Move all components/offline_pages/ files into component/offline_pages/core

components/offline_pages/core/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 "components/offline_pages/core/background/request_coordinator.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_info.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "components/offline_pages/background/device_conditions.h"
-#include "components/offline_pages/background/network_quality_provider_stub.h"
-#include "components/offline_pages/background/offliner.h"
-#include "components/offline_pages/background/offliner_factory.h"
-#include "components/offline_pages/background/offliner_factory_stub.h"
-#include "components/offline_pages/background/offliner_policy.h"
-#include "components/offline_pages/background/offliner_stub.h"
-#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 "components/offline_pages/background/scheduler_stub.h"
-#include "components/offline_pages/offline_page_feature.h"
+#include "components/offline_pages/core/background/device_conditions.h"
+#include "components/offline_pages/core/background/network_quality_provider_stub.h"
+#include "components/offline_pages/core/background/offliner.h"
+#include "components/offline_pages/core/background/offliner_factory.h"
+#include "components/offline_pages/core/background/offliner_factory_stub.h"
+#include "components/offline_pages/core/background/offliner_policy.h"
+#include "components/offline_pages/core/background/offliner_stub.h"
+#include "components/offline_pages/core/background/request_queue.h"
+#include "components/offline_pages/core/background/request_queue_in_memory_store.h"
+#include "components/offline_pages/core/background/save_page_request.h"
+#include "components/offline_pages/core/background/scheduler.h"
+#include "components/offline_pages/core/background/scheduler_stub.h"
+#include "components/offline_pages/core/offline_page_feature.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 // put test constants here
 const GURL kUrl1("http://universe.com/everything");
 const GURL kUrl2("http://universe.com/toinfinityandbeyond");
 const std::string kClientNamespace("bookmark");
 const std::string kId1("42");
@@ skipping 52 matching lines @@
   SavePageRequest::RequestState state() { return state_; }
 
  private:
   bool added_called_;
   bool completed_called_;
   bool changed_called_;
   RequestCoordinator::BackgroundSavePageResult last_status_;
   SavePageRequest::RequestState state_;
 };
 
-class RequestCoordinatorTest
-    : public testing::Test {
+class RequestCoordinatorTest : public testing::Test {
  public:
   RequestCoordinatorTest();
   ~RequestCoordinatorTest() override;
 
   void SetUp() override;
 
   void PumpLoop();
 
-  RequestCoordinator* coordinator() {
-    return coordinator_.get();
-  }
+  RequestCoordinator* coordinator() { return coordinator_.get(); }
 
-  bool is_busy() {
-    return coordinator_->is_busy();
-  }
+  bool is_busy() { return coordinator_->is_busy(); }
 
   bool is_starting() { return coordinator_->is_starting(); }
 
   // Empty callback function.
   void ImmediateScheduleCallbackFunction(bool result) {
     immediate_schedule_callback_called_ = true;
     immediate_schedule_callback_result_ = result;
   }
 
   // Callback function which releases a wait for it.
-  void WaitingCallbackFunction(bool result) {
-    waiter_.Signal();
-  }
+  void WaitingCallbackFunction(bool result) { waiter_.Signal(); }
 
   net::NetworkChangeNotifier::ConnectionType GetConnectionType() {
     return coordinator()->GetConnectionType();
   }
 
   // Callback for Add requests.
   void AddRequestDone(AddRequestResult result, const SavePageRequest& request);
 
   // Callback for getting requests.
   void GetRequestsDone(GetRequestsResult result,
@@ skipping 17 matching lines @@
   }
 
   const std::vector<std::unique_ptr<SavePageRequest>>& last_requests() const {
     return last_requests_;
   }
 
   const MultipleItemStatuses& last_remove_results() const {
     return last_remove_results_;
   }
 
-  void DisableLoading() {
-    offliner_->disable_loading();
-  }
+  void DisableLoading() { offliner_->disable_loading(); }
 
   void EnableOfflinerCallback(bool enable) {
     offliner_->enable_callback(enable);
   }
 
   void SetNetworkConditionsForTest(
       net::NetworkChangeNotifier::ConnectionType connection) {
     coordinator()->SetNetworkConditionsForTest(connection);
   }
 
@@ skipping 44 matching lines @@
     else
       coordinator_->disabled_requests_.clear();
 
     coordinator_->RequestNotPicked(non_user_requested_tasks_remaining, false);
   }
 
   void SetDeviceConditionsForTest(DeviceConditions device_conditions) {
     coordinator_->SetDeviceConditionsForTest(device_conditions);
   }
 
-  void WaitForCallback() {
-    waiter_.Wait();
-  }
+  void WaitForCallback() { waiter_.Wait(); }
 
   void AdvanceClockBy(base::TimeDelta delta) {
     task_runner_->FastForwardBy(delta);
   }
 
   SavePageRequest AddRequest1();
 
   SavePageRequest AddRequest2();
 
   Offliner::RequestStatus last_offlining_status() const {
@@ skipping 54 matching lines @@
                          net::NetworkChangeNotifier::CONNECTION_3G) {}
 
 RequestCoordinatorTest::~RequestCoordinatorTest() {}
 
 void RequestCoordinatorTest::SetUp() {
   std::unique_ptr<OfflinerPolicy> policy(new OfflinerPolicy());
   std::unique_ptr<OfflinerFactory> offliner_factory(new OfflinerFactoryStub());
   // Save the offliner for use by the tests.
   offliner_ = reinterpret_cast<OfflinerStub*>(
       offliner_factory->GetOffliner(policy.get()));
-  std::unique_ptr<RequestQueueInMemoryStore>
-      store(new RequestQueueInMemoryStore());
+  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 NetworkQualityProviderStub());
   coordinator_.reset(new RequestCoordinator(
       std::move(policy), std::move(offliner_factory), std::move(queue),
       std::move(scheduler_stub), network_quality_estimator_.get()));
   coordinator_->AddObserver(&observer_);
   SetNetworkConnected(true);
   immediate_callback_ =
       base::Bind(&RequestCoordinatorTest::ImmediateScheduleCallbackFunction,
@@ skipping 47 matching lines @@
                  base::Unretained(this));
   coordinator()->SetProcessingCallbackForTest(callback);
 
   // Mock that coordinator is in actively processing state starting now.
   SetProcessingStateForTest(
       RequestCoordinator::ProcessingWindowState::IMMEDIATE_WINDOW);
   SetOperationStartTimeForTest(base::Time::Now());
 }
 
 void RequestCoordinatorTest::SendOfflinerDoneCallback(
-    const SavePageRequest& request, Offliner::RequestStatus status) {
+    const SavePageRequest& request,
+    Offliner::RequestStatus status) {
   // Using the fact that the test class is a friend, call to the callback
   coordinator_->OfflinerDoneCallback(request, status);
 }
 
 SavePageRequest RequestCoordinatorTest::AddRequest1() {
   offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
                                           base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
                            base::Unretained(this)));
