[Offline pages] Updating RequestQueue::RemoveRequests to use a TaskQueue

components/offline_pages/background/request_queue_store_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_queue_store.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 40 matching lines @@
   void PumpLoop();
   void ClearResults();
 
   // Callback used for get requests.
   void GetRequestsDone(bool result,
                        std::vector<std::unique_ptr<SavePageRequest>> requests);
   // Callback used for add/update request.
   void AddOrUpdateDone(UpdateStatus result);
   void AddRequestDone(ItemActionStatus status);
   void UpdateRequestDone(std::unique_ptr<UpdateRequestsResult> result);
-  // Callback used for remove requests.
-  void RemoveDone(const RequestQueue::UpdateMultipleRequestResults& results,
-                  std::vector<std::unique_ptr<SavePageRequest>> requests);
   // Callback used for reset.
   void ResetDone(bool result);
 
   LastResult last_result() const { return last_result_; }
   UpdateStatus last_update_status() const { return last_update_status_; }
-  const RequestQueue::UpdateMultipleRequestResults&
-  last_multiple_update_results() const {
-    return last_multiple_update_results_;
-  }
-  const RequestQueue::UpdateMultipleRequestResults& last_remove_results()
-      const {
-    return last_remove_results_;
-  }
   const std::vector<std::unique_ptr<SavePageRequest>>& last_requests() const {
     return last_requests_;
   }
   ItemActionStatus last_add_status() const { return last_add_status_; }
 
   UpdateRequestsResult* last_update_result() const {
     return last_update_result_.get();
   }
 
  protected:
   base::ScopedTempDir temp_directory_;
 
  private:
   LastResult last_result_;
   UpdateStatus last_update_status_;
   ItemActionStatus last_add_status_;
   std::unique_ptr<UpdateRequestsResult> last_update_result_;
-  RequestQueue::UpdateMultipleRequestResults last_multiple_update_results_;
-  RequestQueue::UpdateMultipleRequestResults last_remove_results_;
   std::vector<std::unique_ptr<SavePageRequest>> last_requests_;
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
 };
 
 RequestQueueStoreTestBase::RequestQueueStoreTestBase()
     : last_result_(LastResult::kNone),
       last_update_status_(UpdateStatus::FAILED),
       last_add_status_(ItemActionStatus::NOT_FOUND),
       task_runner_(new base::TestSimpleTaskRunner),
       task_runner_handle_(task_runner_) {
   EXPECT_TRUE(temp_directory_.CreateUniqueTempDir());
 }
 
 void RequestQueueStoreTestBase::TearDown() {
   // Wait for all the pieces of the store to delete itself properly.
   PumpLoop();
 }
 
 void RequestQueueStoreTestBase::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
 void RequestQueueStoreTestBase::ClearResults() {
   last_result_ = LastResult::kNone;
   last_update_status_ = UpdateStatus::FAILED;
   last_add_status_ = ItemActionStatus::NOT_FOUND;
-  last_remove_results_.clear();
   last_requests_.clear();
   last_update_result_.reset(nullptr);
 }
 
 void RequestQueueStoreTestBase::GetRequestsDone(
     bool result,
     std::vector<std::unique_ptr<SavePageRequest>> requests) {
   last_result_ = result ? LastResult::kTrue : LastResult::kFalse;
   last_requests_ = std::move(requests);
 }
 
 void RequestQueueStoreTestBase::AddOrUpdateDone(UpdateStatus status) {
   last_update_status_ = status;
 }
 
 void RequestQueueStoreTestBase::AddRequestDone(ItemActionStatus status) {
   last_add_status_ = status;
 }
 
 void RequestQueueStoreTestBase::UpdateRequestDone(
     std::unique_ptr<UpdateRequestsResult> result) {
   last_update_result_ = std::move(result);
 }
 
-void RequestQueueStoreTestBase::RemoveDone(
-    const RequestQueue::UpdateMultipleRequestResults& results,
-    std::vector<std::unique_ptr<SavePageRequest>> requests) {
-  last_remove_results_ = results;
-  last_requests_ = std::move(requests);
-}
-
 void RequestQueueStoreTestBase::ResetDone(bool result) {
   last_result_ = result ? LastResult::kTrue : LastResult::kFalse;
 }
 
 // Defines interface for the store factory.
 class RequestQueueStoreFactory {
  public:
   virtual RequestQueueStore* BuildStore(const base::FilePath& path) = 0;
 };
 
@@ skipping 158 matching lines @@
                                base::Unretained(this)));
   SavePageRequest request2(kRequestId2, kUrl2, kClientId2, creation_time,
                            kUserRequested);
   store->AddRequest(request2,
                     base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
                                base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   std::vector<int64_t> request_ids{kRequestId, kRequestId2};
-  store->RemoveRequests(request_ids,
-                        base::Bind(&RequestQueueStoreTestBase::RemoveDone,
-                                   base::Unretained(this)));
-  ASSERT_EQ(0ul, this->last_remove_results().size());
+  store->RemoveRequests(
+      request_ids, base::Bind(&RequestQueueStoreTestBase::UpdateRequestDone,
+                              base::Unretained(this)));
+
+  ASSERT_FALSE(this->last_update_result());
   this->PumpLoop();
-  ASSERT_EQ(2ul, this->last_remove_results().size());
-  ASSERT_EQ(RequestQueue::UpdateRequestResult::SUCCESS,
-            this->last_remove_results().at(0).second);
-  ASSERT_EQ(RequestQueue::UpdateRequestResult::SUCCESS,
-            this->last_remove_results().at(1).second);
-  ASSERT_EQ(2UL, this->last_requests().size());
-  ASSERT_EQ(kRequestId, this->last_requests().at(0)->request_id());
-  this->ClearResults();
+  ASSERT_TRUE(this->last_update_result());
+  EXPECT_EQ(2UL, this->last_update_result()->item_statuses.size());
+  EXPECT_EQ(kRequestId, this->last_update_result()->item_statuses[0].first);
+  EXPECT_EQ(ItemActionStatus::SUCCESS,
+            this->last_update_result()->item_statuses[0].second);
+  EXPECT_EQ(kRequestId2, this->last_update_result()->item_statuses[1].first);
+  EXPECT_EQ(ItemActionStatus::SUCCESS,
+            this->last_update_result()->item_statuses[1].second);
+  EXPECT_EQ(2UL, this->last_update_result()->updated_items.size());
+  EXPECT_EQ(request1, this->last_update_result()->updated_items.at(0));
+  EXPECT_EQ(request2, this->last_update_result()->updated_items.at(1));
 

[Pete Williamson, 2016/09/30 18:03:53]

It might be good to call this->ClearResults() before the following "get"
operation.

[fgorski, 2016/10/04 17:18:23]

Done.

   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_TRUE(this->last_requests().empty());
   this->ClearResults();
 
   // Try to remove a request that is not in the queue.
-  store->RemoveRequests(request_ids,
-                        base::Bind(&RequestQueueStoreTestBase::RemoveDone,
-                                   base::Unretained(this)));
-  ASSERT_EQ(LastResult::kNone, this->last_result());
+  store->RemoveRequests(
+      request_ids, base::Bind(&RequestQueueStoreTestBase::UpdateRequestDone,
+                              base::Unretained(this)));
+  ASSERT_FALSE(this->last_update_result());
   this->PumpLoop();
-  ASSERT_EQ(2ul, this->last_remove_results().size());
+  ASSERT_TRUE(this->last_update_result());
   // When requests are missing, we expect the results to say so, but since they
   // are missing, no requests should have been returned.
-  ASSERT_EQ(RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST,
-            this->last_remove_results().at(0).second);
-  ASSERT_EQ(RequestQueue::UpdateRequestResult::REQUEST_DOES_NOT_EXIST,
-            this->last_remove_results().at(1).second);
-  ASSERT_EQ(0UL, this->last_requests().size());
+  EXPECT_EQ(2UL, this->last_update_result()->item_statuses.size());
+  EXPECT_EQ(kRequestId, this->last_update_result()->item_statuses[0].first);
+  EXPECT_EQ(ItemActionStatus::NOT_FOUND,
+            this->last_update_result()->item_statuses[0].second);
+  EXPECT_EQ(kRequestId2, this->last_update_result()->item_statuses[1].first);
+  EXPECT_EQ(ItemActionStatus::NOT_FOUND,
+            this->last_update_result()->item_statuses[1].second);
+  EXPECT_EQ(0UL, this->last_update_result()->updated_items.size());
 }
 
 TYPED_TEST(RequestQueueStoreTest, ResetStore) {
   std::unique_ptr<RequestQueueStore> store(this->BuildStore());
   base::Time creation_time = base::Time::Now();
   SavePageRequest original_request(
       kRequestId, kUrl, kClientId, creation_time, kUserRequested);
   store->AddRequest(original_request,
                     base::Bind(&RequestQueueStoreTestBase::AddRequestDone,
                                base::Unretained(this)));
@@ skipping 37 matching lines @@
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   ASSERT_EQ(1ul, this->last_requests().size());
   ASSERT_TRUE(original_request == *(this->last_requests().at(0).get()));
 }
 
 }  // offline_pages