Add m-esr52 at 52.6.0

1 files changed, 744 insertions, 0 deletions

diff --git a/widget/gonk/nsWindow.cpp b/widget/gonk/nsWindow.cpp
new file mode 100644
index 000000000..e11b7f233
--- /dev/null
+++ b/widget/gonk/nsWindow.cpp
@@ -0,0 +1,744 @@
+/* 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 "nsWindow.h"
+
+#include "mozilla/DebugOnly.h"
+
+#include <fcntl.h>
+
+#include "android/log.h"
+#include "mozilla/dom/TabParent.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Services.h"
+#include "mozilla/FileUtils.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "gfxContext.h"
+#include "gfxPlatform.h"
+#include "GLContextProvider.h"
+#include "GLContext.h"
+#include "GLContextEGL.h"
+#include "nsAppShell.h"
+#include "nsScreenManagerGonk.h"
+#include "nsTArray.h"
+#include "nsIWidgetListener.h"
+#include "ClientLayerManager.h"
+#include "BasicLayers.h"
+#include "libdisplay/GonkDisplay.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/layers/APZCTreeManager.h"
+#include "mozilla/layers/APZThreadUtils.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/CompositorSession.h"
+#include "mozilla/TouchEvents.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::gfx;
+using namespace mozilla::gl;
+using namespace mozilla::layers;
+using namespace mozilla::widget;
+
+static nsWindow *gFocusedWindow = nullptr;
+
+NS_IMPL_ISUPPORTS_INHERITED0(nsWindow, nsBaseWidget)
+
+nsWindow::nsWindow()
+{
+    RefPtr<nsScreenManagerGonk> screenManager = nsScreenManagerGonk::GetInstance();
+    screenManager->Initialize();
+
+    // 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();
+    if (!ShouldUseOffMainThreadCompositing()) {
+        MOZ_CRASH("How can we render apps, then?");
+    }
+}
+
+nsWindow::~nsWindow()
+{
+    if (mScreen->IsPrimaryScreen()) {
+        mComposer2D->SetCompositorBridgeParent(nullptr);
+    }
+}
+
+void
+nsWindow::DoDraw(void)
+{
+    if (!hal::GetScreenEnabled()) {
+        gDrawRequest = true;
+        return;
+    }
+
+    RefPtr<nsScreenGonk> screen = nsScreenManagerGonk::GetPrimaryScreen();
+    const nsTArray<nsWindow*>& windows = screen->GetTopWindows();
+
+    if (windows.IsEmpty()) {
+        LOG("  no window to draw, bailing");
+        return;
+    }
+
+    RefPtr<nsWindow> targetWindow = (nsWindow *)windows[0];
+    while (targetWindow->GetLastChild()) {
+        targetWindow = (nsWindow *)targetWindow->GetLastChild();
+    }
+
+    nsIWidgetListener* listener = targetWindow->GetWidgetListener();
+    if (listener) {
+        listener->WillPaintWindow(targetWindow);
+    }
+
+    listener = targetWindow->GetWidgetListener();
+    if (listener) {
+        LayerManager* lm = targetWindow->GetLayerManager();
+        if (mozilla::layers::LayersBackend::LAYERS_CLIENT == lm->GetBackendType()) {
+            // No need to do anything, the compositor will handle drawing
+        } else {
+            NS_RUNTIMEABORT("Unexpected layer manager type");
+        }
+
+        listener->DidPaintWindow();
+    }
+}
+
+void
+nsWindow::ConfigureAPZControllerThread()
+{
+    APZThreadUtils::SetControllerThread(CompositorThreadHolder::Loop());
+}
+
+/*static*/ nsEventStatus
+nsWindow::DispatchKeyInput(WidgetKeyboardEvent& aEvent)
+{
+    if (!gFocusedWindow) {
+        return nsEventStatus_eIgnore;
+    }
+
+    gFocusedWindow->UserActivity();
+
+    nsEventStatus status;
+    aEvent.mWidget = gFocusedWindow;
+    gFocusedWindow->DispatchEvent(&aEvent, status);
+    return status;
+}
+
+/*static*/ void
+nsWindow::DispatchTouchInput(MultiTouchInput& aInput)
+{
+    APZThreadUtils::AssertOnControllerThread();
+
+    if (!gFocusedWindow) {
+        return;
+    }
+
+    gFocusedWindow->DispatchTouchInputViaAPZ(aInput);
+}
+
+class DispatchTouchInputOnMainThread : public mozilla::Runnable
+{
+public:
+    DispatchTouchInputOnMainThread(const MultiTouchInput& aInput,
+                                   const ScrollableLayerGuid& aGuid,
+                                   const uint64_t& aInputBlockId,
+                                   nsEventStatus aApzResponse)
+      : mInput(aInput)
+      , mGuid(aGuid)
+      , mInputBlockId(aInputBlockId)
+      , mApzResponse(aApzResponse)
+    {}
+
+    NS_IMETHOD Run() override {
+        if (gFocusedWindow) {
+            gFocusedWindow->DispatchTouchEventForAPZ(mInput, mGuid, mInputBlockId, mApzResponse);
+        }
+        return NS_OK;
+    }
+
+private:
+    MultiTouchInput mInput;
+    ScrollableLayerGuid mGuid;
+    uint64_t mInputBlockId;
+    nsEventStatus mApzResponse;
+};
+
+void
+nsWindow::DispatchTouchInputViaAPZ(MultiTouchInput& aInput)
+{
+    APZThreadUtils::AssertOnControllerThread();
+
+    if (!mAPZC) {
+        // In general mAPZC should not be null, but during initial setup
+        // it might be, so we handle that case by ignoring touch input there.
+        return;
+    }
+
+    // First send it through the APZ code
+    mozilla::layers::ScrollableLayerGuid guid;
+    uint64_t inputBlockId;
+    nsEventStatus result = mAPZC->ReceiveInputEvent(aInput, &guid, &inputBlockId);
+    // If the APZ says to drop it, then we drop it
+    if (result == nsEventStatus_eConsumeNoDefault) {
+        return;
+    }
+
+    // Can't use NS_NewRunnableMethod because it only takes up to one arg and
+    // we need more. Also we can't pass in |this| to the task because nsWindow
+    // refcounting is not threadsafe. Instead we just use the gFocusedWindow
+    // static ptr inside the task.
+    NS_DispatchToMainThread(new DispatchTouchInputOnMainThread(
+        aInput, guid, inputBlockId, result));
+}
+
+void
+nsWindow::DispatchTouchEventForAPZ(const MultiTouchInput& aInput,
+                                   const ScrollableLayerGuid& aGuid,
+                                   const uint64_t aInputBlockId,
+                                   nsEventStatus aApzResponse)
+{
+    MOZ_ASSERT(NS_IsMainThread());
+    UserActivity();
+
+    // Convert it to an event we can send to Gecko
+    WidgetTouchEvent event = aInput.ToWidgetTouchEvent(this);
+
+    // Dispatch the event into the gecko root process for "normal" flow.
+    // The event might get sent to a child process,
+    // but if it doesn't we need to notify the APZ of various things.
+    // All of that happens in ProcessUntransformedAPZEvent
+    ProcessUntransformedAPZEvent(&event, aGuid, aInputBlockId, aApzResponse);
+}
+
+class DispatchTouchInputOnControllerThread : public Runnable
+{
+public:
+    DispatchTouchInputOnControllerThread(const MultiTouchInput& aInput)
+      : mInput(aInput)
+    {}
+
+    NS_IMETHOD Run() override {
+        if (gFocusedWindow) {
+            gFocusedWindow->DispatchTouchInputViaAPZ(mInput);
+        }
+        return NS_OK;
+    }
+
+private:
+    MultiTouchInput mInput;
+};
+
+nsresult
+nsWindow::SynthesizeNativeTouchPoint(uint32_t aPointerId,
+                                     TouchPointerState aPointerState,
+                                     LayoutDeviceIntPoint aPoint,
+                                     double aPointerPressure,
+                                     uint32_t aPointerOrientation,
+                                     nsIObserver* aObserver)
+{
+    AutoObserverNotifier notifier(aObserver, "touchpoint");
+
+    if (aPointerState == TOUCH_HOVER) {
+        return NS_ERROR_UNEXPECTED;
+    }
+
+    if (!mSynthesizedTouchInput) {
+        mSynthesizedTouchInput = MakeUnique<MultiTouchInput>();
+    }
+
+    // We should probably use a real timestamp here, but this is B2G and
+    // so this probably never even exercised any more.
+    uint32_t time = 0;
+    TimeStamp timestamp = TimeStamp::FromSystemTime(time);
+
+    MultiTouchInput inputToDispatch = UpdateSynthesizedTouchState(
+        mSynthesizedTouchInput.get(), time, timestamp, aPointerId, aPointerState,
+        aPoint, aPointerPressure, aPointerOrientation);
+
+    // Can't use NewRunnableMethod here because that will pass a const-ref
+    // argument to DispatchTouchInputViaAPZ whereas that function takes a
+    // non-const ref. At this callsite we don't care about the mutations that
+    // the function performs so this is fine. Also we can't pass |this| to the
+    // task because nsWindow refcounting is not threadsafe. Instead we just use
+    // the gFocusedWindow static ptr instead the task.
+    APZThreadUtils::RunOnControllerThread(
+      MakeAndAddRef<DispatchTouchInputOnControllerThread>(inputToDispatch));
+
+    return NS_OK;
+}
+
+nsresult
+nsWindow::Create(nsIWidget* aParent,
+                 void* aNativeParent,
+                 const LayoutDeviceIntRect& aRect,
+                 nsWidgetInitData* aInitData)
+{
+    BaseCreate(aParent, aInitData);
+
+    nsCOMPtr<nsIScreen> screen;
+
+    uint32_t screenId = aParent ? ((nsWindow*)aParent)->mScreen->GetId() :
+                                  aInitData->mScreenId;
+
+    RefPtr<nsScreenManagerGonk> screenManager = nsScreenManagerGonk::GetInstance();
+    screenManager->ScreenForId(screenId, getter_AddRefs(screen));
+
+    mScreen = static_cast<nsScreenGonk*>(screen.get());
+
+    mBounds = aRect;
+
+    mParent = (nsWindow *)aParent;
+    mVisible = false;
+
+    if (!aParent) {
+        mBounds = mScreen->GetRect();
+    }
+
+    mComposer2D = HwcComposer2D::GetInstance();
+
+    if (!IS_TOPLEVEL()) {
+        return NS_OK;
+    }
+
+    mScreen->RegisterWindow(this);
+
+    Resize(0, 0, mBounds.width, mBounds.height, false);
+
+    return NS_OK;
+}
+
+void
+nsWindow::Destroy()
+{
+    mOnDestroyCalled = true;
+    mScreen->UnregisterWindow(this);
+    if (this == gFocusedWindow) {
+        gFocusedWindow = nullptr;
+    }
+    nsBaseWidget::OnDestroy();
+}
+
+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 {
+        const nsTArray<nsWindow*>& windows =
+            mScreen->GetTopWindows();
+        for (unsigned int i = 0; i < windows.Length(); i++) {
+            nsWindow *win = windows[i];
+            if (!win->mVisible) {
+                continue;
+            }
+            win->BringToTop();
+            break;
+        }
+    }
+
+    return NS_OK;
+}
+
+bool
+nsWindow::IsVisible() const
+{
+    return mVisible;
+}
+
+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 = LayoutDeviceIntRect(NSToIntRound(aX), NSToIntRound(aY),
+                                  NSToIntRound(aWidth), NSToIntRound(aHeight));
+    if (mWidgetListener) {
+        mWidgetListener->WindowResized(this, mBounds.width, mBounds.height);
+    }
+
+    if (aRepaint) {
+        Invalidate(mBounds);
+    }
+
+    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();
+    }
+
+    if (!IS_TOPLEVEL() && mScreen->IsPrimaryScreen()) {
+        // We should only set focused window on non-toplevel primary window.
+        gFocusedWindow = this;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindow::ConfigureChildren(const nsTArray<nsIWidget::Configuration>&)
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsWindow::Invalidate(const LayoutDeviceIntRect& aRect)
+{
+    nsWindow *top = mParent;
+    while (top && top->mParent) {
+        top = top->mParent;
+    }
+    const nsTArray<nsWindow*>& windows = mScreen->GetTopWindows();
+    if (top != windows[0] && this != windows[0]) {
+        return NS_OK;
+    }
+
+    gDrawRequest = true;
+    mozilla::NotifyEvent();
+    return NS_OK;
+}
+
+LayoutDeviceIntPoint
+nsWindow::WidgetToScreenOffset()
+{
+    LayoutDeviceIntPoint 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:
+        // Called before primary display's EGLSurface creation.
+        return mScreen->GetNativeWindow();
+    case NS_NATIVE_OPENGL_CONTEXT:
+        return mScreen->GetGLContext().take();
+    case NS_RAW_NATIVE_IME_CONTEXT: {
+        void* pseudoIMEContext = GetPseudoIMEContext();
+        if (pseudoIMEContext) {
+            return pseudoIMEContext;
+        }
+        // There is only one IME context on Gonk.
+        return NS_ONLY_ONE_NATIVE_IME_CONTEXT;
+    }
+    }
+
+    return nullptr;
+}
+
+void
+nsWindow::SetNativeData(uint32_t aDataType, uintptr_t aVal)
+{
+    switch (aDataType) {
+    case NS_NATIVE_OPENGL_CONTEXT:
+        GLContext* context = reinterpret_cast<GLContext*>(aVal);
+        if (!context) {
+            mScreen->SetEGLInfo(EGL_NO_DISPLAY,
+                                EGL_NO_SURFACE,
+                                nullptr);
+            return;
+        }
+        mScreen->SetEGLInfo(GLContextEGL::Cast(context)->GetEGLDisplay(),
+                            GLContextEGL::Cast(context)->GetEGLSurface(),
+                            context);
+        return;
+    }
+}
+
+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()
+{
+    return mInputContext;
+}
+
+nsresult
+nsWindow::MakeFullScreen(bool aFullScreen, nsIScreen*)
+{
+    if (mWindowType != eWindowType_toplevel) {
+        // Ignore fullscreen request for non-toplevel windows.
+        NS_WARNING("MakeFullScreen() on a dialog or child widget?");
+        nsBaseWidget::InfallibleMakeFullScreen(aFullScreen);
+        return NS_OK;
+    }
+
+    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.
+        nsIntRect virtualBounds;
+        mScreen->GetRect(&virtualBounds.x, &virtualBounds.y,
+                         &virtualBounds.width, &virtualBounds.height);
+        Resize(virtualBounds.x, virtualBounds.y,
+               virtualBounds.width, virtualBounds.height,
+               /*repaint*/true);
+    }
+
+    if (nsIWidgetListener* listener = GetWidgetListener()) {
+      listener->FullscreenChanged(aFullScreen);
+    }
+    return NS_OK;
+}
+
+already_AddRefed<DrawTarget>
+nsWindow::StartRemoteDrawing()
+{
+    RefPtr<DrawTarget> buffer = mScreen->StartRemoteDrawing();
+    return buffer.forget();
+}
+
+void
+nsWindow::EndRemoteDrawing()
+{
+    mScreen->EndRemoteDrawing();
+}
+
+float
+nsWindow::GetDPI()
+{
+    return mScreen->GetDpi();
+}
+
+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 < 280.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)
+{
+    if (mLayerManager) {
+        // This layer manager might be used for painting outside of DoDraw(), so we need
+        // to set the correct rotation on it.
+        if (ClientLayerManager* manager = mLayerManager->AsClientLayerManager()) {
+            uint32_t rotation = mScreen->EffectiveScreenRotation();
+            manager->SetDefaultTargetConfiguration(mozilla::layers::BufferMode::BUFFER_NONE,
+                                                   ScreenRotation(rotation));
+        }
+        return mLayerManager;
+    }
+
+    const nsTArray<nsWindow*>& windows = mScreen->GetTopWindows();
+    nsWindow *topWindow = windows[0];
+
+    if (!topWindow) {
+        LOGW(" -- no topwindow\n");
+        return nullptr;
+    }
+
+    CreateCompositor();
+    if (RefPtr<CompositorBridgeParent> bridge = GetCompositorBridgeParent()) {
+        mScreen->SetCompositorBridgeParent(bridge);
+        if (mScreen->IsPrimaryScreen()) {
+            mComposer2D->SetCompositorBridgeParent(bridge);
+        }
+    }
+    MOZ_ASSERT(mLayerManager);
+    return mLayerManager;
+}
+
+void
+nsWindow::DestroyCompositor()
+{
+    if (RefPtr<CompositorBridgeParent> bridge = GetCompositorBridgeParent()) {
+        mScreen->SetCompositorBridgeParent(nullptr);
+        if (mScreen->IsPrimaryScreen()) {
+            // Unset CompositorBridgeParent
+            mComposer2D->SetCompositorBridgeParent(nullptr);
+        }
+    }
+    nsBaseWidget::DestroyCompositor();
+}
+
+void
+nsWindow::BringToTop()
+{
+    const nsTArray<nsWindow*>& windows = mScreen->GetTopWindows();
+    if (!windows.IsEmpty()) {
+        if (nsIWidgetListener* listener = windows[0]->GetWidgetListener()) {
+            listener->WindowDeactivated();
+        }
+    }
+
+    mScreen->BringToTop(this);
+
+    if (mWidgetListener) {
+        mWidgetListener->WindowActivated();
+    }
+
+    Invalidate(mBounds);
+}
+
+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;
+}
+
+LayoutDeviceIntRect
+nsWindow::GetNaturalBounds()
+{
+    return mScreen->GetNaturalBounds();
+}
+
+nsScreenGonk*
+nsWindow::GetScreen()
+{
+    return mScreen;
+}
+
+bool
+nsWindow::NeedsPaint()
+{
+  if (!mLayerManager) {
+    return false;
+  }
+  return nsIWidget::NeedsPaint();
+}
+
+Composer2D*
+nsWindow::GetComposer2D()
+{
+    if (mScreen->GetDisplayType() == GonkDisplay::DISPLAY_VIRTUAL) {
+        return nullptr;
+    }
+
+    return mComposer2D;
+}
+
+CompositorBridgeParent*
+nsWindow::GetCompositorBridgeParent() const
+{
+    return mCompositorSession ? mCompositorSession->GetInProcessBridge() : nullptr;
+}