[OfflinePages] Restarts immediate processing if stopped due to no net

components/offline_pages/background/request_coordinator.cc

 // Copyright 2016 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/offline_pages/background/request_coordinator.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 541 matching lines @@
   // Make sure we are not on svelte device to start immediately.
   if (is_low_end_device_ &&
       !offline_pages::IsOfflinePagesSvelteConcurrentLoadingEnabled()) {
     DVLOG(2) << "low end device, returning";
     // Let the scheduler know we are done processing and failed due to svelte.
     immediate_schedule_callback_.Run(false);
     return OfflinerImmediateStartStatus::NOT_STARTED_ON_SVELTE;
   }
 
   if (GetConnectionType() ==
-             net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE)
+      net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE) {
+    RequestConnectedEventForStarting();
     return OfflinerImmediateStartStatus::NO_CONNECTION;
+  } else {
+    // Clear any pending connected event request since we have connection
+    // and will start processing.
+    ClearConnectedEventRequest();
+  }
 
   // Start processing with manufactured conservative battery conditions
   // (i.e., assume no battery).
   // TODO(dougarnett): Obtain actual battery conditions (from Android/Java).
 
   DeviceConditions device_conditions(false, 0, GetConnectionType());
   if (StartProcessingInternal(ProcessingWindowState::IMMEDIATE_WINDOW,
                               device_conditions, immediate_schedule_callback_))
     return OfflinerImmediateStartStatus::STARTED;
   else
     return OfflinerImmediateStartStatus::NOT_ACCEPTED;
 }
 
+void RequestCoordinator::RequestConnectedEventForStarting() {
+  connection_notifier_.reset(new ConnectionNotifier(
+      base::Bind(&RequestCoordinator::HandleConnectedEventForStarting,
+                 weak_ptr_factory_.GetWeakPtr())));
+}
+
+void RequestCoordinator::ClearConnectedEventRequest() {
+  connection_notifier_.reset(nullptr);
+}
+
+void RequestCoordinator::HandleConnectedEventForStarting() {
+  ClearConnectedEventRequest();
+  StartImmediatelyIfConnected();
+}
+
 void RequestCoordinator::TryNextRequest(bool is_start_of_processing) {
   is_starting_ = true;
   base::TimeDelta processing_time_budget;
   if (processing_state_ == ProcessingWindowState::SCHEDULED_WINDOW) {
     processing_time_budget = base::TimeDelta::FromSeconds(
         policy_->GetProcessingTimeBudgetWhenBackgroundScheduledInSeconds());
   } else {
     DCHECK(processing_state_ == ProcessingWindowState::IMMEDIATE_WINDOW);
     processing_time_budget = base::TimeDelta::FromSeconds(
         policy_->GetProcessingTimeBudgetForImmediateLoadInSeconds());
@@ skipping 10 matching lines @@
 
   // If there is no network or no time left in the budget, return to the
   // scheduler. We do not remove the pending scheduler task that was set
   // up earlier in case we run out of time, so the background scheduler
   // will return to us at the next opportunity to run background tasks.
   if (connection_type ==
           net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE ||
       (base::Time::Now() - operation_start_time_) > processing_time_budget) {
     is_starting_ = false;
 
+    // If we were doing immediate processing, try to start it again
+    // when we get connected.
+    if (processing_state_ == ProcessingWindowState::IMMEDIATE_WINDOW)
+      RequestConnectedEventForStarting();
+
     // Let the scheduler know we are done processing.
     // TODO: Make sure the scheduler callback is valid before running it.
     scheduler_callback_.Run(true);
     DVLOG(2) << " out of time, giving up. " << __func__;
 
     return;
   }
 
   // Ask request queue to make a new PickRequestTask object, then put it on the
   // task queue.
@@ skipping 339 matching lines @@
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages