Adds an observer for the request coordinator.

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 49 matching lines @@
   void TearDown() override;
 
   void PumpLoop();
   void ClearResults();
 
   // Callback used for get requests.
   void GetRequestsDone(bool result,
                        const std::vector<SavePageRequest>& requests);
   // Callback used for add/update request.
   void AddOrUpdateDone(UpdateStatus result);
+  void UpdateMultipleRequestsDone(
+      const RequestQueue::UpdateMultipleRequestResults& results,
+      const std::vector<SavePageRequest>& requests);
   // Callback used for remove requests.
-  void RemoveDone(const RequestQueue::UpdateMultipleRequestResults& results);
+  void RemoveDone(const RequestQueue::UpdateMultipleRequestResults& results,
+                  const std::vector<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<SavePageRequest>& last_requests() const {
     return last_requests_;
   }
 
  protected:
   base::ScopedTempDir temp_directory_;
 
  private:
   LastResult last_result_;
   UpdateStatus last_update_status_;
+  RequestQueue::UpdateMultipleRequestResults last_multiple_update_results_;
   RequestQueue::UpdateMultipleRequestResults last_remove_results_;
   std::vector<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),
@@ skipping 22 matching lines @@
     bool result,
     const std::vector<SavePageRequest>& requests) {
   last_result_ = result ? LastResult::kTrue : LastResult::kFalse;
   last_requests_ = requests;
 }
 
 void RequestQueueStoreTestBase::AddOrUpdateDone(UpdateStatus status) {
   last_update_status_ = status;
 }
 
+void RequestQueueStoreTestBase::UpdateMultipleRequestsDone(
+    const RequestQueue::UpdateMultipleRequestResults& results,
+    const std::vector<SavePageRequest>& requests) {
+  last_multiple_update_results_ = results;
+  last_requests_ = requests;
+}
+
 void RequestQueueStoreTestBase::RemoveDone(
-    const RequestQueue::UpdateMultipleRequestResults& results) {
+    const RequestQueue::UpdateMultipleRequestResults& results,
+    const std::vector<SavePageRequest>& requests) {
   last_remove_results_ = results;
+  last_requests_ = 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 134 matching lines @@
   store->RemoveRequests(request_ids,
                         base::Bind(&RequestQueueStoreTestBase::RemoveDone,
                                    base::Unretained(this)));
   ASSERT_EQ(0ul, this->last_remove_results().size());
   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(kRequestId, this->last_requests().at(0).request_id());
   this->ClearResults();
 
   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.
@@ skipping 22 matching lines @@
   store->AddOrUpdateRequest(
       request1, base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
                            base::Unretained(this)));
   this->PumpLoop();
   this->ClearResults();
 
   // Pause a request.
   std::vector<int64_t> request_ids{kRequestId};
   store->ChangeRequestsState(
       request_ids, SavePageRequest::RequestState::PAUSED,
-      base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
+      base::Bind(&RequestQueueStoreTestBase::UpdateMultipleRequestsDone,
                  base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
 
   // Verify pause succeeded
-  ASSERT_EQ(UpdateStatus::UPDATED, this->last_update_status());
+  ASSERT_EQ(1ul, this->last_multiple_update_results().size());
+  ASSERT_EQ(RequestQueue::UpdateRequestResult::SUCCESS,
+            this->last_multiple_update_results().at(0).second);
+  ASSERT_EQ(kRequestId, this->last_requests().at(0).request_id());
   this->ClearResults();
 
   // Get the request from the queue to check it out
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   // The request should still be in the queue.
   ASSERT_EQ(1UL, this->last_requests().size());
   // Request 1 should be paused.
   ASSERT_EQ(SavePageRequest::RequestState::PAUSED,
             this->last_requests().at(0).request_state());
   this->ClearResults();
 
   // Now resume the same request we paused.
   store->ChangeRequestsState(
       request_ids, SavePageRequest::RequestState::AVAILABLE,
-      base::Bind(&RequestQueueStoreTestBase::AddOrUpdateDone,
+      base::Bind(&RequestQueueStoreTestBase::UpdateMultipleRequestsDone,
                  base::Unretained(this)));
   ASSERT_EQ(LastResult::kNone, this->last_result());
   this->PumpLoop();
 
   // Verify resume succeeded.
-  ASSERT_EQ(UpdateStatus::UPDATED, this->last_update_status());
+  ASSERT_EQ(1ul, this->last_multiple_update_results().size());
+  ASSERT_EQ(RequestQueue::UpdateRequestResult::SUCCESS,
+            this->last_multiple_update_results().at(0).second);
+  ASSERT_EQ(kRequestId, this->last_requests().at(0).request_id());
   this->ClearResults();
 
   // Get the request from the queue to check it out
   store->GetRequests(base::Bind(&RequestQueueStoreTestBase::GetRequestsDone,
                                 base::Unretained(this)));
   this->PumpLoop();
   ASSERT_EQ(LastResult::kTrue, this->last_result());
   // The request should still be in the queue.
   ASSERT_EQ(1UL, this->last_requests().size());
   // Request 1 should be paused.
@@ skipping 50 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()[0]);
 }
 
 }  // offline_pages