@@ skipping 22 matching lines @@
         "OfflinePages.Background.ScheduledStart.AvailableRequestCount.Svelte",
         0, 1);
   } else {
     histograms().ExpectBucketCount(
         "OfflinePages.Background.ScheduledStart.AvailableRequestCount", 0, 1);
   }
 }
 
 TEST_F(RequestCoordinatorTest, StartProcessingWithRequestInProgress) {
   // Start processing for this request.
-  EXPECT_NE(
-      coordinator()->SavePageLater(
-          kUrl1, kClientId1, kUserRequested,
-          RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
+  EXPECT_NE(coordinator()->SavePageLater(
+                kUrl1, kClientId1, kUserRequested,
+                RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER),
+            0);
 
   // 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(),
                                              immediate_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(),
                                               immediate_callback()));
 }
 
 TEST_F(RequestCoordinatorTest, SavePageLater) {
   // The user-requested request which gets processed by SavePageLater
   // would invoke user request callback.
   coordinator()->SetImmediateScheduleCallbackForTest(immediate_callback());
 
-  EXPECT_NE(
-      coordinator()->SavePageLater(
-          kUrl1, kClientId1, kUserRequested,
-          RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
+  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.
@@ skipping 28 matching lines @@
   // The user-requested request which gets processed by SavePageLater
   // would invoke user request callback.
   coordinator()->SetImmediateScheduleCallbackForTest(immediate_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)));
+  coordinator()->queue()->GetRequests(base::Bind(
+      &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
 
   // Wait for callbacks to finish, both request queue and offliner.
   PumpLoop();
 
   // On low-end devices the callback will be called with false since the
   // processing started but failed due to svelte devices.
   EXPECT_TRUE(immediate_schedule_callback_called());
   if (base::SysInfo::IsLowEndDevice()) {
     EXPECT_FALSE(immediate_schedule_callback_result());
   } else {
     EXPECT_TRUE(immediate_schedule_callback_result());
   }
 
   // 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());
+  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, OfflinerDoneRequestSucceeded) {
   // Add a request to the queue, wait for callbacks to finish.
-  offline_pages::SavePageRequest request(
-      kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
+  offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
+                                         base::Time::Now(), kUserRequested);
   SetupForOfflinerDoneCallbackTest(&request);
 
   // 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)));
+  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.
   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,
@@ skipping 24 matching lines @@
 
   // 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);
+  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.
   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 continue to 2nd request so
   // no scheduler callback yet.
   EXPECT_FALSE(immediate_schedule_callback_called());
 
   // Busy processing 2nd request.
   EXPECT_TRUE(is_busy());
 
-  coordinator()->queue()->GetRequests(
-      base::Bind(&RequestCoordinatorTest::GetRequestsDone,
-                 base::Unretained(this)));
+  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) since we exceeded
   // retry count.
   EXPECT_TRUE(observer().completed_called());
   EXPECT_EQ(RequestCoordinator::BackgroundSavePageResult::RETRY_COUNT_EXCEEDED,
@@ skipping 64 matching lines @@
   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);
+  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);
   PumpLoop();
   EXPECT_TRUE(immediate_schedule_callback_called());
 
   // Verify the request is not removed from the queue, and wait for callbacks.
@@ skipping 282 matching lines @@
   coordinator()->EnableForOffliner(request_id, kClientId1);
   PumpLoop();
 
   // Verify request changed again.
   EXPECT_TRUE(observer().changed_called());
   EXPECT_EQ(SavePageRequest::RequestState::AVAILABLE, observer().state());
 }
 
 TEST_F(RequestCoordinatorTest, WatchdogTimeoutForScheduledProcessing) {
   // Build a request to use with the pre-renderer, and put it on the queue.
-  offline_pages::SavePageRequest request(
-      kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
+  offline_pages::SavePageRequest request(kRequestId1, kUrl1, kClientId1,
+                                         base::Time::Now(), kUserRequested);
   // Set request to allow one more completed attempt.
   int max_tries = coordinator()->policy()->GetMaxCompletedTries();
   request.set_completed_attempt_count(max_tries - 1);
   coordinator()->queue()->AddRequest(
-      request,
-      base::Bind(&RequestCoordinatorTest::AddRequestDone,
-                 base::Unretained(this)));
+      request, base::Bind(&RequestCoordinatorTest::AddRequestDone,
+                          base::Unretained(this)));
   PumpLoop();
 
   // 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);
 
   // Sending the request to the offliner.
   EXPECT_TRUE(
       coordinator()->StartProcessing(device_conditions(), waiting_callback()));
   PumpLoop();
 
   // Advance the mock clock far enough to cause a watchdog timeout
   AdvanceClockBy(base::TimeDelta::FromSeconds(
       coordinator()
           ->policy()
-          ->GetSinglePageTimeLimitWhenBackgroundScheduledInSeconds() + 1));
+          ->GetSinglePageTimeLimitWhenBackgroundScheduledInSeconds() +
+      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();
   PumpLoop();
 
   EXPECT_FALSE(is_starting());
   EXPECT_FALSE(coordinator()->is_busy());
   EXPECT_TRUE(OfflinerWasCanceled());
 }
 
 TEST_F(RequestCoordinatorTest, WatchdogTimeoutForImmediateProcessing) {
   // If low end device, pretend it is not so that immediate start happens.
   SetIsLowEndDeviceForTest(false);
 
   // 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);
+  EXPECT_NE(coordinator()->SavePageLater(
+                kUrl1, kClientId1, kUserRequested,
+                RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER),
+            0);
   PumpLoop();
 
   // Verify that immediate start from adding the request did happen.
   EXPECT_TRUE(coordinator()->is_busy());
 
   // Advance the mock clock 1 second before the watchdog timeout.
   AdvanceClockBy(base::TimeDelta::FromSeconds(
       coordinator()
           ->policy()
-          ->GetSinglePageTimeLimitForImmediateLoadInSeconds() - 1));
+          ->GetSinglePageTimeLimitForImmediateLoadInSeconds() -
+      1));
   PumpLoop();
 
   // Verify still busy.
   EXPECT_TRUE(coordinator()->is_busy());
   EXPECT_FALSE(OfflinerWasCanceled());
 
   // Advance the mock clock past the watchdog timeout now.
   AdvanceClockBy(base::TimeDelta::FromSeconds(2));
   PumpLoop();
 
