Domain Reliability: Don't upload when metrics reporting is off.

components/domain_reliability/monitor_unittest.cc

 // 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.
 
 #include "components/domain_reliability/monitor.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/testing_pref_service.h"
 #include "base/test/test_simple_task_runner.h"
 #include "components/domain_reliability/baked_in_configs.h"
 #include "components/domain_reliability/beacon.h"
 #include "components/domain_reliability/config.h"
 #include "components/domain_reliability/test_util.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace domain_reliability {
 
 namespace {
 
 typedef std::vector<DomainReliabilityBeacon> BeaconVector;
 
 static const size_t kAlwaysReportIndex = 0u;
 static const size_t kNeverReportIndex = 1u;
 
+static const char* kPrefName = "reporting_enabled";
+
 scoped_refptr<net::HttpResponseHeaders> MakeHttpResponseHeaders(
     const std::string& headers) {
   return scoped_refptr<net::HttpResponseHeaders>(
       new net::HttpResponseHeaders(net::HttpUtil::AssembleRawHeaders(
           headers.c_str(), headers.length())));
 }
 
 }  // namespace
 
 class DomainReliabilityMonitorTest : public testing::Test {
  protected:
   typedef DomainReliabilityMonitor::RequestInfo RequestInfo;
 
   DomainReliabilityMonitorTest()
       : network_task_runner_(new base::TestSimpleTaskRunner()),
         url_request_context_getter_(
             new net::TestURLRequestContextGetter(network_task_runner_)),
         time_(new MockTime()),
         monitor_("test-reporter", scoped_ptr<MockableTime>(time_)),
         context_(NULL) {
-    monitor_.Init(url_request_context_getter_);
+    // This will block uploads, but there's no test for whether uploads happen.
+    // TODO(ttuttle): Test that uploads actually happen.
+    pref_service_.registry()->RegisterBooleanPref(kPrefName, false);
+    pref_service_.SetUserPref(kPrefName, new base::FundamentalValue(true));
+    monitor_.InitReportingPref(
+        &pref_service_, kPrefName, network_task_runner_);
+    monitor_.InitURLRequestContext(url_request_context_getter_);
     context_ = monitor_.AddContextForTesting(MakeTestConfig());
   }
 
   static RequestInfo MakeRequestInfo() {
     RequestInfo request;
     request.status = net::URLRequestStatus();
     request.status.set_status(net::URLRequestStatus::SUCCESS);
     request.status.set_error(net::OK);
     request.response_info.socket_address =
         net::HostPortPair::FromString("12.34.56.78:80");
@@ skipping 36 matching lines @@
     return expected_successful == successful && expected_failed == failed;
   }
 
   DomainReliabilityContext* CreateAndAddContext(const std::string& domain) {
     return monitor_.AddContextForTesting(MakeTestConfigWithDomain(domain));
   }
 
   scoped_refptr<base::TestSimpleTaskRunner> network_task_runner_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   MockTime* time_;
+  TestingPrefServiceSimple pref_service_;
   DomainReliabilityMonitor monitor_;
   DomainReliabilityContext* context_;
   DomainReliabilityMonitor::RequestInfo request_;
 };
 
 namespace {
 
 TEST_F(DomainReliabilityMonitorTest, Create) {
   EXPECT_EQ(0u, CountPendingBeacons());
   EXPECT_TRUE(CheckRequestCounts(kAlwaysReportIndex, 0u, 0u));
@@ skipping 251 matching lines @@
   request.url = GURL("http://test.wildcard/always_report");
   OnRequestLegComplete(request);
 
   EXPECT_TRUE(CheckRequestCounts(context1, kAlwaysReportIndex, 1u, 0u));
   EXPECT_TRUE(CheckRequestCounts(context2, kAlwaysReportIndex, 0u, 0u));
 }
 
 }  // namespace
 
 }  // namespace domain_reliability