Skip to content

GitLab

T
tangled
Commit 28464ce3 authored by alexclarke's avatar alexclarke Committed by Commit bot
Browse files
Options

Revert of precache: Move the java files into //components/precache/android... 

Revert of precache: Move the java files into //components/precache/android (patchset #5 id:120001 of https://codereview.chromium.org/1031003003/)

Reason for revert:
This broke downstream chrome for android.  Coordination with chrome os is required. See bug for more details.

Original issue's description:
> precache: Move the java files into //components/precache/android
>
> This moves code out of //java/apps/chrome/.../precache into:
>   . //components/precache/android/: classes that provide information about
>     device-state, network connectivity etc.
>   . //chrome/android/.../precache/: precache service and service launchers.
>
> BUG=401552
>
> Committed: https://crrev.com/efb5a13547940947b2c8f42a4e9ed64d45bdd2d2
> Cr-Commit-Position: refs/heads/master@{#322298}

TBR=bengr@chromium.org,yfriedman@chromium.org,thestig@chromium.org,sadrul@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=401552

Review URL: https://codereview.chromium.org/1032273004

Cr-Commit-Position: refs/heads/master@{#322355}
parent 62b1a31d
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 1415 deletions
chrome/android/BUILD.gn
View file @ 28464ce3
...@@ -86,7 +86,6 @@ android_library("chrome_java") { ...@@ -86,7 +86,6 @@ android_library("chrome_java") {
"//components/gcm_driver/android:gcm_driver_java", "//components/gcm_driver/android:gcm_driver_java",
"//components/invalidation:java", "//components/invalidation:java",
"//components/navigation_interception/android:navigation_interception_java", "//components/navigation_interception/android:navigation_interception_java",
"//components/precache/android:precache_java",
"//components/variations/android:variations_java", "//components/variations/android:variations_java",
"//components/web_contents_delegate_android:web_contents_delegate_android_java", "//components/web_contents_delegate_android:web_contents_delegate_android_java",
"//content/public/android:content_java", "//content/public/android:content_java",
......
chrome/android/java/DEPS
View file @ 28464ce3
...@@ -3,7 +3,6 @@ include_rules = [ ...@@ -3,7 +3,6 @@ include_rules = [
"+components/web_contents_delegate_android", "+components/web_contents_delegate_android",
"+components/bookmarks/common/android/java/src/org/chromium/components/bookmarks", "+components/bookmarks/common/android/java/src/org/chromium/components/bookmarks",
"+components/dom_distiller/android/java/src/org/chromium/components/dom_distiller/core", "+components/dom_distiller/android/java/src/org/chromium/components/dom_distiller/core",
"+components/precache/android/java",
"+content/public/android/java", "+content/public/android/java",
"+sync/android/java/src/org/chromium/sync", "+sync/android/java/src/org/chromium/sync",
] ]
chrome/android/java/src/org/chromium/chrome/browser/precache/PrecacheLauncher.java deleted 100644 → 0
View file @ 62b1a31d
// 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.chrome.browser.precache;
import android.content.Context;
import org.chromium.base.CalledByNative;
import org.chromium.base.ThreadUtils;
import org.chromium.chrome.browser.preferences.privacy.PrivacyPreferencesManager;
import java.util.concurrent.Callable;
/** Class that interacts with the PrecacheManager to control precache cycles. */
public abstract class PrecacheLauncher {
/** Pointer to the native PrecacheLauncher object. Set to 0 when uninitialized. */
private long mNativePrecacheLauncher;
/** Destroy the native PrecacheLauncher, releasing the memory that it was using. */
public void destroy() {
if (mNativePrecacheLauncher != 0) {
nativeDestroy(mNativePrecacheLauncher);
mNativePrecacheLauncher = 0;
}
}
/** Starts a precache cycle. */
public void start() {
// Lazily initialize the native PrecacheLauncher.
if (mNativePrecacheLauncher == 0) {
mNativePrecacheLauncher = nativeInit();
}
nativeStart(mNativePrecacheLauncher);
}
/** Cancel the precache cycle if one is ongoing. */
public void cancel() {
// Lazily initialize the native PrecacheLauncher.
if (mNativePrecacheLauncher == 0) {
mNativePrecacheLauncher = nativeInit();
}
nativeCancel(mNativePrecacheLauncher);
}
/** Called when a precache cycle completes. */
protected abstract void onPrecacheCompleted();
/**
* Called by native code when the precache cycle completes. This method exists because an
* abstract method cannot be directly called from native.
*/
@CalledByNative
private void onPrecacheCompletedCallback() {
onPrecacheCompleted();
}
/**
* Returns true if precaching is enabled by either Finch or the command line flag, and also by
* the predictive network actions preference and current network connection type.
*
* @param privacyPreferencesManager Singleton that manages the prefetch bandwidth preference.
*/
public static boolean isPrecachingEnabled(
final PrivacyPreferencesManager privacyPreferencesManager) {
if (!nativeIsPrecachingEnabled()) return false;
// privacyPreferencesManager.shouldPrerender() can only be executed on the UI thread.
return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Boolean>() {
@Override
public Boolean call() {
return privacyPreferencesManager.shouldPrerender();
}
});
}
/**
* If precaching is enabled, then allow the PrecacheService to be launched and signal Chrome
* when conditions are right to start precaching. If precaching is disabled, prevent the
* PrecacheService from ever starting.
*
* @param privacyPreferencesManager Singleton that manages the prefetch bandwidth preference.
* @param context The context of the PrecacheServiceLauncher.
*/
public static void updatePrecachingEnabled(PrivacyPreferencesManager privacyPreferencesManager,
Context context) {
PrecacheServiceLauncher.setIsPrecachingEnabled(context,
isPrecachingEnabled(privacyPreferencesManager));
}
private native long nativeInit();
private native void nativeDestroy(long nativePrecacheLauncher);
private native void nativeStart(long nativePrecacheLauncher);
private native void nativeCancel(long nativePrecacheLauncher);
private static native boolean nativeIsPrecachingEnabled();
}
chrome/android/java/src/org/chromium/chrome/browser/precache/PrecacheService.java deleted 100644 → 0
View file @ 62b1a31d
// 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.chrome.browser.precache;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.os.IBinder;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.util.Log;
import org.chromium.base.VisibleForTesting;
import org.chromium.base.annotations.SuppressFBWarnings;
import org.chromium.base.library_loader.LibraryProcessType;
import org.chromium.base.library_loader.ProcessInitException;
import org.chromium.components.precache.DeviceState;
import org.chromium.content.browser.BrowserStartupController;
/**
* Background service that runs while Chrome is precaching resources. Precaching is only done while
* the device is connected to power, Wi-Fi, and the device is not interactive (e.g., the screen is
* off. This is a sticky service that is started when the {@link PrecacheServiceLauncher}
* determines that conditions are right for precaching. Once started, this service runs until
* either precaching finishes successfully, or the conditions are no longer met.
*/
public class PrecacheService extends Service {
private static final String TAG = "PrecacheService";
public static final String ACTION_START_PRECACHE =
"org.chromium.chrome.browser.precache.PrecacheService.START_PRECACHE";
/** Wakelock that is held while precaching is in progress. */
private WakeLock mPrecachingWakeLock;
/** True if there is a precache in progress. */
private boolean mIsPrecaching = false;
@VisibleForTesting
boolean isPrecaching() {
return mIsPrecaching;
}
private DeviceState mDeviceState = DeviceState.getInstance();
@VisibleForTesting
void setDeviceState(DeviceState deviceState) {
mDeviceState = deviceState;
}
/** Receiver that will be notified when conditions become wrong for precaching. */
private final BroadcastReceiver mDeviceStateReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (mIsPrecaching && (mDeviceState.isInteractive(context)
|| !mDeviceState.isPowerConnected(context)
|| !mDeviceState.isWifiAvailable(context))) {
cancelPrecaching();
}
}
};
@VisibleForTesting
BroadcastReceiver getDeviceStateReceiver() {
return mDeviceStateReceiver;
}
@VisibleForTesting
void handlePrecacheCompleted() {
if (mIsPrecaching) finishPrecaching();
}
/** PrecacheLauncher used to run precaching. */
private PrecacheLauncher mPrecacheLauncher = new PrecacheLauncher() {
@Override
protected void onPrecacheCompleted() {
handlePrecacheCompleted();
}
};
@VisibleForTesting
void setPrecacheLauncher(PrecacheLauncher precacheLauncher) {
mPrecacheLauncher = precacheLauncher;
}
@Override
public void onCreate() {
super.onCreate();
registerDeviceStateReceiver();
}
@Override
public void onDestroy() {
if (mIsPrecaching) cancelPrecaching();
unregisterReceiver(mDeviceStateReceiver);
mPrecacheLauncher.destroy();
releasePrecachingWakeLock();
super.onDestroy();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
try {
if (intent != null && ACTION_START_PRECACHE.equals(intent.getAction())
&& !mIsPrecaching) {
// Only start precaching if precaching is not already in progress.
startPrecaching();
}
} finally {
PrecacheServiceLauncher.releaseWakeLock();
}
// The PrecacheService should only be running while precaching is in progress. Return
// {@link Service.START_STICKY} if precaching is in progress to keep the service running;
// otherwise, return {@link Service.START_NOT_STICKY} to cause the service to stop once it
// is done processing commands sent to it.
return mIsPrecaching ? START_STICKY : START_NOT_STICKY;
}
/** PrecacheService does not support binding. */
@Override
public IBinder onBind(Intent intent) {
return null;
}
/** Attempt to start up the browser processes and load the native libraries. */
@SuppressFBWarnings("DM_EXIT")
@VisibleForTesting
void prepareNativeLibraries() {
try {
BrowserStartupController.get(getApplicationContext(),
LibraryProcessType.PROCESS_BROWSER)
.startBrowserProcessesSync(false);
} catch (ProcessInitException e) {
Log.e(TAG, "ProcessInitException while starting the browser process");
// Since the library failed to initialize nothing in the application
// can work, so kill the whole application not just the activity.
System.exit(-1);
}
}
/** Begin a precache cycle. */
private void startPrecaching() {
Log.v(TAG, "Start precaching");
prepareNativeLibraries();
mIsPrecaching = true;
acquirePrecachingWakeLock();
// In certain cases, the PrecacheLauncher will skip precaching entirely and call
// finishPrecaching() before this call to mPrecacheLauncher.start() returns, so the call to
// mPrecacheLauncher.start() must happen after acquiring the wake lock to ensure that the
// wake lock is released properly.
mPrecacheLauncher.start();
}
/** End a precache cycle. */
private void finishPrecaching() {
Log.v(TAG, "Finish precaching");
shutdownPrecaching();
}
/** Cancel a precache cycle. */
private void cancelPrecaching() {
Log.v(TAG, "Cancel precaching");
prepareNativeLibraries();
mPrecacheLauncher.cancel();
shutdownPrecaching();
}
/**
* Update state to indicate that precaching is no longer in progress, and stop the service.
*/
private void shutdownPrecaching() {
mIsPrecaching = false;
releasePrecachingWakeLock();
stopSelf();
}
/** Register a BroadcastReceiver to detect when conditions become wrong for precaching. */
private void registerDeviceStateReceiver() {
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_POWER_DISCONNECTED);
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
filter.addAction(Intent.ACTION_SCREEN_ON);
registerReceiver(mDeviceStateReceiver, filter);
}
/** Acquire the precaching WakeLock. */
private void acquirePrecachingWakeLock() {
if (mPrecachingWakeLock == null) {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
mPrecachingWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
}
mPrecachingWakeLock.acquire();
}
/** Release the precaching WakeLock if it is held. */
private void releasePrecachingWakeLock() {
if (mPrecachingWakeLock != null && mPrecachingWakeLock.isHeld()) {
mPrecachingWakeLock.release();
}
}
}
chrome/android/java/src/org/chromium/chrome/browser/precache/PrecacheServiceLauncher.java deleted 100644 → 0
View file @ 62b1a31d
// 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.chrome.browser.precache;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.os.SystemClock;
import android.preference.PreferenceManager;
import org.chromium.base.ThreadUtils;
import org.chromium.base.VisibleForTesting;
import org.chromium.components.precache.DeviceState;
/**
* BroadcastReceiver that determines when conditions are right for precaching, and starts the
* {@link PrecacheService} if they are. Conditions are right for precaching when the device is
* connected to power, Wi-Fi, interactivity (e.g., the screen) is off, and at least
* |WAIT_UNTIL_NEXT_PRECACHE_MS| have passed since the last time precaching was done.
*/
public class PrecacheServiceLauncher extends BroadcastReceiver {
private static final String TAG = "PrecacheServiceLauncher";
@VisibleForTesting
static final String PREF_IS_PRECACHING_ENABLED = "precache.is_precaching_enabled";
@VisibleForTesting
static final String PREF_PRECACHE_LAST_TIME = "precache.last_time";
@VisibleForTesting
static final String ACTION_ALARM =
"org.chromium.chrome.browser.precache.PrecacheServiceLauncher.ALARM";
private static final int INTERACTIVE_STATE_POLLING_PERIOD_MS = 15 * 60 * 1000; // 15 minutes.
static final int WAIT_UNTIL_NEXT_PRECACHE_MS = 4 * 60 * 60 * 1000; // 4 hours.
private static WakeLock sWakeLock = null;
private DeviceState mDeviceState = DeviceState.getInstance();
@VisibleForTesting
void setDeviceState(DeviceState deviceState) {
mDeviceState = deviceState;
}
/**
* Set whether or not precaching is enabled. If precaching is enabled, this receiver will start
* the PrecacheService when it receives an intent. If precaching is disabled, any running
* PrecacheService will be stopped, and this receiver will do nothing when it receives an
* intent.
*
* @param context The Context to use.
* @param enabled Whether or not precaching is enabled.
*/
public static void setIsPrecachingEnabled(Context context, boolean enabled) {
Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
editor.putBoolean(PREF_IS_PRECACHING_ENABLED, enabled);
editor.apply();
if (!enabled) {
// Stop any running PrecacheService. If PrecacheService is not running, then this does
// nothing.
Intent serviceIntent = new Intent(null, null, context, PrecacheService.class);
context.stopService(serviceIntent);
}
}
@Override
public void onReceive(Context context, Intent intent) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
boolean isPrecachingEnabled = prefs.getBoolean(PREF_IS_PRECACHING_ENABLED, false);
long lastPrecacheTimeMs = prefs.getLong(PREF_PRECACHE_LAST_TIME, 0L);
if (lastPrecacheTimeMs > getElapsedRealtimeOnSystem()) {
// System.elapsedRealtime() counts milliseconds since boot, so if the device has been
// rebooted since the last time precaching was performed, reset lastPrecacheTimeMs to 0.
lastPrecacheTimeMs = 0L;
}
// Do nothing if precaching is disabled.
if (!isPrecachingEnabled) return;
boolean isPowerConnected = mDeviceState.isPowerConnected(context);
boolean isWifiAvailable = mDeviceState.isWifiAvailable(context);
boolean isInteractive = mDeviceState.isInteractive(context);
boolean areConditionsGoodForPrecaching =
isPowerConnected && isWifiAvailable && !isInteractive;
long timeSinceLastPrecacheMs = getElapsedRealtimeOnSystem() - lastPrecacheTimeMs;
boolean hasEnoughTimePassedSinceLastPrecache =
timeSinceLastPrecacheMs >= WAIT_UNTIL_NEXT_PRECACHE_MS;
// Only start precaching when an alarm action is received. This is to prevent situations
// such as power being connected, precaching starting, then precaching being immediately
// canceled because the screen turns on in response to power being connected.
if (ACTION_ALARM.equals(intent.getAction())
&& areConditionsGoodForPrecaching
&& hasEnoughTimePassedSinceLastPrecache) {
// Store a pref indicating that precaching is starting now.
Editor editor = prefs.edit();
editor.putLong(PREF_PRECACHE_LAST_TIME, getElapsedRealtimeOnSystem());
editor.apply();
setAlarm(context, Math.max(
INTERACTIVE_STATE_POLLING_PERIOD_MS, WAIT_UNTIL_NEXT_PRECACHE_MS));
acquireWakeLockAndStartService(context);
} else {
if (isPowerConnected && isWifiAvailable) {
// If we're just waiting for non-interactivity (e.g., the screen to be off), or for
// enough time to pass after Wi-Fi or power has been connected, then set an alarm
// for the next time to check the device state. We can't receive SCREEN_ON/OFF
// intents as is done for detecting changes in power and connectivity, because
// SCREEN_ON/OFF intents are only delivered to BroadcastReceivers that are
// registered dynamically in code, but the PrecacheServiceLauncher is registered in
// the Android manifest.
setAlarm(context, Math.max(INTERACTIVE_STATE_POLLING_PERIOD_MS,
WAIT_UNTIL_NEXT_PRECACHE_MS - timeSinceLastPrecacheMs));
} else {
// If the device doesn't have connected power or doesn't have Wi-Fi, then there's no
// point in setting an alarm.
cancelAlarm(context);
}
}
}
/** Release the wakelock if it is held. */
@VisibleForTesting
protected static void releaseWakeLock() {
ThreadUtils.assertOnUiThread();
if (sWakeLock != null && sWakeLock.isHeld()) sWakeLock.release();
}
/**
* Acquire the wakelock and start the PrecacheService.
*
* @param context The Context to use to start the service.
*/
private void acquireWakeLockAndStartService(Context context) {
acquireWakeLock(context);
startPrecacheService(context);
}
@VisibleForTesting
protected void startPrecacheService(Context context) {
Intent serviceIntent = new Intent(
PrecacheService.ACTION_START_PRECACHE, null, context, PrecacheService.class);
context.startService(serviceIntent);
}
@VisibleForTesting
protected void acquireWakeLock(Context context) {
ThreadUtils.assertOnUiThread();
if (sWakeLock == null) {
PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
sWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
}
sWakeLock.acquire();
}
/**
* Get a PendingIntent for setting an alarm to notify the PrecacheServiceLauncher.
*
* @param context The Context to use for the PendingIntent.
* @return The PendingIntent.
*/
private static PendingIntent getPendingAlarmIntent(Context context) {
return PendingIntent.getBroadcast(context, 0,
new Intent(ACTION_ALARM, null, context, PrecacheServiceLauncher.class),
PendingIntent.FLAG_UPDATE_CURRENT);
}
/**
* Set an alarm to notify the PrecacheServiceLauncher in the future.
*
* @param context The Context to use.
* @param delayMs Delay in milliseconds before the alarm goes off.
*/
private void setAlarm(Context context, long delayMs) {
setAlarmOnSystem(context, AlarmManager.ELAPSED_REALTIME_WAKEUP,
getElapsedRealtimeOnSystem() + delayMs, getPendingAlarmIntent(context));
}
/**
* Set the alarm on the system using the given parameters. This method can be overridden in
* tests.
*/
@VisibleForTesting
protected void setAlarmOnSystem(Context context, int type, long triggerAtMillis,
PendingIntent operation) {
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.set(type, triggerAtMillis, operation);
}
/**
* Cancel a previously set alarm, if there is one. This method can be overridden in tests.
*
* @param context The Context to use.
*/
private void cancelAlarm(Context context) {
cancelAlarmOnSystem(context, getPendingAlarmIntent(context));
}
/** Cancel a previously set alarm on the system. This method can be overridden in tests. */
@VisibleForTesting
protected void cancelAlarmOnSystem(Context context, PendingIntent operation) {
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.cancel(operation);
}
@VisibleForTesting
protected long getElapsedRealtimeOnSystem() {
return SystemClock.elapsedRealtime();
}
}
chrome/android/javatests/DEPS
View file @ 28464ce3
include_rules = [ include_rules = [
"+components/dom_distiller/android/java/src/org/chromium/components/dom_distiller/core", "+components/dom_distiller/android/java/src/org/chromium/components/dom_distiller/core",
"+components/bookmarks/common/android/java/src/org/chromium/components/bookmarks", "+components/bookmarks/common/android/java/src/org/chromium/components/bookmarks",
"+components/precache/android/javatests",
"+content/public/android/java", "+content/public/android/java",
"+sync/android/java/src/org/chromium/sync", "+sync/android/java/src/org/chromium/sync",
# We should only depend on the util package of something that lives in # We should only depend on the util package of something that lives in
......
chrome/android/javatests/src/org/chromium/chrome/browser/precache/MockPrecacheService.java deleted 100644 → 0
View file @ 62b1a31d
// 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.chrome.browser.precache;
/**
* PrecacheService class with native initialization mocked out.
*/
public class MockPrecacheService extends PrecacheService {
@Override
void prepareNativeLibraries() {}
}
chrome/android/javatests/src/org/chromium/chrome/browser/precache/PrecacheServiceLauncherTest.java deleted 100644 → 0
View file @ 62b1a31d
// 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.chrome.browser.precache;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.test.InstrumentationTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import org.chromium.base.test.util.AdvancedMockContext;
import org.chromium.base.test.util.Feature;
import org.chromium.components.precache.MockDeviceState;
import java.util.HashMap;
import java.util.Map;
/**
* Tests the |PrecacheServiceLauncher|.
*/
public class PrecacheServiceLauncherTest extends InstrumentationTestCase {
private Context getContext(boolean enabled, long lastTimeMs) {
AdvancedMockContext context = new AdvancedMockContext() {
@Override
public String getPackageName() {
return getInstrumentation().getTargetContext().getPackageName();
}
};
Map<String, Object> map = new HashMap<String, Object>();
map.put(PrecacheServiceLauncher.PREF_IS_PRECACHING_ENABLED, enabled);
map.put(PrecacheServiceLauncher.PREF_PRECACHE_LAST_TIME, lastTimeMs);
context.addSharedPreferences(context.getPackageName() + "_preferences", map);
return context;
}
/**
* Class mocks out the system-related function of |PrecacheServiceLauncher|
* and provides a method to set a mocked elapsed realtime.
*/
static class MockPrecacheServiceLauncher extends PrecacheServiceLauncher {
private long mElapsedRealtime;
private boolean mCancelAlarmCalled;
private boolean mSetAlarmCalled;
private boolean mStartPrecacheCalled;
@Override
protected void setAlarmOnSystem(Context context, int type, long triggerAtMillis,
PendingIntent operation) {
mSetAlarmCalled = true;
}
@Override
protected void cancelAlarmOnSystem(Context context, PendingIntent operation) {
mCancelAlarmCalled = true;
}
@Override
protected long getElapsedRealtimeOnSystem() {
return mElapsedRealtime;
}
@Override
protected void startPrecacheService(Context context) {
mStartPrecacheCalled = true;
}
@Override
protected void acquireWakeLock(Context context) {}
protected void setElapsedRealtime(long elapsedRealtime) {
mElapsedRealtime = elapsedRealtime;
}
protected void checkExpectations(boolean expectedSetAlarm, boolean expectedCancelAlarm,
boolean expectedStartPrecache) {
assertEquals("Set alarm", expectedSetAlarm, mSetAlarmCalled);
assertEquals("Cancel alarm", expectedCancelAlarm, mCancelAlarmCalled);
assertEquals("Start precache", expectedStartPrecache, mStartPrecacheCalled);
}
}
private static void checkPrefsExpectations(Context context, long expectedLastTime) {
SharedPreferences prefs = context.getSharedPreferences(
context.getPackageName() + "_preferences", Context.MODE_PRIVATE);
assertEquals(expectedLastTime,
prefs.getLong(PrecacheServiceLauncher.PREF_PRECACHE_LAST_TIME, -1L));
}
@SmallTest
@Feature({"Precache"})
public void testDoNothingIfNotEnabled() {
MockPrecacheServiceLauncher launcher = new MockPrecacheServiceLauncher();
MockDeviceState deviceState = new MockDeviceState(0, true, false, true);
launcher.setDeviceState(deviceState);
Context context = getContext(false, 0L);
launcher.setElapsedRealtime(PrecacheServiceLauncher.WAIT_UNTIL_NEXT_PRECACHE_MS);
launcher.onReceive(context, new Intent(PrecacheServiceLauncher.ACTION_ALARM));
launcher.checkExpectations(false, false, false);
checkPrefsExpectations(context, 0L);
}
@SmallTest
@Feature({"Precache"})
public void testGoodConditions() {
MockPrecacheServiceLauncher launcher = new MockPrecacheServiceLauncher();
MockDeviceState deviceState = new MockDeviceState(0, true, false, true);
launcher.setDeviceState(deviceState);
Context context = getContext(true, 0L);
launcher.setElapsedRealtime(PrecacheServiceLauncher.WAIT_UNTIL_NEXT_PRECACHE_MS);
launcher.onReceive(context, new Intent(PrecacheServiceLauncher.ACTION_ALARM));
launcher.checkExpectations(true, false, true);
checkPrefsExpectations(context, PrecacheServiceLauncher.WAIT_UNTIL_NEXT_PRECACHE_MS);
}
@SmallTest
@Feature({"Precache"})
public void testNotEnoughTimeButGoodConditionsOtherwise() {
MockPrecacheServiceLauncher launcher = new MockPrecacheServiceLauncher();
MockDeviceState deviceState = new MockDeviceState(0, true, false, true);
launcher.setDeviceState(deviceState);
Context context = getContext(true, 0L);
launcher.setElapsedRealtime(PrecacheServiceLauncher.WAIT_UNTIL_NEXT_PRECACHE_MS - 1);
launcher.onReceive(context, new Intent(PrecacheServiceLauncher.ACTION_ALARM));
launcher.checkExpectations(true, false, false);
checkPrefsExpectations(context, 0L);
}
@SmallTest
@Feature({"Precache"})
public void testEnoughTimeButNoPower() {
MockPrecacheServiceLauncher launcher = new MockPrecacheServiceLauncher();
MockDeviceState deviceState = new MockDeviceState(0, false, false, true);
launcher.setDeviceState(deviceState);
Context context = getContext(true, 0L);
launcher.setElapsedRealtime(PrecacheServiceLauncher.WAIT_UNTIL_NEXT_PRECACHE_MS - 1);
launcher.onReceive(context, new Intent(PrecacheServiceLauncher.ACTION_ALARM));
launcher.checkExpectations(false, true, false);
checkPrefsExpectations(context, 0L);
}
}
chrome/android/javatests/src/org/chromium/chrome/browser/precache/PrecacheServiceTest.java deleted 100644 → 0
View file @ 62b1a31d
// 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.chrome.browser.precache;
import android.content.Intent;
import android.test.ServiceTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import org.chromium.base.ThreadUtils;
import org.chromium.base.test.util.AdvancedMockContext;
import org.chromium.base.test.util.Feature;
import org.chromium.components.precache.MockDeviceState;
/**
* Tests of {@link PrecacheService}.
*/
public class PrecacheServiceTest extends ServiceTestCase<MockPrecacheService> {
/**
* Mock of the {@link PrecacheLauncher}.
*/
static class MockPrecacheLauncher extends PrecacheLauncher {
private MockPrecacheService mService;
public void setService(MockPrecacheService service) {
mService = service;
}
@Override
public void destroy() {}
@Override
public void start() {}
@Override
public void cancel() {}
@Override
protected void onPrecacheCompleted() {
mService.handlePrecacheCompleted();
}
}
private final MockPrecacheLauncher mPrecacheLauncher = new MockPrecacheLauncher();
public PrecacheServiceTest() {
super(MockPrecacheService.class);
}
@Override
protected void setupService() {
super.setupService();
mPrecacheLauncher.setService(getService());
getService().setPrecacheLauncher(mPrecacheLauncher);
}
private void startAndChangeDeviceState(MockPrecacheService service, boolean powerIsConnected,
boolean isInteractive, boolean wifiIsAvailable) {
AdvancedMockContext context = new AdvancedMockContext();
getService().setDeviceState(new MockDeviceState(0, true, false, true));
assertFalse("Precaching should not be in progress initially", service.isPrecaching());
ThreadUtils.runOnUiThreadBlocking(new Runnable() {
@Override
public void run() {
Intent intent = new Intent(getService(), MockPrecacheService.class);
intent.setAction(PrecacheService.ACTION_START_PRECACHE);
startService(intent);
}
});
assertTrue("Precaching should be in progress after start", service.isPrecaching());
getService().setDeviceState(
new MockDeviceState(0, powerIsConnected, isInteractive, wifiIsAvailable));
service.getDeviceStateReceiver().onReceive(context, new Intent());
}
/** Tests that disconnecting power stops a precache. */
@SmallTest
@Feature({"Precache"})
public void testPrecacheWhenPowerDisconnects() {
setupService();
startAndChangeDeviceState(getService(), false, false, true);
assertFalse("Precaching should not be in progress when power is disconnected",
getService().isPrecaching());
}
/** Tests that the device becoming interactive stops a precache. */
@SmallTest
@Feature({"Precache"})
public void testPrecacheWhenDeviceBecomesInteractive() {
setupService();
startAndChangeDeviceState(getService(), true, true, true);
assertFalse("Precaching should not be in progress when the device is interactive",
getService().isPrecaching());
}
/** Tests that going off of Wi-Fi stops a precache. */
@SmallTest
@Feature({"Precache"})
public void testPrecacheWhenNoLongerWifi() {
setupService();
startAndChangeDeviceState(getService(), true, true, true);
assertFalse("Precaching should not be in progress when the network is not Wi-Fi",
getService().isPrecaching());
}
/** Tests that precaching continues if prerequisites are still met. */
@SmallTest
@Feature({"Precache"})
public void testPrecacheWhenPrerequisitesStillMet() {
setupService();
startAndChangeDeviceState(getService(), true, false, true);
assertTrue("Precaching should be in progress", getService().isPrecaching());
}
/**
* Tests that precaching continues until completion while the prerequisite device states
* (Wifi is in use, power is connected, and the device is non-interactive) continue to be met.
*/
@SmallTest
@Feature({"Precache"})
public void testPrecacheCompleted() {
setupService();
startAndChangeDeviceState(getService(), true, false, true);
assertTrue("Precaching should be in progress", getService().isPrecaching());
mPrecacheLauncher.onPrecacheCompleted();
assertFalse("Precaching should not be in progress after completion",
getService().isPrecaching());
}
}
chrome/android/shell/java/AndroidManifest.xml.jinja2
View file @ 28464ce3
...@@ -192,15 +192,5 @@ ...@@ -192,15 +192,5 @@
<meta-data android:name="org.chromium.chrome.browser.SERVICE_TAB_LAUNCHER" <meta-data android:name="org.chromium.chrome.browser.SERVICE_TAB_LAUNCHER"
android:value="org.chromium.chrome.shell.ChromeShellServiceTabLauncher" /> android:value="org.chromium.chrome.shell.ChromeShellServiceTabLauncher" />
<!-- Precache service. -->
<service android:name="org.chromium.chrome.browser.precache.PrecacheService"
android:exported="false" />
<receiver android:name="org.chromium.chrome.browser.precache.PrecacheServiceLauncher">
<intent-filter>
<action android:name="android.intent.action.ACTION_POWER_CONNECTED"/>
<action android:name="android.intent.action.ACTION_POWER_DISCONNECTED"/>
<action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
</intent-filter>
</receiver>
</application> </application>
</manifest> </manifest>
chrome/browser/android/chrome_jni_registrar.cc
View file @ 28464ce3
...@@ -44,7 +44,6 @@ ...@@ -44,7 +44,6 @@
#include "chrome/browser/android/omnibox/autocomplete_controller_android.h" #include "chrome/browser/android/omnibox/autocomplete_controller_android.h"
#include "chrome/browser/android/omnibox/omnibox_prerender.h" #include "chrome/browser/android/omnibox/omnibox_prerender.h"
#include "chrome/browser/android/password_ui_view_android.h" #include "chrome/browser/android/password_ui_view_android.h"
#include "chrome/browser/android/precache/precache_launcher.h"
#include "chrome/browser/android/preferences/autofill/autofill_profile_bridge.h" #include "chrome/browser/android/preferences/autofill/autofill_profile_bridge.h"
#include "chrome/browser/android/preferences/pref_service_bridge.h" #include "chrome/browser/android/preferences/pref_service_bridge.h"
#include "chrome/browser/android/preferences/website_preference_bridge.h" #include "chrome/browser/android/preferences/website_preference_bridge.h"
...@@ -224,7 +223,6 @@ static base::android::RegistrationMethod kChromeRegisteredMethods[] = { ...@@ -224,7 +223,6 @@ static base::android::RegistrationMethod kChromeRegisteredMethods[] = {
PasswordUIViewAndroid::RegisterPasswordUIViewAndroid}, PasswordUIViewAndroid::RegisterPasswordUIViewAndroid},
{"PersonalDataManagerAndroid", {"PersonalDataManagerAndroid",
autofill::PersonalDataManagerAndroid::Register}, autofill::PersonalDataManagerAndroid::Register},
{"PrecacheLauncher", RegisterPrecacheLauncher},
{"PrefServiceBridge", RegisterPrefServiceBridge}, {"PrefServiceBridge", RegisterPrefServiceBridge},
{"ProfileAndroid", ProfileAndroid::RegisterProfileAndroid}, {"ProfileAndroid", ProfileAndroid::RegisterProfileAndroid},
{"ProfileDownloader", RegisterProfileDownloader}, {"ProfileDownloader", RegisterProfileDownloader},
......
chrome/browser/android/precache/precache_launcher.cc deleted 100644 → 0
View file @ 62b1a31d
// Copyright 2014 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.
#include "chrome/browser/android/precache/precache_launcher.h"
#include <jni.h>
#include "base/android/jni_android.h"
#include "base/android/jni_weak_ref.h"
#include "base/bind.h"
#include "base/logging.h"
#include "base/prefs/pref_service.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/history/top_sites_factory.h"
#include "chrome/browser/precache/most_visited_urls_provider.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "components/data_reduction_proxy/core/common/data_reduction_proxy_pref_names.h"
#include "components/history/core/browser/top_sites.h"
#include "components/precache/content/precache_manager.h"
#include "components/precache/content/precache_manager_factory.h"
#include "jni/PrecacheLauncher_jni.h"
using base::android::AttachCurrentThread;
using precache::PrecacheManager;
namespace {
// Get the profile that should be used for precaching.
Profile* GetProfile() {
Profile* profile = g_browser_process->profile_manager()->GetLastUsedProfile()
->GetOriginalProfile();
DCHECK(profile);
DCHECK(g_browser_process->profile_manager()->IsValidProfile(profile));
return profile;
}
// Get the PrecacheManager for the given |profile|.
PrecacheManager* GetPrecacheManager(Profile* profile) {
PrecacheManager* precache_manager =
precache::PrecacheManagerFactory::GetForBrowserContext(profile);
DCHECK(precache_manager);
return precache_manager;
}
bool IsDataReductionProxyEnabled(Profile* profile) {
// TODO(bengr): Use DataReductionProxySettings instead once it is safe to
// instantiate from here.
PrefService* prefs = profile->GetPrefs();
return prefs && prefs->GetBoolean(
data_reduction_proxy::prefs::kDataReductionProxyEnabled);
}
} // namespace
PrecacheLauncher::PrecacheLauncher(JNIEnv* env, jobject obj)
: weak_java_precache_launcher_(env, obj), weak_factory_(this) {}
PrecacheLauncher::~PrecacheLauncher() {}
void PrecacheLauncher::Destroy(JNIEnv* env, jobject obj) {
delete this;
}
void PrecacheLauncher::Start(JNIEnv* env, jobject obj) {
// TODO(bengr): Add integration tests for the whole feature.
Profile* profile = GetProfile();
PrecacheManager* precache_manager = GetPrecacheManager(profile);
scoped_refptr<history::TopSites> ts = TopSitesFactory::GetForProfile(profile);
precache::MostVisitedURLsProvider url_list_provider(ts.get());
if (!IsDataReductionProxyEnabled(profile)) {
Java_PrecacheLauncher_onPrecacheCompletedCallback(
env, weak_java_precache_launcher_.get(env).obj());
return;
}
precache_manager->StartPrecaching(
base::Bind(&PrecacheLauncher::OnPrecacheCompleted,
weak_factory_.GetWeakPtr()),
&url_list_provider);
}
void PrecacheLauncher::Cancel(JNIEnv* env, jobject obj) {
Profile* profile = GetProfile();
PrecacheManager* precache_manager = GetPrecacheManager(profile);
precache_manager->CancelPrecaching();
}
void PrecacheLauncher::OnPrecacheCompleted() {
JNIEnv* env = AttachCurrentThread();
Java_PrecacheLauncher_onPrecacheCompletedCallback(
env, weak_java_precache_launcher_.get(env).obj());
}
static jlong Init(JNIEnv* env, jobject obj) {
return reinterpret_cast<intptr_t>(new PrecacheLauncher(env, obj));
}
static jboolean IsPrecachingEnabled(JNIEnv* env, jclass clazz) {
return PrecacheManager::IsPrecachingEnabled();
}
bool RegisterPrecacheLauncher(JNIEnv* env) {
return RegisterNativesImpl(env);
}
chrome/browser/android/precache/precache_launcher.h deleted 100644 → 0
View file @ 62b1a31d
// Copyright 2014 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.
#ifndef CHROME_BROWSER_ANDROID_PRECACHE_PRECACHE_LAUNCHER_H_
#define CHROME_BROWSER_ANDROID_PRECACHE_PRECACHE_LAUNCHER_H_
#include <jni.h>
#include "base/android/jni_android.h"
#include "base/android/jni_weak_ref.h"
#include "base/memory/weak_ptr.h"
class PrecacheLauncher {
public:
PrecacheLauncher(JNIEnv* env, jobject obj);
void Destroy(JNIEnv* env, jobject obj);
void Start(JNIEnv* env, jobject obj);
void Cancel(JNIEnv* env, jobject obj);
private:
~PrecacheLauncher();
// Called when precaching completes.
void OnPrecacheCompleted();
JavaObjectWeakGlobalRef weak_java_precache_launcher_;
// This must be the last member field in the class.
base::WeakPtrFactory<PrecacheLauncher> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(PrecacheLauncher);
};
// Registers the native methods to be called from Java.
bool RegisterPrecacheLauncher(JNIEnv* env);
#endif // CHROME_BROWSER_ANDROID_PRECACHE_PRECACHE_LAUNCHER_H_
chrome/chrome.gyp
View file @ 28464ce3
...@@ -619,7 +619,6 @@ ...@@ -619,7 +619,6 @@
'../components/components.gyp:gcm_driver_java', '../components/components.gyp:gcm_driver_java',
'../components/components.gyp:invalidation_java', '../components/components.gyp:invalidation_java',
'../components/components.gyp:navigation_interception_java', '../components/components.gyp:navigation_interception_java',
'../components/components.gyp:precache_java',
'../components/components.gyp:variations_java', '../components/components.gyp:variations_java',
'../components/components.gyp:web_contents_delegate_android_java', '../components/components.gyp:web_contents_delegate_android_java',
'../content/content.gyp:content_java', '../content/content.gyp:content_java',
......
chrome/chrome_browser.gypi
View file @ 28464ce3
...@@ -133,8 +133,6 @@ ...@@ -133,8 +133,6 @@
'browser/android/omnibox/omnibox_prerender.h', 'browser/android/omnibox/omnibox_prerender.h',
'browser/android/password_ui_view_android.cc', 'browser/android/password_ui_view_android.cc',
'browser/android/password_ui_view_android.h', 'browser/android/password_ui_view_android.h',
'browser/android/precache/precache_launcher.cc',
'browser/android/precache/precache_launcher.h',
'browser/android/preferences/autofill/autofill_profile_bridge.cc', 'browser/android/preferences/autofill/autofill_profile_bridge.cc',
'browser/android/preferences/autofill/autofill_profile_bridge.h', 'browser/android/preferences/autofill/autofill_profile_bridge.h',
'browser/android/preferences/pref_service_bridge.cc', 'browser/android/preferences/pref_service_bridge.cc',
...@@ -1658,7 +1656,6 @@ ...@@ -1658,7 +1656,6 @@
'android/java/src/org/chromium/chrome/browser/password_manager/Credential.java', 'android/java/src/org/chromium/chrome/browser/password_manager/Credential.java',
'android/java/src/org/chromium/chrome/browser/password_manager/PasswordAuthenticationManager.java', 'android/java/src/org/chromium/chrome/browser/password_manager/PasswordAuthenticationManager.java',
'android/java/src/org/chromium/chrome/browser/PasswordUIView.java', 'android/java/src/org/chromium/chrome/browser/PasswordUIView.java',
'android/java/src/org/chromium/chrome/browser/precache/PrecacheLauncher.java',
'android/java/src/org/chromium/chrome/browser/preferences/autofill/AutofillProfileBridge.java', 'android/java/src/org/chromium/chrome/browser/preferences/autofill/AutofillProfileBridge.java',
'android/java/src/org/chromium/chrome/browser/preferences/LocationSettings.java', 'android/java/src/org/chromium/chrome/browser/preferences/LocationSettings.java',
'android/java/src/org/chromium/chrome/browser/preferences/PrefServiceBridge.java', 'android/java/src/org/chromium/chrome/browser/preferences/PrefServiceBridge.java',
......
chrome/chrome_tests.gypi
View file @ 28464ce3
...@@ -2913,7 +2913,6 @@ ...@@ -2913,7 +2913,6 @@
'../base/base.gyp:base', '../base/base.gyp:base',
'../base/base.gyp:base_java_test_support', '../base/base.gyp:base_java_test_support',
'../components/components.gyp:invalidation_javatests', '../components/components.gyp:invalidation_javatests',
'../components/components.gyp:precache_javatests',
'../content/content_shell_and_tests.gyp:content_java_test_support', '../content/content_shell_and_tests.gyp:content_java_test_support',
'../sync/sync.gyp:sync_javatests', '../sync/sync.gyp:sync_javatests',
'../ui/android/ui_android.gyp:ui_javatests', '../ui/android/ui_android.gyp:ui_javatests',
......
components/precache.gypi
View file @ 28464ce3
...@@ -70,31 +70,4 @@ ...@@ -70,31 +70,4 @@
'includes': [ '../build/protoc.gypi', ], 'includes': [ '../build/protoc.gypi', ],
}, },
], ],
'conditions': [
['OS=="android"', {
'targets': [{
'target_name': 'precache_java',
'type': 'none',
'dependencies': [
'../base/base.gyp:base',
'../content/content.gyp:content_java',
],
'variables': {
'java_in_dir': 'precache/android/java',
},
'includes': [ '../build/java.gypi' ],
}, {
'target_name': 'precache_javatests',
'type': 'none',
'dependencies': [
'precache_java',
'../base/base.gyp:base_java_test_support',
],
'variables': {
'java_in_dir': 'precache/android/javatests',
},
'includes': [ '../build/java.gypi' ],
}],
}],
],
} }
components/precache/android/BUILD.gn deleted 100644 → 0
View file @ 62b1a31d
# 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.
import("//build/config/android/rules.gni")
# GYP: //components/precache.gypi:precache_java
android_library("precache_java") {
deps = [
"//base:base_java",
]
DEPRECATED_java_in_dir = "java/src"
}
android_library("precache_javatests") {
deps = [
"//base:base_java_test_support",
":precache_java",
]
DEPRECATED_java_in_dir = "javatests/src"
}
components/precache/android/java/src/org/chromium/components/precache/DeviceState.java deleted 100644 → 0
View file @ 62b1a31d
// 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.components.precache;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.os.BatteryManager;
import org.chromium.base.ApiCompatibilityUtils;
import org.chromium.base.VisibleForTesting;
/**
* Utility class that provides information about the current state of the device.
*/
public class DeviceState {
private static DeviceState sDeviceState = null;
/** Disallow Construction of DeviceState objects. Use {@link #getInstance()} instead to create
* a singleton instance.
*/
protected DeviceState() {}
public static DeviceState getInstance() {
if (sDeviceState == null) sDeviceState = new DeviceState();
return sDeviceState;
}
protected NetworkInfoDelegateFactory mNetworkInfoDelegateFactory =
new NetworkInfoDelegateFactory();
@VisibleForTesting
void setNetworkInfoDelegateFactory(NetworkInfoDelegateFactory factory) {
mNetworkInfoDelegateFactory = factory;
}
/** @return integer representing the current status of the battery. */
@VisibleForTesting
int getStickyBatteryStatus(Context context) {
IntentFilter iFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
// Call registerReceiver on context.getApplicationContext(), not on context itself, because
// context could be a BroadcastReceiver context, which would throw an
// android.content.ReceiverCallNotAllowedException.
Intent batteryStatus = context.getApplicationContext().registerReceiver(null, iFilter);
if (batteryStatus == null) {
return BatteryManager.BATTERY_STATUS_UNKNOWN;
}
return batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS,
BatteryManager.BATTERY_STATUS_UNKNOWN);
}
/** @return whether the device is connected to power. */
public boolean isPowerConnected(Context context) {
int status = getStickyBatteryStatus(context);
return status == BatteryManager.BATTERY_STATUS_CHARGING
|| status == BatteryManager.BATTERY_STATUS_FULL;
}
public boolean isInteractive(Context context) {
return ApiCompatibilityUtils.isInteractive(context);
}
/** @return whether the currently active network is Wi-Fi, not roaming, and not metered. */
public boolean isWifiAvailable(Context context) {
NetworkInfoDelegate networkInfo =
mNetworkInfoDelegateFactory.getNetworkInfoDelegate(context);
return (networkInfo.isValid()
&& networkInfo.getType() == ConnectivityManager.TYPE_WIFI
&& networkInfo.isAvailable()
&& networkInfo.isConnected()
&& !networkInfo.isRoaming()
&& !networkInfo.isActiveNetworkMetered());
}
}
components/precache/android/java/src/org/chromium/components/precache/NetworkInfoDelegate.java deleted 100644 → 0
View file @ 62b1a31d
// 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.components.precache;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import org.chromium.base.VisibleForTesting;
/**
* Wrapper class for NetworkInfo and ConnectivityManager.
*/
public class NetworkInfoDelegate {
private NetworkInfo mNetworkInfo;
private ConnectivityManager mConnectivityManager;
@VisibleForTesting
NetworkInfoDelegate() {}
public NetworkInfoDelegate(Context context) {
getNetworkInfo(context);
}
protected void getNetworkInfo(Context context) {
mConnectivityManager =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
}
protected boolean isValid() {
return mNetworkInfo != null;
}
protected int getType() {
return mNetworkInfo.getType();
}
protected boolean isAvailable() {
return mNetworkInfo.isAvailable();
}
protected boolean isConnected() {
return mNetworkInfo.isConnected();
}
protected boolean isRoaming() {
return mNetworkInfo.isRoaming();
}
protected boolean isActiveNetworkMetered() {
// ConnectivityManager.isActiveNetworkMetered was added in SDK API 16.
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
return false;
}
return mConnectivityManager.isActiveNetworkMetered();
}
}
components/precache/android/java/src/org/chromium/components/precache/NetworkInfoDelegateFactory.java deleted 100644 → 0
View file @ 62b1a31d
// 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.components.precache;
import android.content.Context;
/**
* Factory for creating network info delegates.
*/
public class NetworkInfoDelegateFactory {
NetworkInfoDelegate getNetworkInfoDelegate(Context context) {
return new NetworkInfoDelegate(context);
}
}
components/precache/android/javatests/src/org/chromium/components/precache/DeviceStateTest.java deleted 100644 → 0
View file @ 62b1a31d
// 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.components.precache;
import android.content.Context;
import android.net.ConnectivityManager;
import android.os.BatteryManager;
import android.test.InstrumentationTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import org.chromium.base.test.util.AdvancedMockContext;
import org.chromium.base.test.util.Feature;
/**
* Tests for {@link DeviceState}.
*/
public class DeviceStateTest extends InstrumentationTestCase {
/**
* Factory to create {@link MockNetworkInfoDelegate} instances.
*/
static class MockNetworkInfoDelegateFactory extends NetworkInfoDelegateFactory {
private final boolean mIsValid;
private final int mType;
private final boolean mIsAvailable;
private final boolean mIsConnected;
private final boolean mIsRoaming;
private final boolean mIsActiveNetworkMetered;
MockNetworkInfoDelegateFactory(boolean valid, int type, boolean available,
boolean connected, boolean roaming, boolean activeNetworkMetered) {
mIsValid = valid;
mType = type;
mIsAvailable = available;
mIsConnected = connected;
mIsRoaming = roaming;
mIsActiveNetworkMetered = activeNetworkMetered;
}
@Override
NetworkInfoDelegate getNetworkInfoDelegate(Context context) {
return new MockNetworkInfoDelegate(mIsValid, mType, mIsAvailable, mIsConnected,
mIsRoaming, mIsActiveNetworkMetered);
}
}
/**
* Mock of {@link NetworkInfoDelegate}.
*/
static class MockNetworkInfoDelegate extends NetworkInfoDelegate {
private final boolean mIsValid;
private final int mType;
private final boolean mIsAvailable;
private final boolean mIsConnected;
private final boolean mIsRoaming;
private final boolean mIsActiveNetworkMetered;
MockNetworkInfoDelegate(boolean valid, int type, boolean available, boolean connected,
boolean roaming, boolean activeNetworkMetered) {
mIsValid = valid;
mType = type;
mIsAvailable = available;
mIsConnected = connected;
mIsRoaming = roaming;
mIsActiveNetworkMetered = activeNetworkMetered;
}
@Override
protected void getNetworkInfo(Context context) {}
@Override
protected boolean isValid() {
return mIsValid;
}
@Override
protected int getType() {
return mType;
}
@Override
protected boolean isAvailable() {
return mIsAvailable;
}
@Override
protected boolean isConnected() {
return mIsConnected;
}
@Override
protected boolean isRoaming() {
return mIsRoaming;
}
@Override
protected boolean isActiveNetworkMetered() {
return mIsActiveNetworkMetered;
}
}
/**
* Mock of {@link DeviceState}.
*/
static class MockDeviceState extends DeviceState {
int mBatteryStatus;
@Override
int getStickyBatteryStatus(Context context) {
return mBatteryStatus;
}
public void setStickyBatteryStatus(int status) {
mBatteryStatus = status;
}
}
@SmallTest
@Feature({"Precache"})
public void testPowerConnected() {
AdvancedMockContext context = new AdvancedMockContext();
MockDeviceState deviceState = new MockDeviceState();
deviceState.setStickyBatteryStatus(BatteryManager.BATTERY_STATUS_NOT_CHARGING);
assertFalse(deviceState.isPowerConnected(context));
deviceState.setStickyBatteryStatus(BatteryManager.BATTERY_STATUS_CHARGING);
assertTrue(deviceState.isPowerConnected(context));
deviceState.setStickyBatteryStatus(BatteryManager.BATTERY_STATUS_FULL);
assertTrue(deviceState.isPowerConnected(context));
}
@SmallTest
@Feature({"Precache"})
public void testWifiAvailable() {
AdvancedMockContext context = new AdvancedMockContext();
DeviceState deviceState = DeviceState.getInstance();
// Expect WiFi to be reported as available because there is valid {@link NetworkInfo},
// the connection is WiFi, it's available and connected, and not roaming or metered.
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(
true, ConnectivityManager.TYPE_WIFI, true, true, false, false));
assertTrue(deviceState.isWifiAvailable(context));
// Expect WiFi to be reported as unavailable because one of the aforementioned required
// conditions is not met.
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(
false, ConnectivityManager.TYPE_WIFI, true, true, false, false));
assertFalse(deviceState.isWifiAvailable(context));
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(true, 0, false, true, false, false));
assertFalse(deviceState.isWifiAvailable(context));
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(
true, ConnectivityManager.TYPE_WIFI, false, true, false, false));
assertFalse(deviceState.isWifiAvailable(context));
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(
true, ConnectivityManager.TYPE_WIFI, true, false, false, false));
assertFalse(deviceState.isWifiAvailable(context));
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(
true, ConnectivityManager.TYPE_WIFI, true, true, true, false));
assertFalse(deviceState.isWifiAvailable(context));
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(
true, ConnectivityManager.TYPE_WIFI, true, true, false, true));
assertFalse(deviceState.isWifiAvailable(context));
deviceState.setNetworkInfoDelegateFactory(
new MockNetworkInfoDelegateFactory(true, 0, false, false, true, true));
assertFalse(deviceState.isWifiAvailable(context));
}
}
components/precache/android/javatests/src/org/chromium/components/precache/MockDeviceState.java deleted 100644 → 0
View file @ 62b1a31d
// 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.components.precache;
import android.content.Context;
/**
* Mock of the DeviceState class.
*/
public class MockDeviceState extends DeviceState {
private final int mStickyBatteryStatus;
private final boolean mPowerIsConnected;
private final boolean mInteractive;
private final boolean mWifiIsAvailable;
public MockDeviceState(int stickyBatteryStatus, boolean powerIsConnected,
boolean interactive, boolean wifiIsAvailable) {
mStickyBatteryStatus = stickyBatteryStatus;
mPowerIsConnected = powerIsConnected;
mInteractive = interactive;
mWifiIsAvailable = wifiIsAvailable;
}
@Override
int getStickyBatteryStatus(Context context) {
return mStickyBatteryStatus;
}
@Override
public boolean isPowerConnected(Context context) {
return mPowerIsConnected;
}
@Override
public boolean isInteractive(Context context) {
return mInteractive;
}
@Override
public boolean isWifiAvailable(Context context) {
return mWifiIsAvailable;
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment