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