Record precache periodic task interval

chrome/android/java/src/org/chromium/chrome/browser/precache/PrecacheController.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.chrome.browser.precache;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
@@ skipping 58 matching lines @@
     public static final String CONTINUATION_TASK_TAG = "precache-continuation";
 
     static final int WAIT_UNTIL_NEXT_PRECACHE_SECONDS = 6 * 60 * 60;  // 6 hours.
     static final int COMPLETION_TASK_MIN_DELAY_SECONDS = 5 * 60; // 5 minutes.
     static final int COMPLETION_TASK_MAX_DELAY_SECONDS = 60 * 60; // 1 hour.
     static final int MAX_SYNC_SERVICE_INIT_TIMOUT_MS = 5 * 60 * 1000; // 5 minutes
     static final int MAX_PRECACHE_DURATION_SECONDS = 30 * 60;  // 30 minutes.
     static final Set<Integer> SYNC_SERVICE_CONFIGURED_DATATYPES =
             Collections.unmodifiableSet(new HashSet<Integer>(Arrays.asList(ModelType.SESSIONS)));
 
+    private static final String PREF_PRECACHE_PERIODIC_TASK_START_TIME_MS =
+            "precache.periodic_task_start_time_ms";
+
     /**
      * Singleton instance of the PrecacheController. PrecacheController is a
      * singleton so that there is a single handle by which to determine if
      * precaching is underway, and to cancel it if necessary.
      */
     private static PrecacheController sInstance;
 
     /**
      * The default task scheduler. Overridden for tests.
      */
@@ skipping 259 matching lines @@
         assert mNonThreadSafe.calledOnValidThread();
         Log.v(TAG, "precache task (%s) started", tag);
         if (!isPrecachingEnabled()) {
             Log.v(TAG, "precaching isn't enabled");
             cancelPeriodicPrecacheTask(mAppContext);
             cancelPrecacheCompletionTask(mAppContext);
             return GcmNetworkManager.RESULT_SUCCESS;
         }
         if (setIsPrecaching(true)) {
             if (PERIODIC_TASK_TAG.equals(tag)) {
+                recordPeriodicTaskIntervalHistogram();
                 cancelPrecacheCompletionTask(mAppContext);
             }
             startPrecachingAfterSyncInit();
             return GcmNetworkManager.RESULT_SUCCESS;
         }
         Log.v(TAG, "precache session was already running");
         return GcmNetworkManager.RESULT_FAILURE;
     }
 
     @VisibleForTesting
@@ skipping 129 matching lines @@
     @VisibleForTesting
     void setPrecacheLauncher(PrecacheLauncher precacheLauncher) {
         assert mNonThreadSafe.calledOnValidThread();
         mPrecacheLauncher = precacheLauncher;
     }
 
     @VisibleForTesting
     static void setTaskScheduler(PrecacheTaskScheduler taskScheduler) {
         PrecacheController.sTaskScheduler = taskScheduler;
     }
+
+    private static void recordPeriodicTaskIntervalHistogram() {
+        SharedPreferences prefs = ContextUtils.getAppSharedPreferences();
+        long previous_start_time_ms = prefs.getLong(PREF_PRECACHE_PERIODIC_TASK_START_TIME_MS, 0);
+        long current_start_time_ms = System.currentTimeMillis();
+        if (previous_start_time_ms > 0 && current_start_time_ms > previous_start_time_ms) {
+            int interval_mins =
+                    (int) ((current_start_time_ms - previous_start_time_ms) / (1000 * 60));
+            RecordHistogram.recordCustomCountHistogram(
+                    "Precache.PeriodicTaskInterval", interval_mins, 1, 10000, 50);
+        }
+        prefs.edit()
+                .putLong(PREF_PRECACHE_PERIODIC_TASK_START_TIME_MS, current_start_time_ms)
+                .apply();
+    }
 }