drive_service_on_worker.cc revision 010d83a9304c5a91596085d917d248abff47903a 
1// Copyright 2014 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 "chrome/browser/sync_file_system/drive_backend/drive_service_on_worker.h"
6
7#include <string>
8
9#include "base/bind.h"
10#include "base/logging.h"
11#include "base/single_thread_task_runner.h"
12#include "chrome/browser/sync_file_system/drive_backend/callback_helper.h"
13#include "chrome/browser/sync_file_system/drive_backend/drive_service_wrapper.h"
14#include "google_apis/drive/drive_api_parser.h"
15#include "google_apis/drive/gdata_wapi_parser.h"
16
17namespace sync_file_system {
18namespace drive_backend {
19
20DriveServiceOnWorker::DriveServiceOnWorker(
21    const base::WeakPtr<DriveServiceWrapper>& wrapper,
22    base::SingleThreadTaskRunner* ui_task_runner,
23    base::SequencedTaskRunner* worker_task_runner)
24    : wrapper_(wrapper),
25      ui_task_runner_(ui_task_runner),
26      worker_task_runner_(worker_task_runner) {}
27
28DriveServiceOnWorker::~DriveServiceOnWorker() {}
29
30google_apis::CancelCallback DriveServiceOnWorker::AddNewDirectory(
31    const std::string& parent_resource_id,
32    const std::string& directory_title,
33    const AddNewDirectoryOptions& options,
34    const google_apis::GetResourceEntryCallback& callback) {
35  ui_task_runner_->PostTask(
36      FROM_HERE,
37      base::Bind(&DriveServiceWrapper::AddNewDirectory,
38                 wrapper_,
39                 parent_resource_id,
40                 directory_title,
41                 options,
42                 RelayCallbackToTaskRunner(
43                     worker_task_runner_,
44                     FROM_HERE,
45                     callback)));
46
47  return google_apis::CancelCallback();
48}
49
50google_apis::CancelCallback DriveServiceOnWorker::DeleteResource(
51    const std::string& resource_id,
52    const std::string& etag,
53    const google_apis::EntryActionCallback& callback) {
54  ui_task_runner_->PostTask(
55      FROM_HERE,
56      base::Bind(&DriveServiceWrapper::DeleteResource,
57                 wrapper_,
58                 resource_id,
59                 etag,
60                 RelayCallbackToTaskRunner(
61                     worker_task_runner_,
62                     FROM_HERE,
63                     callback)));
64
65  return google_apis::CancelCallback();
66}
67
68google_apis::CancelCallback DriveServiceOnWorker::DownloadFile(
69    const base::FilePath& local_cache_path,
70    const std::string& resource_id,
71    const google_apis::DownloadActionCallback& download_action_callback,
72    const google_apis::GetContentCallback& get_content_callback,
73    const google_apis::ProgressCallback& progress_callback) {
74  ui_task_runner_->PostTask(
75      FROM_HERE,
76      base::Bind(&DriveServiceWrapper::DownloadFile,
77                 wrapper_,
78                 local_cache_path,
79                 resource_id,
80                 RelayCallbackToTaskRunner(
81                     worker_task_runner_,
82                     FROM_HERE,
83                     download_action_callback),
84                 RelayCallbackToTaskRunner(
85                     worker_task_runner_,
86                     FROM_HERE,
87                     get_content_callback),
88                 RelayCallbackToTaskRunner(
89                     worker_task_runner_,
90                     FROM_HERE,
91                     progress_callback)));
92
93  return google_apis::CancelCallback();
94}
95
96
97google_apis::CancelCallback DriveServiceOnWorker::GetAboutResource(
98    const google_apis::AboutResourceCallback& callback) {
99  ui_task_runner_->PostTask(
100      FROM_HERE,
101      base::Bind(&DriveServiceWrapper::GetAboutResource,
102                 wrapper_,
103                 RelayCallbackToTaskRunner(
104                     worker_task_runner_,
105                     FROM_HERE,
106                     callback)));
107
108  return google_apis::CancelCallback();
109}
110
111
112google_apis::CancelCallback DriveServiceOnWorker::GetChangeList(
113    int64 start_changestamp,
114    const google_apis::GetResourceListCallback& callback) {
115  ui_task_runner_->PostTask(
116      FROM_HERE,
117      base::Bind(&DriveServiceWrapper::GetChangeList,
118                 wrapper_,
119                 start_changestamp,
120                 RelayCallbackToTaskRunner(
121                     worker_task_runner_,
122                     FROM_HERE,
123                     callback)));
124
125  return google_apis::CancelCallback();
126}
127
128google_apis::CancelCallback DriveServiceOnWorker::GetRemainingChangeList(
129    const GURL& next_link,
130    const google_apis::GetResourceListCallback& callback) {
131  ui_task_runner_->PostTask(
132      FROM_HERE,
133      base::Bind(&DriveServiceWrapper::GetRemainingChangeList,
134                 wrapper_,
135                 next_link,
136                 RelayCallbackToTaskRunner(
137                     worker_task_runner_,
138                     FROM_HERE,
139                     callback)));
140
141  return google_apis::CancelCallback();
142}
143
144std::string DriveServiceOnWorker::GetRootResourceId() const {
145  NOTREACHED();
146  // This method is expected to be called only on unit tests.
147  return "root";
148}
149
150google_apis::CancelCallback DriveServiceOnWorker::GetRemainingFileList(
151    const GURL& next_link,
152    const google_apis::GetResourceListCallback& callback) {
153  ui_task_runner_->PostTask(
154      FROM_HERE,
155      base::Bind(&DriveServiceWrapper::GetRemainingFileList,
156                 wrapper_,
157                 next_link,
158                 RelayCallbackToTaskRunner(
159                     worker_task_runner_,
160                     FROM_HERE,
161                     callback)));
162
163  return google_apis::CancelCallback();
164}
165
166
167google_apis::CancelCallback DriveServiceOnWorker::GetResourceEntry(
168    const std::string& resource_id,
169    const google_apis::GetResourceEntryCallback& callback) {
170  ui_task_runner_->PostTask(
171      FROM_HERE,
172      base::Bind(&DriveServiceWrapper::GetResourceEntry,
173                 wrapper_,
174                 resource_id,
175                 RelayCallbackToTaskRunner(
176                     worker_task_runner_,
177                     FROM_HERE,
178                     callback)));
179
180  return google_apis::CancelCallback();
181}
182
183google_apis::CancelCallback DriveServiceOnWorker::GetResourceListInDirectory(
184    const std::string& directory_resource_id,
185    const google_apis::GetResourceListCallback& callback) {
186  ui_task_runner_->PostTask(
187      FROM_HERE,
188      base::Bind(&DriveServiceWrapper::GetResourceListInDirectory,
189                 wrapper_,
190                 directory_resource_id,
191                 RelayCallbackToTaskRunner(
192                     worker_task_runner_,
193                     FROM_HERE,
194                     callback)));
195
196  return google_apis::CancelCallback();
197}
198
199google_apis::CancelCallback DriveServiceOnWorker::RemoveResourceFromDirectory(
200    const std::string& parent_resource_id,
201    const std::string& resource_id,
202    const google_apis::EntryActionCallback& callback) {
203  ui_task_runner_->PostTask(
204      FROM_HERE,
205      base::Bind(&DriveServiceWrapper::RemoveResourceFromDirectory,
206                 wrapper_,
207                 parent_resource_id,
208                 resource_id,
209                 RelayCallbackToTaskRunner(
210                     worker_task_runner_,
211                     FROM_HERE,
212                     callback)));
213
214  return google_apis::CancelCallback();
215}
216
217google_apis::CancelCallback DriveServiceOnWorker::SearchByTitle(
218    const std::string& title,
219    const std::string& directory_resource_id,
220    const google_apis::GetResourceListCallback& callback) {
221  ui_task_runner_->PostTask(
222      FROM_HERE,
223      base::Bind(&DriveServiceWrapper::SearchByTitle,
224                 wrapper_,
225                 title,
226                 directory_resource_id,
227                 RelayCallbackToTaskRunner(
228                     worker_task_runner_,
229                     FROM_HERE,
230                     callback)));
231
232  return google_apis::CancelCallback();
233}
234
235bool DriveServiceOnWorker::HasRefreshToken() const {
236  // TODO(peria): Cache the state and returns it directly, before migration of
237  //    SyncWorker to a worker thread.
238  DCHECK(wrapper_);
239  return wrapper_->HasRefreshToken();
240}
241
242void DriveServiceOnWorker::Initialize(const std::string& account_id) {
243  NOTREACHED();
244}
245
246void DriveServiceOnWorker::AddObserver(drive::DriveServiceObserver* observer) {
247  NOTREACHED();
248}
249
250void DriveServiceOnWorker::RemoveObserver(
251    drive::DriveServiceObserver* observer) {
252  NOTREACHED();
253}
254
255bool DriveServiceOnWorker::CanSendRequest() const {
256  NOTREACHED();
257  return false;
258}
259
260drive::ResourceIdCanonicalizer
261DriveServiceOnWorker::GetResourceIdCanonicalizer() const {
262  NOTREACHED();
263  return drive::ResourceIdCanonicalizer();
264}
265
266bool DriveServiceOnWorker::HasAccessToken() const {
267  NOTREACHED();
268  return false;
269}
270
271void DriveServiceOnWorker::RequestAccessToken(
272    const google_apis::AuthStatusCallback& callback) {
273  NOTREACHED();
274}
275
276void DriveServiceOnWorker::ClearAccessToken() {
277  NOTREACHED();
278}
279
280void DriveServiceOnWorker::ClearRefreshToken() {
281  NOTREACHED();
282}
283
284google_apis::CancelCallback DriveServiceOnWorker::GetAllResourceList(
285    const google_apis::GetResourceListCallback& callback) {
286  NOTREACHED();
287  return google_apis::CancelCallback();
288}
289
290google_apis::CancelCallback DriveServiceOnWorker::Search(
291    const std::string& search_query,
292    const google_apis::GetResourceListCallback& callback) {
293  NOTREACHED();
294  return google_apis::CancelCallback();
295}
296
297google_apis::CancelCallback DriveServiceOnWorker::GetShareUrl(
298    const std::string& resource_id,
299    const GURL& embed_origin,
300    const google_apis::GetShareUrlCallback& callback) {
301  NOTREACHED();
302  return google_apis::CancelCallback();
303}
304
305google_apis::CancelCallback DriveServiceOnWorker::GetAppList(
306    const google_apis::AppListCallback& callback) {
307  NOTREACHED();
308  return google_apis::CancelCallback();
309}
310
311google_apis::CancelCallback DriveServiceOnWorker::TrashResource(
312    const std::string& resource_id,
313    const google_apis::EntryActionCallback& callback) {
314  NOTREACHED();
315  return google_apis::CancelCallback();
316}
317
318google_apis::CancelCallback DriveServiceOnWorker::CopyResource(
319    const std::string& resource_id,
320    const std::string& parent_resource_id,
321    const std::string& new_title,
322    const base::Time& last_modified,
323    const google_apis::GetResourceEntryCallback& callback) {
324  NOTREACHED();
325  return google_apis::CancelCallback();
326}
327
328google_apis::CancelCallback DriveServiceOnWorker::UpdateResource(
329    const std::string& resource_id,
330    const std::string& parent_resource_id,
331    const std::string& new_title,
332    const base::Time& last_modified,
333    const base::Time& last_viewed_by_me,
334    const google_apis::GetResourceEntryCallback& callback) {
335  NOTREACHED();
336  return google_apis::CancelCallback();
337}
338
339google_apis::CancelCallback DriveServiceOnWorker::RenameResource(
340    const std::string& resource_id,
341    const std::string& new_title,
342    const google_apis::EntryActionCallback& callback) {
343  NOTREACHED();
344  return google_apis::CancelCallback();
345}
346
347google_apis::CancelCallback DriveServiceOnWorker::AddResourceToDirectory(
348    const std::string& parent_resource_id,
349    const std::string& resource_id,
350    const google_apis::EntryActionCallback& callback) {
351  NOTREACHED();
352  return google_apis::CancelCallback();
353}
354
355google_apis::CancelCallback DriveServiceOnWorker::InitiateUploadNewFile(
356    const std::string& content_type,
357    int64 content_length,
358    const std::string& parent_resource_id,
359    const std::string& title,
360    const InitiateUploadNewFileOptions& options,
361    const google_apis::InitiateUploadCallback& callback) {
362  NOTREACHED();
363  return google_apis::CancelCallback();
364}
365
366google_apis::CancelCallback DriveServiceOnWorker::InitiateUploadExistingFile(
367    const std::string& content_type,
368    int64 content_length,
369    const std::string& resource_id,
370    const InitiateUploadExistingFileOptions& options,
371    const google_apis::InitiateUploadCallback& callback) {
372  NOTREACHED();
373  return google_apis::CancelCallback();
374}
375
376google_apis::CancelCallback DriveServiceOnWorker::ResumeUpload(
377    const GURL& upload_url,
378    int64 start_position,
379    int64 end_position,
380    int64 content_length,
381    const std::string& content_type,
382    const base::FilePath& local_file_path,
383    const google_apis::UploadRangeCallback& callback,
384    const google_apis::ProgressCallback& progress_callback) {
385  NOTREACHED();
386  return google_apis::CancelCallback();
387}
388
389google_apis::CancelCallback DriveServiceOnWorker::GetUploadStatus(
390    const GURL& upload_url,
391    int64 content_length,
392    const google_apis::UploadRangeCallback& callback) {
393  NOTREACHED();
394  return google_apis::CancelCallback();
395}
396
397google_apis::CancelCallback DriveServiceOnWorker::AuthorizeApp(
398    const std::string& resource_id,
399    const std::string& app_id,
400    const google_apis::AuthorizeAppCallback& callback) {
401  NOTREACHED();
402  return google_apis::CancelCallback();
403}
404
405google_apis::CancelCallback DriveServiceOnWorker::UninstallApp(
406    const std::string& app_id,
407    const google_apis::EntryActionCallback& callback) {
408  NOTREACHED();
409  return google_apis::CancelCallback();
410}
411
412google_apis::CancelCallback DriveServiceOnWorker::AddPermission(
413    const std::string& resource_id,
414    const std::string& email,
415    google_apis::drive::PermissionRole role,
416    const google_apis::EntryActionCallback& callback) {
417  NOTREACHED();
418  return google_apis::CancelCallback();
419}
420
421}  // namespace drive_backend
422}  // namespace sync_file_system
423