widget/PuppetWidget.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=8 et :
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #include "base/basictypes.h"
   9
  10 #include "ClientLayerManager.h"
  11 #include "gfxPlatform.h"
  12 #include "mozilla/dom/TabChild.h"
  13 #include "mozilla/dom/TabGroup.h"
  14 #include "mozilla/gfx/gfxVars.h"
  15 #include "mozilla/Hal.h"
  16 #include "mozilla/IMEStateManager.h"
  17 #include "mozilla/layers/APZChild.h"
  18 #include "mozilla/layers/PLayerTransactionChild.h"
  19 #include "mozilla/layers/WebRenderLayerManager.h"
  20 #include "mozilla/Preferences.h"
  21 #include "mozilla/TextComposition.h"
  22 #include "mozilla/TextEventDispatcher.h"
  23 #include "mozilla/TextEvents.h"
  24 #include "mozilla/Unused.h"
  25 #include "BasicLayers.h"
  26 #include "PuppetWidget.h"
  27 #include "nsContentUtils.h"
  28 #include "nsIWidgetListener.h"
  29 #include "imgIContainer.h"
  30 #include "nsView.h"
  31 #include "nsPrintfCString.h"
  32
  33 using namespace mozilla;
  34 using namespace mozilla::dom;
  35 using namespace mozilla::hal;
  36 using namespace mozilla::gfx;
  37 using namespace mozilla::layers;
  38 using namespace mozilla::widget;
  39
  40 static void
  41 InvalidateRegion(nsIWidget* aWidget, const LayoutDeviceIntRegion& aRegion)
  42 {
  43   for (auto iter = aRegion.RectIter(); !iter.Done(); iter.Next()) {
  44     aWidget->Invalidate(iter.Get());
  45   }
  46 }
  47
  48 /*static*/ already_AddRefed<nsIWidget>
  49 nsIWidget::CreatePuppetWidget(TabChild* aTabChild)
  50 {
  51   MOZ_ASSERT(!aTabChild || nsIWidget::UsePuppetWidgets(),
  52              "PuppetWidgets not allowed in this configuration");
  53
  54   nsCOMPtr<nsIWidget> widget = new PuppetWidget(aTabChild);
  55   return widget.forget();
  56 }
  57
  58 namespace mozilla {
  59 namespace widget {
  60
  61 static bool
  62 IsPopup(const nsWidgetInitData* aInitData)
  63 {
  64   return aInitData && aInitData->mWindowType == eWindowType_popup;
  65 }
  66
  67 static bool
  68 MightNeedIMEFocus(const nsWidgetInitData* aInitData)
  69 {
  70   // In the puppet-widget world, popup widgets are just dummies and
  71   // shouldn't try to mess with IME state.
  72 #ifdef MOZ_CROSS_PROCESS_IME
  73   return !IsPopup(aInitData);
  74 #else
  75   return false;
  76 #endif
  77 }
  78
  79 // Arbitrary, fungible.
  80 const size_t PuppetWidget::kMaxDimension = 4000;
  81
  82 static bool gRemoteDesktopBehaviorEnabled = false;
  83 static bool gRemoteDesktopBehaviorInitialized = false;
  84
  85 NS_IMPL_ISUPPORTS_INHERITED(PuppetWidget, nsBaseWidget
  86                                         , TextEventDispatcherListener)
  87
  88 PuppetWidget::PuppetWidget(TabChild* aTabChild)
  89   : mTabChild(aTabChild)
  90   , mMemoryPressureObserver(nullptr)
  91   , mDPI(-1)
  92   , mRounding(1)
  93   , mDefaultScale(-1)
  94   , mCursorHotspotX(0)
  95   , mCursorHotspotY(0)
  96   , mEnabled(false)
  97   , mVisible(false)
  98   , mNeedIMEStateInit(false)
  99   , mIgnoreCompositionEvents(false)
 100 {
 101   // Setting 'Unknown' means "not yet cached".
 102   mInputContext.mIMEState.mEnabled = IMEState::UNKNOWN;
 103
 104   if (!gRemoteDesktopBehaviorInitialized) {
 105     Preferences::AddBoolVarCache(&gRemoteDesktopBehaviorEnabled, "browser.tabs.remote.desktopbehavior", false);
 106     gRemoteDesktopBehaviorInitialized = true;
 107   }
 108 }
 109
 110 PuppetWidget::~PuppetWidget()
 111 {
 112   Destroy();
 113 }
 114
 115 void
 116 PuppetWidget::InfallibleCreate(nsIWidget* aParent,
 117                                nsNativeWidget aNativeParent,
 118                                const LayoutDeviceIntRect& aRect,
 119                                nsWidgetInitData* aInitData)
 120 {
 121   MOZ_ASSERT(!aNativeParent, "got a non-Puppet native parent");
 122
 123   BaseCreate(nullptr, aInitData);
 124
 125   mBounds = aRect;
 126   mEnabled = true;
 127   mVisible = true;
 128
 129   mDrawTarget = gfxPlatform::GetPlatform()->
 130     CreateOffscreenContentDrawTarget(IntSize(1, 1), SurfaceFormat::B8G8R8A8);
 131
 132   mNeedIMEStateInit = MightNeedIMEFocus(aInitData);
 133
 134   PuppetWidget* parent = static_cast<PuppetWidget*>(aParent);
 135   if (parent) {
 136     parent->SetChild(this);
 137     mLayerManager = parent->GetLayerManager();
 138   }
 139   else {
 140     Resize(mBounds.X(), mBounds.Y(), mBounds.Width(), mBounds.Height(), false);
 141   }
 142   mMemoryPressureObserver = MemoryPressureObserver::Create(this);
 143 }
 144
 145 nsresult
 146 PuppetWidget::Create(nsIWidget* aParent,
 147                      nsNativeWidget aNativeParent,
 148                      const LayoutDeviceIntRect& aRect,
 149                      nsWidgetInitData* aInitData)
 150 {
 151   InfallibleCreate(aParent, aNativeParent, aRect, aInitData);
 152   return NS_OK;
 153 }
 154
 155 void
 156 PuppetWidget::InitIMEState()
 157 {
 158   MOZ_ASSERT(mTabChild);
 159   if (mNeedIMEStateInit) {
 160     mContentCache.Clear();
 161     mTabChild->SendUpdateContentCache(mContentCache);
 162     mIMENotificationRequestsOfParent = IMENotificationRequests();
 163     mNeedIMEStateInit = false;
 164   }
 165 }
 166
 167 already_AddRefed<nsIWidget>
 168 PuppetWidget::CreateChild(const LayoutDeviceIntRect& aRect,
 169                           nsWidgetInitData* aInitData,
 170                           bool aForceUseIWidgetParent)
 171 {
 172   bool isPopup = IsPopup(aInitData);
 173   nsCOMPtr<nsIWidget> widget = nsIWidget::CreatePuppetWidget(mTabChild);
 174   return ((widget &&
 175            NS_SUCCEEDED(widget->Create(isPopup ? nullptr: this, nullptr, aRect,
 176                                        aInitData))) ?
 177           widget.forget() : nullptr);
 178 }
 179
 180 void
 181 PuppetWidget::Destroy()
 182 {
 183   if (mOnDestroyCalled) {
 184     return;
 185   }
 186   mOnDestroyCalled = true;
 187
 188   Base::OnDestroy();
 189   Base::Destroy();
 190   mPaintTask.Revoke();
 191   if (mMemoryPressureObserver) {
 192     mMemoryPressureObserver->Unregister();
 193     mMemoryPressureObserver = nullptr;
 194   }
 195   mChild = nullptr;
 196   if (mLayerManager) {
 197     mLayerManager->Destroy();
 198   }
 199   mLayerManager = nullptr;
 200   mTabChild = nullptr;
 201 }
 202
 203 void
 204 PuppetWidget::Show(bool aState)
 205 {
 206   NS_ASSERTION(mEnabled,
 207                "does it make sense to Show()/Hide() a disabled widget?");
 208
 209   bool wasVisible = mVisible;
 210   mVisible = aState;
 211
 212   if (mChild) {
 213     mChild->mVisible = aState;
 214   }
 215
 216   if (!wasVisible && mVisible) {
 217     // The previously attached widget listener is handy if
 218     // we're transitioning from page to page without dropping
 219     // layers (since we'll continue to show the old layers
 220     // associated with that old widget listener). If the
 221     // PuppetWidget was hidden, those layers are dropped,
 222     // so the previously attached widget listener is really
 223     // of no use anymore (and is actually actively harmful - see
 224     // bug 1323586).
 225     mPreviouslyAttachedWidgetListener = nullptr;
 226     Resize(mBounds.Width(), mBounds.Height(), false);
 227     Invalidate(mBounds);
 228   }
 229 }
 230
 231 void
 232 PuppetWidget::Resize(double aWidth,
 233                      double aHeight,
 234                      bool   aRepaint)
 235 {
 236   LayoutDeviceIntRect oldBounds = mBounds;
 237   mBounds.SizeTo(LayoutDeviceIntSize(NSToIntRound(aWidth),
 238                                      NSToIntRound(aHeight)));
 239
 240   if (mChild) {
 241     mChild->Resize(aWidth, aHeight, aRepaint);
 242     return;
 243   }
 244
 245   // XXX: roc says that |aRepaint| dictates whether or not to
 246   // invalidate the expanded area
 247   if (oldBounds.Size() < mBounds.Size() && aRepaint) {
 248     LayoutDeviceIntRegion dirty(mBounds);
 249     dirty.Sub(dirty, oldBounds);
 250     InvalidateRegion(this, dirty);
 251   }
 252
 253   // call WindowResized() on both the current listener, and possibly
 254   // also the previous one if we're in a state where we're drawing that one
 255   // because the current one is paint suppressed
 256   if (!oldBounds.IsEqualEdges(mBounds) && mAttachedWidgetListener) {
 257     if (GetCurrentWidgetListener() &&
 258         GetCurrentWidgetListener() != mAttachedWidgetListener) {
 259       GetCurrentWidgetListener()->WindowResized(this, mBounds.Width(), mBounds.Height());
 260     }
 261     mAttachedWidgetListener->WindowResized(this, mBounds.Width(), mBounds.Height());
 262   }
 263 }
 264
 265 nsresult
 266 PuppetWidget::ConfigureChildren(const nsTArray<Configuration>& aConfigurations)
 267 {
 268   for (uint32_t i = 0; i < aConfigurations.Length(); ++i) {
 269     const Configuration& configuration = aConfigurations[i];
 270     PuppetWidget* w = static_cast<PuppetWidget*>(configuration.mChild.get());
 271     NS_ASSERTION(w->GetParent() == this,
 272                  "Configured widget is not a child");
 273     w->SetWindowClipRegion(configuration.mClipRegion, true);
 274     LayoutDeviceIntRect bounds = w->GetBounds();
 275     if (bounds.Size() != configuration.mBounds.Size()) {
 276       w->Resize(configuration.mBounds.X(), configuration.mBounds.Y(),
 277                 configuration.mBounds.Width(), configuration.mBounds.Height(),
 278                 true);
 279     } else if (bounds.TopLeft() != configuration.mBounds.TopLeft()) {
 280       w->Move(configuration.mBounds.X(), configuration.mBounds.Y());
 281     }
 282     w->SetWindowClipRegion(configuration.mClipRegion, false);
 283   }
 284   return NS_OK;
 285 }
 286
 287 nsresult
 288 PuppetWidget::SetFocus(bool aRaise)
 289 {
 290   if (aRaise && mTabChild) {
 291     mTabChild->SendRequestFocus(true);
 292   }
 293
 294   return NS_OK;
 295 }
 296
 297 void
 298 PuppetWidget::Invalidate(const LayoutDeviceIntRect& aRect)
 299 {
 300 #ifdef DEBUG
 301   debug_DumpInvalidate(stderr, this, &aRect, "PuppetWidget", 0);
 302 #endif
 303
 304   if (mChild) {
 305     mChild->Invalidate(aRect);
 306     return;
 307   }
 308
 309   mDirtyRegion.Or(mDirtyRegion, aRect);
 310
 311   if (mTabChild && !mDirtyRegion.IsEmpty() && !mPaintTask.IsPending()) {
 312     mPaintTask = new PaintTask(this);
 313     nsCOMPtr<nsIRunnable> event(mPaintTask.get());
 314     mTabChild->TabGroup()->Dispatch(TaskCategory::Other, event.forget());
 315     return;
 316   }
 317 }
 318
 319 void
 320 PuppetWidget::InitEvent(WidgetGUIEvent& aEvent, LayoutDeviceIntPoint* aPoint)
 321 {
 322   if (nullptr == aPoint) {
 323     aEvent.mRefPoint = LayoutDeviceIntPoint(0, 0);
 324   } else {
 325     // use the point override if provided
 326     aEvent.mRefPoint = *aPoint;
 327   }
 328   aEvent.mTime = PR_Now() / 1000;
 329 }
 330
 331 nsresult
 332 PuppetWidget::DispatchEvent(WidgetGUIEvent* aEvent, nsEventStatus& aStatus)
 333 {
 334 #ifdef DEBUG
 335   debug_DumpEvent(stdout, aEvent->mWidget, aEvent, "PuppetWidget", 0);
 336 #endif
 337
 338   MOZ_ASSERT(!mChild || mChild->mWindowType == eWindowType_popup,
 339              "Unexpected event dispatch!");
 340
 341   MOZ_ASSERT(!aEvent->AsKeyboardEvent() ||
 342              aEvent->mFlags.mIsSynthesizedForTests ||
 343              aEvent->AsKeyboardEvent()->AreAllEditCommandsInitialized(),
 344     "Non-sysnthesized keyboard events should have edit commands for all types "
 345     "before dispatched");
 346
 347   if (aEvent->mClass == eCompositionEventClass) {
 348     // If we've already requested to commit/cancel the latest composition,
 349     // TextComposition for the old composition has been destroyed.  Then,
 350     // the DOM tree needs to listen to next eCompositionStart and its
 351     // following events.  So, until we meet new eCompositionStart, let's
 352     // discard all unnecessary composition events here.
 353     if (mIgnoreCompositionEvents) {
 354       if (aEvent->mMessage != eCompositionStart) {
 355         aStatus = nsEventStatus_eIgnore;
 356         return NS_OK;
 357       }
 358       // Now, we receive new eCompositionStart.  Let's restart to handle
 359       // composition in this process.
 360       mIgnoreCompositionEvents = false;
 361     }
 362     // Store the latest native IME context of parent process's widget or
 363     // TextEventDispatcher if it's in this process.
 364     WidgetCompositionEvent* compositionEvent = aEvent->AsCompositionEvent();
 365 #ifdef DEBUG
 366     if (mNativeIMEContext.IsValid() &&
 367         mNativeIMEContext != compositionEvent->mNativeIMEContext) {
 368       RefPtr<TextComposition> composition =
 369         IMEStateManager::GetTextCompositionFor(this);
 370       MOZ_ASSERT(!composition,
 371         "When there is composition caused by old native IME context, "
 372         "composition events caused by different native IME context are not "
 373         "allowed");
 374     }
 375 #endif // #ifdef DEBUG
 376     mNativeIMEContext = compositionEvent->mNativeIMEContext;
 377   }
 378
 379   // If the event is a composition event or a keyboard event, it should be
 380   // dispatched with TextEventDispatcher if we could do that with current
 381   // design.  However, we cannot do that without big changes and the behavior
 382   // is not so complicated for now.  Therefore, we should just notify it
 383   // of dispatching events and TextEventDispatcher should emulate the state
 384   // with events here.
 385   if (aEvent->mClass == eCompositionEventClass ||
 386       aEvent->mClass == eKeyboardEventClass) {
 387     TextEventDispatcher* dispatcher = GetTextEventDispatcher();
 388     // However, if the event is being dispatched by the text event dispatcher
 389     // or, there is native text event dispatcher listener, that means that
 390     // native text input event handler is in this process like on Android,
 391     // and the event is not synthesized for tests, the event is coming from
 392     // the TextEventDispatcher.  In these cases, we shouldn't notify
 393     // TextEventDispatcher of dispatching the event.
 394     if (!dispatcher->IsDispatchingEvent() &&
 395         !(mNativeTextEventDispatcherListener &&
 396           !aEvent->mFlags.mIsSynthesizedForTests)) {
 397       DebugOnly<nsresult> rv =
 398         dispatcher->BeginInputTransactionFor(aEvent, this);
 399       NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
 400         "The text event dispatcher should always succeed to start input "
 401         "transaction for the event");
 402     }
 403   }
 404
 405   aStatus = nsEventStatus_eIgnore;
 406
 407   if (GetCurrentWidgetListener()) {
 408     aStatus =
 409       GetCurrentWidgetListener()->HandleEvent(aEvent, mUseAttachedEvents);
 410   }
 411
 412   return NS_OK;
 413 }
 414
 415 nsEventStatus
 416 PuppetWidget::DispatchInputEvent(WidgetInputEvent* aEvent)
 417 {
 418   if (!AsyncPanZoomEnabled()) {
 419     nsEventStatus status = nsEventStatus_eIgnore;
 420     DispatchEvent(aEvent, status);
 421     return status;
 422   }
 423
 424   if (!mTabChild) {
 425     return nsEventStatus_eIgnore;
 426   }
 427
 428   switch (aEvent->mClass) {
 429     case eWheelEventClass:
 430       Unused <<
 431         mTabChild->SendDispatchWheelEvent(*aEvent->AsWheelEvent());
 432       break;
 433     case eMouseEventClass:
 434       Unused <<
 435         mTabChild->SendDispatchMouseEvent(*aEvent->AsMouseEvent());
 436       break;
 437     case eKeyboardEventClass:
 438       Unused <<
 439         mTabChild->SendDispatchKeyboardEvent(*aEvent->AsKeyboardEvent());
 440       break;
 441     default:
 442       MOZ_ASSERT_UNREACHABLE("unsupported event type");
 443   }
 444
 445   return nsEventStatus_eIgnore;
 446 }
 447
 448 nsresult
 449 PuppetWidget::SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
 450                                        int32_t aNativeKeyCode,
 451                                        uint32_t aModifierFlags,
 452                                        const nsAString& aCharacters,
 453                                        const nsAString& aUnmodifiedCharacters,
 454                                        nsIObserver* aObserver)
 455 {
 456   AutoObserverNotifier notifier(aObserver, "keyevent");
 457   if (!mTabChild) {
 458     return NS_ERROR_FAILURE;
 459   }
 460   mTabChild->SendSynthesizeNativeKeyEvent(aNativeKeyboardLayout, aNativeKeyCode,
 461                                           aModifierFlags, nsString(aCharacters),
 462                                           nsString(aUnmodifiedCharacters),
 463                                           notifier.SaveObserver());
 464   return NS_OK;
 465 }
 466
 467 nsresult
 468 PuppetWidget::SynthesizeNativeMouseEvent(mozilla::LayoutDeviceIntPoint aPoint,
 469                                          uint32_t aNativeMessage,
 470                                          uint32_t aModifierFlags,
 471                                          nsIObserver* aObserver)
 472 {
 473   AutoObserverNotifier notifier(aObserver, "mouseevent");
 474   if (!mTabChild) {
 475     return NS_ERROR_FAILURE;
 476   }
 477   mTabChild->SendSynthesizeNativeMouseEvent(aPoint, aNativeMessage,
 478                                             aModifierFlags,
 479                                             notifier.SaveObserver());
 480   return NS_OK;
 481 }
 482
 483 nsresult
 484 PuppetWidget::SynthesizeNativeMouseMove(mozilla::LayoutDeviceIntPoint aPoint,
 485                                         nsIObserver* aObserver)
 486 {
 487   AutoObserverNotifier notifier(aObserver, "mousemove");
 488   if (!mTabChild) {
 489     return NS_ERROR_FAILURE;
 490   }
 491   mTabChild->SendSynthesizeNativeMouseMove(aPoint, notifier.SaveObserver());
 492   return NS_OK;
 493 }
 494
 495 nsresult
 496 PuppetWidget::SynthesizeNativeMouseScrollEvent(
 497                 mozilla::LayoutDeviceIntPoint aPoint,
 498                 uint32_t aNativeMessage,
 499                 double aDeltaX,
 500                 double aDeltaY,
 501                 double aDeltaZ,
 502                 uint32_t aModifierFlags,
 503                 uint32_t aAdditionalFlags,
 504                 nsIObserver* aObserver)
 505 {
 506   AutoObserverNotifier notifier(aObserver, "mousescrollevent");
 507   if (!mTabChild) {
 508     return NS_ERROR_FAILURE;
 509   }
 510   mTabChild->SendSynthesizeNativeMouseScrollEvent(aPoint, aNativeMessage,
 511                                                   aDeltaX, aDeltaY, aDeltaZ,
 512                                                   aModifierFlags,
 513                                                   aAdditionalFlags,
 514                                                   notifier.SaveObserver());
 515   return NS_OK;
 516 }
 517
 518 nsresult
 519 PuppetWidget::SynthesizeNativeTouchPoint(uint32_t aPointerId,
 520                                          TouchPointerState aPointerState,
 521                                          LayoutDeviceIntPoint aPoint,
 522                                          double aPointerPressure,
 523                                          uint32_t aPointerOrientation,
 524                                          nsIObserver* aObserver)
 525 {
 526   AutoObserverNotifier notifier(aObserver, "touchpoint");
 527   if (!mTabChild) {
 528     return NS_ERROR_FAILURE;
 529   }
 530   mTabChild->SendSynthesizeNativeTouchPoint(aPointerId, aPointerState,
 531                                             aPoint, aPointerPressure,
 532                                             aPointerOrientation,
 533                                             notifier.SaveObserver());
 534   return NS_OK;
 535 }
 536
 537 nsresult
 538 PuppetWidget::SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint,
 539                                        bool aLongTap,
 540                                        nsIObserver* aObserver)
 541 {
 542   AutoObserverNotifier notifier(aObserver, "touchtap");
 543   if (!mTabChild) {
 544     return NS_ERROR_FAILURE;
 545   }
 546   mTabChild->SendSynthesizeNativeTouchTap(aPoint, aLongTap,
 547                                           notifier.SaveObserver());
 548   return NS_OK;
 549 }
 550
 551 nsresult
 552 PuppetWidget::ClearNativeTouchSequence(nsIObserver* aObserver)
 553 {
 554   AutoObserverNotifier notifier(aObserver, "cleartouch");
 555   if (!mTabChild) {
 556     return NS_ERROR_FAILURE;
 557   }
 558   mTabChild->SendClearNativeTouchSequence(notifier.SaveObserver());
 559   return NS_OK;
 560 }
 561
 562 void
 563 PuppetWidget::SetConfirmedTargetAPZC(
 564                 uint64_t aInputBlockId,
 565                 const nsTArray<ScrollableLayerGuid>& aTargets) const
 566 {
 567   if (mTabChild) {
 568     mTabChild->SetTargetAPZC(aInputBlockId, aTargets);
 569   }
 570 }
 571
 572 void
 573 PuppetWidget::UpdateZoomConstraints(const uint32_t& aPresShellId,
 574                                     const FrameMetrics::ViewID& aViewId,
 575                                     const Maybe<ZoomConstraints>& aConstraints)
 576 {
 577   if (mTabChild) {
 578     mTabChild->DoUpdateZoomConstraints(aPresShellId, aViewId, aConstraints);
 579   }
 580 }
 581
 582 bool
 583 PuppetWidget::AsyncPanZoomEnabled() const
 584 {
 585   return mTabChild && mTabChild->AsyncPanZoomEnabled();
 586 }
 587
 588 void
 589 PuppetWidget::GetEditCommands(NativeKeyBindingsType aType,
 590                               const WidgetKeyboardEvent& aEvent,
 591                               nsTArray<CommandInt>& aCommands)
 592 {
 593   // Validate the arguments.
 594   nsIWidget::GetEditCommands(aType, aEvent, aCommands);
 595
 596   mTabChild->RequestEditCommands(aType, aEvent, aCommands);
 597 }
 598
 599 LayerManager*
 600 PuppetWidget::GetLayerManager(PLayerTransactionChild* aShadowManager,
 601                               LayersBackend aBackendHint,
 602                               LayerManagerPersistence aPersistence)
 603 {
 604   if (!mLayerManager) {
 605     if (XRE_IsParentProcess()) {
 606       // On the parent process there is no CompositorBridgeChild which confuses
 607       // some layers code, so we use basic layers instead. Note that we create
 608       // a non-retaining layer manager since we don't care about performance.
 609       mLayerManager = new BasicLayerManager(BasicLayerManager::BLM_OFFSCREEN);
 610       return mLayerManager;
 611     }
 612
 613     // If we know for sure that the parent side of this TabChild is not
 614     // connected to the compositor, we don't want to use a "remote" layer
 615     // manager like WebRender or Client. Instead we use a Basic one which
 616     // can do drawing in this process.
 617     MOZ_ASSERT(!mTabChild || mTabChild->IsLayersConnected() != Some(true));
 618     mLayerManager = new BasicLayerManager(this);
 619   }
 620
 621   return mLayerManager;
 622 }
 623
 624 bool
 625 PuppetWidget::CreateRemoteLayerManager(const std::function<bool(LayerManager*)>& aInitializeFunc)
 626 {
 627   RefPtr<LayerManager> lm;
 628   MOZ_ASSERT(mTabChild);
 629   if (mTabChild->GetCompositorOptions().UseWebRender()) {
 630     lm = new WebRenderLayerManager(this);
 631   } else {
 632     lm = new ClientLayerManager(this);
 633   }
 634
 635   if (!aInitializeFunc(lm)) {
 636     return false;
 637   }
 638
 639   // Force the old LM to self destruct, otherwise if the reference dangles we
 640   // could fail to revoke the most recent transaction. We only want to replace
 641   // it if we successfully create its successor because a partially initialized
 642   // layer manager is worse than a fully initialized but shutdown layer manager.
 643   DestroyLayerManager();
 644   mLayerManager = lm.forget();
 645   return true;
 646 }
 647
 648 nsresult
 649 PuppetWidget::RequestIMEToCommitComposition(bool aCancel)
 650 {
 651   if (!mTabChild) {
 652     return NS_ERROR_FAILURE;
 653   }
 654
 655   MOZ_ASSERT(!Destroyed());
 656
 657   // There must not be composition which is caused by the PuppetWidget instance.
 658   if (NS_WARN_IF(!mNativeIMEContext.IsValid())) {
 659     return NS_OK;
 660   }
 661
 662   // We've already requested to commit/cancel composition.
 663   if (NS_WARN_IF(mIgnoreCompositionEvents)) {
 664 #ifdef DEBUG
 665     RefPtr<TextComposition> composition =
 666       IMEStateManager::GetTextCompositionFor(this);
 667     MOZ_ASSERT(!composition);
 668 #endif // #ifdef DEBUG
 669     return NS_OK;
 670   }
 671
 672   RefPtr<TextComposition> composition =
 673     IMEStateManager::GetTextCompositionFor(this);
 674   // This method shouldn't be called when there is no text composition instance.
 675   if (NS_WARN_IF(!composition)) {
 676     return NS_OK;
 677   }
 678
 679   MOZ_DIAGNOSTIC_ASSERT(composition->IsRequestingCommitOrCancelComposition(),
 680     "Requesting commit or cancel composition should be requested via "
 681     "TextComposition instance");
 682
 683   bool isCommitted = false;
 684   nsAutoString committedString;
 685   if (NS_WARN_IF(!mTabChild->SendRequestIMEToCommitComposition(
 686                                aCancel, &isCommitted, &committedString))) {
 687     return NS_ERROR_FAILURE;
 688   }
 689
 690   // If the composition wasn't committed synchronously, we need to wait async
 691   // composition events for destroying the TextComposition instance.
 692   if (!isCommitted) {
 693     return NS_OK;
 694   }
 695
 696   // Dispatch eCompositionCommit event.
 697   WidgetCompositionEvent compositionCommitEvent(true, eCompositionCommit, this);
 698   InitEvent(compositionCommitEvent, nullptr);
 699   compositionCommitEvent.mData = committedString;
 700   nsEventStatus status = nsEventStatus_eIgnore;
 701   DispatchEvent(&compositionCommitEvent, status);
 702
 703 #ifdef DEBUG
 704   RefPtr<TextComposition> currentComposition =
 705     IMEStateManager::GetTextCompositionFor(this);
 706   MOZ_ASSERT(!currentComposition);
 707 #endif // #ifdef DEBUG
 708
 709   // Ignore the following composition events until we receive new
 710   // eCompositionStart event.
 711   mIgnoreCompositionEvents = true;
 712
 713   Unused <<
 714     mTabChild->SendOnEventNeedingAckHandled(eCompositionCommitRequestHandled);
 715
 716   // NOTE: PuppetWidget might be destroyed already.
 717   return NS_OK;
 718 }
 719
 720 nsresult
 721 PuppetWidget::StartPluginIME(const mozilla::WidgetKeyboardEvent& aKeyboardEvent,
 722                              int32_t aPanelX, int32_t aPanelY,
 723                              nsString& aCommitted)
 724 {
 725   if (!mTabChild ||
 726       !mTabChild->SendStartPluginIME(aKeyboardEvent, aPanelX,
 727                                      aPanelY, &aCommitted)) {
 728     return NS_ERROR_FAILURE;
 729   }
 730   return NS_OK;
 731 }
 732
 733 void
 734 PuppetWidget::SetPluginFocused(bool& aFocused)
 735 {
 736   if (mTabChild) {
 737     mTabChild->SendSetPluginFocused(aFocused);
 738   }
 739 }
 740
 741 void
 742 PuppetWidget::DefaultProcOfPluginEvent(const WidgetPluginEvent& aEvent)
 743 {
 744   if (!mTabChild) {
 745     return;
 746   }
 747   mTabChild->SendDefaultProcOfPluginEvent(aEvent);
 748 }
 749
 750 // When this widget caches input context and currently managed by
 751 // IMEStateManager, the cache is valid.
 752 bool
 753 PuppetWidget::HaveValidInputContextCache() const
 754 {
 755   return (mInputContext.mIMEState.mEnabled != IMEState::UNKNOWN &&
 756           IMEStateManager::GetWidgetForActiveInputContext() == this);
 757 }
 758
 759 void
 760 PuppetWidget::SetInputContext(const InputContext& aContext,
 761                               const InputContextAction& aAction)
 762 {
 763   mInputContext = aContext;
 764   // Any widget instances cannot cache IME open state because IME open state
 765   // can be changed by user but native IME may not notify us of changing the
 766   // open state on some platforms.
 767   mInputContext.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED;
 768   if (!mTabChild) {
 769     return;
 770   }
 771   mTabChild->SendSetInputContext(aContext, aAction);
 772 }
 773
 774 InputContext
 775 PuppetWidget::GetInputContext()
 776 {
 777   // XXX Currently, we don't support retrieving IME open state from child
 778   //     process.
 779
 780   // If the cache of input context is valid, we can avoid to use synchronous
 781   // IPC.
 782   if (HaveValidInputContextCache()) {
 783     return mInputContext;
 784   }
 785
 786   NS_WARNING("PuppetWidget::GetInputContext() needs to retrieve it with IPC");
 787
 788   // Don't cache InputContext here because this process isn't managing IME
 789   // state of the chrome widget.  So, we cannot modify mInputContext when
 790   // chrome widget is set to new context.
 791   InputContext context;
 792   if (mTabChild) {
 793     mTabChild->SendGetInputContext(&context.mIMEState);
 794   }
 795   return context;
 796 }
 797
 798 NativeIMEContext
 799 PuppetWidget::GetNativeIMEContext()
 800 {
 801   return mNativeIMEContext;
 802 }
 803
 804 nsresult
 805 PuppetWidget::NotifyIMEOfFocusChange(const IMENotification& aIMENotification)
 806 {
 807   if (!mTabChild) {
 808     return NS_ERROR_FAILURE;
 809   }
 810
 811   bool gotFocus = aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS;
 812   if (gotFocus) {
 813     if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN) {
 814       // When IME gets focus, we should initalize all information of the
 815       // content.
 816       if (NS_WARN_IF(!mContentCache.CacheAll(this, &aIMENotification))) {
 817         return NS_ERROR_FAILURE;
 818       }
 819     } else {
 820       // However, if a plugin has focus, only the editor rect information is
 821       // available.
 822       if (NS_WARN_IF(!mContentCache.CacheEditorRect(this, &aIMENotification))) {
 823         return NS_ERROR_FAILURE;
 824       }
 825     }
 826   } else {
 827     // When IME loses focus, we don't need to store anything.
 828     mContentCache.Clear();
 829   }
 830
 831   mIMENotificationRequestsOfParent =
 832   IMENotificationRequests(IMENotificationRequests::NOTIFY_ALL);
 833   RefPtr<PuppetWidget> self = this;
 834   mTabChild->SendNotifyIMEFocus(mContentCache, aIMENotification)->Then(
 835     mTabChild->TabGroup()->EventTargetFor(TaskCategory::UI),
 836     __func__,
 837     [self] (IMENotificationRequests aRequests) {
 838       self->mIMENotificationRequestsOfParent = aRequests;
 839     },
 840     [self] (mozilla::ipc::ResponseRejectReason aReason) {
 841       NS_WARNING("SendNotifyIMEFocus got rejected.");
 842     });
 843
 844   return NS_OK;
 845 }
 846
 847 nsresult
 848 PuppetWidget::NotifyIMEOfCompositionUpdate(
 849                 const IMENotification& aIMENotification)
 850 {
 851   if (NS_WARN_IF(!mTabChild)) {
 852     return NS_ERROR_FAILURE;
 853   }
 854
 855   if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN &&
 856       NS_WARN_IF(!mContentCache.CacheSelection(this, &aIMENotification))) {
 857     return NS_ERROR_FAILURE;
 858   }
 859   mTabChild->SendNotifyIMECompositionUpdate(mContentCache, aIMENotification);
 860   return NS_OK;
 861 }
 862
 863 nsresult
 864 PuppetWidget::NotifyIMEOfTextChange(const IMENotification& aIMENotification)
 865 {
 866   MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_TEXT_CHANGE,
 867              "Passed wrong notification");
 868   if (!mTabChild) {
 869     return NS_ERROR_FAILURE;
 870   }
 871
 872   // While a plugin has focus, text change notification shouldn't be available.
 873   if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
 874     return NS_ERROR_FAILURE;
 875   }
 876
 877   // FYI: text change notification is the first notification after
 878   //      a user operation changes the content.  So, we need to modify
 879   //      the cache as far as possible here.
 880
 881   if (NS_WARN_IF(!mContentCache.CacheText(this, &aIMENotification))) {
 882     return NS_ERROR_FAILURE;
 883   }
 884
 885   // TabParent doesn't this this to cache.  we don't send the notification
 886   // if parent process doesn't request NOTIFY_TEXT_CHANGE.
 887   if (mIMENotificationRequestsOfParent.WantTextChange()) {
 888     mTabChild->SendNotifyIMETextChange(mContentCache, aIMENotification);
 889   } else {
 890     mTabChild->SendUpdateContentCache(mContentCache);
 891   }
 892   return NS_OK;
 893 }
 894
 895 nsresult
 896 PuppetWidget::NotifyIMEOfSelectionChange(
 897                 const IMENotification& aIMENotification)
 898 {
 899   MOZ_ASSERT(aIMENotification.mMessage == NOTIFY_IME_OF_SELECTION_CHANGE,
 900              "Passed wrong notification");
 901   if (!mTabChild) {
 902     return NS_ERROR_FAILURE;
 903   }
 904
 905   // While a plugin has focus, selection change notification shouldn't be
 906   // available.
 907   if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
 908     return NS_ERROR_FAILURE;
 909   }
 910
 911   // Note that selection change must be notified after text change if it occurs.
 912   // Therefore, we don't need to query text content again here.
 913   mContentCache.SetSelection(
 914     this,
 915     aIMENotification.mSelectionChangeData.mOffset,
 916     aIMENotification.mSelectionChangeData.Length(),
 917     aIMENotification.mSelectionChangeData.mReversed,
 918     aIMENotification.mSelectionChangeData.GetWritingMode());
 919
 920   mTabChild->SendNotifyIMESelection(mContentCache, aIMENotification);
 921
 922   return NS_OK;
 923 }
 924
 925 nsresult
 926 PuppetWidget::NotifyIMEOfMouseButtonEvent(
 927                 const IMENotification& aIMENotification)
 928 {
 929   if (!mTabChild) {
 930     return NS_ERROR_FAILURE;
 931   }
 932
 933   // While a plugin has focus, mouse button event notification shouldn't be
 934   // available.
 935   if (NS_WARN_IF(mInputContext.mIMEState.mEnabled == IMEState::PLUGIN)) {
 936     return NS_ERROR_FAILURE;
 937   }
 938
 939
 940   bool consumedByIME = false;
 941   if (!mTabChild->SendNotifyIMEMouseButtonEvent(aIMENotification,
 942                                                 &consumedByIME)) {
 943     return NS_ERROR_FAILURE;
 944   }
 945
 946   return consumedByIME ? NS_SUCCESS_EVENT_CONSUMED : NS_OK;
 947 }
 948
 949 nsresult
 950 PuppetWidget::NotifyIMEOfPositionChange(const IMENotification& aIMENotification)
 951 {
 952   if (NS_WARN_IF(!mTabChild)) {
 953     return NS_ERROR_FAILURE;
 954   }
 955
 956   if (NS_WARN_IF(!mContentCache.CacheEditorRect(this, &aIMENotification))) {
 957     return NS_ERROR_FAILURE;
 958   }
 959   // While a plugin has focus, selection range isn't available.  So, we don't
 960   // need to cache it at that time.
 961   if (mInputContext.mIMEState.mEnabled != IMEState::PLUGIN &&
 962       NS_WARN_IF(!mContentCache.CacheSelection(this, &aIMENotification))) {
 963     return NS_ERROR_FAILURE;
 964   }
 965   if (mIMENotificationRequestsOfParent.WantPositionChanged()) {
 966     mTabChild->SendNotifyIMEPositionChange(mContentCache, aIMENotification);
 967   } else {
 968     mTabChild->SendUpdateContentCache(mContentCache);
 969   }
 970   return NS_OK;
 971 }
 972
 973 void
 974 PuppetWidget::SetCursor(nsCursor aCursor)
 975 {
 976   // Don't cache on windows, Windowless flash breaks this via async cursor updates.
 977 #if !defined(XP_WIN)
 978   if (mCursor == aCursor && !mCustomCursor && !mUpdateCursor) {
 979     return;
 980   }
 981 #endif
 982
 983   mCustomCursor = nullptr;
 984
 985   if (mTabChild &&
 986       !mTabChild->SendSetCursor(aCursor, mUpdateCursor)) {
 987     return;
 988   }
 989
 990   mCursor = aCursor;
 991   mUpdateCursor = false;
 992 }
 993
 994 nsresult
 995 PuppetWidget::SetCursor(imgIContainer* aCursor,
 996                         uint32_t aHotspotX, uint32_t aHotspotY)
 997 {
 998   if (!aCursor || !mTabChild) {
 999     return NS_OK;
1000   }
1001
1002 #if !defined(XP_WIN)
1003   if (mCustomCursor == aCursor &&
1004       mCursorHotspotX == aHotspotX &&
1005       mCursorHotspotY == aHotspotY &&
1006       !mUpdateCursor) {
1007     return NS_OK;
1008   }
1009 #endif
1010
1011   RefPtr<mozilla::gfx::SourceSurface> surface =
1012     aCursor->GetFrame(imgIContainer::FRAME_CURRENT,
1013                       imgIContainer::FLAG_SYNC_DECODE);
1014   if (!surface) {
1015     return NS_ERROR_FAILURE;
1016   }
1017
1018   RefPtr<mozilla::gfx::DataSourceSurface> dataSurface =
1019     surface->GetDataSurface();
1020   if (!dataSurface) {
1021     return NS_ERROR_FAILURE;
1022   }
1023
1024   size_t length;
1025   int32_t stride;
1026   mozilla::UniquePtr<char[]> surfaceData =
1027     nsContentUtils::GetSurfaceData(WrapNotNull(dataSurface), &length, &stride);
1028
1029   nsDependentCString cursorData(surfaceData.get(), length);
1030   mozilla::gfx::IntSize size = dataSurface->GetSize();
1031   if (!mTabChild->SendSetCustomCursor(cursorData, size.width, size.height, stride,
1032                                       dataSurface->GetFormat(),
1033                                       aHotspotX, aHotspotY, mUpdateCursor)) {
1034     return NS_ERROR_FAILURE;
1035   }
1036
1037   mCursor = eCursorInvalid;
1038   mCustomCursor = aCursor;
1039   mCursorHotspotX = aHotspotX;
1040   mCursorHotspotY = aHotspotY;
1041   mUpdateCursor = false;
1042
1043   return NS_OK;
1044 }
1045
1046 void
1047 PuppetWidget::ClearCachedCursor()
1048 {
1049   nsBaseWidget::ClearCachedCursor();
1050   mCustomCursor = nullptr;
1051 }
1052
1053 nsresult
1054 PuppetWidget::Paint()
1055 {
1056   MOZ_ASSERT(!mDirtyRegion.IsEmpty(), "paint event logic messed up");
1057
1058   if (!GetCurrentWidgetListener())
1059     return NS_OK;
1060
1061   LayoutDeviceIntRegion region = mDirtyRegion;
1062
1063   // reset repaint tracking
1064   mDirtyRegion.SetEmpty();
1065   mPaintTask.Revoke();
1066
1067   RefPtr<PuppetWidget> strongThis(this);
1068
1069   GetCurrentWidgetListener()->WillPaintWindow(this);
1070
1071   if (GetCurrentWidgetListener()) {
1072 #ifdef DEBUG
1073     debug_DumpPaintEvent(stderr, this, region.ToUnknownRegion(),
1074                          "PuppetWidget", 0);
1075 #endif
1076
1077     if (mLayerManager->GetBackendType() == mozilla::layers::LayersBackend::LAYERS_CLIENT ||
1078         mLayerManager->GetBackendType() == mozilla::layers::LayersBackend::LAYERS_WR ||
1079         (mozilla::layers::LayersBackend::LAYERS_BASIC == mLayerManager->GetBackendType() &&
1080          mTabChild && mTabChild->IsLayersConnected().isSome())) {
1081       // Do nothing, the compositor will handle drawing
1082       if (mTabChild) {
1083         mTabChild->NotifyPainted();
1084       }
1085     } else if (mozilla::layers::LayersBackend::LAYERS_BASIC == mLayerManager->GetBackendType()) {
1086       RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(mDrawTarget);
1087       if (!ctx) {
1088         gfxDevCrash(LogReason::InvalidContext) << "PuppetWidget context problem " << gfx::hexa(mDrawTarget);
1089         return NS_ERROR_FAILURE;
1090       }
1091       ctx->Rectangle(gfxRect(0,0,0,0));
1092       ctx->Clip();
1093       AutoLayerManagerSetup setupLayerManager(this, ctx,
1094                                               BufferMode::BUFFER_NONE);
1095       GetCurrentWidgetListener()->PaintWindow(this, region);
1096       if (mTabChild) {
1097         mTabChild->NotifyPainted();
1098       }
1099     }
1100   }
1101
1102   if (GetCurrentWidgetListener()) {
1103     GetCurrentWidgetListener()->DidPaintWindow();
1104   }
1105
1106   return NS_OK;
1107 }
1108
1109 void
1110 PuppetWidget::SetChild(PuppetWidget* aChild)
1111 {
1112   MOZ_ASSERT(this != aChild, "can't parent a widget to itself");
1113   MOZ_ASSERT(!aChild->mChild,
1114              "fake widget 'hierarchy' only expected to have one level");
1115
1116   mChild = aChild;
1117 }
1118
1119 NS_IMETHODIMP
1120 PuppetWidget::PaintTask::Run()
1121 {
1122   if (mWidget) {
1123     mWidget->Paint();
1124   }
1125   return NS_OK;
1126 }
1127
1128 void
1129 PuppetWidget::PaintNowIfNeeded()
1130 {
1131   if (IsVisible() && mPaintTask.IsPending()) {
1132     Paint();
1133   }
1134 }
1135
1136 void
1137 PuppetWidget::OnMemoryPressure(layers::MemoryPressureReason aWhy)
1138 {
1139   if (aWhy != MemoryPressureReason::LOW_MEMORY_ONGOING &&
1140       !mVisible &&
1141       mLayerManager &&
1142       XRE_IsContentProcess()) {
1143     mLayerManager->ClearCachedResources();
1144   }
1145 }
1146
1147 bool
1148 PuppetWidget::NeedsPaint()
1149 {
1150   // e10s popups are handled by the parent process, so never should be painted here
1151   if (XRE_IsContentProcess() &&
1152       gRemoteDesktopBehaviorEnabled &&
1153       mWindowType == eWindowType_popup) {
1154     NS_WARNING("Trying to paint an e10s popup in the child process!");
1155     return false;
1156   }
1157
1158   return mVisible;
1159 }
1160
1161 float
1162 PuppetWidget::GetDPI()
1163 {
1164   return mDPI;
1165 }
1166
1167 double
1168 PuppetWidget::GetDefaultScaleInternal()
1169 {
1170   return mDefaultScale;
1171 }
1172
1173 int32_t
1174 PuppetWidget::RoundsWidgetCoordinatesTo()
1175 {
1176   return mRounding;
1177 }
1178
1179 void*
1180 PuppetWidget::GetNativeData(uint32_t aDataType)
1181 {
1182   switch (aDataType) {
1183   case NS_NATIVE_SHAREABLE_WINDOW: {
1184     // NOTE: We can not have a tab child in some situations, such as when we're
1185     // rendering to a fake widget for thumbnails.
1186     if (!mTabChild) {
1187       NS_WARNING("Need TabChild to get the nativeWindow from!");
1188     }
1189     mozilla::WindowsHandle nativeData = 0;
1190     if (mTabChild) {
1191       nativeData = mTabChild->WidgetNativeData();
1192     }
1193     return (void*)nativeData;
1194   }
1195   case NS_NATIVE_WINDOW:
1196   case NS_NATIVE_WIDGET:
1197   case NS_NATIVE_DISPLAY:
1198     // These types are ignored (see bug 1183828, bug 1240891).
1199     break;
1200   case NS_RAW_NATIVE_IME_CONTEXT:
1201     MOZ_CRASH("You need to call GetNativeIMEContext() instead");
1202   case NS_NATIVE_PLUGIN_PORT:
1203   case NS_NATIVE_GRAPHIC:
1204   case NS_NATIVE_SHELLWIDGET:
1205   default:
1206     NS_WARNING("nsWindow::GetNativeData called with bad value");
1207     break;
1208   }
1209   return nullptr;
1210 }
1211
1212 #if defined(XP_WIN)
1213 void
1214 PuppetWidget::SetNativeData(uint32_t aDataType, uintptr_t aVal)
1215 {
1216   switch (aDataType) {
1217   case NS_NATIVE_CHILD_OF_SHAREABLE_WINDOW:
1218     MOZ_ASSERT(mTabChild, "Need TabChild to send the message.");
1219     if (mTabChild) {
1220       mTabChild->SendSetNativeChildOfShareableWindow(aVal);
1221     }
1222     break;
1223   default:
1224     NS_WARNING("SetNativeData called with unsupported data type.");
1225   }
1226 }
1227 #endif
1228
1229 LayoutDeviceIntPoint
1230 PuppetWidget::GetChromeOffset()
1231 {
1232   if (!GetOwningTabChild()) {
1233     NS_WARNING("PuppetWidget without Tab does not have chrome information.");
1234     return LayoutDeviceIntPoint();
1235   }
1236   return GetOwningTabChild()->GetChromeOffset();
1237 }
1238
1239 LayoutDeviceIntPoint
1240 PuppetWidget::GetWindowPosition()
1241 {
1242   if (!GetOwningTabChild()) {
1243     return LayoutDeviceIntPoint();
1244   }
1245
1246   int32_t winX, winY, winW, winH;
1247   NS_ENSURE_SUCCESS(GetOwningTabChild()->GetDimensions(0, &winX, &winY, &winW, &winH), LayoutDeviceIntPoint());
1248   return LayoutDeviceIntPoint(winX, winY) + GetOwningTabChild()->GetClientOffset();
1249 }
1250
1251 LayoutDeviceIntRect
1252 PuppetWidget::GetScreenBounds()
1253 {
1254   return LayoutDeviceIntRect(WidgetToScreenOffset(), mBounds.Size());
1255 }
1256
1257 uint32_t PuppetWidget::GetMaxTouchPoints() const
1258 {
1259   uint32_t maxTouchPoints = 0;
1260   if (mTabChild) {
1261     mTabChild->GetMaxTouchPoints(&maxTouchPoints);
1262   }
1263   return maxTouchPoints;
1264 }
1265
1266 void
1267 PuppetWidget::StartAsyncScrollbarDrag(const AsyncDragMetrics& aDragMetrics)
1268 {
1269   mTabChild->StartScrollbarDrag(aDragMetrics);
1270 }
1271
1272 PuppetScreen::PuppetScreen(void *nativeScreen)
1273 {
1274 }
1275
1276 PuppetScreen::~PuppetScreen()
1277 {
1278 }
1279
1280 static ScreenConfiguration
1281 ScreenConfig()
1282 {
1283   ScreenConfiguration config;
1284   hal::GetCurrentScreenConfiguration(&config);
1285   return config;
1286 }
1287
1288 nsIntSize
1289 PuppetWidget::GetScreenDimensions()
1290 {
1291   nsIntRect r = ScreenConfig().rect();
1292   return nsIntSize(r.Width(), r.Height());
1293 }
1294
1295 NS_IMETHODIMP
1296 PuppetScreen::GetRect(int32_t *outLeft,  int32_t *outTop,
1297                       int32_t *outWidth, int32_t *outHeight)
1298 {
1299   nsIntRect r = ScreenConfig().rect();
1300   r.GetRect(outLeft, outTop, outWidth, outHeight);
1301   return NS_OK;
1302 }
1303
1304 NS_IMETHODIMP
1305 PuppetScreen::GetAvailRect(int32_t *outLeft,  int32_t *outTop,
1306                            int32_t *outWidth, int32_t *outHeight)
1307 {
1308   return GetRect(outLeft, outTop, outWidth, outHeight);
1309 }
1310
1311 NS_IMETHODIMP
1312 PuppetScreen::GetPixelDepth(int32_t *aPixelDepth)
1313 {
1314   *aPixelDepth = ScreenConfig().pixelDepth();
1315   return NS_OK;
1316 }
1317
1318 NS_IMETHODIMP
1319 PuppetScreen::GetColorDepth(int32_t *aColorDepth)
1320 {
1321   *aColorDepth = ScreenConfig().colorDepth();
1322   return NS_OK;
1323 }
1324
1325 NS_IMPL_ISUPPORTS(PuppetScreenManager, nsIScreenManager)
1326
1327 PuppetScreenManager::PuppetScreenManager()
1328 {
1329     mOneScreen = new PuppetScreen(nullptr);
1330 }
1331
1332 PuppetScreenManager::~PuppetScreenManager()
1333 {
1334 }
1335
1336 NS_IMETHODIMP
1337 PuppetScreenManager::GetPrimaryScreen(nsIScreen** outScreen)
1338 {
1339   NS_IF_ADDREF(*outScreen = mOneScreen.get());
1340   return NS_OK;
1341 }
1342
1343 NS_IMETHODIMP
1344 PuppetScreenManager::ScreenForRect(int32_t inLeft,
1345                                    int32_t inTop,
1346                                    int32_t inWidth,
1347                                    int32_t inHeight,
1348                                    nsIScreen** outScreen)
1349 {
1350   return GetPrimaryScreen(outScreen);
1351 }
1352
1353 nsIWidgetListener*
1354 PuppetWidget::GetCurrentWidgetListener()
1355 {
1356   if (!mPreviouslyAttachedWidgetListener ||
1357       !mAttachedWidgetListener) {
1358     return mAttachedWidgetListener;
1359   }
1360
1361   if (mAttachedWidgetListener->GetView()->IsPrimaryFramePaintSuppressed()) {
1362     return mPreviouslyAttachedWidgetListener;
1363   }
1364
1365   return mAttachedWidgetListener;
1366 }
1367
1368 void
1369 PuppetWidget::SetCandidateWindowForPlugin(
1370                 const CandidateWindowPosition& aPosition)
1371 {
1372   if (!mTabChild) {
1373     return;
1374   }
1375
1376   mTabChild->SendSetCandidateWindowForPlugin(aPosition);
1377 }
1378
1379 void
1380 PuppetWidget::EnableIMEForPlugin(bool aEnable)
1381 {
1382   if (!mTabChild) {
1383     return;
1384   }
1385
1386   // If current IME state isn't plugin, we ignore this call.
1387   if (NS_WARN_IF(HaveValidInputContextCache() &&
1388                  mInputContext.mIMEState.mEnabled != IMEState::UNKNOWN &&
1389                  mInputContext.mIMEState.mEnabled != IMEState::PLUGIN)) {
1390     return;
1391   }
1392
1393   // We don't have valid state in cache or state is plugin, so delegate to
1394   // chrome process.
1395   mTabChild->SendEnableIMEForPlugin(aEnable);
1396 }
1397
1398 void
1399 PuppetWidget::ZoomToRect(const uint32_t& aPresShellId,
1400                          const FrameMetrics::ViewID& aViewId,
1401                          const CSSRect& aRect,
1402                          const uint32_t& aFlags)
1403 {
1404   if (!mTabChild) {
1405     return;
1406   }
1407
1408   mTabChild->ZoomToRect(aPresShellId, aViewId, aRect, aFlags);
1409 }
1410
1411 void
1412 PuppetWidget::LookUpDictionary(
1413                 const nsAString& aText,
1414                 const nsTArray<mozilla::FontRange>& aFontRangeArray,
1415                 const bool aIsVertical,
1416                 const LayoutDeviceIntPoint& aPoint)
1417 {
1418   if (!mTabChild) {
1419     return;
1420   }
1421
1422   mTabChild->SendLookUpDictionary(nsString(aText), aFontRangeArray, aIsVertical, aPoint);
1423 }
1424
1425 bool
1426 PuppetWidget::HasPendingInputEvent()
1427 {
1428   if (!mTabChild) {
1429     return false;
1430   }
1431
1432   bool ret = false;
1433
1434   mTabChild->GetIPCChannel()->PeekMessages(
1435     [&ret](const IPC::Message& aMsg) -> bool {
1436       if (nsContentUtils::IsMessageInputEvent(aMsg)) {
1437         ret = true;
1438         return false; // Stop peeking.
1439       }
1440       return true;
1441     }
1442   );
1443
1444   return ret;
1445 }
1446
1447 void
1448 PuppetWidget::HandledWindowedPluginKeyEvent(
1449                 const NativeEventData& aKeyEventData,
1450                 bool aIsConsumed)
1451 {
1452   if (NS_WARN_IF(mKeyEventInPluginCallbacks.IsEmpty())) {
1453     return;
1454   }
1455   nsCOMPtr<nsIKeyEventInPluginCallback> callback =
1456     mKeyEventInPluginCallbacks[0];
1457   MOZ_ASSERT(callback);
1458   mKeyEventInPluginCallbacks.RemoveElementAt(0);
1459   callback->HandledWindowedPluginKeyEvent(aKeyEventData, aIsConsumed);
1460 }
1461
1462 nsresult
1463 PuppetWidget::OnWindowedPluginKeyEvent(const NativeEventData& aKeyEventData,
1464                                        nsIKeyEventInPluginCallback* aCallback)
1465 {
1466   if (NS_WARN_IF(!mTabChild)) {
1467     return NS_ERROR_NOT_AVAILABLE;
1468   }
1469   if (NS_WARN_IF(!mTabChild->SendOnWindowedPluginKeyEvent(aKeyEventData))) {
1470     return NS_ERROR_FAILURE;
1471   }
1472   mKeyEventInPluginCallbacks.AppendElement(aCallback);
1473   return NS_SUCCESS_EVENT_HANDLED_ASYNCHRONOUSLY;
1474 }
1475
1476 // TextEventDispatcherListener
1477
1478 NS_IMETHODIMP
1479 PuppetWidget::NotifyIME(TextEventDispatcher* aTextEventDispatcher,
1480                         const IMENotification& aIMENotification)
1481 {
1482   MOZ_ASSERT(aTextEventDispatcher == mTextEventDispatcher);
1483
1484   // If there is different text event dispatcher listener for handling
1485   // text event dispatcher, that means that native keyboard events and
1486   // IME events are handled in this process.  Therefore, we don't need
1487   // to send any requests and notifications to the parent process.
1488   if (mNativeTextEventDispatcherListener) {
1489     return NS_ERROR_NOT_IMPLEMENTED;
1490   }
1491
1492   switch (aIMENotification.mMessage) {
1493     case REQUEST_TO_COMMIT_COMPOSITION:
1494       return RequestIMEToCommitComposition(false);
1495     case REQUEST_TO_CANCEL_COMPOSITION:
1496       return RequestIMEToCommitComposition(true);
1497     case NOTIFY_IME_OF_FOCUS:
1498     case NOTIFY_IME_OF_BLUR:
1499       return NotifyIMEOfFocusChange(aIMENotification);
1500     case NOTIFY_IME_OF_SELECTION_CHANGE:
1501       return NotifyIMEOfSelectionChange(aIMENotification);
1502     case NOTIFY_IME_OF_TEXT_CHANGE:
1503       return NotifyIMEOfTextChange(aIMENotification);
1504     case NOTIFY_IME_OF_COMPOSITION_EVENT_HANDLED:
1505       return NotifyIMEOfCompositionUpdate(aIMENotification);
1506     case NOTIFY_IME_OF_MOUSE_BUTTON_EVENT:
1507       return NotifyIMEOfMouseButtonEvent(aIMENotification);
1508     case NOTIFY_IME_OF_POSITION_CHANGE:
1509       return NotifyIMEOfPositionChange(aIMENotification);
1510     default:
1511       return NS_ERROR_NOT_IMPLEMENTED;
1512   }
1513
1514   return NS_ERROR_NOT_IMPLEMENTED;
1515 }
1516
1517 NS_IMETHODIMP_(IMENotificationRequests)
1518 PuppetWidget::GetIMENotificationRequests()
1519 {
1520   if (mInputContext.mIMEState.mEnabled == IMEState::PLUGIN) {
1521     // If a plugin has focus, we cannot receive text nor selection change
1522     // in the plugin.  Therefore, PuppetWidget needs to receive only position
1523     // change event for updating the editor rect cache.
1524     return IMENotificationRequests(
1525              mIMENotificationRequestsOfParent.mWantUpdates |
1526              IMENotificationRequests::NOTIFY_POSITION_CHANGE);
1527   }
1528   return IMENotificationRequests(
1529            mIMENotificationRequestsOfParent.mWantUpdates |
1530            IMENotificationRequests::NOTIFY_TEXT_CHANGE |
1531            IMENotificationRequests::NOTIFY_POSITION_CHANGE);
1532 }
1533
1534 NS_IMETHODIMP_(void)
1535 PuppetWidget::OnRemovedFrom(TextEventDispatcher* aTextEventDispatcher)
1536 {
1537   MOZ_ASSERT(aTextEventDispatcher == mTextEventDispatcher);
1538 }
1539
1540 NS_IMETHODIMP_(void)
1541 PuppetWidget::WillDispatchKeyboardEvent(
1542                 TextEventDispatcher* aTextEventDispatcher,
1543                 WidgetKeyboardEvent& aKeyboardEvent,
1544                 uint32_t aIndexOfKeypress,
1545                 void* aData)
1546 {
1547   MOZ_ASSERT(aTextEventDispatcher == mTextEventDispatcher);
1548 }
1549
1550 nsresult
1551 PuppetWidget::SetSystemFont(const nsCString& aFontName)
1552 {
1553   if (!mTabChild) {
1554     return NS_ERROR_FAILURE;
1555   }
1556
1557   mTabChild->SendSetSystemFont(aFontName);
1558   return NS_OK;
1559 }
1560
1561 nsresult
1562 PuppetWidget::GetSystemFont(nsCString& aFontName)
1563 {
1564   if (!mTabChild) {
1565     return NS_ERROR_FAILURE;
1566   }
1567   mTabChild->SendGetSystemFont(&aFontName);
1568   return NS_OK;
1569 }
1570
1571 } // namespace widget
1572 } // namespace mozilla