[Offline Pages] Add evaluation test support in RequestCoordinator.

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 50 matching lines @@
     conditions_ = trigger_conditions;
   }
 
   void BackupSchedule(const TriggerConditions& trigger_conditions,
                       long delay_in_seconds) override {
     backup_schedule_called_ = true;
     schedule_delay_ = delay_in_seconds;
     conditions_ = trigger_conditions;
   }
 
-
   // Unschedules the currently scheduled task, if any.
   void Unschedule() override {
     unschedule_called_ = true;
   }
 
   bool schedule_called() const { return schedule_called_; }
 
   bool backup_schedule_called() const { return backup_schedule_called_;}
 
   bool unschedule_called() const { return unschedule_called_; }
@@ skipping 150 matching lines @@
     return coordinator_.get();
   }
 
   bool is_busy() {
     return coordinator_->is_busy();
   }
 
   bool is_starting() { return coordinator_->is_starting(); }
 
   // Empty callback function.
-  void EmptyCallbackFunction(bool result) {
+  void ImmediateScheduleCallbackFunction(bool result) {
+    immediate_schedule_callback_called_ = true;
   }
 
   // Callback function which releases a wait for it.
   void WaitingCallbackFunction(bool result) {
     waiter_.Signal();
   }
 
   // Callback for Add requests.
   void AddRequestDone(RequestQueue::AddRequestResult result,
                       const SavePageRequest& request);
@@ skipping 66 matching lines @@
   }
 
   Offliner::RequestStatus last_offlining_status() const {
     return coordinator_->last_offlining_status_;
   }
 
   bool OfflinerWasCanceled() const { return offliner_->cancel_called(); }
 
   ObserverStub observer() { return observer_; }
 
+  bool immediate_schedule_callback_called() const {
+    return immediate_schedule_callback_called_;
+  }
+
  private:
   RequestQueue::GetRequestsResult last_get_requests_result_;
   MultipleItemStatuses last_remove_results_;
   std::vector<std::unique_ptr<SavePageRequest>> last_requests_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<NetworkQualityEstimatorStub> network_quality_estimator_;
   std::unique_ptr<RequestCoordinator> coordinator_;
   OfflinerStub* offliner_;
   base::WaitableEvent waiter_;
   ObserverStub observer_;
+  bool immediate_schedule_callback_called_;
 };
 
 RequestCoordinatorTest::RequestCoordinatorTest()
     : last_get_requests_result_(RequestQueue::GetRequestsResult::STORE_FAILURE),
       task_runner_(new base::TestMockTimeTaskRunner),
       task_runner_handle_(task_runner_),
       offliner_(nullptr),
       waiter_(base::WaitableEvent::ResetPolicy::MANUAL,
-              base::WaitableEvent::InitialState::NOT_SIGNALED) {}
+              base::WaitableEvent::InitialState::NOT_SIGNALED),
+      immediate_schedule_callback_called_(false) {}
 
 RequestCoordinatorTest::~RequestCoordinatorTest() {}
 
 void RequestCoordinatorTest::SetUp() {
   std::unique_ptr<OfflinerPolicy> policy(new OfflinerPolicy());
   std::unique_ptr<OfflinerFactory> factory(new OfflinerFactoryStub());
   // Save the offliner for use by the tests.
   offliner_ =
       reinterpret_cast<OfflinerStub*>(factory->GetOffliner(policy.get()));
   std::unique_ptr<RequestQueueInMemoryStore>
@@ skipping 41 matching lines @@
 void RequestCoordinatorTest::SendOfflinerDoneCallback(
     const SavePageRequest& request, Offliner::RequestStatus status) {
   // Using the fact that the test class is a friend, call to the callback
   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));
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
+  PumpLoop();
+  EXPECT_TRUE(immediate_schedule_callback_called());
 }
 
 TEST_F(RequestCoordinatorTest, StartProcessingWithRequestInProgress) {
   // Put the request on the queue.
   EXPECT_NE(
       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::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
                  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));
   PumpLoop();
   EXPECT_TRUE(is_busy());
+  // Since the offliner is disabled, this callback should not be called.
+  EXPECT_FALSE(immediate_schedule_callback_called());
 
   // 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);
