API to provide status of save page reqeusts to API.

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 11 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 GURL kUrl("http://universe.com/everything");
-const ClientId kClientId("bookmark", "42");
+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 GURL kUrl2("http://universe.com/toinfinityandbeyond");
-const ClientId kClientId2("bookmark", "43");
-const int kRequestId(1);
 const long kTestTimeoutSeconds = 1;
 const long kTestTimeBudgetSeconds = 200;
 const int kBatteryPercentageHigh = 75;
 const bool kPowerRequired = true;
 const bool kUserRequested = true;
 const int kAttemptCount = 1;
 }  // namespace
 
 class SchedulerStub : public Scheduler {
  public:
@@ skipping 20 matching lines @@
 
  private:
   bool schedule_called_;
   bool unschedule_called_;
   TriggerConditions conditions_;
 };
 
 class OfflinerStub : public Offliner {
  public:
   OfflinerStub()
-      : request_(kRequestId, kUrl, kClientId, base::Time::Now(),
+      : request_(kRequestId1, kUrl1, kClientId1, base::Time::Now(),
                  kUserRequested),
         enable_callback_(false),
         cancel_called_(false) {}
 
   bool LoadAndSave(const SavePageRequest& request,
                    const CompletionCallback& callback) override {
     callback_ = callback;
     request_ = request;
     // Post the callback on the run loop.
     if (enable_callback_) {
@@ skipping 45 matching lines @@
   void PumpLoop();
 
   RequestCoordinator* coordinator() {
     return coordinator_.get();
   }
 
   bool is_busy() {
     return coordinator_->is_busy();
   }
 
-  // Empty callback function
+  // Empty callback function.
   void EmptyCallbackFunction(bool result) {
   }
 
   // Callback function which releases a wait for it.
   void WaitingCallbackFunction(bool result) {
     waiter_.Signal();
   }
 
-  // Callback for Add requests
+  // Callback for Add requests.
   void AddRequestDone(RequestQueue::AddRequestResult result,
                       const SavePageRequest& request);
 
   // Callback for getting requests.
   void GetRequestsDone(RequestQueue::GetRequestsResult result,
                        const std::vector<SavePageRequest>& requests);
 
+  // Callback for getting request statuses.
+  void GetQueuedRequestsDone(const std::vector<ClientId>& client_ids);
+
   void SendOfflinerDoneCallback(const SavePageRequest& request,
                                 Offliner::RequestStatus status);
 
   RequestQueue::GetRequestsResult last_get_requests_result() const {
     return last_get_requests_result_;
   }
 
   const std::vector<SavePageRequest>& last_requests() const {
     return last_requests_;
   }
 
+  const std::vector<ClientId>& last_client_ids() const {
+    return last_client_ids_;
+  }
+
   void EnableOfflinerCallback(bool enable) {
     offliner_->enable_callback(enable);
   }
 
   void SetOfflinerTimeoutForTest(const base::TimeDelta& timeout) {
     coordinator_->SetOfflinerTimeoutForTest(timeout);
   }
 
   void SetDeviceConditionsForTest(DeviceConditions device_conditions) {
     coordinator_->SetDeviceConditionsForTest(device_conditions);
   }
 
   void WaitForCallback() {
     waiter_.Wait();
   }
 
   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(); }
 
  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_;
 };
 
 RequestCoordinatorTest::RequestCoordinatorTest()
     : last_get_requests_result_(RequestQueue::GetRequestsResult::STORE_FAILURE),
       task_runner_(new base::TestMockTimeTaskRunner),
@@ skipping 23 matching lines @@
   task_runner_->RunUntilIdle();
 }
 
 void RequestCoordinatorTest::GetRequestsDone(
     RequestQueue::GetRequestsResult result,
     const std::vector<SavePageRequest>& requests) {
   last_get_requests_result_ = result;
   last_requests_ = requests;
 }
 
+void RequestCoordinatorTest::GetQueuedRequestsDone(
+    const std::vector<ClientId>& client_ids) {
+  last_client_ids_ = client_ids;
+  waiter_.Signal();
+}
+
 void RequestCoordinatorTest::AddRequestDone(
     RequestQueue::AddRequestResult result,
     const SavePageRequest& request) {}
 
 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));
   EXPECT_TRUE(coordinator()->StartProcessing(device_conditions, callback));
 }
 
 TEST_F(RequestCoordinatorTest, StartProcessingWithRequestInProgress) {
   // Put the request on the queue.
-  EXPECT_TRUE(coordinator()->SavePageLater(kUrl, kClientId, kUserRequested));
+  EXPECT_TRUE(coordinator()->SavePageLater(kUrl1, kClientId1, kUserRequested));
 
   // 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));
   PumpLoop();
   EXPECT_TRUE(is_busy());
 
   // Now trying to start processing on another request should return false.
   EXPECT_FALSE(coordinator()->StartProcessing(device_conditions, callback));
 }
 
 TEST_F(RequestCoordinatorTest, SavePageLater) {
-  EXPECT_TRUE(coordinator()->SavePageLater(kUrl, kClientId, kUserRequested));
+  EXPECT_TRUE(coordinator()->SavePageLater(kUrl1, kClientId1, kUserRequested));
 
   // 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();
 
   // Check the request queue is as expected.
   EXPECT_EQ(1UL, last_requests().size());
-  EXPECT_EQ(kUrl, last_requests()[0].url());
-  EXPECT_EQ(kClientId, last_requests()[0].client_id());
+  EXPECT_EQ(kUrl1, last_requests()[0].url());
+  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);
 }
 
 TEST_F(RequestCoordinatorTest, OfflinerDoneRequestSucceeded) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
