Inform GetEntropySource of whether or not metrics reporting will be enabled.

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 69 matching lines @@
   // in tests only.
   void Start();
   void StartRecordingOnly();
   void Stop();
 
   // Returns the client ID for this client, or the empty string if metrics
   // recording is not currently running.
   std::string GetClientId();
 
   // Returns the preferred entropy source used to seed persistent activities
-  // based on whether or not metrics reporting is permitted on this client. If
-  // it is permitted, this returns the client ID concatenated with the low
-  // entropy source. Otherwise, this just returns the low entropy source.
-  std::string GetEntropySource();
+  // based on whether or not metrics reporting will permitted on this client.
+  // The caller must determine if metrics reporting will be enabled for this
+  // client and pass that state in as |reporting_will_be_enabled|. If
+  // |reporting_will_be_enabled| is true, this method returns the client ID
+  // concatenated with the low entropy source. Otherwise, this method just
+  // returns the low entropy source. Note that this reporting state can not be
+  // checked by reporting_active() because this method may need to be called
+  // before the MetricsService needs to be started.
+  std::string GetEntropySource(bool reporting_will_be_enabled);
 
   // Force the client ID to be generated. This is useful in case it's needed
   // before recording.
   void ForceClientIdCreation();
 
   // At startup, prefs needs to be called with a list of all the pref names and
   // types we'll be using.
   static void RegisterPrefs(PrefService* local_state);
 
   // Set up notifications which indicate that a user is performing work. This is
@@ skipping 66 matching lines @@
     INITIAL_LOG_READY,      // Initial log generated, and waiting for reply.
     SENDING_OLD_LOGS,       // Sending unsent logs from previous session.
     SENDING_CURRENT_LOGS,   // Sending standard current logs as they acrue.
   };
 
   enum ShutdownCleanliness {
     CLEANLY_SHUTDOWN = 0xdeadbeef,
     NEED_TO_SHUTDOWN = ~CLEANLY_SHUTDOWN
   };
 
+  // Designates which entropy source was returned from this MetricsService.
+  // This is used for testing to validate that we return the correct source
+  // depending on the state of the service.
+  enum EntropySourceReturned {
+    LAST_ENTROPY_NONE,
+    LAST_ENTROPY_LOW,
+    LAST_ENTROPY_HIGH,
+  };
+
   // First part of the init task. Called on the FILE thread to load hardware
   // class information.
   static void InitTaskGetHardwareClass(base::WeakPtr<MetricsService> self,
                                        base::MessageLoopProxy* target_loop);
 
   // Callback from InitTaskGetHardwareClass() that continues the init task by
   // loading plugin information.
   void OnInitTaskGotHardwareClass(const std::string& hardware_class);
 
   // Callback from PluginService::GetPlugins() that continues the init task by
@@ skipping 16 matching lines @@
       const tracked_objects::ProcessDataSnapshot& process_data,
       content::ProcessType process_type) OVERRIDE;
   // Callback that moves the state to INIT_TASK_DONE.
   virtual void FinishedReceivingProfilerData() OVERRIDE;
 
   // Returns the low entropy source for this client. This is a random value
   // that is non-identifying amongst browser clients. This method will
   // generate the entropy source value if it has not been called before.
   int GetLowEntropySource();
 
+  // Returns the last entropy source that was returned by this service since
+  // start up, or NONE if neither was returned yet. This is exposed for testing
+  // only.
+  EntropySourceReturned entropy_source_returned() const {
+    return entropy_source_returned_;
+  }
+
   // When we start a new version of Chromium (different from our last run), we
   // need to discard the old crash stats so that we don't attribute crashes etc.
   // in the old version to the current version (via current logs).
   // Without this, a common reason to finally start a new version is to crash
   // the old version (after an autoupdate has arrived), and so we'd bias
   // initial results towards showing crashes :-(.
   static void DiscardOldStabilityStats(PrefService* local_state);
 
   // Sets and gets whether metrics recording is active.
   // SetRecording(false) also forces a persistent save of logging state (if
@@ skipping 229 matching lines @@
 
   // Indicates that an asynchronous reporting step is running.
   // This is used only for debugging.
   bool waiting_for_asynchronous_reporting_step_;
 
 #if defined(OS_CHROMEOS)
   // The external metric service is used to log ChromeOS UMA events.
   scoped_refptr<chromeos::ExternalMetrics> external_metrics_;
 #endif
 
+  // The last entropy source returned by this service, used for testing.
+  EntropySourceReturned entropy_source_returned_;
+
   // 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, ClientIdCorrectlyFormatted);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, IsPluginProcess);
+  FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, CheckLowEntropySourceUsed);
+  FRIEND_TEST_ALL_PREFIXES(MetricsServiceReportingTest,
+                           CheckHighEntropySourceUsed);
 
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
 // This class limits and documents access to the IsMetricsReportingEnabled()
 // method. Since the method is private, each user has to be explicitly declared
 // as a 'friend' below.
 class MetricsServiceHelper {
  private:
   friend bool prerender::IsOmniboxEnabled(Profile* profile);
   friend class extensions::ExtensionDownloader;
 
   // Returns true if prefs::kMetricsReportingEnabled is set.
   static bool IsMetricsReportingEnabled();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MetricsServiceHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_