+  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(
       coordinator()->SavePageLater(
           kUrl1, kClientId1, kUserRequested,
           RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
 
   // Expect that a request got placed on the queue.
+  coordinator()->queue()->GetRequests(base::Bind(
+      &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
+
+  // Wait for callbacks to finish, both request queue and offliner.
+  PumpLoop();
+  EXPECT_TRUE(immediate_schedule_callback_called());
+
+  // Check the request queue is as expected.
+  EXPECT_EQ(1UL, last_requests().size());
+  EXPECT_EQ(kUrl1, last_requests().at(0)->url());
+  EXPECT_EQ(kClientId1, last_requests().at(0)->client_id());
+
+  // Expect that the scheduler got notified.
+  SchedulerStub* scheduler_stub =
+      reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
+  EXPECT_TRUE(scheduler_stub->schedule_called());
+  EXPECT_EQ(coordinator()
+                ->GetTriggerConditions(last_requests()[0]->user_requested())
+                .minimum_battery_percentage,
+            scheduler_stub->conditions()->minimum_battery_percentage);
+
+  // Check that the observer got the notification that a page is available
+  EXPECT_TRUE(observer().added_called());
+}
+
+TEST_F(RequestCoordinatorTest, SavePageLaterFailed) {
+  // Set up device conditions for the test and enable the offliner.
+  DeviceConditions device_conditions(false, 75,
+                                     net::NetworkChangeNotifier::CONNECTION_3G);
+  SetDeviceConditionsForTest(device_conditions);
+  SetEffectiveConnectionTypeForTest(
+      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
+  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_TRUE(
+      coordinator()->SavePageLater(
+          kUrl1, kClientId1, kUserRequested,
+          RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER) != 0);
+
+  // Expect that a request got placed on the queue.
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
 
   // Wait for callbacks to finish, both request queue and offliner.
   PumpLoop();
+  // Will not be called since the offliner is disabled.
+  EXPECT_FALSE(immediate_schedule_callback_called());
 
   // Check the request queue is as expected.
   EXPECT_EQ(1UL, last_requests().size());
   EXPECT_EQ(kUrl1, last_requests().at(0)->url());
   EXPECT_EQ(kClientId1, last_requests().at(0)->client_id());
 
   // Expect that the scheduler got notified.
   SchedulerStub* scheduler_stub = reinterpret_cast<SchedulerStub*>(
       coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->schedule_called());
@@ skipping 12 matching lines @@
       kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   request.MarkAttemptStarted(base::Time::Now());
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // We need to give a callback to the request.
   base::Callback<void(bool)> callback =
-      base::Bind(
-          &RequestCoordinatorTest::EmptyCallbackFunction,
-          base::Unretained(this));
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   coordinator()->SetProcessingCallbackForTest(callback);
 
   // Set up device conditions for the test.
   DeviceConditions device_conditions(
       false, 75, net::NetworkChangeNotifier::CONNECTION_3G);
   SetDeviceConditionsForTest(device_conditions);
 
   // 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 the request gets removed from the queue, and wait for callbacks.
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // We should not find any requests in the queue anymore.
   // RequestPicker should *not* have tried to start an additional job,
   // because the request queue is empty now.
@@ skipping 20 matching lines @@
   offline_pages::SavePageRequest request2(
       kRequestId2, kUrl2, kClientId2, base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request2,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // We need to give a callback to the request.
   base::Callback<void(bool)> callback =
-      base::Bind(
-          &RequestCoordinatorTest::EmptyCallbackFunction,
-          base::Unretained(this));
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   coordinator()->SetProcessingCallbackForTest(callback);
 
   // Set up device conditions for the test.
   DeviceConditions device_conditions(
       false, 75, net::NetworkChangeNotifier::CONNECTION_3G);
   SetDeviceConditionsForTest(device_conditions);
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(request,
                            Offliner::RequestStatus::PRERENDERING_FAILED);
   PumpLoop();
+  EXPECT_TRUE(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.
 
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
   PumpLoop();
 
@@ skipping 19 matching lines @@
 
   // Add second request to the queue to check handling when first fails.
   offline_pages::SavePageRequest request2(kRequestId2, kUrl2, kClientId2,
                                           base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request2, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
   PumpLoop();
 
   // We need to give a callback to the request.
-  base::Callback<void(bool)> callback = base::Bind(
-      &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   coordinator()->SetProcessingCallbackForTest(callback);
 
   // Set up device conditions for the test.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   SetDeviceConditionsForTest(device_conditions);
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(
       request, Offliner::RequestStatus::PRERENDERING_FAILED_NO_RETRY);
   PumpLoop();
+  EXPECT_TRUE(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.
 
   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, OfflinerDoneForegroundCancel) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
       kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   request.MarkAttemptStarted(base::Time::Now());
   coordinator()->queue()->AddRequest(
       request, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                           base::Unretained(this)));
   PumpLoop();
 
   // We need to give a callback to the request.
-  base::Callback<void(bool)> callback = base::Bind(
-      &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   coordinator()->SetProcessingCallbackForTest(callback);
 
   // Set up device conditions for the test.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   SetDeviceConditionsForTest(device_conditions);
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(request,
                            Offliner::RequestStatus::FOREGROUND_CANCELED);
   PumpLoop();
+  EXPECT_TRUE(immediate_schedule_callback_called());
 
   // Verify the request is not removed from the queue, and wait for callbacks.
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Request no longer in the queue (for single attempt policy).
   EXPECT_EQ(1UL, last_requests().size());
   // Verify foreground cancel not counted as an attempt after all.
   EXPECT_EQ(0L, last_requests().at(0)->completed_attempt_count());
 }
 
 TEST_F(RequestCoordinatorTest, OfflinerDonePrerenderingCancel) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
                                          base::Time::Now(), kUserRequested);
   request.MarkAttemptStarted(base::Time::Now());
   coordinator()->queue()->AddRequest(
       request, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                           base::Unretained(this)));
   PumpLoop();
 
   // We need to give a callback to the request.
-  base::Callback<void(bool)> callback = base::Bind(
-      &RequestCoordinatorTest::EmptyCallbackFunction, base::Unretained(this));
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   coordinator()->SetProcessingCallbackForTest(callback);
 
   // Set up device conditions for the test.
   DeviceConditions device_conditions(false, 75,
                                      net::NetworkChangeNotifier::CONNECTION_3G);
   SetDeviceConditionsForTest(device_conditions);
 
   // Call the OfflinerDoneCallback to simulate the request failed, wait
   // for callbacks.
   SendOfflinerDoneCallback(request,
                            Offliner::RequestStatus::PRERENDERING_CANCELED);
   PumpLoop();
+  EXPECT_TRUE(immediate_schedule_callback_called());
 
   // Verify the request is not removed from the queue, and wait for callbacks.
   coordinator()->queue()->GetRequests(base::Bind(
       &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // Request still in the queue.
   EXPECT_EQ(1UL, last_requests().size());
   // Verify prerendering cancel not counted as an attempt after all.
   const std::unique_ptr<SavePageRequest>& found_request =
       last_requests().front();
   EXPECT_EQ(0L, found_request->completed_attempt_count());
 }
 
 // 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));
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   coordinator()->StartProcessing(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));
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   coordinator()->StartProcessing(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());
+  EXPECT_TRUE(immediate_schedule_callback_called());
 
   // The scheduler should have been called to schedule the non-user requested
   // task.
   SchedulerStub* scheduler_stub =
       reinterpret_cast<SchedulerStub*>(coordinator()->scheduler());
   EXPECT_TRUE(scheduler_stub->schedule_called());
   EXPECT_TRUE(scheduler_stub->unschedule_called());
   const Scheduler::TriggerConditions* conditions = scheduler_stub->conditions();
   EXPECT_EQ(conditions->require_power_connected,
             coordinator()->policy()->PowerRequired(!kUserRequested));
@@ skipping 44 matching lines @@
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  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));
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
 
   // Let the async callbacks in the request coordinator run.
   PumpLoop();
+  EXPECT_TRUE(immediate_schedule_callback_called());
 
   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));
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(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_TRUE(immediate_schedule_callback_called());
 
   EXPECT_FALSE(is_starting());
 
   // OfflinerDoneCallback will not end up getting called with status SAVED,
   // since we cancelled the event before it called offliner_->LoadAndSave().
   EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
             last_offlining_status());
 
   // Since offliner was not started, it will not have seen cancel call.
   EXPECT_FALSE(OfflinerWasCanceled());
 }
 
 // This tests a StopProcessing call after the prerenderer has been started.
 TEST_F(RequestCoordinatorTest, StartProcessingThenStopProcessingLater) {
   // 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();
 
   // 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));
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
   EXPECT_TRUE(is_starting());
 
   // Let all the async parts of the start processing pipeline run to completion.
   PumpLoop();
+  // Since the offliner is disabled, this callback should not be called.
+  EXPECT_FALSE(immediate_schedule_callback_called());
 
   // Coordinator should now be busy.
   EXPECT_TRUE(is_busy());
   EXPECT_FALSE(is_starting());
 
   // Now we cancel it while the prerenderer is busy.
   coordinator()->StopProcessing(Offliner::REQUEST_COORDINATOR_CANCELED);
 
   // Let the async callbacks in the cancel run.
   PumpLoop();
@@ skipping 18 matching lines @@
   coordinator()->queue()->AddRequest(
       request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            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));
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
 
   // Let all the async parts of the start processing pipeline run to completion.
   PumpLoop();
+  // Since the offliner is disabled, this callback should not be called.
+  EXPECT_FALSE(immediate_schedule_callback_called());
 
   // 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)));
 
   // Let the async callbacks in the cancel run.
   PumpLoop();
 
   // Since offliner was started, it will have seen cancel call.
   EXPECT_TRUE(OfflinerWasCanceled());
 }
 
 TEST_F(RequestCoordinatorTest, MarkRequestCompleted) {
   // Add a request to the queue.
   offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
                                           base::Time::Now(), kUserRequested);
   int64_t request_id = coordinator()->SavePageLater(
       kUrl1, kClientId1, kUserRequested,
       RequestCoordinator::RequestAvailability::DISABLED_FOR_OFFLINER);
   PumpLoop();
   EXPECT_NE(request_id, 0l);
 
   // 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));
+  base::Callback<void(bool)> callback =
+      base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
+                 base::Unretained(this));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
 
   // Call the method under test, making sure we send SUCCESS to the observer.
   coordinator()->MarkRequestCompleted(request_id);
   PumpLoop();
+  EXPECT_TRUE(immediate_schedule_callback_called());
 
   // Our observer should have seen SUCCESS instead of REMOVED.
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::SUCCESS,
             observer().last_status());
   EXPECT_TRUE(observer().completed_called());
 }
 
 TEST_F(RequestCoordinatorTest, WatchdogTimeoutForScheduledProcessing) {
   // Build a request to use with the pre-renderer, and put it on the queue.
   offline_pages::SavePageRequest request(
@@ skipping 293 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