chrome/browser/drive/drive_api_service.cc

   1 // Copyright (c) 2012 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/drive/drive_api_service.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "chrome/browser/drive/drive_api_util.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "google_apis/drive/auth_service.h"
  15 #include "google_apis/drive/drive_api_parser.h"
  16 #include "google_apis/drive/drive_api_requests.h"
  17 #include "google_apis/drive/gdata_errorcode.h"
  18 #include "google_apis/drive/gdata_wapi_parser.h"
  19 #include "google_apis/drive/gdata_wapi_requests.h"
  20 #include "google_apis/drive/request_sender.h"
  21 #include "google_apis/google_api_keys.h"
  22 #include "net/url_request/url_request_context_getter.h"
  23
  24 using content::BrowserThread;
  25 using google_apis::AboutResourceCallback;
  26 using google_apis::AppList;
  27 using google_apis::AppListCallback;
  28 using google_apis::AuthStatusCallback;
  29 using google_apis::AuthorizeAppCallback;
  30 using google_apis::CancelCallback;
  31 using google_apis::ChangeList;
  32 using google_apis::ChangeListCallback;
  33 using google_apis::DownloadActionCallback;
  34 using google_apis::EntryActionCallback;
  35 using google_apis::FileList;
  36 using google_apis::FileListCallback;
  37 using google_apis::FileResource;
  38 using google_apis::FileResourceCallback;
  39 using google_apis::GDATA_OTHER_ERROR;
  40 using google_apis::GDATA_PARSE_ERROR;
  41 using google_apis::GDataErrorCode;
  42 using google_apis::GetContentCallback;
  43 using google_apis::GetResourceEntryRequest;
  44 using google_apis::GetShareUrlCallback;
  45 using google_apis::HTTP_NOT_IMPLEMENTED;
  46 using google_apis::HTTP_SUCCESS;
  47 using google_apis::InitiateUploadCallback;
  48 using google_apis::Link;
  49 using google_apis::ProgressCallback;
  50 using google_apis::RequestSender;
  51 using google_apis::UploadRangeResponse;
  52 using google_apis::drive::AboutGetRequest;
  53 using google_apis::drive::AppsListRequest;
  54 using google_apis::drive::ChangesListRequest;
  55 using google_apis::drive::ChangesListNextPageRequest;
  56 using google_apis::drive::ChildrenDeleteRequest;
  57 using google_apis::drive::ChildrenInsertRequest;
  58 using google_apis::drive::DownloadFileRequest;
  59 using google_apis::drive::FilesCopyRequest;
  60 using google_apis::drive::FilesGetRequest;
  61 using google_apis::drive::FilesInsertRequest;
  62 using google_apis::drive::FilesPatchRequest;
  63 using google_apis::drive::FilesListRequest;
  64 using google_apis::drive::FilesListNextPageRequest;
  65 using google_apis::drive::FilesDeleteRequest;
  66 using google_apis::drive::FilesTrashRequest;
  67 using google_apis::drive::GetUploadStatusRequest;
  68 using google_apis::drive::InitiateUploadExistingFileRequest;
  69 using google_apis::drive::InitiateUploadNewFileRequest;
  70 using google_apis::drive::ResumeUploadRequest;
  71 using google_apis::drive::UploadRangeCallback;
  72
  73 namespace drive {
  74
  75 namespace {
  76
  77 // OAuth2 scopes for Drive API.
  78 const char kDriveScope[] = "https://www.googleapis.com/auth/drive";
  79 const char kDriveAppsReadonlyScope[] =
  80     "https://www.googleapis.com/auth/drive.apps.readonly";
  81 const char kDriveAppsScope[] = "https://www.googleapis.com/auth/drive.apps";
  82 const char kDocsListScope[] = "https://docs.google.com/feeds/";
  83
  84 // Mime type to create a directory.
  85 const char kFolderMimeType[] = "application/vnd.google-apps.folder";
  86
  87 // Max number of file entries to be fetched in a single http request.
  88 //
  89 // The larger the number is,
  90 // - The total running time to fetch the whole file list will become shorter.
  91 // - The running time for a single request tends to become longer.
  92 // Since the file list fetching is a completely background task, for our side,
  93 // only the total time matters. However, the server seems to have a time limit
  94 // per single request, which disables us to set the largest value (1000).
  95 // TODO(kinaba): make it larger when the server gets faster.
  96 const int kMaxNumFilesResourcePerRequest = 300;
  97 const int kMaxNumFilesResourcePerRequestForSearch = 100;
  98
  99 // For performance, we declare all fields we use.
 100 const char kAboutResourceFields[] =
 101     "kind,quotaBytesTotal,quotaBytesUsed,largestChangeId,rootFolderId";
 102 const char kFileResourceFields[] =
 103     "kind,id,title,createdDate,sharedWithMeDate,mimeType,"
 104     "md5Checksum,fileSize,labels/trashed,imageMediaMetadata/width,"
 105     "imageMediaMetadata/height,imageMediaMetadata/rotation,etag,"
 106     "parents(id,parentLink),alternateLink,"
 107     "modifiedDate,lastViewedByMeDate,shared";
 108 const char kFileResourceOpenWithLinksFields[] =
 109     "kind,id,openWithLinks/*";
 110 const char kFileListFields[] =
 111     "kind,items(kind,id,title,createdDate,sharedWithMeDate,"
 112     "mimeType,md5Checksum,fileSize,labels/trashed,imageMediaMetadata/width,"
 113     "imageMediaMetadata/height,imageMediaMetadata/rotation,etag,"
 114     "parents(id,parentLink),alternateLink,"
 115     "modifiedDate,lastViewedByMeDate,shared),nextLink";
 116 const char kChangeListFields[] =
 117     "kind,items(file(kind,id,title,createdDate,sharedWithMeDate,"
 118     "mimeType,md5Checksum,fileSize,labels/trashed,imageMediaMetadata/width,"
 119     "imageMediaMetadata/height,imageMediaMetadata/rotation,etag,"
 120     "parents(id,parentLink),alternateLink,modifiedDate,"
 121     "lastViewedByMeDate,shared),deleted,id,fileId,modificationDate),nextLink,"
 122     "largestChangeId";
 123
 124 void ExtractOpenUrlAndRun(const std::string& app_id,
 125                           const AuthorizeAppCallback& callback,
 126                           GDataErrorCode error,
 127                           scoped_ptr<FileResource> value) {
 128   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 129   DCHECK(!callback.is_null());
 130
 131   if (!value) {
 132     callback.Run(error, GURL());
 133     return;
 134   }
 135
 136   const std::vector<FileResource::OpenWithLink>& open_with_links =
 137       value->open_with_links();
 138   for (size_t i = 0; i < open_with_links.size(); ++i) {
 139     if (open_with_links[i].app_id == app_id) {
 140       callback.Run(HTTP_SUCCESS, open_with_links[i].open_url);
 141       return;
 142     }
 143   }
 144
 145   // Not found.
 146   callback.Run(GDATA_OTHER_ERROR, GURL());
 147 }
 148
 149 void ExtractShareUrlAndRun(const google_apis::GetShareUrlCallback& callback,
 150                            google_apis::GDataErrorCode error,
 151                            scoped_ptr<google_apis::ResourceEntry> entry) {
 152   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 153
 154   const google_apis::Link* share_link =
 155       entry ? entry->GetLinkByType(google_apis::Link::LINK_SHARE) : NULL;
 156   callback.Run(error, share_link ? share_link->href() : GURL());
 157 }
 158
 159 // Ignores the |entry|, and runs the |callback|.
 160 void EntryActionCallbackAdapter(
 161     const EntryActionCallback& callback,
 162     GDataErrorCode error, scoped_ptr<FileResource> entry) {
 163   callback.Run(error);
 164 }
 165
 166 // The resource ID for the root directory for Drive API is defined in the spec:
 167 // https://developers.google.com/drive/folder
 168 const char kDriveApiRootDirectoryResourceId[] = "root";
 169
 170 }  // namespace
 171
 172 DriveAPIService::DriveAPIService(
 173     OAuth2TokenService* oauth2_token_service,
 174     net::URLRequestContextGetter* url_request_context_getter,
 175     base::SequencedTaskRunner* blocking_task_runner,
 176     const GURL& base_url,
 177     const GURL& base_download_url,
 178     const GURL& wapi_base_url,
 179     const std::string& custom_user_agent)
 180     : oauth2_token_service_(oauth2_token_service),
 181       url_request_context_getter_(url_request_context_getter),
 182       blocking_task_runner_(blocking_task_runner),
 183       url_generator_(base_url, base_download_url),
 184       wapi_url_generator_(wapi_base_url),
 185       custom_user_agent_(custom_user_agent) {
 186   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 187 }
 188
 189 DriveAPIService::~DriveAPIService() {
 190   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 191   if (sender_.get())
 192     sender_->auth_service()->RemoveObserver(this);
 193 }
 194
 195 void DriveAPIService::Initialize(const std::string& account_id) {
 196   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 197
 198   std::vector<std::string> scopes;
 199   scopes.push_back(kDriveScope);
 200   scopes.push_back(kDriveAppsReadonlyScope);
 201   scopes.push_back(kDriveAppsScope);
 202
 203   // Note: The following scope is used to support GetShareUrl on Drive API v2.
 204   // Unfortunately, there is no support on Drive API v2, so we need to fall back
 205   // to GData WAPI for the GetShareUrl.
 206   scopes.push_back(kDocsListScope);
 207
 208   sender_.reset(new RequestSender(
 209       new google_apis::AuthService(oauth2_token_service_,
 210                                    account_id,
 211                                    url_request_context_getter_.get(),
 212                                    scopes),
 213       url_request_context_getter_.get(),
 214       blocking_task_runner_.get(),
 215       custom_user_agent_));
 216   sender_->auth_service()->AddObserver(this);
 217 }
 218
 219 void DriveAPIService::AddObserver(DriveServiceObserver* observer) {
 220   observers_.AddObserver(observer);
 221 }
 222
 223 void DriveAPIService::RemoveObserver(DriveServiceObserver* observer) {
 224   observers_.RemoveObserver(observer);
 225 }
 226
 227 bool DriveAPIService::CanSendRequest() const {
 228   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 229
 230   return HasRefreshToken();
 231 }
 232
 233 std::string DriveAPIService::GetRootResourceId() const {
 234   return kDriveApiRootDirectoryResourceId;
 235 }
 236
 237 CancelCallback DriveAPIService::GetAllFileList(
 238     const FileListCallback& callback) {
 239   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 240   DCHECK(!callback.is_null());
 241
 242   FilesListRequest* request = new FilesListRequest(
 243       sender_.get(), url_generator_, callback);
 244   request->set_max_results(kMaxNumFilesResourcePerRequest);
 245   request->set_q("trashed = false");  // Exclude trashed files.
 246   request->set_fields(kFileListFields);
 247   return sender_->StartRequestWithRetry(request);
 248 }
 249
 250 CancelCallback DriveAPIService::GetFileListInDirectory(
 251     const std::string& directory_resource_id,
 252     const FileListCallback& callback) {
 253   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 254   DCHECK(!directory_resource_id.empty());
 255   DCHECK(!callback.is_null());
 256
 257   // Because children.list method on Drive API v2 returns only the list of
 258   // children's references, but we need all file resource list.
 259   // So, here we use files.list method instead, with setting parents query.
 260   // After the migration from GData WAPI to Drive API v2, we should clean the
 261   // code up by moving the responsibility to include "parents" in the query
 262   // to client side.
 263   // We aren't interested in files in trash in this context, neither.
 264   FilesListRequest* request = new FilesListRequest(
 265       sender_.get(), url_generator_, callback);
 266   request->set_max_results(kMaxNumFilesResourcePerRequest);
 267   request->set_q(base::StringPrintf(
 268       "'%s' in parents and trashed = false",
 269       util::EscapeQueryStringValue(directory_resource_id).c_str()));
 270   request->set_fields(kFileListFields);
 271   return sender_->StartRequestWithRetry(request);
 272 }
 273
 274 CancelCallback DriveAPIService::Search(
 275     const std::string& search_query,
 276     const FileListCallback& callback) {
 277   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 278   DCHECK(!search_query.empty());
 279   DCHECK(!callback.is_null());
 280
 281   FilesListRequest* request = new FilesListRequest(
 282       sender_.get(), url_generator_, callback);
 283   request->set_max_results(kMaxNumFilesResourcePerRequestForSearch);
 284   request->set_q(util::TranslateQuery(search_query));
 285   request->set_fields(kFileListFields);
 286   return sender_->StartRequestWithRetry(request);
 287 }
 288
 289 CancelCallback DriveAPIService::SearchByTitle(
 290     const std::string& title,
 291     const std::string& directory_resource_id,
 292     const FileListCallback& callback) {
 293   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 294   DCHECK(!title.empty());
 295   DCHECK(!callback.is_null());
 296
 297   std::string query;
 298   base::StringAppendF(&query, "title = '%s'",
 299                       util::EscapeQueryStringValue(title).c_str());
 300   if (!directory_resource_id.empty()) {
 301     base::StringAppendF(
 302         &query, " and '%s' in parents",
 303         util::EscapeQueryStringValue(directory_resource_id).c_str());
 304   }
 305   query += " and trashed = false";
 306
 307   FilesListRequest* request = new FilesListRequest(
 308       sender_.get(), url_generator_, callback);
 309   request->set_max_results(kMaxNumFilesResourcePerRequest);
 310   request->set_q(query);
 311   request->set_fields(kFileListFields);
 312   return sender_->StartRequestWithRetry(request);
 313 }
 314
 315 CancelCallback DriveAPIService::GetChangeList(
 316     int64 start_changestamp,
 317     const ChangeListCallback& callback) {
 318   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 319   DCHECK(!callback.is_null());
 320
 321   ChangesListRequest* request = new ChangesListRequest(
 322       sender_.get(), url_generator_, callback);
 323   request->set_max_results(kMaxNumFilesResourcePerRequest);
 324   request->set_start_change_id(start_changestamp);
 325   request->set_fields(kChangeListFields);
 326   return sender_->StartRequestWithRetry(request);
 327 }
 328
 329 CancelCallback DriveAPIService::GetRemainingChangeList(
 330     const GURL& next_link,
 331     const ChangeListCallback& callback) {
 332   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 333   DCHECK(!next_link.is_empty());
 334   DCHECK(!callback.is_null());
 335
 336   ChangesListNextPageRequest* request = new ChangesListNextPageRequest(
 337       sender_.get(), callback);
 338   request->set_next_link(next_link);
 339   request->set_fields(kChangeListFields);
 340   return sender_->StartRequestWithRetry(request);
 341 }
 342
 343 CancelCallback DriveAPIService::GetRemainingFileList(
 344     const GURL& next_link,
 345     const FileListCallback& callback) {
 346   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 347   DCHECK(!next_link.is_empty());
 348   DCHECK(!callback.is_null());
 349
 350   FilesListNextPageRequest* request = new FilesListNextPageRequest(
 351       sender_.get(), callback);
 352   request->set_next_link(next_link);
 353   request->set_fields(kFileListFields);
 354   return sender_->StartRequestWithRetry(request);
 355 }
 356
 357 CancelCallback DriveAPIService::GetFileResource(
 358     const std::string& resource_id,
 359     const FileResourceCallback& callback) {
 360   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 361   DCHECK(!callback.is_null());
 362
 363   FilesGetRequest* request = new FilesGetRequest(
 364       sender_.get(), url_generator_, callback);
 365   request->set_file_id(resource_id);
 366   request->set_fields(kFileResourceFields);
 367   return sender_->StartRequestWithRetry(request);
 368 }
 369
 370 CancelCallback DriveAPIService::GetShareUrl(
 371     const std::string& resource_id,
 372     const GURL& embed_origin,
 373     const GetShareUrlCallback& callback) {
 374   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 375   DCHECK(!callback.is_null());
 376
 377   // Unfortunately "share url" is not yet supported on Drive API v2.
 378   // So, as a fallback, we use GData WAPI protocol for this method.
 379   // TODO(hidehiko): Get rid of this implementation when share url is
 380   // supported on Drive API v2.
 381   return sender_->StartRequestWithRetry(
 382       new GetResourceEntryRequest(sender_.get(),
 383                                   wapi_url_generator_,
 384                                   resource_id,
 385                                   embed_origin,
 386                                   base::Bind(&ExtractShareUrlAndRun,
 387                                              callback)));
 388 }
 389
 390 CancelCallback DriveAPIService::GetAboutResource(
 391     const AboutResourceCallback& callback) {
 392   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 393   DCHECK(!callback.is_null());
 394
 395   AboutGetRequest* request =
 396       new AboutGetRequest(sender_.get(), url_generator_, callback);
 397   request->set_fields(kAboutResourceFields);
 398   return sender_->StartRequestWithRetry(request);
 399 }
 400
 401 CancelCallback DriveAPIService::GetAppList(const AppListCallback& callback) {
 402   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 403   DCHECK(!callback.is_null());
 404
 405   return sender_->StartRequestWithRetry(
 406       new AppsListRequest(sender_.get(), url_generator_,
 407                           google_apis::IsGoogleChromeAPIKeyUsed(),
 408                           callback));
 409 }
 410
 411 CancelCallback DriveAPIService::DownloadFile(
 412     const base::FilePath& local_cache_path,
 413     const std::string& resource_id,
 414     const DownloadActionCallback& download_action_callback,
 415     const GetContentCallback& get_content_callback,
 416     const ProgressCallback& progress_callback) {
 417   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 418   DCHECK(!download_action_callback.is_null());
 419   // get_content_callback may be null.
 420
 421   return sender_->StartRequestWithRetry(
 422       new DownloadFileRequest(sender_.get(),
 423                               url_generator_,
 424                               resource_id,
 425                               local_cache_path,
 426                               download_action_callback,
 427                               get_content_callback,
 428                               progress_callback));
 429 }
 430
 431 CancelCallback DriveAPIService::DeleteResource(
 432     const std::string& resource_id,
 433     const std::string& etag,
 434     const EntryActionCallback& callback) {
 435   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 436   DCHECK(!callback.is_null());
 437
 438   FilesDeleteRequest* request = new FilesDeleteRequest(
 439       sender_.get(), url_generator_, callback);
 440   request->set_file_id(resource_id);
 441   request->set_etag(etag);
 442   return sender_->StartRequestWithRetry(request);
 443 }
 444
 445 CancelCallback DriveAPIService::TrashResource(
 446     const std::string& resource_id,
 447     const EntryActionCallback& callback) {
 448   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 449   DCHECK(!callback.is_null());
 450
 451   FilesTrashRequest* request = new FilesTrashRequest(
 452       sender_.get(), url_generator_,
 453       base::Bind(&EntryActionCallbackAdapter, callback));
 454   request->set_file_id(resource_id);
 455   request->set_fields(kFileResourceFields);
 456   return sender_->StartRequestWithRetry(request);
 457 }
 458
 459 CancelCallback DriveAPIService::AddNewDirectory(
 460     const std::string& parent_resource_id,
 461     const std::string& directory_title,
 462     const AddNewDirectoryOptions& options,
 463     const FileResourceCallback& callback) {
 464   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 465   DCHECK(!callback.is_null());
 466
 467   FilesInsertRequest* request = new FilesInsertRequest(
 468       sender_.get(), url_generator_, callback);
 469   request->set_last_viewed_by_me_date(options.last_viewed_by_me_date);
 470   request->set_mime_type(kFolderMimeType);
 471   request->set_modified_date(options.modified_date);
 472   request->add_parent(parent_resource_id);
 473   request->set_title(directory_title);
 474   request->set_fields(kFileResourceFields);
 475   return sender_->StartRequestWithRetry(request);
 476 }
 477
 478 CancelCallback DriveAPIService::CopyResource(
 479     const std::string& resource_id,
 480     const std::string& parent_resource_id,
 481     const std::string& new_title,
 482     const base::Time& last_modified,
 483     const FileResourceCallback& callback) {
 484   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 485   DCHECK(!callback.is_null());
 486
 487   FilesCopyRequest* request = new FilesCopyRequest(
 488       sender_.get(), url_generator_, callback);
 489   request->set_file_id(resource_id);
 490   request->add_parent(parent_resource_id);
 491   request->set_title(new_title);
 492   request->set_modified_date(last_modified);
 493   request->set_fields(kFileResourceFields);
 494   return sender_->StartRequestWithRetry(request);
 495 }
 496
 497 CancelCallback DriveAPIService::UpdateResource(
 498     const std::string& resource_id,
 499     const std::string& parent_resource_id,
 500     const std::string& new_title,
 501     const base::Time& last_modified,
 502     const base::Time& last_viewed_by_me,
 503     const FileResourceCallback& callback) {
 504   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 505   DCHECK(!callback.is_null());
 506
 507   FilesPatchRequest* request = new FilesPatchRequest(
 508       sender_.get(), url_generator_, callback);
 509   request->set_file_id(resource_id);
 510   request->set_title(new_title);
 511   if (!parent_resource_id.empty())
 512     request->add_parent(parent_resource_id);
 513   if (!last_modified.is_null()) {
 514     // Need to set setModifiedDate to true to overwrite modifiedDate.
 515     request->set_set_modified_date(true);
 516     request->set_modified_date(last_modified);
 517   }
 518   if (!last_viewed_by_me.is_null()) {
 519     // Need to set updateViewedDate to false, otherwise the lastViewedByMeDate
 520     // will be set to the request time (not the specified time via request).
 521     request->set_update_viewed_date(false);
 522     request->set_last_viewed_by_me_date(last_viewed_by_me);
 523   }
 524   request->set_fields(kFileResourceFields);
 525   return sender_->StartRequestWithRetry(request);
 526 }
 527
 528 CancelCallback DriveAPIService::AddResourceToDirectory(
 529     const std::string& parent_resource_id,
 530     const std::string& resource_id,
 531     const EntryActionCallback& callback) {
 532   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 533   DCHECK(!callback.is_null());
 534
 535   ChildrenInsertRequest* request =
 536       new ChildrenInsertRequest(sender_.get(), url_generator_, callback);
 537   request->set_folder_id(parent_resource_id);
 538   request->set_id(resource_id);
 539   return sender_->StartRequestWithRetry(request);
 540 }
 541
 542 CancelCallback DriveAPIService::RemoveResourceFromDirectory(
 543     const std::string& parent_resource_id,
 544     const std::string& resource_id,
 545     const EntryActionCallback& callback) {
 546   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 547   DCHECK(!callback.is_null());
 548
 549   ChildrenDeleteRequest* request =
 550       new ChildrenDeleteRequest(sender_.get(), url_generator_, callback);
 551   request->set_child_id(resource_id);
 552   request->set_folder_id(parent_resource_id);
 553   return sender_->StartRequestWithRetry(request);
 554 }
 555
 556 CancelCallback DriveAPIService::InitiateUploadNewFile(
 557     const std::string& content_type,
 558     int64 content_length,
 559     const std::string& parent_resource_id,
 560     const std::string& title,
 561     const InitiateUploadNewFileOptions& options,
 562     const InitiateUploadCallback& callback) {
 563   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 564   DCHECK(!callback.is_null());
 565
 566   InitiateUploadNewFileRequest* request =
 567       new InitiateUploadNewFileRequest(sender_.get(),
 568                                        url_generator_,
 569                                        content_type,
 570                                        content_length,
 571                                        parent_resource_id,
 572                                        title,
 573                                        callback);
 574   request->set_modified_date(options.modified_date);
 575   request->set_last_viewed_by_me_date(options.last_viewed_by_me_date);
 576   return sender_->StartRequestWithRetry(request);
 577 }
 578
 579 CancelCallback DriveAPIService::InitiateUploadExistingFile(
 580     const std::string& content_type,
 581     int64 content_length,
 582     const std::string& resource_id,
 583     const InitiateUploadExistingFileOptions& options,
 584     const InitiateUploadCallback& callback) {
 585   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 586   DCHECK(!callback.is_null());
 587
 588   InitiateUploadExistingFileRequest* request =
 589       new InitiateUploadExistingFileRequest(sender_.get(),
 590                                             url_generator_,
 591                                             content_type,
 592                                             content_length,
 593                                             resource_id,
 594                                             options.etag,
 595                                             callback);
 596   request->set_parent_resource_id(options.parent_resource_id);
 597   request->set_title(options.title);
 598   request->set_modified_date(options.modified_date);
 599   request->set_last_viewed_by_me_date(options.last_viewed_by_me_date);
 600   return sender_->StartRequestWithRetry(request);
 601 }
 602
 603 CancelCallback DriveAPIService::ResumeUpload(
 604     const GURL& upload_url,
 605     int64 start_position,
 606     int64 end_position,
 607     int64 content_length,
 608     const std::string& content_type,
 609     const base::FilePath& local_file_path,
 610     const UploadRangeCallback& callback,
 611     const ProgressCallback& progress_callback) {
 612   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 613   DCHECK(!callback.is_null());
 614
 615   return sender_->StartRequestWithRetry(
 616       new ResumeUploadRequest(
 617           sender_.get(),
 618           upload_url,
 619           start_position,
 620           end_position,
 621           content_length,
 622           content_type,
 623           local_file_path,
 624           callback,
 625           progress_callback));
 626 }
 627
 628 CancelCallback DriveAPIService::GetUploadStatus(
 629     const GURL& upload_url,
 630     int64 content_length,
 631     const UploadRangeCallback& callback) {
 632   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 633   DCHECK(!callback.is_null());
 634
 635   return sender_->StartRequestWithRetry(new GetUploadStatusRequest(
 636       sender_.get(),
 637       upload_url,
 638       content_length,
 639       callback));
 640 }
 641
 642 CancelCallback DriveAPIService::AuthorizeApp(
 643     const std::string& resource_id,
 644     const std::string& app_id,
 645     const AuthorizeAppCallback& callback) {
 646   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 647   DCHECK(!callback.is_null());
 648
 649   // Files.Authorize is only available for whitelisted clients like official
 650   // Google Chrome. In other cases, we fall back to Files.Get that returns the
 651   // same value as Files.Authorize without doing authorization. In that case,
 652   // the app can open if it was authorized by other means (from whitelisted
 653   // clients or drive.google.com web UI.)
 654   if (google_apis::IsGoogleChromeAPIKeyUsed()) {
 655     google_apis::drive::FilesAuthorizeRequest* request =
 656         new google_apis::drive::FilesAuthorizeRequest(
 657             sender_.get(), url_generator_,
 658             base::Bind(&ExtractOpenUrlAndRun, app_id, callback));
 659     request->set_app_id(app_id);
 660     request->set_file_id(resource_id);
 661     request->set_fields(kFileResourceOpenWithLinksFields);
 662     return sender_->StartRequestWithRetry(request);
 663   } else {
 664     FilesGetRequest* request = new FilesGetRequest(
 665         sender_.get(), url_generator_,
 666         base::Bind(&ExtractOpenUrlAndRun, app_id, callback));
 667     request->set_file_id(resource_id);
 668     request->set_fields(kFileResourceOpenWithLinksFields);
 669     return sender_->StartRequestWithRetry(request);
 670   }
 671 }
 672
 673 CancelCallback DriveAPIService::UninstallApp(
 674     const std::string& app_id,
 675     const google_apis::EntryActionCallback& callback) {
 676   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 677   DCHECK(!callback.is_null());
 678
 679   google_apis::drive::AppsDeleteRequest* request =
 680       new google_apis::drive::AppsDeleteRequest(sender_.get(), url_generator_,
 681                                                 callback);
 682   request->set_app_id(app_id);
 683   return sender_->StartRequestWithRetry(request);
 684 }
 685
 686 google_apis::CancelCallback DriveAPIService::AddPermission(
 687     const std::string& resource_id,
 688     const std::string& email,
 689     google_apis::drive::PermissionRole role,
 690     const google_apis::EntryActionCallback& callback) {
 691   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 692   DCHECK(!callback.is_null());
 693
 694   google_apis::drive::PermissionsInsertRequest* request =
 695       new google_apis::drive::PermissionsInsertRequest(sender_.get(),
 696                                                        url_generator_,
 697                                                        callback);
 698   request->set_id(resource_id);
 699   request->set_role(role);
 700   request->set_type(google_apis::drive::PERMISSION_TYPE_USER);
 701   request->set_value(email);
 702   return sender_->StartRequestWithRetry(request);
 703 }
 704
 705 bool DriveAPIService::HasAccessToken() const {
 706   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 707   return sender_->auth_service()->HasAccessToken();
 708 }
 709
 710 void DriveAPIService::RequestAccessToken(const AuthStatusCallback& callback) {
 711   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 712   DCHECK(!callback.is_null());
 713
 714   const std::string access_token = sender_->auth_service()->access_token();
 715   if (!access_token.empty()) {
 716     callback.Run(google_apis::HTTP_NOT_MODIFIED, access_token);
 717     return;
 718   }
 719
 720   // Retrieve the new auth token.
 721   sender_->auth_service()->StartAuthentication(callback);
 722 }
 723
 724 bool DriveAPIService::HasRefreshToken() const {
 725   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 726   return sender_->auth_service()->HasRefreshToken();
 727 }
 728
 729 void DriveAPIService::ClearAccessToken() {
 730   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 731   sender_->auth_service()->ClearAccessToken();
 732 }
 733
 734 void DriveAPIService::ClearRefreshToken() {
 735   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 736   sender_->auth_service()->ClearRefreshToken();
 737 }
 738
 739 void DriveAPIService::OnOAuth2RefreshTokenChanged() {
 740   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 741   if (CanSendRequest()) {
 742     FOR_EACH_OBSERVER(
 743         DriveServiceObserver, observers_, OnReadyToSendRequests());
 744   } else if (!HasRefreshToken()) {
 745     FOR_EACH_OBSERVER(
 746         DriveServiceObserver, observers_, OnRefreshTokenInvalid());
 747   }
 748 }
 749
 750 }  // namespace drive