Domain Reliability: Get correct reporting pref once, on startup

components/domain_reliability/monitor.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.
 
 #ifndef COMPONENTS_DOMAIN_RELIABILITY_MONITOR_H_
 #define COMPONENTS_DOMAIN_RELIABILITY_MONITOR_H_
 
 #include <map>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/prefs/pref_member.h"
+#include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "components/domain_reliability/beacon.h"
 #include "components/domain_reliability/clear_mode.h"
 #include "components/domain_reliability/config.h"
 #include "components/domain_reliability/context.h"
 #include "components/domain_reliability/dispatcher.h"
 #include "components/domain_reliability/domain_reliability_export.h"
 #include "components/domain_reliability/scheduler.h"
 #include "components/domain_reliability/uploader.h"
 #include "components/domain_reliability/util.h"
 #include "net/base/load_timing_info.h"
 #include "net/http/http_response_info.h"
 #include "net/url_request/url_request_status.h"
 
-class PrefService;
-
 namespace base {
-class SingleThreadTaskRunner;
 class ThreadChecker;
 class Value;
 }  // namespace base
 
 namespace net {
 class URLRequest;
 class URLRequestContext;
 class URLRequestContextGetter;
 }  // namespace net
 
 namespace domain_reliability {
 
 // The top-level object that measures requests and hands off the measurements
 // to the proper |DomainReliabilityContext|.
 class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor {
  public:
   // Creates a Monitor. |local_state_pref_service| must live on |pref_thread|
   // (which should be the current thread); |network_thread| is the thread
   // on which requests will actually be monitored and reported.
   DomainReliabilityMonitor(
       const std::string& upload_reporter_string,
       scoped_refptr<base::SingleThreadTaskRunner> pref_thread,
-      scoped_refptr<base::SingleThreadTaskRunner> network_thread,
-      PrefService* local_state_pref_service,
-      const char* reporting_pref_name);
+      scoped_refptr<base::SingleThreadTaskRunner> network_thread);
 
   // Same, but specifies a mock interface for time functions for testing.
   DomainReliabilityMonitor(
       const std::string& upload_reporter_string,
       scoped_refptr<base::SingleThreadTaskRunner> pref_thread,
       scoped_refptr<base::SingleThreadTaskRunner> network_thread,
-      PrefService* local_state_pref_service,
-      const char* reporting_pref_name,
       scoped_ptr<MockableTime> time);
 
   // Must be called from the pref thread if |MoveToNetworkThread| was not
   // called, or from the network thread if it was called.
   ~DomainReliabilityMonitor();
 
   // Must be called before |InitURLRequestContext| on the same thread on which
   // the Monitor was constructed. Moves (most of) the Monitor to the network
   // thread passed in the constructor.
   void MoveToNetworkThread();
 
-  // Must be called from the pref thread before the Monitor is destructed if
-  // |MoveToNetworkThread| was called.
-  void DestroyReportingPref();
-
-  // All public methods below this point must be called on the network thread:
+  // All public methods below this point must be called on the network thread
+  // after |MoveToNetworkThread| is called on the pref thread.
 
   // Initializes the Monitor's URLRequestContextGetter.
   //
   // Must be called on the network thread, after |MoveToNetworkThread|.
   void InitURLRequestContext(net::URLRequestContext* url_request_context);
 
   // Same, but for unittests where the Getter is readily available.
   void InitURLRequestContext(
       scoped_refptr<net::URLRequestContextGetter> url_request_context_getter);
 
   // Populates the monitor with contexts that were configured at compile time.
   void AddBakedInConfigs();
 
+  // Sets whether the uploader will discard uploads. Must be called after
+  // |InitURLRequestContext|.

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

It also must be called before OnBeforeRedirect and OnCompleted, right? Probably
worth adding that to the documentation.

(Or it could be folded into InitURLRequestContext so the caller can't actually
call it wrong.)

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

Done.

+  void SetDiscardUploads(bool discard_uploads);
+
   // Should be called when |request| is about to follow a redirect. Will
   // examine and possibly log the redirect request.
   void OnBeforeRedirect(net::URLRequest* request);
 
   // Should be called when |request| is complete. Will examine and possibly
   // log the (final) request. (|started| should be true if the request was
   // actually started before it was terminated.)
   void OnCompleted(net::URLRequest* request, bool started);
 
   // Called to remove browsing data. With CLEAR_BEACONS, leaves contexts in
@@ skipping 35 matching lines @@
   // Creates a context, adds it to the monitor, and returns a pointer to it.
   // (The pointer is only valid until the Monitor is destroyed.)
   DomainReliabilityContext* AddContext(
       scoped_ptr<const DomainReliabilityConfig> config);
   // Deletes all contexts from |contexts_| and clears the map.
   void ClearContexts();
   void OnRequestLegComplete(const RequestInfo& info);
 
   DomainReliabilityContext* GetContextForHost(const std::string& host) const;
 
-  void InitReportingPref(
-      PrefService* local_state_pref_service,
-      const char* reporting_pref_name);
-  void OnReportingPrefChanged();
-
   bool OnPrefThread() const {
     return pref_task_runner_->BelongsToCurrentThread();
   }
   bool OnNetworkThread() const {
     return network_task_runner_->BelongsToCurrentThread();
   }
 
   base::WeakPtr<DomainReliabilityMonitor> MakeWeakPtr();
 
   scoped_ptr<MockableTime> time_;
   const std::string upload_reporter_string_;
   DomainReliabilityScheduler::Params scheduler_params_;
   DomainReliabilityDispatcher dispatcher_;
   scoped_ptr<DomainReliabilityUploader> uploader_;
   ContextMap contexts_;
 
   scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
-  BooleanPrefMember reporting_pref_;
   bool moved_to_network_thread_;
+  bool discard_uploads_set_;
 
   base::WeakPtrFactory<DomainReliabilityMonitor> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DomainReliabilityMonitor);
 };
 
 }  // namespace domain_reliability
 
 #endif  // COMPONENTS_DOMAIN_RELIABILITY_MONITOR_H_