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

components/offline_pages/background/request_coordinator_unittest.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 <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 287 matching lines @@
 
   void EnableOfflinerCallback(bool enable) {
     offliner_->enable_callback(enable);
   }
 
   void SetNetworkConditionsForTest(
       net::NetworkChangeNotifier::ConnectionType connection) {
     coordinator()->SetNetworkConditionsForTest(connection);
   }
 
+  void SetEffectiveConnectionTypeForTest(net::EffectiveConnectionType type) {
+    network_quality_estimator_->SetEffectiveConnectionTypeForTest(type);
+  }
+
+  void SetNetworkConnected(bool connected) {
+    if (connected) {
+      SetNetworkConditionsForTest(
+          net::NetworkChangeNotifier::ConnectionType::CONNECTION_3G);
+      SetEffectiveConnectionTypeForTest(
+          net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
+    } else {
+      SetNetworkConditionsForTest(
+          net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE);
+      SetEffectiveConnectionTypeForTest(
+          net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
+    }
+  }
+
   void SetIsLowEndDeviceForTest(bool is_low_end_device) {
     coordinator()->is_low_end_device_ = is_low_end_device;
   }
 
   void SetProcessingStateForTest(
       RequestCoordinator::ProcessingWindowState processing_state) {
     coordinator()->processing_state_ = processing_state;
   }
 
   void SetOperationStartTimeForTest(base::Time start_time) {
     coordinator()->operation_start_time_ = start_time;
   }
 
-  void SetEffectiveConnectionTypeForTest(net::EffectiveConnectionType type) {
-    network_quality_estimator_->SetEffectiveConnectionTypeForTest(type);
-  }
-
   void ScheduleForTest() { coordinator_->ScheduleAsNeeded(); }
 
   void CallRequestNotPicked(bool non_user_requested_tasks_remaining,
                             bool disabled_tasks_remaining) {
     if (disabled_tasks_remaining)
       coordinator_->disabled_requests_.insert(kRequestId1);
     else
       coordinator_->disabled_requests_.clear();
 
     coordinator_->RequestNotPicked(non_user_requested_tasks_remaining);
@@ skipping 56 matching lines @@
       reinterpret_cast<OfflinerStub*>(factory->GetOffliner(policy.get()));
   std::unique_ptr<RequestQueueInMemoryStore>
       store(new RequestQueueInMemoryStore());
   std::unique_ptr<RequestQueue> queue(new RequestQueue(std::move(store)));
   std::unique_ptr<Scheduler> scheduler_stub(new SchedulerStub());
   network_quality_estimator_.reset(new NetworkQualityEstimatorStub());
   coordinator_.reset(new RequestCoordinator(
       std::move(policy), std::move(factory), std::move(queue),
       std::move(scheduler_stub), network_quality_estimator_.get()));
   coordinator_->AddObserver(&observer_);
-  SetEffectiveConnectionTypeForTest(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
-  SetNetworkConditionsForTest(
-      net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE);
+  SetNetworkConnected(true);
 }
 
 void RequestCoordinatorTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
 void RequestCoordinatorTest::GetRequestsDone(
     RequestQueue::GetRequestsResult result,
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_get_requests_result_ = result;
@@ skipping 87 matching lines @@
 
   // Now trying to start processing on another request should return false.
   EXPECT_FALSE(coordinator()->StartProcessing(device_conditions, callback));
 }
 
 TEST_F(RequestCoordinatorTest, SavePageLater) {
   // Set up device conditions for the test and enable the offliner.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   SetDeviceConditionsForTest(device_conditions);
-  // Set up the fake network conditions for the NetworkConnectionNotifier.
-  SetNetworkConditionsForTest(
-      net::NetworkChangeNotifier::ConnectionType::CONNECTION_3G);
-  // Set up the fake network conditions for the network quality estimator.
-  SetEffectiveConnectionTypeForTest(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
   EnableOfflinerCallback(true);
   base::Callback<void(bool)> callback =
       base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
                  base::Unretained(this));
 
   // The user-requested request which gets processed by SavePageLater
   // would invoke user request callback.
   coordinator()->SetImmediateScheduleCallbackForTest(callback);
 
   EXPECT_NE(
@@ skipping 561 matching lines @@
   PumpLoop();
 
   EXPECT_FALSE(is_starting());
   EXPECT_TRUE(OfflinerWasCanceled());
 }
 
 TEST_F(RequestCoordinatorTest, WatchdogTimeoutForImmediateProcessing) {
   // If low end device, pretend it is not so that immediate start happens.
   SetIsLowEndDeviceForTest(false);
 
-  // Set up the fake network conditions for the NetworkConnectionNotifier.
-  SetNetworkConditionsForTest(
-      net::NetworkChangeNotifier::ConnectionType::CONNECTION_3G);
-  // Set up the fake network conditions for the network quality estimator.
-  SetEffectiveConnectionTypeForTest(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
-
   // Ensure that the new request does not finish - we simulate it being
   // in progress by asking it to skip making the completion callback.
   EnableOfflinerCallback(false);
 
   EXPECT_NE(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
   PumpLoop();
 
@@ skipping 58 matching lines @@
   // Verify the request gets removed from the queue, and wait for callbacks.
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // We should find one request in the queue.
   EXPECT_EQ(1UL, last_requests().size());
 }
 
+TEST_F(RequestCoordinatorTest, TryNextRequestWithNoNetwork) {
+  // Build two requests to use with the pre-renderer, and put it on the queue.
+  offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
+                                          base::Time::Now(), kUserRequested);
+  offline_pages::SavePageRequest request2(kRequestId1 + 1, kUrl1, kClientId1,
+                                          base::Time::Now(), kUserRequested);
+  coordinator()->queue()->AddRequest(
+      request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
+                           base::Unretained(this)));
+  coordinator()->queue()->AddRequest(
+      request2, base::Bind(&RequestCoordinatorTest::AddRequestDone,
+                           base::Unretained(this)));
+  PumpLoop();
+
+  // Set up for the call to StartProcessing.
+  DeviceConditions device_conditions(!kPowerRequired, kBatteryPercentageHigh,
+                                     net::NetworkChangeNotifier::CONNECTION_3G);
+  base::Callback<void(bool)> callback = base::Bind(
+      &RequestCoordinatorTest::WaitingCallbackFunction, base::Unretained(this));
+  EnableOfflinerCallback(false);
+
+  // Sending the request to the offliner.
+  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  PumpLoop();
+  EXPECT_TRUE(coordinator()->is_busy());
+
+  // Now lose the network connection.
+  SetNetworkConnected(false);
+
+  // Complete first request and then TryNextRequest should decide not
+  // to pick another request (because of no network connection).
+  SendOfflinerDoneCallback(request1, Offliner::RequestStatus::SAVED);
+  PumpLoop();
+
+  // Not starting nor busy with next request.
+  EXPECT_FALSE(coordinator()->is_starting());
+  EXPECT_FALSE(coordinator()->is_busy());
+
+  // Get queued requests.
+  coordinator()->queue()->GetRequests(base::Bind(
+      &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
+  PumpLoop();
+
+  // We should find one request in the queue.
+  EXPECT_EQ(1UL, last_requests().size());
+}
+
 TEST_F(RequestCoordinatorTest, GetAllRequests) {
   // Add two requests to the queue.
   offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
                                           base::Time::Now(), kUserRequested);
   offline_pages::SavePageRequest request2(kRequestId1 + 1, kUrl2, kClientId2,
                                           base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
   coordinator()->queue()->AddRequest(
@@ skipping 67 matching lines @@
 
   EXPECT_TRUE(observer().completed_called());
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::REMOVED,
             observer().last_status());
   EXPECT_EQ(1UL, last_remove_results().size());
   EXPECT_EQ(kRequestId1, std::get<0>(last_remove_results().at(0)));
 }
 
 TEST_F(RequestCoordinatorTest,
        SavePageStartsProcessingWhenConnectedAndNotLowEndDevice) {
-  // Set up the fake network conditions for the NetworkConnectionNotifier.
-  SetNetworkConditionsForTest(
-      net::NetworkChangeNotifier::ConnectionType::CONNECTION_3G);
-  // Set up the fake network conditions for the network quality estimator.
-  SetEffectiveConnectionTypeForTest(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
   EXPECT_NE(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
   PumpLoop();
 
   // Now whether processing triggered immediately depends on whether test
   // is run on svelte device or not.
   if (base::SysInfo::IsLowEndDevice()) {
     EXPECT_FALSE(is_busy());
   } else {
     EXPECT_TRUE(is_busy());
   }
 }
 
 TEST_F(RequestCoordinatorTest, SavePageDoesntStartProcessingWhenDisconnected) {
+  SetNetworkConnected(false);
   EXPECT_NE(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
   PumpLoop();
   EXPECT_FALSE(is_busy());
 }
 
 TEST_F(RequestCoordinatorTest,
-       SavePageDoesntStartProcessingWhenPoorlyConnected) {
+       SavePageDoesStartProcessingWhenPoorlyConnected) {
+  // Set specific network type for 2G with poor effective connection.
+  SetNetworkConditionsForTest(
+      net::NetworkChangeNotifier::ConnectionType::CONNECTION_2G);
   SetEffectiveConnectionTypeForTest(
       net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   EXPECT_NE(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
   PumpLoop();
-  EXPECT_FALSE(is_busy());
+  EXPECT_TRUE(is_busy());
 }
 
 TEST_F(RequestCoordinatorTest,
        ResumeStartsProcessingWhenConnectedAndNotLowEndDevice) {
+  // Start unconnected.
+  SetNetworkConnected(false);
+
   // Add a request to the queue.
   offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
                                           base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
   PumpLoop();
   EXPECT_FALSE(is_busy());
 
   // Pause the request.
   std::vector<int64_t> request_ids;
   request_ids.push_back(kRequestId1);
   coordinator()->PauseRequests(request_ids);
   PumpLoop();
 
   // Resume the request while disconnected.
   coordinator()->ResumeRequests(request_ids);
   PumpLoop();
   EXPECT_FALSE(is_busy());
 
   // Pause the request again.
   coordinator()->PauseRequests(request_ids);
   PumpLoop();
 
   // Now simulate reasonable connection.
-  SetNetworkConditionsForTest(
-      net::NetworkChangeNotifier::ConnectionType::CONNECTION_3G);
-  SetEffectiveConnectionTypeForTest(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
+  SetNetworkConnected(true);
 
   // Resume the request while connected.
   coordinator()->ResumeRequests(request_ids);
   EXPECT_FALSE(is_busy());
   PumpLoop();
 
   // Now whether processing triggered immediately depends on whether test
   // is run on svelte device or not.
   if (base::SysInfo::IsLowEndDevice()) {
     EXPECT_FALSE(is_busy());
   } else {
     EXPECT_TRUE(is_busy());
   }
 }
 
 }  // namespace offline_pages