-      kRequestId, kUrl, kClientId, base::Time::Now(), kUserRequested);
+      kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   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,
@@ skipping 19 matching lines @@
 
   // 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());
 }
 
 TEST_F(RequestCoordinatorTest, OfflinerDoneRequestFailed) {
   // Add a request to the queue, wait for callbacks to finish.
   offline_pages::SavePageRequest request(
-      kRequestId, kUrl, kClientId, base::Time::Now(), kUserRequested);
+      kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // 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(
@@ skipping 36 matching lines @@
   // Verify retry count was incremented for first request.
   const SavePageRequest& found_request = last_requests().front();
   EXPECT_EQ(1L, found_request.attempt_count());
 }
 
 // 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(
-      kRequestId, kUrl, kClientId, base::Time::Now(), kUserRequested);
+      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(
@@ skipping 13 matching lines @@
             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(
-      kRequestId, kUrl, kClientId, base::Time::Now(), kUserRequested);
+      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,
@@ skipping 18 matching lines @@
   EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
             last_offlining_status());
 
   // Since offliner was started, it will have seen cancel call.
   EXPECT_TRUE(OfflinerWasCanceled());
 }
 
 TEST_F(RequestCoordinatorTest, PrerendererTimeout) {
   // Build a request to use with the pre-renderer, and put it on the queue.
   offline_pages::SavePageRequest request(
-      kRequestId, kUrl, kClientId, base::Time::Now(), kUserRequested);
+      kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   coordinator()->queue()->AddRequest(
       request,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // Set up for the call to StartProcessing.
   DeviceConditions device_conditions(
       !kPowerRequired, kBatteryPercentageHigh,
       net::NetworkChangeNotifier::CONNECTION_3G);
@@ skipping 22 matching lines @@
   // tasks too soon.
   WaitForCallback();
   PumpLoop();
 
   EXPECT_TRUE(OfflinerWasCanceled());
   EXPECT_EQ(Offliner::RequestStatus::REQUEST_COORDINATOR_CANCELED,
             last_offlining_status());
 }
 
 TEST_F(RequestCoordinatorTest, TimeBudgetExceeded) {
-  // Build a request to use with the pre-renderer, and put it on the queue.
+  // Build two requests to use with the pre-renderer, and put it on the queue.
   offline_pages::SavePageRequest request1(
-      kRequestId, kUrl, kClientId, base::Time::Now(), kUserRequested);
+      kRequestId1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   offline_pages::SavePageRequest request2(
-      kRequestId + 1, kUrl, kClientId, base::Time::Now(), kUserRequested);
+      kRequestId1 + 1, kUrl1, kClientId1, base::Time::Now(), kUserRequested);
   request2.set_attempt_count(kAttemptCount);
   coordinator()->queue()->AddRequest(
       request1,
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
-    coordinator()->queue()->AddRequest(
-      request1,
+  coordinator()->queue()->AddRequest(
+      request1,  // TODO(petewil): This is a bug, should be request2.
       base::Bind(&RequestCoordinatorTest::AddRequestDone,
                  base::Unretained(this)));
   PumpLoop();
 
   // 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,
@@ skipping 13 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 find one request in the queue.
   EXPECT_EQ(1UL, last_requests().size());
 }
 
+TEST_F(RequestCoordinatorTest, GetQueuedRequests) {
+  // Add two requests to the queue.
+  offline_pages::SavePageRequest request1(kRequestId1, kUrl1, kClientId1,
+                                          base::Time::Now(), kUserRequested);
+  offline_pages::SavePageRequest request2(kRequestId1 + 1, kUrl2, kClientId2,
+                                          base::Time::Now(), kUserRequested);
+  coordinator()->queue()->AddRequest(
+      request1, base::Bind(&RequestCoordinatorTest::AddRequestDone,
+                           base::Unretained(this)));
+  coordinator()->queue()->AddRequest(
+      request2, base::Bind(&RequestCoordinatorTest::AddRequestDone,
+                           base::Unretained(this)));
+  PumpLoop();
+
+  // Start the async status fetching.
+  coordinator()->GetQueuedRequests(
+      kClientNamespace,
+      base::Bind(&RequestCoordinatorTest::GetQueuedRequestsDone,
+                 base::Unretained(this)));
+  PumpLoop();
+
+  // 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);
+}
+
 }  // namespace offline_pages