[OfflinePages] Classifies PRERENDERING_FAILED cases whether to TryNext

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 571 matching lines @@
   // Add second request to the queue to check handling when first fails.
   AddRequest2();
   PumpLoop();
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(request,
                            Offliner::RequestStatus::PRERENDERING_FAILED);
   PumpLoop();
 
-  // For retriable failure, processing should stop and scheduler callback
-  // called (so that request can be retried first next processing window).
-  EXPECT_TRUE(immediate_schedule_callback_called());
+  // For retriable failure, processing should continue to 2nd request so
+  // no scheduler callback yet.
+  EXPECT_FALSE(immediate_schedule_callback_called());
 
-  // TODO(dougarnett): Consider injecting mock RequestPicker for this test
-  // and verifying that there is no attempt to pick another request following
-  // this failure code.
+  // Busy processing 2nd request.
+  EXPECT_TRUE(is_busy());
 
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // Now just one request in the queue since failed request removed
   // (max number of attempts exceeded).
   EXPECT_EQ(1UL, last_requests().size());
   // Check that the observer got the notification that we failed (and the
-  // subsequent notification that the request was removed).
+  // subsequent notification that the request was removed) since we exceeded
+  // retry count.
   EXPECT_TRUE(observer().completed_called());
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::RETRY_COUNT_EXCEEDED,
             observer().last_status());
 }
 
 TEST_F(RequestCoordinatorTest, OfflinerDoneRequestFailedNoRetryFailure) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
                                          base::Time::Now(), kUserRequested);
   SetupForOfflinerDoneCallbackTest(&request);
   EnableOfflinerCallback(false);
 
   // Add second request to the queue to check handling when first fails.
   AddRequest2();
   PumpLoop();
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(
       request, Offliner::RequestStatus::PRERENDERING_FAILED_NO_RETRY);
   PumpLoop();
 
   // For no retry failure, processing should continue to 2nd request so
   // no scheduler callback yet.
   EXPECT_FALSE(immediate_schedule_callback_called());
 
-  // TODO(dougarnett): Consider injecting mock RequestPicker for this test
-  // and verifying that there is as attempt to pick another request following
-  // this non-retryable failure code.
+  // Busy processing 2nd request.
+  EXPECT_TRUE(is_busy());
 
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Now just one request in the queue since non-retryable failure.
   EXPECT_EQ(1UL, last_requests().size());
   // Check that the observer got the notification that we failed (and the
   // subsequent notification that the request was removed).
   EXPECT_TRUE(observer().completed_called());
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::PRERENDER_FAILURE,
             observer().last_status());
 }
 
+TEST_F(RequestCoordinatorTest, OfflinerDoneRequestFailedNoNextFailure) {
+  // Add a request to the queue, wait for callbacks to finish.
+  offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
+                                         base::Time::Now(), kUserRequested);
+  SetupForOfflinerDoneCallbackTest(&request);
+  EnableOfflinerCallback(false);
+
+  // Add second request to the queue to check handling when first fails.
+  AddRequest2();
+  PumpLoop();
+
+  // Call the OfflinerDoneCallback to simulate the request failed, wait
+  // for callbacks.
+  SendOfflinerDoneCallback(
+      request, Offliner::RequestStatus::PRERENDERING_FAILED_NO_NEXT);
+  PumpLoop();
+
+  // For no next failure, processing should not continue to 2nd request so
+  // expect scheduler callback.
+  EXPECT_TRUE(immediate_schedule_callback_called());
+
+  // Not busy for NO_NEXT failure.
+  EXPECT_FALSE(is_busy());
+
+  coordinator()->queue()->GetRequests(base::Bind(
+      &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
+  PumpLoop();
+
+  // Both requests still in queue.
+  EXPECT_EQ(2UL, last_requests().size());
+}
+
 TEST_F(RequestCoordinatorTest, OfflinerDoneForegroundCancel) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
       kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   SetupForOfflinerDoneCallbackTest(&request);
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(request,
                            Offliner::RequestStatus::FOREGROUND_CANCELED);
@@ skipping 649 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