path: root/dom/plugins/ipc/PluginModuleChild.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=4 et : */
/* 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 "mozilla/plugins/PluginModuleChild.h"

/* This must occur *after* plugins/PluginModuleChild.h to avoid typedefs
 * conflicts. */
#include "mozilla/ArrayUtils.h"

#include "mozilla/ipc/MessageChannel.h"

#ifdef MOZ_WIDGET_GTK
#  include <gtk/gtk.h>
#  include <gdk/gdkx.h>
#endif

#include "nsIFile.h"

#include "pratom.h"
#include "nsDebug.h"
#include "nsCOMPtr.h"
#include "nsPluginsDir.h"
#include "nsXULAppAPI.h"

#ifdef MOZ_X11
#  include "nsX11ErrorHandler.h"
#  include "mozilla/X11Util.h"
#endif

#include "mozilla/ipc/CrashReporterClient.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProcessChild.h"
#include "mozilla/plugins/PluginInstanceChild.h"
#include "mozilla/plugins/StreamNotifyChild.h"
#include "mozilla/plugins/BrowserStreamChild.h"
#include "mozilla/Sprintf.h"
#include "mozilla/Unused.h"

#include "nsNPAPIPlugin.h"
#include "FunctionHook.h"
#include "FunctionBrokerChild.h"

#ifdef XP_WIN
#  include "mozilla/widget/AudioSession.h"
#  include <knownfolders.h>
#endif

#ifdef MOZ_WIDGET_COCOA
#  include "PluginInterposeOSX.h"
#  include "PluginUtilsOSX.h"
#endif

#ifdef MOZ_GECKO_PROFILER
#  include "ChildProfilerController.h"
#endif

#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
#  include "mozilla/Sandbox.h"
#endif

using namespace mozilla;
using namespace mozilla::ipc;
using namespace mozilla::plugins;
using namespace mozilla::widget;

#if defined(XP_WIN)
const wchar_t* kFlashFullscreenClass = L"ShockwaveFlashFullScreen";
#  if defined(MOZ_SANDBOX)
std::wstring sRoamingPath;
#  endif
#endif

namespace {
// see PluginModuleChild::GetChrome()
PluginModuleChild* gChromeInstance = nullptr;
}  // namespace

#ifdef XP_WIN
// Used with fix for flash fullscreen window loosing focus.
static bool gDelayFlashFocusReplyUntilEval = false;
#endif

/* static */
bool PluginModuleChild::CreateForContentProcess(
    Endpoint<PPluginModuleChild>&& aEndpoint) {
  auto* child = new PluginModuleChild(false);
  return child->InitForContent(std::move(aEndpoint));
}

PluginModuleChild::PluginModuleChild(bool aIsChrome)
    : mLibrary(0),
      mPluginFilename(""),
      mQuirks(QUIRKS_NOT_INITIALIZED),
      mIsChrome(aIsChrome),
      mHasShutdown(false),
      mShutdownFunc(0),
      mInitializeFunc(0)
#if defined(OS_WIN) || defined(OS_MACOSX)
      ,
      mGetEntryPointsFunc(0)
#elif defined(MOZ_WIDGET_GTK)
      ,
      mNestedLoopTimerId(0)
#endif
#ifdef OS_WIN
      ,
      mNestedEventHook(nullptr),
      mGlobalCallWndProcHook(nullptr),
      mAsyncRenderSupport(false)
#endif
#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
      ,
      mFlashSandboxLevel(0),
      mEnableFlashSandboxLogging(false)
#endif
{
  memset(&mFunctions, 0, sizeof(mFunctions));
  if (mIsChrome) {
    MOZ_ASSERT(!gChromeInstance);
    gChromeInstance = this;
  }

#ifdef XP_MACOSX
  if (aIsChrome) {
    mac_plugin_interposing::child::SetUpCocoaInterposing();
  }
#endif
}

PluginModuleChild::~PluginModuleChild() {
  if (mIsChrome) {
    MOZ_ASSERT(gChromeInstance == this);

    // We don't unload the plugin library in case it uses atexit handlers or
    // other similar hooks.

    DeinitGraphics();
    PluginScriptableObjectChild::ClearIdentifiers();

    gChromeInstance = nullptr;
  }
}

// static
PluginModuleChild* PluginModuleChild::GetChrome() {
  // A special PluginModuleChild instance that talks to the chrome process
  // during startup and shutdown. Synchronous messages to or from this actor
  // should be avoided because they may lead to hangs.
  MOZ_ASSERT(gChromeInstance);
  return gChromeInstance;
}

void PluginModuleChild::CommonInit() {
  PLUGIN_LOG_DEBUG_METHOD;

  // Request Windows message deferral behavior on our channel. This
  // applies to the top level and all sub plugin protocols since they
  // all share the same channel.
  // Bug 1090573 - Don't do this for connections to content processes.
  GetIPCChannel()->SetChannelFlags(
      MessageChannel::REQUIRE_DEFERRED_MESSAGE_PROTECTION);

  memset((void*)&mFunctions, 0, sizeof(mFunctions));
  mFunctions.size = sizeof(mFunctions);
  mFunctions.version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
}

bool PluginModuleChild::InitForContent(
    Endpoint<PPluginModuleChild>&& aEndpoint) {
  CommonInit();

  if (!aEndpoint.Bind(this)) {
    return false;
  }

  mLibrary = GetChrome()->mLibrary;
  mFunctions = GetChrome()->mFunctions;

  return true;
}

