--- a/mobile/android/base/java/org/mozilla/gecko/GeckoActivityMonitor.java
+++ b/mobile/android/base/java/org/mozilla/gecko/GeckoActivityMonitor.java
@@ -1,81 +1,85 @@
 /* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
  * 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/. */
 
 package org.mozilla.gecko;
 
-import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.Application;
+import android.content.Context;
 import android.os.Bundle;
 
+import java.lang.ref.WeakReference;
+
 public class GeckoActivityMonitor implements Application.ActivityLifecycleCallbacks {
     private static final String LOGTAG = "GeckoActivityMonitor";
 
-    // We only hold a reference to the currently running activity - when this activity pauses,
-    // the reference is released or else overwritten by the next activity.
-    @SuppressLint("StaticFieldLeak")
     private static final GeckoActivityMonitor instance = new GeckoActivityMonitor();
 
-    private Activity currentActivity;
+    private GeckoApplication appContext;
+    private WeakReference<Activity> currentActivity = new WeakReference<>(null);
+    private boolean mInitialized;
 
     public static GeckoActivityMonitor getInstance() {
         return instance;
     }
 
     private GeckoActivityMonitor() { }
 
     public Activity getCurrentActivity() {
-        return currentActivity;
+        return currentActivity.get();
+    }
+
+    public synchronized void initialize(final Context context) {
+        if (mInitialized) {
+            return;
+        }
+
+        appContext = (GeckoApplication) context.getApplicationContext();
+
+        appContext.registerActivityLifecycleCallbacks(this);
+        mInitialized = true;
     }
 
     @Override
-    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
-        currentActivity = activity;
-    }
+    public void onActivityCreated(Activity activity, Bundle savedInstanceState) { }
 
     // onNewIntent happens in-between a pause/resume cycle, which means that we wouldn't have
     // a current activity to report if we were using only the official ActivityLifecycleCallbacks.
     // For code that wants to know the current activity even at this point we therefore have to
     // handle this ourselves.
-    public void onActivityNewIntent(Activity activity) {
-        currentActivity = activity;
-    }
+    public void onActivityNewIntent(Activity activity) { }
 
     @Override
     public void onActivityStarted(Activity activity) {
-        currentActivity = activity;
+        if (currentActivity.get() == null) {
+            appContext.onApplicationForeground();
+        }
+        currentActivity = new WeakReference<>(activity);
     }
 
     @Override
-    public void onActivityResumed(Activity activity) {
-        currentActivity = activity;
-    }
+    public void onActivityResumed(Activity activity) { }
 
     @Override
-    public void onActivityPaused(Activity activity) {
-        releaseIfCurrentActivity(activity);
-    }
+    public void onActivityPaused(Activity activity) { }
 
     @Override
     public void onActivityStopped(Activity activity) {
-        releaseIfCurrentActivity(activity);
+        // onStop for the previous activity is called after onStart for the new activity, so if
+        // we're switching activities within our app, currentActivity should already refer to the
+        // next activity at this point.
+        // If it doesn't, it means we've been backgrounded.
+        if (currentActivity.get() == activity) {
+            currentActivity.clear();
+            appContext.onApplicationBackground();
+        }
     }
 
     @Override
     public void onActivitySaveInstanceState(Activity activity, Bundle outState) { }
 
     @Override
-    public void onActivityDestroyed(Activity activity) {
-        releaseIfCurrentActivity(activity);
-    }
-
-    private void releaseIfCurrentActivity(Activity activity) {
-        // If the next activity has already started by the time the previous activity is being
-        // stopped/destroyed, we no longer need to clear the previous activity.
-        if (currentActivity == activity) {
-            currentActivity = null;
-        }
-    }
+    public void onActivityDestroyed(Activity activity) { }
 }

--- a/mobile/android/base/java/org/mozilla/gecko/GeckoApplication.java
+++ b/mobile/android/base/java/org/mozilla/gecko/GeckoApplication.java
@@ -168,42 +168,43 @@ public class GeckoApplication extends Ap
         } catch (IllegalStateException ex) {
             // GeckoApp hasn't started, so we have no ContextGetter in BrowserLocaleManager.
             Log.w(LOG_TAG, "Couldn't correct locale.", ex);
         }
 
         super.onConfigurationChanged(config);
     }
 
-    public void onActivityPause(GeckoActivityStatus activity) {
+    public void onActivityPause(GeckoActivityStatus activity) { }
+
+    public void onApplicationBackground() {
         mInBackground = true;
 
-        if ((activity.isFinishing() == false) &&
-            (activity.isGeckoActivityOpened() == false)) {
-            // Notify Gecko that we are pausing; the cache service will be
-            // shutdown, closing the disk cache cleanly. If the android
-            // low memory killer subsequently kills us, the disk cache will
-            // be left in a consistent state, avoiding costly cleanup and
-            // re-creation.
-            GeckoThread.onPause();
-            mPausedGecko = true;
+        // Notify Gecko that we are pausing; the cache service will be
+        // shutdown, closing the disk cache cleanly. If the android
+        // low memory killer subsequently kills us, the disk cache will
+        // be left in a consistent state, avoiding costly cleanup and
+        // re-creation.
+        GeckoThread.onPause();
+        mPausedGecko = true;
 
-            final BrowserDB db = BrowserDB.from(this);
-            ThreadUtils.postToBackgroundThread(new Runnable() {
-                @Override
-                public void run() {
-                    db.expireHistory(getContentResolver(), BrowserContract.ExpirePriority.NORMAL);
-                }
-            });
+        final BrowserDB db = BrowserDB.from(this);
+        ThreadUtils.postToBackgroundThread(new Runnable() {
+            @Override
+            public void run() {
+                db.expireHistory(getContentResolver(), BrowserContract.ExpirePriority.NORMAL);
+            }
+        });
 
-            GeckoNetworkManager.getInstance().stop();
-        }
+        GeckoNetworkManager.getInstance().stop();
     }
 
-    public void onActivityResume(GeckoActivityStatus activity) {
+    public void onActivityResume(GeckoActivityStatus activity) { }
+
+    public void onApplicationForeground() {
         if (mIsInitialResume) {
             GeckoBatteryManager.getInstance().start(this);
             GeckoFontScaleListener.getInstance().initialize(this);
             GeckoNetworkManager.getInstance().start(this);
             mIsInitialResume = false;
         } else if (mPausedGecko) {
             GeckoThread.onResume();
             mPausedGecko = false;
@@ -231,17 +232,17 @@ public class GeckoApplication extends Ap
         }
 
         mIsInitialResume = true;
 
         mRefWatcher = LeakCanary.install(this);
 
         sSessionUUID = UUID.randomUUID().toString();
 
-        registerActivityLifecycleCallbacks(GeckoActivityMonitor.getInstance());
+        GeckoActivityMonitor.getInstance().initialize(this);
 
         final Context context = getApplicationContext();
         GeckoAppShell.setApplicationContext(context);
         HardwareUtils.init(context);
         FilePicker.init(context);
         DownloadsIntegration.init();
         HomePanelsManager.getInstance().init(context);