[Metrics] Make MetricsStateManager take a callback param to check if UMA is enabled.

chrome/browser/metrics/metrics_service_unittest.cc

 // 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.
 
 #include "chrome/browser/metrics/metrics_service.h"
 
 #include <string>
 
-#include "base/command_line.h"
+#include "base/bind.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/browser/metrics/metrics_state_manager.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/scoped_testing_local_state.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "components/metrics/metrics_service_observer.h"
 #include "components/variations/metrics_util.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size.h"
@@ skipping 60 matching lines @@
     return 1;
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestMetricsLog);
 };
 
 class MetricsServiceTest : public testing::Test {
  public:
   MetricsServiceTest()
       : testing_local_state_(TestingBrowserProcess::GetGlobal()),
-        metrics_state_manager_(metrics::MetricsStateManager::Create(
-            GetLocalState())) {
+        is_metrics_reporting_enabled_(false),
+        metrics_state_manager_(
+            metrics::MetricsStateManager::Create(
+                GetLocalState(),
+                base::Bind(&MetricsServiceTest::is_metrics_reporting_enabled,
+                           base::Unretained(this)))) {
   }
 
   virtual ~MetricsServiceTest() {
     MetricsService::SetExecutionPhase(MetricsService::UNINITIALIZED_PHASE);
   }
 
   metrics::MetricsStateManager* GetMetricsStateManager() {
     return metrics_state_manager_.get();
   }
 
   PrefService* GetLocalState() {
     return testing_local_state_.Get();
   }
 
   // Sets metrics reporting as enabled for testing.
   void EnableMetricsReporting() {
-    // TODO(asvitkine): Refactor the code to not need this flag and delete it.
-    CommandLine::ForCurrentProcess()->AppendSwitch(
-        switches::kEnableMetricsReportingForTesting);
+    is_metrics_reporting_enabled_ = true;
   }
 
   // Waits until base::TimeTicks::Now() no longer equals |value|. This should
   // take between 1-15ms per the documented resolution of base::TimeTicks.
   void WaitUntilTimeChanges(const base::TimeTicks& value) {
     while (base::TimeTicks::Now() == value) {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
     }
   }
 
   // Returns true if there is a synthetic trial in the given vector that matches
   // the given trial name and trial group; returns false otherwise.
   bool HasSyntheticTrial(
       const std::vector<variations::ActiveGroupId>& synthetic_trials,
       const std::string& trial_name,
       const std::string& trial_group) {
     uint32 trial_name_hash = metrics::HashName(trial_name);
     uint32 trial_group_hash = metrics::HashName(trial_group);
     for (std::vector<variations::ActiveGroupId>::const_iterator it =
              synthetic_trials.begin();
          it != synthetic_trials.end(); ++it) {
       if ((*it).name == trial_name_hash && (*it).group == trial_group_hash)
         return true;
     }
     return false;
   }
 
  private:
+  bool is_metrics_reporting_enabled() const {
+    return is_metrics_reporting_enabled_;
+  }
+
   content::TestBrowserThreadBundle thread_bundle_;
   ScopedTestingLocalState testing_local_state_;
+  bool is_metrics_reporting_enabled_;
   scoped_ptr<metrics::MetricsStateManager> metrics_state_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsServiceTest);
 };
 
 class TestMetricsServiceObserver : public MetricsServiceObserver {
  public:
   TestMetricsServiceObserver(): observed_(0) {}
   virtual ~TestMetricsServiceObserver() {}
 
@@ skipping 201 matching lines @@
 
   service.RemoveObserver(&observer1);
 
   service.OpenNewLog();
   EXPECT_EQ(2, observer1.observed());
   EXPECT_EQ(2, observer2.observed());
   service.log_manager_.FinishCurrentLog();
 
   service.RemoveObserver(&observer2);
 }