/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

include protocol PPluginInstance;
include protocol PPluginScriptableObject;
include protocol PCrashReporter;
include protocol PContent;
include ProfilerTypes;

using NPError from "npapi.h";
using NPNVariable from "npapi.h";
using mozilla::dom::NativeThreadId from "mozilla/dom/TabMessageUtils.h";
using class mac_plugin_interposing::NSCursorInfo from "mozilla/plugins/PluginMessageUtils.h";
using struct nsID from "nsID.h";
using struct mozilla::plugins::NPAudioDeviceChangeDetailsIPC from "mozilla/plugins/PluginMessageUtils.h";

namespace mozilla {
namespace plugins {

struct PluginSettings
{
  // These settings correspond to NPNVariable. They are fetched from
  // mozilla::plugins::parent::_getvalue.
  bool javascriptEnabled;
  bool asdEnabled;
  bool isOffline;
  bool supportsXembed;
  bool supportsWindowless;

  // These settings come from elsewhere.
  nsCString userAgent;
  bool nativeCursorsSupported;
};

intr protocol PPluginModule
{
  bridges PContent, PPluginModule;

  manages PPluginInstance;
  manages PCrashReporter;

both:
  // Window-specific message which instructs the interrupt mechanism to enter
  // a nested event loop for the current interrupt call.
  async ProcessNativeEventsInInterruptCall();

child:
  async DisableFlashProtectedMode();

  // Sync query to check if a Flash library indicates it
  // supports async rendering mode.
  intr ModuleSupportsAsyncRender()
    returns (bool result);

  // Forces the child process to update its plugin function table.
  intr NP_GetEntryPoints()
    returns (NPError rv);

  intr NP_Initialize(PluginSettings settings)
    returns (NPError rv);

  async AsyncNP_Initialize(PluginSettings settings);

  async PPluginInstance(nsCString aMimeType,
                        uint16_t aMode,
                        nsCString[] aNames,
                        nsCString[] aValues);

  // Implements the synchronous version of NPP_New for when async plugin init
  // is preffed off.
  intr SyncNPP_New(PPluginInstance aActor)
    returns (NPError rv);

  // Implements the async plugin init version of NPP_New.
  async AsyncNPP_New(PPluginInstance aActor);

  intr NP_Shutdown()
    returns (NPError rv);

  intr OptionalFunctionsSupported()
    returns (bool aURLRedirectNotify, bool aClearSiteData,
             bool aGetSitesWithData);

  async NPP_ClearSiteData(nsCString site, uint64_t flags, uint64_t maxAge, uint64_t aCallbackId);

  async NPP_GetSitesWithData(uint64_t aCallbackId);

  // Windows specific message to set up an audio session in the plugin process
  async SetAudioSessionData(nsID aID,
                            nsString aDisplayName,
                            nsString aIconPath);

  async SetParentHangTimeout(uint32_t seconds);

  intr PCrashReporter()
    returns (NativeThreadId tid, uint32_t processType);

  /**
   * Control the Gecko Profiler in the plugin process.
   */
  async StartProfiler(ProfilerInitParams params);
  async StopProfiler();

  async GatherProfile();

  async SettingChanged(PluginSettings settings);

  async NPP_SetValue_NPNVaudioDeviceChangeDetails(NPAudioDeviceChangeDetailsIPC changeDetails);

parent:
  async NP_InitializeResult(NPError aError);

  /**
   * This message is only used on X11 platforms.
   *
   * Send a dup of the plugin process's X socket to the parent
   * process.  In theory, this scheme keeps the plugin's X resources
   * around until after both the plugin process shuts down *and* the
   * parent process closes the dup fd.  This is used to prevent the
   * parent process from crashing on X errors if, e.g., the plugin
   * crashes *just before* a repaint and the parent process tries to
   * use the newly-invalid surface.
   */
  async BackUpXResources(FileDescriptor aXSocketFd);

  // Wake up and process a few native events.  Periodically called by
  // Gtk-specific code upon detecting that the plugin process has
  // entered a nested event loop.  If the browser doesn't process
  // native events, then "livelock" and some other glitches can occur.
  intr ProcessSomeEvents();

  // OS X Specific calls to manage the plugin's window
  // when interposing system calls.
  async PluginShowWindow(uint32_t aWindowId, bool aModal,
                         int32_t aX, int32_t aY,
                         size_t aWidth, size_t aHeight);
  async PluginHideWindow(uint32_t aWindowId);

  // OS X Specific calls to allow the plugin to manage the cursor.
  async SetCursor(NSCursorInfo cursorInfo);
  async ShowCursor(bool show);
  async PushCursor(NSCursorInfo cursorInfo);
  async PopCursor();

  sync NPN_SetException(nsCString message);

  async NPN_ReloadPlugins(bool aReloadPages);

  // Notifies the chrome process that a PluginModuleChild linked to a content
  // process was destroyed. The chrome process may choose to asynchronously shut
  // down the plugin process in response.
  async NotifyContentModuleDestroyed();

  async Profile(nsCString aProfile);

  // Answers to request about site data
  async ReturnClearSiteData(NPError aRv, uint64_t aCallbackId);

  async ReturnSitesWithData(nsCString[] aSites, uint64_t aCallbackId);

  intr GetKeyState(int32_t aVirtKey)
    returns (int16_t aState);

  intr NPN_SetValue_NPPVpluginRequiresAudioDeviceChanges(bool shouldRegister)
    returns (NPError result);
};

} // namespace plugins
} // namespace mozilla