Remove dependencies of Metrics{Service,Log} on g_browser_process->local_state()

chrome/browser/metrics/metrics_service.h

 // 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.
 
 // This file defines a service that collects information about the user
 // experience in order to help improve future versions of the app.
 
 #ifndef CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 #define CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 
@@ skipping 36 matching lines @@
 class TemplateURLService;
 
 namespace {
 class CrashesDOMHandler;
 class FlashDOMHandler;
 }
 
 namespace base {
 class DictionaryValue;
 class MessageLoopProxy;
+class PrefService;
 }
 
 namespace chrome_variations {
 struct ActiveGroupId;
 }
 
 namespace content {
 class RenderProcessHost;
 class WebContents;
 struct WebPluginInfo;
@@ skipping 57 matching lines @@
     UNINITIALIZED_PHASE = 0,
     START_METRICS_RECORDING = 100,
     CREATE_PROFILE = 200,
     STARTUP_TIMEBOMB_ARM = 300,
     THREAD_WATCHER_START = 400,
     MAIN_MESSAGE_LOOP_RUN = 500,
     SHUTDOWN_TIMEBOMB_ARM = 600,
     SHUTDOWN_COMPLETE = 700,
   };
 
-  // Creates the MetricsService with the given |state_manager|. Does not take
-  // ownership of |state_manager|, instead stores a weak pointer to it. Caller
-  // should ensure that |state_manager| is valid for the lifetime of this class.
-  explicit MetricsService(metrics::MetricsStateManager* state_manager);
+  // Creates the MetricsService with the given |state_manager| and
+  // |local_state|. Does not take ownership of the parameters, instead stores
+  // weak pointers. Caller should ensure that the passed-in objects are valid
+  // for the lifetime of this class.
+  MetricsService(metrics::MetricsStateManager* state_manager,
+                 PrefService* local_state);
   virtual ~MetricsService();
 
   // Initializes metrics recording state. Updates various bookkeeping values in
   // prefs and sets up the scheduler. This is a separate function rather than
   // being done by the constructor so that field trials could be created before
   // this is run.
   void InitializeMetricsRecordingState();
 
   // Starts the metrics system, turning on recording and uploading of metrics.
   // Should be called when starting up with metrics enabled, or when metrics
@@ skipping 80 matching lines @@
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
   // Called when the application is going into background mode.
   void OnAppEnterBackground();
 
   // Called when the application is coming out of background mode.
   void OnAppEnterForeground();
 #else
   // Set the dirty flag, which will require a later call to LogCleanShutdown().
-  static void LogNeedForCleanShutdown();
+  static void LogNeedForCleanShutdown(PrefService* local_state);
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
-  static void SetExecutionPhase(ExecutionPhase execution_phase);
+  static void SetExecutionPhase(ExecutionPhase execution_phase,
+                                PrefService* local_state);
 
   // Saves in the preferences if the crash report registration was successful.
   // This count is eventually send via UMA logs.
   void RecordBreakpadRegistration(bool success);
 
   // Saves in the preferences if the browser is running under a debugger.
   // This count is eventually send via UMA logs.
   void RecordBreakpadHasDebugger(bool has_debugger);
 
 #if defined(OS_WIN)
@@ skipping 228 matching lines @@
 
   // Returns a list of synthetic field trials that were active for the entire
   // duration of the current log.
   void GetCurrentSyntheticFieldTrials(
       std::vector<chrome_variations::ActiveGroupId>* synthetic_trials);
 
   // Used to manage various metrics reporting state prefs, such as client id,
   // low entropy source and whether metrics reporting is enabled. Weak pointer.
   metrics::MetricsStateManager* state_manager_;
 
+  PrefService* local_state_;
+
   base::ActionCallback action_callback_;
 
   content::NotificationRegistrar registrar_;
 
   // Set to true when |ResetMetricsIDsIfNecessary| is called for the first time.
   // This prevents multiple resets within the same Chrome session.
   bool metrics_ids_reset_check_performed_;
 
   // Indicate whether recording and reporting are currently happening.
   // These should not be set directly, but by calling SetRecording and
@@ skipping 124 matching lines @@
   friend class extensions::MetricsPrivateGetIsCrashReportingEnabledFunction;
   friend class ::FlashDOMHandler;
   friend class system_logs::ChromeInternalLogSource;
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, MetricsReportingEnabled);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, CrashReportingEnabled);
 
   // Returns true if prefs::kMetricsReportingEnabled is set.
   // TODO(asvitkine): Consolidate the method in MetricsStateManager.
   // TODO(asvitkine): This function does not report the correct value on
   // Android and ChromeOS, see http://crbug.com/362192.
-  static bool IsMetricsReportingEnabled();
+  static bool IsMetricsReportingEnabled(const PrefService* local_state);

[Alexei Svitkine (slow), 2014/05/19 13:13:54]

Hmm, so we have a separate bug to move MetricsServiceHelper to its own file (and
eventually for it to go through MetricsStateManager) - so with that eventual
goal, we wouldn't need these params to be passed anyway. (Sorry that I didn't
make that clear on the bug... my bad.)

Given the above, I think this part can be reverted.

[blundell, 2014/05/19 13:49:28]

Are we not going to need to access this API from the component? I thought that
MetricsServiceHelper was going to become the //chrome implementation of a
component-level interface.

On 2014/05/19 13:13:54, Alexei Svitkine wrote:

[Alexei Svitkine (slow), 2014/05/19 13:53:44]

Not quite. The idea is that the implementation should be in
MetricsServiceHelper, but to also have a ChromeMetricsServiceHelper that extends
it just to provide the friend declarations above.

The MetricsServiceHelper should just be an accessor over MetricsService (or
other classes e.g. MetricsStateManager), so it shouldn't need an additional
local_state param.

 
   // Returns true if crash reporting is enabled.  This is set at the platform
   // level for Android and ChromeOS, and otherwise is the same as
   // IsMetricsReportingEnabled for desktop Chrome.
-  static bool IsCrashReportingEnabled();
+  static bool IsCrashReportingEnabled(const PrefService* local_state);
 
   // Registers/unregisters |observer| to receive MetricsLog notifications
   // from metrics service.
   static void AddMetricsServiceObserver(MetricsServiceObserver* observer);
   static void RemoveMetricsServiceObserver(MetricsServiceObserver* observer);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MetricsServiceHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_