/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* vim: set sw=4 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>

#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/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";

#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

bool

PluginModuleChild::InitForChrome(const std::string& aPluginFilename,

                                 base::ProcessId aParentPid,

                                 MessageLoop* aIOLoop,

                                 IPC::Channel* aChannel)

{

    NS_ASSERTION(aChannel, "need a channel");

    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)

    NS_NAMED_LITERAL_CSTRING(flash10Head, "Shockwave Flash 10.");

    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(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_Plugin;

      flashSandboxInfo.pluginInfo.type = MacSandboxPluginType_Flash;

      flashSandboxInfo.pluginInfo.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 = True;

    gdk_error_trap_push();

    XSendEvent(dpy, xevent.xbutton.window,

               True, ButtonPressMask, &xevent);

    xevent.xbutton.type = ButtonRelease;

    xevent.xbutton.state |= button_mask;

    XSendEvent(dpy, xevent.xbutton.window,

               True, 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();

    InfallibleTArray<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(Shmem&& aShmem, mozilla::dom::NativeThreadId* aOutId)

{

    CrashReporterClient::InitSingletonWithShmem(aShmem);

    *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 {

namespace plugins {

namespace 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 child */

} /* namespace plugins */

} /* namespace mozilla */

const NPNetscapeFuncs PluginModuleChild::sBrowserFuncs = {

    sizeof(sBrowserFuncs),

    (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR,

    mozilla::plugins::child::_geturl,