[Offline Pages] Define separate watchdog timeout for concurrent bg loads

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 <utility>
 #include <vector>
 
@@ skipping 12 matching lines @@
 #include "components/offline_pages/background/request_queue.h"
 #include "components/offline_pages/background/request_queue_in_memory_store.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/background/scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 // put test constants here
+const bool kIsBackgroundScheduled = true;
 const GURL kUrl1("http://universe.com/everything");
 const GURL kUrl2("http://universe.com/toinfinityandbeyond");
 const std::string kClientNamespace("bookmark");
 const std::string kId1("42");
 const std::string kId2("life*universe+everything");
 const ClientId kClientId1(kClientNamespace, kId1);
 const ClientId kClientId2(kClientNamespace, kId2);
 const int kRequestId1(1);
 const int kRequestId2(2);
 const long kTestTimeoutSeconds = 1;
@@ skipping 364 matching lines @@
   coordinator_->OfflinerDoneCallback(request, status);
 }
 
 TEST_F(RequestCoordinatorTest, StartProcessingWithNoRequests) {
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback =
       base::Bind(
           &RequestCoordinatorTest::EmptyCallbackFunction,
           base::Unretained(this));
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
 }
 
 TEST_F(RequestCoordinatorTest, StartProcessingWithRequestInProgress) {
   // Put the request on the queue.
   EXPECT_TRUE(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER) != 0);
 
   // Set up for the call to StartProcessing by building arguments.
   DeviceConditions device_conditions(
       false, 75, net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback =
       base::Bind(&RequestCoordinatorTest::EmptyCallbackFunction,
                  base::Unretained(this));
 
   // Ensure that the forthcoming request does not finish - we simulate it being
   // in progress by asking it to skip making the completion callback.
   EnableOfflinerCallback(false);
 
   // Sending the request to the offliner should make it busy.
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
   PumpLoop();
   EXPECT_TRUE(is_busy());
 
   // Now trying to start processing on another request should return false.
-  EXPECT_FALSE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_FALSE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                              device_conditions, callback));
 }
 
 TEST_F(RequestCoordinatorTest, SavePageLater) {
   EXPECT_TRUE(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER) != 0);
 
   // Expect that a request got placed on the queue.
   coordinator()->queue()->GetRequests(
@@ skipping 251 matching lines @@
 }
 
 // If one item completes, and there are no more user requeted items left,
 // we should make a scheduler entry for a non-user requested item.
 TEST_F(RequestCoordinatorTest, RequestNotPickedDisabledItemsRemain) {
   // Call start processing just to set up a scheduler callback.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback = base::Bind(
       &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
-  coordinator()->StartProcessing(device_conditions, callback);
+  coordinator()->StartProcessing(kIsBackgroundScheduled, device_conditions,
+                                 callback);
   EXPECT_TRUE(is_starting());
 
   // Call RequestNotPicked, simulating a request on the disabled list.
   CallRequestNotPicked(false, true);
   PumpLoop();
 
   EXPECT_FALSE(is_starting());
 
   // The scheduler should have been called to schedule the disabled task for
   // 5 minutes from now.
   SchedulerStub* scheduler_stub =
       reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->backup_schedule_called());
   EXPECT_TRUE(scheduler_stub->unschedule_called());
 }
 
 // If one item completes, and there are no more user requeted items left,
 // we should make a scheduler entry for a non-user requested item.
 TEST_F(RequestCoordinatorTest, RequestNotPickedNonUserRequestedItemsRemain) {
   // Call start processing just to set up a scheduler callback.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback = base::Bind(
       &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
-  coordinator()->StartProcessing(device_conditions, callback);
+  coordinator()->StartProcessing(kIsBackgroundScheduled, device_conditions,
+                                 callback);
   EXPECT_TRUE(is_starting());
 
   // Call RequestNotPicked, and make sure we pick schedule a task for non user
   // requested conditions, with no tasks on the disabled list.
   CallRequestNotPicked(true, false);
   PumpLoop();
 
   EXPECT_FALSE(is_starting());
 
   // The scheduler should have been called to schedule the non-user requested
@@ skipping 55 matching lines @@
                  base::Unretained(this)));
   PumpLoop();
 
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   DisableLoading();
   base::Callback<void(bool)> callback =
       base::Bind(
           &RequestCoordinatorTest::EmptyCallbackFunction,
           base::Unretained(this));
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
 
   // Let the async callbacks in the request coordinator run.
   PumpLoop();
 
   EXPECT_FALSE(is_starting());
   EXPECT_EQ(Offliner::PRERENDERING_NOT_STARTED, last_offlining_status());
 }
 
 // This tests a StopProcessing call before we have actually started the
 // prerenderer.
 TEST_F(RequestCoordinatorTest, StartProcessingThenStopProcessingImmediately) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
       kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
   PumpLoop();
 
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback =
       base::Bind(
           &RequestCoordinatorTest::EmptyCallbackFunction,
           base::Unretained(this));
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
   EXPECT_TRUE(is_starting());
 
   // Now, quick, before it can do much (we haven't called PumpLoop), cancel it.
   coordinator()->StopProcessing(Offliner::REQUEST_COORDINATOR_CANCELED);
 
   // Let the async callbacks in the request coordinator run.
   PumpLoop();
 
   EXPECT_FALSE(is_starting());
 
