Add m-esr52 at 52.6.0

1 files changed, 688 insertions, 0 deletions

diff --git a/widget/android/nsAppShell.cpp b/widget/android/nsAppShell.cpp
new file mode 100644
index 000000000..fefd711d0
--- /dev/null
+++ b/widget/android/nsAppShell.cpp
@@ -0,0 +1,688 @@
+/* -*- Mode: c++; tab-width: 40; indent-tabs-mode: nil; c-basic-offset: 4; -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsAppShell.h"
+
+#include "base/basictypes.h"
+#include "base/message_loop.h"
+#include "base/task.h"
+#include "mozilla/Hal.h"
+#include "nsIScreen.h"
+#include "nsIScreenManager.h"
+#include "nsWindow.h"
+#include "nsThreadUtils.h"
+#include "nsICommandLineRunner.h"
+#include "nsIObserverService.h"
+#include "nsIAppStartup.h"
+#include "nsIGeolocationProvider.h"
+#include "nsCacheService.h"
+#include "nsIDOMEventListener.h"
+#include "nsIDOMClientRectList.h"
+#include "nsIDOMClientRect.h"
+#include "nsIDOMWakeLockListener.h"
+#include "nsIPowerManagerService.h"
+#include "nsISpeculativeConnect.h"
+#include "nsIURIFixup.h"
+#include "nsCategoryManagerUtils.h"
+#include "nsCDefaultURIFixup.h"
+#include "nsToolkitCompsCID.h"
+#include "nsGeoPosition.h"
+
+#include "mozilla/Services.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Hal.h"
+#include "prenv.h"
+
+#include "AndroidBridge.h"
+#include "AndroidBridgeUtilities.h"
+#include "GeneratedJNINatives.h"
+#include <android/log.h>
+#include <pthread.h>
+#include <wchar.h>
+
+#include "GeckoProfiler.h"
+#ifdef MOZ_ANDROID_HISTORY
+#include "nsNetUtil.h"
+#include "nsIURI.h"
+#include "IHistory.h"
+#endif
+
+#ifdef MOZ_LOGGING
+#include "mozilla/Logging.h"
+#endif
+
+#ifdef MOZ_CRASHREPORTER
+#include "nsICrashReporter.h"
+#include "nsExceptionHandler.h"
+#endif
+
+#include "AndroidAlerts.h"
+#include "ANRReporter.h"
+#include "GeckoBatteryManager.h"
+#include "GeckoNetworkManager.h"
+#include "GeckoScreenOrientation.h"
+#include "PrefsHelper.h"
+#include "fennec/MemoryMonitor.h"
+#include "fennec/Telemetry.h"
+#include "fennec/ThumbnailHelper.h"
+
+#ifdef DEBUG_ANDROID_EVENTS
+#define EVLOG(args...)  ALOG(args)
+#else
+#define EVLOG(args...) do { } while (0)
+#endif
+
+using namespace mozilla;
+
+nsIGeolocationUpdate *gLocationCallback = nullptr;
+
+nsAppShell* nsAppShell::sAppShell;
+StaticAutoPtr<Mutex> nsAppShell::sAppShellLock;
+
+NS_IMPL_ISUPPORTS_INHERITED(nsAppShell, nsBaseAppShell, nsIObserver)
+
+class WakeLockListener final : public nsIDOMMozWakeLockListener {
+private:
+  ~WakeLockListener() {}
+
+public:
+  NS_DECL_ISUPPORTS;
+
+  nsresult Callback(const nsAString& topic, const nsAString& state) override {
+    java::GeckoAppShell::NotifyWakeLockChanged(topic, state);
+    return NS_OK;
+  }
+};
+
+NS_IMPL_ISUPPORTS(WakeLockListener, nsIDOMMozWakeLockListener)
+nsCOMPtr<nsIPowerManagerService> sPowerManagerService = nullptr;
+StaticRefPtr<WakeLockListener> sWakeLockListener;
+
+
+class GeckoThreadSupport final
+    : public java::GeckoThread::Natives<GeckoThreadSupport>
+{
+    // When this number goes above 0, the app is paused. When less than or
+    // equal to zero, the app is resumed.
+    static int32_t sPauseCount;
+
+public:
+    static void SpeculativeConnect(jni::String::Param aUriStr)
+    {
+        if (!NS_IsMainThread()) {
+            // We will be on the main thread if the call was queued on the Java
+            // side during startup. Otherwise, the call was not queued, which
+            // means Gecko is already sufficiently loaded, and we don't really
+            // care about speculative connections at this point.
+            return;
+        }
+
+        nsCOMPtr<nsIIOService> ioServ = do_GetIOService();
+        nsCOMPtr<nsISpeculativeConnect> specConn = do_QueryInterface(ioServ);
+        if (!specConn) {
+            return;
+        }
+
+        nsCOMPtr<nsIURI> uri = nsAppShell::ResolveURI(aUriStr->ToCString());
+        if (!uri) {
+            return;
+        }
+        specConn->SpeculativeConnect(uri, nullptr);
+    }
+
+    static void WaitOnGecko()
+    {
+        struct NoOpEvent : nsAppShell::Event {
+            void Run() override {}
+        };
+        nsAppShell::SyncRunEvent(NoOpEvent());
+    }
+
+    static void OnPause()
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+
+        sPauseCount++;
+        // If sPauseCount is now 1, we just crossed the threshold from "resumed"
+        // "paused". so we should notify observers and so on.
+        if (sPauseCount != 1) {
+            return;
+        }
+
+        nsCOMPtr<nsIObserverService> obsServ =
+            mozilla::services::GetObserverService();
+        obsServ->NotifyObservers(nullptr, "application-background", nullptr);
+
+        NS_NAMED_LITERAL_STRING(minimize, "heap-minimize");
+        obsServ->NotifyObservers(nullptr, "memory-pressure", minimize.get());
+
+        // If we are OOM killed with the disk cache enabled, the entire
+        // cache will be cleared (bug 105843), so shut down the cache here
+        // and re-init on foregrounding
+        if (nsCacheService::GlobalInstance()) {
+            nsCacheService::GlobalInstance()->Shutdown();
+        }
+
+        // We really want to send a notification like profile-before-change,
+        // but profile-before-change ends up shutting some things down instead
+        // of flushing data
+        nsIPrefService* prefs = Preferences::GetService();
+        if (prefs) {
+            prefs->SavePrefFile(nullptr);
+        }
+    }
+
+    static void OnResume()
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+
+        sPauseCount--;
+        // If sPauseCount is now 0, we just crossed the threshold from "paused"
+        // to "resumed", so we should notify observers and so on.
+        if (sPauseCount != 0) {
+            return;
+        }
+
+        // If we are OOM killed with the disk cache enabled, the entire
+        // cache will be cleared (bug 105843), so shut down cache on backgrounding
+        // and re-init here
+        if (nsCacheService::GlobalInstance()) {
+            nsCacheService::GlobalInstance()->Init();
+        }
+
+        // We didn't return from one of our own activities, so restore
+        // to foreground status
+        nsCOMPtr<nsIObserverService> obsServ =
+            mozilla::services::GetObserverService();
+        obsServ->NotifyObservers(nullptr, "application-foreground", nullptr);
+    }
+
+    static void CreateServices(jni::String::Param aCategory, jni::String::Param aData)
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+
+        nsCString category(aCategory->ToCString());
+
+        NS_CreateServicesFromCategory(
+                category.get(),
+                nullptr, // aOrigin
+                category.get(),
+                aData ? aData->ToString().get() : nullptr);
+    }
+
+    static int64_t RunUiThreadCallback()
+    {
+        if (!AndroidBridge::Bridge()) {
+            return -1;
+        }
+
+        return AndroidBridge::Bridge()->RunDelayedUiThreadTasks();
+    }
+};
+
+int32_t GeckoThreadSupport::sPauseCount;
+
+
+class GeckoAppShellSupport final
+    : public java::GeckoAppShell::Natives<GeckoAppShellSupport>
+{
+public:
+    static void ReportJavaCrash(const jni::Class::LocalRef& aCls,
+                                jni::Throwable::Param aException,
+                                jni::String::Param aStack)
+    {
+        if (!jni::ReportException(aCls.Env(), aException.Get(), aStack.Get())) {
+            // Only crash below if crash reporter is initialized and annotation
+            // succeeded. Otherwise try other means of reporting the crash in
+            // Java.
+            return;
+        }
+
+        MOZ_CRASH("Uncaught Java exception");
+    }
+
+    static void SyncNotifyObservers(jni::String::Param aTopic,
+                                    jni::String::Param aData)
+    {
+        MOZ_RELEASE_ASSERT(NS_IsMainThread());
+        NotifyObservers(aTopic, aData);
+    }
+
+    static void NotifyObservers(jni::String::Param aTopic,
+                                jni::String::Param aData)
+    {
+        MOZ_ASSERT(NS_IsMainThread());
+        MOZ_ASSERT(aTopic);
+
+        nsCOMPtr<nsIObserverService> obsServ = services::GetObserverService();
+        if (!obsServ) {
+            return;
+        }
+
+        obsServ->NotifyObservers(nullptr, aTopic->ToCString().get(),
+                                 aData ? aData->ToString().get() : nullptr);
+    }
+
+    static void OnSensorChanged(int32_t aType, float aX, float aY, float aZ,
+                                float aW, int32_t aAccuracy, int64_t aTime)
+    {
+        AutoTArray<float, 4> values;
+
+        switch (aType) {
+        // Bug 938035, transfer HAL data for orientation sensor to meet w3c
+        // spec, ex: HAL report alpha=90 means East but alpha=90 means West
+        // in w3c spec
+        case hal::SENSOR_ORIENTATION:
+            values.AppendElement(360.0f - aX);
+            values.AppendElement(-aY);
+            values.AppendElement(-aZ);
+            break;
+
+        case hal::SENSOR_LINEAR_ACCELERATION:
+        case hal::SENSOR_ACCELERATION:
+        case hal::SENSOR_GYROSCOPE:
+        case hal::SENSOR_PROXIMITY:
+            values.AppendElement(aX);
+            values.AppendElement(aY);
+            values.AppendElement(aZ);
+            break;
+
+        case hal::SENSOR_LIGHT:
+            values.AppendElement(aX);
+            break;
+
+        case hal::SENSOR_ROTATION_VECTOR:
+        case hal::SENSOR_GAME_ROTATION_VECTOR:
+            values.AppendElement(aX);
+            values.AppendElement(aY);
+            values.AppendElement(aZ);
+            values.AppendElement(aW);
+            break;
+
+        default:
+            __android_log_print(ANDROID_LOG_ERROR, "Gecko",
+                                "Unknown sensor type %d", aType);
+        }
+
+        hal::SensorData sdata(hal::SensorType(aType), aTime, values,
+                              hal::SensorAccuracyType(aAccuracy));
+        hal::NotifySensorChange(sdata);
+    }
+
+    static void OnLocationChanged(double aLatitude, double aLongitude,
+                                  double aAltitude, float aAccuracy,
+                                  float aBearing, float aSpeed, int64_t aTime)
+    {
+        if (!gLocationCallback) {
+            return;
+        }
+
+        RefPtr<nsIDOMGeoPosition> geoPosition(
+                new nsGeoPosition(aLatitude, aLongitude, aAltitude, aAccuracy,
+                                  aAccuracy, aBearing, aSpeed, aTime));
+        gLocationCallback->Update(geoPosition);
+    }
+
+    static void NotifyUriVisited(jni::String::Param aUri)
+    {
+#ifdef MOZ_ANDROID_HISTORY
+        nsCOMPtr<IHistory> history = services::GetHistoryService();
+        nsCOMPtr<nsIURI> visitedURI;
+        if (history &&
+            NS_SUCCEEDED(NS_NewURI(getter_AddRefs(visitedURI),
+                                   aUri->ToString()))) {
+            history->NotifyVisited(visitedURI);
+        }
+#endif
+    }
+
+    static void NotifyAlertListener(jni::String::Param aName,
+                                    jni::String::Param aTopic,
+                                    jni::String::Param aCookie)
+    {
+        if (!aName || !aTopic || !aCookie) {
+            return;
+        }
+
+        AndroidAlerts::NotifyListener(
+                aName->ToString(), aTopic->ToCString().get(),
+                aCookie->ToString().get());
+    }
+
+    static void OnFullScreenPluginHidden(jni::Object::Param aView)
+    {
+        nsPluginInstanceOwner::ExitFullScreen(aView.Get());
+    }
+};
+
+nsAppShell::nsAppShell()
+    : mSyncRunFinished(*(sAppShellLock = new Mutex("nsAppShell")),
+                       "nsAppShell.SyncRun")
+    , mSyncRunQuit(false)
+{
+    {
+        MutexAutoLock lock(*sAppShellLock);
+        sAppShell = this;
+    }
+
+    if (!XRE_IsParentProcess()) {
+        return;
+    }
+
+    if (jni::IsAvailable()) {
+        // Initialize JNI and Set the corresponding state in GeckoThread.
+        AndroidBridge::ConstructBridge();
+        GeckoAppShellSupport::Init();
+        GeckoThreadSupport::Init();
+        mozilla::GeckoBatteryManager::Init();
+        mozilla::GeckoNetworkManager::Init();
+        mozilla::GeckoScreenOrientation::Init();
+        mozilla::PrefsHelper::Init();
+        nsWindow::InitNatives();
+
+        if (jni::IsFennec()) {
+            mozilla::ANRReporter::Init();
+            mozilla::MemoryMonitor::Init();
+            mozilla::widget::Telemetry::Init();
+            mozilla::ThumbnailHelper::Init();
+        }
+
+        java::GeckoThread::SetState(java::GeckoThread::State::JNI_READY());
+    }
+
+    sPowerManagerService = do_GetService(POWERMANAGERSERVICE_CONTRACTID);
+
+    if (sPowerManagerService) {
+        sWakeLockListener = new WakeLockListener();
+    } else {
+        NS_WARNING("Failed to retrieve PowerManagerService, wakelocks will be broken!");
+    }
+}
+
+nsAppShell::~nsAppShell()
+{
+    {
+        MutexAutoLock lock(*sAppShellLock);
+        sAppShell = nullptr;
+    }
+
+    while (mEventQueue.Pop(/* mayWait */ false)) {
+        NS_WARNING("Discarded event on shutdown");
+    }
+
+    if (sPowerManagerService) {
+        sPowerManagerService->RemoveWakeLockListener(sWakeLockListener);
+
+        sPowerManagerService = nullptr;
+        sWakeLockListener = nullptr;
+    }
+
+    if (jni::IsAvailable()) {
+        AndroidBridge::DeconstructBridge();
+    }
+}
+
+void
+nsAppShell::NotifyNativeEvent()
+{
+    mEventQueue.Signal();
+}
+
+#define PREFNAME_COALESCE_TOUCHES "dom.event.touch.coalescing.enabled"
+static const char* kObservedPrefs[] = {
+  PREFNAME_COALESCE_TOUCHES,
+  nullptr
+};
+
+nsresult
+nsAppShell::Init()
+{
+    nsresult rv = nsBaseAppShell::Init();
+    nsCOMPtr<nsIObserverService> obsServ =
+        mozilla::services::GetObserverService();
+    if (obsServ) {
+        obsServ->AddObserver(this, "browser-delayed-startup-finished", false);
+        obsServ->AddObserver(this, "profile-after-change", false);
+        obsServ->AddObserver(this, "chrome-document-loaded", false);
+        obsServ->AddObserver(this, "quit-application-granted", false);
+        obsServ->AddObserver(this, "xpcom-shutdown", false);
+    }
+
+    if (sPowerManagerService)
+        sPowerManagerService->AddWakeLockListener(sWakeLockListener);
+
+    Preferences::AddStrongObservers(this, kObservedPrefs);
+    mAllowCoalescingTouches = Preferences::GetBool(PREFNAME_COALESCE_TOUCHES, true);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsAppShell::Observe(nsISupports* aSubject,
+                    const char* aTopic,
+                    const char16_t* aData)
+{
+    bool removeObserver = false;
+
+    if (!strcmp(aTopic, "xpcom-shutdown")) {
+        {
+            // Release any thread waiting for a sync call to finish.
+            mozilla::MutexAutoLock shellLock(*sAppShellLock);
+            mSyncRunQuit = true;
+            mSyncRunFinished.NotifyAll();
+        }
+        // We need to ensure no observers stick around after XPCOM shuts down
+        // or we'll see crashes, as the app shell outlives XPConnect.
+        mObserversHash.Clear();
+        return nsBaseAppShell::Observe(aSubject, aTopic, aData);
+
+    } else if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) &&
+               aData &&
+               nsDependentString(aData).Equals(NS_LITERAL_STRING(PREFNAME_COALESCE_TOUCHES))) {
+        mAllowCoalescingTouches = Preferences::GetBool(PREFNAME_COALESCE_TOUCHES, true);
+        return NS_OK;
+
+    } else if (!strcmp(aTopic, "browser-delayed-startup-finished")) {
+        NS_CreateServicesFromCategory("browser-delayed-startup-finished", nullptr,
+                                      "browser-delayed-startup-finished");
+
+    } else if (!strcmp(aTopic, "profile-after-change")) {
+        if (jni::IsAvailable()) {
+            // See if we want to force 16-bit color before doing anything
+            if (Preferences::GetBool("gfx.android.rgb16.force", false)) {
+                java::GeckoAppShell::SetScreenDepthOverride(16);
+            }
+
+            java::GeckoThread::SetState(
+                    java::GeckoThread::State::PROFILE_READY());
+
+            // Gecko on Android follows the Android app model where it never
+            // stops until it is killed by the system or told explicitly to
+            // quit. Therefore, we should *not* exit Gecko when there is no
+            // window or the last window is closed. nsIAppStartup::Quit will
+            // still force Gecko to exit.
+            nsCOMPtr<nsIAppStartup> appStartup =
+                do_GetService(NS_APPSTARTUP_CONTRACTID);
+            if (appStartup) {
+                appStartup->EnterLastWindowClosingSurvivalArea();
+            }
+        }
+        removeObserver = true;
+
+    } else if (!strcmp(aTopic, "chrome-document-loaded")) {
+        if (jni::IsAvailable()) {
+            // Our first window has loaded, assume any JS initialization has run.
+            java::GeckoThread::CheckAndSetState(
+                    java::GeckoThread::State::PROFILE_READY(),
+                    java::GeckoThread::State::RUNNING());
+        }
+        removeObserver = true;
+
+    } else if (!strcmp(aTopic, "quit-application-granted")) {
+        if (jni::IsAvailable()) {
+            java::GeckoThread::SetState(
+                    java::GeckoThread::State::EXITING());
+
+            // We are told explicitly to quit, perhaps due to
+            // nsIAppStartup::Quit being called. We should release our hold on
+            // nsIAppStartup and let it continue to quit.
+            nsCOMPtr<nsIAppStartup> appStartup =
+                do_GetService(NS_APPSTARTUP_CONTRACTID);
+            if (appStartup) {
+                appStartup->ExitLastWindowClosingSurvivalArea();
+            }
+        }
+        removeObserver = true;
+
+    } else if (!strcmp(aTopic, "nsPref:changed")) {
+        if (jni::IsAvailable()) {
+            mozilla::PrefsHelper::OnPrefChange(aData);
+        }
+    }
+
+    if (removeObserver) {
+        nsCOMPtr<nsIObserverService> obsServ =
+            mozilla::services::GetObserverService();
+        if (obsServ) {
+            obsServ->RemoveObserver(this, aTopic);
+        }
+    }
+    return NS_OK;
+}
+
+bool
+nsAppShell::ProcessNextNativeEvent(bool mayWait)
+{
+    EVLOG("nsAppShell::ProcessNextNativeEvent %d", mayWait);
+
+    PROFILER_LABEL("nsAppShell", "ProcessNextNativeEvent",
+        js::ProfileEntry::Category::EVENTS);
+
+    mozilla::UniquePtr<Event> curEvent;
+
+    {
+        curEvent = mEventQueue.Pop(/* mayWait */ false);
+
+        if (!curEvent && mayWait) {
+            // This processes messages in the Android Looper. Note that we only
+            // get here if the normal Gecko event loop has been awoken
+            // (bug 750713). Looper messages effectively have the lowest
+            // priority because we only process them before we're about to
+            // wait for new events.
+            if (jni::IsAvailable() &&
+                    AndroidBridge::Bridge()->PumpMessageLoop()) {
+                return true;
+            }
+
+            PROFILER_LABEL("nsAppShell", "ProcessNextNativeEvent::Wait",
+                js::ProfileEntry::Category::EVENTS);
+            mozilla::HangMonitor::Suspend();
+
+            curEvent = mEventQueue.Pop(/* mayWait */ true);
+        }
+    }
+
+    if (!curEvent)
+        return false;
+
+    mozilla::HangMonitor::NotifyActivity(curEvent->ActivityType());
+
+    curEvent->Run();
+    return true;
+}
+
+void
+nsAppShell::SyncRunEvent(Event&& event,
+                         UniquePtr<Event>(*eventFactory)(UniquePtr<Event>&&))
+{
+    // Perform the call on the Gecko thread in a separate lambda, and wait
+    // on the monitor on the current thread.
+    MOZ_ASSERT(!NS_IsMainThread());
+
+    // This is the lock to check that app shell is still alive,
+    // and to wait on for the sync call to complete.
+    mozilla::MutexAutoLock shellLock(*sAppShellLock);
+    nsAppShell* const appShell = sAppShell;
+
+    if (MOZ_UNLIKELY(!appShell)) {
+        // Post-shutdown.
+        return;
+    }
+
+    bool finished = false;
+    auto runAndNotify = [&event, &finished] {
+        mozilla::MutexAutoLock shellLock(*sAppShellLock);
+        nsAppShell* const appShell = sAppShell;
+        if (MOZ_UNLIKELY(!appShell || appShell->mSyncRunQuit)) {
+            return;
+        }
+        event.Run();
+        finished = true;
+        appShell->mSyncRunFinished.NotifyAll();
+    };
+
+    UniquePtr<Event> runAndNotifyEvent = mozilla::MakeUnique<
+            LambdaEvent<decltype(runAndNotify)>>(mozilla::Move(runAndNotify));
+
+    if (eventFactory) {
+        runAndNotifyEvent = (*eventFactory)(mozilla::Move(runAndNotifyEvent));
+    }
+
+    appShell->mEventQueue.Post(mozilla::Move(runAndNotifyEvent));
+
+    while (!finished && MOZ_LIKELY(sAppShell && !sAppShell->mSyncRunQuit)) {
+        appShell->mSyncRunFinished.Wait();
+    }
+}
+
+already_AddRefed<nsIURI>
+nsAppShell::ResolveURI(const nsCString& aUriStr)
+{
+    nsCOMPtr<nsIIOService> ioServ = do_GetIOService();
+    nsCOMPtr<nsIURI> uri;
+
+    if (NS_SUCCEEDED(ioServ->NewURI(aUriStr, nullptr,
+                                    nullptr, getter_AddRefs(uri)))) {
+        return uri.forget();
+    }
+
+    nsCOMPtr<nsIURIFixup> fixup = do_GetService(NS_URIFIXUP_CONTRACTID);
+    if (fixup && NS_SUCCEEDED(
+            fixup->CreateFixupURI(aUriStr, 0, nullptr, getter_AddRefs(uri)))) {
+        return uri.forget();
+    }
+    return nullptr;
+}
+
+nsresult
+nsAppShell::AddObserver(const nsAString &aObserverKey, nsIObserver *aObserver)
+{
+    NS_ASSERTION(aObserver != nullptr, "nsAppShell::AddObserver: aObserver is null!");
+    mObserversHash.Put(aObserverKey, aObserver);
+    return NS_OK;
+}
+
+// Used by IPC code
+namespace mozilla {
+
+bool ProcessNextEvent()
+{
+    nsAppShell* const appShell = nsAppShell::Get();
+    if (!appShell) {
+        return false;
+    }
+
+    return appShell->ProcessNextNativeEvent(true) ? true : false;
+}
+
+void NotifyEvent()
+{
+    nsAppShell* const appShell = nsAppShell::Get();
+    if (!appShell) {
+        return;
+    }
+    appShell->NotifyNativeEvent();
+}
+
+}