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.h" | |
6 | |
7 #include <utility> | |
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/add_request_task.h" | |
13 #include "components/offline_pages/background/change_requests_state_task.h" | |
14 #include "components/offline_pages/background/get_requests_task.h" | |
15 #include "components/offline_pages/background/initialize_store_task.h" | |
16 #include "components/offline_pages/background/mark_attempt_aborted_task.h" | |
17 #include "components/offline_pages/background/mark_attempt_completed_task.h" | |
18 #include "components/offline_pages/background/mark_attempt_started_task.h" | |
19 #include "components/offline_pages/background/pick_request_task.h" | |
20 #include "components/offline_pages/background/remove_requests_task.h" | |
21 #include "components/offline_pages/background/request_queue_store.h" | |
22 #include "components/offline_pages/background/save_page_request.h" | |
23 | |
24 namespace offline_pages { | |
25 | |
26 namespace { | |
27 // Completes the get requests call. | |
28 void GetRequestsDone(const RequestQueue::GetRequestsCallback& callback, | |
29 bool success, | |
30 std::vector<std::unique_ptr<SavePageRequest>> requests) { | |
31 GetRequestsResult result = | |
32 success ? GetRequestsResult::SUCCESS : GetRequestsResult::STORE_FAILURE; | |
33 // TODO(fgorski): Filter out expired requests based on policy. | |
34 // This may trigger the purging if necessary. | |
35 // Also this may be turned into a method on the request queue or add a policy | |
36 // parameter in the process. | |
37 callback.Run(result, std::move(requests)); | |
38 } | |
39 | |
40 // Completes the add request call. | |
41 void AddRequestDone(const RequestQueue::AddRequestCallback& callback, | |
42 const SavePageRequest& request, | |
43 ItemActionStatus status) { | |
44 AddRequestResult result; | |
45 switch (status) { | |
46 case ItemActionStatus::SUCCESS: | |
47 result = AddRequestResult::SUCCESS; | |
48 break; | |
49 case ItemActionStatus::ALREADY_EXISTS: | |
50 result = AddRequestResult::ALREADY_EXISTS; | |
51 break; | |
52 case ItemActionStatus::STORE_ERROR: | |
53 result = AddRequestResult::STORE_FAILURE; | |
54 break; | |
55 case ItemActionStatus::NOT_FOUND: | |
56 default: | |
57 NOTREACHED(); | |
58 return; | |
59 } | |
60 callback.Run(result, request); | |
61 } | |
62 | |
63 } // namespace | |
64 | |
65 RequestQueue::RequestQueue(std::unique_ptr<RequestQueueStore> store) | |
66 : store_(std::move(store)), weak_ptr_factory_(this) { | |
67 Initialize(); | |
68 } | |
69 | |
70 RequestQueue::~RequestQueue() {} | |
71 | |
72 void RequestQueue::GetRequests(const GetRequestsCallback& callback) { | |
73 std::unique_ptr<Task> task(new GetRequestsTask( | |
74 store_.get(), base::Bind(&GetRequestsDone, callback))); | |
75 task_queue_.AddTask(std::move(task)); | |
76 } | |
77 | |
78 void RequestQueue::AddRequest(const SavePageRequest& request, | |
79 const AddRequestCallback& callback) { | |
80 // TODO(fgorski): check that request makes sense. | |
81 // TODO(fgorski): check that request does not violate policy. | |
82 std::unique_ptr<AddRequestTask> task(new AddRequestTask( | |
83 store_.get(), request, base::Bind(&AddRequestDone, callback, request))); | |
84 task_queue_.AddTask(std::move(task)); | |
85 } | |
86 | |
87 void RequestQueue::RemoveRequests(const std::vector<int64_t>& request_ids, | |
88 const UpdateCallback& callback) { | |
89 std::unique_ptr<Task> task( | |
90 new RemoveRequestsTask(store_.get(), request_ids, callback)); | |
91 task_queue_.AddTask(std::move(task)); | |
92 } | |
93 | |
94 void RequestQueue::ChangeRequestsState( | |
95 const std::vector<int64_t>& request_ids, | |
96 const SavePageRequest::RequestState new_state, | |
97 const RequestQueue::UpdateCallback& callback) { | |
98 std::unique_ptr<Task> task(new ChangeRequestsStateTask( | |
99 store_.get(), request_ids, new_state, callback)); | |
100 task_queue_.AddTask(std::move(task)); | |
101 } | |
102 | |
103 void RequestQueue::MarkAttemptStarted(int64_t request_id, | |
104 const UpdateCallback& callback) { | |
105 std::unique_ptr<Task> task( | |
106 new MarkAttemptStartedTask(store_.get(), request_id, callback)); | |
107 task_queue_.AddTask(std::move(task)); | |
108 } | |
109 | |
110 void RequestQueue::MarkAttemptAborted(int64_t request_id, | |
111 const UpdateCallback& callback) { | |
112 std::unique_ptr<Task> task( | |
113 new MarkAttemptAbortedTask(store_.get(), request_id, callback)); | |
114 task_queue_.AddTask(std::move(task)); | |
115 } | |
116 | |
117 void RequestQueue::MarkAttemptCompleted(int64_t request_id, | |
118 const UpdateCallback& callback) { | |
119 std::unique_ptr<Task> task( | |
120 new MarkAttemptCompletedTask(store_.get(), request_id, callback)); | |
121 task_queue_.AddTask(std::move(task)); | |
122 } | |
123 | |
124 void RequestQueue::PickNextRequest( | |
125 OfflinerPolicy* policy, | |
126 PickRequestTask::RequestPickedCallback picked_callback, | |
127 PickRequestTask::RequestNotPickedCallback not_picked_callback, | |
128 PickRequestTask::RequestCountCallback request_count_callback, | |
129 DeviceConditions& conditions, | |
130 std::set<int64_t>& disabled_requests) { | |
131 // Using the PickerContext, create a picker task. | |
132 std::unique_ptr<Task> task(new PickRequestTask( | |
133 store_.get(), policy, picked_callback, not_picked_callback, | |
134 request_count_callback, conditions, disabled_requests)); | |
135 | |
136 // Queue up the picking task, it will call one of the callbacks when it | |
137 // completes. | |
138 task_queue_.AddTask(std::move(task)); | |
139 } | |
140 | |
141 void RequestQueue::CleanupRequestQueue() { | |
142 // Create a cleanup task. | |
143 std::unique_ptr<Task> task(cleanup_factory_->CreateCleanupTask(store_.get())); | |
144 | |
145 // Queue up the cleanup task. | |
146 task_queue_.AddTask(std::move(task)); | |
147 } | |
148 | |
149 void RequestQueue::Initialize() { | |
150 std::unique_ptr<Task> task(new InitializeStoreTask( | |
151 store_.get(), base::Bind(&RequestQueue::InitializeStoreDone, | |
152 weak_ptr_factory_.GetWeakPtr()))); | |
153 task_queue_.AddTask(std::move(task)); | |
154 } | |
155 | |
156 void RequestQueue::InitializeStoreDone(bool success) { | |
157 // TODO(fgorski): Result can be ignored for now. Report UMA in future. | |
158 // No need to pass the result up to RequestCoordinator. | |
159 } | |
160 | |
161 } // namespace offline_pages | |
OLD | NEW |