mozilla::ipc::IPCResult PluginModuleChild::RecvInitProfiler(
    Endpoint<mozilla::PProfilerChild>&& aEndpoint) {
#ifdef MOZ_GECKO_PROFILER
  mProfilerController = ChildProfilerController::Create(std::move(aEndpoint));
#endif
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::RecvDisableFlashProtectedMode() {
  MOZ_ASSERT(mIsChrome);
#ifdef XP_WIN
  FunctionHook::HookProtectedMode();
#else
  MOZ_ASSERT(false, "Should not be called");
#endif
  return IPC_OK();
}

#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
void PluginModuleChild::EnableFlashSandbox(int aLevel,
                                           bool aShouldEnableLogging) {
  mFlashSandboxLevel = aLevel;
  mEnableFlashSandboxLogging = aShouldEnableLogging;
}
#endif

#if defined(OS_WIN) && defined(MOZ_SANDBOX)
/* static */
void PluginModuleChild::SetFlashRoamingPath(const std::wstring& aRoamingPath) {
  MOZ_ASSERT(sRoamingPath.empty());
  sRoamingPath = aRoamingPath;
}

/* static */ std::wstring PluginModuleChild::GetFlashRoamingPath() {
  return sRoamingPath;
}
#endif

bool PluginModuleChild::InitForChrome(const std::string& aPluginFilename,
                                      base::ProcessId aParentPid,
                                      MessageLoop* aIOLoop,
                                      UniquePtr<IPC::Channel> aChannel) {
  NS_ASSERTION(aChannel, "need a channel");

#if defined(OS_WIN) && defined(MOZ_SANDBOX)
  MOZ_ASSERT(!sRoamingPath.empty(),
             "Should have already called SetFlashRoamingPath");
#endif

  if (!InitGraphics()) return false;

  mPluginFilename = aPluginFilename.c_str();
  nsCOMPtr<nsIFile> localFile;
  NS_NewLocalFile(NS_ConvertUTF8toUTF16(mPluginFilename), true,
                  getter_AddRefs(localFile));

  if (!localFile) return false;

  bool exists;
  localFile->Exists(&exists);
  NS_ASSERTION(exists, "plugin file ain't there");

  nsPluginFile pluginFile(localFile);

  nsPluginInfo info = nsPluginInfo();
  if (NS_FAILED(pluginFile.GetPluginInfo(info, &mLibrary))) {
    return false;
  }

#if defined(XP_WIN)
  // XXX quirks isn't initialized yet
  mAsyncRenderSupport = info.fSupportsAsyncRender;
#endif
#if defined(MOZ_X11)
  constexpr auto flash10Head = "Shockwave Flash 10."_ns;
  if (StringBeginsWith(nsDependentCString(info.fDescription), flash10Head)) {
    AddQuirk(QUIRK_FLASH_EXPOSE_COORD_TRANSLATION);
  }
#endif
#if defined(XP_MACOSX)
  const char* namePrefix = "Plugin Content";
  char nameBuffer[80];
  SprintfLiteral(nameBuffer, "%s (%s)", namePrefix, info.fName);
  mozilla::plugins::PluginUtilsOSX::SetProcessName(nameBuffer);
#endif
  pluginFile.FreePluginInfo(info);
#if defined(MOZ_X11) || defined(XP_MACOSX)
  if (!mLibrary)
#endif
  {
    nsresult rv = pluginFile.LoadPlugin(&mLibrary);
    if (NS_FAILED(rv)) return false;
  }
  NS_ASSERTION(mLibrary, "couldn't open shared object");

  CommonInit();

  if (!Open(std::move(aChannel), aParentPid, aIOLoop)) {
    return false;
  }

  GetIPCChannel()->SetAbortOnError(true);

#if defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)
  mShutdownFunc =
      (NP_PLUGINSHUTDOWN)PR_FindFunctionSymbol(mLibrary, "NP_Shutdown");

  // create the new plugin handler

  mInitializeFunc =
      (NP_PLUGINUNIXINIT)PR_FindFunctionSymbol(mLibrary, "NP_Initialize");
  NS_ASSERTION(mInitializeFunc, "couldn't find NP_Initialize()");

#elif defined(OS_WIN) || defined(OS_MACOSX)
  mShutdownFunc =
      (NP_PLUGINSHUTDOWN)PR_FindFunctionSymbol(mLibrary, "NP_Shutdown");

  mGetEntryPointsFunc =
      (NP_GETENTRYPOINTS)PR_FindSymbol(mLibrary, "NP_GetEntryPoints");
  NS_ENSURE_TRUE(mGetEntryPointsFunc, false);

  mInitializeFunc =
      (NP_PLUGININIT)PR_FindFunctionSymbol(mLibrary, "NP_Initialize");
  NS_ENSURE_TRUE(mInitializeFunc, false);
#else

#  error Please copy the initialization code from nsNPAPIPlugin.cpp

#endif

#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
  if (mFlashSandboxLevel > 0) {
    MacSandboxInfo flashSandboxInfo;
    flashSandboxInfo.type = MacSandboxType_Flash;
    flashSandboxInfo.pluginBinaryPath = aPluginFilename;
    flashSandboxInfo.level = mFlashSandboxLevel;
    flashSandboxInfo.shouldLog = mEnableFlashSandboxLogging;

    std::string sbError;
    if (!mozilla::StartMacSandbox(flashSandboxInfo, sbError)) {
      fprintf(stderr, "Failed to start sandbox:\n%s\n", sbError.c_str());
      return false;
    }
  }
#endif

  return true;
}

#if defined(MOZ_WIDGET_GTK)

typedef void (*GObjectDisposeFn)(GObject*);
typedef gboolean (*GtkWidgetScrollEventFn)(GtkWidget*, GdkEventScroll*);
typedef void (*GtkPlugEmbeddedFn)(GtkPlug*);

static GObjectDisposeFn real_gtk_plug_dispose;
static GtkPlugEmbeddedFn real_gtk_plug_embedded;

static void undo_bogus_unref(gpointer data, GObject* object,
                             gboolean is_last_ref) {
  if (!is_last_ref)  // recursion in g_object_ref
    return;

  g_object_ref(object);
}

static void wrap_gtk_plug_dispose(GObject* object) {
  // Work around Flash Player bug described in bug 538914.
  //
  // This function is called during gtk_widget_destroy and/or before
  // the object's last reference is removed.  A reference to the
  // object is held during the call so the ref count should not drop
  // to zero.  However, Flash Player tries to destroy the GtkPlug
  // using g_object_unref instead of gtk_widget_destroy.  The
  // reference that Flash is removing actually belongs to the
  // GtkPlug.  During real_gtk_plug_dispose, the GtkPlug removes its
  // reference.
  //
  // A toggle ref is added to prevent premature deletion of the object
  // caused by Flash Player's extra unref, and to detect when there are
  // unexpectedly no other references.
  g_object_add_toggle_ref(object, undo_bogus_unref, nullptr);
  (*real_gtk_plug_dispose)(object);
  g_object_remove_toggle_ref(object, undo_bogus_unref, nullptr);
}

static gboolean gtk_plug_scroll_event(GtkWidget* widget,
                                      GdkEventScroll* gdk_event) {
  if (!gtk_widget_is_toplevel(widget))  // in same process as its GtkSocket
    return FALSE;  // event not handled; propagate to GtkSocket

  GdkWindow* socket_window = gtk_plug_get_socket_window(GTK_PLUG(widget));
  if (!socket_window) return FALSE;

  // Propagate the event to the embedder.
  GdkScreen* screen = gdk_window_get_screen(socket_window);
  GdkWindow* plug_window = gtk_widget_get_window(widget);
  GdkWindow* event_window = gdk_event->window;
  gint x = gdk_event->x;
  gint y = gdk_event->y;
  unsigned int button;
  unsigned int button_mask = 0;
  XEvent xevent;
  Display* dpy = GDK_WINDOW_XDISPLAY(socket_window);

  /* Translate the event coordinates to the plug window,
   * which should be aligned with the socket window.
   */
  while (event_window != plug_window) {
    gint dx, dy;

    gdk_window_get_position(event_window, &dx, &dy);
    x += dx;
    y += dy;

    event_window = gdk_window_get_parent(event_window);
    if (!event_window) return FALSE;
  }

  switch (gdk_event->direction) {
    case GDK_SCROLL_UP:
      button = 4;
      button_mask = Button4Mask;
      break;
    case GDK_SCROLL_DOWN:
      button = 5;
      button_mask = Button5Mask;
      break;
    case GDK_SCROLL_LEFT:
      button = 6;
      break;
    case GDK_SCROLL_RIGHT:
      button = 7;
      break;
    default:
      return FALSE;  // unknown GdkScrollDirection
  }

  memset(&xevent, 0, sizeof(xevent));
  xevent.xbutton.type = ButtonPress;
  xevent.xbutton.window = gdk_x11_window_get_xid(socket_window);
  xevent.xbutton.root =
      gdk_x11_window_get_xid(gdk_screen_get_root_window(screen));
  xevent.xbutton.subwindow = gdk_x11_window_get_xid(plug_window);
  xevent.xbutton.time = gdk_event->time;
  xevent.xbutton.x = x;
  xevent.xbutton.y = y;
  xevent.xbutton.x_root = gdk_event->x_root;
  xevent.xbutton.y_root = gdk_event->y_root;
  xevent.xbutton.state = gdk_event->state;
  xevent.xbutton.button = button;
  xevent.xbutton.same_screen = X11True;

  gdk_error_trap_push();

  XSendEvent(dpy, xevent.xbutton.window, X11True, ButtonPressMask, &xevent);

  xevent.xbutton.type = ButtonRelease;
  xevent.xbutton.state |= button_mask;
  XSendEvent(dpy, xevent.xbutton.window, X11True, ButtonReleaseMask, &xevent);

  gdk_display_sync(gdk_screen_get_display(screen));
  gdk_error_trap_pop();

  return TRUE;  // event handled
}

static void wrap_gtk_plug_embedded(GtkPlug* plug) {
  GdkWindow* socket_window = gtk_plug_get_socket_window(plug);
  if (socket_window) {
    if (gtk_check_version(2, 18, 7) != nullptr  // older
        && g_object_get_data(G_OBJECT(socket_window),
                             "moz-existed-before-set-window")) {
      // Add missing reference for
      // https://bugzilla.gnome.org/show_bug.cgi?id=607061
      g_object_ref(socket_window);
    }

    // Ensure the window exists to make this GtkPlug behave like an
    // in-process GtkPlug for Flash Player.  (Bugs 561308 and 539138).
    gtk_widget_realize(GTK_WIDGET(plug));
  }

  if (*real_gtk_plug_embedded) {
    (*real_gtk_plug_embedded)(plug);
  }
}

//
// The next four constants are knobs that can be tuned.  They trade
// off potential UI lag from delayed event processing with CPU time.
//
static const gint kNestedLoopDetectorPriority = G_PRIORITY_HIGH_IDLE;
// 90ms so that we can hopefully break livelocks before the user
// notices UI lag (100ms)
static const guint kNestedLoopDetectorIntervalMs = 90;

static const gint kBrowserEventPriority = G_PRIORITY_HIGH_IDLE;
static const guint kBrowserEventIntervalMs = 10;

// static
gboolean PluginModuleChild::DetectNestedEventLoop(gpointer data) {
  PluginModuleChild* pmc = static_cast<PluginModuleChild*>(data);

  MOZ_ASSERT(0 != pmc->mNestedLoopTimerId, "callback after descheduling");
  MOZ_ASSERT(pmc->mTopLoopDepth < g_main_depth(),
             "not canceled before returning to main event loop!");

  PLUGIN_LOG_DEBUG(("Detected nested glib event loop"));

  // just detected a nested loop; start a timer that will
  // periodically rpc-call back into the browser and process some
  // events
  pmc->mNestedLoopTimerId = g_timeout_add_full(
      kBrowserEventPriority, kBrowserEventIntervalMs,
      PluginModuleChild::ProcessBrowserEvents, data, nullptr);
  // cancel the nested-loop detection timer
  return FALSE;
}

// static
gboolean PluginModuleChild::ProcessBrowserEvents(gpointer data) {
  PluginModuleChild* pmc = static_cast<PluginModuleChild*>(data);

  MOZ_ASSERT(pmc->mTopLoopDepth < g_main_depth(),
             "not canceled before returning to main event loop!");

  pmc->CallProcessSomeEvents();

  return TRUE;
}

void PluginModuleChild::EnteredCxxStack() {
  MOZ_ASSERT(0 == mNestedLoopTimerId, "previous timer not descheduled");

  mNestedLoopTimerId = g_timeout_add_full(
      kNestedLoopDetectorPriority, kNestedLoopDetectorIntervalMs,
      PluginModuleChild::DetectNestedEventLoop, this, nullptr);

#  ifdef DEBUG
  mTopLoopDepth = g_main_depth();
#  endif
}

void PluginModuleChild::ExitedCxxStack() {
  MOZ_ASSERT(0 < mNestedLoopTimerId, "nested loop timeout not scheduled");

  g_source_remove(mNestedLoopTimerId);
  mNestedLoopTimerId = 0;
}

#endif

mozilla::ipc::IPCResult PluginModuleChild::RecvSetParentHangTimeout(
    const uint32_t& aSeconds) {
#ifdef XP_WIN
  SetReplyTimeoutMs(((aSeconds > 0) ? (1000 * aSeconds) : 0));
#endif
  return IPC_OK();
}

bool PluginModuleChild::ShouldContinueFromReplyTimeout() {
#ifdef XP_WIN
  MOZ_CRASH("terminating child process");
#endif
  return true;
}

bool PluginModuleChild::InitGraphics() {
#if defined(MOZ_WIDGET_GTK)
  // Work around plugins that don't interact well with GDK
  // client-side windows.
  PR_SetEnv("GDK_NATIVE_WINDOWS=1");

  gtk_init(0, 0);

  // GtkPlug is a static class so will leak anyway but this ref makes sure.
  gpointer gtk_plug_class = g_type_class_ref(GTK_TYPE_PLUG);

  // The dispose method is a good place to hook into the destruction process
  // because the reference count should be 1 the last time dispose is
  // called.  (Toggle references wouldn't detect if the reference count
  // might be higher.)
  GObjectDisposeFn* dispose = &G_OBJECT_CLASS(gtk_plug_class)->dispose;
  MOZ_ASSERT(*dispose != wrap_gtk_plug_dispose, "InitGraphics called twice");
  real_gtk_plug_dispose = *dispose;
  *dispose = wrap_gtk_plug_dispose;

  // If we ever stop setting GDK_NATIVE_WINDOWS, we'll also need to
  // gtk_widget_add_events GDK_SCROLL_MASK or GDK client-side windows will
  // not tell us about the scroll events that it intercepts.  With native
  // windows, this is called when GDK intercepts the events; if GDK doesn't
  // intercept the events, then the X server will instead send them directly
  // to an ancestor (embedder) window.
  GtkWidgetScrollEventFn* scroll_event =
      &GTK_WIDGET_CLASS(gtk_plug_class)->scroll_event;
  if (!*scroll_event) {
    *scroll_event = gtk_plug_scroll_event;
  }

  GtkPlugEmbeddedFn* embedded = &GTK_PLUG_CLASS(gtk_plug_class)->embedded;
  real_gtk_plug_embedded = *embedded;
  *embedded = wrap_gtk_plug_embedded;

#else
  // may not be necessary on all platforms
#endif
#ifdef MOZ_X11
  // Do this after initializing GDK, or GDK will install its own handler.
  InstallX11ErrorHandler();
#endif
  return true;
}

void PluginModuleChild::DeinitGraphics() {
#if defined(MOZ_X11) && defined(NS_FREE_PERMANENT_DATA)
  // We free some data off of XDisplay close hooks, ensure they're
  // run.  Closing the display is pretty scary, so we only do it to
  // silence leak checkers.
  XCloseDisplay(DefaultXDisplay());
#endif
}

NPError PluginModuleChild::NP_Shutdown() {
  AssertPluginThread();
  MOZ_ASSERT(mIsChrome);

  if (mHasShutdown) {
    return NPERR_NO_ERROR;
  }

#if defined XP_WIN
  mozilla::widget::StopAudioSession();
#endif

  // the PluginModuleParent shuts down this process after this interrupt
  // call pops off its stack

  NPError rv = mShutdownFunc ? mShutdownFunc() : NPERR_NO_ERROR;

  // weakly guard against re-entry after NP_Shutdown
  memset(&mFunctions, 0, sizeof(mFunctions));

#ifdef OS_WIN
  ResetEventHooks();
#endif

  GetIPCChannel()->SetAbortOnError(false);

  mHasShutdown = true;

  return rv;
}

mozilla::ipc::IPCResult PluginModuleChild::AnswerNP_Shutdown(NPError* rv) {
  *rv = NP_Shutdown();
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::AnswerOptionalFunctionsSupported(
    bool* aURLRedirectNotify, bool* aClearSiteData, bool* aGetSitesWithData) {
  *aURLRedirectNotify = !!mFunctions.urlredirectnotify;
  *aClearSiteData = !!mFunctions.clearsitedata;
  *aGetSitesWithData = !!mFunctions.getsiteswithdata;
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::RecvNPP_ClearSiteData(
    const nsCString& aSite, const uint64_t& aFlags, const uint64_t& aMaxAge,
    const uint64_t& aCallbackId) {
  NPError result =
      mFunctions.clearsitedata(NullableStringGet(aSite), aFlags, aMaxAge);
  SendReturnClearSiteData(result, aCallbackId);
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::RecvNPP_GetSitesWithData(
    const uint64_t& aCallbackId) {
  char** result = mFunctions.getsiteswithdata();
  nsTArray<nsCString> array;
  if (!result) {
    SendReturnSitesWithData(array, aCallbackId);
    return IPC_OK();
  }
  char** iterator = result;
  while (*iterator) {
    array.AppendElement(*iterator);
    free(*iterator);
    ++iterator;
  }
  SendReturnSitesWithData(array, aCallbackId);
  free(result);
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::RecvSetAudioSessionData(
    const nsID& aId, const nsString& aDisplayName, const nsString& aIconPath) {
#if !defined XP_WIN
  MOZ_CRASH("Not Reached!");
#else
  nsresult rv =
      mozilla::widget::RecvAudioSessionData(aId, aDisplayName, aIconPath);
  NS_ENSURE_SUCCESS(rv, IPC_OK());  // Bail early if this fails

  // Ignore failures here; we can't really do anything about them
  mozilla::widget::StartAudioSession();
  return IPC_OK();
#endif
}

mozilla::ipc::IPCResult PluginModuleChild::RecvInitPluginModuleChild(
    Endpoint<PPluginModuleChild>&& aEndpoint) {
  if (!CreateForContentProcess(std::move(aEndpoint))) {
    return IPC_FAIL(this, "CreateForContentProcess failed");
  }
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::RecvInitPluginFunctionBroker(
    Endpoint<PFunctionBrokerChild>&& aEndpoint) {
#if defined(XP_WIN)
  MOZ_ASSERT(mIsChrome);
  if (!FunctionBrokerChild::Initialize(std::move(aEndpoint))) {
    return IPC_FAIL(
        this, "InitPluginFunctionBroker failed to initialize broker child.");
  }
  return IPC_OK();
#else
  return IPC_FAIL(this,
                  "InitPluginFunctionBroker not supported on this platform.");
#endif
}

mozilla::ipc::IPCResult PluginModuleChild::AnswerInitCrashReporter(
    mozilla::dom::NativeThreadId* aOutId) {
  CrashReporterClient::InitSingleton();
  *aOutId = CrashReporter::CurrentThreadId();

  return IPC_OK();
}

void PluginModuleChild::ActorDestroy(ActorDestroyReason why) {
#ifdef MOZ_GECKO_PROFILER
  if (mProfilerController) {
    mProfilerController->Shutdown();
    mProfilerController = nullptr;
  }
#endif

  if (!mIsChrome) {
    PluginModuleChild* chromeInstance = PluginModuleChild::GetChrome();
    if (chromeInstance) {
      chromeInstance->SendNotifyContentModuleDestroyed();
    }

    // Destroy ourselves once we finish other teardown activities.
    RefPtr<DeleteTask<PluginModuleChild>> task =
        new DeleteTask<PluginModuleChild>(this);
    MessageLoop::current()->PostTask(task.forget());
    return;
  }

  if (AbnormalShutdown == why) {
    NS_WARNING("shutting down early because of crash!");
    ProcessChild::QuickExit();
  }

  if (!mHasShutdown) {
    MOZ_ASSERT(gChromeInstance == this);
    NP_Shutdown();
  }

#if defined(XP_WIN)
  FunctionBrokerChild::Destroy();
  FunctionHook::ClearDllInterceptorCache();
#endif

  // doesn't matter why we're being destroyed; it's up to us to
  // initiate (clean) shutdown
  CrashReporterClient::DestroySingleton();

  XRE_ShutdownChildProcess();
}

void PluginModuleChild::CleanUp() {}

const char* PluginModuleChild::GetUserAgent() {
  return NullableStringGet(Settings().userAgent());
}

//-----------------------------------------------------------------------------
// FIXME/cjones: just getting this out of the way for the moment ...

namespace mozilla::plugins::child {

static NPError _requestread(NPStream* pstream, NPByteRange* rangeList);

static NPError _geturlnotify(NPP aNPP, const char* relativeURL,
                             const char* target, void* notifyData);

static NPError _getvalue(NPP aNPP, NPNVariable variable, void* r_value);

static NPError _setvalue(NPP aNPP, NPPVariable variable, void* r_value);

static NPError _geturl(NPP aNPP, const char* relativeURL, const char* target);

static NPError _posturlnotify(NPP aNPP, const char* relativeURL,
                              const char* target, uint32_t len, const char* buf,
                              NPBool file, void* notifyData);

static NPError _posturl(NPP aNPP, const char* relativeURL, const char* target,
                        uint32_t len, const char* buf, NPBool file);

static void _status(NPP aNPP, const char* message);

static void _memfree(void* ptr);

static uint32_t _memflush(uint32_t size);

static void _reloadplugins(NPBool reloadPages);

static void _invalidaterect(NPP aNPP, NPRect* invalidRect);

static void _invalidateregion(NPP aNPP, NPRegion invalidRegion);

static void _forceredraw(NPP aNPP);

static const char* _useragent(NPP aNPP);

static void* _memalloc(uint32_t size);

// Deprecated entry points for the old Java plugin.
static void* /* OJI type: JRIEnv* */
_getjavaenv(void);

// Deprecated entry points for the old Java plugin.
static void* /* OJI type: jref */
_getjavapeer(NPP aNPP);

static bool _invoke(NPP aNPP, NPObject* npobj, NPIdentifier method,
                    const NPVariant* args, uint32_t argCount,
                    NPVariant* result);

static bool _invokedefault(NPP aNPP, NPObject* npobj, const NPVariant* args,
                           uint32_t argCount, NPVariant* result);

static bool _evaluate(NPP aNPP, NPObject* npobj, NPString* script,
                      NPVariant* result);

static bool _getproperty(NPP aNPP, NPObject* npobj, NPIdentifier property,
                         NPVariant* result);

static bool _setproperty(NPP aNPP, NPObject* npobj, NPIdentifier property,
                         const NPVariant* value);

static bool _removeproperty(NPP aNPP, NPObject* npobj, NPIdentifier property);

static bool _hasproperty(NPP aNPP, NPObject* npobj, NPIdentifier propertyName);

static bool _hasmethod(NPP aNPP, NPObject* npobj, NPIdentifier methodName);

static bool _enumerate(NPP aNPP, NPObject* npobj, NPIdentifier** identifier,
                       uint32_t* count);

static bool _construct(NPP aNPP, NPObject* npobj, const NPVariant* args,
                       uint32_t argCount, NPVariant* result);

static void _releasevariantvalue(NPVariant* variant);

static void _setexception(NPObject* npobj, const NPUTF8* message);

static void _pushpopupsenabledstate(NPP aNPP, NPBool enabled);

static void _poppopupsenabledstate(NPP aNPP);

static NPError _getvalueforurl(NPP npp, NPNURLVariable variable,
                               const char* url, char** value, uint32_t* len);

static NPError _setvalueforurl(NPP npp, NPNURLVariable variable,
                               const char* url, const char* value,
                               uint32_t len);

static uint32_t _scheduletimer(NPP instance, uint32_t interval, NPBool repeat,
                               void (*timerFunc)(NPP npp, uint32_t timerID));

static void _unscheduletimer(NPP instance, uint32_t timerID);

static NPError _popupcontextmenu(NPP instance, NPMenu* menu);

static NPBool _convertpoint(NPP instance, double sourceX, double sourceY,
                            NPCoordinateSpace sourceSpace, double* destX,
                            double* destY, NPCoordinateSpace destSpace);

static void _urlredirectresponse(NPP instance, void* notifyData, NPBool allow);

static NPError _initasyncsurface(NPP instance, NPSize* size,
                                 NPImageFormat format, void* initData,
                                 NPAsyncSurface* surface);

static NPError _finalizeasyncsurface(NPP instance, NPAsyncSurface* surface);

static void _setcurrentasyncsurface(NPP instance, NPAsyncSurface* surface,
                                    NPRect* changed);

}  // namespace mozilla::plugins::child

const NPNetscapeFuncs PluginModuleChild::sBrowserFuncs = {
    sizeof(sBrowserFuncs),
    (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR,
    mozilla::plugins::child::_geturl,
    mozilla::plugins::child::_posturl,
    mozilla::plugins::child::_requestread,
    nullptr,  // _newstream, unimplemented
    nullptr,  // _write, unimplemented
    nullptr,  // _destroystream, unimplemented
    mozilla::plugins::child::_status,
    mozilla::plugins::child::_useragent,
    mozilla::plugins::child::_memalloc,
    mozilla::plugins::child::_memfree,
    mozilla::plugins::child::_memflush,
    mozilla::plugins::child::_reloadplugins,
    mozilla::plugins::child::_getjavaenv,
    mozilla::plugins::child::_getjavapeer,
    mozilla::plugins::child::_geturlnotify,
    mozilla::plugins::child::_posturlnotify,
    mozilla::plugins::child::_getvalue,
    mozilla::plugins::child::_setvalue,
    mozilla::plugins::child::_invalidaterect,
    mozilla::plugins::child::_invalidateregion,
    mozilla::plugins::child::_forceredraw,
    PluginModuleChild::NPN_GetStringIdentifier,
    PluginModuleChild::NPN_GetStringIdentifiers,
    PluginModuleChild::NPN_GetIntIdentifier,
    PluginModuleChild::NPN_IdentifierIsString,
    PluginModuleChild::NPN_UTF8FromIdentifier,
    PluginModuleChild::NPN_IntFromIdentifier,
    PluginModuleChild::NPN_CreateObject,
    PluginModuleChild::NPN_RetainObject,
    PluginModuleChild::NPN_ReleaseObject,
    mozilla::plugins::child::_invoke,
    mozilla::plugins::child::_invokedefault,
    mozilla::plugins::child::_evaluate,
    mozilla::plugins::child::_getproperty,
    mozilla::plugins::child::_setproperty,
    mozilla::plugins::child::_removeproperty,
    mozilla::plugins::child::_hasproperty,
    mozilla::plugins::child::_hasmethod,
    mozilla::plugins::child::_releasevariantvalue,
    mozilla::plugins::child::_setexception,
    mozilla::plugins::child::_pushpopupsenabledstate,
    mozilla::plugins::child::_poppopupsenabledstate,
    mozilla::plugins::child::_enumerate,
    nullptr,  // pluginthreadasynccall, not used
    mozilla::plugins::child::_construct,
    mozilla::plugins::child::_getvalueforurl,
    mozilla::plugins::child::_setvalueforurl,
    nullptr,  // NPN GetAuthenticationInfo, not supported
    mozilla::plugins::child::_scheduletimer,
    mozilla::plugins::child::_unscheduletimer,
    mozilla::plugins::child::_popupcontextmenu,
    mozilla::plugins::child::_convertpoint,
    nullptr,  // handleevent, unimplemented
    nullptr,  // unfocusinstance, unimplemented
    mozilla::plugins::child::_urlredirectresponse,
    mozilla::plugins::child::_initasyncsurface,
    mozilla::plugins::child::_finalizeasyncsurface,
    mozilla::plugins::child::_setcurrentasyncsurface,
};

PluginInstanceChild* InstCast(NPP aNPP) {
  MOZ_ASSERT(!!(aNPP->ndata), "nil instance");
  return static_cast<PluginInstanceChild*>(aNPP->ndata);
}

namespace mozilla::plugins::child {

NPError _requestread(NPStream* aStream, NPByteRange* aRangeList) {
  return NPERR_STREAM_NOT_SEEKABLE;
}

NPError _geturlnotify(NPP aNPP, const char* aRelativeURL, const char* aTarget,
                      void* aNotifyData) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);

  if (!aNPP)  // nullptr check for nspluginwrapper (bug 561690)
    return NPERR_INVALID_INSTANCE_ERROR;

  nsCString url = NullableString(aRelativeURL);
  auto* sn = new StreamNotifyChild(url);

  NPError err;
  if (!InstCast(aNPP)->CallPStreamNotifyConstructor(
          sn, url, NullableString(aTarget), false, nsCString(), false, &err)) {
    return NPERR_GENERIC_ERROR;
  }

  if (NPERR_NO_ERROR == err) {
    // If NPN_PostURLNotify fails, the parent will immediately send us
    // a PStreamNotifyDestructor, which should not call NPP_URLNotify.
    sn->SetValid(aNotifyData);
  }

  return err;
}

NPError _getvalue(NPP aNPP, NPNVariable aVariable, void* aValue) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);

  switch (aVariable) {
    // Copied from nsNPAPIPlugin.cpp
    case NPNVToolkit:
#if defined(MOZ_WIDGET_GTK)
      *static_cast<NPNToolkitType*>(aValue) = NPNVGtk2;
      return NPERR_NO_ERROR;
#endif
      return NPERR_GENERIC_ERROR;

    case NPNVjavascriptEnabledBool:
      *(NPBool*)aValue =
          PluginModuleChild::GetChrome()->Settings().javascriptEnabled();
      return NPERR_NO_ERROR;
    case NPNVasdEnabledBool:
      *(NPBool*)aValue =
          PluginModuleChild::GetChrome()->Settings().asdEnabled();
      return NPERR_NO_ERROR;
    case NPNVisOfflineBool:
      *(NPBool*)aValue = PluginModuleChild::GetChrome()->Settings().isOffline();
      return NPERR_NO_ERROR;
    case NPNVSupportsXEmbedBool:
      // We don't support windowed xembed any more. But we still deliver
      // events based on X/GTK, not Xt, so we continue to return true
      // (and Flash requires that we return true).
      *(NPBool*)aValue = true;
      return NPERR_NO_ERROR;
    case NPNVSupportsWindowless:
      *(NPBool*)aValue = true;
      return NPERR_NO_ERROR;
#if defined(MOZ_WIDGET_GTK)
    case NPNVxDisplay: {
      if (!aNPP) {
        return NPERR_INVALID_INSTANCE_ERROR;
      }
      return InstCast(aNPP)->NPN_GetValue(aVariable, aValue);
    }
    case NPNVxtAppContext:
      return NPERR_GENERIC_ERROR;
#endif
    default: {
      if (aNPP) {
        return InstCast(aNPP)->NPN_GetValue(aVariable, aValue);
      }

      NS_WARNING("Null NPP!");
      return NPERR_INVALID_INSTANCE_ERROR;
    }
  }

  MOZ_ASSERT_UNREACHABLE("Shouldn't get here!");
  return NPERR_GENERIC_ERROR;
}

NPError _setvalue(NPP aNPP, NPPVariable aVariable, void* aValue) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);
  return InstCast(aNPP)->NPN_SetValue(aVariable, aValue);
}

NPError _geturl(NPP aNPP, const char* aRelativeURL, const char* aTarget) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);

  NPError err;
  InstCast(aNPP)->CallNPN_GetURL(NullableString(aRelativeURL),
                                 NullableString(aTarget), &err);
  return err;
}

