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

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 310 matching lines @@
       SetEffectiveConnectionTypeForTest(
           net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
     } else {
       SetNetworkConditionsForTest(
           net::NetworkChangeNotifier::ConnectionType::CONNECTION_NONE);
       SetEffectiveConnectionTypeForTest(
           net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
     }
   }
 
+  void CallConnectionTypeObserver() {
+    if (coordinator()->connection_notifier_) {
+      coordinator()->connection_notifier_->OnConnectionTypeChanged(
+          GetConnectionType());
+    }
+  }
+
   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) {
@@ skipping 347 matching lines @@
   // RequestPicker should *not* have tried to start an additional job,
   // because the request queue is empty now.
   EXPECT_EQ(0UL, last_requests().size());
   // Check that the observer got the notification that we succeeded, and that
   // the request got removed from the queue.
   EXPECT_TRUE(observer().completed_called());
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::SUCCESS,
             observer().last_status());
 }
 
+TEST_F(RequestCoordinatorTest, OfflinerDoneRequestSucceededButLostNetwork) {
+  // Add a request to the queue and set offliner done callback for it.
+  offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
+                                         base::Time::Now(), kUserRequested);
+  SetupForOfflinerDoneCallbackTest(&request);
+  EnableOfflinerCallback(false);
+
+  // Add a 2nd request to the queue.
+  AddRequest2();
+
+  // Disconnect network.
+  SetNetworkConnected(false);
+
+  // Call the OfflinerDoneCallback to simulate the page being completed, wait
+  // for callbacks.
+  SendOfflinerDoneCallback(request, Offliner::RequestStatus::SAVED);
+  PumpLoop();
+  EXPECT_TRUE(immediate_schedule_callback_called());
+
+  // Verify not busy with 2nd request (since no connection).
+  EXPECT_FALSE(is_busy());
+
+  // Now connect network and verify processing starts.
+  SetNetworkConnected(true);
+  CallConnectionTypeObserver();
+  PumpLoop();
+  EXPECT_TRUE(is_busy());
+}
+
 TEST_F(RequestCoordinatorTest, OfflinerDoneRequestFailed) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
       kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   request.set_completed_attempt_count(kMaxCompletedTries - 1);
   SetupForOfflinerDoneCallbackTest(&request);
   // Stop processing before completing the second request on the queue.
   EnableOfflinerCallback(false);
 
   // Add second request to the queue to check handling when first fails.
@@ skipping 653 matching lines @@
                 kUrl2, kClientId2, kUserRequested,
                 RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER),
             0);
   PumpLoop();
 
   // Verify immediate processing did start this time.
   EXPECT_TRUE(is_busy());
 }
 
 TEST_F(RequestCoordinatorTest, SavePageDoesntStartProcessingWhenDisconnected) {
+  // If low end device, pretend it is not so that immediate start allowed.
+  SetIsLowEndDeviceForTest(false);
+
   SetNetworkConnected(false);
+  EnableOfflinerCallback(false);
   EXPECT_NE(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
   PumpLoop();
   EXPECT_FALSE(is_busy());
+
+  // Now connect network and verify processing starts.
+  SetNetworkConnected(true);
+  CallConnectionTypeObserver();
+  PumpLoop();
+  EXPECT_TRUE(is_busy());
 }
 
 TEST_F(RequestCoordinatorTest,
        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);
 
@@ skipping 49 matching lines @@
   // 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