Move more metrics classes to metrics namespace.

components/metrics/metrics_service.h

 // 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.
 
 // This file defines a service that collects information about the user
 // experience in order to help improve future versions of the app.
 
 #ifndef COMPONENTS_METRICS_METRICS_SERVICE_H_
 #define COMPONENTS_METRICS_METRICS_SERVICE_H_
 
@@ skipping 13 matching lines @@
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "components/metrics/metrics_log.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"
 
-class MetricsReportingScheduler;
+class MetricsServiceAccessor;
 class PrefService;
 class PrefRegistrySimple;
 
 namespace base {
 class DictionaryValue;
 class HistogramSamples;
 class MessageLoopProxy;
 class PrefService;
 }
 
 namespace variations {
 struct ActiveGroupId;
 }
 
-namespace metrics {
-class MetricsLogUploader;
-class MetricsServiceClient;
-class MetricsStateManager;
-}
-
 namespace net {
 class URLFetcher;
 }
 
+namespace metrics {
+
+class MetricsLogUploader;
+class MetricsReportingScheduler;
+class MetricsServiceClient;
+class MetricsStateManager;
+
 // A Field Trial and its selected group, which represent a particular
 // Chrome configuration state. For example, the trial name could map to
 // a preference name, and the group name could map to a preference value.
 struct SyntheticTrialGroup {
  public:
   ~SyntheticTrialGroup();
 
   variations::ActiveGroupId id;
   base::TimeTicks start_time;
 
  private:
   // Synthetic field trial users:
-  friend class MetricsServiceAccessor;
+  friend class ::MetricsServiceAccessor;
   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);
 };
 
 // See metrics_service.cc for a detailed description.
 class MetricsService : public base::HistogramFlattener {
  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,
     SHUTDOWN_COMPLETE = 700,
   };
 
   // Creates the MetricsService with the given |state_manager|, |client|, and
   // |local_state|.  Does not take ownership of the paramaters; instead stores
   // a weak pointer to each. Caller should ensure that the parameters are valid
   // for the lifetime of this class.
-  MetricsService(metrics::MetricsStateManager* state_manager,
-                 metrics::MetricsServiceClient* client,
+  MetricsService(MetricsStateManager* state_manager,
+                 MetricsServiceClient* client,
                  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.
@@ skipping 96 matching lines @@
   // annotated with this trial group if and only if all events in the report
   // were created after the trial is registered. Only one group name may be
   // registered at a time for a given trial_name. Only the last group name that
   // is registered for a given trial name will be recorded. The values passed
   // in must not correspond to any real field trial in the code.
   // To use this method, SyntheticTrialGroup should friend your class.
   void RegisterSyntheticFieldTrial(const SyntheticTrialGroup& trial_group);
 
   // 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);
+  void RegisterMetricsProvider(scoped_ptr<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_; }
+  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.
@@ skipping 127 matching lines @@
 
   // 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_;
+  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_;
+  MetricsStateManager* const state_manager_;
 
   // Used to interact with the embedder. Weak pointer; must outlive |this|
   // instance.
-  metrics::MetricsServiceClient* const client_;
+  MetricsServiceClient* const client_;
 
   // Registered metrics providers.
-  ScopedVector<metrics::MetricsProvider> metrics_providers_;
+  ScopedVector<MetricsProvider> metrics_providers_;
 
   PrefService* local_state_;
 
   base::ActionCallback action_callback_;
 
   // Indicate whether recording and reporting are currently happening.
   // These should not be set directly, but by calling SetRecording and
   // SetReporting.
   bool recording_active_;
   bool reporting_active_;
 
   // Indicate whether test mode is enabled, where the initial log should never
   // be cut, and logs are neither persisted nor uploaded.
   bool test_mode_active_;
 
   // The progression of states made by the browser are recorded in the following
   // state.
   State state_;
 
   // Whether the initial stability log has been recorded during startup.
   bool has_initial_stability_log_;
 
   // The initial metrics log, used to record startup metrics (histograms and
   // profiler data). Note that if a crash occurred in the previous session, an
   // initial stability log may be sent before this.
   scoped_ptr<MetricsLog> initial_metrics_log_;
 
   // Instance of the helper class for uploading logs.
-  scoped_ptr<metrics::MetricsLogUploader> log_uploader_;
+  scoped_ptr<MetricsLogUploader> log_uploader_;
 
   // Whether there is a current log upload in progress.
   bool log_upload_in_progress_;
 
   // Whether the MetricsService object has received any notifications since
   // the last time a transmission was sent.
   bool idle_since_last_transmission_;
 
   // A number that identifies the how many times the app has been launched.
   int session_id_;
@@ skipping 23 matching lines @@
   static ShutdownCleanliness clean_shutdown_status_;
 
   // Field trial groups that map to Chrome configuration states.
   SyntheticTrialGroups synthetic_trial_groups_;
 
   ObserverList<MetricsServiceObserver> observers_;
 
   // Confirms single-threaded access to |observers_| in debug builds.
   base::ThreadChecker thread_checker_;
 
-  friend class MetricsServiceAccessor;
+  friend class ::MetricsServiceAccessor;
 
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, IsPluginProcess);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, MetricsServiceObserver);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest,
                            PermutedEntropyCacheClearedWhenLowEntropyReset);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, RegisterSyntheticTrial);
 
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
+}  // namespace metrics
+
 #endif  // COMPONENTS_METRICS_METRICS_SERVICE_H_