NPError _posturlnotify(NPP aNPP, const char* aRelativeURL, const char* aTarget,
                       uint32_t aLength, const char* aBuffer, NPBool aIsFile,
                       void* aNotifyData) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);

  if (!aBuffer) return NPERR_INVALID_PARAM;

  if (aIsFile) {
    PLUGIN_LOG_DEBUG(
        ("NPN_PostURLNotify with file=true is no longer supported"));
    return NPERR_GENERIC_ERROR;
  }

  nsCString url = NullableString(aRelativeURL);
  auto* sn = new StreamNotifyChild(url);

  NPError err;
  if (!InstCast(aNPP)->CallPStreamNotifyConstructor(
          sn, url, NullableString(aTarget), true, nsCString(aBuffer, aLength),
          aIsFile, &err)) {
    return NPERR_GENERIC_ERROR;
  }

  if (NPERR_NO_ERROR == err) {
    // If NPN_PostURLNotify fails, the parent will immediately send us
    // a PStreamNotifyDestructor, which should not call NPP_URLNotify.
    sn->SetValid(aNotifyData);
  }

  return err;
}

NPError _posturl(NPP aNPP, const char* aRelativeURL, const char* aTarget,
                 uint32_t aLength, const char* aBuffer, NPBool aIsFile) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(NPERR_INVALID_PARAM);

  if (aIsFile) {
    PLUGIN_LOG_DEBUG(("NPN_PostURL with file=true is no longer supported"));
    return NPERR_GENERIC_ERROR;
  }
  NPError err;
  // FIXME what should happen when |aBuffer| is null?
  InstCast(aNPP)->CallNPN_PostURL(
      NullableString(aRelativeURL), NullableString(aTarget),
      nsDependentCString(aBuffer, aLength), aIsFile, &err);
  return err;
}

