The Tor Browser: comparison dom/plugins/ipc/PluginInstanceChild.cpp

--1:000000000000
+:c413a46f0c6b
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+* vim: 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 "PluginBackgroundDestroyer.h"
+#include "PluginInstanceChild.h"
+#include "PluginModuleChild.h"
+#include "BrowserStreamChild.h"
+#include "PluginStreamChild.h"
+#include "StreamNotifyChild.h"
+#include "PluginProcessChild.h"
+#include "gfxASurface.h"
+#include "gfxContext.h"
+#include "nsNPAPIPluginInstance.h"
+#ifdef MOZ_X11
+#include "gfxXlibSurface.h"
+#endif
+#ifdef XP_WIN
+#include "mozilla/gfx/SharedDIBSurface.h"
+#include "nsCrashOnException.h"
+extern const wchar_t* kFlashFullscreenClass;
+using mozilla::gfx::SharedDIBSurface;
+#endif
+#include "gfxSharedImageSurface.h"
+#include "gfxUtils.h"
+#include "gfxAlphaRecovery.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/ipc/MessageChannel.h"
+#include "mozilla/AutoRestore.h"
+#include "ImageContainer.h"
+using namespace mozilla;
+using mozilla::ipc::ProcessChild;
+using namespace mozilla::plugins;
+using namespace mozilla::layers;
+using namespace mozilla::gfx;
+using namespace std;
+#ifdef MOZ_WIDGET_GTK
+#include <gtk/gtk.h>
+#if (MOZ_WIDGET_GTK == 3)
+#include <gtk/gtkx.h>
+#endif
+#include <gdk/gdkx.h>
+#include <gdk/gdk.h>
+#if (MOZ_WIDGET_GTK == 2)
+#include "gtk2xtbin.h"
+#endif
+#elif defined(MOZ_WIDGET_QT)
+#undef KeyPress
+#undef KeyRelease
+#elif defined(OS_WIN)
+#ifndef WM_MOUSEHWHEEL
+#define WM_MOUSEHWHEEL     0x020E
+#endif
+#include "nsWindowsDllInterceptor.h"
+typedef BOOL (WINAPI *User32TrackPopupMenu)(HMENU hMenu,
+UINT uFlags,
+int x,
+int y,
+int nReserved,
+HWND hWnd,
+CONST RECT *prcRect);
+static WindowsDllInterceptor sUser32Intercept;
+static HWND sWinlessPopupSurrogateHWND = nullptr;
+static User32TrackPopupMenu sUser32TrackPopupMenuStub = nullptr;
+using mozilla::gfx::SharedDIB;
+#include <windows.h>
+#include <windowsx.h>
+// Flash WM_USER message delay time for PostDelayedTask. Borrowed
+// from Chromium's web plugin delegate src. See 'flash msg throttling
+// helpers' section for details.
+const int kFlashWMUSERMessageThrottleDelayMs = 5;
+static const TCHAR kPluginIgnoreSubclassProperty[] = TEXT("PluginIgnoreSubclassProperty");
+#elif defined(XP_MACOSX)
+#include <ApplicationServices/ApplicationServices.h>
+#include "nsCocoaFeatures.h"
+#include "PluginUtilsOSX.h"
+#endif // defined(XP_MACOSX)
+template<>
+struct RunnableMethodTraits<PluginInstanceChild>
+{
+static void RetainCallee(PluginInstanceChild* obj) { }
+static void ReleaseCallee(PluginInstanceChild* obj) { }
+};
+PluginInstanceChild::PluginInstanceChild(const NPPluginFuncs* aPluginIface)
+: mPluginIface(aPluginIface)
+#if defined(XP_MACOSX)
+, mContentsScaleFactor(1.0)
+#endif
+, mDrawingModel(kDefaultDrawingModel)
+, mCurrentAsyncSurface(0)
+, mAsyncInvalidateMutex("PluginInstanceChild::mAsyncInvalidateMutex")
+, mAsyncInvalidateTask(0)
+, mCachedWindowActor(nullptr)
+, mCachedElementActor(nullptr)
+#if (MOZ_WIDGET_GTK == 2)
+, mXEmbed(false)
+#endif // MOZ_WIDGET_GTK
+#if defined(OS_WIN)
+, mPluginWindowHWND(0)
+, mPluginWndProc(0)
+, mPluginParentHWND(0)
+, mCachedWinlessPluginHWND(0)
+, mWinlessPopupSurrogateHWND(0)
+, mWinlessThrottleOldWndProc(0)
+, mWinlessHiddenMsgHWND(0)
+#endif // OS_WIN
+, mAsyncCallMutex("PluginInstanceChild::mAsyncCallMutex")
+#if defined(MOZ_WIDGET_COCOA)
+#if defined(__i386__)
+, mEventModel(NPEventModelCarbon)
+#endif
+, mShColorSpace(nullptr)
+, mShContext(nullptr)
+, mCGLayer(nullptr)
+, mCurrentEvent(nullptr)
+#endif
+, mLayersRendering(false)
+#ifdef XP_WIN
+, mCurrentSurfaceActor(nullptr)
+, mBackSurfaceActor(nullptr)
+#endif
+, mAccumulatedInvalidRect(0,0,0,0)
+, mIsTransparent(false)
+, mSurfaceType(gfxSurfaceType::Max)
+, mCurrentInvalidateTask(nullptr)
+, mCurrentAsyncSetWindowTask(nullptr)
+, mPendingPluginCall(false)
+, mDoAlphaExtraction(false)
+, mHasPainted(false)
+, mSurfaceDifferenceRect(0,0,0,0)
+{
+memset(&mWindow, 0, sizeof(mWindow));
+mWindow.type = NPWindowTypeWindow;
+mData.ndata = (void*) this;
+mData.pdata = nullptr;
+#if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
+mWindow.ws_info = &mWsInfo;
+memset(&mWsInfo, 0, sizeof(mWsInfo));
+#if (MOZ_WIDGET_GTK == 2)
+mWsInfo.display = nullptr;
+mXtClient.top_widget = nullptr;
+#else
+mWsInfo.display = DefaultXDisplay();
+#endif
+#endif // MOZ_X11 && XP_UNIX && !XP_MACOSX
+#if defined(OS_WIN)
+memset(&mAlphaExtract, 0, sizeof(mAlphaExtract));
+#endif // OS_WIN
+#if defined(OS_WIN)
+InitPopupMenuHook();
+#endif // OS_WIN
+}
+PluginInstanceChild::~PluginInstanceChild()
+{
+#if defined(OS_WIN)
+NS_ASSERTION(!mPluginWindowHWND, "Destroying PluginInstanceChild without NPP_Destroy?");
+#endif
+#if defined(MOZ_WIDGET_COCOA)
+if (mShColorSpace) {
+::CGColorSpaceRelease(mShColorSpace);
+}
+if (mShContext) {
+::CGContextRelease(mShContext);
+}
+if (mCGLayer) {
+PluginUtilsOSX::ReleaseCGLayer(mCGLayer);
+}
+if (mDrawingModel == NPDrawingModelCoreAnimation) {
+UnscheduleTimer(mCARefreshTimer);
+}
+#endif
+}
+int
+PluginInstanceChild::GetQuirks()
+{
+return PluginModuleChild::current()->GetQuirks();
+}
+NPError
+PluginInstanceChild::InternalGetNPObjectForValue(NPNVariable aValue,
+NPObject** aObject)
+{
+PluginScriptableObjectChild* actor = nullptr;
+NPError result = NPERR_NO_ERROR;
+switch (aValue) {
+case NPNVWindowNPObject:
+if (!(actor = mCachedWindowActor)) {
+PPluginScriptableObjectChild* actorProtocol;
+CallNPN_GetValue_NPNVWindowNPObject(&actorProtocol, &result);
+if (result == NPERR_NO_ERROR) {
+actor = mCachedWindowActor =
+static_cast<PluginScriptableObjectChild*>(actorProtocol);
+NS_ASSERTION(actor, "Null actor!");
+PluginModuleChild::sBrowserFuncs.retainobject(
+actor->GetObject(false));
+}
+}
+break;
+case NPNVPluginElementNPObject:
+if (!(actor = mCachedElementActor)) {
+PPluginScriptableObjectChild* actorProtocol;
+CallNPN_GetValue_NPNVPluginElementNPObject(&actorProtocol,
+&result);
+if (result == NPERR_NO_ERROR) {
+actor = mCachedElementActor =
+static_cast<PluginScriptableObjectChild*>(actorProtocol);
+NS_ASSERTION(actor, "Null actor!");
+PluginModuleChild::sBrowserFuncs.retainobject(
+actor->GetObject(false));
+}
+}
+break;
+default:
+NS_NOTREACHED("Don't know what to do with this value type!");
+}
+#ifdef DEBUG
+{
+NPError currentResult;
+PPluginScriptableObjectChild* currentActor = nullptr;
+switch (aValue) {
+case NPNVWindowNPObject:
+CallNPN_GetValue_NPNVWindowNPObject(&currentActor,
+&currentResult);
+break;
+case NPNVPluginElementNPObject:
+CallNPN_GetValue_NPNVPluginElementNPObject(&currentActor,
+&currentResult);
+break;
+default:
+MOZ_ASSERT(false);
+}
+// Make sure that the current actor returned by the parent matches our
+// cached actor!
+NS_ASSERTION(!currentActor ||
+static_cast<PluginScriptableObjectChild*>(currentActor) ==
+actor, "Cached actor is out of date!");
+}
+#endif
+if (result != NPERR_NO_ERROR) {
+return result;
+}
+NPObject* object = actor->GetObject(false);
+NS_ASSERTION(object, "Null object?!");
+*aObject = PluginModuleChild::sBrowserFuncs.retainobject(object);
+return NPERR_NO_ERROR;
+}
+NPError
+PluginInstanceChild::NPN_GetValue(NPNVariable aVar,
+void* aValue)
+{
+PLUGIN_LOG_DEBUG(("%s (aVar=%i)", FULLFUNCTION, (int) aVar));
+AssertPluginThread();
+switch(aVar) {
+#if defined(MOZ_X11)
+case NPNVToolkit:
+*((NPNToolkitType*)aValue) = NPNVGtk2;
+return NPERR_NO_ERROR;
+case NPNVxDisplay:
+if (!mWsInfo.display) {
+// We are called before Initialize() so we have to call it now.
+Initialize();
+NS_ASSERTION(mWsInfo.display, "We should have a valid display!");
+}
+*(void **)aValue = mWsInfo.display;
+return NPERR_NO_ERROR;
+#elif defined(OS_WIN)
+case NPNVToolkit:
+return NPERR_GENERIC_ERROR;
+#endif
+case NPNVprivateModeBool: {
+bool v = false;
+NPError result;
+if (!CallNPN_GetValue_NPNVprivateModeBool(&v, &result)) {
+return NPERR_GENERIC_ERROR;
+}
+*static_cast<NPBool*>(aValue) = v;
+return result;
+}
+case NPNVdocumentOrigin: {
+nsCString v;
+NPError result;
+if (!CallNPN_GetValue_NPNVdocumentOrigin(&v, &result)) {
+return NPERR_GENERIC_ERROR;
+}
+if (result == NPERR_NO_ERROR) {
+*static_cast<char**>(aValue) = ToNewCString(v);
+}
+return result;
+}
+case NPNVWindowNPObject: // Intentional fall-through
+case NPNVPluginElementNPObject: {
+NPObject* object;
+NPError result = InternalGetNPObjectForValue(aVar, &object);
+if (result == NPERR_NO_ERROR) {
+*((NPObject**)aValue) = object;
+}
+return result;
+}
+case NPNVnetscapeWindow: {
+#ifdef XP_WIN
+if (mWindow.type == NPWindowTypeDrawable) {
+if (mCachedWinlessPluginHWND) {
+*static_cast<HWND*>(aValue) = mCachedWinlessPluginHWND;
+return NPERR_NO_ERROR;
+}
+NPError result;
+if (!CallNPN_GetValue_NPNVnetscapeWindow(&mCachedWinlessPluginHWND, &result)) {
+return NPERR_GENERIC_ERROR;
+}
+*static_cast<HWND*>(aValue) = mCachedWinlessPluginHWND;
+return result;
+}
+else {
+*static_cast<HWND*>(aValue) = mPluginWindowHWND;
+return NPERR_NO_ERROR;
+}
+#elif defined(MOZ_X11)
+NPError result;
+CallNPN_GetValue_NPNVnetscapeWindow(static_cast<XID*>(aValue), &result);
+return result;
+#else
+return NPERR_GENERIC_ERROR;
+#endif
+}
+case NPNVsupportsAsyncBitmapSurfaceBool: {
+#ifdef XP_WIN
+*((NPBool*)aValue) = PluginModuleChild::current()->AsyncDrawingAllowed();
+#else
+// We do not support non-windows yet.
+*((NPBool*)aValue) = false;
+#endif
+return NPERR_NO_ERROR;
+}
+#ifdef XP_WIN
+case NPNVsupportsAsyncWindowsDXGISurfaceBool: {
+bool val;
+CallNPN_GetValue_DrawingModelSupport(NPNVsupportsAsyncWindowsDXGISurfaceBool, &val);
+*((NPBool*)aValue) = val;
+return NPERR_NO_ERROR;
+}
+#endif
+#ifdef XP_MACOSX
+case NPNVsupportsCoreGraphicsBool: {
+*((NPBool*)aValue) = true;
+return NPERR_NO_ERROR;
+}
+case NPNVsupportsCoreAnimationBool: {
+*((NPBool*)aValue) = nsCocoaFeatures::SupportCoreAnimationPlugins();
+return NPERR_NO_ERROR;
+}
+case NPNVsupportsInvalidatingCoreAnimationBool: {
+*((NPBool*)aValue) = nsCocoaFeatures::SupportCoreAnimationPlugins();
+return NPERR_NO_ERROR;
+}
+case NPNVsupportsCompositingCoreAnimationPluginsBool: {
+*((NPBool*)aValue) = true;
+return NPERR_NO_ERROR;
+}
+case NPNVsupportsCocoaBool: {
+*((NPBool*)aValue) = true;
+return NPERR_NO_ERROR;
+}
+#ifndef NP_NO_CARBON
+case NPNVsupportsCarbonBool: {
+*((NPBool*)aValue) = false;
+return NPERR_NO_ERROR;
+}
+#endif
+case NPNVsupportsUpdatedCocoaTextInputBool: {
+*static_cast<NPBool*>(aValue) = true;
+return NPERR_NO_ERROR;
+}
+#ifndef NP_NO_QUICKDRAW
+case NPNVsupportsQuickDrawBool: {
+*((NPBool*)aValue) = false;
+return NPERR_NO_ERROR;
+}
+#endif /* NP_NO_QUICKDRAW */
+case NPNVcontentsScaleFactor: {
+*static_cast<double*>(aValue) = mContentsScaleFactor;
+return NPERR_NO_ERROR;
+}
+#endif /* XP_MACOSX */
+#ifdef DEBUG
+case NPNVjavascriptEnabledBool:
+case NPNVasdEnabledBool:
+case NPNVisOfflineBool:
+case NPNVSupportsXEmbedBool:
+case NPNVSupportsWindowless:
+NS_NOTREACHED("NPNVariable should be handled in PluginModuleChild.");
+#endif
+default:
+PR_LOG(GetPluginLog(), PR_LOG_WARNING,
+("In PluginInstanceChild::NPN_GetValue: Unhandled NPNVariable %i (%s)",
+(int) aVar, NPNVariableToString(aVar)));
+return NPERR_GENERIC_ERROR;
+}
+}
+#ifdef MOZ_WIDGET_COCOA
+#define DEFAULT_REFRESH_MS 20 // CoreAnimation: 50 FPS
+void
+CAUpdate(NPP npp, uint32_t timerID) {
+static_cast<PluginInstanceChild*>(npp->ndata)->Invalidate();
+}
+void
+PluginInstanceChild::Invalidate()
+{
+NPRect windowRect = {0, 0, uint16_t(mWindow.height),
+uint16_t(mWindow.width)};
+InvalidateRect(&windowRect);
+}
+#endif
+NPError
+PluginInstanceChild::NPN_SetValue(NPPVariable aVar, void* aValue)
+{
+PR_LOG(GetPluginLog(), PR_LOG_DEBUG, ("%s (aVar=%i, aValue=%p)",
+FULLFUNCTION, (int) aVar, aValue));
+AssertPluginThread();
+switch (aVar) {
+case NPPVpluginWindowBool: {
+NPError rv;
+bool windowed = (NPBool) (intptr_t) aValue;
+if (!CallNPN_SetValue_NPPVpluginWindow(windowed, &rv))
+return NPERR_GENERIC_ERROR;
+NPWindowType newWindowType = windowed ? NPWindowTypeWindow : NPWindowTypeDrawable;
+#if (MOZ_WIDGET_GTK == 2)
+if (mWindow.type != newWindowType && mWsInfo.display) {
+// plugin type has been changed but we already have a valid display
+// so update it for the recent plugin mode
+if (mXEmbed || !windowed) {
+// Use default GTK display for XEmbed and windowless plugins
+mWsInfo.display = DefaultXDisplay();
+}
+else {
+mWsInfo.display = xt_client_get_display();
+}
+}
+#endif
+mWindow.type = newWindowType;
+return rv;
+}
+case NPPVpluginTransparentBool: {
+NPError rv;
+mIsTransparent = (!!aValue);
+if (!CallNPN_SetValue_NPPVpluginTransparent(mIsTransparent, &rv))
+return NPERR_GENERIC_ERROR;
+return rv;
+}
+case NPPVpluginUsesDOMForCursorBool: {
+NPError rv = NPERR_GENERIC_ERROR;
+if (!CallNPN_SetValue_NPPVpluginUsesDOMForCursor((NPBool)(intptr_t)aValue, &rv)) {
+return NPERR_GENERIC_ERROR;
+}
+return rv;
+}
+case NPPVpluginDrawingModel: {
+NPError rv;
+int drawingModel = (int16_t) (intptr_t) aValue;
+if (!PluginModuleChild::current()->AsyncDrawingAllowed() &&
+IsDrawingModelAsync(drawingModel)) {
+return NPERR_GENERIC_ERROR;
+}
+CrossProcessMutexHandle handle;
+OptionalShmem optionalShmem;
+if (!CallNPN_SetValue_NPPVpluginDrawingModel(drawingModel, &optionalShmem, &handle, &rv))
+return NPERR_GENERIC_ERROR;
+if (IsDrawingModelAsync(drawingModel)) {
+if (optionalShmem.type() != OptionalShmem::TShmem) {
+return NPERR_GENERIC_ERROR;
+}
+mRemoteImageDataShmem = optionalShmem.get_Shmem();
+mRemoteImageData = mRemoteImageDataShmem.get<RemoteImageData>();
+mRemoteImageDataMutex = new CrossProcessMutex(handle);
+}
+mDrawingModel = drawingModel;
+#ifdef XP_MACOSX
+if (drawingModel == NPDrawingModelCoreAnimation) {
+mCARefreshTimer = ScheduleTimer(DEFAULT_REFRESH_MS, true, CAUpdate);
+}
+#endif
+PLUGIN_LOG_DEBUG(("  Plugin requested drawing model id  #%i\n",
+mDrawingModel));
+return rv;
+}
+#ifdef XP_MACOSX
+case NPPVpluginEventModel: {
+NPError rv;
+int eventModel = (int16_t) (intptr_t) aValue;
+if (!CallNPN_SetValue_NPPVpluginEventModel(eventModel, &rv))
+return NPERR_GENERIC_ERROR;
+#if defined(__i386__)
+mEventModel = static_cast<NPEventModel>(eventModel);
+#endif
+PLUGIN_LOG_DEBUG(("  Plugin requested event model id # %i\n",
+eventModel));
+return rv;
+}
+#endif
+default:
+PR_LOG(GetPluginLog(), PR_LOG_WARNING,
+("In PluginInstanceChild::NPN_SetValue: Unhandled NPPVariable %i (%s)",
+(int) aVar, NPPVariableToString(aVar)));
+return NPERR_GENERIC_ERROR;
+}
+}
+bool
+PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginWantsAllNetworkStreams(
+bool* wantsAllStreams, NPError* rv)
+{
+AssertPluginThread();
+uint32_t value = 0;
+if (!mPluginIface->getvalue) {
+*rv = NPERR_GENERIC_ERROR;
+}
+else {
+*rv = mPluginIface->getvalue(GetNPP(), NPPVpluginWantsAllNetworkStreams,
+&value);
+}
+*wantsAllStreams = value;
+return true;
+}
+bool
+PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginNeedsXEmbed(
+bool* needs, NPError* rv)
+{
+AssertPluginThread();
+#ifdef MOZ_X11
+// The documentation on the types for many variables in NP(N|P)_GetValue
+// is vague.  Often boolean values are NPBool (1 byte), but
+// https://developer.mozilla.org/en/XEmbed_Extension_for_Mozilla_Plugins
+// treats NPPVpluginNeedsXEmbed as PRBool (int), and
+// on x86/32-bit, flash stores to this using |movl 0x1,&needsXEmbed|.
+// thus we can't use NPBool for needsXEmbed, or the three bytes above
+// it on the stack would get clobbered. so protect with the larger bool.
+int needsXEmbed = 0;
+if (!mPluginIface->getvalue) {
+*rv = NPERR_GENERIC_ERROR;
+}
+else {
+*rv = mPluginIface->getvalue(GetNPP(), NPPVpluginNeedsXEmbed,
+&needsXEmbed);
+}
+*needs = needsXEmbed;
+return true;
+#else
+NS_RUNTIMEABORT("shouldn't be called on non-X11 platforms");
+return false;               // not reached
+#endif
+}
+bool
+PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginScriptableNPObject(
+PPluginScriptableObjectChild** aValue,
+NPError* aResult)
+{
+AssertPluginThread();
+NPObject* object = nullptr;
+NPError result = NPERR_GENERIC_ERROR;
+if (mPluginIface->getvalue) {
+result = mPluginIface->getvalue(GetNPP(), NPPVpluginScriptableNPObject,
+&object);
+}
+if (result == NPERR_NO_ERROR && object) {
+PluginScriptableObjectChild* actor = GetActorForNPObject(object);
+// If we get an actor then it has retained. Otherwise we don't need it
+// any longer.
+PluginModuleChild::sBrowserFuncs.releaseobject(object);
+if (actor) {
+*aValue = actor;
+*aResult = NPERR_NO_ERROR;
+return true;
+}
+NS_ERROR("Failed to get actor!");
+result = NPERR_GENERIC_ERROR;
+}
+else {
+result = NPERR_GENERIC_ERROR;
+}
+*aValue = nullptr;
+*aResult = result;
+return true;
+}
+bool
+PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(
+nsCString* aPlugId,
+NPError* aResult)
+{
+AssertPluginThread();
+#if MOZ_ACCESSIBILITY_ATK
+char* plugId = nullptr;
+NPError result = NPERR_GENERIC_ERROR;
+if (mPluginIface->getvalue) {
+result = mPluginIface->getvalue(GetNPP(),
+NPPVpluginNativeAccessibleAtkPlugId,
+&plugId);
+}
+*aPlugId = nsCString(plugId);
+*aResult = result;
+return true;
+#else
+NS_RUNTIMEABORT("shouldn't be called on non-ATK platforms");
+return false;
+#endif
+}
+bool
+PluginInstanceChild::AnswerNPP_SetValue_NPNVprivateModeBool(const bool& value,
+NPError* result)
+{
+if (!mPluginIface->setvalue) {
+*result = NPERR_GENERIC_ERROR;
+return true;
+}
+NPBool v = value;
+*result = mPluginIface->setvalue(GetNPP(), NPNVprivateModeBool, &v);
+return true;
+}
+bool
+PluginInstanceChild::AnswerNPP_HandleEvent(const NPRemoteEvent& event,
+int16_t* handled)
+{
+PLUGIN_LOG_DEBUG_FUNCTION;
+AssertPluginThread();
+#if defined(MOZ_X11) && defined(DEBUG)
+if (GraphicsExpose == event.event.type)
+PLUGIN_LOG_DEBUG(("  received drawable 0x%lx\n",
+event.event.xgraphicsexpose.drawable));
+#endif
+#ifdef XP_MACOSX
+// Mac OS X does not define an NPEvent structure. It defines more specific types.
+NPCocoaEvent evcopy = event.event;
+// event.contentsScaleFactor <= 0 is a signal we shouldn't use it,
+// for example when AnswerNPP_HandleEvent() is called from elsewhere
+// in the child process (not via rpc code from the parent process).
+if (event.contentsScaleFactor > 0) {
+mContentsScaleFactor = event.contentsScaleFactor;
+}
+// Make sure we reset mCurrentEvent in case of an exception
+AutoRestore<const NPCocoaEvent*> savePreviousEvent(mCurrentEvent);
+// Track the current event for NPN_PopUpContextMenu.
+mCurrentEvent = &event.event;
+#else
+// Make a copy since we may modify values.
+NPEvent evcopy = event.event;
+#endif
+#ifdef OS_WIN
+// FIXME/bug 567645: temporarily drop the "dummy event" on the floor
+if (WM_NULL == evcopy.event)
+return true;
+// Painting for win32. SharedSurfacePaint handles everything.
+if (mWindow.type == NPWindowTypeDrawable) {
+if (evcopy.event == WM_PAINT) {
+*handled = SharedSurfacePaint(evcopy);
+return true;
+}
+else if (DoublePassRenderingEvent() == evcopy.event) {
+// We'll render to mSharedSurfaceDib first, then render to a cached bitmap
+// we store locally. The two passes are for alpha extraction, so the second
+// pass must be to a flat white surface in order for things to work.
+mAlphaExtract.doublePass = RENDER_BACK_ONE;
+*handled = true;
+return true;
+}
+}
+*handled = WinlessHandleEvent(evcopy);
+return true;
+#endif
+// XXX A previous call to mPluginIface->event might block, e.g. right click
+// for context menu. Still, we might get here again, calling into the plugin
+// a second time while it's in the previous call.
+if (!mPluginIface->event)
+*handled = false;
+else
+*handled = mPluginIface->event(&mData, reinterpret_cast<void*>(&evcopy));
+#ifdef XP_MACOSX
+// Release any reference counted objects created in the child process.
+if (evcopy.type == NPCocoaEventKeyDown ||
+evcopy.type == NPCocoaEventKeyUp) {
+::CFRelease((CFStringRef)evcopy.data.key.characters);
+::CFRelease((CFStringRef)evcopy.data.key.charactersIgnoringModifiers);
+}
+else if (evcopy.type == NPCocoaEventTextInput) {
+::CFRelease((CFStringRef)evcopy.data.text.text);
+}
+#endif
+#ifdef MOZ_X11
+if (GraphicsExpose == event.event.type) {
+// Make sure the X server completes the drawing before the parent
+// draws on top and destroys the Drawable.
+//
+// XSync() waits for the X server to complete.  Really this child
+// process does not need to wait; the parent is the process that needs
+// to wait.  A possibly-slightly-better alternative would be to send
+// an X event to the parent that the parent would wait for.
+XSync(mWsInfo.display, False);
+}
+#endif
+return true;
+}
+#ifdef XP_MACOSX
+bool
+PluginInstanceChild::AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event,
+Shmem& mem,
+int16_t* handled,
+Shmem* rtnmem)
+{
+PLUGIN_LOG_DEBUG_FUNCTION;
+AssertPluginThread();
+PaintTracker pt;
+NPCocoaEvent evcopy = event.event;
+mContentsScaleFactor = event.contentsScaleFactor;
+if (evcopy.type == NPCocoaEventDrawRect) {
+int scaleFactor = ceil(mContentsScaleFactor);
+if (!mShColorSpace) {
+mShColorSpace = CreateSystemColorSpace();
+if (!mShColorSpace) {
+PLUGIN_LOG_DEBUG(("Could not allocate ColorSpace."));
+*handled = false;
+*rtnmem = mem;
+return true;
+}
+}
+if (!mShContext) {
+void* cgContextByte = mem.get<char>();
+mShContext = ::CGBitmapContextCreate(cgContextByte,
+mWindow.width * scaleFactor,
+mWindow.height * scaleFactor, 8,
+mWindow.width * 4 * scaleFactor, mShColorSpace,
+kCGImageAlphaPremultipliedFirst |
+kCGBitmapByteOrder32Host);
+if (!mShContext) {
+PLUGIN_LOG_DEBUG(("Could not allocate CGBitmapContext."));
+*handled = false;
+*rtnmem = mem;
+return true;
+}
+}
+CGRect clearRect = ::CGRectMake(0, 0, mWindow.width, mWindow.height);
+::CGContextClearRect(mShContext, clearRect);
+evcopy.data.draw.context = mShContext;
+} else {
+PLUGIN_LOG_DEBUG(("Invalid event type for AnswerNNP_HandleEvent_Shmem."));
+*handled = false;
+*rtnmem = mem;
+return true;
+}
+if (!mPluginIface->event) {
+*handled = false;
+} else {
+::CGContextSaveGState(evcopy.data.draw.context);
+*handled = mPluginIface->event(&mData, reinterpret_cast<void*>(&evcopy));
+::CGContextRestoreGState(evcopy.data.draw.context);
+}
+*rtnmem = mem;
+return true;
+}
+#else
+bool
+PluginInstanceChild::AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event,
+Shmem& mem,
+int16_t* handled,
+Shmem* rtnmem)
+{
+NS_RUNTIMEABORT("not reached.");
+*rtnmem = mem;
+return true;
+}
+#endif
+#ifdef XP_MACOSX
+void CallCGDraw(CGContextRef ref, void* aPluginInstance, nsIntRect aUpdateRect) {
+PluginInstanceChild* pluginInstance = (PluginInstanceChild*)aPluginInstance;
+pluginInstance->CGDraw(ref, aUpdateRect);
+}
+bool
+PluginInstanceChild::CGDraw(CGContextRef ref, nsIntRect aUpdateRect) {
+NPCocoaEvent drawEvent;
+drawEvent.type = NPCocoaEventDrawRect;
+drawEvent.version = 0;
+drawEvent.data.draw.x = aUpdateRect.x;
+drawEvent.data.draw.y = aUpdateRect.y;
+drawEvent.data.draw.width = aUpdateRect.width;
+drawEvent.data.draw.height = aUpdateRect.height;
+drawEvent.data.draw.context = ref;
+NPRemoteEvent remoteDrawEvent = {drawEvent};
+// Signal to AnswerNPP_HandleEvent() not to use this value
+remoteDrawEvent.contentsScaleFactor = -1.0;
+int16_t handled;
+AnswerNPP_HandleEvent(remoteDrawEvent, &handled);
+return handled == true;
+}
+bool
+PluginInstanceChild::AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event,
+const uint32_t &surfaceid,
+int16_t* handled)
+{
+PLUGIN_LOG_DEBUG_FUNCTION;
+AssertPluginThread();
+PaintTracker pt;
+NPCocoaEvent evcopy = event.event;
+mContentsScaleFactor = event.contentsScaleFactor;
+RefPtr<MacIOSurface> surf = MacIOSurface::LookupSurface(surfaceid,
+mContentsScaleFactor);
+if (!surf) {
+NS_ERROR("Invalid IOSurface.");
+*handled = false;
+return false;
+}
+if (!mCARenderer) {
+mCARenderer = new nsCARenderer();
+}
+if (evcopy.type == NPCocoaEventDrawRect) {
+mCARenderer->AttachIOSurface(surf);
+if (!mCARenderer->isInit()) {
+void *caLayer = nullptr;
+NPError result = mPluginIface->getvalue(GetNPP(),
+NPPVpluginCoreAnimationLayer,
+&caLayer);
+if (result != NPERR_NO_ERROR || !caLayer) {
+PLUGIN_LOG_DEBUG(("Plugin requested CoreAnimation but did not "
+"provide CALayer."));
+*handled = false;
+return false;
+}
+mCARenderer->SetupRenderer(caLayer, mWindow.width, mWindow.height,
+mContentsScaleFactor,
+GetQuirks() & PluginModuleChild::QUIRK_ALLOW_OFFLINE_RENDERER ?
+ALLOW_OFFLINE_RENDERER : DISALLOW_OFFLINE_RENDERER);
+// Flash needs to have the window set again after this step
+if (mPluginIface->setwindow)
+(void) mPluginIface->setwindow(&mData, &mWindow);
+}
+} else {
+PLUGIN_LOG_DEBUG(("Invalid event type for "
+"AnswerNNP_HandleEvent_IOSurface."));
+*handled = false;
+return false;
+}
+mCARenderer->Render(mWindow.width, mWindow.height,
+mContentsScaleFactor, nullptr);
+return true;
+}
+#else
+bool
+PluginInstanceChild::AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event,
+const uint32_t &surfaceid,
+int16_t* handled)
+{
+NS_RUNTIMEABORT("NPP_HandleEvent_IOSurface is a OSX-only message");
+return false;
+}
+#endif
+bool
+PluginInstanceChild::RecvWindowPosChanged(const NPRemoteEvent& event)
+{
+NS_ASSERTION(!mLayersRendering && !mPendingPluginCall,
+"Shouldn't be receiving WindowPosChanged with layer rendering");
+#ifdef OS_WIN
+int16_t dontcare;
+return AnswerNPP_HandleEvent(event, &dontcare);
+#else
+NS_RUNTIMEABORT("WindowPosChanged is a windows-only message");
+return false;
+#endif
+}
+bool
+PluginInstanceChild::RecvContentsScaleFactorChanged(const double& aContentsScaleFactor)
+{
+#ifdef XP_MACOSX
+mContentsScaleFactor = aContentsScaleFactor;
+if (mShContext) {
+// Release the shared context so that it is reallocated
+// with the new size.
+::CGContextRelease(mShContext);
+mShContext = nullptr;
+}
+return true;
+#else
+NS_RUNTIMEABORT("ContentsScaleFactorChanged is an OSX-only message");
+return false;
+#endif
+}
+#if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
+// Create a new window from NPWindow
+bool PluginInstanceChild::CreateWindow(const NPRemoteWindow& aWindow)
+{
+PLUGIN_LOG_DEBUG(("%s (aWindow=<window: 0x%lx, x: %d, y: %d, width: %d, height: %d>)",
+FULLFUNCTION,
+aWindow.window,
+aWindow.x, aWindow.y,
+aWindow.width, aWindow.height));
+#if (MOZ_WIDGET_GTK == 2)
+if (mXEmbed) {
+mWindow.window = reinterpret_cast<void*>(aWindow.window);
+}
+else {
+Window browserSocket = (Window)(aWindow.window);
+xt_client_init(&mXtClient, mWsInfo.visual, mWsInfo.colormap, mWsInfo.depth);
+xt_client_create(&mXtClient, browserSocket, mWindow.width, mWindow.height);
+mWindow.window = (void *)XtWindow(mXtClient.child_widget);
+}
+#else
+mWindow.window = reinterpret_cast<void*>(aWindow.window);
+#endif
+return true;
+}
+// Destroy window
+void PluginInstanceChild::DeleteWindow()
+{
+PLUGIN_LOG_DEBUG(("%s (aWindow=<window: 0x%lx, x: %d, y: %d, width: %d, height: %d>)",
+FULLFUNCTION,
+mWindow.window,
+mWindow.x, mWindow.y,
+mWindow.width, mWindow.height));
+if (!mWindow.window)
+return;
+#if (MOZ_WIDGET_GTK == 2)
+if (mXtClient.top_widget) {
+xt_client_unrealize(&mXtClient);
+xt_client_destroy(&mXtClient);
+mXtClient.top_widget = nullptr;
+}
+#endif
+// We don't have to keep the plug-in window ID any longer.
+mWindow.window = nullptr;
+}
+#endif
+bool
+PluginInstanceChild::AnswerNPP_SetWindow(const NPRemoteWindow& aWindow)
+{
+PLUGIN_LOG_DEBUG(("%s (aWindow=<window: 0x%lx, x: %d, y: %d, width: %d, height: %d>)",
+FULLFUNCTION,
+aWindow.window,
+aWindow.x, aWindow.y,
+aWindow.width, aWindow.height));
+NS_ASSERTION(!mLayersRendering && !mPendingPluginCall,
+"Shouldn't be receiving NPP_SetWindow with layer rendering");
+AssertPluginThread();
+#if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
+NS_ASSERTION(mWsInfo.display, "We should have a valid display!");
+// The minimum info is sent over IPC to allow this
+// code to determine the rest.
+mWindow.x = aWindow.x;
+mWindow.y = aWindow.y;
+mWindow.width = aWindow.width;
+mWindow.height = aWindow.height;
+mWindow.clipRect = aWindow.clipRect;
+mWindow.type = aWindow.type;
+mWsInfo.colormap = aWindow.colormap;
+int depth;
+FindVisualAndDepth(mWsInfo.display, aWindow.visualID,
+&mWsInfo.visual, &depth);
+mWsInfo.depth = depth;
+if (!mWindow.window && mWindow.type == NPWindowTypeWindow) {
+CreateWindow(aWindow);
+}
+#if (MOZ_WIDGET_GTK == 2)
+if (mXEmbed && gtk_check_version(2,18,7) != nullptr) { // older
+if (aWindow.type == NPWindowTypeWindow) {
+GdkWindow* socket_window = gdk_window_lookup(static_cast<GdkNativeWindow>(aWindow.window));
+if (socket_window) {
+// A GdkWindow for the socket already exists.  Need to
+// workaround https://bugzilla.gnome.org/show_bug.cgi?id=607061
+// See wrap_gtk_plug_embedded in PluginModuleChild.cpp.
+g_object_set_data(G_OBJECT(socket_window),
+"moz-existed-before-set-window",
+GUINT_TO_POINTER(1));
+}
+}
+if (aWindow.visualID != None
+&& gtk_check_version(2, 12, 10) != nullptr) { // older
+// Workaround for a bug in Gtk+ (prior to 2.12.10) where deleting
+// a foreign GdkColormap will also free the XColormap.
+// http://git.gnome.org/browse/gtk+/log/gdk/x11/gdkcolor-x11.c?id=GTK_2_12_10
+GdkVisual *gdkvisual = gdkx_visual_get(aWindow.visualID);
+GdkColormap *gdkcolor =
+gdk_x11_colormap_foreign_new(gdkvisual, aWindow.colormap);
+if (g_object_get_data(G_OBJECT(gdkcolor), "moz-have-extra-ref")) {
+// We already have a ref to keep the object alive.
+g_object_unref(gdkcolor);
+} else {
+// leak and mark as already leaked
+g_object_set_data(G_OBJECT(gdkcolor),
+"moz-have-extra-ref", GUINT_TO_POINTER(1));
+}
+}
+}
+#endif
+PLUGIN_LOG_DEBUG(
+("[InstanceChild][%p] Answer_SetWindow w=<x=%d,y=%d, w=%d,h=%d>, clip=<l=%d,t=%d,r=%d,b=%d>",
+this, mWindow.x, mWindow.y, mWindow.width, mWindow.height,
+mWindow.clipRect.left, mWindow.clipRect.top, mWindow.clipRect.right, mWindow.clipRect.bottom));
+if (mPluginIface->setwindow)
+(void) mPluginIface->setwindow(&mData, &mWindow);
+#elif defined(OS_WIN)
+switch (aWindow.type) {
+case NPWindowTypeWindow:
+{
+if ((GetQuirks() & PluginModuleChild::QUIRK_QUICKTIME_AVOID_SETWINDOW) &&
+aWindow.width == 0 &&
+aWindow.height == 0) {
+// Skip SetWindow call for hidden QuickTime plugins
+return true;
+}
+if (!CreatePluginWindow())
+return false;
+ReparentPluginWindow(reinterpret_cast<HWND>(aWindow.window));
+SizePluginWindow(aWindow.width, aWindow.height);
+mWindow.window = (void*)mPluginWindowHWND;
+mWindow.x = aWindow.x;
+mWindow.y = aWindow.y;
+mWindow.width = aWindow.width;
+mWindow.height = aWindow.height;
+mWindow.type = aWindow.type;
+if (mPluginIface->setwindow) {
+SetProp(mPluginWindowHWND, kPluginIgnoreSubclassProperty, (HANDLE)1);
+(void) mPluginIface->setwindow(&mData, &mWindow);
+WNDPROC wndProc = reinterpret_cast<WNDPROC>(
+GetWindowLongPtr(mPluginWindowHWND, GWLP_WNDPROC));
+if (wndProc != PluginWindowProc) {
+mPluginWndProc = reinterpret_cast<WNDPROC>(
+SetWindowLongPtr(mPluginWindowHWND, GWLP_WNDPROC,
+reinterpret_cast<LONG_PTR>(PluginWindowProc)));
+NS_ASSERTION(mPluginWndProc != PluginWindowProc, "WTF?");
+}
+RemoveProp(mPluginWindowHWND, kPluginIgnoreSubclassProperty);
+HookSetWindowLongPtr();
+}
+}
+break;
+case NPWindowTypeDrawable:
+mWindow.type = aWindow.type;
+if (GetQuirks() & PluginModuleChild::QUIRK_WINLESS_TRACKPOPUP_HOOK)
+CreateWinlessPopupSurrogate();
+if (GetQuirks() & PluginModuleChild::QUIRK_FLASH_THROTTLE_WMUSER_EVENTS)
+SetupFlashMsgThrottle();
+return SharedSurfaceSetWindow(aWindow);
+break;
+default:
+NS_NOTREACHED("Bad plugin window type.");
+return false;
+break;
+}
+#elif defined(XP_MACOSX)
+mWindow.x = aWindow.x;
+mWindow.y = aWindow.y;
+mWindow.width = aWindow.width;
+mWindow.height = aWindow.height;
+mWindow.clipRect = aWindow.clipRect;
+mWindow.type = aWindow.type;
+mContentsScaleFactor = aWindow.contentsScaleFactor;
+if (mShContext) {
+// Release the shared context so that it is reallocated
+// with the new size.
+::CGContextRelease(mShContext);
+mShContext = nullptr;
+}
+if (mPluginIface->setwindow)
+(void) mPluginIface->setwindow(&mData, &mWindow);
+#elif defined(ANDROID)
+// TODO: Need Android impl
+#elif defined(MOZ_WIDGET_QT)
+// TODO: Need QT-nonX impl
+#else
+#  error Implement me for your OS
+#endif
+return true;
+}
+bool
+PluginInstanceChild::Initialize()
+{
+#if (MOZ_WIDGET_GTK == 2)
+NPError rv;
+if (mWsInfo.display) {
+// Already initialized
+return false;
+}
+// Request for windowless plugins is set in newp(), before this call.
+if (mWindow.type == NPWindowTypeWindow) {
+AnswerNPP_GetValue_NPPVpluginNeedsXEmbed(&mXEmbed, &rv);
+// Set up Xt loop for windowed plugins without XEmbed support
+if (!mXEmbed) {
+xt_client_xloop_create();
+}
+}
+// Use default GTK display for XEmbed and windowless plugins
+if (mXEmbed || mWindow.type != NPWindowTypeWindow) {
+mWsInfo.display = DefaultXDisplay();
+}
+else {
+mWsInfo.display = xt_client_get_display();
+}
+#endif
+return true;
+}
+#if defined(OS_WIN)
+static const TCHAR kWindowClassName[] = TEXT("GeckoPluginWindow");
+static const TCHAR kPluginInstanceChildProperty[] = TEXT("PluginInstanceChildProperty");
+static const TCHAR kFlashThrottleProperty[] = TEXT("MozillaFlashThrottleProperty");
+// static
+bool
+PluginInstanceChild::RegisterWindowClass()
+{
+static bool alreadyRegistered = false;
+if (alreadyRegistered)
+return true;
+alreadyRegistered = true;
+WNDCLASSEX wcex;
+wcex.cbSize         = sizeof(WNDCLASSEX);
+wcex.style          = CS_DBLCLKS;
+wcex.lpfnWndProc    = DummyWindowProc;
+wcex.cbClsExtra     = 0;
+wcex.cbWndExtra     = 0;
+wcex.hInstance      = GetModuleHandle(nullptr);
+wcex.hIcon          = 0;
+wcex.hCursor        = 0;
+wcex.hbrBackground  = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
+wcex.lpszMenuName   = 0;
+wcex.lpszClassName  = kWindowClassName;
+wcex.hIconSm        = 0;
+return RegisterClassEx(&wcex) ? true : false;
+}
+bool
+PluginInstanceChild::CreatePluginWindow()
+{
+// already initialized
+if (mPluginWindowHWND)
+return true;
+if (!RegisterWindowClass())
+return false;
+mPluginWindowHWND =
+CreateWindowEx(WS_EX_LEFT | WS_EX_LTRREADING |
+WS_EX_NOPARENTNOTIFY | // XXXbent Get rid of this!
+WS_EX_RIGHTSCROLLBAR,
+kWindowClassName, 0,
+WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0, 0,
+0, 0, nullptr, 0, GetModuleHandle(nullptr), 0);
+if (!mPluginWindowHWND)
+return false;
+if (!SetProp(mPluginWindowHWND, kPluginInstanceChildProperty, this))
+return false;
+// Apparently some plugins require an ASCII WndProc.
+SetWindowLongPtrA(mPluginWindowHWND, GWLP_WNDPROC,
+reinterpret_cast<LONG_PTR>(DefWindowProcA));
+return true;
+}
+void
+PluginInstanceChild::DestroyPluginWindow()
+{
+if (mPluginWindowHWND) {
+// Unsubclass the window.
+WNDPROC wndProc = reinterpret_cast<WNDPROC>(
+GetWindowLongPtr(mPluginWindowHWND, GWLP_WNDPROC));
+// Removed prior to SetWindowLongPtr, see HookSetWindowLongPtr.
+RemoveProp(mPluginWindowHWND, kPluginInstanceChildProperty);
+if (wndProc == PluginWindowProc) {
+NS_ASSERTION(mPluginWndProc, "Should have old proc here!");
+SetWindowLongPtr(mPluginWindowHWND, GWLP_WNDPROC,
+reinterpret_cast<LONG_PTR>(mPluginWndProc));
+mPluginWndProc = 0;
+}
+DestroyWindow(mPluginWindowHWND);
+mPluginWindowHWND = 0;
+}
+}
+void
+PluginInstanceChild::ReparentPluginWindow(HWND hWndParent)
+{
+if (hWndParent != mPluginParentHWND && IsWindow(hWndParent)) {
+// Fix the child window's style to be a child window.
+LONG_PTR style = GetWindowLongPtr(mPluginWindowHWND, GWL_STYLE);
+style |= WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
+style &= ~WS_POPUP;
+SetWindowLongPtr(mPluginWindowHWND, GWL_STYLE, style);
+// Do the reparenting.
+SetParent(mPluginWindowHWND, hWndParent);
+// Make sure we're visible.
+ShowWindow(mPluginWindowHWND, SW_SHOWNA);
+}
+mPluginParentHWND = hWndParent;
+}
+void
+PluginInstanceChild::SizePluginWindow(int width,
+int height)
+{
+if (mPluginWindowHWND) {
+mPluginSize.x = width;
+mPluginSize.y = height;
+SetWindowPos(mPluginWindowHWND, nullptr, 0, 0, width, height,
+SWP_NOZORDER | SWP_NOREPOSITION);
+}
+}
+// See chromium's webplugin_delegate_impl.cc for explanation of this function.
+// static
+LRESULT CALLBACK
+PluginInstanceChild::DummyWindowProc(HWND hWnd,
+UINT message,
+WPARAM wParam,
+LPARAM lParam)
+{
+return CallWindowProc(DefWindowProc, hWnd, message, wParam, lParam);
+}
+// static
+LRESULT CALLBACK
+PluginInstanceChild::PluginWindowProc(HWND hWnd,
+UINT message,
+WPARAM wParam,
+LPARAM lParam)
+{
+return mozilla::CallWindowProcCrashProtected(PluginWindowProcInternal, hWnd, message, wParam, lParam);
+}
+// static
+LRESULT CALLBACK
+PluginInstanceChild::PluginWindowProcInternal(HWND hWnd,
+UINT message,
+WPARAM wParam,
+LPARAM lParam)
+{
+NS_ASSERTION(!mozilla::ipc::MessageChannel::IsPumpingMessages(),
+"Failed to prevent a nonqueued message from running!");
+PluginInstanceChild* self = reinterpret_cast<PluginInstanceChild*>(
+GetProp(hWnd, kPluginInstanceChildProperty));
+if (!self) {
+NS_NOTREACHED("Badness!");
+return 0;
+}
+NS_ASSERTION(self->mPluginWindowHWND == hWnd, "Wrong window!");
+NS_ASSERTION(self->mPluginWndProc != PluginWindowProc, "Self-referential windowproc. Infinite recursion will happen soon.");
+// Adobe's shockwave positions the plugin window relative to the browser
+// frame when it initializes. With oopp disabled, this wouldn't have an
+// effect. With oopp, GeckoPluginWindow is a child of the parent plugin
+// window, so the move offsets the child within the parent. Generally
+// we don't want plugins moving or sizing our window, so we prevent these
+// changes here.
+if (message == WM_WINDOWPOSCHANGING) {
+WINDOWPOS* pos = reinterpret_cast<WINDOWPOS*>(lParam);
+if (pos && (!(pos->flags & SWP_NOMOVE) || !(pos->flags & SWP_NOSIZE))) {
+pos->x = pos->y = 0;
+pos->cx = self->mPluginSize.x;
+pos->cy = self->mPluginSize.y;
+LRESULT res = CallWindowProc(self->mPluginWndProc, hWnd, message, wParam,
+lParam);
+pos->x = pos->y = 0;
+pos->cx = self->mPluginSize.x;
+pos->cy = self->mPluginSize.y;
+return res;
+}
+}
+// The plugin received keyboard focus, let the parent know so the dom is up to date.
+if (message == WM_MOUSEACTIVATE)
+self->CallPluginFocusChange(true);
+// Prevent lockups due to plugins making rpc calls when the parent
+// is making a synchronous SendMessage call to the child window. Add
+// more messages as needed.
+if ((InSendMessageEx(nullptr)&(ISMEX_REPLIED|ISMEX_SEND)) == ISMEX_SEND) {
+switch(message) {
+case WM_KILLFOCUS:
+ReplyMessage(0);
+break;
+}
+}
+if (message == WM_KILLFOCUS)
+self->CallPluginFocusChange(false);
+if (message == WM_USER+1 &&
+(self->GetQuirks() & PluginModuleChild::QUIRK_FLASH_THROTTLE_WMUSER_EVENTS)) {
+self->FlashThrottleMessage(hWnd, message, wParam, lParam, true);
+return 0;
+}
+NS_ASSERTION(self->mPluginWndProc != PluginWindowProc,
+"Self-referential windowproc happened inside our hook proc. "
+"Infinite recursion will happen soon.");
+LRESULT res = CallWindowProc(self->mPluginWndProc, hWnd, message, wParam,
+lParam);
+// Make sure capture is released by the child on mouse events. Fixes a
+// problem with flash full screen mode mouse input. Appears to be
+// caused by a bug in flash, since we are not setting the capture
+// on the window.
+if (message == WM_LBUTTONDOWN &&
+self->GetQuirks() & PluginModuleChild::QUIRK_FLASH_FIXUP_MOUSE_CAPTURE) {
+wchar_t szClass[26];
+HWND hwnd = GetForegroundWindow();
+if (hwnd && GetClassNameW(hwnd, szClass,
+sizeof(szClass)/sizeof(char16_t)) &&
+!wcscmp(szClass, kFlashFullscreenClass)) {
+ReleaseCapture();
+SetFocus(hwnd);
+}
+}
+if (message == WM_CLOSE)
+self->DestroyPluginWindow();
+if (message == WM_NCDESTROY)
+RemoveProp(hWnd, kPluginInstanceChildProperty);
+return res;
+}
+/* set window long ptr hook for flash */
+/*
+* Flash will reset the subclass of our widget at various times.
+* (Notably when entering and exiting full screen mode.) This
+* occurs independent of the main plugin window event procedure.
+* We trap these subclass calls to prevent our subclass hook from
+* getting dropped.
+* Note, ascii versions can be nixed once flash versions < 10.1
+* are considered obsolete.
+*/
+#ifdef _WIN64
+typedef LONG_PTR
+(WINAPI *User32SetWindowLongPtrA)(HWND hWnd,
+int nIndex,
+LONG_PTR dwNewLong);
+typedef LONG_PTR
+(WINAPI *User32SetWindowLongPtrW)(HWND hWnd,
+int nIndex,
+LONG_PTR dwNewLong);
+static User32SetWindowLongPtrA sUser32SetWindowLongAHookStub = nullptr;
+static User32SetWindowLongPtrW sUser32SetWindowLongWHookStub = nullptr;
+#else
+typedef LONG
+(WINAPI *User32SetWindowLongA)(HWND hWnd,
+int nIndex,
+LONG dwNewLong);
+typedef LONG
+(WINAPI *User32SetWindowLongW)(HWND hWnd,
+int nIndex,
+LONG dwNewLong);
+static User32SetWindowLongA sUser32SetWindowLongAHookStub = nullptr;
+static User32SetWindowLongW sUser32SetWindowLongWHookStub = nullptr;
+#endif
+extern LRESULT CALLBACK
+NeuteredWindowProc(HWND hwnd,
+UINT uMsg,
+WPARAM wParam,
+LPARAM lParam);
+const wchar_t kOldWndProcProp[] = L"MozillaIPCOldWndProc";
+// static
+bool
+PluginInstanceChild::SetWindowLongHookCheck(HWND hWnd,
+int nIndex,
+LONG_PTR newLong)
+{
+// Let this go through if it's not a subclass
+if (nIndex != GWLP_WNDPROC ||
+// if it's not a subclassed plugin window
+!GetProp(hWnd, kPluginInstanceChildProperty) ||
+// if we're not disabled
+GetProp(hWnd, kPluginIgnoreSubclassProperty) ||
+// if the subclass is set to a known procedure
+newLong == reinterpret_cast<LONG_PTR>(PluginWindowProc) ||
+newLong == reinterpret_cast<LONG_PTR>(NeuteredWindowProc) ||
+newLong == reinterpret_cast<LONG_PTR>(DefWindowProcA) ||
+newLong == reinterpret_cast<LONG_PTR>(DefWindowProcW) ||
+// if the subclass is a WindowsMessageLoop subclass restore
+GetProp(hWnd, kOldWndProcProp))
+return true;
+// prevent the subclass
+return false;
+}
+#ifdef _WIN64
+LONG_PTR WINAPI
+PluginInstanceChild::SetWindowLongPtrAHook(HWND hWnd,
+int nIndex,
+LONG_PTR newLong)
+#else
+LONG WINAPI
+PluginInstanceChild::SetWindowLongAHook(HWND hWnd,
+int nIndex,
+LONG newLong)
+#endif
+{
+if (SetWindowLongHookCheck(hWnd, nIndex, newLong))
+return sUser32SetWindowLongAHookStub(hWnd, nIndex, newLong);
+// Set flash's new subclass to get the result.
+LONG_PTR proc = sUser32SetWindowLongAHookStub(hWnd, nIndex, newLong);
+// We already checked this in SetWindowLongHookCheck
+PluginInstanceChild* self = reinterpret_cast<PluginInstanceChild*>(
+GetProp(hWnd, kPluginInstanceChildProperty));
+// Hook our subclass back up, just like we do on setwindow.
+WNDPROC currentProc =
+reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_WNDPROC));
+if (currentProc != PluginWindowProc) {
+self->mPluginWndProc =
+reinterpret_cast<WNDPROC>(sUser32SetWindowLongWHookStub(hWnd, nIndex,
+reinterpret_cast<LONG_PTR>(PluginWindowProc)));
+NS_ASSERTION(self->mPluginWndProc != PluginWindowProc, "Infinite recursion coming up!");
+}
+return proc;
+}
+#ifdef _WIN64
+LONG_PTR WINAPI
+PluginInstanceChild::SetWindowLongPtrWHook(HWND hWnd,
+int nIndex,
+LONG_PTR newLong)
+#else
+LONG WINAPI
+PluginInstanceChild::SetWindowLongWHook(HWND hWnd,
+int nIndex,
+LONG newLong)
+#endif
+{
+if (SetWindowLongHookCheck(hWnd, nIndex, newLong))
+return sUser32SetWindowLongWHookStub(hWnd, nIndex, newLong);
+// Set flash's new subclass to get the result.
+LONG_PTR proc = sUser32SetWindowLongWHookStub(hWnd, nIndex, newLong);
+// We already checked this in SetWindowLongHookCheck
+PluginInstanceChild* self = reinterpret_cast<PluginInstanceChild*>(
+GetProp(hWnd, kPluginInstanceChildProperty));
+// Hook our subclass back up, just like we do on setwindow.
+WNDPROC currentProc =
+reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_WNDPROC));
+if (currentProc != PluginWindowProc) {
+self->mPluginWndProc =
+reinterpret_cast<WNDPROC>(sUser32SetWindowLongWHookStub(hWnd, nIndex,
+reinterpret_cast<LONG_PTR>(PluginWindowProc)));
+NS_ASSERTION(self->mPluginWndProc != PluginWindowProc, "Infinite recursion coming up!");
+}
+return proc;
+}
+void
+PluginInstanceChild::HookSetWindowLongPtr()
+{
+if (!(GetQuirks() & PluginModuleChild::QUIRK_FLASH_HOOK_SETLONGPTR))
+return;
+sUser32Intercept.Init("user32.dll");
+#ifdef _WIN64
+if (!sUser32SetWindowLongAHookStub)
+sUser32Intercept.AddHook("SetWindowLongPtrA", reinterpret_cast<intptr_t>(SetWindowLongPtrAHook),
+(void**) &sUser32SetWindowLongAHookStub);
+if (!sUser32SetWindowLongWHookStub)
+sUser32Intercept.AddHook("SetWindowLongPtrW", reinterpret_cast<intptr_t>(SetWindowLongPtrWHook),
+(void**) &sUser32SetWindowLongWHookStub);
+#else
+if (!sUser32SetWindowLongAHookStub)
+sUser32Intercept.AddHook("SetWindowLongA", reinterpret_cast<intptr_t>(SetWindowLongAHook),
+(void**) &sUser32SetWindowLongAHookStub);
+if (!sUser32SetWindowLongWHookStub)
+sUser32Intercept.AddHook("SetWindowLongW", reinterpret_cast<intptr_t>(SetWindowLongWHook),
+(void**) &sUser32SetWindowLongWHookStub);
+#endif
+}
+/* windowless track popup menu helpers */
+BOOL
+WINAPI
+PluginInstanceChild::TrackPopupHookProc(HMENU hMenu,
+UINT uFlags,
+int x,
+int y,
+int nReserved,
+HWND hWnd,
+CONST RECT *prcRect)
+{
+if (!sUser32TrackPopupMenuStub) {
+NS_ERROR("TrackPopupMenu stub isn't set! Badness!");
+return 0;
+}
+// Only change the parent when we know this is a context on the plugin
+// surface within the browser. Prevents resetting the parent on child ui
+// displayed by plugins that have working parent-child relationships.
+wchar_t szClass[21];
+bool haveClass = GetClassNameW(hWnd, szClass, ArrayLength(szClass));
+if (!haveClass ||
+(wcscmp(szClass, L"MozillaWindowClass") &&
+wcscmp(szClass, L"SWFlash_Placeholder"))) {
+// Unrecognized parent
+return sUser32TrackPopupMenuStub(hMenu, uFlags, x, y, nReserved,
+hWnd, prcRect);
+}
+// Called on an unexpected event, warn.
+if (!sWinlessPopupSurrogateHWND) {
+NS_WARNING(
+"Untraced TrackPopupHookProc call! Menu might not work right!");
+return sUser32TrackPopupMenuStub(hMenu, uFlags, x, y, nReserved,
+hWnd, prcRect);
+}
+HWND surrogateHwnd = sWinlessPopupSurrogateHWND;
+sWinlessPopupSurrogateHWND = nullptr;
+// Popups that don't use TPM_RETURNCMD expect a final command message
+// when an item is selected and the context closes. Since we replace
+// the parent, we need to forward this back to the real parent so it
+// can act on the menu item selected.
+bool isRetCmdCall = (uFlags & TPM_RETURNCMD);
+DWORD res = sUser32TrackPopupMenuStub(hMenu, uFlags|TPM_RETURNCMD, x, y,
+nReserved, surrogateHwnd, prcRect);
+if (!isRetCmdCall && res) {
+SendMessage(hWnd, WM_COMMAND, MAKEWPARAM(res, 0), 0);
+}
+return res;
+}
+void
+PluginInstanceChild::InitPopupMenuHook()
+{
+if (!(GetQuirks() & PluginModuleChild::QUIRK_WINLESS_TRACKPOPUP_HOOK) ||
+sUser32TrackPopupMenuStub)
+return;
+// Note, once WindowsDllInterceptor is initialized for a module,
+// it remains initialized for that particular module for it's
+// lifetime. Additional instances are needed if other modules need
+// to be hooked.
+if (!sUser32TrackPopupMenuStub) {
+sUser32Intercept.Init("user32.dll");
+sUser32Intercept.AddHook("TrackPopupMenu", reinterpret_cast<intptr_t>(TrackPopupHookProc),
+(void**) &sUser32TrackPopupMenuStub);
+}
+}
+void
+PluginInstanceChild::CreateWinlessPopupSurrogate()
+{
+// already initialized
+if (mWinlessPopupSurrogateHWND)
+return;
+HWND hwnd = nullptr;
+NPError result;
+if (!CallNPN_GetValue_NPNVnetscapeWindow(&hwnd, &result)) {
+NS_ERROR("CallNPN_GetValue_NPNVnetscapeWindow failed.");
+return;
+}
+mWinlessPopupSurrogateHWND =
+CreateWindowEx(WS_EX_NOPARENTNOTIFY, L"Static", nullptr, WS_CHILD,
+0, 0, 0, 0, hwnd, 0, GetModuleHandle(nullptr), 0);
+if (!mWinlessPopupSurrogateHWND) {
+NS_ERROR("CreateWindowEx failed for winless placeholder!");
+return;
+}
+return;
+}
+void
+PluginInstanceChild::DestroyWinlessPopupSurrogate()
+{
+if (mWinlessPopupSurrogateHWND)
+DestroyWindow(mWinlessPopupSurrogateHWND);
+mWinlessPopupSurrogateHWND = nullptr;
+}
+int16_t
+PluginInstanceChild::WinlessHandleEvent(NPEvent& event)
+{
+if (!mPluginIface->event)
+return false;
+// Events that might generate nested event dispatch loops need
+// special handling during delivery.
+int16_t handled;
+HWND focusHwnd = nullptr;
+// TrackPopupMenu will fail if the parent window is not associated with
+// our ui thread. So we hook TrackPopupMenu so we can hand in a surrogate
+// parent created in the child process.
+if ((GetQuirks() & PluginModuleChild::QUIRK_WINLESS_TRACKPOPUP_HOOK) && // XXX turn on by default?
+(event.event == WM_RBUTTONDOWN || // flash
+event.event == WM_RBUTTONUP)) {  // silverlight
+sWinlessPopupSurrogateHWND = mWinlessPopupSurrogateHWND;
+// A little trick scrounged from chromium's code - set the focus
+// to our surrogate parent so keyboard nav events go to the menu.
+focusHwnd = SetFocus(mWinlessPopupSurrogateHWND);
+}
+MessageLoop* loop = MessageLoop::current();
+AutoRestore<bool> modalLoop(loop->os_modal_loop());
+handled = mPluginIface->event(&mData, reinterpret_cast<void*>(&event));
+sWinlessPopupSurrogateHWND = nullptr;
+if (IsWindow(focusHwnd)) {
+SetFocus(focusHwnd);
+}
+return handled;
+}
+/* windowless drawing helpers */
+bool
+PluginInstanceChild::SharedSurfaceSetWindow(const NPRemoteWindow& aWindow)
+{
+// If the surfaceHandle is empty, parent is telling us we can reuse our cached
+// memory surface and hdc. Otherwise, we need to reset, usually due to a
+// expanding plugin port size.
+if (!aWindow.surfaceHandle) {
+if (!mSharedSurfaceDib.IsValid()) {
+return false;
+}
+}
+else {
+// Attach to the new shared surface parent handed us.
+if (NS_FAILED(mSharedSurfaceDib.Attach((SharedDIB::Handle)aWindow.surfaceHandle,
+aWindow.width, aWindow.height, false)))
+return false;
+// Free any alpha extraction resources if needed. This will be reset
+// the next time it's used.
+AlphaExtractCacheRelease();
+}
+// NPRemoteWindow's origin is the origin of our shared dib.
+mWindow.x      = aWindow.x;
+mWindow.y      = aWindow.y;
+mWindow.width  = aWindow.width;
+mWindow.height = aWindow.height;
+mWindow.type   = aWindow.type;
+mWindow.window = reinterpret_cast<void*>(mSharedSurfaceDib.GetHDC());
+::SetViewportOrgEx(mSharedSurfaceDib.GetHDC(),
+-aWindow.x, -aWindow.y, nullptr);
+if (mPluginIface->setwindow)
+mPluginIface->setwindow(&mData, &mWindow);
+return true;
+}
+void
+PluginInstanceChild::SharedSurfaceRelease()
+{
+mSharedSurfaceDib.Close();
+AlphaExtractCacheRelease();
+}
+/* double pass cache buffer - (rarely) used in cases where alpha extraction
+* occurs for windowless plugins. */
+bool
+PluginInstanceChild::AlphaExtractCacheSetup()
+{
+AlphaExtractCacheRelease();
+mAlphaExtract.hdc = ::CreateCompatibleDC(nullptr);
+if (!mAlphaExtract.hdc)
+return false;
+BITMAPINFOHEADER bmih;
+memset((void*)&bmih, 0, sizeof(BITMAPINFOHEADER));
+bmih.biSize        = sizeof(BITMAPINFOHEADER);
+bmih.biWidth       = mWindow.width;
+bmih.biHeight      = mWindow.height;
+bmih.biPlanes      = 1;
+bmih.biBitCount    = 32;
+bmih.biCompression = BI_RGB;
+void* ppvBits = nullptr;
+mAlphaExtract.bmp = ::CreateDIBSection(mAlphaExtract.hdc,
+(BITMAPINFO*)&bmih,
+DIB_RGB_COLORS,
+(void**)&ppvBits,
+nullptr,
+(unsigned long)sizeof(BITMAPINFOHEADER));
+if (!mAlphaExtract.bmp)
+return false;
+DeleteObject(::SelectObject(mAlphaExtract.hdc, mAlphaExtract.bmp));
+return true;
+}
+void
+PluginInstanceChild::AlphaExtractCacheRelease()
+{
+if (mAlphaExtract.bmp)
+::DeleteObject(mAlphaExtract.bmp);
+if (mAlphaExtract.hdc)
+::DeleteObject(mAlphaExtract.hdc);
+mAlphaExtract.bmp = nullptr;
+mAlphaExtract.hdc = nullptr;
+}
+void
+PluginInstanceChild::UpdatePaintClipRect(RECT* aRect)
+{
+if (aRect) {
+// Update the clip rect on our internal hdc
+HRGN clip = ::CreateRectRgnIndirect(aRect);
+::SelectClipRgn(mSharedSurfaceDib.GetHDC(), clip);
+::DeleteObject(clip);
+}
+}
+int16_t
+PluginInstanceChild::SharedSurfacePaint(NPEvent& evcopy)
+{
+if (!mPluginIface->event)
+return false;
+RECT* pRect = reinterpret_cast<RECT*>(evcopy.lParam);
+switch(mAlphaExtract.doublePass) {
+case RENDER_NATIVE:
+// pass the internal hdc to the plugin
+UpdatePaintClipRect(pRect);
+evcopy.wParam = WPARAM(mSharedSurfaceDib.GetHDC());
+return mPluginIface->event(&mData, reinterpret_cast<void*>(&evcopy));
+break;
+case RENDER_BACK_ONE:
+// Handle a double pass render used in alpha extraction for transparent
+// plugins. (See nsObjectFrame and gfxWindowsNativeDrawing for details.)
+// We render twice, once to the shared dib, and once to a cache which
+// we copy back on a second paint. These paints can't be spread across
+// multiple rpc messages as delays cause animation frame changes.
+if (!mAlphaExtract.bmp && !AlphaExtractCacheSetup()) {
+mAlphaExtract.doublePass = RENDER_NATIVE;
+return false;
+}
+// See gfxWindowsNativeDrawing, color order doesn't have to match.
+UpdatePaintClipRect(pRect);
+::FillRect(mSharedSurfaceDib.GetHDC(), pRect, (HBRUSH)GetStockObject(WHITE_BRUSH));
+evcopy.wParam = WPARAM(mSharedSurfaceDib.GetHDC());
+if (!mPluginIface->event(&mData, reinterpret_cast<void*>(&evcopy))) {
+mAlphaExtract.doublePass = RENDER_NATIVE;
+return false;
+}
+// Copy to cache. We render to shared dib so we don't have to call
+// setwindow between calls (flash issue).
+::BitBlt(mAlphaExtract.hdc,
+pRect->left,
+pRect->top,
+pRect->right - pRect->left,
+pRect->bottom - pRect->top,
+mSharedSurfaceDib.GetHDC(),
+pRect->left,
+pRect->top,
+SRCCOPY);
+::FillRect(mSharedSurfaceDib.GetHDC(), pRect, (HBRUSH)GetStockObject(BLACK_BRUSH));
+if (!mPluginIface->event(&mData, reinterpret_cast<void*>(&evcopy))) {
+mAlphaExtract.doublePass = RENDER_NATIVE;
+return false;
+}
+mAlphaExtract.doublePass = RENDER_BACK_TWO;
+return true;
+break;
+case RENDER_BACK_TWO:
+// copy our cached surface back
+UpdatePaintClipRect(pRect);
+::BitBlt(mSharedSurfaceDib.GetHDC(),
+pRect->left,
+pRect->top,
+pRect->right - pRect->left,
+pRect->bottom - pRect->top,
+mAlphaExtract.hdc,
+pRect->left,
+pRect->top,
+SRCCOPY);
+mAlphaExtract.doublePass = RENDER_NATIVE;
+return true;
+break;
+}
+return false;
+}
+/* flash msg throttling helpers */
+// Flash has the unfortunate habit of flooding dispatch loops with custom
+// windowing events they use for timing. We throttle these by dropping the
+// delivery priority below any other event, including pending ipc io
+// notifications. We do this for both windowed and windowless controls.
+// Note flash's windowless msg window can last longer than our instance,
+// so we try to unhook when the window is destroyed and in NPP_Destroy.
+void
+PluginInstanceChild::UnhookWinlessFlashThrottle()
+{
+// We may have already unhooked
+if (!mWinlessThrottleOldWndProc)
+return;
+WNDPROC tmpProc = mWinlessThrottleOldWndProc;
+mWinlessThrottleOldWndProc = nullptr;
+NS_ASSERTION(mWinlessHiddenMsgHWND,
+"Missing mWinlessHiddenMsgHWND w/subclass set??");
+// reset the subclass
+SetWindowLongPtr(mWinlessHiddenMsgHWND, GWLP_WNDPROC,
+reinterpret_cast<LONG_PTR>(tmpProc));
+// Remove our instance prop
+RemoveProp(mWinlessHiddenMsgHWND, kFlashThrottleProperty);
+mWinlessHiddenMsgHWND = nullptr;
+}
+// static
+LRESULT CALLBACK
+PluginInstanceChild::WinlessHiddenFlashWndProc(HWND hWnd,
+UINT message,
+WPARAM wParam,
+LPARAM lParam)
+{
+PluginInstanceChild* self = reinterpret_cast<PluginInstanceChild*>(
+GetProp(hWnd, kFlashThrottleProperty));
+if (!self) {
+NS_NOTREACHED("Badness!");
+return 0;
+}
+NS_ASSERTION(self->mWinlessThrottleOldWndProc,
+"Missing subclass procedure!!");
+// Throttle
+if (message == WM_USER+1) {
+self->FlashThrottleMessage(hWnd, message, wParam, lParam, false);
+return 0;
+}
+// Unhook
+if (message == WM_CLOSE || message == WM_NCDESTROY) {
+WNDPROC tmpProc = self->mWinlessThrottleOldWndProc;
+self->UnhookWinlessFlashThrottle();
+LRESULT res = CallWindowProc(tmpProc, hWnd, message, wParam, lParam);
+return res;
+}
+return CallWindowProc(self->mWinlessThrottleOldWndProc,
+hWnd, message, wParam, lParam);
+}
+// Enumerate all thread windows looking for flash's hidden message window.
+// Once we find it, sub class it so we can throttle user msgs.
+// static
+BOOL CALLBACK
+PluginInstanceChild::EnumThreadWindowsCallback(HWND hWnd,
+LPARAM aParam)
+{
+PluginInstanceChild* self = reinterpret_cast<PluginInstanceChild*>(aParam);
+if (!self) {
+NS_NOTREACHED("Enum befuddled!");
+return FALSE;
+}
+wchar_t className[64];
+if (!GetClassNameW(hWnd, className, sizeof(className)/sizeof(char16_t)))
+return TRUE;
+if (!wcscmp(className, L"SWFlash_PlaceholderX")) {
+WNDPROC oldWndProc =
+reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_WNDPROC));
+// Only set this if we haven't already.
+if (oldWndProc != WinlessHiddenFlashWndProc) {
+if (self->mWinlessThrottleOldWndProc) {
+NS_WARNING("mWinlessThrottleWndProc already set???");
+return FALSE;
+}
+// Subsclass and store self as a property
+self->mWinlessHiddenMsgHWND = hWnd;
+self->mWinlessThrottleOldWndProc =
+reinterpret_cast<WNDPROC>(SetWindowLongPtr(hWnd, GWLP_WNDPROC,
+reinterpret_cast<LONG_PTR>(WinlessHiddenFlashWndProc)));
+SetProp(hWnd, kFlashThrottleProperty, self);
+NS_ASSERTION(self->mWinlessThrottleOldWndProc,
+"SetWindowLongPtr failed?!");
+}
+// Return no matter what once we find the right window.
+return FALSE;
+}
+return TRUE;
+}
+void
+PluginInstanceChild::SetupFlashMsgThrottle()
+{
+if (mWindow.type == NPWindowTypeDrawable) {
+// Search for the flash hidden message window and subclass it. Only
+// search for flash windows belonging to our ui thread!
+if (mWinlessThrottleOldWndProc)
+return;
+EnumThreadWindows(GetCurrentThreadId(), EnumThreadWindowsCallback,
+reinterpret_cast<LPARAM>(this));
+}
+else {
+// Already setup through quirks and the subclass.
+return;
+}
+}
+WNDPROC
+PluginInstanceChild::FlashThrottleAsyncMsg::GetProc()
+{
+if (mInstance) {
+return mWindowed ? mInstance->mPluginWndProc :
+mInstance->mWinlessThrottleOldWndProc;
+}
+return nullptr;
+}
+void
+PluginInstanceChild::FlashThrottleAsyncMsg::Run()
+{
+RemoveFromAsyncList();
+// GetProc() checks mInstance, and pulls the procedure from
+// PluginInstanceChild. We don't transport sub-class procedure
+// ptrs around in FlashThrottleAsyncMsg msgs.
+if (!GetProc())
+return;
+// deliver the event to flash
+CallWindowProc(GetProc(), GetWnd(), GetMsg(), GetWParam(), GetLParam());
+}
+void
+PluginInstanceChild::FlashThrottleMessage(HWND aWnd,
+UINT aMsg,
+WPARAM aWParam,
+LPARAM aLParam,
+bool isWindowed)
+{
+// We reuse ChildAsyncCall so we get the cancelation work
+// that's done in Destroy.
+FlashThrottleAsyncMsg* task = new FlashThrottleAsyncMsg(this,
+aWnd, aMsg, aWParam, aLParam, isWindowed);
+if (!task)
+return;
+{
+MutexAutoLock lock(mAsyncCallMutex);
+mPendingAsyncCalls.AppendElement(task);
+}
+MessageLoop::current()->PostDelayedTask(FROM_HERE,
+task, kFlashWMUSERMessageThrottleDelayMs);
+}
+#endif // OS_WIN
+bool
+PluginInstanceChild::AnswerSetPluginFocus()
+{
+PR_LOG(GetPluginLog(), PR_LOG_DEBUG, ("%s", FULLFUNCTION));
+#if defined(OS_WIN)
+// Parent is letting us know the dom set focus to the plugin. Note,
+// focus can change during transit in certain edge cases, for example
+// when a button click brings up a full screen window. Since we send
+// this in response to a WM_SETFOCUS event on our parent, the parent
+// should have focus when we receive this. If not, ignore the call.
+if (::GetFocus() == mPluginWindowHWND ||
+((GetQuirks() & PluginModuleChild::QUIRK_SILVERLIGHT_FOCUS_CHECK_PARENT) &&
+(::GetFocus() != mPluginParentHWND)))
+return true;
+::SetFocus(mPluginWindowHWND);
+return true;
+#else
+NS_NOTREACHED("PluginInstanceChild::AnswerSetPluginFocus not implemented!");
+return false;
+#endif
+}
+bool
+PluginInstanceChild::AnswerUpdateWindow()
+{
+PR_LOG(GetPluginLog(), PR_LOG_DEBUG, ("%s", FULLFUNCTION));
+#if defined(OS_WIN)
+if (mPluginWindowHWND) {
+RECT rect;
+if (GetUpdateRect(GetParent(mPluginWindowHWND), &rect, FALSE)) {
+::InvalidateRect(mPluginWindowHWND, &rect, FALSE);
+}
+UpdateWindow(mPluginWindowHWND);
+}
+return true;
+#else
+NS_NOTREACHED("PluginInstanceChild::AnswerUpdateWindow not implemented!");
+return false;
+#endif
+}
+bool
+PluginInstanceChild::RecvNPP_DidComposite()
+{
+if (mPluginIface->didComposite) {
+mPluginIface->didComposite(GetNPP());
+}
+return true;
+}
+PPluginScriptableObjectChild*
+PluginInstanceChild::AllocPPluginScriptableObjectChild()
+{
+AssertPluginThread();
+return new PluginScriptableObjectChild(Proxy);
+}
+bool
+PluginInstanceChild::DeallocPPluginScriptableObjectChild(
+PPluginScriptableObjectChild* aObject)
+{
+AssertPluginThread();
+delete aObject;
+return true;
+}
+bool
+PluginInstanceChild::RecvPPluginScriptableObjectConstructor(
+PPluginScriptableObjectChild* aActor)
+{
+AssertPluginThread();
+// This is only called in response to the parent process requesting the
+// creation of an actor. This actor will represent an NPObject that is
+// created by the browser and returned to the plugin.
+PluginScriptableObjectChild* actor =
+static_cast<PluginScriptableObjectChild*>(aActor);
+NS_ASSERTION(!actor->GetObject(false), "Actor already has an object?!");
+actor->InitializeProxy();
+NS_ASSERTION(actor->GetObject(false), "Actor should have an object!");
+return true;
+}
+bool
+PluginInstanceChild::AnswerPBrowserStreamConstructor(
+PBrowserStreamChild* aActor,
+const nsCString& url,
+const uint32_t& length,
+const uint32_t& lastmodified,
+PStreamNotifyChild* notifyData,
+const nsCString& headers,
+const nsCString& mimeType,
+const bool& seekable,
+NPError* rv,
+uint16_t* stype)
+{
+AssertPluginThread();
+*rv = static_cast<BrowserStreamChild*>(aActor)
+->StreamConstructed(mimeType, seekable, stype);
+return true;
+}
+PBrowserStreamChild*
+PluginInstanceChild::AllocPBrowserStreamChild(const nsCString& url,
+const uint32_t& length,
+const uint32_t& lastmodified,
+PStreamNotifyChild* notifyData,
+const nsCString& headers,
+const nsCString& mimeType,
+const bool& seekable,
+NPError* rv,
+uint16_t *stype)
+{
+AssertPluginThread();
+return new BrowserStreamChild(this, url, length, lastmodified,
+static_cast<StreamNotifyChild*>(notifyData),
+headers, mimeType, seekable, rv, stype);
+}
+bool
+PluginInstanceChild::DeallocPBrowserStreamChild(PBrowserStreamChild* stream)
+{
+AssertPluginThread();
+delete stream;
+return true;
+}
+PPluginStreamChild*
+PluginInstanceChild::AllocPPluginStreamChild(const nsCString& mimeType,
+const nsCString& target,
+NPError* result)
+{
+NS_RUNTIMEABORT("not callable");
+return nullptr;
+}
+bool
+PluginInstanceChild::DeallocPPluginStreamChild(PPluginStreamChild* stream)
+{
+AssertPluginThread();
+delete stream;
+return true;
+}
+PStreamNotifyChild*
+PluginInstanceChild::AllocPStreamNotifyChild(const nsCString& url,
+const nsCString& target,
+const bool& post,
+const nsCString& buffer,
+const bool& file,
+NPError* result)
+{
+AssertPluginThread();
+NS_RUNTIMEABORT("not reached");
+return nullptr;
+}
+void
+StreamNotifyChild::ActorDestroy(ActorDestroyReason why)
+{
+if (AncestorDeletion == why && mBrowserStream) {
+NS_ERROR("Pending NPP_URLNotify not called when closing an instance.");
+// reclaim responsibility for deleting ourself
+mBrowserStream->mStreamNotify = nullptr;
+mBrowserStream = nullptr;
+}
+}
+void
+StreamNotifyChild::SetAssociatedStream(BrowserStreamChild* bs)
+{
+NS_ASSERTION(bs, "Shouldn't be null");
+NS_ASSERTION(!mBrowserStream, "Two streams for one streamnotify?");
+mBrowserStream = bs;
+}
+bool
+StreamNotifyChild::Recv__delete__(const NPReason& reason)
+{
+AssertPluginThread();
+if (mBrowserStream)
+mBrowserStream->NotifyPending();
+else
+NPP_URLNotify(reason);
+return true;
+}
+bool
+StreamNotifyChild::RecvRedirectNotify(const nsCString& url, const int32_t& status)
+{
+// NPP_URLRedirectNotify requires a non-null closure. Since core logic
+// assumes that all out-of-process notify streams have non-null closure
+// data it will assume that the plugin was notified at this point and
+// expect a response otherwise the redirect will hang indefinitely.
+if (!mClosure) {
+SendRedirectNotifyResponse(false);
+}
+PluginInstanceChild* instance = static_cast<PluginInstanceChild*>(Manager());
+if (instance->mPluginIface->urlredirectnotify)
+instance->mPluginIface->urlredirectnotify(instance->GetNPP(), url.get(), status, mClosure);
+return true;
+}
+void
+StreamNotifyChild::NPP_URLNotify(NPReason reason)
+{
+PluginInstanceChild* instance = static_cast<PluginInstanceChild*>(Manager());
+if (mClosure)
+instance->mPluginIface->urlnotify(instance->GetNPP(), mURL.get(),
+reason, mClosure);
+}
+bool
+PluginInstanceChild::DeallocPStreamNotifyChild(PStreamNotifyChild* notifyData)
+{
+AssertPluginThread();
+if (!static_cast<StreamNotifyChild*>(notifyData)->mBrowserStream)
+delete notifyData;
+return true;
+}
+PluginScriptableObjectChild*
+PluginInstanceChild::GetActorForNPObject(NPObject* aObject)
+{
+AssertPluginThread();
+NS_ASSERTION(aObject, "Null pointer!");
+if (aObject->_class == PluginScriptableObjectChild::GetClass()) {
+// One of ours! It's a browser-provided object.
+ChildNPObject* object = static_cast<ChildNPObject*>(aObject);
+NS_ASSERTION(object->parent, "Null actor!");
+return object->parent;
+}
+PluginScriptableObjectChild* actor =
+PluginModuleChild::current()->GetActorForNPObject(aObject);
+if (actor) {
+// Plugin-provided object that we've previously wrapped.
+return actor;
+}
+actor = new PluginScriptableObjectChild(LocalObject);
+if (!SendPPluginScriptableObjectConstructor(actor)) {
+NS_ERROR("Failed to send constructor message!");
+return nullptr;
+}
+actor->InitializeLocal(aObject);
+return actor;
+}
+NPError
+PluginInstanceChild::NPN_NewStream(NPMIMEType aMIMEType, const char* aWindow,
+NPStream** aStream)
+{
+AssertPluginThread();
+PluginStreamChild* ps = new PluginStreamChild();
+NPError result;
+CallPPluginStreamConstructor(ps, nsDependentCString(aMIMEType),
+NullableString(aWindow), &result);
+if (NPERR_NO_ERROR != result) {
+*aStream = nullptr;
+PPluginStreamChild::Call__delete__(ps, NPERR_GENERIC_ERROR, true);
+return result;
+}
+*aStream = &ps->mStream;
+return NPERR_NO_ERROR;
+}
+void
+PluginInstanceChild::NPN_URLRedirectResponse(void* notifyData, NPBool allow)
+{
+if (!notifyData) {
+return;
+}
+InfallibleTArray<PStreamNotifyChild*> notifyStreams;
+ManagedPStreamNotifyChild(notifyStreams);
+uint32_t notifyStreamCount = notifyStreams.Length();
+for (uint32_t i = 0; i < notifyStreamCount; i++) {
+StreamNotifyChild* sn = static_cast<StreamNotifyChild*>(notifyStreams[i]);
+if (sn->mClosure == notifyData) {
+sn->SendRedirectNotifyResponse(static_cast<bool>(allow));
+return;
+}
+}
+NS_ASSERTION(false, "Couldn't find stream for redirect response!");
+}
+NPError
+PluginInstanceChild::DeallocateAsyncBitmapSurface(NPAsyncSurface *aSurface)
+{
+AsyncBitmapData* data;
+if (!mAsyncBitmaps.Get(aSurface, &data)) {
+return NPERR_INVALID_PARAM;
+}
+DeallocShmem(data->mShmem);
+aSurface->bitmap.data = nullptr;
+mAsyncBitmaps.Remove(aSurface);
+return NPERR_NO_ERROR;
+}
+bool
+PluginInstanceChild::IsAsyncDrawing()
+{
+return IsDrawingModelAsync(mDrawingModel);
+}
+NPError
+PluginInstanceChild::NPN_InitAsyncSurface(NPSize *size, NPImageFormat format,
+void *initData, NPAsyncSurface *surface)
+{
+AssertPluginThread();
+surface->bitmap.data = nullptr;
+if (!IsAsyncDrawing()) {
+return NPERR_GENERIC_ERROR;
+}
+switch (mDrawingModel) {
+case NPDrawingModelAsyncBitmapSurface: {
+if (mAsyncBitmaps.Get(surface, nullptr)) {
+return NPERR_INVALID_PARAM;
+}
+if (size->width < 0 || size->height < 0) {
+return NPERR_INVALID_PARAM;
+}
+bool result;
+NPRemoteAsyncSurface remote;
+if (!CallNPN_InitAsyncSurface(gfxIntSize(size->width, size->height), format, &remote, &result) || !result) {
+return NPERR_OUT_OF_MEMORY_ERROR;
+}
+NS_ABORT_IF_FALSE(remote.data().get_Shmem().IsWritable(),
+"Failed to create writable shared memory.");
+AsyncBitmapData *data = new AsyncBitmapData;
+mAsyncBitmaps.Put(surface, data);
+data->mRemotePtr = (void*)remote.hostPtr();
+data->mShmem = remote.data().get_Shmem();
+surface->bitmap.data = data->mShmem.get<unsigned char>();
+surface->bitmap.stride = remote.stride();
+surface->format = remote.format();
+surface->size.width = remote.size().width;
+surface->size.height = remote.size().height;
+return NPERR_NO_ERROR;
+}
+#ifdef XP_WIN
+case NPDrawingModelAsyncWindowsDXGISurface: {
+if (size->width < 0 || size->height < 0) {
+return NPERR_INVALID_PARAM;
+}
+bool result;
+NPRemoteAsyncSurface remote;
+if (!CallNPN_InitAsyncSurface(gfxIntSize(size->width, size->height), format, &remote, &result) || !result) {
+return NPERR_OUT_OF_MEMORY_ERROR;
+}
+surface->format = remote.format();
+surface->size.width = remote.size().width;
+surface->size.height = remote.size().height;
+surface->sharedHandle = remote.data().get_DXGISharedSurfaceHandle();
+return NPERR_NO_ERROR;
+}
+#endif
+}
+return NPERR_GENERIC_ERROR;
+}
+NPError
+PluginInstanceChild::NPN_FinalizeAsyncSurface(NPAsyncSurface *surface)
+{
+AssertPluginThread();
+if (!IsAsyncDrawing()) {
+return NPERR_GENERIC_ERROR;
+}
+switch (mDrawingModel) {
+case NPDrawingModelAsyncBitmapSurface: {
+AsyncBitmapData *bitmapData;
+if (!mAsyncBitmaps.Get(surface, &bitmapData)) {
+return NPERR_GENERIC_ERROR;
+}
+{
+CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
+RemoteImageData *data = mRemoteImageData;
+if (data->mBitmap.mData == bitmapData->mRemotePtr) {
+data->mBitmap.mData = nullptr;
+data->mSize = IntSize(0, 0);
+data->mWasUpdated = true;
+}
+}
+return DeallocateAsyncBitmapSurface(surface);
+}
+#ifdef XP_WIN
+case NPDrawingModelAsyncWindowsDXGISurface: {
+{
+CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
+RemoteImageData *data = mRemoteImageData;
+if (data->mTextureHandle == surface->sharedHandle) {
+data->mTextureHandle = nullptr;
+data->mSize = IntSize(0, 0);
+data->mWasUpdated = true;
+}
+}
+SendReleaseDXGISharedSurface(surface->sharedHandle);
+return NPERR_NO_ERROR;
+}
+#endif
+}
+return NPERR_GENERIC_ERROR;
+}
+void
+PluginInstanceChild::NPN_SetCurrentAsyncSurface(NPAsyncSurface *surface, NPRect *changed)
+{
+if (!IsAsyncDrawing()) {
+return;
+}
+RemoteImageData *data = mRemoteImageData;
+if (!surface) {
+CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
+data->mBitmap.mData = nullptr;
+data->mSize = IntSize(0, 0);
+data->mWasUpdated = true;
+} else {
+switch (mDrawingModel) {
+case NPDrawingModelAsyncBitmapSurface:
+{
+AsyncBitmapData *bitmapData;
+if (!mAsyncBitmaps.Get(surface, &bitmapData)) {
+return;
+}
+CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
+data->mBitmap.mData = (unsigned char*)bitmapData->mRemotePtr;
+data->mSize = IntSize(surface->size.width, surface->size.height);
+data->mFormat = surface->format == NPImageFormatBGRX32 ?
+RemoteImageData::BGRX32 : RemoteImageData::BGRA32;
+data->mBitmap.mStride = surface->bitmap.stride;
+data->mWasUpdated = true;
+break;
+}
+#ifdef XP_WIN
+case NPDrawingModelAsyncWindowsDXGISurface:
+{
+CrossProcessMutexAutoLock autoLock(*mRemoteImageDataMutex);
+data->mType = RemoteImageData::DXGI_TEXTURE_HANDLE;
+data->mSize = IntSize(surface->size.width, surface->size.height);
+data->mFormat = surface->format == NPImageFormatBGRX32 ?
+RemoteImageData::BGRX32 : RemoteImageData::BGRA32;
+data->mTextureHandle = surface->sharedHandle;
+data->mWasUpdated = true;
+break;
+}
+#endif
+}
+}
+{
+MutexAutoLock autoLock(mAsyncInvalidateMutex);
+if (!mAsyncInvalidateTask) {
+mAsyncInvalidateTask =
+NewRunnableMethod<PluginInstanceChild, void (PluginInstanceChild::*)()>
+(this, &PluginInstanceChild::DoAsyncRedraw);
+ProcessChild::message_loop()->PostTask(FROM_HERE, mAsyncInvalidateTask);
+}
+}
+}
+void
+PluginInstanceChild::DoAsyncRedraw()
+{
+{
+MutexAutoLock autoLock(mAsyncInvalidateMutex);
+mAsyncInvalidateTask = nullptr;
+}
+SendRedrawPlugin();
+}
+bool
+PluginInstanceChild::RecvAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
+const NPRemoteWindow& aWindow)
+{
+AssertPluginThread();
+NS_ASSERTION(!aWindow.window, "Remote window should be null.");
+if (mCurrentAsyncSetWindowTask) {
+mCurrentAsyncSetWindowTask->Cancel();
+mCurrentAsyncSetWindowTask = nullptr;
+}
+// We shouldn't process this now because it may be received within a nested
+// RPC call, and both Flash and Java don't expect to receive setwindow calls
+// at arbitrary times.
+mCurrentAsyncSetWindowTask =
+NewRunnableMethod<PluginInstanceChild,
+void (PluginInstanceChild::*)(const gfxSurfaceType&, const NPRemoteWindow&, bool),
+gfxSurfaceType, NPRemoteWindow, bool>
+(this, &PluginInstanceChild::DoAsyncSetWindow,
+aSurfaceType, aWindow, true);
+MessageLoop::current()->PostTask(FROM_HERE, mCurrentAsyncSetWindowTask);
+return true;
+}
+void
+PluginInstanceChild::DoAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
+const NPRemoteWindow& aWindow,
+bool aIsAsync)
+{
+PLUGIN_LOG_DEBUG(
+("[InstanceChild][%p] AsyncSetWindow to <x=%d,y=%d, w=%d,h=%d>",
+this, aWindow.x, aWindow.y, aWindow.width, aWindow.height));
+AssertPluginThread();
+NS_ASSERTION(!aWindow.window, "Remote window should be null.");
+NS_ASSERTION(!mPendingPluginCall, "Can't do SetWindow during plugin call!");
+if (aIsAsync) {
+if (!mCurrentAsyncSetWindowTask) {
+return;
+}
+mCurrentAsyncSetWindowTask = nullptr;
+}
+mWindow.window = nullptr;
+if (mWindow.width != aWindow.width || mWindow.height != aWindow.height ||
+mWindow.clipRect.top != aWindow.clipRect.top ||
+mWindow.clipRect.left != aWindow.clipRect.left ||
+mWindow.clipRect.bottom != aWindow.clipRect.bottom ||
+mWindow.clipRect.right != aWindow.clipRect.right)
+mAccumulatedInvalidRect = nsIntRect(0, 0, aWindow.width, aWindow.height);
+mWindow.x = aWindow.x;
+mWindow.y = aWindow.y;
+mWindow.width = aWindow.width;
+mWindow.height = aWindow.height;
+mWindow.clipRect = aWindow.clipRect;
+mWindow.type = aWindow.type;
+#ifdef XP_MACOSX
+mContentsScaleFactor = aWindow.contentsScaleFactor;
+#endif
+if (GetQuirks() & PluginModuleChild::QUIRK_SILVERLIGHT_DEFAULT_TRANSPARENT)
+mIsTransparent = true;
+mLayersRendering = true;
+mSurfaceType = aSurfaceType;
+UpdateWindowAttributes(true);
+#ifdef XP_WIN
+if (GetQuirks() & PluginModuleChild::QUIRK_WINLESS_TRACKPOPUP_HOOK)
+CreateWinlessPopupSurrogate();
+if (GetQuirks() & PluginModuleChild::QUIRK_FLASH_THROTTLE_WMUSER_EVENTS)
+SetupFlashMsgThrottle();
+#endif
+if (!mAccumulatedInvalidRect.IsEmpty()) {
+AsyncShowPluginFrame();
+}
+}
+static inline gfxRect
+GfxFromNsRect(const nsIntRect& aRect)
+{
+return gfxRect(aRect.x, aRect.y, aRect.width, aRect.height);
+}
+bool
+PluginInstanceChild::CreateOptSurface(void)
+{
+NS_ABORT_IF_FALSE(mSurfaceType != gfxSurfaceType::Max,
+"Need a valid surface type here");
+NS_ASSERTION(!mCurrentSurface, "mCurrentSurfaceActor can get out of sync.");
+nsRefPtr<gfxASurface> retsurf;
+// Use an opaque surface unless we're transparent and *don't* have
+// a background to source from.
+gfxImageFormat format =
+(mIsTransparent && !mBackground) ? gfxImageFormat::ARGB32 :
+gfxImageFormat::RGB24;
+#ifdef MOZ_X11
+Display* dpy = mWsInfo.display;
+Screen* screen = DefaultScreenOfDisplay(dpy);
+if (format == gfxImageFormat::RGB24 &&
+DefaultDepth(dpy, DefaultScreen(dpy)) == 16) {
+format = gfxImageFormat::RGB16_565;
+}
+if (mSurfaceType == gfxSurfaceType::Xlib) {
+if (!mIsTransparent  || mBackground) {
+Visual* defaultVisual = DefaultVisualOfScreen(screen);
+mCurrentSurface =
+gfxXlibSurface::Create(screen, defaultVisual,
+gfxIntSize(mWindow.width,
+mWindow.height));
+return mCurrentSurface != nullptr;
+}
+XRenderPictFormat* xfmt = XRenderFindStandardFormat(dpy, PictStandardARGB32);
+if (!xfmt) {
+NS_ERROR("Need X falback surface, but FindRenderFormat failed");
+return false;
+}
+mCurrentSurface =
+gfxXlibSurface::Create(screen, xfmt,
+gfxIntSize(mWindow.width,
+mWindow.height));
+return mCurrentSurface != nullptr;
+}
+#endif
+#ifdef XP_WIN
+if (mSurfaceType == gfxSurfaceType::Win32 ||
+mSurfaceType == gfxSurfaceType::D2D) {
+bool willHaveTransparentPixels = mIsTransparent && !mBackground;
+SharedDIBSurface* s = new SharedDIBSurface();
+if (!s->Create(reinterpret_cast<HDC>(mWindow.window),
+mWindow.width, mWindow.height,
+willHaveTransparentPixels))
+return false;
+mCurrentSurface = s;
+return true;
+}
+NS_RUNTIMEABORT("Shared-memory drawing not expected on Windows.");
+#endif
+// Make common shmem implementation working for any platform
+mCurrentSurface =
+gfxSharedImageSurface::CreateUnsafe(this, gfxIntSize(mWindow.width, mWindow.height), format);
+return !!mCurrentSurface;
+}
+bool
+PluginInstanceChild::MaybeCreatePlatformHelperSurface(void)
+{
+if (!mCurrentSurface) {
+NS_ERROR("Cannot create helper surface without mCurrentSurface");
+return false;
+}
+#ifdef MOZ_X11
+bool supportNonDefaultVisual = false;
+Screen* screen = DefaultScreenOfDisplay(mWsInfo.display);
+Visual* defaultVisual = DefaultVisualOfScreen(screen);
+Visual* visual = nullptr;
+Colormap colormap = 0;
+mDoAlphaExtraction = false;
+bool createHelperSurface = false;
+if (mCurrentSurface->GetType() == gfxSurfaceType::Xlib) {
+static_cast<gfxXlibSurface*>(mCurrentSurface.get())->
+GetColormapAndVisual(&colormap, &visual);
+// Create helper surface if layer surface visual not same as default
+// and we don't support non-default visual rendering
+if (!visual || (defaultVisual != visual && !supportNonDefaultVisual)) {
+createHelperSurface = true;
+visual = defaultVisual;
+mDoAlphaExtraction = mIsTransparent;
+}
+} else if (mCurrentSurface->GetType() == gfxSurfaceType::Image) {
+// For image layer surface we should always create helper surface
+createHelperSurface = true;
+// Check if we can create helper surface with non-default visual
+visual = gfxXlibSurface::FindVisual(screen,
+static_cast<gfxImageSurface*>(mCurrentSurface.get())->Format());
+if (!visual || (defaultVisual != visual && !supportNonDefaultVisual)) {
+visual = defaultVisual;
+mDoAlphaExtraction = mIsTransparent;
+}
+}
+if (createHelperSurface) {
+if (!visual) {
+NS_ERROR("Need X falback surface, but visual failed");
+return false;
+}
+mHelperSurface =
+gfxXlibSurface::Create(screen, visual,
+mCurrentSurface->GetSize());
+if (!mHelperSurface) {
+NS_WARNING("Fail to create create helper surface");
+return false;
+}
+}
+#elif defined(XP_WIN)
+mDoAlphaExtraction = mIsTransparent && !mBackground;
+#endif
+return true;
+}
+bool
+PluginInstanceChild::EnsureCurrentBuffer(void)
+{
+#ifndef XP_MACOSX
+nsIntRect toInvalidate(0, 0, 0, 0);
+gfxIntSize winSize = gfxIntSize(mWindow.width, mWindow.height);
+if (mBackground && mBackground->GetSize() != winSize) {
+// It would be nice to keep the old background here, but doing
+// so can lead to cases in which we permanently keep the old
+// background size.
+mBackground = nullptr;
+toInvalidate.UnionRect(toInvalidate,
+nsIntRect(0, 0, winSize.width, winSize.height));
+}
+if (mCurrentSurface) {
+gfxIntSize surfSize = mCurrentSurface->GetSize();
+if (winSize != surfSize ||
+(mBackground && !CanPaintOnBackground()) ||
+(mBackground &&
+gfxContentType::COLOR != mCurrentSurface->GetContentType()) ||
+(!mBackground && mIsTransparent &&
+gfxContentType::COLOR == mCurrentSurface->GetContentType())) {
+// Don't try to use an old, invalid DC.
+mWindow.window = nullptr;
+ClearCurrentSurface();
+toInvalidate.UnionRect(toInvalidate,
+nsIntRect(0, 0, winSize.width, winSize.height));
+}
+}
+mAccumulatedInvalidRect.UnionRect(mAccumulatedInvalidRect, toInvalidate);
+if (mCurrentSurface) {
+return true;
+}
+if (!CreateOptSurface()) {
+NS_ERROR("Cannot create optimized surface");
+return false;
+}
+if (!MaybeCreatePlatformHelperSurface()) {
+NS_ERROR("Cannot create helper surface");
+return false;
+}
+return true;
+#else // XP_MACOSX
+if (!mDoubleBufferCARenderer.HasCALayer()) {
+void *caLayer = nullptr;
+if (mDrawingModel == NPDrawingModelCoreGraphics) {
+if (!mCGLayer) {
+bool avoidCGCrashes = !nsCocoaFeatures::OnMountainLionOrLater() &&
+(GetQuirks() & PluginModuleChild::QUIRK_FLASH_AVOID_CGMODE_CRASHES);
+caLayer = mozilla::plugins::PluginUtilsOSX::GetCGLayer(CallCGDraw, this,
+avoidCGCrashes,
+mContentsScaleFactor);
+if (!caLayer) {
+PLUGIN_LOG_DEBUG(("GetCGLayer failed."));
+return false;
+}
+}
+mCGLayer = caLayer;
+} else {
+NPError result = mPluginIface->getvalue(GetNPP(),
+NPPVpluginCoreAnimationLayer,
+&caLayer);
+if (result != NPERR_NO_ERROR || !caLayer) {
+PLUGIN_LOG_DEBUG(("Plugin requested CoreAnimation but did not "
+"provide CALayer."));
+return false;
+}
+}
+mDoubleBufferCARenderer.SetCALayer(caLayer);
+}
+if (mDoubleBufferCARenderer.HasFrontSurface() &&
+(mDoubleBufferCARenderer.GetFrontSurfaceWidth() != mWindow.width ||
+mDoubleBufferCARenderer.GetFrontSurfaceHeight() != mWindow.height ||
+mDoubleBufferCARenderer.GetContentsScaleFactor() != mContentsScaleFactor)) {
+mDoubleBufferCARenderer.ClearFrontSurface();
+}
+if (!mDoubleBufferCARenderer.HasFrontSurface()) {
+bool allocSurface = mDoubleBufferCARenderer.InitFrontSurface(
+mWindow.width, mWindow.height, mContentsScaleFactor,
+GetQuirks() & PluginModuleChild::QUIRK_ALLOW_OFFLINE_RENDERER ?
+ALLOW_OFFLINE_RENDERER : DISALLOW_OFFLINE_RENDERER);
+if (!allocSurface) {
+PLUGIN_LOG_DEBUG(("Fail to allocate front IOSurface"));
+return false;
+}
+if (mPluginIface->setwindow)
+(void) mPluginIface->setwindow(&mData, &mWindow);
+nsIntRect toInvalidate(0, 0, mWindow.width, mWindow.height);
+mAccumulatedInvalidRect.UnionRect(mAccumulatedInvalidRect, toInvalidate);
+}
+return true;
+#endif
+}
+void
+PluginInstanceChild::UpdateWindowAttributes(bool aForceSetWindow)
+{
+nsRefPtr<gfxASurface> curSurface = mHelperSurface ? mHelperSurface : mCurrentSurface;
+bool needWindowUpdate = aForceSetWindow;
+#ifdef MOZ_X11
+Visual* visual = nullptr;
+Colormap colormap = 0;
+if (curSurface && curSurface->GetType() == gfxSurfaceType::Xlib) {
+static_cast<gfxXlibSurface*>(curSurface.get())->
+GetColormapAndVisual(&colormap, &visual);
+if (visual != mWsInfo.visual || colormap != mWsInfo.colormap) {
+mWsInfo.visual = visual;
+mWsInfo.colormap = colormap;
+needWindowUpdate = true;
+}
+}
+#endif // MOZ_X11
+#ifdef XP_WIN
+HDC dc = nullptr;
+if (curSurface) {
+if (!SharedDIBSurface::IsSharedDIBSurface(curSurface))
+NS_RUNTIMEABORT("Expected SharedDIBSurface!");
+SharedDIBSurface* dibsurf = static_cast<SharedDIBSurface*>(curSurface.get());
+dc = dibsurf->GetHDC();
+}
+if (mWindow.window != dc) {
+mWindow.window = dc;
+needWindowUpdate = true;
+}
+#endif // XP_WIN
+if (!needWindowUpdate) {
+return;
+}
+#ifndef XP_MACOSX
+// Adjusting the window isn't needed for OSX
+#ifndef XP_WIN
+// On Windows, we translate the device context, in order for the window
+// origin to be correct.
+mWindow.x = mWindow.y = 0;
+#endif
+if (IsVisible()) {
+// The clip rect is relative to drawable top-left.
+nsIntRect clipRect;
+// Don't ask the plugin to draw outside the drawable. The clip rect
+// is in plugin coordinates, not window coordinates.
+// This also ensures that the unsigned clip rectangle offsets won't be -ve.
+clipRect.SetRect(0, 0, mWindow.width, mWindow.height);
+mWindow.clipRect.left = 0;
+mWindow.clipRect.top = 0;
+mWindow.clipRect.right = clipRect.XMost();
+mWindow.clipRect.bottom = clipRect.YMost();
+}
+#endif // XP_MACOSX
+#ifdef XP_WIN
+// Windowless plugins on Windows need a WM_WINDOWPOSCHANGED event to update
+// their location... or at least Flash does: Silverlight uses the
+// window.x/y passed to NPP_SetWindow
+if (mPluginIface->event) {
+WINDOWPOS winpos = {
+0, 0,
+mWindow.x, mWindow.y,
+mWindow.width, mWindow.height,
+0
+};
+NPEvent pluginEvent = {
+WM_WINDOWPOSCHANGED, 0,
+(LPARAM) &winpos
+};
+mPluginIface->event(&mData, &pluginEvent);
+}
+#endif
+PLUGIN_LOG_DEBUG(
+("[InstanceChild][%p] UpdateWindow w=<x=%d,y=%d, w=%d,h=%d>, clip=<l=%d,t=%d,r=%d,b=%d>",
+this, mWindow.x, mWindow.y, mWindow.width, mWindow.height,
+mWindow.clipRect.left, mWindow.clipRect.top, mWindow.clipRect.right, mWindow.clipRect.bottom));
+if (mPluginIface->setwindow) {
+mPluginIface->setwindow(&mData, &mWindow);
+}
+}
+void
+PluginInstanceChild::PaintRectToPlatformSurface(const nsIntRect& aRect,
+gfxASurface* aSurface)
+{
+UpdateWindowAttributes();
+#ifdef MOZ_X11
+{
+NS_ASSERTION(aSurface->GetType() == gfxSurfaceType::Xlib,
+"Non supported platform surface type");
+NPEvent pluginEvent;
+XGraphicsExposeEvent& exposeEvent = pluginEvent.xgraphicsexpose;
+exposeEvent.type = GraphicsExpose;
+exposeEvent.display = mWsInfo.display;
+exposeEvent.drawable = static_cast<gfxXlibSurface*>(aSurface)->XDrawable();
+exposeEvent.x = aRect.x;
+exposeEvent.y = aRect.y;
+exposeEvent.width = aRect.width;
+exposeEvent.height = aRect.height;
+exposeEvent.count = 0;
+// information not set:
+exposeEvent.serial = 0;
+exposeEvent.send_event = False;
+exposeEvent.major_code = 0;
+exposeEvent.minor_code = 0;
+mPluginIface->event(&mData, reinterpret_cast<void*>(&exposeEvent));
+}
+#elif defined(XP_WIN)
+NS_ASSERTION(SharedDIBSurface::IsSharedDIBSurface(aSurface),
+"Expected (SharedDIB) image surface.");
+// This rect is in the window coordinate space. aRect is in the plugin
+// coordinate space.
+RECT rect = {
+mWindow.x + aRect.x,
+mWindow.y + aRect.y,
+mWindow.x + aRect.XMost(),
+mWindow.y + aRect.YMost()
+};
+NPEvent paintEvent = {
+WM_PAINT,
+uintptr_t(mWindow.window),
+uintptr_t(&rect)
+};
+::SetViewportOrgEx((HDC) mWindow.window, -mWindow.x, -mWindow.y, nullptr);
+::SelectClipRgn((HDC) mWindow.window, nullptr);
+::IntersectClipRect((HDC) mWindow.window, rect.left, rect.top, rect.right, rect.bottom);
+mPluginIface->event(&mData, reinterpret_cast<void*>(&paintEvent));
+#else
+NS_RUNTIMEABORT("Surface type not implemented.");
+#endif
+}
+void
+PluginInstanceChild::PaintRectToSurface(const nsIntRect& aRect,
+gfxASurface* aSurface,
+const gfxRGBA& aColor)
+{
+// Render using temporary X surface, with copy to image surface
+nsIntRect plPaintRect(aRect);
+nsRefPtr<gfxASurface> renderSurface = aSurface;
+#ifdef MOZ_X11
+if (mIsTransparent && (GetQuirks() & PluginModuleChild::QUIRK_FLASH_EXPOSE_COORD_TRANSLATION)) {
+// Work around a bug in Flash up to 10.1 d51 at least, where expose event
+// top left coordinates within the plugin-rect and not at the drawable
+// origin are misinterpreted.  (We can move the top left coordinate
+// provided it is within the clipRect.), see bug 574583
+plPaintRect.SetRect(0, 0, aRect.XMost(), aRect.YMost());
+}
+if (mHelperSurface) {
+// On X11 we can paint to non Xlib surface only with HelperSurface
+renderSurface = mHelperSurface;
+}
+#endif
+if (mIsTransparent && !CanPaintOnBackground()) {
+// Clear surface content for transparent rendering
+nsRefPtr<gfxContext> ctx = new gfxContext(renderSurface);
+ctx->SetDeviceColor(aColor);
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->Rectangle(GfxFromNsRect(plPaintRect));
+ctx->Fill();
+}
+PaintRectToPlatformSurface(plPaintRect, renderSurface);
+if (renderSurface != aSurface) {
+// Copy helper surface content to target
+nsRefPtr<gfxContext> ctx = new gfxContext(aSurface);
+ctx->SetSource(renderSurface);
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->Rectangle(GfxFromNsRect(aRect));
+ctx->Fill();
+}
+}
+void
+PluginInstanceChild::PaintRectWithAlphaExtraction(const nsIntRect& aRect,
+gfxASurface* aSurface)
+{
+NS_ABORT_IF_FALSE(aSurface->GetContentType() == gfxContentType::COLOR_ALPHA,
+"Refusing to pointlessly recover alpha");
+nsIntRect rect(aRect);
+// If |aSurface| can be used to paint and can have alpha values
+// recovered directly to it, do that to save a tmp surface and
+// copy.
+bool useSurfaceSubimageForBlack = false;
+if (gfxSurfaceType::Image == aSurface->GetType()) {
+gfxImageSurface* surfaceAsImage =
+static_cast<gfxImageSurface*>(aSurface);
+useSurfaceSubimageForBlack =
+(surfaceAsImage->Format() == gfxImageFormat::ARGB32);
+// If we're going to use a subimage, nudge the rect so that we
+// can use optimal alpha recovery.  If we're not using a
+// subimage, the temporaries should automatically get
+// fast-path alpha recovery so we don't need to do anything.
+if (useSurfaceSubimageForBlack) {
+rect =
+gfxAlphaRecovery::AlignRectForSubimageRecovery(aRect,
+surfaceAsImage);
+}
+}
+nsRefPtr<gfxImageSurface> whiteImage;
+nsRefPtr<gfxImageSurface> blackImage;
+gfxRect targetRect(rect.x, rect.y, rect.width, rect.height);
+gfxIntSize targetSize(rect.width, rect.height);
+gfxPoint deviceOffset = -targetRect.TopLeft();
+// We always use a temporary "white image"
+whiteImage = new gfxImageSurface(targetSize, gfxImageFormat::RGB24);
+if (whiteImage->CairoStatus()) {
+return;
+}
+#ifdef XP_WIN
+// On windows, we need an HDC and so can't paint directly to
+// vanilla image surfaces.  Bifurcate this painting code so that
+// we don't accidentally attempt that.
+if (!SharedDIBSurface::IsSharedDIBSurface(aSurface))
+NS_RUNTIMEABORT("Expected SharedDIBSurface!");
+// Paint the plugin directly onto the target, with a white
+// background and copy the result
+PaintRectToSurface(rect, aSurface, gfxRGBA(1.0, 1.0, 1.0));
+{
+gfxRect copyRect(gfxPoint(0, 0), targetRect.Size());
+nsRefPtr<gfxContext> ctx = new gfxContext(whiteImage);
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->SetSource(aSurface, deviceOffset);
+ctx->Rectangle(copyRect);
+ctx->Fill();
+}
+// Paint the plugin directly onto the target, with a black
+// background
+PaintRectToSurface(rect, aSurface, gfxRGBA(0.0, 0.0, 0.0));
+// Don't copy the result, just extract a subimage so that we can
+// recover alpha directly into the target
+gfxImageSurface *image = static_cast<gfxImageSurface*>(aSurface);
+blackImage = image->GetSubimage(targetRect);
+#else
+// Paint onto white background
+whiteImage->SetDeviceOffset(deviceOffset);
+PaintRectToSurface(rect, whiteImage, gfxRGBA(1.0, 1.0, 1.0));
+if (useSurfaceSubimageForBlack) {
+gfxImageSurface *surface = static_cast<gfxImageSurface*>(aSurface);
+blackImage = surface->GetSubimage(targetRect);
+} else {
+blackImage = new gfxImageSurface(targetSize,
+gfxImageFormat::ARGB32);
+}
+// Paint onto black background
+blackImage->SetDeviceOffset(deviceOffset);
+PaintRectToSurface(rect, blackImage, gfxRGBA(0.0, 0.0, 0.0));
+#endif
+NS_ABORT_IF_FALSE(whiteImage && blackImage, "Didn't paint enough!");
+// Extract alpha from black and white image and store to black
+// image
+if (!gfxAlphaRecovery::RecoverAlpha(blackImage, whiteImage)) {
+return;
+}
+// If we had to use a temporary black surface, copy the pixels
+// with alpha back to the target
+if (!useSurfaceSubimageForBlack) {
+nsRefPtr<gfxContext> ctx = new gfxContext(aSurface);
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->SetSource(blackImage);
+ctx->Rectangle(targetRect);
+ctx->Fill();
+}
+}
+bool
+PluginInstanceChild::CanPaintOnBackground()
+{
+return (mBackground &&
+mCurrentSurface &&
+mCurrentSurface->GetSize() == mBackground->GetSize());
+}
+bool
+PluginInstanceChild::ShowPluginFrame()
+{
+// mLayersRendering can be false if we somehow get here without
+// receiving AsyncSetWindow() first.  mPendingPluginCall is our
+// re-entrancy guard; we can't paint while nested inside another
+// paint.
+if (!mLayersRendering || mPendingPluginCall) {
+return false;
+}
+AutoRestore<bool> pending(mPendingPluginCall);
+mPendingPluginCall = true;
+bool temporarilyMakeVisible = !IsVisible() && !mHasPainted;
+if (temporarilyMakeVisible && mWindow.width && mWindow.height) {
+mWindow.clipRect.right = mWindow.width;
+mWindow.clipRect.bottom = mWindow.height;
+} else if (!IsVisible()) {
+// If we're not visible, don't bother painting a <0,0,0,0>
+// rect.  If we're eventually made visible, the visibility
+// change will invalidate our window.
+ClearCurrentSurface();
+return true;
+}
+if (!EnsureCurrentBuffer()) {
+return false;
+}
+#ifdef MOZ_WIDGET_COCOA
+// We can't use the thebes code with CoreAnimation so we will
+// take a different code path.
+if (mDrawingModel == NPDrawingModelCoreAnimation ||
+mDrawingModel == NPDrawingModelInvalidatingCoreAnimation ||
+mDrawingModel == NPDrawingModelCoreGraphics) {
+if (!IsVisible()) {
+return true;
+}
+if (!mDoubleBufferCARenderer.HasFrontSurface()) {
+NS_ERROR("CARenderer not initialized for rendering");
+return false;
+}
+// Clear accRect here to be able to pass
+// test_invalidate_during_plugin_paint  test
+nsIntRect rect = mAccumulatedInvalidRect;
+mAccumulatedInvalidRect.SetEmpty();
+// Fix up old invalidations that might have been made when our
+// surface was a different size
+rect.IntersectRect(rect,
+nsIntRect(0, 0,
+mDoubleBufferCARenderer.GetFrontSurfaceWidth(),
+mDoubleBufferCARenderer.GetFrontSurfaceHeight()));
+if (mDrawingModel == NPDrawingModelCoreGraphics) {
+mozilla::plugins::PluginUtilsOSX::Repaint(mCGLayer, rect);
+}
+mDoubleBufferCARenderer.Render();
+NPRect r = { (uint16_t)rect.y, (uint16_t)rect.x,
+(uint16_t)rect.YMost(), (uint16_t)rect.XMost() };
+SurfaceDescriptor currSurf;
+currSurf = IOSurfaceDescriptor(mDoubleBufferCARenderer.GetFrontSurfaceID(),
+mDoubleBufferCARenderer.GetContentsScaleFactor());
+mHasPainted = true;
+SurfaceDescriptor returnSurf;
+if (!SendShow(r, currSurf, &returnSurf)) {
+return false;
+}
+SwapSurfaces();
+return true;
+} else {
+NS_ERROR("Unsupported drawing model for async layer rendering");
+return false;
+}
+#endif
+NS_ASSERTION(mWindow.width == uint32_t(mWindow.clipRect.right - mWindow.clipRect.left) &&
+mWindow.height == uint32_t(mWindow.clipRect.bottom - mWindow.clipRect.top),
+"Clip rect should be same size as window when using layers");
+// Clear accRect here to be able to pass
+// test_invalidate_during_plugin_paint  test
+nsIntRect rect = mAccumulatedInvalidRect;
+mAccumulatedInvalidRect.SetEmpty();
+// Fix up old invalidations that might have been made when our
+// surface was a different size
+gfxIntSize surfaceSize = mCurrentSurface->GetSize();
+rect.IntersectRect(rect,
+nsIntRect(0, 0, surfaceSize.width, surfaceSize.height));
+if (!ReadbackDifferenceRect(rect)) {
+// We couldn't read back the pixels that differ between the
+// current surface and last, so we have to invalidate the
+// entire window.
+rect.SetRect(0, 0, mWindow.width, mWindow.height);
+}
+bool haveTransparentPixels =
+gfxContentType::COLOR_ALPHA == mCurrentSurface->GetContentType();
+PLUGIN_LOG_DEBUG(
+("[InstanceChild][%p] Painting%s <x=%d,y=%d, w=%d,h=%d> on surface <w=%d,h=%d>",
+this, haveTransparentPixels ? " with alpha" : "",
+rect.x, rect.y, rect.width, rect.height,
+mCurrentSurface->GetSize().width, mCurrentSurface->GetSize().height));
+if (CanPaintOnBackground()) {
+PLUGIN_LOG_DEBUG(("  (on background)"));
+// Source the background pixels ...
+{
+nsRefPtr<gfxContext> ctx =
+new gfxContext(mHelperSurface ? mHelperSurface : mCurrentSurface);
+ctx->SetSource(mBackground);
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->Rectangle(gfxRect(rect.x, rect.y, rect.width, rect.height));
+ctx->Fill();
+}
+// ... and hand off to the plugin
+// BEWARE: mBackground may die during this call
+PaintRectToSurface(rect, mCurrentSurface, gfxRGBA(0.0, 0.0, 0.0, 0.0));
+} else if (!temporarilyMakeVisible && mDoAlphaExtraction) {
+// We don't want to pay the expense of alpha extraction for
+// phony paints.
+PLUGIN_LOG_DEBUG(("  (with alpha recovery)"));
+PaintRectWithAlphaExtraction(rect, mCurrentSurface);
+} else {
+PLUGIN_LOG_DEBUG(("  (onto opaque surface)"));
+// If we're on a platform that needs helper surfaces for
+// plugins, and we're forcing a throwaway paint of a
+// wmode=transparent plugin, then make sure to use the helper
+// surface here.
+nsRefPtr<gfxASurface> target =
+(temporarilyMakeVisible && mHelperSurface) ?
+mHelperSurface : mCurrentSurface;
+PaintRectToSurface(rect, target, gfxRGBA(0.0, 0.0, 0.0, 0.0));
+}
+mHasPainted = true;
+if (temporarilyMakeVisible) {
+mWindow.clipRect.right = mWindow.clipRect.bottom = 0;
+PLUGIN_LOG_DEBUG(
+("[InstanceChild][%p] Undoing temporary clipping w=<x=%d,y=%d, w=%d,h=%d>, clip=<l=%d,t=%d,r=%d,b=%d>",
+this, mWindow.x, mWindow.y, mWindow.width, mWindow.height,
+mWindow.clipRect.left, mWindow.clipRect.top, mWindow.clipRect.right, mWindow.clipRect.bottom));
+if (mPluginIface->setwindow) {
+mPluginIface->setwindow(&mData, &mWindow);
+}
+// Skip forwarding the results of the phony paint to the
+// browser.  We may have painted a transparent plugin using
+// the opaque-plugin path, which can result in wrong pixels.
+// We also don't want to pay the expense of forwarding the
+// surface for plugins that might really be invisible.
+mAccumulatedInvalidRect.SetRect(0, 0, mWindow.width, mWindow.height);
+return true;
+}
+NPRect r = { (uint16_t)rect.y, (uint16_t)rect.x,
+(uint16_t)rect.YMost(), (uint16_t)rect.XMost() };
+SurfaceDescriptor currSurf;
+#ifdef MOZ_X11
+if (mCurrentSurface->GetType() == gfxSurfaceType::Xlib) {
+gfxXlibSurface *xsurf = static_cast<gfxXlibSurface*>(mCurrentSurface.get());
+currSurf = SurfaceDescriptorX11(xsurf);
+// Need to sync all pending x-paint requests
+// before giving drawable to another process
+XSync(mWsInfo.display, False);
+} else
+#endif
+#ifdef XP_WIN
+if (SharedDIBSurface::IsSharedDIBSurface(mCurrentSurface)) {
+SharedDIBSurface* s = static_cast<SharedDIBSurface*>(mCurrentSurface.get());
+if (!mCurrentSurfaceActor) {
+base::SharedMemoryHandle handle = nullptr;
+s->ShareToProcess(PluginModuleChild::current()->OtherProcess(), &handle);
+mCurrentSurfaceActor =
+SendPPluginSurfaceConstructor(handle,
+mCurrentSurface->GetSize(),
+haveTransparentPixels);
+}
+currSurf = mCurrentSurfaceActor;
+s->Flush();
+} else
+#endif
+if (gfxSharedImageSurface::IsSharedImage(mCurrentSurface)) {
+currSurf = static_cast<gfxSharedImageSurface*>(mCurrentSurface.get())->GetShmem();
+} else {
+NS_RUNTIMEABORT("Surface type is not remotable");
+return false;
+}
+// Unused, except to possibly return a shmem to us
+SurfaceDescriptor returnSurf;
+if (!SendShow(r, currSurf, &returnSurf)) {
+return false;
+}
+SwapSurfaces();
+mSurfaceDifferenceRect = rect;
+return true;
+}
+bool
+PluginInstanceChild::ReadbackDifferenceRect(const nsIntRect& rect)
+{
+if (!mBackSurface)
+return false;
+// We can read safely from XSurface,SharedDIBSurface and Unsafe SharedMemory,
+// because PluginHost is not able to modify that surface
+#if defined(MOZ_X11)
+if (mBackSurface->GetType() != gfxSurfaceType::Xlib &&
+!gfxSharedImageSurface::IsSharedImage(mBackSurface))
+return false;
+#elif defined(XP_WIN)
+if (!SharedDIBSurface::IsSharedDIBSurface(mBackSurface))
+return false;
+#else
+return false;
+#endif
+if (mCurrentSurface->GetContentType() != mBackSurface->GetContentType())
+return false;
+if (mSurfaceDifferenceRect.IsEmpty())
+return true;
+PLUGIN_LOG_DEBUG(
+("[InstanceChild][%p] Reading back part of <x=%d,y=%d, w=%d,h=%d>",
+this, mSurfaceDifferenceRect.x, mSurfaceDifferenceRect.y,
+mSurfaceDifferenceRect.width, mSurfaceDifferenceRect.height));
+// Read back previous content
+nsRefPtr<gfxContext> ctx = new gfxContext(mCurrentSurface);
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->SetSource(mBackSurface);
+// Subtract from mSurfaceDifferenceRect area which is overlapping with rect
+nsIntRegion result;
+result.Sub(mSurfaceDifferenceRect, nsIntRegion(rect));
+nsIntRegionRectIterator iter(result);
+const nsIntRect* r;
+while ((r = iter.Next()) != nullptr) {
+ctx->Rectangle(GfxFromNsRect(*r));
+}
+ctx->Fill();
+return true;
+}
+void
+PluginInstanceChild::InvalidateRectDelayed(void)
+{
+if (!mCurrentInvalidateTask) {
+return;
+}
+mCurrentInvalidateTask = nullptr;
+if (mAccumulatedInvalidRect.IsEmpty()) {
+return;
+}
+if (!ShowPluginFrame()) {
+AsyncShowPluginFrame();
+}
+}
+void
+PluginInstanceChild::AsyncShowPluginFrame(void)
+{
+if (mCurrentInvalidateTask) {
+return;
+}
+mCurrentInvalidateTask =
+NewRunnableMethod(this, &PluginInstanceChild::InvalidateRectDelayed);
+MessageLoop::current()->PostTask(FROM_HERE, mCurrentInvalidateTask);
+}
+void
+PluginInstanceChild::InvalidateRect(NPRect* aInvalidRect)
+{
+NS_ASSERTION(aInvalidRect, "Null pointer!");
+#ifdef OS_WIN
+// Invalidate and draw locally for windowed plugins.
+if (mWindow.type == NPWindowTypeWindow) {
+NS_ASSERTION(IsWindow(mPluginWindowHWND), "Bad window?!");
+RECT rect = { aInvalidRect->left, aInvalidRect->top,
+aInvalidRect->right, aInvalidRect->bottom };
+::InvalidateRect(mPluginWindowHWND, &rect, FALSE);
+return;
+}
+#endif
+if (mLayersRendering) {
+nsIntRect r(aInvalidRect->left, aInvalidRect->top,
+aInvalidRect->right - aInvalidRect->left,
+aInvalidRect->bottom - aInvalidRect->top);
+mAccumulatedInvalidRect.UnionRect(r, mAccumulatedInvalidRect);
+// If we are able to paint and invalidate sent, then reset
+// accumulated rectangle
+AsyncShowPluginFrame();
+return;
+}
+// If we were going to use layers rendering but it's not set up
+// yet, and the plugin happens to call this first, we'll forward
+// the invalidation to the browser.  It's unclear whether
+// non-layers plugins need this rect forwarded when their window
+// width or height is 0, which it would be for layers plugins
+// before their first SetWindow().
+SendNPN_InvalidateRect(*aInvalidRect);
+}
+bool
+PluginInstanceChild::RecvUpdateBackground(const SurfaceDescriptor& aBackground,
+const nsIntRect& aRect)
+{
+NS_ABORT_IF_FALSE(mIsTransparent, "Only transparent plugins use backgrounds");
+if (!mBackground) {
+// XXX refactor me
+switch (aBackground.type()) {
+#ifdef MOZ_X11
+case SurfaceDescriptor::TSurfaceDescriptorX11: {
+mBackground = aBackground.get_SurfaceDescriptorX11().OpenForeign();
+break;
+}
+#endif
+case SurfaceDescriptor::TShmem: {
+mBackground = gfxSharedImageSurface::Open(aBackground.get_Shmem());
+break;
+}
+default:
+NS_RUNTIMEABORT("Unexpected background surface descriptor");
+}
+if (!mBackground) {
+return false;
+}
+gfxIntSize bgSize = mBackground->GetSize();
+mAccumulatedInvalidRect.UnionRect(mAccumulatedInvalidRect,
+nsIntRect(0, 0, bgSize.width, bgSize.height));
+AsyncShowPluginFrame();
+return true;
+}
+// XXX refactor me
+mAccumulatedInvalidRect.UnionRect(aRect, mAccumulatedInvalidRect);
+// This must be asynchronous, because we may be nested within RPC messages
+// which do not expect to receiving paint events.
+AsyncShowPluginFrame();
+return true;
+}
+PPluginBackgroundDestroyerChild*
+PluginInstanceChild::AllocPPluginBackgroundDestroyerChild()
+{
+return new PluginBackgroundDestroyerChild();
+}
+bool
+PluginInstanceChild::RecvPPluginBackgroundDestroyerConstructor(
+PPluginBackgroundDestroyerChild* aActor)
+{
+// Our background changed, so we have to invalidate the area
+// painted with the old background.  If the background was
+// destroyed because we have a new background, then we expect to
+// be notified of that "soon", before processing the asynchronous
+// invalidation here.  If we're *not* getting a new background,
+// our current front surface is stale and we want to repaint
+// "soon" so that we can hand the browser back a surface with
+// alpha values.  (We should be notified of that invalidation soon
+// too, but we don't assume that here.)
+if (mBackground) {
+gfxIntSize bgsize = mBackground->GetSize();
+mAccumulatedInvalidRect.UnionRect(
+nsIntRect(0, 0, bgsize.width, bgsize.height), mAccumulatedInvalidRect);
+// NB: we don't have to XSync here because only ShowPluginFrame()
+// uses mBackground, and it always XSyncs after finishing.
+mBackground = nullptr;
+AsyncShowPluginFrame();
+}
+return PPluginBackgroundDestroyerChild::Send__delete__(aActor);
+}
+bool
+PluginInstanceChild::DeallocPPluginBackgroundDestroyerChild(
+PPluginBackgroundDestroyerChild* aActor)
+{
+delete aActor;
+return true;
+}
+uint32_t
+PluginInstanceChild::ScheduleTimer(uint32_t interval, bool repeat,
+TimerFunc func)
+{
+ChildTimer* t = new ChildTimer(this, interval, repeat, func);
+if (0 == t->ID()) {
+delete t;
+return 0;
+}
+mTimers.AppendElement(t);
+return t->ID();
+}
+void
+PluginInstanceChild::UnscheduleTimer(uint32_t id)
+{
+if (0 == id)
+return;
+mTimers.RemoveElement(id, ChildTimer::IDComparator());
+}
+void
+PluginInstanceChild::AsyncCall(PluginThreadCallback aFunc, void* aUserData)
+{
+ChildAsyncCall* task = new ChildAsyncCall(this, aFunc, aUserData);
+{
+MutexAutoLock lock(mAsyncCallMutex);
+mPendingAsyncCalls.AppendElement(task);
+}
+ProcessChild::message_loop()->PostTask(FROM_HERE, task);
+}
+static PLDHashOperator
+InvalidateObject(DeletingObjectEntry* e, void* userArg)
+{
+NPObject* o = e->GetKey();
+if (!e->mDeleted && o->_class && o->_class->invalidate)
+o->_class->invalidate(o);
+return PL_DHASH_NEXT;
+}
+static PLDHashOperator
+DeleteObject(DeletingObjectEntry* e, void* userArg)
+{
+NPObject* o = e->GetKey();
+if (!e->mDeleted) {
+e->mDeleted = true;
+#ifdef NS_BUILD_REFCNT_LOGGING
+{
+int32_t refcnt = o->referenceCount;
+while (refcnt) {
+--refcnt;
+NS_LOG_RELEASE(o, refcnt, "NPObject");
+}
+}
+#endif
+PluginModuleChild::DeallocNPObject(o);
+}
+return PL_DHASH_NEXT;
+}
+void
+PluginInstanceChild::SwapSurfaces()
+{
+nsRefPtr<gfxASurface> tmpsurf = mCurrentSurface;
+#ifdef XP_WIN
+PPluginSurfaceChild* tmpactor = mCurrentSurfaceActor;
+#endif
+mCurrentSurface = mBackSurface;
+#ifdef XP_WIN
+mCurrentSurfaceActor = mBackSurfaceActor;
+#endif
+mBackSurface = tmpsurf;
+#ifdef XP_WIN
+mBackSurfaceActor = tmpactor;
+#endif
+#ifdef MOZ_WIDGET_COCOA
+mDoubleBufferCARenderer.SwapSurfaces();
+// Outdated back surface... not usable anymore due to changed plugin size.
+// Dropping obsolete surface
+if (mDoubleBufferCARenderer.HasFrontSurface() &&
+mDoubleBufferCARenderer.HasBackSurface() &&
+(mDoubleBufferCARenderer.GetFrontSurfaceWidth() !=
+mDoubleBufferCARenderer.GetBackSurfaceWidth() ||
+mDoubleBufferCARenderer.GetFrontSurfaceHeight() !=
+mDoubleBufferCARenderer.GetBackSurfaceHeight() ||
+mDoubleBufferCARenderer.GetFrontSurfaceContentsScaleFactor() !=
+mDoubleBufferCARenderer.GetBackSurfaceContentsScaleFactor())) {
+mDoubleBufferCARenderer.ClearFrontSurface();
+}
+#else
+if (mCurrentSurface && mBackSurface &&
+(mCurrentSurface->GetSize() != mBackSurface->GetSize() ||
+mCurrentSurface->GetContentType() != mBackSurface->GetContentType())) {
+ClearCurrentSurface();
+}
+#endif
+}
+void
+PluginInstanceChild::ClearCurrentSurface()
+{
+mCurrentSurface = nullptr;
+#ifdef MOZ_WIDGET_COCOA
+if (mDoubleBufferCARenderer.HasFrontSurface()) {
+mDoubleBufferCARenderer.ClearFrontSurface();
+}
+#endif
+#ifdef XP_WIN
+if (mCurrentSurfaceActor) {
+PPluginSurfaceChild::Send__delete__(mCurrentSurfaceActor);
+mCurrentSurfaceActor = nullptr;
+}
+#endif
+mHelperSurface = nullptr;
+}
+void
+PluginInstanceChild::ClearAllSurfaces()
+{
+if (mBackSurface) {
+// Get last surface back, and drop it
+SurfaceDescriptor temp = null_t();
+NPRect r = { 0, 0, 1, 1 };
+SendShow(r, temp, &temp);
+}
+if (gfxSharedImageSurface::IsSharedImage(mCurrentSurface))
+DeallocShmem(static_cast<gfxSharedImageSurface*>(mCurrentSurface.get())->GetShmem());
+if (gfxSharedImageSurface::IsSharedImage(mBackSurface))
+DeallocShmem(static_cast<gfxSharedImageSurface*>(mBackSurface.get())->GetShmem());
+mCurrentSurface = nullptr;
+mBackSurface = nullptr;
+#ifdef XP_WIN
+if (mCurrentSurfaceActor) {
+PPluginSurfaceChild::Send__delete__(mCurrentSurfaceActor);
+mCurrentSurfaceActor = nullptr;
+}
+if (mBackSurfaceActor) {
+PPluginSurfaceChild::Send__delete__(mBackSurfaceActor);
+mBackSurfaceActor = nullptr;
+}
+#endif
+#ifdef MOZ_WIDGET_COCOA
+if (mDoubleBufferCARenderer.HasBackSurface()) {
+// Get last surface back, and drop it
+SurfaceDescriptor temp = null_t();
+NPRect r = { 0, 0, 1, 1 };
+SendShow(r, temp, &temp);
+}
+if (mCGLayer) {
+mozilla::plugins::PluginUtilsOSX::ReleaseCGLayer(mCGLayer);
+mCGLayer = nullptr;
+}
+mDoubleBufferCARenderer.ClearFrontSurface();
+mDoubleBufferCARenderer.ClearBackSurface();
+#endif
+}
+PLDHashOperator
+PluginInstanceChild::DeleteSurface(NPAsyncSurface* surf, nsAutoPtr<AsyncBitmapData> &data, void* userArg)
+{
+PluginInstanceChild *inst = static_cast<PluginInstanceChild*>(userArg);
+inst->DeallocShmem(data->mShmem);
+return PL_DHASH_REMOVE;
+}
+bool
+PluginInstanceChild::AnswerNPP_Destroy(NPError* aResult)
+{
+PLUGIN_LOG_DEBUG_METHOD;
+AssertPluginThread();
+*aResult = NPERR_NO_ERROR;
+#if defined(OS_WIN)
+SetProp(mPluginWindowHWND, kPluginIgnoreSubclassProperty, (HANDLE)1);
+#endif
+InfallibleTArray<PBrowserStreamChild*> streams;
+ManagedPBrowserStreamChild(streams);
+// First make sure none of these streams become deleted
+for (uint32_t i = 0; i < streams.Length(); ) {
+if (static_cast<BrowserStreamChild*>(streams[i])->InstanceDying())
+++i;
+else
+streams.RemoveElementAt(i);
+}
+for (uint32_t i = 0; i < streams.Length(); ++i)
+static_cast<BrowserStreamChild*>(streams[i])->FinishDelivery();
+mTimers.Clear();
+// NPP_Destroy() should be a synchronization point for plugin threads
+// calling NPN_AsyncCall: after this function returns, they are no longer
+// allowed to make async calls on this instance.
+PluginModuleChild::current()->NPP_Destroy(this);
+mData.ndata = 0;
+if (mCurrentInvalidateTask) {
+mCurrentInvalidateTask->Cancel();
+mCurrentInvalidateTask = nullptr;
+}
+if (mCurrentAsyncSetWindowTask) {
+mCurrentAsyncSetWindowTask->Cancel();
+mCurrentAsyncSetWindowTask = nullptr;
+}
+{
+MutexAutoLock autoLock(mAsyncInvalidateMutex);
+if (mAsyncInvalidateTask) {
+mAsyncInvalidateTask->Cancel();
+mAsyncInvalidateTask = nullptr;
+}
+}
+ClearAllSurfaces();
+mDeletingHash = new nsTHashtable<DeletingObjectEntry>;
+PluginModuleChild::current()->FindNPObjectsForInstance(this);
+mDeletingHash->EnumerateEntries(InvalidateObject, nullptr);
+mDeletingHash->EnumerateEntries(DeleteObject, nullptr);
+// Null out our cached actors as they should have been killed in the
+// PluginInstanceDestroyed call above.
+mCachedWindowActor = nullptr;
+mCachedElementActor = nullptr;
+#if defined(OS_WIN)
+SharedSurfaceRelease();
+DestroyWinlessPopupSurrogate();
+UnhookWinlessFlashThrottle();
+DestroyPluginWindow();
+#endif
+// Pending async calls are discarded, not delivered. This matches the
+// in-process behavior.
+for (uint32_t i = 0; i < mPendingAsyncCalls.Length(); ++i)
+mPendingAsyncCalls[i]->Cancel();
+mPendingAsyncCalls.Clear();
+if (mAsyncBitmaps.Count()) {
+NS_ERROR("Not all AsyncBitmaps were finalized by a plugin!");
+mAsyncBitmaps.Enumerate(DeleteSurface, this);
+}
+#if (MOZ_WIDGET_GTK == 2)
+if (mWindow.type == NPWindowTypeWindow && !mXEmbed) {
+xt_client_xloop_destroy();
+}
+#endif
+#if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
+DeleteWindow();
+#endif
+return true;
+}

The Tor Browser / file comparison

comparison: dom/plugins/ipc/PluginInstanceChild.cpp

dom/plugins/ipc/PluginInstanceChild.cpp