[Offline Pages] Coordinator checks for net connection before starting next req

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 456 matching lines @@
                                  device_conditions, callback);
 }
 
 bool RequestCoordinator::StartProcessingInternal(
     const ProcessingWindowState processing_state,
     const DeviceConditions& device_conditions,
     const base::Callback<void(bool)>& callback) {
   current_conditions_.reset(new DeviceConditions(device_conditions));
   if (is_starting_ || is_busy_)
     return false;
-  is_starting_ = true;
   processing_state_ = processing_state;
   scheduler_callback_ = callback;
 
   // Mark the time at which we started processing so we can check our time
   // budget.
   operation_start_time_ = base::Time::Now();
 
   TryNextRequest();
 
   return true;
@@ skipping 38 matching lines @@
 
   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::TryNextRequest() {
+  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());
   }
 
-  // If there is no time left in the budget, return to the scheduler.
-  // We do not remove the pending 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 ((base::Time::Now() - operation_start_time_) > processing_time_budget) {
+  // 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 (GetConnectionType() ==
+          net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE ||
+      (base::Time::Now() - operation_start_time_) > processing_time_budget) {
     is_starting_ = false;
 
     // 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;
   }
 
@@ skipping 265 matching lines @@
 
 ClientPolicyController* RequestCoordinator::GetPolicyController() {
   return policy_controller_.get();
 }
 
 void RequestCoordinator::Shutdown() {
   network_quality_estimator_ = nullptr;
 }
 
 }  // namespace offline_pages