void _status(NPP aNPP, const char* aMessage) {
  // NPN_Status is no longer supported.
}

void _memfree(void* aPtr) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  free(aPtr);
}

uint32_t _memflush(uint32_t aSize) { return 0; }

void _reloadplugins(NPBool aReloadPages) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD_VOID();

  // Send the reload message to all modules. Chrome will need to reload from
  // disk and content will need to request a new list of plugin tags from
  // chrome.
  PluginModuleChild::GetChrome()->SendNPN_ReloadPlugins(!!aReloadPages);
}

void _invalidaterect(NPP aNPP, NPRect* aInvalidRect) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD_VOID();
  // nullptr check for nspluginwrapper (bug 548434)
  if (aNPP) {
    InstCast(aNPP)->InvalidateRect(aInvalidRect);
  }
}

void _invalidateregion(NPP aNPP, NPRegion aInvalidRegion) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD_VOID();
  NS_WARNING("Not yet implemented!");
}

void _forceredraw(NPP aNPP) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD_VOID();

  // We ignore calls to NPN_ForceRedraw. Such calls should
  // never be necessary.
}

const char* _useragent(NPP aNPP) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(nullptr);
  return PluginModuleChild::GetChrome()->GetUserAgent();
}

void* _memalloc(uint32_t aSize) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  return moz_xmalloc(aSize);
}