@@ skipping 19 matching lines @@
 
   // Ensure the start processing request stops before the completion callback.
   EnableOfflinerCallback(false);
 
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback =
       base::Bind(
           &RequestCoordinatorTest::EmptyCallbackFunction,
           base::Unretained(this));
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
   EXPECT_TRUE(is_starting());
 
   // Let all the async parts of the start processing pipeline run to completion.
   PumpLoop();
 
   // Coordinator should now be busy.
   EXPECT_TRUE(is_busy());
   EXPECT_FALSE(is_starting());
 
   // Now we cancel it while the prerenderer is busy.
@@ skipping 24 matching lines @@
                            base::Unretained(this)));
   PumpLoop();
 
   // Ensure the start processing request stops before the completion callback.
   EnableOfflinerCallback(false);
 
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback = base::Bind(
       &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
 
   // Let all the async parts of the start processing pipeline run to completion.
   PumpLoop();
 
   // Remove the request while it is processing.
   std::vector<int64_t> request_ids{kRequestId1};
   coordinator()->RemoveRequests(
       request_ids, base::Bind(&RequestCoordinatorTest::RemoveRequestsDone,
                               base::Unretained(this)));
 
@@ skipping 13 matching lines @@
                            base::Unretained(this)));
   PumpLoop();
 
   // Ensure the start processing request stops before the completion callback.
   EnableOfflinerCallback(false);
 
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   base::Callback<void(bool)> callback = base::Bind(
       &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
 
   // Call the method under test, making sure we send SUCCESS to the observer.
   coordinator()->MarkRequestCompleted(kRequestId1);
   PumpLoop();
 
   // Our observer should have seen SUCCESS instead of REMOVED.
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::SUCCESS,
             observer().last_status());
   EXPECT_TRUE(observer().completed_called());
 }
@@ skipping 18 matching lines @@
 
   // 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);
 
   // Ask RequestCoordinator to stop waiting for the offliner after this many
   // seconds.
   SetOfflinerTimeoutForTest(base::TimeDelta::FromSeconds(kTestTimeoutSeconds));
 
   // Sending the request to the offliner.
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
   PumpLoop();
 
   // Advance the mock clock far enough to cause a watchdog timeout
   AdvanceClockBy(base::TimeDelta::FromSeconds(kTestTimeoutSeconds + 1));
   PumpLoop();
 
   // Wait for timeout to expire.  Use a TaskRunner with a DelayedTaskRunner
   // which won't time out immediately, so the watchdog thread doesn't kill valid
   // tasks too soon.
   WaitForCallback();
@@ skipping 24 matching lines @@
 
   // 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));
 
   // Sending the request to the offliner.
-  EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  EXPECT_TRUE(coordinator()->StartProcessing(kIsBackgroundScheduled,
+                                             device_conditions, callback));
   PumpLoop();
 
   // Advance the mock clock far enough to exceed our time budget.
   AdvanceClockBy(base::TimeDelta::FromSeconds(kTestTimeBudgetSeconds));
   PumpLoop();
 
   // TryNextRequest should decide that there is no more work to be done,
   // and call back to the scheduler, even though there is another request in the
   // queue.  There should be one request left in the queue.
   // Verify the request gets removed from the queue, and wait for callbacks.
@@ skipping 170 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