Adds an observer for the request coordinator.

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 108 matching lines @@
     if (offliner_.get() == nullptr) {
       offliner_.reset(new OfflinerStub());
     }
     return offliner_.get();
   }
 
  private:
   std::unique_ptr<OfflinerStub> offliner_;
 };
 
+class ObserverStub : public RequestCoordinator::Observer {
+ public:
+  ObserverStub()
+      : available_called_(false),
+        succeeded_called_(false),
+        failed_called_(false),
+        paused_called_(false) {}
+
+  void clear() {
+    available_called_ = false;
+    succeeded_called_ = false;
+    failed_called_ = false;
+    paused_called_ = false;
+  }
+
+  void OnAvailable(RequestCoordinator::RequestInfo info) override {
+    available_called_ = true;
+  }
+
+  void OnSucceeded(RequestCoordinator::RequestInfo info) override {
+    succeeded_called_ = true;
+  }
+
+  void OnFailed(RequestCoordinator::RequestInfo info) override {
+    failed_called_ = true;
+  }
+
+  void OnPaused(RequestCoordinator::RequestInfo info) override {
+    paused_called_ = true;
+  }
+
+  bool available_called() { return available_called_; }
+  bool succeeded_called() { return succeeded_called_; }
+  bool failed_called() { return failed_called_; }
+  bool paused_called() { return paused_called_; }
+
+ private:
+  bool available_called_;
+  bool succeeded_called_;
+  bool failed_called_;
+  bool paused_called_;
+};
+
 class RequestCoordinatorTest
     : public testing::Test {
  public:
   RequestCoordinatorTest();
   ~RequestCoordinatorTest() override;
 
   void SetUp() override;
 
   void PumpLoop();
 
@@ skipping 59 matching lines @@
   void AdvanceClockBy(base::TimeDelta delta) {
     task_runner_->FastForwardBy(delta);
   }
 
   Offliner::RequestStatus last_offlining_status() const {
     return coordinator_->last_offlining_status_;
   }
 
   bool OfflinerWasCanceled() const { return offliner_->cancel_called(); }
 
+  ObserverStub observer() { return observer_; }
+
  private:
   RequestQueue::GetRequestsResult last_get_requests_result_;
   std::vector<SavePageRequest> last_requests_;
   std::vector<ClientId> last_client_ids_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<RequestCoordinator> coordinator_;
   OfflinerStub* offliner_;
   base::WaitableEvent waiter_;
+  ObserverStub observer_;
 };
 
 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) {}
 
 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>
       store(new RequestQueueInMemoryStore());
   std::unique_ptr<RequestQueue> queue(new RequestQueue(std::move(store)));
   std::unique_ptr<Scheduler> scheduler_stub(new SchedulerStub());
   coordinator_.reset(new RequestCoordinator(
       std::move(policy), std::move(factory), std::move(queue),
       std::move(scheduler_stub)));
+  coordinator_->AddObserver(&observer_);
 }
 
 void RequestCoordinatorTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
 void RequestCoordinatorTest::GetRequestsDone(
     RequestQueue::GetRequestsResult result,
     const std::vector<SavePageRequest>& requests) {
   last_get_requests_result_ = result;
@@ skipping 67 matching lines @@
   EXPECT_EQ(kClientId1, last_requests()[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()
                 ->GetTriggerConditionsForUserRequest()
                 .minimum_battery_percentage,
             scheduler_stub->conditions()->minimum_battery_percentage);
+
+  // Check that the observer got the notification that a page is available
+  EXPECT_EQ(true, observer().available_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);
   request.MarkAttemptStarted(base::Time::Now());
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
@@ skipping 21 matching lines @@
   // 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.
   EXPECT_EQ(0UL, last_requests().size());
+  // Check that the observer got the notification that we succeeded.
+  EXPECT_EQ(true, observer().succeeded_called());
 }
 
 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.MarkAttemptStarted(base::Time::Now());
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
@@ skipping 34 matching lines @@
 
   // Verify neither request is removed from the queue; wait for callbacks.
   coordinator()->queue()->GetRequests(
       base::Bind(&RequestCoordinatorTest::GetRequestsDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // Now just one request in the queue since failed request removed
   // (for single attempt policy).
   EXPECT_EQ(1UL, last_requests().size());
+  // Check that the observer got the notification that we failed
+  EXPECT_EQ(true, observer().failed_called());
 }
 
 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)));
@@ skipping 218 matching lines @@
   // Wait for async get to finish.
   WaitForCallback();
   PumpLoop();
 
   // Check that the statuses found in the callback match what we expect.
   EXPECT_EQ(2UL, last_client_ids().size());
   EXPECT_EQ(kId1, last_client_ids().at(0).id);
   EXPECT_EQ(kId2, last_client_ids().at(1).id);
 }
 
+TEST_F(RequestCoordinatorTest, PauseAndResumeObserver) {
+  // Add a request to the queue.
+  offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
+                                          base::Time::Now(), kUserRequested);
+  coordinator()->queue()->AddRequest(
+      request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
+                           base::Unretained(this)));
+  PumpLoop();
+
+  // Pause the request.
+  std::vector<ClientId> client_ids;
+  client_ids.push_back(kClientId1);
+  coordinator()->PauseRequests(client_ids);
+  PumpLoop();
+
+  EXPECT_EQ(true, observer().paused_called());
+
+  // Clear out the observer before the next call.
+  observer().clear();
+
+  // Resume the request.
+  coordinator()->ResumeRequests(client_ids);
+  PumpLoop();
+
+  EXPECT_EQ(true, observer().available_called());
+}
+
 }  // namespace offline_pages