// Deprecated entry points for the old Java plugin.
void* /* OJI type: JRIEnv* */
_getjavaenv(void) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  return 0;
}

void* /* OJI type: jref */
_getjavapeer(NPP aNPP) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  return 0;
}

bool _invoke(NPP aNPP, NPObject* aNPObj, NPIdentifier aMethod,
             const NPVariant* aArgs, uint32_t aArgCount, NPVariant* aResult) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->invoke)
    return false;

  return aNPObj->_class->invoke(aNPObj, aMethod, aArgs, aArgCount, aResult);
}

bool _invokedefault(NPP aNPP, NPObject* aNPObj, const NPVariant* aArgs,
                    uint32_t aArgCount, NPVariant* aResult) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->invokeDefault)
    return false;

  return aNPObj->_class->invokeDefault(aNPObj, aArgs, aArgCount, aResult);
}

bool _evaluate(NPP aNPP, NPObject* aObject, NPString* aScript,
               NPVariant* aResult) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!(aNPP && aObject && aScript && aResult)) {
    NS_ERROR("Bad arguments!");
    return false;
  }

  PluginScriptableObjectChild* actor =
      InstCast(aNPP)->GetActorForNPObject(aObject);
  if (!actor) {
    NS_ERROR("Failed to create actor?!");
    return false;
  }

#ifdef XP_WIN
  if (gDelayFlashFocusReplyUntilEval) {
    ReplyMessage(0);
    gDelayFlashFocusReplyUntilEval = false;
  }
#endif

  return actor->Evaluate(aScript, aResult);
}

bool _getproperty(NPP aNPP, NPObject* aNPObj, NPIdentifier aPropertyName,
                  NPVariant* aResult) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->getProperty)
    return false;

  return aNPObj->_class->getProperty(aNPObj, aPropertyName, aResult);
}

