widget/xpwidgets/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 "BasicLayers.h"
  11 #include "gfxPlatform.h"
  12 #if defined(MOZ_ENABLE_D3D10_LAYER)
  13 # include "LayerManagerD3D10.h"
  14 #endif
  15 #include "mozilla/dom/TabChild.h"
  16 #include "mozilla/Hal.h"
  17 #include "mozilla/layers/CompositorChild.h"
  18 #include "mozilla/layers/PLayersChild.h"
  19 #include "PuppetWidget.h"
  20 #include "nsIWidgetListener.h"
  21
  22 using namespace mozilla::dom;
  23 using namespace mozilla::hal;
  24 using namespace mozilla::layers;
  25 using namespace mozilla::widget;
  26
  27 static void
  28 InvalidateRegion(nsIWidget* aWidget, const nsIntRegion& aRegion)
  29 {
  30   nsIntRegionRectIterator it(aRegion);
  31   while(const nsIntRect* r = it.Next()) {
  32     aWidget->Invalidate(*r);
  33   }
  34 }
  35
  36 /*static*/ already_AddRefed<nsIWidget>
  37 nsIWidget::CreatePuppetWidget(TabChild* aTabChild)
  38 {
  39   NS_ABORT_IF_FALSE(nsIWidget::UsePuppetWidgets(),
  40                     "PuppetWidgets not allowed in this configuration");
  41
  42   nsCOMPtr<nsIWidget> widget = new PuppetWidget(aTabChild);
  43   return widget.forget();
  44 }
  45
  46 namespace mozilla {
  47 namespace widget {
  48
  49 static bool
  50 IsPopup(const nsWidgetInitData* aInitData)
  51 {
  52   return aInitData && aInitData->mWindowType == eWindowType_popup;
  53 }
  54
  55 static bool
  56 MightNeedIMEFocus(const nsWidgetInitData* aInitData)
  57 {
  58   // In the puppet-widget world, popup widgets are just dummies and
  59   // shouldn't try to mess with IME state.
  60   return !IsPopup(aInitData);
  61 }
  62
  63
  64 // Arbitrary, fungible.
  65 const size_t PuppetWidget::kMaxDimension = 4000;
  66
  67 NS_IMPL_ISUPPORTS_INHERITED1(PuppetWidget, nsBaseWidget,
  68                              nsISupportsWeakReference)
  69
  70 PuppetWidget::PuppetWidget(TabChild* aTabChild)
  71   : mTabChild(aTabChild)
  72   , mDPI(-1)
  73 {
  74   MOZ_COUNT_CTOR(PuppetWidget);
  75 }
  76
  77 PuppetWidget::~PuppetWidget()
  78 {
  79   MOZ_COUNT_DTOR(PuppetWidget);
  80 }
  81
  82 NS_IMETHODIMP
  83 PuppetWidget::Create(nsIWidget        *aParent,
  84                      nsNativeWidget   aNativeParent,
  85                      const nsIntRect  &aRect,
  86                      nsDeviceContext *aContext,
  87                      nsWidgetInitData *aInitData)
  88 {
  89   NS_ABORT_IF_FALSE(!aNativeParent, "got a non-Puppet native parent");
  90
  91   BaseCreate(nullptr, aRect, aContext, aInitData);
  92
  93   mBounds = aRect;
  94   mEnabled = true;
  95   mVisible = true;
  96
  97   mSurface = gfxPlatform::GetPlatform()
  98              ->CreateOffscreenSurface(gfxIntSize(1, 1),
  99                                       gfxASurface::ContentFromFormat(gfxASurface::ImageFormatARGB32));
 100
 101   mIMEComposing = false;
 102   mNeedIMEStateInit = MightNeedIMEFocus(aInitData);
 103
 104   PuppetWidget* parent = static_cast<PuppetWidget*>(aParent);
 105   if (parent) {
 106     parent->SetChild(this);
 107     mLayerManager = parent->GetLayerManager();
 108   }
 109   else {
 110     Resize(mBounds.x, mBounds.y, mBounds.width, mBounds.height, false);
 111   }
 112
 113   return NS_OK;
 114 }
 115
 116 void
 117 PuppetWidget::InitIMEState()
 118 {
 119   if (mNeedIMEStateInit) {
 120     uint32_t chromeSeqno;
 121     mTabChild->SendNotifyIMEFocus(false, &mIMEPreference, &chromeSeqno);
 122     mIMELastBlurSeqno = mIMELastReceivedSeqno = chromeSeqno;
 123     mNeedIMEStateInit = false;
 124   }
 125 }
 126
 127 already_AddRefed<nsIWidget>
 128 PuppetWidget::CreateChild(const nsIntRect  &aRect,
 129                           nsDeviceContext *aContext,
 130                           nsWidgetInitData *aInitData,
 131                           bool             aForceUseIWidgetParent)
 132 {
 133   bool isPopup = IsPopup(aInitData);
 134   nsCOMPtr<nsIWidget> widget = nsIWidget::CreatePuppetWidget(mTabChild);
 135   return ((widget &&
 136            NS_SUCCEEDED(widget->Create(isPopup ? nullptr: this, nullptr, aRect,
 137                                        aContext, aInitData))) ?
 138           widget.forget() : nullptr);
 139 }
 140
 141 NS_IMETHODIMP
 142 PuppetWidget::Destroy()
 143 {
 144   Base::OnDestroy();
 145   Base::Destroy();
 146   mPaintTask.Revoke();
 147   mChild = nullptr;
 148   if (mLayerManager) {
 149     mLayerManager->Destroy();
 150   }
 151   mLayerManager = nullptr;
 152   mTabChild = nullptr;
 153   return NS_OK;
 154 }
 155
 156 NS_IMETHODIMP
 157 PuppetWidget::Show(bool aState)
 158 {
 159   NS_ASSERTION(mEnabled,
 160                "does it make sense to Show()/Hide() a disabled widget?");
 161
 162   bool wasVisible = mVisible;
 163   mVisible = aState;
 164
 165   if (mChild) {
 166     mChild->mVisible = aState;
 167   }
 168
 169   if (!mVisible && mLayerManager) {
 170     mLayerManager->ClearCachedResources();
 171   }
 172
 173   if (!wasVisible && mVisible) {
 174     Resize(mBounds.width, mBounds.height, false);
 175     Invalidate(mBounds);
 176   }
 177
 178   return NS_OK;
 179 }
 180
 181 NS_IMETHODIMP
 182 PuppetWidget::Resize(int32_t aWidth,
 183                      int32_t aHeight,
 184                      bool    aRepaint)
 185 {
 186   nsIntRect oldBounds = mBounds;
 187   mBounds.SizeTo(nsIntSize(aWidth, aHeight));
 188
 189   if (mChild) {
 190     return mChild->Resize(aWidth, aHeight, aRepaint);
 191   }
 192
 193   // XXX: roc says that |aRepaint| dictates whether or not to
 194   // invalidate the expanded area
 195   if (oldBounds.Size() < mBounds.Size() && aRepaint) {
 196     nsIntRegion dirty(mBounds);
 197     dirty.Sub(dirty,  oldBounds);
 198     InvalidateRegion(this, dirty);
 199   }
 200
 201   if (!oldBounds.IsEqualEdges(mBounds) && mAttachedWidgetListener) {
 202     mAttachedWidgetListener->WindowResized(this, mBounds.width, mBounds.height);
 203   }
 204
 205   return NS_OK;
 206 }
 207
 208 NS_IMETHODIMP
 209 PuppetWidget::SetFocus(bool aRaise)
 210 {
 211   // XXX/cjones: someone who knows about event handling needs to
 212   // decide how this should work.
 213   return NS_OK;
 214 }
 215
 216 NS_IMETHODIMP
 217 PuppetWidget::Invalidate(const nsIntRect& aRect)
 218 {
 219 #ifdef DEBUG
 220   debug_DumpInvalidate(stderr, this, &aRect,
 221                        nsAutoCString("PuppetWidget"), 0);
 222 #endif
 223
 224   if (mChild) {
 225     return mChild->Invalidate(aRect);
 226   }
 227
 228   mDirtyRegion.Or(mDirtyRegion, aRect);
 229
 230   if (!mDirtyRegion.IsEmpty() && !mPaintTask.IsPending()) {
 231     mPaintTask = new PaintTask(this);
 232     return NS_DispatchToCurrentThread(mPaintTask.get());
 233   }
 234
 235   return NS_OK;
 236 }
 237
 238 void
 239 PuppetWidget::InitEvent(nsGUIEvent& event, nsIntPoint* aPoint)
 240 {
 241   if (nullptr == aPoint) {
 242     event.refPoint.x = 0;
 243     event.refPoint.y = 0;
 244   }
 245   else {
 246     // use the point override if provided
 247     event.refPoint.x = aPoint->x;
 248     event.refPoint.y = aPoint->y;
 249   }
 250   event.time = PR_Now() / 1000;
 251 }
 252
 253 NS_IMETHODIMP
 254 PuppetWidget::DispatchEvent(nsGUIEvent* event, nsEventStatus& aStatus)
 255 {
 256 #ifdef DEBUG
 257   debug_DumpEvent(stdout, event->widget, event,
 258                   nsAutoCString("PuppetWidget"), 0);
 259 #endif
 260
 261   NS_ABORT_IF_FALSE(!mChild || mChild->mWindowType == eWindowType_popup,
 262                     "Unexpected event dispatch!");
 263
 264   aStatus = nsEventStatus_eIgnore;
 265
 266   if (event->message == NS_COMPOSITION_START) {
 267     mIMEComposing = true;
 268   }
 269   switch (event->eventStructType) {
 270   case NS_COMPOSITION_EVENT:
 271     mIMELastReceivedSeqno = static_cast<nsCompositionEvent*>(event)->seqno;
 272     if (mIMELastReceivedSeqno < mIMELastBlurSeqno)
 273       return NS_OK;
 274     break;
 275   case NS_TEXT_EVENT:
 276     mIMELastReceivedSeqno = static_cast<nsTextEvent*>(event)->seqno;
 277     if (mIMELastReceivedSeqno < mIMELastBlurSeqno)
 278       return NS_OK;
 279     break;
 280   case NS_SELECTION_EVENT:
 281     mIMELastReceivedSeqno = static_cast<nsSelectionEvent*>(event)->seqno;
 282     if (mIMELastReceivedSeqno < mIMELastBlurSeqno)
 283       return NS_OK;
 284     break;
 285   }
 286
 287   if (mAttachedWidgetListener) {
 288     aStatus = mAttachedWidgetListener->HandleEvent(event, mUseAttachedEvents);
 289   }
 290
 291   if (event->message == NS_COMPOSITION_END) {
 292     mIMEComposing = false;
 293   }
 294
 295   return NS_OK;
 296 }
 297
 298 LayerManager*
 299 PuppetWidget::GetLayerManager(PLayersChild* aShadowManager,
 300                               LayersBackend aBackendHint,
 301                               LayerManagerPersistence aPersistence,
 302                               bool* aAllowRetaining)
 303 {
 304   if (!mLayerManager) {
 305     // The backend hint is a temporary placeholder until Azure, when
 306     // all content-process layer managers will be BasicLayerManagers.
 307 #if defined(MOZ_ENABLE_D3D10_LAYER)
 308     if (mozilla::layers::LAYERS_D3D10 == aBackendHint) {
 309       nsRefPtr<LayerManagerD3D10> m = new LayerManagerD3D10(this);
 310       m->AsShadowForwarder()->SetShadowManager(aShadowManager);
 311       if (m->Initialize()) {
 312         mLayerManager = m;
 313       }
 314     }
 315 #endif
 316     if (!mLayerManager) {
 317       mLayerManager = new BasicShadowLayerManager(this);
 318       mLayerManager->AsShadowForwarder()->SetShadowManager(aShadowManager);
 319     }
 320   }
 321   if (aAllowRetaining) {
 322     *aAllowRetaining = true;
 323   }
 324   return mLayerManager;
 325 }
 326
 327 gfxASurface*
 328 PuppetWidget::GetThebesSurface()
 329 {
 330   return mSurface;
 331 }
 332
 333 nsresult
 334 PuppetWidget::IMEEndComposition(bool aCancel)
 335 {
 336   nsEventStatus status;
 337   nsTextEvent textEvent(true, NS_TEXT_TEXT, this);
 338   InitEvent(textEvent, nullptr);
 339   textEvent.seqno = mIMELastReceivedSeqno;
 340   // SendEndIMEComposition is always called since ResetInputState
 341   // should always be called even if we aren't composing something.
 342   if (!mTabChild ||
 343       !mTabChild->SendEndIMEComposition(aCancel, &textEvent.theText)) {
 344     return NS_ERROR_FAILURE;
 345   }
 346
 347   if (!mIMEComposing)
 348     return NS_OK;
 349
 350   DispatchEvent(&textEvent, status);
 351
 352   nsCompositionEvent compEvent(true, NS_COMPOSITION_END, this);
 353   InitEvent(compEvent, nullptr);
 354   compEvent.seqno = mIMELastReceivedSeqno;
 355   DispatchEvent(&compEvent, status);
 356   return NS_OK;
 357 }
 358
 359 NS_IMETHODIMP
 360 PuppetWidget::ResetInputState()
 361 {
 362   return IMEEndComposition(false);
 363 }
 364
 365 NS_IMETHODIMP
 366 PuppetWidget::CancelComposition()
 367 {
 368   return IMEEndComposition(true);
 369 }
 370
 371 NS_IMETHODIMP_(void)
 372 PuppetWidget::SetInputContext(const InputContext& aContext,
 373                               const InputContextAction& aAction)
 374 {
 375   if (!mTabChild) {
 376     return;
 377   }
 378   mTabChild->SendSetInputContext(
 379     static_cast<int32_t>(aContext.mIMEState.mEnabled),
 380     static_cast<int32_t>(aContext.mIMEState.mOpen),
 381     aContext.mHTMLInputType,
 382     aContext.mHTMLInputInputmode,
 383     aContext.mActionHint,
 384     static_cast<int32_t>(aAction.mCause),
 385     static_cast<int32_t>(aAction.mFocusChange));
 386 }
 387
 388 NS_IMETHODIMP_(InputContext)
 389 PuppetWidget::GetInputContext()
 390 {
 391   InputContext context;
 392   if (mTabChild) {
 393     int32_t enabled, open;
 394     mTabChild->SendGetInputContext(&enabled, &open);
 395     context.mIMEState.mEnabled = static_cast<IMEState::Enabled>(enabled);
 396     context.mIMEState.mOpen = static_cast<IMEState::Open>(open);
 397   }
 398   return context;
 399 }
 400
 401 NS_IMETHODIMP
 402 PuppetWidget::OnIMEFocusChange(bool aFocus)
 403 {
 404   if (!mTabChild)
 405     return NS_ERROR_FAILURE;
 406
 407   if (aFocus) {
 408     nsEventStatus status;
 409     nsQueryContentEvent queryEvent(true, NS_QUERY_TEXT_CONTENT, this);
 410     InitEvent(queryEvent, nullptr);
 411     // Query entire content
 412     queryEvent.InitForQueryTextContent(0, UINT32_MAX);
 413     DispatchEvent(&queryEvent, status);
 414
 415     if (queryEvent.mSucceeded) {
 416       mTabChild->SendNotifyIMETextHint(queryEvent.mReply.mString);
 417     }
 418   } else {
 419     // ResetInputState might not have been called yet
 420     ResetInputState();
 421   }
 422
 423   uint32_t chromeSeqno;
 424   mIMEPreference.mWantUpdates = false;
 425   mIMEPreference.mWantHints = false;
 426   if (!mTabChild->SendNotifyIMEFocus(aFocus, &mIMEPreference, &chromeSeqno))
 427     return NS_ERROR_FAILURE;
 428
 429   if (aFocus) {
 430     if (!mIMEPreference.mWantUpdates && !mIMEPreference.mWantHints)
 431       // call OnIMEFocusChange on blur but no other updates
 432       return NS_SUCCESS_IME_NO_UPDATES;
 433     OnIMESelectionChange(); // Update selection
 434   } else {
 435     mIMELastBlurSeqno = chromeSeqno;
 436   }
 437   return NS_OK;
 438 }
 439
 440 NS_IMETHODIMP
 441 PuppetWidget::OnIMETextChange(uint32_t aStart, uint32_t aEnd, uint32_t aNewEnd)
 442 {
 443   if (!mTabChild)
 444     return NS_ERROR_FAILURE;
 445
 446   if (mIMEPreference.mWantHints) {
 447     nsEventStatus status;
 448     nsQueryContentEvent queryEvent(true, NS_QUERY_TEXT_CONTENT, this);
 449     InitEvent(queryEvent, nullptr);
 450     queryEvent.InitForQueryTextContent(0, UINT32_MAX);
 451     DispatchEvent(&queryEvent, status);
 452
 453     if (queryEvent.mSucceeded) {
 454       mTabChild->SendNotifyIMETextHint(queryEvent.mReply.mString);
 455     }
 456   }
 457   if (mIMEPreference.mWantUpdates) {
 458     mTabChild->SendNotifyIMETextChange(aStart, aEnd, aNewEnd);
 459   }
 460   return NS_OK;
 461 }
 462
 463 NS_IMETHODIMP
 464 PuppetWidget::OnIMESelectionChange(void)
 465 {
 466   if (!mTabChild)
 467     return NS_ERROR_FAILURE;
 468
 469   if (mIMEPreference.mWantUpdates) {
 470     nsEventStatus status;
 471     nsQueryContentEvent queryEvent(true, NS_QUERY_SELECTED_TEXT, this);
 472     InitEvent(queryEvent, nullptr);
 473     DispatchEvent(&queryEvent, status);
 474
 475     if (queryEvent.mSucceeded) {
 476       mTabChild->SendNotifyIMESelection(mIMELastReceivedSeqno,
 477                                         queryEvent.GetSelectionStart(),
 478                                         queryEvent.GetSelectionEnd());
 479     }
 480   }
 481   return NS_OK;
 482 }
 483
 484 NS_IMETHODIMP
 485 PuppetWidget::SetCursor(nsCursor aCursor)
 486 {
 487   if (mCursor == aCursor) {
 488     return NS_OK;
 489   }
 490
 491   if (!mTabChild ||
 492       !mTabChild->SendSetCursor(aCursor)) {
 493     return NS_ERROR_FAILURE;
 494   }
 495
 496   mCursor = aCursor;
 497
 498   return NS_OK;
 499 }
 500
 501 nsresult
 502 PuppetWidget::Paint()
 503 {
 504   NS_ABORT_IF_FALSE(!mDirtyRegion.IsEmpty(), "paint event logic messed up");
 505
 506   if (!mAttachedWidgetListener)
 507     return NS_OK;
 508
 509   nsIntRegion region = mDirtyRegion;
 510
 511   // reset repaint tracking
 512   mDirtyRegion.SetEmpty();
 513   mPaintTask.Revoke();
 514
 515   {
 516 #ifdef DEBUG
 517     debug_DumpPaintEvent(stderr, this, region,
 518                          nsAutoCString("PuppetWidget"), 0);
 519 #endif
 520
 521     if (mozilla::layers::LAYERS_D3D10 == mLayerManager->GetBackendType()) {
 522       mAttachedWidgetListener->PaintWindow(this, region, false, true);
 523     } else {
 524       nsRefPtr<gfxContext> ctx = new gfxContext(mSurface);
 525       ctx->Rectangle(gfxRect(0,0,0,0));
 526       ctx->Clip();
 527       AutoLayerManagerSetup setupLayerManager(this, ctx,
 528                                               BUFFER_NONE);
 529       mAttachedWidgetListener->PaintWindow(this, region, false, true);
 530       mTabChild->NotifyPainted();
 531     }
 532   }
 533
 534   if (mAttachedWidgetListener) {
 535     mAttachedWidgetListener->DidPaintWindow();
 536   }
 537
 538   return NS_OK;
 539 }
 540
 541 void
 542 PuppetWidget::SetChild(PuppetWidget* aChild)
 543 {
 544   NS_ABORT_IF_FALSE(this != aChild, "can't parent a widget to itself");
 545   NS_ABORT_IF_FALSE(!aChild->mChild,
 546                     "fake widget 'hierarchy' only expected to have one level");
 547
 548   mChild = aChild;
 549 }
 550
 551 NS_IMETHODIMP
 552 PuppetWidget::PaintTask::Run()
 553 {
 554   if (mWidget) {
 555     mWidget->Paint();
 556   }
 557   return NS_OK;
 558 }
 559
 560 bool
 561 PuppetWidget::NeedsPaint()
 562 {
 563   return mVisible;
 564 }
 565
 566 float
 567 PuppetWidget::GetDPI()
 568 {
 569   if (mDPI < 0) {
 570     NS_ABORT_IF_FALSE(mTabChild, "Need TabChild to get the DPI from!");
 571     mTabChild->GetDPI(&mDPI);
 572   }
 573
 574   return mDPI;
 575 }
 576
 577 void*
 578 PuppetWidget::GetNativeData(uint32_t aDataType)
 579 {
 580   switch (aDataType) {
 581   case NS_NATIVE_SHAREABLE_WINDOW: {
 582     NS_ABORT_IF_FALSE(mTabChild, "Need TabChild to get the nativeWindow from!");
 583     mozilla::WindowsHandle nativeData = 0;
 584     mTabChild->SendGetWidgetNativeData(&nativeData);
 585     return (void*)nativeData;
 586   }
 587   case NS_NATIVE_WINDOW:
 588   case NS_NATIVE_DISPLAY:
 589   case NS_NATIVE_PLUGIN_PORT:
 590   case NS_NATIVE_GRAPHIC:
 591   case NS_NATIVE_SHELLWIDGET:
 592   case NS_NATIVE_WIDGET:
 593     NS_WARNING("nsWindow::GetNativeData not implemented for this type");
 594     break;
 595   default:
 596     NS_WARNING("nsWindow::GetNativeData called with bad value");
 597     break;
 598   }
 599   return nullptr;
 600 }
 601
 602 PuppetScreen::PuppetScreen(void *nativeScreen)
 603 {
 604 }
 605
 606 PuppetScreen::~PuppetScreen()
 607 {
 608 }
 609
 610 static ScreenConfiguration
 611 ScreenConfig()
 612 {
 613   ScreenConfiguration config;
 614   hal::GetCurrentScreenConfiguration(&config);
 615   return config;
 616 }
 617
 618 NS_IMETHODIMP
 619 PuppetScreen::GetRect(int32_t *outLeft,  int32_t *outTop,
 620                       int32_t *outWidth, int32_t *outHeight)
 621 {
 622   nsIntRect r = ScreenConfig().rect();
 623   *outLeft = r.x;
 624   *outTop = r.y;
 625   *outWidth = r.width;
 626   *outHeight = r.height;
 627   return NS_OK;
 628 }
 629
 630 NS_IMETHODIMP
 631 PuppetScreen::GetAvailRect(int32_t *outLeft,  int32_t *outTop,
 632                            int32_t *outWidth, int32_t *outHeight)
 633 {
 634   return GetRect(outLeft, outTop, outWidth, outHeight);
 635 }
 636
 637
 638 NS_IMETHODIMP
 639 PuppetScreen::GetPixelDepth(int32_t *aPixelDepth)
 640 {
 641   *aPixelDepth = ScreenConfig().pixelDepth();
 642   return NS_OK;
 643 }
 644
 645 NS_IMETHODIMP
 646 PuppetScreen::GetColorDepth(int32_t *aColorDepth)
 647 {
 648   *aColorDepth = ScreenConfig().colorDepth();
 649   return NS_OK;
 650 }
 651
 652 NS_IMETHODIMP
 653 PuppetScreen::GetRotation(uint32_t* aRotation)
 654 {
 655   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.");
 656   return NS_ERROR_NOT_AVAILABLE;
 657 }
 658
 659 NS_IMETHODIMP
 660 PuppetScreen::SetRotation(uint32_t aRotation)
 661 {
 662   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.");
 663   return NS_ERROR_NOT_AVAILABLE;
 664 }
 665
 666 NS_IMPL_ISUPPORTS1(PuppetScreenManager, nsIScreenManager)
 667
 668 PuppetScreenManager::PuppetScreenManager()
 669 {
 670     mOneScreen = new PuppetScreen(nullptr);
 671 }
 672
 673 PuppetScreenManager::~PuppetScreenManager()
 674 {
 675 }
 676
 677 NS_IMETHODIMP
 678 PuppetScreenManager::GetPrimaryScreen(nsIScreen** outScreen)
 679 {
 680   NS_IF_ADDREF(*outScreen = mOneScreen.get());
 681   return NS_OK;
 682 }
 683
 684 NS_IMETHODIMP
 685 PuppetScreenManager::ScreenForRect(int32_t inLeft,
 686                                    int32_t inTop,
 687                                    int32_t inWidth,
 688                                    int32_t inHeight,
 689                                    nsIScreen** outScreen)
 690 {
 691   return GetPrimaryScreen(outScreen);
 692 }
 693
 694 NS_IMETHODIMP
 695 PuppetScreenManager::ScreenForNativeWidget(void* aWidget,
 696                                            nsIScreen** outScreen)
 697 {
 698   return GetPrimaryScreen(outScreen);
 699 }
 700
 701 NS_IMETHODIMP
 702 PuppetScreenManager::GetNumberOfScreens(uint32_t* aNumberOfScreens)
 703 {
 704   *aNumberOfScreens = 1;
 705   return NS_OK;
 706 }
 707
 708 }  // namespace widget
 709 }  // namespace mozilla