Plumbing for variations headers from synthetic field trials.

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_
 
 #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/time/time.h"
 #include "components/metrics/clean_exit_beacon.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/variations/active_field_trials.h"
 
 class MetricsServiceAccessor;
 class PrefService;
 class PrefRegistrySimple;
@@ skipping 35 matching lines @@
   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);
 };
 
+// Interface class to observe changes to synthetic trials in MetricsService.
+class SyntheticTrialObserver {
+ public:
+  // Called when the list of synthetic field trial groups has changed.
+  virtual void OnSyntheticTrialsChanged(
+      const std::vector<SyntheticTrialGroup>& groups) = 0;
+
+ protected:
+  virtual ~SyntheticTrialObserver() {}
+};
+
 // 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,
@@ skipping 115 matching lines @@
   // Registers a field trial name and group to be used to annotate a UMA report
   // with a particular Chrome configuration state. A UMA report will be
   // 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);
 
+  // Adds an observer to be notified when the synthetic trials list changes.
+  void AddSyntheticTrialObserver(SyntheticTrialObserver* observer);
+
+  // Removes an existing observer of synthetic trials list changes.
+  void RemoveSyntheticTrialObserver(SyntheticTrialObserver* observer);
+
   // Register the specified |provider| to provide additional metrics into the
   // UMA log. Should be called during MetricsService initialization only.
   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);
 
@@ skipping 127 matching lines @@
   // Records state that should be periodically saved, like uptime and
   // buffered plugin stability statistics.
   void RecordCurrentState(PrefService* pref);
 
   // Checks whether events should currently be logged.
   bool ShouldLogEvents();
 
   // Sets the value of the specified path in prefs and schedules a save.
   void RecordBooleanPrefValue(const char* path, bool value);
 
+  // Notifies observers on a synthetic trial list change.
+  void NotifySyntheticTrialObservers();
+
   // 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);
 
   // Records the current environment (system profile) in |log|.
   void RecordCurrentEnvironment(MetricsLog* log);
@@ skipping 69 matching lines @@
 
   // Stores the time of the first call to |GetUptimes()|.
   base::TimeTicks first_updated_time_;
 
   // Stores the time of the last call to |GetUptimes()|.
   base::TimeTicks last_updated_time_;
 
   // Field trial groups that map to Chrome configuration states.
   SyntheticTrialGroups synthetic_trial_groups_;
 
+  // List of observers of |synthetic_trial_groups_| changes.
+  ObserverList<SyntheticTrialObserver> synthetic_trial_observer_list_;
+
   // Execution phase the browser is in.
   static ExecutionPhase execution_phase_;
 
   // Reduntant marker to check that we completed our shutdown, and set the
   // exited-cleanly bit in the prefs.
   static ShutdownCleanliness clean_shutdown_status_;
 
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, IsPluginProcess);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest,
                            PermutedEntropyCacheClearedWhenLowEntropyReset);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, RegisterSyntheticTrial);
 
   // Weak pointers factory used to post task on different threads. All weak
   // pointers managed by this factory have the same lifetime as MetricsService.
   base::WeakPtrFactory<MetricsService> self_ptr_factory_;
 
   // Weak pointers factory used for saving state. All weak pointers managed by
   // this factory are invalidated in ScheduleNextStateSave.
   base::WeakPtrFactory<MetricsService> state_saver_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
 }  // namespace metrics
 
 #endif  // COMPONENTS_METRICS_METRICS_SERVICE_H_