Add m-esr52 at 52.6.0

1 files changed, 1580 insertions, 0 deletions

diff --git a/widget/PuppetWidget.cpp b/widget/PuppetWidget.cpp
new file mode 100644
index 000000000..1fa13ee6f
--- /dev/null
+++ b/widget/PuppetWidget.cpp
@@ -0,0 +1,1580 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 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 "base/basictypes.h"
+
+#include "ClientLayerManager.h"
+#include "gfxPlatform.h"
+#include "mozilla/dom/TabChild.h"
+#include "mozilla/Hal.h"
+#include "mozilla/IMEStateManager.h"
+#include "mozilla/layers/APZChild.h"
+#include "mozilla/layers/PLayerTransactionChild.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/TextComposition.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/Unused.h"
+#include "PuppetWidget.h"
+#include "nsContentUtils.h"
+#include "nsIWidgetListener.h"
+#include "imgIContainer.h"
+#include "nsView.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::hal;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+using namespace mozilla::widget;
+
+static void
+InvalidateRegion(nsIWidget* aWidget, const LayoutDeviceIntRegion& aRegion)
+{
+  for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
+    aWidget->Invalidate(iter.Get());
+  }
+}
+
+/*static*/ already_AddRefed<nsIWidget>
+nsIWidget::CreatePuppetWidget(TabChild* aTabChild)
+{
+  MOZ_ASSERT(!aTabChild || nsIWidget::UsePuppetWidgets(),
+             "PuppetWidgets not allowed in this configuration");
+
+  nsCOMPtr<nsIWidget> widget = new PuppetWidget(aTabChild);
+  return widget.forget();
+}
+
+namespace mozilla {
+namespace widget {
+
+static bool
+IsPopup(const nsWidgetInitData* aInitData)
+{
+  return aInitData && aInitData->mWindowType == eWindowType_popup;
+}
+
+static bool
+MightNeedIMEFocus(const nsWidgetInitData* aInitData)
+{
+  // In the puppet-widget world, popup widgets are just dummies and
+  // shouldn't try to mess with IME state.
+#ifdef MOZ_CROSS_PROCESS_IME
+  return !IsPopup(aInitData);
+#else
+  return false;
+#endif
+}
+
+// Arbitrary, fungible.
+const size_t PuppetWidget::kMaxDimension = 4000;
+
+NS_IMPL_ISUPPORTS_INHERITED0(PuppetWidget, nsBaseWidget)
+
+PuppetWidget::PuppetWidget(TabChild* aTabChild)
+  : mTabChild(aTabChild)
+  , mMemoryPressureObserver(nullptr)
+  , mDPI(-1)
+  , mRounding(-1)
+  , mDefaultScale(-1)
+  , mCursorHotspotX(0)
+  , mCursorHotspotY(0)
+  , mNativeKeyCommandsValid(false)
+{
+  MOZ_COUNT_CTOR(PuppetWidget);
+
+  mSingleLineCommands.SetCapacity(4);
+  mMultiLineCommands.SetCapacity(4);
+  mRichTextCommands.SetCapacity(4);
+
+  // Setting 'Unknown' means "not yet cached".
+  mInputContext.mIMEState.mEnabled = IMEState::UNKNOWN;
+}
+
+PuppetWidget::~PuppetWidget()
+{
+  MOZ_COUNT_DTOR(PuppetWidget);
+
+  Destroy();
+}
+
+void
+PuppetWidget::InfallibleCreate(nsIWidget* aParent,
+                               nsNativeWidget aNativeParent,
+                               const LayoutDeviceIntRect& aRect,
+                               nsWidgetInitData* aInitData)
+{
+  MOZ_ASSERT(!aNativeParent, "got a non-Puppet native parent");
+
+  BaseCreate(nullptr, aInitData);
+
+  mBounds = aRect;
+  mEnabled = true;
+  mVisible = true;
+
+  mDrawTarget = gfxPlatform::GetPlatform()->
+    CreateOffscreenContentDrawTarget(IntSize(1, 1), SurfaceFormat::B8G8R8A8);
+
+  mNeedIMEStateInit = MightNeedIMEFocus(aInitData);
+
+  PuppetWidget* parent = static_cast<PuppetWidget*>(aParent);
+  if (parent) {
+    parent->SetChild(this);
+    mLayerManager = parent->GetLayerManager();
+  }
+  else {
+    Resize(mBounds.x, mBounds.y, mBounds.width, mBounds.height, false);
+  }
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    mMemoryPressureObserver = new MemoryPressureObserver(this);
+    obs->AddObserver(mMemoryPressureObserver, "memory-pressure", false);
+  }
+}
+
+nsresult
+PuppetWidget::Create(nsIWidget* aParent,
+                     nsNativeWidget aNativeParent,
+                     const LayoutDeviceIntRect& aRect,
+                     nsWidgetInitData* aInitData)
+{
+  InfallibleCreate(aParent, aNativeParent, aRect, aInitData);
+  return NS_OK;
+}
+
+void
+PuppetWidget::InitIMEState()
+{
+  MOZ_ASSERT(mTabChild);
+  if (mNeedIMEStateInit) {
+    mContentCache.Clear();
+    mTabChild->SendUpdateContentCache(mContentCache);
+    mIMEPreferenceOfParent = nsIMEUpdatePreference();
+    mNeedIMEStateInit = false;
+  }
+}
+
+already_AddRefed<nsIWidget>
+PuppetWidget::CreateChild(const LayoutDeviceIntRect& aRect,
+                          nsWidgetInitData* aInitData,
+                          bool aForceUseIWidgetParent)
+{
+  bool isPopup = IsPopup(aInitData);
+  nsCOMPtr<nsIWidget> widget = nsIWidget::CreatePuppetWidget(mTabChild);
+  return ((widget &&
+           NS_SUCCEEDED(widget->Create(isPopup ? nullptr: this, nullptr, aRect,
+                                       aInitData))) ?
+          widget.forget() : nullptr);
+}
+
+void
+PuppetWidget::Destroy()
+{
+  if (mOnDestroyCalled) {
+    return;
+  }
+  mOnDestroyCalled = true;
+
+  Base::OnDestroy();
+  Base::Destroy();
+  mPaintTask.Revoke();
+  if (mMemoryPressureObserver) {
+    mMemoryPressureObserver->Remove();
+  }
+  mMemoryPressureObserver = nullptr;
+  mChild = nullptr;
+  if (mLayerManager) {
+    mLayerManager->Destroy();
+  }
+  mLayerManager = nullptr;
+  mTabChild = nullptr;
+}
+
+NS_IMETHODIMP
+PuppetWidget::Show(bool aState)
+{
+  NS_ASSERTION(mEnabled,
+               "does it make sense to Show()/Hide() a disabled widget?");
+
+  bool wasVisible = mVisible;
+  mVisible = aState;
+
+  if (mChild) {
+    mChild->mVisible = aState;
+  }
+
+  if (!wasVisible && mVisible) {
+    // The previously attached widget listener is handy if
+    // we're transitioning from page to page without dropping
+    // layers (since we'll continue to show the old layers
+    // associated with that old widget listener). If the
+    // PuppetWidget was hidden, those layers are dropped,
+    // so the previously attached widget listener is really
+    // of no use anymore (and is actually actively harmful - see
+    // bug 1323586).
+    mPreviouslyAttachedWidgetListener = nullptr;
+    Resize(mBounds.width, mBounds.height, false);
+    Invalidate(mBounds);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetWidget::Resize(double aWidth,
+                     double aHeight,
+                     bool   aRepaint)
+{
+  LayoutDeviceIntRect oldBounds = mBounds;
+  mBounds.SizeTo(LayoutDeviceIntSize(NSToIntRound(aWidth),
+                                     NSToIntRound(aHeight)));
+
+  if (mChild) {
+    return mChild->Resize(aWidth, aHeight, aRepaint);
+  }
+
+  // XXX: roc says that |aRepaint| dictates whether or not to
+  // invalidate the expanded area
+  if (oldBounds.Size() < mBounds.Size() && aRepaint) {
+    LayoutDeviceIntRegion dirty(mBounds);
+    dirty.Sub(dirty, oldBounds);
+    InvalidateRegion(this, dirty);
+  }
+
+  // call WindowResized() on both the current listener, and possibly
+  // also the previous one if we're in a state where we're drawing that one
+  // because the current one is paint suppressed
+  if (!oldBounds.IsEqualEdges(mBounds) && mAttachedWidgetListener) {
+    if (GetCurrentWidgetListener() &&
+        GetCurrentWidgetListener() != mAttachedWidgetListener) {
+      GetCurrentWidgetListener()->WindowResized(this, mBounds.width, mBounds.height);
+    }
+    mAttachedWidgetListener->WindowResized(this, mBounds.width, mBounds.height);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::ConfigureChildren(const nsTArray<Configuration>& aConfigurations)
+{
+  for (uint32_t i = 0; i < aConfigurations.Length(); ++i) {
+    const Configuration& configuration = aConfigurations[i];
+    PuppetWidget* w = static_cast<PuppetWidget*>(configuration.mChild.get());
+    NS_ASSERTION(w->GetParent() == this,
+                 "Configured widget is not a child");
+    w->SetWindowClipRegion(configuration.mClipRegion, true);
+    LayoutDeviceIntRect bounds = w->GetBounds();
+    if (bounds.Size() != configuration.mBounds.Size()) {
+      w->Resize(configuration.mBounds.x, configuration.mBounds.y,
+                configuration.mBounds.width, configuration.mBounds.height,
+                true);
+    } else if (bounds.TopLeft() != configuration.mBounds.TopLeft()) {
+      w->Move(configuration.mBounds.x, configuration.mBounds.y);
+    }
+    w->SetWindowClipRegion(configuration.mClipRegion, false);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetWidget::SetFocus(bool aRaise)
+{
+  if (aRaise && mTabChild) {
+    mTabChild->SendRequestFocus(true);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetWidget::Invalidate(const LayoutDeviceIntRect& aRect)
+{
+#ifdef DEBUG
+  debug_DumpInvalidate(stderr, this, &aRect, "PuppetWidget", 0);
+#endif
+
+  if (mChild) {
+    return mChild->Invalidate(aRect);
+  }
+
+  mDirtyRegion.Or(mDirtyRegion, aRect);
+
+  if (!mDirtyRegion.IsEmpty() && !mPaintTask.IsPending()) {
+    mPaintTask = new PaintTask(this);
+    return NS_DispatchToCurrentThread(mPaintTask.get());
+  }
+
+  return NS_OK;
+}
+
+void
+PuppetWidget::InitEvent(WidgetGUIEvent& event, LayoutDeviceIntPoint* aPoint)
+{
+  if (nullptr == aPoint) {
+    event.mRefPoint = LayoutDeviceIntPoint(0, 0);
+  } else {
+    // use the point override if provided
+    event.mRefPoint = *aPoint;
+  }
+  event.mTime = PR_Now() / 1000;
+}
+
+NS_IMETHODIMP
+PuppetWidget::DispatchEvent(WidgetGUIEvent* event, nsEventStatus& aStatus)
+{
+#ifdef DEBUG
+  debug_DumpEvent(stdout, event->mWidget, event, "PuppetWidget", 0);
+#endif
+
+  MOZ_ASSERT(!mChild || mChild->mWindowType == eWindowType_popup,
+             "Unexpected event dispatch!");
+
+  AutoCacheNativeKeyCommands autoCache(this);
+  if (event->mFlags.mIsSynthesizedForTests && !mNativeKeyCommandsValid) {
+    WidgetKeyboardEvent* keyEvent = event->AsKeyboardEvent();
+    if (keyEvent) {
+      mTabChild->RequestNativeKeyBindings(&autoCache, keyEvent);
+    }
+  }
+
+  if (event->mClass == eCompositionEventClass) {
+    // Store the latest native IME context of parent process's widget or
+    // TextEventDispatcher if it's in this process.
+    WidgetCompositionEvent* compositionEvent = event->AsCompositionEvent();
+#ifdef DEBUG
+    if (mNativeIMEContext.IsValid() &&
+        mNativeIMEContext != compositionEvent->mNativeIMEContext) {
+      RefPtr<TextComposition> composition =
+        IMEStateManager::GetTextCompositionFor(this);
+      MOZ_ASSERT(!composition,
+        "When there is composition caused by old native IME context, "
+        "composition events caused by different native IME context are not "
+        "allowed");
+    }
+#endif // #ifdef DEBUG
+    mNativeIMEContext = compositionEvent->mNativeIMEContext;
+  }
+
+  aStatus = nsEventStatus_eIgnore;
+
+  if (GetCurrentWidgetListener()) {
+    aStatus = GetCurrentWidgetListener()->HandleEvent(event, mUseAttachedEvents);
+  }
+
+  return NS_OK;
+}
+
+nsEventStatus
+PuppetWidget::DispatchInputEvent(WidgetInputEvent* aEvent)
+{
+  if (!AsyncPanZoomEnabled()) {
+    nsEventStatus status = nsEventStatus_eIgnore;
+    DispatchEvent(aEvent, status);
+    return status;
+  }
+
+  if (!mTabChild) {
+    return nsEventStatus_eIgnore;
+  }
+
+  switch (aEvent->mClass) {
+    case eWheelEventClass:
+      Unused <<
+        mTabChild->SendDispatchWheelEvent(*aEvent->AsWheelEvent());
+      break;
+    case eMouseEventClass:
+      Unused <<
+        mTabChild->SendDispatchMouseEvent(*aEvent->AsMouseEvent());
+      break;
+    case eKeyboardEventClass:
+      Unused <<
+        mTabChild->SendDispatchKeyboardEvent(*aEvent->AsKeyboardEvent());
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("unsupported event type");
+  }
+
+  return nsEventStatus_eIgnore;
+}
+
+nsresult
+PuppetWidget::SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
+                                       int32_t aNativeKeyCode,
+                                       uint32_t aModifierFlags,
+                                       const nsAString& aCharacters,
+                                       const nsAString& aUnmodifiedCharacters,
+                                       nsIObserver* aObserver)
+{
+  AutoObserverNotifier notifier(aObserver, "keyevent");
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendSynthesizeNativeKeyEvent(aNativeKeyboardLayout, aNativeKeyCode,
+    aModifierFlags, nsString(aCharacters), nsString(aUnmodifiedCharacters),
+    notifier.SaveObserver());
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::SynthesizeNativeMouseEvent(mozilla::LayoutDeviceIntPoint aPoint,
+                                         uint32_t aNativeMessage,
+                                         uint32_t aModifierFlags,
+                                         nsIObserver* aObserver)
+{
+  AutoObserverNotifier notifier(aObserver, "mouseevent");
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendSynthesizeNativeMouseEvent(aPoint, aNativeMessage,
+    aModifierFlags, notifier.SaveObserver());
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::SynthesizeNativeMouseMove(mozilla::LayoutDeviceIntPoint aPoint,
+                                        nsIObserver* aObserver)
+{
+  AutoObserverNotifier notifier(aObserver, "mousemove");
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendSynthesizeNativeMouseMove(aPoint, notifier.SaveObserver());
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::SynthesizeNativeMouseScrollEvent(mozilla::LayoutDeviceIntPoint aPoint,
+                                               uint32_t aNativeMessage,
+                                               double aDeltaX,
+                                               double aDeltaY,
+                                               double aDeltaZ,
+                                               uint32_t aModifierFlags,
+                                               uint32_t aAdditionalFlags,
+                                               nsIObserver* aObserver)
+{
+  AutoObserverNotifier notifier(aObserver, "mousescrollevent");
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendSynthesizeNativeMouseScrollEvent(aPoint, aNativeMessage,
+    aDeltaX, aDeltaY, aDeltaZ, aModifierFlags, aAdditionalFlags,
+    notifier.SaveObserver());
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::SynthesizeNativeTouchPoint(uint32_t aPointerId,
+                                         TouchPointerState aPointerState,
+                                         LayoutDeviceIntPoint aPoint,
+                                         double aPointerPressure,
+                                         uint32_t aPointerOrientation,
+                                         nsIObserver* aObserver)
+{
+  AutoObserverNotifier notifier(aObserver, "touchpoint");
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendSynthesizeNativeTouchPoint(aPointerId, aPointerState,
+    aPoint, aPointerPressure, aPointerOrientation,
+    notifier.SaveObserver());
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint,
+                                       bool aLongTap,
+                                       nsIObserver* aObserver)
+{
+  AutoObserverNotifier notifier(aObserver, "touchtap");
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendSynthesizeNativeTouchTap(aPoint, aLongTap,
+    notifier.SaveObserver());
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::ClearNativeTouchSequence(nsIObserver* aObserver)
+{
+  AutoObserverNotifier notifier(aObserver, "cleartouch");
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendClearNativeTouchSequence(notifier.SaveObserver());
+  return NS_OK;
+}
+ 
+void
+PuppetWidget::SetConfirmedTargetAPZC(uint64_t aInputBlockId,
+                                     const nsTArray<ScrollableLayerGuid>& aTargets) const
+{
+  if (mTabChild) {
+    mTabChild->SetTargetAPZC(aInputBlockId, aTargets);
+  }
+}
+
+void
+PuppetWidget::UpdateZoomConstraints(const uint32_t& aPresShellId,
+                                    const FrameMetrics::ViewID& aViewId,
+                                    const Maybe<ZoomConstraints>& aConstraints)
+{
+  if (mTabChild) {
+    mTabChild->DoUpdateZoomConstraints(aPresShellId, aViewId, aConstraints);
+  }
+}
+
+bool
+PuppetWidget::AsyncPanZoomEnabled() const
+{
+  return mTabChild && mTabChild->AsyncPanZoomEnabled();
+}
+
+NS_IMETHODIMP_(bool)
+PuppetWidget::ExecuteNativeKeyBinding(NativeKeyBindingsType aType,
+                                      const mozilla::WidgetKeyboardEvent& aEvent,
+                                      DoCommandCallback aCallback,
+                                      void* aCallbackData)
+{
+  // B2G doesn't have native key bindings.
+#ifdef MOZ_WIDGET_GONK
+  return false;
+#else // #ifdef MOZ_WIDGET_GONK
+  AutoCacheNativeKeyCommands autoCache(this);
+  if (!aEvent.mWidget && !mNativeKeyCommandsValid) {
+    MOZ_ASSERT(!aEvent.mFlags.mIsSynthesizedForTests);
+    // Abort if untrusted to avoid leaking system settings
+    if (NS_WARN_IF(!aEvent.IsTrusted())) {
+      return false;
+    }
+    mTabChild->RequestNativeKeyBindings(&autoCache, &aEvent);
+  }
+
+  MOZ_ASSERT(mNativeKeyCommandsValid);
+
+  const nsTArray<mozilla::CommandInt>* commands = nullptr;
+  switch (aType) {
+    case nsIWidget::NativeKeyBindingsForSingleLineEditor:
+      commands = &mSingleLineCommands;
+      break;
+    case nsIWidget::NativeKeyBindingsForMultiLineEditor:
+      commands = &mMultiLineCommands;
+      break;
+    case nsIWidget::NativeKeyBindingsForRichTextEditor:
+      commands = &mRichTextCommands;
+      break;
+    default:
+      MOZ_CRASH("Invalid type");
+      break;
+  }
+
+  if (commands->IsEmpty()) {
+    return false;
+  }
+
+  for (uint32_t i = 0; i < commands->Length(); i++) {
+    aCallback(static_cast<mozilla::Command>((*commands)[i]), aCallbackData);
+  }
+  return true;
+#endif
+}
+
+LayerManager*
+PuppetWidget::GetLayerManager(PLayerTransactionChild* aShadowManager,
+                              LayersBackend aBackendHint,
+                              LayerManagerPersistence aPersistence)
+{
+  if (!mLayerManager) {
+    mLayerManager = new ClientLayerManager(this);
+  }
+  ShadowLayerForwarder* lf = mLayerManager->AsShadowForwarder();
+  if (lf && !lf->HasShadowManager() && aShadowManager) {
+    lf->SetShadowManager(aShadowManager);
+  }
+  return mLayerManager;
+}
+
+LayerManager*
+PuppetWidget::RecreateLayerManager(PLayerTransactionChild* aShadowManager)
+{
+  mLayerManager = new ClientLayerManager(this);
+  if (ShadowLayerForwarder* lf = mLayerManager->AsShadowForwarder()) {
+    lf->SetShadowManager(aShadowManager);
+  }
+  return mLayerManager;
+}
+
+nsresult
+PuppetWidget::RequestIMEToCommitComposition(bool aCancel)
+{
+#ifdef MOZ_CROSS_PROCESS_IME
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+
+  MOZ_ASSERT(!Destroyed());
+
+  // There must not be composition which is caused by the PuppetWidget instance.
+  if (NS_WARN_IF(!mNativeIMEContext.IsValid())) {
+    return NS_OK;
+  }
+
+  RefPtr<TextComposition> composition =
+    IMEStateManager::GetTextCompositionFor(this);
+  // This method shouldn't be called when there is no text composition instance.
+  if (NS_WARN_IF(!composition)) {
+    return NS_OK;
+  }
+
+  bool isCommitted = false;
+  nsAutoString committedString;
+  if (NS_WARN_IF(!mTabChild->SendRequestIMEToCommitComposition(
+                               aCancel, &isCommitted, &committedString))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // If the composition wasn't committed synchronously, we need to wait async
+  // composition events for destroying the TextComposition instance.
+  if (!isCommitted) {
+    return NS_OK;
+  }
+
+  // Dispatch eCompositionCommit event.
+  WidgetCompositionEvent compositionCommitEvent(true, eCompositionCommit, this);
+  InitEvent(compositionCommitEvent, nullptr);
+  compositionCommitEvent.mData = committedString;
+  nsEventStatus status = nsEventStatus_eIgnore;
+  DispatchEvent(&compositionCommitEvent, status);
+
+  // NOTE: PuppetWidget might be destroyed already.
+
+#endif // #ifdef MOZ_CROSS_PROCESS_IME
+
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::NotifyIMEInternal(const IMENotification& aIMENotification)
+{
+  switch (aIMENotification.mMessage) {
+    case REQUEST_TO_COMMIT_COMPOSITION:
+      return RequestIMEToCommitComposition(false);
+    case REQUEST_TO_CANCEL_COMPOSITION:
+      return RequestIMEToCommitComposition(true);
+    case NOTIFY_IME_OF_FOCUS:
+    case NOTIFY_IME_OF_BLUR:
+      return NotifyIMEOfFocusChange(aIMENotification);
+    case NOTIFY_IME_OF_SELECTION_CHANGE:
+      return NotifyIMEOfSelectionChange(aIMENotification);
+    case NOTIFY_IME_OF_TEXT_CHANGE:
+      return NotifyIMEOfTextChange(aIMENotification);
+    case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED:
+      return NotifyIMEOfCompositionUpdate(aIMENotification);
+    case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
+      return NotifyIMEOfMouseButtonEvent(aIMENotification);
+    case NOTIFY_IME_OF_POSITION_CHANGE:
+      return NotifyIMEOfPositionChange(aIMENotification);
+    default:
+      return NS_ERROR_NOT_IMPLEMENTED;
+  }
+}
+
+NS_IMETHODIMP
+PuppetWidget::StartPluginIME(const mozilla::WidgetKeyboardEvent& aKeyboardEvent,
+                             int32_t aPanelX, int32_t aPanelY,
+                             nsString& aCommitted)
+{
+  if (!mTabChild ||
+      !mTabChild->SendStartPluginIME(aKeyboardEvent, aPanelX,
+                                     aPanelY, &aCommitted)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+void
+PuppetWidget::SetPluginFocused(bool& aFocused)
+{
+  if (mTabChild) {
+    mTabChild->SendSetPluginFocused(aFocused);
+  }
+}
+
+void
+PuppetWidget::DefaultProcOfPluginEvent(const WidgetPluginEvent& aEvent)
+{
+  if (!mTabChild) {
+    return;
+  }
+  mTabChild->SendDefaultProcOfPluginEvent(aEvent);
+}
+
+NS_IMETHODIMP_(void)
+PuppetWidget::SetInputContext(const InputContext& aContext,
+                              const InputContextAction& aAction)
+{
+  mInputContext = aContext;
+  // Any widget instances cannot cache IME open state because IME open state
+  // can be changed by user but native IME may not notify us of changing the
+  // open state on some platforms.
+  mInputContext.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED;
+
+#ifndef MOZ_CROSS_PROCESS_IME
+  return;
+#endif
+
+  if (!mTabChild) {
+    return;
+  }
+  mTabChild->SendSetInputContext(
+    static_cast<int32_t>(aContext.mIMEState.mEnabled),
+    static_cast<int32_t>(aContext.mIMEState.mOpen),
+    aContext.mHTMLInputType,
+    aContext.mHTMLInputInputmode,
+    aContext.mActionHint,
+    static_cast<int32_t>(aAction.mCause),
+    static_cast<int32_t>(aAction.mFocusChange));
+}
+
+NS_IMETHODIMP_(InputContext)
+PuppetWidget::GetInputContext()
+{
+#ifndef MOZ_CROSS_PROCESS_IME
+  return InputContext();
+#endif
+
+  // XXX Currently, we don't support retrieving IME open state from child
+  //     process.
+
+  // When this widget caches input context and currently managed by
+  // IMEStateManager, the cache is valid.  Only in this case, we can
+  // avoid to use synchronous IPC.
+  if (mInputContext.mIMEState.mEnabled != IMEState::UNKNOWN &&
+      IMEStateManager::GetWidgetForActiveInputContext() == this) {
+    return mInputContext;
+  }
+
+  NS_WARNING("PuppetWidget::GetInputContext() needs to retrieve it with IPC");
+
+  // Don't cache InputContext here because this process isn't managing IME
+  // state of the chrome widget.  So, we cannot modify mInputContext when
+  // chrome widget is set to new context.
+  InputContext context;
+  if (mTabChild) {
+    int32_t enabled, open;
+    mTabChild->SendGetInputContext(&enabled, &open);
+    context.mIMEState.mEnabled = static_cast<IMEState::Enabled>(enabled);
+    context.mIMEState.mOpen = static_cast<IMEState::Open>(open);
+  }
+  return context;
+}
+
+NS_IMETHODIMP_(NativeIMEContext)
+PuppetWidget::GetNativeIMEContext()
+{
+  return mNativeIMEContext;
+}
+
+nsresult
+PuppetWidget::NotifyIMEOfFocusChange(const IMENotification& aIMENotification)
+{
+#ifndef MOZ_CROSS_PROCESS_IME
+  return NS_OK;
+#endif
+
+  if (!mTabChild)
+    return NS_ERROR_FAILURE;
+
+  bool gotFocus = aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS;
+  if (gotFocus) {
+    if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN) {
+      // When IME gets focus, we should initalize all information of the
+      // content.
+      if (NS_WARN_IF(!mContentCache.CacheAll(this, &aIMENotification))) {
+        return NS_ERROR_FAILURE;
+      }
+    } else {
+      // However, if a plugin has focus, only the editor rect information is
+      // available.
+      if (NS_WARN_IF(!mContentCache.CacheEditorRect(this, &aIMENotification))) {
+        return NS_ERROR_FAILURE;
+      }
+    }
+  } else {
+    // When IME loses focus, we don't need to store anything.
+    mContentCache.Clear();
+  }
+
+  mIMEPreferenceOfParent = nsIMEUpdatePreference();
+  if (!mTabChild->SendNotifyIMEFocus(mContentCache, aIMENotification,
+                                     &mIMEPreferenceOfParent)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::NotifyIMEOfCompositionUpdate(
+                const IMENotification& aIMENotification)
+{
+#ifndef MOZ_CROSS_PROCESS_IME
+  return NS_OK;
+#endif
+
+  NS_ENSURE_TRUE(mTabChild, NS_ERROR_FAILURE);
+
+  if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN &&
+      NS_WARN_IF(!mContentCache.CacheSelection(this, &aIMENotification))) {
+    return NS_ERROR_FAILURE;
+  }
+  mTabChild->SendNotifyIMECompositionUpdate(mContentCache, aIMENotification);
+  return NS_OK;
+}
+
+nsIMEUpdatePreference
+PuppetWidget::GetIMEUpdatePreference()
+{
+#ifdef MOZ_CROSS_PROCESS_IME
+  // e10s requires IME content cache in in the TabParent for handling query
+  // content event only with the parent process.  Therefore, this process
+  // needs to receive a lot of information from the focused editor to sent
+  // the latest content to the parent process.
+  if (mInputContext.mIMEState.mEnabled == IMEState::PLUGIN) {
+    // But if a plugin has focus, we cannot receive text nor selection change
+    // in the plugin.  Therefore, PuppetWidget needs to receive only position
+    // change event for updating the editor rect cache.
+    return nsIMEUpdatePreference(mIMEPreferenceOfParent.mWantUpdates |
+                                 nsIMEUpdatePreference::NOTIFY_POSITION_CHANGE);
+  }
+  return nsIMEUpdatePreference(mIMEPreferenceOfParent.mWantUpdates |
+                               nsIMEUpdatePreference::NOTIFY_TEXT_CHANGE |
+                               nsIMEUpdatePreference::NOTIFY_POSITION_CHANGE );
+#else
+  // B2G doesn't handle IME as widget-level.
+  return nsIMEUpdatePreference();
+#endif
+}
+
+nsresult
+PuppetWidget::NotifyIMEOfTextChange(const IMENotification& aIMENotification)
+{
+  MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_TEXT_CHANGE,
+             "Passed wrong notification");
+
+#ifndef MOZ_CROSS_PROCESS_IME
+  return NS_OK;
+#endif
+
+  if (!mTabChild)
+    return NS_ERROR_FAILURE;
+
+  // While a plugin has focus, text change notification shouldn't be available.
+  if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // FYI: text change notification is the first notification after
+  //      a user operation changes the content.  So, we need to modify
+  //      the cache as far as possible here.
+
+  if (NS_WARN_IF(!mContentCache.CacheText(this, &aIMENotification))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // TabParent doesn't this this to cache.  we don't send the notification
+  // if parent process doesn't request NOTIFY_TEXT_CHANGE.
+  if (mIMEPreferenceOfParent.WantTextChange()) {
+    mTabChild->SendNotifyIMETextChange(mContentCache, aIMENotification);
+  } else {
+    mTabChild->SendUpdateContentCache(mContentCache);
+  }
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::NotifyIMEOfSelectionChange(
+                const IMENotification& aIMENotification)
+{
+  MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_SELECTION_CHANGE,
+             "Passed wrong notification");
+
+#ifndef MOZ_CROSS_PROCESS_IME
+  return NS_OK;
+#endif
+
+  if (!mTabChild)
+    return NS_ERROR_FAILURE;
+
+  // While a plugin has focus, selection change notification shouldn't be
+  // available.
+  if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Note that selection change must be notified after text change if it occurs.
+  // Therefore, we don't need to query text content again here.
+  mContentCache.SetSelection(
+    this, 
+    aIMENotification.mSelectionChangeData.mOffset,
+    aIMENotification.mSelectionChangeData.Length(),
+    aIMENotification.mSelectionChangeData.mReversed,
+    aIMENotification.mSelectionChangeData.GetWritingMode());
+
+  mTabChild->SendNotifyIMESelection(mContentCache, aIMENotification);
+
+  return NS_OK;
+}
+
+nsresult
+PuppetWidget::NotifyIMEOfMouseButtonEvent(
+                const IMENotification& aIMENotification)
+{
+  if (!mTabChild) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // While a plugin has focus, mouse button event notification shouldn't be
+  // available.
+  if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
+    return NS_ERROR_FAILURE;
+  }
+
+
+  bool consumedByIME = false;
+  if (!mTabChild->SendNotifyIMEMouseButtonEvent(aIMENotification,
+                                                &consumedByIME)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return consumedByIME ? NS_SUCCESS_EVENT_CONSUMED : NS_OK;
+}
+
+nsresult
+PuppetWidget::NotifyIMEOfPositionChange(const IMENotification& aIMENotification)
+{
+#ifndef MOZ_CROSS_PROCESS_IME
+  return NS_OK;
+#endif
+  if (NS_WARN_IF(!mTabChild)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (NS_WARN_IF(!mContentCache.CacheEditorRect(this, &aIMENotification))) {
+    return NS_ERROR_FAILURE;
+  }
+  // While a plugin has focus, selection range isn't available.  So, we don't
+  // need to cache it at that time.
+  if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN &&
+      NS_WARN_IF(!mContentCache.CacheSelection(this, &aIMENotification))) {
+    return NS_ERROR_FAILURE;
+  }
+  if (mIMEPreferenceOfParent.WantPositionChanged()) {
+    mTabChild->SendNotifyIMEPositionChange(mContentCache, aIMENotification);
+  } else {
+    mTabChild->SendUpdateContentCache(mContentCache);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetWidget::SetCursor(nsCursor aCursor)
+{
+  // Don't cache on windows, Windowless flash breaks this via async cursor updates.
+#if !defined(XP_WIN)
+  if (mCursor == aCursor && !mCustomCursor && !mUpdateCursor) {
+    return NS_OK;
+  }
+#endif
+
+  mCustomCursor = nullptr;
+
+  if (mTabChild &&
+      !mTabChild->SendSetCursor(aCursor, mUpdateCursor)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mCursor = aCursor;
+  mUpdateCursor = false;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetWidget::SetCursor(imgIContainer* aCursor,
+                        uint32_t aHotspotX, uint32_t aHotspotY)
+{
+  if (!aCursor || !mTabChild) {
+    return NS_OK;
+  }
+
+#if !defined(XP_WIN)
+  if (mCustomCursor == aCursor &&
+      mCursorHotspotX == aHotspotX &&
+      mCursorHotspotY == aHotspotY &&
+      !mUpdateCursor) {
+    return NS_OK;
+  }
+#endif
+
+  RefPtr<mozilla::gfx::SourceSurface> surface =
+    aCursor->GetFrame(imgIContainer::FRAME_CURRENT,
+                      imgIContainer::FLAG_SYNC_DECODE);
+  if (!surface) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<mozilla::gfx::DataSourceSurface> dataSurface =
+    surface->GetDataSurface();
+  if (!dataSurface) {
+    return NS_ERROR_FAILURE;
+  }
+
+  size_t length;
+  int32_t stride;
+  mozilla::UniquePtr<char[]> surfaceData =
+    nsContentUtils::GetSurfaceData(WrapNotNull(dataSurface), &length, &stride);
+
+  nsDependentCString cursorData(surfaceData.get(), length);
+  mozilla::gfx::IntSize size = dataSurface->GetSize();
+  if (!mTabChild->SendSetCustomCursor(cursorData, size.width, size.height, stride,
+                                      static_cast<uint8_t>(dataSurface->GetFormat()),
+                                      aHotspotX, aHotspotY, mUpdateCursor)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mCursor = nsCursor(-1);
+  mCustomCursor = aCursor;
+  mCursorHotspotX = aHotspotX;
+  mCursorHotspotY = aHotspotY;
+  mUpdateCursor = false;
+
+  return NS_OK;
+}
+
+void
+PuppetWidget::ClearCachedCursor()
+{
+  nsBaseWidget::ClearCachedCursor();
+  mCustomCursor = nullptr;
+}
+
+nsresult
+PuppetWidget::Paint()
+{
+  MOZ_ASSERT(!mDirtyRegion.IsEmpty(), "paint event logic messed up");
+
+  if (!GetCurrentWidgetListener())
+    return NS_OK;
+
+  LayoutDeviceIntRegion region = mDirtyRegion;
+
+  // reset repaint tracking
+  mDirtyRegion.SetEmpty();
+  mPaintTask.Revoke();
+
+  RefPtr<PuppetWidget> strongThis(this);
+
+  GetCurrentWidgetListener()->WillPaintWindow(this);
+
+  if (GetCurrentWidgetListener()) {
+#ifdef DEBUG
+    debug_DumpPaintEvent(stderr, this, region.ToUnknownRegion(),
+                         "PuppetWidget", 0);
+#endif
+
+    if (mozilla::layers::LayersBackend::LAYERS_CLIENT == mLayerManager->GetBackendType()) {
+      // Do nothing, the compositor will handle drawing
+      if (mTabChild) {
+        mTabChild->NotifyPainted();
+      }
+    } else if (mozilla::layers::LayersBackend::LAYERS_BASIC == mLayerManager->GetBackendType()) {
+      RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(mDrawTarget);
+      if (!ctx) {
+        gfxDevCrash(LogReason::InvalidContext) << "PuppetWidget context problem " << gfx::hexa(mDrawTarget);
+        return NS_ERROR_FAILURE;
+      }
+      ctx->Rectangle(gfxRect(0,0,0,0));
+      ctx->Clip();
+      AutoLayerManagerSetup setupLayerManager(this, ctx,
+                                              BufferMode::BUFFER_NONE);
+      GetCurrentWidgetListener()->PaintWindow(this, region);
+      if (mTabChild) {
+        mTabChild->NotifyPainted();
+      }
+    }
+  }
+
+  if (GetCurrentWidgetListener()) {
+    GetCurrentWidgetListener()->DidPaintWindow();
+  }
+
+  return NS_OK;
+}
+
+void
+PuppetWidget::SetChild(PuppetWidget* aChild)
+{
+  MOZ_ASSERT(this != aChild, "can't parent a widget to itself");
+  MOZ_ASSERT(!aChild->mChild,
+             "fake widget 'hierarchy' only expected to have one level");
+
+  mChild = aChild;
+}
+
+NS_IMETHODIMP
+PuppetWidget::PaintTask::Run()
+{
+  if (mWidget) {
+    mWidget->Paint();
+  }
+  return NS_OK;
+}
+
+void
+PuppetWidget::PaintNowIfNeeded()
+{
+  if (IsVisible() && mPaintTask.IsPending()) {
+    Paint();
+  }
+}
+
+NS_IMPL_ISUPPORTS(PuppetWidget::MemoryPressureObserver, nsIObserver)
+
+NS_IMETHODIMP
+PuppetWidget::MemoryPressureObserver::Observe(nsISupports* aSubject,
+                                              const char* aTopic,
+                                              const char16_t* aData)
+{
+  if (!mWidget) {
+    return NS_OK;
+  }
+
+  if (strcmp("memory-pressure", aTopic) == 0 &&
+      !NS_LITERAL_STRING("lowering-priority").Equals(aData)) {
+    if (!mWidget->mVisible && mWidget->mLayerManager &&
+        XRE_IsContentProcess()) {
+      mWidget->mLayerManager->ClearCachedResources();
+    }
+  }
+  return NS_OK;
+}
+
+void
+PuppetWidget::MemoryPressureObserver::Remove()
+{
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->RemoveObserver(this, "memory-pressure");
+  }
+  mWidget = nullptr;
+}
+
+bool
+PuppetWidget::NeedsPaint()
+{
+  // e10s popups are handled by the parent process, so never should be painted here
+  if (XRE_IsContentProcess() &&
+      Preferences::GetBool("browser.tabs.remote.desktopbehavior", false) &&
+      mWindowType == eWindowType_popup) {
+    NS_WARNING("Trying to paint an e10s popup in the child process!");
+    return false;
+  }
+
+  return mVisible;
+}
+
+float
+PuppetWidget::GetDPI()
+{
+  if (mDPI < 0) {
+    if (mTabChild) {
+      mTabChild->GetDPI(&mDPI);
+    } else {
+      mDPI = 96.0;
+    }
+  }
+
+  return mDPI;
+}
+
+double
+PuppetWidget::GetDefaultScaleInternal()
+{
+  if (mDefaultScale < 0) {
+    if (mTabChild) {
+      mTabChild->GetDefaultScale(&mDefaultScale);
+    } else {
+      mDefaultScale = 1;
+    }
+  }
+
+  return mDefaultScale;
+}
+
+int32_t
+PuppetWidget::RoundsWidgetCoordinatesTo()
+{
+  if (mRounding < 0) {
+    if (mTabChild) {
+      mTabChild->GetWidgetRounding(&mRounding);
+    } else {
+      mRounding = 1;
+    }
+  }
+
+  return mRounding;
+}
+
+void*
+PuppetWidget::GetNativeData(uint32_t aDataType)
+{
+  switch (aDataType) {
+  case NS_NATIVE_SHAREABLE_WINDOW: {
+    MOZ_ASSERT(mTabChild, "Need TabChild to get the nativeWindow from!");
+    mozilla::WindowsHandle nativeData = 0;
+    if (mTabChild) {
+      mTabChild->SendGetWidgetNativeData(&nativeData);
+    }
+    return (void*)nativeData;
+  }
+  case NS_NATIVE_WINDOW:
+  case NS_NATIVE_WIDGET:
+  case NS_NATIVE_DISPLAY:
+    // These types are ignored (see bug 1183828, bug 1240891).
+    break;
+  case NS_RAW_NATIVE_IME_CONTEXT:
+    MOZ_CRASH("You need to call GetNativeIMEContext() instead");
+  case NS_NATIVE_PLUGIN_PORT:
+  case NS_NATIVE_GRAPHIC:
+  case NS_NATIVE_SHELLWIDGET:
+  default:
+    NS_WARNING("nsWindow::GetNativeData called with bad value");
+    break;
+  }
+  return nullptr;
+}
+
+#if defined(XP_WIN)
+void
+PuppetWidget::SetNativeData(uint32_t aDataType, uintptr_t aVal)
+{
+  switch (aDataType) {
+  case NS_NATIVE_CHILD_OF_SHAREABLE_WINDOW:
+    MOZ_ASSERT(mTabChild, "Need TabChild to send the message.");
+    if (mTabChild) {
+      mTabChild->SendSetNativeChildOfShareableWindow(aVal);
+    }
+    break;
+  default:
+    NS_WARNING("SetNativeData called with unsupported data type.");
+  }
+}
+#endif
+
+nsIntPoint
+PuppetWidget::GetChromeDimensions()
+{
+  if (!GetOwningTabChild()) {
+    NS_WARNING("PuppetWidget without Tab does not have chrome information.");
+    return nsIntPoint();
+  }
+  return GetOwningTabChild()->GetChromeDisplacement().ToUnknownPoint();
+}
+
+nsIntPoint
+PuppetWidget::GetWindowPosition()
+{
+  if (!GetOwningTabChild()) {
+    return nsIntPoint();
+  }
+
+  int32_t winX, winY, winW, winH;
+  NS_ENSURE_SUCCESS(GetOwningTabChild()->GetDimensions(0, &winX, &winY, &winW, &winH), nsIntPoint());
+  return nsIntPoint(winX, winY) + GetOwningTabChild()->GetClientOffset().ToUnknownPoint();
+}
+
+LayoutDeviceIntRect
+PuppetWidget::GetScreenBounds()
+{
+  return LayoutDeviceIntRect(WidgetToScreenOffset(), mBounds.Size());
+}
+
+uint32_t PuppetWidget::GetMaxTouchPoints() const
+{
+  static uint32_t sTouchPoints = 0;
+  static bool sIsInitialized = false;
+  if (sIsInitialized) {
+    return sTouchPoints;
+  }
+  if (mTabChild) {
+    mTabChild->GetMaxTouchPoints(&sTouchPoints);
+    sIsInitialized = true;
+  }
+  return sTouchPoints;
+}
+
+void
+PuppetWidget::StartAsyncScrollbarDrag(const AsyncDragMetrics& aDragMetrics)
+{
+  mTabChild->StartScrollbarDrag(aDragMetrics);
+}
+
+PuppetScreen::PuppetScreen(void *nativeScreen)
+{
+}
+
+PuppetScreen::~PuppetScreen()
+{
+}
+
+static ScreenConfiguration
+ScreenConfig()
+{
+  ScreenConfiguration config;
+  hal::GetCurrentScreenConfiguration(&config);
+  return config;
+}
+
+nsIntSize
+PuppetWidget::GetScreenDimensions()
+{
+  nsIntRect r = ScreenConfig().rect();
+  return nsIntSize(r.width, r.height);
+}
+
+NS_IMETHODIMP
+PuppetScreen::GetId(uint32_t *outId)
+{
+  *outId = 1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetScreen::GetRect(int32_t *outLeft,  int32_t *outTop,
+                      int32_t *outWidth, int32_t *outHeight)
+{
+  nsIntRect r = ScreenConfig().rect();
+  *outLeft = r.x;
+  *outTop = r.y;
+  *outWidth = r.width;
+  *outHeight = r.height;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetScreen::GetAvailRect(int32_t *outLeft,  int32_t *outTop,
+                           int32_t *outWidth, int32_t *outHeight)
+{
+  return GetRect(outLeft, outTop, outWidth, outHeight);
+}
+
+NS_IMETHODIMP
+PuppetScreen::GetPixelDepth(int32_t *aPixelDepth)
+{
+  *aPixelDepth = ScreenConfig().pixelDepth();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetScreen::GetColorDepth(int32_t *aColorDepth)
+{
+  *aColorDepth = ScreenConfig().colorDepth();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetScreen::GetRotation(uint32_t* aRotation)
+{
+  NS_WARNING("Attempt to get screen rotation through nsIScreen::GetRotation().  Nothing should know or care this in sandboxed contexts.  If you want *orientation*, use hal.");
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+PuppetScreen::SetRotation(uint32_t aRotation)
+{
+  NS_WARNING("Attempt to set screen rotation through nsIScreen::GetRotation().  Nothing should know or care this in sandboxed contexts.  If you want *orientation*, use hal.");
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMPL_ISUPPORTS(PuppetScreenManager, nsIScreenManager)
+
+PuppetScreenManager::PuppetScreenManager()
+{
+    mOneScreen = new PuppetScreen(nullptr);
+}
+
+PuppetScreenManager::~PuppetScreenManager()
+{
+}
+
+NS_IMETHODIMP
+PuppetScreenManager::ScreenForId(uint32_t aId,
+                                 nsIScreen** outScreen)
+{
+  NS_IF_ADDREF(*outScreen = mOneScreen.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetScreenManager::GetPrimaryScreen(nsIScreen** outScreen)
+{
+  NS_IF_ADDREF(*outScreen = mOneScreen.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetScreenManager::ScreenForRect(int32_t inLeft,
+                                   int32_t inTop,
+                                   int32_t inWidth,
+                                   int32_t inHeight,
+                                   nsIScreen** outScreen)
+{
+  return GetPrimaryScreen(outScreen);
+}
+
+NS_IMETHODIMP
+PuppetScreenManager::ScreenForNativeWidget(void* aWidget,
+                                           nsIScreen** outScreen)
+{
+  return GetPrimaryScreen(outScreen);
+}
+
+NS_IMETHODIMP
+PuppetScreenManager::GetNumberOfScreens(uint32_t* aNumberOfScreens)
+{
+  *aNumberOfScreens = 1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PuppetScreenManager::GetSystemDefaultScale(float *aDefaultScale)
+{
+  *aDefaultScale = 1.0f;
+  return NS_OK;
+}
+
+nsIWidgetListener*
+PuppetWidget::GetCurrentWidgetListener()
+{
+  if (!mPreviouslyAttachedWidgetListener ||
+      !mAttachedWidgetListener) {
+    return mAttachedWidgetListener;
+  }
+
+  if (mAttachedWidgetListener->GetView()->IsPrimaryFramePaintSuppressed()) {
+    return mPreviouslyAttachedWidgetListener;
+  }
+
+  return mAttachedWidgetListener;
+}
+
+void
+PuppetWidget::SetCandidateWindowForPlugin(
+                const CandidateWindowPosition& aPosition)
+{
+  if (!mTabChild) {
+    return;
+  }
+
+  mTabChild->SendSetCandidateWindowForPlugin(aPosition);
+}
+
+void
+PuppetWidget::ZoomToRect(const uint32_t& aPresShellId,
+                         const FrameMetrics::ViewID& aViewId,
+                         const CSSRect& aRect,
+                         const uint32_t& aFlags)
+{
+  if (!mTabChild) {
+    return;
+  }
+
+  mTabChild->ZoomToRect(aPresShellId, aViewId, aRect, aFlags);
+}
+
+void
+PuppetWidget::LookUpDictionary(
+                const nsAString& aText,
+                const nsTArray<mozilla::FontRange>& aFontRangeArray,
+                const bool aIsVertical,
+                const LayoutDeviceIntPoint& aPoint)
+{
+  if (!mTabChild) {
+    return;
+  }
+
+  mTabChild->SendLookUpDictionary(nsString(aText), aFontRangeArray, aIsVertical, aPoint);
+}
+
+bool
+PuppetWidget::HasPendingInputEvent()
+{
+  if (!mTabChild) {
+    return false;
+  }
+
+  bool ret = false;
+
+  mTabChild->GetIPCChannel()->PeekMessages(
+    [&ret](const IPC::Message& aMsg) -> bool {
+      if ((aMsg.type() & mozilla::dom::PBrowser::PBrowserStart)
+          == mozilla::dom::PBrowser::PBrowserStart) {
+        switch (aMsg.type()) {
+          case mozilla::dom::PBrowser::Msg_RealMouseMoveEvent__ID:
+          case mozilla::dom::PBrowser::Msg_SynthMouseMoveEvent__ID:
+          case mozilla::dom::PBrowser::Msg_RealMouseButtonEvent__ID:
+          case mozilla::dom::PBrowser::Msg_RealKeyEvent__ID:
+          case mozilla::dom::PBrowser::Msg_MouseWheelEvent__ID:
+          case mozilla::dom::PBrowser::Msg_RealTouchEvent__ID:
+          case mozilla::dom::PBrowser::Msg_RealTouchMoveEvent__ID:
+          case mozilla::dom::PBrowser::Msg_RealDragEvent__ID:
+          case mozilla::dom::PBrowser::Msg_UpdateDimensions__ID:
+          case mozilla::dom::PBrowser::Msg_MouseEvent__ID:
+          case mozilla::dom::PBrowser::Msg_KeyEvent__ID:
+            ret = true;
+            return false;  // Stop peeking.
+        }
+      }
+      return true;
+    }
+  );
+
+  return ret;
+}
+
+void
+PuppetWidget::HandledWindowedPluginKeyEvent(
+                const NativeEventData& aKeyEventData,
+                bool aIsConsumed)
+{
+  if (NS_WARN_IF(mKeyEventInPluginCallbacks.IsEmpty())) {
+    return;
+  }
+  nsCOMPtr<nsIKeyEventInPluginCallback> callback =
+    mKeyEventInPluginCallbacks[0];
+  MOZ_ASSERT(callback);
+  mKeyEventInPluginCallbacks.RemoveElementAt(0);
+  callback->HandledWindowedPluginKeyEvent(aKeyEventData, aIsConsumed);
+}
+
+nsresult
+PuppetWidget::OnWindowedPluginKeyEvent(const NativeEventData& aKeyEventData,
+                                       nsIKeyEventInPluginCallback* aCallback)
+{
+  if (NS_WARN_IF(!mTabChild)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  if (NS_WARN_IF(!mTabChild->SendOnWindowedPluginKeyEvent(aKeyEventData))) {
+    return NS_ERROR_FAILURE;
+  }
+  mKeyEventInPluginCallbacks.AppendElement(aCallback);
+  return NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY;
+}
+
+} // namespace widget
+} // namespace mozilla