Domain Reliability: Mark beacons from previous networks.

components/domain_reliability/monitor.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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
@@ skipping 15 matching lines @@
       upload_reporter_string_(upload_reporter_string),
       scheduler_params_(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       pref_task_runner_(pref_thread),
       network_task_runner_(network_thread),
       moved_to_network_thread_(false),
       discard_uploads_set_(false),
       weak_factory_(this) {
   DCHECK(OnPrefThread());
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
     const std::string& upload_reporter_string,
     scoped_refptr<base::SingleThreadTaskRunner> pref_thread,
     scoped_refptr<base::SingleThreadTaskRunner> network_thread,
     scoped_ptr<MockableTime> time)
     : time_(time.Pass()),
       upload_reporter_string_(upload_reporter_string),
       scheduler_params_(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       pref_task_runner_(pref_thread),
       network_task_runner_(network_thread),
       moved_to_network_thread_(false),
       discard_uploads_set_(false),
       weak_factory_(this) {
   DCHECK(OnPrefThread());
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);

[davidben, 2014/10/30 21:18:00]

I think this should be in InitURLRequestContext, otherwise the notifications
won't come on the right thread. And then maybe the destructor checks
|moved_to_network_thread_| because RemoveNetworkChangeObserver needs to be
called on the same thread.

 }
 
 DomainReliabilityMonitor::~DomainReliabilityMonitor() {
   if (moved_to_network_thread_)
     DCHECK(OnNetworkThread());
   else
     DCHECK(OnPrefThread());
 
   ClearContexts();
+  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void DomainReliabilityMonitor::MoveToNetworkThread() {
   DCHECK(OnPrefThread());
   DCHECK(!moved_to_network_thread_);
 
   moved_to_network_thread_ = true;
 }
 
 void DomainReliabilityMonitor::InitURLRequestContext(
@@ skipping 64 matching lines @@
     return;
   RequestInfo request_info(*request);
   if (request_info.AccessedNetwork()) {
     OnRequestLegComplete(request_info);
     // A request was just using the network, so now is a good time to run any
     // pending and eligible uploads.
     dispatcher_.RunEligibleTasks();
   }
 }
 
+void DomainReliabilityMonitor::OnNetworkChanged(
+    net::NetworkChangeNotifier::ConnectionType type) {
+  last_network_change_time_ = time_->NowTicks();
+}
+
 void DomainReliabilityMonitor::ClearBrowsingData(
    DomainReliabilityClearMode mode) {
   DCHECK(OnNetworkThread());
 
   switch (mode) {
     case CLEAR_BEACONS: {
       ContextMap::const_iterator it;
       for (it = contexts_.begin(); it != contexts_.end(); ++it)
         it->second->ClearBeacons();
       break;
@@ skipping 54 matching lines @@
   DCHECK(config);
   DCHECK(config->IsValid());
 
   // Grab a copy of the domain before transferring ownership of |config|.
   std::string domain = config->domain;
 
   DomainReliabilityContext* context =
       new DomainReliabilityContext(time_.get(),
                                    scheduler_params_,
                                    upload_reporter_string_,
+                                   last_network_change_time_,
                                    &dispatcher_,
                                    uploader_.get(),
                                    config.Pass());
 
   std::pair<ContextMap::iterator, bool> map_it =
       contexts_.insert(make_pair(domain, context));
   // Make sure the domain wasn't already in the map.
   DCHECK(map_it.second);
 
   return map_it.first->second;
@@ skipping 88 matching lines @@
 
   return NULL;
 }
 
 base::WeakPtr<DomainReliabilityMonitor>
 DomainReliabilityMonitor::MakeWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace domain_reliability