The Tor Browser: widget/gonk/nsWindow.cpp@b8a032363ba2 (annotated)

widget/gonk/nsWindow.cpp@b8a032363ba2 (annotated)

widget/gonk/nsWindow.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* Copyright 2012 Mozilla Foundation and Mozilla contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include "mozilla/DebugOnly.h"
 #include <fcntl.h>
 #include "android/log.h"
 #include "mozilla/dom/TabParent.h"
 #include "mozilla/Hal.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/FileUtils.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "Framebuffer.h"
 #include "gfxContext.h"
 #include "gfxPlatform.h"
 #include "gfxUtils.h"
 #include "GLContextProvider.h"
 #include "GLContext.h"
 #include "nsAutoPtr.h"
 #include "nsAppShell.h"
 #include "nsIdleService.h"
 #include "nsScreenManagerGonk.h"
 #include "nsTArray.h"
 #include "nsWindow.h"
 #include "nsIWidgetListener.h"
 #include "cutils/properties.h"
 #include "ClientLayerManager.h"
 #include "BasicLayers.h"
 #include "libdisplay/GonkDisplay.h"
 #include "pixelflinger/format.h"
 #include "mozilla/BasicEvents.h"
 #include "mozilla/layers/APZCTreeManager.h"
 #include "mozilla/layers/CompositorParent.h"
 #include "ParentProcessController.h"
 #include "nsThreadUtils.h"
 #include "HwcComposer2D.h"
 #define LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "Gonk" , ## args)
 #define LOGW(args...) __android_log_print(ANDROID_LOG_WARN, "Gonk", ## args)
 #define LOGE(args...) __android_log_print(ANDROID_LOG_ERROR, "Gonk", ## args)
 #define IS_TOPLEVEL() (mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog)
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::hal;
 using namespace mozilla::gl;
 using namespace mozilla::layers;
 using namespace mozilla::widget;
 nsIntRect gScreenBounds;
 static uint32_t sScreenRotation;
 static uint32_t sPhysicalScreenRotation;
 static nsIntRect sVirtualBounds;
 static nsRefPtr<GLContext> sGLContext;
 static nsTArray<nsWindow *> sTopWindows;
 static nsWindow *gFocusedWindow = nullptr;
 static bool sFramebufferOpen;
 static bool sUsingOMTC;
 static bool sUsingHwc;
 static bool sScreenInitialized;
 static nsRefPtr<gfxASurface> sOMTCSurface;
 namespace {
 static uint32_t
 EffectiveScreenRotation()
 {
     return (sScreenRotation + sPhysicalScreenRotation) % (360 / 90);
 }
 class ScreenOnOffEvent : public nsRunnable {
 public:
     ScreenOnOffEvent(bool on)
         : mIsOn(on)
     {}
     NS_IMETHOD Run() {
         for (uint32_t i = 0; i < sTopWindows.Length(); i++) {
             nsWindow *win = sTopWindows[i];
             if (nsIWidgetListener* listener = win->GetWidgetListener()) {
                 listener->SizeModeChanged(mIsOn ? nsSizeMode_Fullscreen : nsSizeMode_Minimized);
             }
         }
         // Notify observers that the screen state has just changed.
         nsCOMPtr<nsIObserverService> observerService = mozilla::services::GetObserverService();
         if (observerService) {
           observerService->NotifyObservers(
             nullptr, "screen-state-changed",
             mIsOn ? MOZ_UTF16("on") : MOZ_UTF16("off")
           );
         }
         return NS_OK;
     }
 private:
     bool mIsOn;
 };
 static StaticRefPtr<ScreenOnOffEvent> sScreenOnEvent;
 static StaticRefPtr<ScreenOnOffEvent> sScreenOffEvent;
 static void
 displayEnabledCallback(bool enabled)
 {
     NS_DispatchToMainThread(enabled ? sScreenOnEvent : sScreenOffEvent);
 }
 } // anonymous namespace
 nsWindow::nsWindow()
 {
     if (!sScreenInitialized) {
         sScreenOnEvent = new ScreenOnOffEvent(true);
         ClearOnShutdown(&sScreenOnEvent);
         sScreenOffEvent = new ScreenOnOffEvent(false);
         ClearOnShutdown(&sScreenOffEvent);
         GetGonkDisplay()->OnEnabled(displayEnabledCallback);
         nsIntSize screenSize;
         bool gotFB = Framebuffer::GetSize(&screenSize);
         if (!gotFB) {
             NS_RUNTIMEABORT("Failed to get size from framebuffer, aborting...");
         }
         gScreenBounds = nsIntRect(nsIntPoint(0, 0), screenSize);
         char propValue[PROPERTY_VALUE_MAX];
         property_get("ro.sf.hwrotation", propValue, "0");
         sPhysicalScreenRotation = atoi(propValue) / 90;
         sVirtualBounds = gScreenBounds;
         sScreenInitialized = true;
         nsAppShell::NotifyScreenInitialized();
         // This is a hack to force initialization of the compositor
         // resources, if we're going to use omtc.
         //
         // NB: GetPlatform() will create the gfxPlatform, which wants
         // to know the color depth, which asks our native window.
         // This has to happen after other init has finished.
         gfxPlatform::GetPlatform();
         sUsingOMTC = ShouldUseOffMainThreadCompositing();
         property_get("ro.display.colorfill", propValue, "0");
         //Update sUsingHwc whenever layers.composer2d.enabled changes
         Preferences::AddBoolVarCache(&sUsingHwc, "layers.composer2d.enabled");
         if (sUsingOMTC) {
           sOMTCSurface = new gfxImageSurface(gfxIntSize(1, 1),
                                              gfxImageFormat::RGB24);
         }
     }
 }
 nsWindow::~nsWindow()
 {
 }
 void
 nsWindow::DoDraw(void)
 {
     if (!hal::GetScreenEnabled()) {
         gDrawRequest = true;
         return;
     }
     if (sTopWindows.IsEmpty()) {
         LOG("  no window to draw, bailing");
         return;
     }
     nsWindow *targetWindow = (nsWindow *)sTopWindows[0];
     while (targetWindow->GetLastChild())
         targetWindow = (nsWindow *)targetWindow->GetLastChild();
     nsIWidgetListener* listener = targetWindow->GetWidgetListener();
     if (listener) {
         listener->WillPaintWindow(targetWindow);
     }
     LayerManager* lm = targetWindow->GetLayerManager();
     if (mozilla::layers::LayersBackend::LAYERS_CLIENT == lm->GetBackendType()) {
       // No need to do anything, the compositor will handle drawing
     } else if (mozilla::layers::LayersBackend::LAYERS_BASIC == lm->GetBackendType()) {
         MOZ_ASSERT(sFramebufferOpen || sUsingOMTC);
         nsRefPtr<gfxASurface> targetSurface;
         if(sUsingOMTC)
             targetSurface = sOMTCSurface;
         else
             targetSurface = Framebuffer::BackBuffer();
         {
             nsRefPtr<gfxContext> ctx = new gfxContext(targetSurface);
             gfxUtils::PathFromRegion(ctx, sVirtualBounds);
             ctx->Clip();
             // No double-buffering needed.
             AutoLayerManagerSetup setupLayerManager(
                 targetWindow, ctx, mozilla::layers::BufferMode::BUFFER_NONE,
                 ScreenRotation(EffectiveScreenRotation()));
             listener = targetWindow->GetWidgetListener();
             if (listener) {
                 listener->PaintWindow(targetWindow, sVirtualBounds);
             }
         }
         if (!sUsingOMTC) {
             targetSurface->Flush();
             Framebuffer::Present(sVirtualBounds);
         }
     } else {
         NS_RUNTIMEABORT("Unexpected layer manager type");
     }
     listener = targetWindow->GetWidgetListener();
     if (listener) {
         listener->DidPaintWindow();
     }
 }
 nsEventStatus
 nsWindow::DispatchInputEvent(WidgetGUIEvent& aEvent, bool* aWasCaptured)
 {
     if (aWasCaptured) {
         *aWasCaptured = false;
     }
     if (!gFocusedWindow) {
         return nsEventStatus_eIgnore;
     }
     gFocusedWindow->UserActivity();
     aEvent.widget = gFocusedWindow;
     if (TabParent* capturer = TabParent::GetEventCapturer()) {
         bool captured = capturer->TryCapture(aEvent);
         if (aWasCaptured) {
             *aWasCaptured = captured;
         }
         if (captured) {
             return nsEventStatus_eConsumeNoDefault;
         }
     }
     nsEventStatus status;
     gFocusedWindow->DispatchEvent(&aEvent, status);
     return status;
 }
 NS_IMETHODIMP
 nsWindow::Create(nsIWidget *aParent,
                  void *aNativeParent,
                  const nsIntRect &aRect,
                  nsDeviceContext *aContext,
                  nsWidgetInitData *aInitData)
 {
     BaseCreate(aParent, IS_TOPLEVEL() ? sVirtualBounds : aRect,
                aContext, aInitData);
     mBounds = aRect;
     mParent = (nsWindow *)aParent;
     mVisible = false;
     if (!aParent) {
         mBounds = sVirtualBounds;
     }
     if (!IS_TOPLEVEL())
         return NS_OK;
     sTopWindows.AppendElement(this);
     Resize(0, 0, sVirtualBounds.width, sVirtualBounds.height, false);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::Destroy(void)
 {
     mOnDestroyCalled = true;
     sTopWindows.RemoveElement(this);
     if (this == gFocusedWindow)
         gFocusedWindow = nullptr;
     nsBaseWidget::OnDestroy();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::Show(bool aState)
 {
     if (mWindowType == eWindowType_invisible)
         return NS_OK;
     if (mVisible == aState)
         return NS_OK;
     mVisible = aState;
     if (!IS_TOPLEVEL())
         return mParent ? mParent->Show(aState) : NS_OK;
     if (aState) {
         BringToTop();
     } else {
         for (unsigned int i = 0; i < sTopWindows.Length(); i++) {
             nsWindow *win = sTopWindows[i];
             if (!win->mVisible)
                 continue;
             win->BringToTop();
             break;
         }
     }
     return NS_OK;
 }
 bool
 nsWindow::IsVisible() const
 {
     return mVisible;
 }
 NS_IMETHODIMP
 nsWindow::ConstrainPosition(bool aAllowSlop,
                             int32_t *aX,
                             int32_t *aY)
 {
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::Move(double aX,
                double aY)
 {
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::Resize(double aWidth,
                  double aHeight,
                  bool   aRepaint)
 {
     return Resize(0, 0, aWidth, aHeight, aRepaint);
 }
 NS_IMETHODIMP
 nsWindow::Resize(double aX,
                  double aY,
                  double aWidth,
                  double aHeight,
                  bool   aRepaint)
 {
     mBounds = nsIntRect(NSToIntRound(aX), NSToIntRound(aY),
                         NSToIntRound(aWidth), NSToIntRound(aHeight));
     if (mWidgetListener)
         mWidgetListener->WindowResized(this, mBounds.width, mBounds.height);
     if (aRepaint)
         Invalidate(sVirtualBounds);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::Enable(bool aState)
 {
     return NS_OK;
 }
 bool
 nsWindow::IsEnabled() const
 {
     return true;
 }
 NS_IMETHODIMP
 nsWindow::SetFocus(bool aRaise)
 {
     if (aRaise)
         BringToTop();
     gFocusedWindow = this;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::ConfigureChildren(const nsTArray<nsIWidget::Configuration>&)
 {
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::Invalidate(const nsIntRect &aRect)
 {
     nsWindow *top = mParent;
     while (top && top->mParent)
         top = top->mParent;
     if (top != sTopWindows[0] && this != sTopWindows[0])
         return NS_OK;
     gDrawRequest = true;
     mozilla::NotifyEvent();
     return NS_OK;
 }
 nsIntPoint
 nsWindow::WidgetToScreenOffset()
 {
     nsIntPoint p(0, 0);
     nsWindow *w = this;
     while (w && w->mParent) {
         p.x += w->mBounds.x;
         p.y += w->mBounds.y;
         w = w->mParent;
     }
     return p;
 }
 void*
 nsWindow::GetNativeData(uint32_t aDataType)
 {
     switch (aDataType) {
     case NS_NATIVE_WINDOW:
         return GetGonkDisplay()->GetNativeWindow();
     }
     return nullptr;
 }
 NS_IMETHODIMP
 nsWindow::DispatchEvent(WidgetGUIEvent* aEvent, nsEventStatus& aStatus)
 {
     if (mWidgetListener)
       aStatus = mWidgetListener->HandleEvent(aEvent, mUseAttachedEvents);
     return NS_OK;
 }
 NS_IMETHODIMP_(void)
 nsWindow::SetInputContext(const InputContext& aContext,
                           const InputContextAction& aAction)
 {
     mInputContext = aContext;
 }
 NS_IMETHODIMP_(InputContext)
 nsWindow::GetInputContext()
 {
     // There is only one IME context on Gonk.
     mInputContext.mNativeIMEContext = nullptr;
     return mInputContext;
 }
 NS_IMETHODIMP
 nsWindow::ReparentNativeWidget(nsIWidget* aNewParent)
 {
     return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::MakeFullScreen(bool aFullScreen)
 {
     if (mWindowType != eWindowType_toplevel) {
         // Ignore fullscreen request for non-toplevel windows.
         NS_WARNING("MakeFullScreen() on a dialog or child widget?");
         return nsBaseWidget::MakeFullScreen(aFullScreen);
     }
     if (aFullScreen) {
         // Fullscreen is "sticky" for toplevel widgets on gonk: we
         // must paint the entire screen, and should only have one
         // toplevel widget, so it doesn't make sense to ever "exit"
         // fullscreen.  If we do, we can leave parts of the screen
         // unpainted.
         Resize(sVirtualBounds.x, sVirtualBounds.y,
                sVirtualBounds.width, sVirtualBounds.height,
                /*repaint*/true);
     }
     return NS_OK;
 }
 float
 nsWindow::GetDPI()
 {
     return GetGonkDisplay()->xdpi;
 }
 double
 nsWindow::GetDefaultScaleInternal()
 {
     float dpi = GetDPI();
     // The mean pixel density for mdpi devices is 160dpi, 240dpi for hdpi,
     // and 320dpi for xhdpi, respectively.
     // We'll take the mid-value between these three numbers as the boundary.
     if (dpi < 200.0) {
         return 1.0; // mdpi devices.
     }
     if (dpi < 300.0) {
         return 1.5; // hdpi devices.
     }
     // xhdpi devices and beyond.
     return floor(dpi / 150.0 + 0.5);
 }
 LayerManager *
 nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
                           LayersBackend aBackendHint,
                           LayerManagerPersistence aPersistence,
                           bool* aAllowRetaining)
 {
     if (aAllowRetaining)
         *aAllowRetaining = true;
     if (mLayerManager) {
         // This layer manager might be used for painting outside of DoDraw(), so we need
         // to set the correct rotation on it.
         if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) {
             BasicLayerManager* manager =
                 static_cast<BasicLayerManager*>(mLayerManager.get());
             manager->SetDefaultTargetConfiguration(mozilla::layers::BufferMode::BUFFER_NONE,
                                                    ScreenRotation(EffectiveScreenRotation()));
         } else if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT) {
             ClientLayerManager* manager =
                 static_cast<ClientLayerManager*>(mLayerManager.get());
             manager->SetDefaultTargetConfiguration(mozilla::layers::BufferMode::BUFFER_NONE,
                                                    ScreenRotation(EffectiveScreenRotation()));
         }
         return mLayerManager;
     }
     // Set mUseLayersAcceleration here to make it consistent with
     // nsBaseWidget::GetLayerManager
     mUseLayersAcceleration = ComputeShouldAccelerate(mUseLayersAcceleration);
     nsWindow *topWindow = sTopWindows[0];
     if (!topWindow) {
         LOGW(" -- no topwindow\n");
         return nullptr;
     }
     if (sUsingOMTC) {
         CreateCompositor();
         if (mCompositorParent) {
             uint64_t rootLayerTreeId = mCompositorParent->RootLayerTreeId();
             CompositorParent::SetControllerForLayerTree(rootLayerTreeId, new ParentProcessController());
             CompositorParent::GetAPZCTreeManager(rootLayerTreeId)->SetDPI(GetDPI());
         }
         if (mLayerManager)
             return mLayerManager;
     }
     if (mUseLayersAcceleration) {
         DebugOnly<nsIntRect> fbBounds = gScreenBounds;
         if (!sGLContext) {
             sGLContext = GLContextProvider::CreateForWindow(this);
         }
         MOZ_ASSERT(fbBounds.value == gScreenBounds);
     }
     // Fall back to software rendering.
     sFramebufferOpen = Framebuffer::Open();
     if (sFramebufferOpen) {
         LOG("Falling back to framebuffer software rendering");
     } else {
         LOGE("Failed to mmap fb(?!?), aborting ...");
         NS_RUNTIMEABORT("Can't open GL context and can't fall back on /dev/graphics/fb0 ...");
     }
     mLayerManager = new ClientLayerManager(this);
     mUseLayersAcceleration = false;
     return mLayerManager;
 }
 gfxASurface *
 nsWindow::GetThebesSurface()
 {
     /* This is really a dummy surface; this is only used when doing reflow, because
      * we need a RenderingContext to measure text against.
      */
     // XXX this really wants to return already_AddRefed, but this only really gets used
     // on direct assignment to a gfxASurface
     return new gfxImageSurface(gfxIntSize(5,5), gfxImageFormat::RGB24);
 }
 void
 nsWindow::BringToTop()
 {
     if (!sTopWindows.IsEmpty()) {
         if (nsIWidgetListener* listener = sTopWindows[0]->GetWidgetListener())
             listener->WindowDeactivated();
     }
     sTopWindows.RemoveElement(this);
     sTopWindows.InsertElementAt(0, this);
     if (mWidgetListener)
         mWidgetListener->WindowActivated();
     Invalidate(sVirtualBounds);
 }
 void
 nsWindow::UserActivity()
 {
     if (!mIdleService) {
         mIdleService = do_GetService("@mozilla.org/widget/idleservice;1");
     }
     if (mIdleService) {
         mIdleService->ResetIdleTimeOut(0);
     }
 }
 uint32_t
 nsWindow::GetGLFrameBufferFormat()
 {
     if (mLayerManager &&
         mLayerManager->GetBackendType() == mozilla::layers::LayersBackend::LAYERS_OPENGL) {
         // We directly map the hardware fb on Gonk.  The hardware fb
         // has RGB format.
         return LOCAL_GL_RGB;
     }
     return LOCAL_GL_NONE;
 }
 nsIntRect
 nsWindow::GetNaturalBounds()
 {
     return gScreenBounds;
 }
 bool
 nsWindow::NeedsPaint()
 {
   if (!mLayerManager) {
     return false;
   }
   return nsIWidget::NeedsPaint();
 }
 Composer2D*
 nsWindow::GetComposer2D()
 {
     if (!sUsingHwc) {
         return nullptr;
     }
     if (HwcComposer2D* hwc = HwcComposer2D::GetInstance()) {
         return hwc->Initialized() ? hwc : nullptr;
     }
     return nullptr;
 }
 // nsScreenGonk.cpp
 nsScreenGonk::nsScreenGonk(void *nativeScreen)
 {
 }
 nsScreenGonk::~nsScreenGonk()
 {
 }
 NS_IMETHODIMP
 nsScreenGonk::GetRect(int32_t *outLeft,  int32_t *outTop,
                       int32_t *outWidth, int32_t *outHeight)
 {
     *outLeft = sVirtualBounds.x;
     *outTop = sVirtualBounds.y;
     *outWidth = sVirtualBounds.width;
     *outHeight = sVirtualBounds.height;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsScreenGonk::GetAvailRect(int32_t *outLeft,  int32_t *outTop,
                            int32_t *outWidth, int32_t *outHeight)
 {
     return GetRect(outLeft, outTop, outWidth, outHeight);
 }
 static uint32_t
 ColorDepth()
 {
     switch (GetGonkDisplay()->surfaceformat) {
     case GGL_PIXEL_FORMAT_RGB_565:
         return 16;
     case GGL_PIXEL_FORMAT_RGBA_8888:
         return 32;
     }
     return 24; // GGL_PIXEL_FORMAT_RGBX_8888
 }
 NS_IMETHODIMP
 nsScreenGonk::GetPixelDepth(int32_t *aPixelDepth)
 {
     // XXX: this should actually return 32 when we're using 24-bit
     // color, because we use RGBX.
     *aPixelDepth = ColorDepth();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsScreenGonk::GetColorDepth(int32_t *aColorDepth)
 {
     return GetPixelDepth(aColorDepth);
 }
 NS_IMETHODIMP
 nsScreenGonk::GetRotation(uint32_t* aRotation)
 {
     *aRotation = sScreenRotation;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsScreenGonk::SetRotation(uint32_t aRotation)
 {
     if (!(aRotation <= ROTATION_270_DEG))
         return NS_ERROR_ILLEGAL_VALUE;
     if (sScreenRotation == aRotation)
         return NS_OK;
     sScreenRotation = aRotation;
     uint32_t rotation = EffectiveScreenRotation();
     if (rotation == nsIScreen::ROTATION_90_DEG ||
         rotation == nsIScreen::ROTATION_270_DEG) {
         sVirtualBounds = nsIntRect(0, 0, gScreenBounds.height,
                                    gScreenBounds.width);
     } else {
         sVirtualBounds = gScreenBounds;
     }
     nsAppShell::NotifyScreenRotation();
     for (unsigned int i = 0; i < sTopWindows.Length(); i++)
         sTopWindows[i]->Resize(sVirtualBounds.width,
                                sVirtualBounds.height,
                                true);
     return NS_OK;
 }
 // NB: This isn't gonk-specific, but gonk is the only widget backend
 // that does this calculation itself, currently.
 static ScreenOrientation
 ComputeOrientation(uint32_t aRotation, const nsIntSize& aScreenSize)
 {
     bool naturallyPortrait = (aScreenSize.height > aScreenSize.width);
     switch (aRotation) {
     case nsIScreen::ROTATION_0_DEG:
         return (naturallyPortrait ? eScreenOrientation_PortraitPrimary :
                 eScreenOrientation_LandscapePrimary);
     case nsIScreen::ROTATION_90_DEG:
         // Arbitrarily choosing 90deg to be primary "unnatural"
         // rotation.
         return (naturallyPortrait ? eScreenOrientation_LandscapePrimary :
                 eScreenOrientation_PortraitPrimary);
     case nsIScreen::ROTATION_180_DEG:
         return (naturallyPortrait ? eScreenOrientation_PortraitSecondary :
                 eScreenOrientation_LandscapeSecondary);
     case nsIScreen::ROTATION_270_DEG:
         return (naturallyPortrait ? eScreenOrientation_LandscapeSecondary :
                 eScreenOrientation_PortraitSecondary);
     default:
         MOZ_CRASH("Gonk screen must always have a known rotation");
     }
 }
 /*static*/ uint32_t
 nsScreenGonk::GetRotation()
 {
     return sScreenRotation;
 }
 /*static*/ ScreenConfiguration
 nsScreenGonk::GetConfiguration()
 {
     ScreenOrientation orientation = ComputeOrientation(sScreenRotation,
                                                        gScreenBounds.Size());
     uint32_t colorDepth = ColorDepth();
     // NB: perpetuating colorDepth == pixelDepth illusion here, for
     // consistency.
     return ScreenConfiguration(sVirtualBounds, orientation,
                                colorDepth, colorDepth);
 }
 NS_IMPL_ISUPPORTS(nsScreenManagerGonk, nsIScreenManager)
 nsScreenManagerGonk::nsScreenManagerGonk()
 {
     mOneScreen = new nsScreenGonk(nullptr);
 }
 nsScreenManagerGonk::~nsScreenManagerGonk()
 {
 }
 NS_IMETHODIMP
 nsScreenManagerGonk::GetPrimaryScreen(nsIScreen **outScreen)
 {
     NS_IF_ADDREF(*outScreen = mOneScreen.get());
     return NS_OK;
 }
 NS_IMETHODIMP
 nsScreenManagerGonk::ScreenForRect(int32_t inLeft,
                                    int32_t inTop,
                                    int32_t inWidth,
                                    int32_t inHeight,
                                    nsIScreen **outScreen)
 {
     return GetPrimaryScreen(outScreen);
 }
 NS_IMETHODIMP
 nsScreenManagerGonk::ScreenForNativeWidget(void *aWidget, nsIScreen **outScreen)
 {
     return GetPrimaryScreen(outScreen);
 }
 NS_IMETHODIMP
 nsScreenManagerGonk::GetNumberOfScreens(uint32_t *aNumberOfScreens)
 {
     *aNumberOfScreens = 1;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsScreenManagerGonk::GetSystemDefaultScale(float *aDefaultScale)
 {
     *aDefaultScale = 1.0f;
     return NS_OK;
 }

The Tor Browser / annotate

widget/gonk/nsWindow.cpp@b8a032363ba2 (annotated)

widget/gonk/nsWindow.cpp