OLD | NEW |
| (Empty) |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "components/offline_pages/background/request_queue_in_memory_store.h" | |
6 | |
7 #include <unordered_set> | |
8 | |
9 #include "base/bind.h" | |
10 #include "base/location.h" | |
11 #include "base/threading/thread_task_runner_handle.h" | |
12 #include "components/offline_pages/background/save_page_request.h" | |
13 | |
14 namespace offline_pages { | |
15 | |
16 RequestQueueInMemoryStore::RequestQueueInMemoryStore() | |
17 : state_(StoreState::NOT_LOADED), scenario_(TestScenario::SUCCESSFUL) {} | |
18 | |
19 RequestQueueInMemoryStore::RequestQueueInMemoryStore(TestScenario scenario) | |
20 : state_(StoreState::NOT_LOADED), scenario_(scenario) {} | |
21 | |
22 RequestQueueInMemoryStore::~RequestQueueInMemoryStore() {} | |
23 | |
24 void RequestQueueInMemoryStore::Initialize(const InitializeCallback& callback) { | |
25 if (scenario_ == TestScenario::SUCCESSFUL) | |
26 state_ = StoreState::LOADED; | |
27 else | |
28 state_ = StoreState::FAILED_LOADING; | |
29 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
30 FROM_HERE, base::Bind(callback, state_ == StoreState::LOADED)); | |
31 } | |
32 | |
33 void RequestQueueInMemoryStore::GetRequests( | |
34 const GetRequestsCallback& callback) { | |
35 DCHECK_NE(state_, StoreState::NOT_LOADED); | |
36 std::vector<std::unique_ptr<SavePageRequest>> result_requests; | |
37 for (const auto& id_request_pair : requests_) { | |
38 std::unique_ptr<SavePageRequest> request( | |
39 new SavePageRequest(id_request_pair.second)); | |
40 result_requests.push_back(std::move(request)); | |
41 } | |
42 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
43 FROM_HERE, | |
44 base::Bind(callback, true, base::Passed(std::move(result_requests)))); | |
45 } | |
46 | |
47 void RequestQueueInMemoryStore::GetRequestsByIds( | |
48 const std::vector<int64_t>& request_ids, | |
49 const UpdateCallback& callback) { | |
50 DCHECK_NE(state_, StoreState::NOT_LOADED); | |
51 std::unique_ptr<UpdateRequestsResult> result( | |
52 new UpdateRequestsResult(state())); | |
53 | |
54 ItemActionStatus status; | |
55 // Make sure not to include the same request multiple times, while preserving | |
56 // the order of non-duplicated IDs in the result. | |
57 std::unordered_set<int64_t> processed_ids; | |
58 for (const auto& request_id : request_ids) { | |
59 if (!processed_ids.insert(request_id).second) | |
60 continue; | |
61 RequestsMap::iterator iter = requests_.find(request_id); | |
62 if (iter != requests_.end()) { | |
63 status = ItemActionStatus::SUCCESS; | |
64 result->updated_items.push_back(iter->second); | |
65 } else { | |
66 status = ItemActionStatus::NOT_FOUND; | |
67 } | |
68 result->item_statuses.push_back(std::make_pair(request_id, status)); | |
69 } | |
70 | |
71 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
72 FROM_HERE, base::Bind(callback, base::Passed(&result))); | |
73 } | |
74 | |
75 void RequestQueueInMemoryStore::AddRequest(const SavePageRequest& request, | |
76 const AddCallback& callback) { | |
77 DCHECK_NE(state_, StoreState::NOT_LOADED); | |
78 RequestsMap::iterator iter = requests_.find(request.request_id()); | |
79 ItemActionStatus status; | |
80 if (iter == requests_.end()) { | |
81 requests_.insert(iter, std::make_pair(request.request_id(), request)); | |
82 status = ItemActionStatus::SUCCESS; | |
83 } else { | |
84 status = ItemActionStatus::ALREADY_EXISTS; | |
85 } | |
86 | |
87 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, | |
88 base::Bind(callback, status)); | |
89 } | |
90 | |
91 void RequestQueueInMemoryStore::UpdateRequests( | |
92 const std::vector<SavePageRequest>& requests, | |
93 const RequestQueue::UpdateCallback& callback) { | |
94 DCHECK_NE(state_, StoreState::NOT_LOADED); | |
95 std::unique_ptr<UpdateRequestsResult> result( | |
96 new UpdateRequestsResult(state())); | |
97 | |
98 ItemActionStatus status; | |
99 for (const auto& request : requests) { | |
100 RequestsMap::iterator iter = requests_.find(request.request_id()); | |
101 if (iter != requests_.end()) { | |
102 status = ItemActionStatus::SUCCESS; | |
103 iter->second = request; | |
104 result->updated_items.push_back(request); | |
105 } else { | |
106 status = ItemActionStatus::NOT_FOUND; | |
107 } | |
108 result->item_statuses.push_back( | |
109 std::make_pair(request.request_id(), status)); | |
110 } | |
111 | |
112 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
113 FROM_HERE, base::Bind(callback, base::Passed(&result))); | |
114 } | |
115 | |
116 void RequestQueueInMemoryStore::RemoveRequests( | |
117 const std::vector<int64_t>& request_ids, | |
118 const UpdateCallback& callback) { | |
119 DCHECK_NE(state_, StoreState::NOT_LOADED); | |
120 std::unique_ptr<UpdateRequestsResult> result( | |
121 new UpdateRequestsResult(StoreState::LOADED)); | |
122 | |
123 ItemActionStatus status; | |
124 // If we find a request, mark it as succeeded, and put it in the request list. | |
125 // Otherwise mark it as failed. | |
126 for (auto request_id : request_ids) { | |
127 RequestsMap::iterator iter = requests_.find(request_id); | |
128 if (iter != requests_.end()) { | |
129 status = ItemActionStatus::SUCCESS; | |
130 result->updated_items.push_back(iter->second); | |
131 requests_.erase(iter); | |
132 } else { | |
133 status = ItemActionStatus::NOT_FOUND; | |
134 } | |
135 result->item_statuses.push_back(std::make_pair(request_id, status)); | |
136 } | |
137 | |
138 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
139 FROM_HERE, base::Bind(callback, base::Passed(&result))); | |
140 } | |
141 | |
142 void RequestQueueInMemoryStore::Reset(const ResetCallback& callback) { | |
143 if (scenario_ != TestScenario::LOAD_FAILED_RESET_FAILED) { | |
144 requests_.clear(); | |
145 state_ = StoreState::NOT_LOADED; | |
146 scenario_ = TestScenario::SUCCESSFUL; | |
147 } else { | |
148 state_ = StoreState::FAILED_RESET; | |
149 } | |
150 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
151 FROM_HERE, base::Bind(callback, state_ == StoreState::NOT_LOADED)); | |
152 } | |
153 | |
154 StoreState RequestQueueInMemoryStore::state() const { | |
155 return state_; | |
156 } | |
157 | |
158 } // namespace offline_pages | |
OLD | NEW |