Add browsertests for VibrationManager java impl on android.

device/vibration/android/java/src/org/chromium/device/vibration/VibrationManagerImpl.java

 // Copyright 2015 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.device.vibration;
 
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.media.AudioManager;
 import android.os.Vibrator;
 import android.util.Log;
 
+import org.chromium.base.VisibleForTesting;
 import org.chromium.mojo.system.MojoException;
 import org.chromium.mojom.device.VibrationManager;
 
 /**
  * Android implementation of the vibration manager service defined in
  * device/vibration/vibration_manager.mojom.
  */
 public class VibrationManagerImpl implements VibrationManager {
     private static final String TAG = "VibrationManagerImpl";
 
     private static final long MINIMUM_VIBRATION_DURATION_MS = 1; // 1 millisecond
     private static final long MAXIMUM_VIBRATION_DURATION_MS = 10000; // 10 seconds
 
     private final AudioManager mAudioManager;
-    private final Vibrator mVibrator;
     private final boolean mHasVibratePermission;
 
+    private static AndroidVibratorWrapper sVibratorWrapper;
+
+    /**
+     * Android Vibrator wrapper class provided to test code to extend.
+     */
+    @VisibleForTesting
+    public static class AndroidVibratorWrapper {
+        private final Vibrator mAndroidVibrator;
+
+        protected AndroidVibratorWrapper(Vibrator vibrator) {
+            mAndroidVibrator = vibrator;
+        }
+
+        public void vibrate(long milliseconds) {
+            mAndroidVibrator.vibrate(milliseconds);
+        }
+
+        public void cancel() {
+            mAndroidVibrator.cancel();
+        }
+    }
+
+    // Test code can use this function to inject other wrapper for testing.
+    public static void setVibratorWrapperForTesting(AndroidVibratorWrapper wrapper) {
+        sVibratorWrapper = wrapper;
+    }
+
     public VibrationManagerImpl(Context context) {
         mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
-        mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
+        if (sVibratorWrapper == null) {
+            sVibratorWrapper = new AndroidVibratorWrapper(
+                    (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE));

[David Trainor- moved to gerrit, 2015/11/02 16:43:51]

If this is a static, should we make *sure* this is the application context we're
calling this on?  I'm not 100% sure it's a problem, but I wouldn't want to leak
an activity forever here.

[Ted C, 2015/11/02 23:16:47]

If you want to avoid keeping a static like this, you could make the Wrapper not
actually take the Vibrator in the constructor but in both methods.  Then the
wrapper/helper/delegate could be overridden with something that does not operate
on it.  And you're not keeping a static ref to a service.

public static class AndroidVibratorWrapper {
    public void vibrate(Vibrator vibrator, long milliseconds) {
       ...
    }
   
    public void cancel(Vibrator vibrator) {
       ...
    }
}

[leonhsl(Using Gerrit), 2015/11/03 08:56:26]

Hi, David, Ted, Thank you very much for helpful advice~
VibrationManagerImpl is a mojo service impl which will be created via a
predefined/fixed route, it is guaranteed that the context here is always the
application context. 
Although it wouldn't be a problem, maybe we should take Ted's advice to avoid
keeping a static ref to an android service? It would be more flexible for
possible future changes.

Hi, Tim, Ppi, WDYT?  Thanks~

[ppi, 2015/11/03 13:27:10]

Ted's suggestion sg to me. 

+        }
         mHasVibratePermission =
                 context.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)
                 == PackageManager.PERMISSION_GRANTED;
         if (!mHasVibratePermission) {
             Log.w(TAG, "Failed to use vibrate API, requires VIBRATE permission.");
         }
     }
 
     @Override
     public void close() {}
 
     @Override
     public void onConnectionError(MojoException e) {}
 
     @Override
     public void vibrate(long milliseconds) {
         // Though the Blink implementation already sanitizes vibration times, don't
         // trust any values passed from the client.
         long sanitizedMilliseconds = Math.max(MINIMUM_VIBRATION_DURATION_MS,
                 Math.min(milliseconds, MAXIMUM_VIBRATION_DURATION_MS));
 
         if (mAudioManager.getRingerMode() != AudioManager.RINGER_MODE_SILENT
                 && mHasVibratePermission) {
-            mVibrator.vibrate(sanitizedMilliseconds);
+            sVibratorWrapper.vibrate(sanitizedMilliseconds);
         }
     }
 
     @Override
     public void cancel() {
-        if (mHasVibratePermission) mVibrator.cancel();
+        if (mHasVibratePermission) sVibratorWrapper.cancel();
     }
 }