@@ skipping 21 matching lines @@
 
   // Advance the mock clock far enough to exceed our time budget.
   // The first request will time out, and because we are over time budget,
   // the second request will not be started.
   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.  Both requests should be left in the queue.
-  coordinator()->queue()->GetRequests(
-      base::Bind(&RequestCoordinatorTest::GetRequestsDone,
-                 base::Unretained(this)));
+  coordinator()->queue()->GetRequests(base::Bind(
+      &RequestCoordinatorTest::GetRequestsDone, base::Unretained(this)));
   PumpLoop();
 
   // We should find two requests in the queue.
   // The first request should now have a completed count of 1.
   EXPECT_EQ(2UL, last_requests().size());
   EXPECT_EQ(1L, last_requests().at(0)->completed_attempt_count());
 }
 
 TEST_F(RequestCoordinatorTest, TryNextRequestWithNoNetwork) {
   SavePageRequest request1 = AddRequest1();
@@ skipping 110 matching lines @@
             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) {
   // Turn off the callback so that the request stops before processing in
   // PumpLoop.
   EnableOfflinerCallback(false);
-  EXPECT_NE(
-      coordinator()->SavePageLater(
-          kUrl1, kClientId1, kUserRequested,
-          RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
+  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());
   }
 }
@@ skipping 60 matching lines @@
   // Set specific network type for 2G with poor effective connection.
   SetNetworkConditionsForTest(
       net::NetworkChangeNotifier::ConnectionType::CONNECTION_2G);
   SetEffectiveConnectionTypeForTest(
       net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
 
   // Turn off the callback so that the request stops before processing in
   // PumpLoop.
   EnableOfflinerCallback(false);
 
-  EXPECT_NE(
-      coordinator()->SavePageLater(
-          kUrl1, kClientId1, kUserRequested,
-          RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER), 0);
+  EXPECT_NE(coordinator()->SavePageLater(
+                kUrl1, kClientId1, kUserRequested,
+                RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER),
+            0);
   PumpLoop();
   EXPECT_TRUE(is_busy());
 }
 
 TEST_F(RequestCoordinatorTest,
        ResumeStartsProcessingWhenConnectedAndNotLowEndDevice) {
   // Start unconnected.
   SetNetworkConnected(false);
 
   // Turn off the callback so that the request stops before processing in
@@ skipping 31 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