bool _setproperty(NPP aNPP, NPObject* aNPObj, NPIdentifier aPropertyName,
                  const NPVariant* aValue) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->setProperty)
    return false;

  return aNPObj->_class->setProperty(aNPObj, aPropertyName, aValue);
}

bool _removeproperty(NPP aNPP, NPObject* aNPObj, NPIdentifier aPropertyName) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->removeProperty)
    return false;

  return aNPObj->_class->removeProperty(aNPObj, aPropertyName);
}

bool _hasproperty(NPP aNPP, NPObject* aNPObj, NPIdentifier aPropertyName) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->hasProperty)
    return false;

  return aNPObj->_class->hasProperty(aNPObj, aPropertyName);
}

bool _hasmethod(NPP aNPP, NPObject* aNPObj, NPIdentifier aMethodName) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class || !aNPObj->_class->hasMethod)
    return false;

  return aNPObj->_class->hasMethod(aNPObj, aMethodName);
}

bool _enumerate(NPP aNPP, NPObject* aNPObj, NPIdentifier** aIdentifiers,
                uint32_t* aCount) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class) return false;

  if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(aNPObj->_class) ||
      !aNPObj->_class->enumerate) {
    *aIdentifiers = 0;
    *aCount = 0;
    return true;
  }

  return aNPObj->_class->enumerate(aNPObj, aIdentifiers, aCount);
}

bool _construct(NPP aNPP, NPObject* aNPObj, const NPVariant* aArgs,
                uint32_t aArgCount, NPVariant* aResult) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(false);

  if (!aNPP || !aNPObj || !aNPObj->_class ||
      !NP_CLASS_STRUCT_VERSION_HAS_CTOR(aNPObj->_class) ||
      !aNPObj->_class->construct) {
    return false;
  }

  return aNPObj->_class->construct(aNPObj, aArgs, aArgCount, aResult);
}

void _releasevariantvalue(NPVariant* aVariant) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  // Only assert plugin thread here for consistency with in-process plugins.
  AssertPluginThread();

  if (NPVARIANT_IS_STRING(*aVariant)) {
    NPString str = NPVARIANT_TO_STRING(*aVariant);
    free(const_cast<NPUTF8*>(str.UTF8Characters));
  } else if (NPVARIANT_IS_OBJECT(*aVariant)) {
    NPObject* object = NPVARIANT_TO_OBJECT(*aVariant);
    if (object) {
      PluginModuleChild::NPN_ReleaseObject(object);
    }
  }
  VOID_TO_NPVARIANT(*aVariant);
}

void _setexception(NPObject* aNPObj, const NPUTF8* aMessage) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD_VOID();

  // Do nothing. We no longer support this API.
}

void _pushpopupsenabledstate(NPP aNPP, NPBool aEnabled) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD_VOID();

  InstCast(aNPP)->CallNPN_PushPopupsEnabledState(aEnabled ? true : false);
}

void _poppopupsenabledstate(NPP aNPP) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD_VOID();

  InstCast(aNPP)->CallNPN_PopPopupsEnabledState();
}

NPError _getvalueforurl(NPP npp, NPNURLVariable variable, const char* url,
                        char** value, uint32_t* len) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();

  if (!url) return NPERR_INVALID_URL;

  if (!npp || !value || !len) return NPERR_INVALID_PARAM;

  if (variable == NPNURLVProxy) {
    nsCString v;
    NPError result;
    InstCast(npp)->CallNPN_GetValueForURL(variable, nsCString(url), &v,
                                          &result);
    if (NPERR_NO_ERROR == result) {
      *value = ToNewCString(v);
      *len = v.Length();
    }
    return result;
  }

  return NPERR_INVALID_PARAM;
}

NPError _setvalueforurl(NPP npp, NPNURLVariable variable, const char* url,
                        const char* value, uint32_t len) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();

  if (!value) return NPERR_INVALID_PARAM;

  if (!url) return NPERR_INVALID_URL;

  if (variable == NPNURLVProxy) {
    NPError result;
    InstCast(npp)->CallNPN_SetValueForURL(
        variable, nsCString(url), nsDependentCString(value, len), &result);
    return result;
  }

  return NPERR_INVALID_PARAM;
}

uint32_t _scheduletimer(NPP npp, uint32_t interval, NPBool repeat,
                        void (*timerFunc)(NPP npp, uint32_t timerID)) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();
  return InstCast(npp)->ScheduleTimer(interval, repeat, timerFunc);
}

void _unscheduletimer(NPP npp, uint32_t timerID) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();
  InstCast(npp)->UnscheduleTimer(timerID);
}

#ifdef OS_MACOSX
static void ProcessBrowserEvents(void* pluginModule) {
  PluginModuleChild* pmc = static_cast<PluginModuleChild*>(pluginModule);

  if (!pmc) return;

  pmc->CallProcessSomeEvents();
}
#endif

NPError _popupcontextmenu(NPP instance, NPMenu* menu) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();

#ifdef MOZ_WIDGET_COCOA
  double pluginX, pluginY;
  double screenX, screenY;

  const NPCocoaEvent* currentEvent = InstCast(instance)->getCurrentEvent();
  if (!currentEvent) {
    return NPERR_GENERIC_ERROR;
  }

  // Ensure that the events has an x/y value.
  if (currentEvent->type != NPCocoaEventMouseDown &&
      currentEvent->type != NPCocoaEventMouseUp &&
      currentEvent->type != NPCocoaEventMouseMoved &&
      currentEvent->type != NPCocoaEventMouseEntered &&
      currentEvent->type != NPCocoaEventMouseExited &&
      currentEvent->type != NPCocoaEventMouseDragged) {
    return NPERR_GENERIC_ERROR;
  }

  pluginX = currentEvent->data.mouse.pluginX;
  pluginY = currentEvent->data.mouse.pluginY;

  if ((pluginX < 0.0) || (pluginY < 0.0)) return NPERR_GENERIC_ERROR;

  NPBool success =
      _convertpoint(instance, pluginX, pluginY, NPCoordinateSpacePlugin,
                    &screenX, &screenY, NPCoordinateSpaceScreen);

  if (success) {
    return mozilla::plugins::PluginUtilsOSX::ShowCocoaContextMenu(
        menu, screenX, screenY, InstCast(instance)->Manager(),
        ProcessBrowserEvents);
  } else {
    NS_WARNING("Convertpoint failed, could not created contextmenu.");
    return NPERR_GENERIC_ERROR;
  }

#else
  NS_WARNING("Not supported on this platform!");
  return NPERR_GENERIC_ERROR;
#endif
}

NPBool _convertpoint(NPP instance, double sourceX, double sourceY,
                     NPCoordinateSpace sourceSpace, double* destX,
                     double* destY, NPCoordinateSpace destSpace) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  if (!IsPluginThread()) {
    NS_WARNING("Not running on the plugin's main thread!");
    return false;
  }

  double rDestX = 0;
  bool ignoreDestX = !destX;
  double rDestY = 0;
  bool ignoreDestY = !destY;
  bool result = false;
  InstCast(instance)->CallNPN_ConvertPoint(sourceX, ignoreDestX, sourceY,
                                           ignoreDestY, sourceSpace, destSpace,
                                           &rDestX, &rDestY, &result);
  if (result) {
    if (destX) *destX = rDestX;
    if (destY) *destY = rDestY;
  }

  return result;
}

void _urlredirectresponse(NPP instance, void* notifyData, NPBool allow) {
  InstCast(instance)->NPN_URLRedirectResponse(notifyData, allow);
}

NPError _initasyncsurface(NPP instance, NPSize* size, NPImageFormat format,
                          void* initData, NPAsyncSurface* surface) {
  return InstCast(instance)->NPN_InitAsyncSurface(size, format, initData,
                                                  surface);
}

NPError _finalizeasyncsurface(NPP instance, NPAsyncSurface* surface) {
  return InstCast(instance)->NPN_FinalizeAsyncSurface(surface);
}

void _setcurrentasyncsurface(NPP instance, NPAsyncSurface* surface,
                             NPRect* changed) {
  InstCast(instance)->NPN_SetCurrentAsyncSurface(surface, changed);
}

}  // namespace mozilla::plugins::child

//-----------------------------------------------------------------------------

