[Metrics] Merge MetricsService and MetricsServiceBase classes.

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_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
+#include "base/metrics/histogram_flattener.h"
+#include "base/metrics/histogram_snapshot_manager.h"
 #include "base/metrics/user_metrics.h"
 #include "base/observer_list.h"
 #include "base/process/kill.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/tracking_synchronizer_observer.h"
-#include "chrome/common/metrics/metrics_service_base.h"
+#include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/metrics_service_observer.h"
 #include "components/variations/active_field_trials.h"
 #include "content/public/browser/browser_child_process_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/user_metrics.h"
 #include "net/url_request/url_fetcher_delegate.h"
 
 class ChromeBrowserMetricsServiceObserver;
 class GoogleUpdateMetricsProviderWin;
 class MetricsReportingScheduler;
 class PrefService;
 class PrefRegistrySimple;
 class Profile;
 class TemplateURLService;
 
 namespace {
 class CrashesDOMHandler;
 class FlashDOMHandler;
 }
 
 namespace base {
 class DictionaryValue;
+class HistogramSamples;
 class MessageLoopProxy;
 }
 
 namespace variations {
 struct ActiveGroupId;
 }
 
 namespace content {
 class RenderProcessHost;
 class WebContents;
@@ skipping 41 matching lines @@
   friend class MetricsService;
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, RegisterSyntheticTrial);
 
   // This constructor is private specifically so as to control which code is
   // able to access it. New code that wishes to use it should be added as a
   // friend class.
   SyntheticTrialGroup(uint32 trial, uint32 group);
 };
 
 class MetricsService
-    : public chrome_browser_metrics::TrackingSynchronizerObserver,
+    : public base::HistogramFlattener,
+      public chrome_browser_metrics::TrackingSynchronizerObserver,
       public content::BrowserChildProcessObserver,
       public content::NotificationObserver,
-      public net::URLFetcherDelegate,
-      public MetricsServiceBase {
+      public net::URLFetcherDelegate {
  public:
   // The execution phase of the browser.
   enum ExecutionPhase {
     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,
@@ skipping 55 matching lines @@
   // At startup, prefs needs to be called with a list of all the pref names and
   // types we'll be using.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Set up notifications which indicate that a user is performing work. This is
   // useful to allow some features to sleep, until the machine becomes active,
   // such as precluding UMA uploads unless there was recent activity.
   static void SetUpNotifications(content::NotificationRegistrar* registrar,
                                  content::NotificationObserver* observer);
 
+  // HistogramFlattener:
+  virtual void RecordDelta(const base::HistogramBase& histogram,
+                           const base::HistogramSamples& snapshot) OVERRIDE;
+  virtual void InconsistencyDetected(
+      base::HistogramBase::Inconsistency problem) OVERRIDE;
+  virtual void UniqueInconsistencyDetected(
+      base::HistogramBase::Inconsistency problem) OVERRIDE;
+  virtual void InconsistencyDetectedInLoggedCount(int amount) OVERRIDE;
+
   // Implementation of content::BrowserChildProcessObserver
   virtual void BrowserChildProcessHostConnected(
       const content::ChildProcessData& data) OVERRIDE;
   virtual void BrowserChildProcessCrashed(
       const content::ChildProcessData& data) OVERRIDE;
   virtual void BrowserChildProcessInstanceCreated(
       const content::ChildProcessData& data) OVERRIDE;
 
-  // Implementation of content::NotificationObserver
+  // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // This should be called when the application is not idle, i.e. the user seems
   // to be interacting with the application.
   void OnApplicationNotIdle();
 
   // Invoked when we get a WM_SESSIONEND. This places a value in prefs that is
   // reset when RecordCompletedSessionEnd is invoked.
@@ skipping 57 matching lines @@
   // Register the specified |provider| to provide additional metrics into the
   // UMA log. Should be called during MetricsService initialization only.
   void RegisterMetricsProvider(scoped_ptr<metrics::MetricsProvider> provider);
 
   // Check if this install was cloned or imaged from another machine. If a
   // clone is detected, reset the client id and low entropy source. This
   // should not be called more than once.
   void CheckForClonedInstall(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
+ protected:
+  // Exposed for testing.
+  metrics::MetricsLogManager* log_manager() { return &log_manager_; }
+
  private:
   // The MetricsService has a lifecycle that is stored as a state.
   // See metrics_service.cc for description of this lifecycle.
   enum State {
     INITIALIZED,                    // Constructor was called.
     INIT_TASK_SCHEDULED,            // Waiting for deferred init tasks to
                                     // complete.
     INIT_TASK_DONE,                 // Waiting for timer to send initial log.
     SENDING_INITIAL_STABILITY_LOG,  // Initial stability log being sent.
     SENDING_INITIAL_METRICS_LOG,    // Initial metrics log being sent.
@@ skipping 173 matching lines @@
   static bool IsPluginProcess(int process_type);
 
   // Returns a list of synthetic field trials that were active for the entire
   // duration of the current log.
   void GetCurrentSyntheticFieldTrials(
       std::vector<variations::ActiveGroupId>* synthetic_trials);
 
   // Creates a new MetricsLog instance with the given |log_type|.
   scoped_ptr<MetricsLog> CreateLog(MetricsLog::LogType log_type);
 
+  // Record complete list of histograms into the current log.
+  // Called when we close a log.
+  void RecordCurrentHistograms();
+
+  // Record complete list of stability histograms into the current log,
+  // i.e., histograms with the |kUmaStabilityHistogramFlag| flag set.
+  void RecordCurrentStabilityHistograms();
+
+  // Manager for the various in-flight logs.
+  metrics::MetricsLogManager log_manager_;
+
+  // |histogram_snapshot_manager_| prepares histogram deltas for transmission.
+  base::HistogramSnapshotManager histogram_snapshot_manager_;
+
   // 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* const state_manager_;
 
   // Used to interact with the embedder. Weak pointer; must outlive |this|
   // instance.
   metrics::MetricsServiceClient* const client_;
 
   // Registered metrics providers.
   ScopedVector<metrics::MetricsProvider> metrics_providers_;
@@ skipping 137 matching lines @@
 
   // 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_