Add a mechanism to pause and resume geolocation requests.

content/public/android/java/src/org/chromium/content/browser/LocationProvider.java

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser;
 
 import android.content.Context;
 import android.location.Criteria;
 import android.location.Location;
 import android.location.LocationListener;
 import android.location.LocationManager;
 import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Message;
 import android.util.Log;
 
+import com.google.common.annotations.VisibleForTesting;
+
 import org.chromium.base.ActivityStatus;
 import org.chromium.base.CalledByNative;
 import org.chromium.base.ThreadUtils;
 
 import java.util.List;
 import java.util.concurrent.FutureTask;
 
 /**
  * Implements the Java side of LocationProviderAndroid.
  * Delegates all real functionality to the inner class.
  * See detailed documentation on
  * content/browser/geolocation/android_location_api_adapter.h.
  * Based on android.webkit.GeolocationService.java
  */
-class LocationProvider {
+public class LocationProvider {
 
     // Log tag
     private static final String TAG = "LocationProvider";
 
+    private static boolean sUseMockProvider;
+
+    @VisibleForTesting
+    public static void enableMockLocationProvider() {

[mkosiba (inactive), 2013/12/09 16:26:08]

nit: I think it would be a bit cleaner if the LocationProvder could be
configured to take a MockLocationProviderImplFactory rather than having a mock
impl baked in directly. It would require adding a test-only Delegate to enable
calling nativeNewLocationAvailable, so I'm not sure we'd save any lines of code
but we'd be shipping less test-only code with the product.

+        sUseMockProvider = true;
+    }
+
+    private interface ContentLocationProvider {
+        public void start(boolean gpsEnabled);
+        public void stop();
+        public boolean isRunning();
+    }
+
+    private static class MockLocationProviderImpl implements ContentLocationProvider {
+        private boolean mIsRunning;
+        private Handler mHandler;
+        private static final Object mLock = new Object();
+
+        private static final int UPDATE_LOCATION = 100;
+
+        public MockLocationProviderImpl() {
+            HandlerThread handlerThread = new HandlerThread("MockLocationProviderImpl");
+            handlerThread.start();
+            mHandler = new Handler(handlerThread.getLooper()) {
+                @Override
+                public void handleMessage(Message msg) {
+                    synchronized(mLock) {
+                        if (msg.what == UPDATE_LOCATION) {
+                            newLocation();
+                            sendEmptyMessageDelayed(UPDATE_LOCATION, 1000);
+                        }
+                    }
+                }
+            };
+        }
+
+        @Override
+        public void start(boolean gpsEnabled) {
+            if (mIsRunning) return;
+            mIsRunning = true;
+            synchronized (mLock) {
+                mHandler.sendEmptyMessage(UPDATE_LOCATION);
+            }
+        }
+
+        @Override
+        public void stop() {
+            if (!mIsRunning) return;
+            mIsRunning = false;
+            synchronized (mLock) {
+                mHandler.removeMessages(UPDATE_LOCATION);
+            }
+        }
+
+        @Override
+        public boolean isRunning() {
+            return mIsRunning;
+        }
+
+        private void newLocation() {
+            nativeNewLocationAvailable(0, 0, System.currentTimeMillis() / 1000.0,
+                    false, 0,
+                    true, 0.5,
+                    false, 0,
+                    false, 0);
+        }
+    };
+
     /**
      * This is the core of android location provider. It is a separate class for clarity
      * so that it can manage all processing completely in the UI thread. The container class
      * ensures that the start/stop calls into this class are done in the UI thread.
      */
     private static class LocationProviderImpl
-            implements LocationListener, ActivityStatus.StateListener {
+            implements LocationListener, ContentLocationProvider {
 
         private Context mContext;
         private LocationManager mLocationManager;
         private boolean mIsRunning;
-        private boolean mShouldRunAfterActivityResume;
-        private boolean mIsGpsEnabled;
 
         LocationProviderImpl(Context context) {
             mContext = context;
         }
 
-        @Override
-        public void onActivityStateChange(int state) {
-            if (state == ActivityStatus.PAUSED) {
-                mShouldRunAfterActivityResume |= mIsRunning;
-                unregisterFromLocationUpdates();
-            } else if (state == ActivityStatus.RESUMED) {
-                assert !mIsRunning;
-                if (mShouldRunAfterActivityResume) {
-                    registerForLocationUpdates();
-                }
-            }
-        }
-
         /**
          * Start listening for location updates.
          * @param gpsEnabled Whether or not we're interested in high accuracy GPS.
          */
-        private void start(boolean gpsEnabled) {
-            if (!mIsRunning && !mShouldRunAfterActivityResume) {
-                // Currently idle so start listening to activity status changes.
-                ActivityStatus.registerStateListener(this);
-            }
-            mIsGpsEnabled = gpsEnabled;
-
-            if (ActivityStatus.getState() != ActivityStatus.RESUMED) {
-                mShouldRunAfterActivityResume = true;
-            } else {
-                unregisterFromLocationUpdates();
-                registerForLocationUpdates();
-            }
+        @Override
+        public void start(boolean gpsEnabled) {
+            unregisterFromLocationUpdates();
+            registerForLocationUpdates(gpsEnabled);
         }
 
         /**
          * Stop listening for location updates.
          */
-        private void stop() {
+        @Override
+        public void stop() {
             unregisterFromLocationUpdates();
-            ActivityStatus.unregisterStateListener(this);
-            mShouldRunAfterActivityResume = false;
         }
 
         /**
          * Returns true if we are currently listening for location updates, false if not.
          */
-        private boolean isRunning() {
+        @Override
+        public boolean isRunning() {
             return mIsRunning;
         }
 
         @Override
         public void onLocationChanged(Location location) {
             // Callbacks from the system location sevice are queued to this thread, so it's
             // possible that we receive callbacks after unregistering. At this point, the
             // native object will no longer exist.
             if (mIsRunning) {
                 updateNewLocation(location);
@@ skipping 26 matching lines @@
             mLocationManager = (LocationManager) mContext.getSystemService(
                     Context.LOCATION_SERVICE);
             if (mLocationManager == null) {
                 Log.e(TAG, "Could not get location manager.");
             }
         }
 
         /**
          * Registers this object with the location service.
          */
-        private void registerForLocationUpdates() {
+        private void registerForLocationUpdates(boolean isGpsEnabled) {
             ensureLocationManagerCreated();
             if (usePassiveOneShotLocation()) return;
 
             assert !mIsRunning;
             mIsRunning = true;
 
             // We're running on the main thread. The C++ side is responsible to
             // bounce notifications to the Geolocation thread as they arrive in the mainLooper.
             try {
                 Criteria criteria = new Criteria();
                 mLocationManager.requestLocationUpdates(0, 0, criteria, this,
                         ThreadUtils.getUiThreadLooper());
-                if (mIsGpsEnabled) {
+                if (isGpsEnabled) {
                     criteria.setAccuracy(Criteria.ACCURACY_FINE);
                     mLocationManager.requestLocationUpdates(0, 0, criteria, this,
                             ThreadUtils.getUiThreadLooper());
                 }
             } catch(SecurityException e) {
                 Log.e(TAG, "Caught security exception registering for location updates from " +
                     "system. This should only happen in DumpRenderTree.");
             } catch(IllegalArgumentException e) {
                 Log.e(TAG, "Caught IllegalArgumentException registering for location updates.");
             }
@@ skipping 33 matching lines @@
          * in the system.
          */
         private boolean isOnlyPassiveLocationProviderEnabled() {
             List<String> providers = mLocationManager.getProviders(true);
             return providers != null && providers.size() == 1
                     && providers.get(0).equals(LocationManager.PASSIVE_PROVIDER);
         }
     }
 
     // Delegate handling the real work in the main thread.
-    private LocationProviderImpl mImpl;
+    private ContentLocationProvider mImpl;
 
     private LocationProvider(Context context) {
-        mImpl = new LocationProviderImpl(context);
+        if (sUseMockProvider) {
+            mImpl = new MockLocationProviderImpl();
+        } else {
+            mImpl = new LocationProviderImpl(context);
+        }
     }
 
     @CalledByNative
     static LocationProvider create(Context context) {
         return new LocationProvider(context);
     }
 
     /**
      * Start listening for location updates until we're told to quit. May be
      * called in any thread.
@@ skipping 36 matching lines @@
 
     // Native functions
     public static native void nativeNewLocationAvailable(
             double latitude, double longitude, double timeStamp,
             boolean hasAltitude, double altitude,
             boolean hasAccuracy, double accuracy,
             boolean hasHeading, double heading,
             boolean hasSpeed, double speed);
     public static native void nativeNewErrorAvailable(String message);
 }