mozilla::ipc::IPCResult PluginModuleChild::RecvSettingChanged(
    const PluginSettings& aSettings) {
  mCachedSettings = aSettings;
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::AnswerNP_GetEntryPoints(
    NPError* _retval) {
  PLUGIN_LOG_DEBUG_METHOD;
  AssertPluginThread();
  MOZ_ASSERT(mIsChrome);

#if defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)
  return IPC_OK();
#elif defined(OS_WIN) || defined(OS_MACOSX)
  *_retval = mGetEntryPointsFunc(&mFunctions);
  return IPC_OK();
#else
#  error Please implement me for your platform
#endif
}

mozilla::ipc::IPCResult PluginModuleChild::AnswerNP_Initialize(
    const PluginSettings& aSettings, NPError* rv) {
  *rv = DoNP_Initialize(aSettings);
  return IPC_OK();
}

NPError PluginModuleChild::DoNP_Initialize(const PluginSettings& aSettings) {
  PLUGIN_LOG_DEBUG_METHOD;
  AssertPluginThread();
  MOZ_ASSERT(mIsChrome);

  mCachedSettings = aSettings;

#ifdef OS_WIN
  SetEventHooks();
#endif

#ifdef MOZ_X11
#  ifdef MOZ_WIDGET_GTK
  if (!GDK_IS_X11_DISPLAY(gdk_display_get_default())) {
    // We don't support NPAPI plugins on Wayland.
    return NPERR_GENERIC_ERROR;
  }
#  endif
  // Send the parent our X socket to act as a proxy reference for our X
  // resources.
  int xSocketFd = ConnectionNumber(DefaultXDisplay());
  SendBackUpXResources(FileDescriptor(xSocketFd));
#endif

  NPError result;
#if defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)
  result = mInitializeFunc(&sBrowserFuncs, &mFunctions);
#elif defined(OS_WIN) || defined(OS_MACOSX)
  result = mInitializeFunc(&sBrowserFuncs);
#else
#  error Please implement me for your platform
#endif

  return result;
}

PPluginInstanceChild* PluginModuleChild::AllocPPluginInstanceChild(
    const nsCString& aMimeType, const nsTArray<nsCString>& aNames,
    const nsTArray<nsCString>& aValues) {
  PLUGIN_LOG_DEBUG_METHOD;
  AssertPluginThread();

  // In e10s, gChromeInstance hands out quirks to instances, but never
  // allocates an instance on its own. Make sure it gets the latest copy
  // of quirks once we have them. Also note, with process-per-tab, we may
  // have multiple PluginModuleChilds in the same plugin process, so only
  // initialize this once in gChromeInstance, which is a singleton.
  GetChrome()->InitQuirksModes(aMimeType);
  mQuirks = GetChrome()->mQuirks;

#ifdef XP_WIN
  FunctionHook::HookFunctions(mQuirks);
#endif

  return new PluginInstanceChild(&mFunctions, aMimeType, aNames, aValues);
}

void PluginModuleChild::InitQuirksModes(const nsCString& aMimeType) {
  if (mQuirks != QUIRKS_NOT_INITIALIZED) {
    return;
  }

  mQuirks = GetQuirksFromMimeTypeAndFilename(aMimeType, mPluginFilename);
}

mozilla::ipc::IPCResult PluginModuleChild::AnswerModuleSupportsAsyncRender(
    bool* aResult) {
#if defined(XP_WIN)
  *aResult = gChromeInstance->mAsyncRenderSupport;
  return IPC_OK();
#else
  MOZ_ASSERT_UNREACHABLE("Shouldn't get here!");
  return IPC_FAIL_NO_REASON(this);
#endif
}

mozilla::ipc::IPCResult PluginModuleChild::RecvPPluginInstanceConstructor(
    PPluginInstanceChild* aActor, const nsCString& aMimeType,
    nsTArray<nsCString>&& aNames, nsTArray<nsCString>&& aValues) {
  PLUGIN_LOG_DEBUG_METHOD;
  AssertPluginThread();

  NS_ASSERTION(aActor, "Null actor!");
  return IPC_OK();
}

mozilla::ipc::IPCResult PluginModuleChild::AnswerSyncNPP_New(
    PPluginInstanceChild* aActor, NPError* rv) {
  PLUGIN_LOG_DEBUG_METHOD;
  PluginInstanceChild* childInstance =
      reinterpret_cast<PluginInstanceChild*>(aActor);
  AssertPluginThread();
  *rv = childInstance->DoNPP_New();
  return IPC_OK();
}

bool PluginModuleChild::DeallocPPluginInstanceChild(
    PPluginInstanceChild* aActor) {
  PLUGIN_LOG_DEBUG_METHOD;
  AssertPluginThread();

  delete aActor;

  return true;
}

NPObject* PluginModuleChild::NPN_CreateObject(NPP aNPP, NPClass* aClass) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  ENSURE_PLUGIN_THREAD(nullptr);

  PluginInstanceChild* i = InstCast(aNPP);
  if (i->mDeletingHash) {
    NS_ERROR("Plugin used NPP after NPP_Destroy");
    return nullptr;
  }

  NPObject* newObject;
  if (aClass && aClass->allocate) {
    newObject = aClass->allocate(aNPP, aClass);
  } else {
    newObject = reinterpret_cast<NPObject*>(child::_memalloc(sizeof(NPObject)));
  }

  if (newObject) {
    newObject->_class = aClass;
    newObject->referenceCount = 1;
    NS_LOG_ADDREF(newObject, 1, "NPObject", sizeof(NPObject));
  }

  PluginScriptableObjectChild::RegisterObject(newObject, i);

  return newObject;
}

NPObject* PluginModuleChild::NPN_RetainObject(NPObject* aNPObj) {
  AssertPluginThread();

  if (NS_WARN_IF(!aNPObj)) {
    return nullptr;
  }

#ifdef NS_BUILD_REFCNT_LOGGING
  int32_t refCnt =
#endif
      PR_ATOMIC_INCREMENT((int32_t*)&aNPObj->referenceCount);
  NS_LOG_ADDREF(aNPObj, refCnt, "NPObject", sizeof(NPObject));

  return aNPObj;
}

void PluginModuleChild::NPN_ReleaseObject(NPObject* aNPObj) {
  AssertPluginThread();

  PluginInstanceChild* instance =
      PluginScriptableObjectChild::GetInstanceForNPObject(aNPObj);
  if (!instance) {
    // The PluginInstanceChild was destroyed
    return;
  }

  DeletingObjectEntry* doe = nullptr;
  if (instance->mDeletingHash) {
    doe = instance->mDeletingHash->GetEntry(aNPObj);
    if (!doe) {
      NS_ERROR(
          "An object for a destroyed instance isn't in the instance deletion "
          "hash");
      return;
    }
    if (doe->mDeleted) return;
  }

  int32_t refCnt = PR_ATOMIC_DECREMENT((int32_t*)&aNPObj->referenceCount);
  NS_LOG_RELEASE(aNPObj, refCnt, "NPObject");

  if (refCnt == 0) {
    DeallocNPObject(aNPObj);
    if (doe) doe->mDeleted = true;
  }
}

void PluginModuleChild::DeallocNPObject(NPObject* aNPObj) {
  if (aNPObj->_class && aNPObj->_class->deallocate) {
    aNPObj->_class->deallocate(aNPObj);
  } else {
    child::_memfree(aNPObj);
  }

  PluginScriptableObjectChild* actor =
      PluginScriptableObjectChild::GetActorForNPObject(aNPObj);
  if (actor) actor->NPObjectDestroyed();

  PluginScriptableObjectChild::UnregisterObject(aNPObj);
}

NPIdentifier PluginModuleChild::NPN_GetStringIdentifier(const NPUTF8* aName) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();

  if (!aName) return 0;

  nsDependentCString name(aName);
  PluginIdentifier ident(name);
  PluginScriptableObjectChild::StackIdentifier stackID(ident);
  stackID.MakePermanent();
  return stackID.ToNPIdentifier();
}

void PluginModuleChild::NPN_GetStringIdentifiers(const NPUTF8** aNames,
                                                 int32_t aNameCount,
                                                 NPIdentifier* aIdentifiers) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();

  if (!(aNames && aNameCount > 0 && aIdentifiers)) {
    MOZ_CRASH("Bad input! Headed for a crash!");
  }

  for (int32_t index = 0; index < aNameCount; ++index) {
    if (!aNames[index]) {
      aIdentifiers[index] = 0;
      continue;
    }
    nsDependentCString name(aNames[index]);
    PluginIdentifier ident(name);
    PluginScriptableObjectChild::StackIdentifier stackID(ident);
    stackID.MakePermanent();
    aIdentifiers[index] = stackID.ToNPIdentifier();
  }
}

bool PluginModuleChild::NPN_IdentifierIsString(NPIdentifier aIdentifier) {
  PLUGIN_LOG_DEBUG_FUNCTION;

  PluginScriptableObjectChild::StackIdentifier stack(aIdentifier);
  return stack.IsString();
}

