Domain Reliability: Get correct reporting pref once, on startup

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()
       : pref_task_runner_(new base::TestSimpleTaskRunner()),
         network_task_runner_(new base::TestSimpleTaskRunner()),
         url_request_context_getter_(
             new net::TestURLRequestContextGetter(network_task_runner_)),
         time_(new MockTime()),
-        pref_service_(CreatePrefService()),
         monitor_("test-reporter",
                  pref_task_runner_,
                  network_task_runner_,
-                 pref_service_.get(),
-                 kPrefName,
                  scoped_ptr<MockableTime>(time_)),
         context_(NULL) {
     monitor_.MoveToNetworkThread();
     monitor_.InitURLRequestContext(url_request_context_getter_);

[davidben, 2014/10/03 00:12:25]

Shouldn't this also call SetDiscardUploads? It looks like these tests are
passing only because they call OnRequestLegComplete directly by being a friend
class.

[Deprecated (see juliatuttle), 2014/10/03 00:42:09]

Done.

     context_ = monitor_.AddContextForTesting(MakeTestConfig());
   }
 
-  static PrefService* CreatePrefService() {
-    TestingPrefServiceSimple* prefs = new TestingPrefServiceSimple();
-    prefs->registry()->RegisterBooleanPref(kPrefName, false);
-    prefs->SetUserPref(kPrefName, new base::FundamentalValue(true));
-    return prefs;
-  }
-
   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");
     request.response_info.headers = MakeHttpResponseHeaders(
         "HTTP/1.1 200 OK\n\n");
     request.response_info.network_accessed = true;
@@ skipping 34 matching lines @@
   }
 
   DomainReliabilityContext* CreateAndAddContext(const std::string& domain) {
     return monitor_.AddContextForTesting(MakeTestConfigWithDomain(domain));
   }
 
   scoped_refptr<base::TestSimpleTaskRunner> pref_task_runner_;
   scoped_refptr<base::TestSimpleTaskRunner> network_task_runner_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   MockTime* time_;
-  scoped_ptr<PrefService> 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