NPIdentifier PluginModuleChild::NPN_GetIntIdentifier(int32_t aIntId) {
  PLUGIN_LOG_DEBUG_FUNCTION;
  AssertPluginThread();

  PluginIdentifier ident(aIntId);
  PluginScriptableObjectChild::StackIdentifier stackID(ident);
  stackID.MakePermanent();
  return stackID.ToNPIdentifier();
}

NPUTF8* PluginModuleChild::NPN_UTF8FromIdentifier(NPIdentifier aIdentifier) {
  PLUGIN_LOG_DEBUG_FUNCTION;

  PluginScriptableObjectChild::StackIdentifier stackID(aIdentifier);
  if (stackID.IsString()) {
    return ToNewCString(stackID.GetString());
  }
  return nullptr;
}

int32_t PluginModuleChild::NPN_IntFromIdentifier(NPIdentifier aIdentifier) {
  PLUGIN_LOG_DEBUG_FUNCTION;

  PluginScriptableObjectChild::StackIdentifier stackID(aIdentifier);
  if (!stackID.IsString()) {
    return stackID.GetInt();
  }
  return INT32_MIN;
}

#ifdef OS_WIN
void PluginModuleChild::EnteredCall() { mIncallPumpingStack.AppendElement(); }

void PluginModuleChild::ExitedCall() {
  NS_ASSERTION(mIncallPumpingStack.Length(), "mismatched entered/exited");
  const IncallFrame& f = mIncallPumpingStack.LastElement();
  if (f._spinning)
    MessageLoop::current()->SetNestableTasksAllowed(
        f._savedNestableTasksAllowed);

  // XXX Is RemoveLastElement intentionally called only after calling
  // SetNestableTasksAllowed? Otherwise, PopLastElement could be used above.
  mIncallPumpingStack.RemoveLastElement();
}

LRESULT CALLBACK PluginModuleChild::CallWindowProcHook(int nCode, WPARAM wParam,
                                                       LPARAM lParam) {
  // Trap and reply to anything we recognize as the source of a
  // potential send message deadlock.
  if (nCode >= 0 &&
      (InSendMessageEx(nullptr) & (ISMEX_REPLIED | ISMEX_SEND)) == ISMEX_SEND) {
    CWPSTRUCT* pCwp = reinterpret_cast<CWPSTRUCT*>(lParam);
    if (pCwp->message == WM_KILLFOCUS) {
      // Fix for flash fullscreen window loosing focus. On single
      // core systems, sync killfocus events need to be handled
      // after the flash fullscreen window procedure processes this
      // message, otherwise fullscreen focus will not work correctly.
      wchar_t szClass[26];
      if (GetClassNameW(pCwp->hwnd, szClass,
                        sizeof(szClass) / sizeof(char16_t)) &&
          !wcscmp(szClass, kFlashFullscreenClass)) {
        gDelayFlashFocusReplyUntilEval = true;
      }
    }
  }

  return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

LRESULT CALLBACK PluginModuleChild::NestedInputEventHook(int nCode,
                                                         WPARAM wParam,
                                                         LPARAM lParam) {
  PluginModuleChild* self = GetChrome();
  uint32_t len = self->mIncallPumpingStack.Length();
  if (nCode >= 0 && len && !self->mIncallPumpingStack[len - 1]._spinning) {
    MessageLoop* loop = MessageLoop::current();
    self->SendProcessNativeEventsInInterruptCall();
    IncallFrame& f = self->mIncallPumpingStack[len - 1];
    f._spinning = true;
    f._savedNestableTasksAllowed = loop->NestableTasksAllowed();
    loop->SetNestableTasksAllowed(true);
    loop->set_os_modal_loop(true);
  }

  return CallNextHookEx(nullptr, nCode, wParam, lParam);
}

void PluginModuleChild::SetEventHooks() {
  NS_ASSERTION(
      !mNestedEventHook,
      "mNestedEventHook already setup in call to SetNestedInputEventHook?");
  NS_ASSERTION(
      !mGlobalCallWndProcHook,
      "mGlobalCallWndProcHook already setup in call to CallWindowProcHook?");

  PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));

  // WH_MSGFILTER event hook for detecting modal loops in the child.
  mNestedEventHook = SetWindowsHookEx(WH_MSGFILTER, NestedInputEventHook,
                                      nullptr, GetCurrentThreadId());

  // WH_CALLWNDPROC event hook for trapping sync messages sent from
  // parent that can cause deadlocks.
  mGlobalCallWndProcHook = SetWindowsHookEx(WH_CALLWNDPROC, CallWindowProcHook,
                                            nullptr, GetCurrentThreadId());
}

void PluginModuleChild::ResetEventHooks() {
  PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
  if (mNestedEventHook) UnhookWindowsHookEx(mNestedEventHook);
  mNestedEventHook = nullptr;
  if (mGlobalCallWndProcHook) UnhookWindowsHookEx(mGlobalCallWndProcHook);
  mGlobalCallWndProcHook = nullptr;
}
#endif

mozilla::ipc::IPCResult
PluginModuleChild::RecvProcessNativeEventsInInterruptCall() {
  PLUGIN_LOG_DEBUG(("%s", FULLFUNCTION));
#if defined(OS_WIN)
  ProcessNativeEventsInInterruptCall();
  return IPC_OK();
#else
  MOZ_CRASH(
      "PluginModuleChild::RecvProcessNativeEventsInInterruptCall not "
      "implemented!");
  return IPC_FAIL_NO_REASON(this);
#endif
}

#ifdef MOZ_WIDGET_COCOA
void PluginModuleChild::ProcessNativeEvents() { CallProcessSomeEvents(); }
#endif

NPError PluginModuleChild::PluginRequiresAudioDeviceChanges(
    PluginInstanceChild* aInstance, NPBool aShouldRegister) {
#ifdef XP_WIN
  // Maintain a set of PluginInstanceChildren that we need to tell when the
  // default audio device has changed.
  NPError rv = NPERR_NO_ERROR;
  if (aShouldRegister) {
    if (mAudioNotificationSet.IsEmpty()) {
      // We are registering the first plugin.  Notify the PluginModuleParent
      // that it needs to start sending us audio device notifications.
      if (!CallNPN_SetValue_NPPVpluginRequiresAudioDeviceChanges(
              aShouldRegister, &rv)) {
        return NPERR_GENERIC_ERROR;
      }
    }
    if (rv == NPERR_NO_ERROR) {
      mAudioNotificationSet.PutEntry(aInstance);
    }
  } else if (!mAudioNotificationSet.IsEmpty()) {
    mAudioNotificationSet.RemoveEntry(aInstance);
    if (mAudioNotificationSet.IsEmpty()) {
      // We released the last plugin.  Unregister from the PluginModuleParent.
      if (!CallNPN_SetValue_NPPVpluginRequiresAudioDeviceChanges(
              aShouldRegister, &rv)) {
        return NPERR_GENERIC_ERROR;
      }
    }
  }
  return rv;
#else
  MOZ_CRASH(
      "PluginRequiresAudioDeviceChanges is not available on this platform.");
#endif  // XP_WIN
}

mozilla::ipc::IPCResult
PluginModuleChild::RecvNPP_SetValue_NPNVaudioDeviceChangeDetails(
    const NPAudioDeviceChangeDetailsIPC& detailsIPC) {
#if defined(XP_WIN)
  NPAudioDeviceChangeDetails details;
  details.flow = detailsIPC.flow;
  details.role = detailsIPC.role;
  details.defaultDevice = detailsIPC.defaultDevice.c_str();
  for (auto iter = mAudioNotificationSet.ConstIter(); !iter.Done();
       iter.Next()) {
    PluginInstanceChild* pluginInst = iter.Get()->GetKey();
    pluginInst->DefaultAudioDeviceChanged(details);
  }
  return IPC_OK();
#else
  MOZ_CRASH(
      "NPP_SetValue_NPNVaudioDeviceChangeDetails is a Windows-only message");
#endif
}

mozilla::ipc::IPCResult
PluginModuleChild::RecvNPP_SetValue_NPNVaudioDeviceStateChanged(
    const NPAudioDeviceStateChangedIPC& aDeviceStateIPC) {
#if defined(XP_WIN)
  NPAudioDeviceStateChanged stateChange;
  stateChange.newState = aDeviceStateIPC.state;
  stateChange.device = aDeviceStateIPC.device.c_str();
  for (auto iter = mAudioNotificationSet.ConstIter(); !iter.Done();
       iter.Next()) {
    PluginInstanceChild* pluginInst = iter.Get()->GetKey();
    pluginInst->AudioDeviceStateChanged(stateChange);
  }
  return IPC_OK();
#else
  MOZ_CRASH("NPP_SetValue_NPNVaudioDeviceRemoved is a Windows-only message");
#endif
}