google_apis/drive/drive_api_requests.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 "google_apis/drive/drive_api_requests.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/json/json_writer.h"
  10 #include "base/location.h"
  11 #include "base/sequenced_task_runner.h"
  12 #include "base/task_runner_util.h"
  13 #include "base/values.h"
  14 #include "google_apis/drive/request_sender.h"
  15 #include "google_apis/drive/request_util.h"
  16 #include "google_apis/drive/time_util.h"
  17 #include "net/base/url_util.h"
  18
  19 namespace google_apis {
  20 namespace {
  21
  22 // Parses the JSON value to FileResource instance and runs |callback| on the
  23 // UI thread once parsing is done.
  24 // This is customized version of ParseJsonAndRun defined above to adapt the
  25 // remaining response type.
  26 void ParseFileResourceWithUploadRangeAndRun(
  27     const drive::UploadRangeCallback& callback,
  28     const UploadRangeResponse& response,
  29     scoped_ptr<base::Value> value) {
  30   DCHECK(!callback.is_null());
  31
  32   scoped_ptr<FileResource> file_resource;
  33   if (value) {
  34     file_resource = FileResource::CreateFrom(*value);
  35     if (!file_resource) {
  36       callback.Run(
  37           UploadRangeResponse(GDATA_PARSE_ERROR,
  38                               response.start_position_received,
  39                               response.end_position_received),
  40           scoped_ptr<FileResource>());
  41       return;
  42     }
  43   }
  44
  45   callback.Run(response, file_resource.Pass());
  46 }
  47
  48 }  // namespace
  49
  50 namespace drive {
  51
  52 //============================ DriveApiPartialFieldRequest ====================
  53
  54 DriveApiPartialFieldRequest::DriveApiPartialFieldRequest(
  55     RequestSender* sender) : UrlFetchRequestBase(sender) {
  56 }
  57
  58 DriveApiPartialFieldRequest::~DriveApiPartialFieldRequest() {
  59 }
  60
  61 GURL DriveApiPartialFieldRequest::GetURL() const {
  62   GURL url = GetURLInternal();
  63   if (!fields_.empty())
  64     url = net::AppendOrReplaceQueryParameter(url, "fields", fields_);
  65   return url;
  66 }
  67
  68 //=============================== FilesGetRequest =============================
  69
  70 FilesGetRequest::FilesGetRequest(
  71     RequestSender* sender,
  72     const DriveApiUrlGenerator& url_generator,
  73     const FileResourceCallback& callback)
  74     : DriveApiDataRequest<FileResource>(sender, callback),
  75       url_generator_(url_generator) {
  76   DCHECK(!callback.is_null());
  77 }
  78
  79 FilesGetRequest::~FilesGetRequest() {}
  80
  81 GURL FilesGetRequest::GetURLInternal() const {
  82   return url_generator_.GetFilesGetUrl(file_id_);
  83 }
  84
  85 //============================ FilesAuthorizeRequest ===========================
  86
  87 FilesAuthorizeRequest::FilesAuthorizeRequest(
  88     RequestSender* sender,
  89     const DriveApiUrlGenerator& url_generator,
  90     const FileResourceCallback& callback)
  91     : DriveApiDataRequest<FileResource>(sender, callback),
  92       url_generator_(url_generator) {
  93   DCHECK(!callback.is_null());
  94 }
  95
  96 FilesAuthorizeRequest::~FilesAuthorizeRequest() {}
  97
  98 net::URLFetcher::RequestType FilesAuthorizeRequest::GetRequestType() const {
  99   return net::URLFetcher::POST;
 100 }
 101
 102 GURL FilesAuthorizeRequest::GetURLInternal() const {
 103   return url_generator_.GetFilesAuthorizeUrl(file_id_, app_id_);
 104 }
 105
 106 //============================ FilesInsertRequest ============================
 107
 108 FilesInsertRequest::FilesInsertRequest(
 109     RequestSender* sender,
 110     const DriveApiUrlGenerator& url_generator,
 111     const FileResourceCallback& callback)
 112     : DriveApiDataRequest<FileResource>(sender, callback),
 113       url_generator_(url_generator) {
 114   DCHECK(!callback.is_null());
 115 }
 116
 117 FilesInsertRequest::~FilesInsertRequest() {}
 118
 119 net::URLFetcher::RequestType FilesInsertRequest::GetRequestType() const {
 120   return net::URLFetcher::POST;
 121 }
 122
 123 bool FilesInsertRequest::GetContentData(std::string* upload_content_type,
 124                                         std::string* upload_content) {
 125   *upload_content_type = util::kContentTypeApplicationJson;
 126
 127   base::DictionaryValue root;
 128
 129   if (!last_viewed_by_me_date_.is_null()) {
 130     root.SetString("lastViewedByMeDate",
 131                    util::FormatTimeAsString(last_viewed_by_me_date_));
 132   }
 133
 134   if (!mime_type_.empty())
 135     root.SetString("mimeType", mime_type_);
 136
 137   if (!modified_date_.is_null())
 138     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 139
 140   if (!parents_.empty()) {
 141     base::ListValue* parents_value = new base::ListValue;
 142     for (size_t i = 0; i < parents_.size(); ++i) {
 143       base::DictionaryValue* parent = new base::DictionaryValue;
 144       parent->SetString("id", parents_[i]);
 145       parents_value->Append(parent);
 146     }
 147     root.Set("parents", parents_value);
 148   }
 149
 150   if (!title_.empty())
 151     root.SetString("title", title_);
 152
 153   base::JSONWriter::Write(&root, upload_content);
 154   DVLOG(1) << "FilesInsert data: " << *upload_content_type << ", ["
 155            << *upload_content << "]";
 156   return true;
 157 }
 158
 159 GURL FilesInsertRequest::GetURLInternal() const {
 160   return url_generator_.GetFilesInsertUrl();
 161 }
 162
 163 //============================== FilesPatchRequest ============================
 164
 165 FilesPatchRequest::FilesPatchRequest(
 166     RequestSender* sender,
 167     const DriveApiUrlGenerator& url_generator,
 168     const FileResourceCallback& callback)
 169     : DriveApiDataRequest<FileResource>(sender, callback),
 170       url_generator_(url_generator),
 171       set_modified_date_(false),
 172       update_viewed_date_(true) {
 173   DCHECK(!callback.is_null());
 174 }
 175
 176 FilesPatchRequest::~FilesPatchRequest() {}
 177
 178 net::URLFetcher::RequestType FilesPatchRequest::GetRequestType() const {
 179   return net::URLFetcher::PATCH;
 180 }
 181
 182 std::vector<std::string> FilesPatchRequest::GetExtraRequestHeaders() const {
 183   std::vector<std::string> headers;
 184   headers.push_back(util::kIfMatchAllHeader);
 185   return headers;
 186 }
 187
 188 GURL FilesPatchRequest::GetURLInternal() const {
 189   return url_generator_.GetFilesPatchUrl(
 190       file_id_, set_modified_date_, update_viewed_date_);
 191 }
 192
 193 bool FilesPatchRequest::GetContentData(std::string* upload_content_type,
 194                                        std::string* upload_content) {
 195   if (title_.empty() &&
 196       modified_date_.is_null() &&
 197       last_viewed_by_me_date_.is_null() &&
 198       parents_.empty())
 199     return false;
 200
 201   *upload_content_type = util::kContentTypeApplicationJson;
 202
 203   base::DictionaryValue root;
 204   if (!title_.empty())
 205     root.SetString("title", title_);
 206
 207   if (!modified_date_.is_null())
 208     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 209
 210   if (!last_viewed_by_me_date_.is_null()) {
 211     root.SetString("lastViewedByMeDate",
 212                    util::FormatTimeAsString(last_viewed_by_me_date_));
 213   }
 214
 215   if (!parents_.empty()) {
 216     base::ListValue* parents_value = new base::ListValue;
 217     for (size_t i = 0; i < parents_.size(); ++i) {
 218       base::DictionaryValue* parent = new base::DictionaryValue;
 219       parent->SetString("id", parents_[i]);
 220       parents_value->Append(parent);
 221     }
 222     root.Set("parents", parents_value);
 223   }
 224
 225   base::JSONWriter::Write(&root, upload_content);
 226   DVLOG(1) << "FilesPatch data: " << *upload_content_type << ", ["
 227            << *upload_content << "]";
 228   return true;
 229 }
 230
 231 //============================= FilesCopyRequest ==============================
 232
 233 FilesCopyRequest::FilesCopyRequest(
 234     RequestSender* sender,
 235     const DriveApiUrlGenerator& url_generator,
 236     const FileResourceCallback& callback)
 237     : DriveApiDataRequest<FileResource>(sender, callback),
 238       url_generator_(url_generator) {
 239   DCHECK(!callback.is_null());
 240 }
 241
 242 FilesCopyRequest::~FilesCopyRequest() {
 243 }
 244
 245 net::URLFetcher::RequestType FilesCopyRequest::GetRequestType() const {
 246   return net::URLFetcher::POST;
 247 }
 248
 249 GURL FilesCopyRequest::GetURLInternal() const {
 250   return url_generator_.GetFilesCopyUrl(file_id_);
 251 }
 252
 253 bool FilesCopyRequest::GetContentData(std::string* upload_content_type,
 254                                       std::string* upload_content) {
 255   if (parents_.empty() && title_.empty())
 256     return false;
 257
 258   *upload_content_type = util::kContentTypeApplicationJson;
 259
 260   base::DictionaryValue root;
 261
 262   if (!modified_date_.is_null())
 263     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 264
 265   if (!parents_.empty()) {
 266     base::ListValue* parents_value = new base::ListValue;
 267     for (size_t i = 0; i < parents_.size(); ++i) {
 268       base::DictionaryValue* parent = new base::DictionaryValue;
 269       parent->SetString("id", parents_[i]);
 270       parents_value->Append(parent);
 271     }
 272     root.Set("parents", parents_value);
 273   }
 274
 275   if (!title_.empty())
 276     root.SetString("title", title_);
 277
 278   base::JSONWriter::Write(&root, upload_content);
 279   DVLOG(1) << "FilesCopy data: " << *upload_content_type << ", ["
 280            << *upload_content << "]";
 281   return true;
 282 }
 283
 284 //============================= FilesListRequest =============================
 285
 286 FilesListRequest::FilesListRequest(
 287     RequestSender* sender,
 288     const DriveApiUrlGenerator& url_generator,
 289     const FileListCallback& callback)
 290     : DriveApiDataRequest<FileList>(sender, callback),
 291       url_generator_(url_generator),
 292       max_results_(100) {
 293   DCHECK(!callback.is_null());
 294 }
 295
 296 FilesListRequest::~FilesListRequest() {}
 297
 298 GURL FilesListRequest::GetURLInternal() const {
 299   return url_generator_.GetFilesListUrl(max_results_, page_token_, q_);
 300 }
 301
 302 //======================== FilesListNextPageRequest =========================
 303
 304 FilesListNextPageRequest::FilesListNextPageRequest(
 305     RequestSender* sender,
 306     const FileListCallback& callback)
 307     : DriveApiDataRequest<FileList>(sender, callback) {
 308   DCHECK(!callback.is_null());
 309 }
 310
 311 FilesListNextPageRequest::~FilesListNextPageRequest() {
 312 }
 313
 314 GURL FilesListNextPageRequest::GetURLInternal() const {
 315   return next_link_;
 316 }
 317
 318 //============================ FilesDeleteRequest =============================
 319
 320 FilesDeleteRequest::FilesDeleteRequest(
 321     RequestSender* sender,
 322     const DriveApiUrlGenerator& url_generator,
 323     const EntryActionCallback& callback)
 324     : EntryActionRequest(sender, callback),
 325       url_generator_(url_generator) {
 326   DCHECK(!callback.is_null());
 327 }
 328
 329 FilesDeleteRequest::~FilesDeleteRequest() {}
 330
 331 net::URLFetcher::RequestType FilesDeleteRequest::GetRequestType() const {
 332   return net::URLFetcher::DELETE_REQUEST;
 333 }
 334
 335 GURL FilesDeleteRequest::GetURL() const {
 336   return url_generator_.GetFilesDeleteUrl(file_id_);
 337 }
 338
 339 std::vector<std::string> FilesDeleteRequest::GetExtraRequestHeaders() const {
 340   std::vector<std::string> headers(
 341       EntryActionRequest::GetExtraRequestHeaders());
 342   headers.push_back(util::GenerateIfMatchHeader(etag_));
 343   return headers;
 344 }
 345
 346 //============================ FilesTrashRequest =============================
 347
 348 FilesTrashRequest::FilesTrashRequest(
 349     RequestSender* sender,
 350     const DriveApiUrlGenerator& url_generator,
 351     const FileResourceCallback& callback)
 352     : DriveApiDataRequest<FileResource>(sender, callback),
 353       url_generator_(url_generator) {
 354   DCHECK(!callback.is_null());
 355 }
 356
 357 FilesTrashRequest::~FilesTrashRequest() {}
 358
 359 net::URLFetcher::RequestType FilesTrashRequest::GetRequestType() const {
 360   return net::URLFetcher::POST;
 361 }
 362
 363 GURL FilesTrashRequest::GetURLInternal() const {
 364   return url_generator_.GetFilesTrashUrl(file_id_);
 365 }
 366
 367 //============================== AboutGetRequest =============================
 368
 369 AboutGetRequest::AboutGetRequest(
 370     RequestSender* sender,
 371     const DriveApiUrlGenerator& url_generator,
 372     const AboutResourceCallback& callback)
 373     : DriveApiDataRequest<AboutResource>(sender, callback),
 374       url_generator_(url_generator) {
 375   DCHECK(!callback.is_null());
 376 }
 377
 378 AboutGetRequest::~AboutGetRequest() {}
 379
 380 GURL AboutGetRequest::GetURLInternal() const {
 381   return url_generator_.GetAboutGetUrl();
 382 }
 383
 384 //============================ ChangesListRequest ===========================
 385
 386 ChangesListRequest::ChangesListRequest(
 387     RequestSender* sender,
 388     const DriveApiUrlGenerator& url_generator,
 389     const ChangeListCallback& callback)
 390     : DriveApiDataRequest<ChangeList>(sender, callback),
 391       url_generator_(url_generator),
 392       include_deleted_(true),
 393       max_results_(100),
 394       start_change_id_(0) {
 395   DCHECK(!callback.is_null());
 396 }
 397
 398 ChangesListRequest::~ChangesListRequest() {}
 399
 400 GURL ChangesListRequest::GetURLInternal() const {
 401   return url_generator_.GetChangesListUrl(
 402       include_deleted_, max_results_, page_token_, start_change_id_);
 403 }
 404
 405 //======================== ChangesListNextPageRequest =========================
 406
 407 ChangesListNextPageRequest::ChangesListNextPageRequest(
 408     RequestSender* sender,
 409     const ChangeListCallback& callback)
 410     : DriveApiDataRequest<ChangeList>(sender, callback) {
 411   DCHECK(!callback.is_null());
 412 }
 413
 414 ChangesListNextPageRequest::~ChangesListNextPageRequest() {
 415 }
 416
 417 GURL ChangesListNextPageRequest::GetURLInternal() const {
 418   return next_link_;
 419 }
 420
 421 //============================== AppsListRequest ===========================
 422
 423 AppsListRequest::AppsListRequest(
 424     RequestSender* sender,
 425     const DriveApiUrlGenerator& url_generator,
 426     bool use_internal_endpoint,
 427     const AppListCallback& callback)
 428     : DriveApiDataRequest<AppList>(sender, callback),
 429       url_generator_(url_generator),
 430       use_internal_endpoint_(use_internal_endpoint) {
 431   DCHECK(!callback.is_null());
 432 }
 433
 434 AppsListRequest::~AppsListRequest() {}
 435
 436 GURL AppsListRequest::GetURLInternal() const {
 437   return url_generator_.GetAppsListUrl(use_internal_endpoint_);
 438 }
 439
 440 //============================== AppsDeleteRequest ===========================
 441
 442 AppsDeleteRequest::AppsDeleteRequest(RequestSender* sender,
 443                                      const DriveApiUrlGenerator& url_generator,
 444                                      const EntryActionCallback& callback)
 445     : EntryActionRequest(sender, callback),
 446       url_generator_(url_generator) {
 447   DCHECK(!callback.is_null());
 448 }
 449
 450 AppsDeleteRequest::~AppsDeleteRequest() {}
 451
 452 net::URLFetcher::RequestType AppsDeleteRequest::GetRequestType() const {
 453   return net::URLFetcher::DELETE_REQUEST;
 454 }
 455
 456 GURL AppsDeleteRequest::GetURL() const {
 457   return url_generator_.GetAppsDeleteUrl(app_id_);
 458 }
 459
 460 //========================== ChildrenInsertRequest ============================
 461
 462 ChildrenInsertRequest::ChildrenInsertRequest(
 463     RequestSender* sender,
 464     const DriveApiUrlGenerator& url_generator,
 465     const EntryActionCallback& callback)
 466     : EntryActionRequest(sender, callback),
 467       url_generator_(url_generator) {
 468   DCHECK(!callback.is_null());
 469 }
 470
 471 ChildrenInsertRequest::~ChildrenInsertRequest() {}
 472
 473 net::URLFetcher::RequestType ChildrenInsertRequest::GetRequestType() const {
 474   return net::URLFetcher::POST;
 475 }
 476
 477 GURL ChildrenInsertRequest::GetURL() const {
 478   return url_generator_.GetChildrenInsertUrl(folder_id_);
 479 }
 480
 481 bool ChildrenInsertRequest::GetContentData(std::string* upload_content_type,
 482                                            std::string* upload_content) {
 483   *upload_content_type = util::kContentTypeApplicationJson;
 484
 485   base::DictionaryValue root;
 486   root.SetString("id", id_);
 487
 488   base::JSONWriter::Write(&root, upload_content);
 489   DVLOG(1) << "InsertResource data: " << *upload_content_type << ", ["
 490            << *upload_content << "]";
 491   return true;
 492 }
 493
 494 //========================== ChildrenDeleteRequest ============================
 495
 496 ChildrenDeleteRequest::ChildrenDeleteRequest(
 497     RequestSender* sender,
 498     const DriveApiUrlGenerator& url_generator,
 499     const EntryActionCallback& callback)
 500     : EntryActionRequest(sender, callback),
 501       url_generator_(url_generator) {
 502   DCHECK(!callback.is_null());
 503 }
 504
 505 ChildrenDeleteRequest::~ChildrenDeleteRequest() {}
 506
 507 net::URLFetcher::RequestType ChildrenDeleteRequest::GetRequestType() const {
 508   return net::URLFetcher::DELETE_REQUEST;
 509 }
 510
 511 GURL ChildrenDeleteRequest::GetURL() const {
 512   return url_generator_.GetChildrenDeleteUrl(child_id_, folder_id_);
 513 }
 514
 515 //======================= InitiateUploadNewFileRequest =======================
 516
 517 InitiateUploadNewFileRequest::InitiateUploadNewFileRequest(
 518     RequestSender* sender,
 519     const DriveApiUrlGenerator& url_generator,
 520     const std::string& content_type,
 521     int64 content_length,
 522     const std::string& parent_resource_id,
 523     const std::string& title,
 524     const InitiateUploadCallback& callback)
 525     : InitiateUploadRequestBase(sender,
 526                                 callback,
 527                                 content_type,
 528                                 content_length),
 529       url_generator_(url_generator),
 530       parent_resource_id_(parent_resource_id),
 531       title_(title) {
 532 }
 533
 534 InitiateUploadNewFileRequest::~InitiateUploadNewFileRequest() {}
 535
 536 GURL InitiateUploadNewFileRequest::GetURL() const {
 537   return url_generator_.GetInitiateUploadNewFileUrl(!modified_date_.is_null());
 538 }
 539
 540 net::URLFetcher::RequestType
 541 InitiateUploadNewFileRequest::GetRequestType() const {
 542   return net::URLFetcher::POST;
 543 }
 544
 545 bool InitiateUploadNewFileRequest::GetContentData(
 546     std::string* upload_content_type,
 547     std::string* upload_content) {
 548   *upload_content_type = util::kContentTypeApplicationJson;
 549
 550   base::DictionaryValue root;
 551   root.SetString("title", title_);
 552
 553   // Fill parent link.
 554   scoped_ptr<base::ListValue> parents(new base::ListValue);
 555   parents->Append(util::CreateParentValue(parent_resource_id_).release());
 556   root.Set("parents", parents.release());
 557
 558   if (!modified_date_.is_null())
 559     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 560
 561   if (!last_viewed_by_me_date_.is_null()) {
 562     root.SetString("lastViewedByMeDate",
 563                    util::FormatTimeAsString(last_viewed_by_me_date_));
 564   }
 565
 566   base::JSONWriter::Write(&root, upload_content);
 567
 568   DVLOG(1) << "InitiateUploadNewFile data: " << *upload_content_type << ", ["
 569            << *upload_content << "]";
 570   return true;
 571 }
 572
 573 //===================== InitiateUploadExistingFileRequest ====================
 574
 575 InitiateUploadExistingFileRequest::InitiateUploadExistingFileRequest(
 576     RequestSender* sender,
 577     const DriveApiUrlGenerator& url_generator,
 578     const std::string& content_type,
 579     int64 content_length,
 580     const std::string& resource_id,
 581     const std::string& etag,
 582     const InitiateUploadCallback& callback)
 583     : InitiateUploadRequestBase(sender,
 584                                 callback,
 585                                 content_type,
 586                                 content_length),
 587       url_generator_(url_generator),
 588       resource_id_(resource_id),
 589       etag_(etag) {
 590 }
 591
 592 InitiateUploadExistingFileRequest::~InitiateUploadExistingFileRequest() {}
 593
 594 GURL InitiateUploadExistingFileRequest::GetURL() const {
 595   return url_generator_.GetInitiateUploadExistingFileUrl(
 596       resource_id_, !modified_date_.is_null());
 597 }
 598
 599 net::URLFetcher::RequestType
 600 InitiateUploadExistingFileRequest::GetRequestType() const {
 601   return net::URLFetcher::PUT;
 602 }
 603
 604 std::vector<std::string>
 605 InitiateUploadExistingFileRequest::GetExtraRequestHeaders() const {
 606   std::vector<std::string> headers(
 607       InitiateUploadRequestBase::GetExtraRequestHeaders());
 608   headers.push_back(util::GenerateIfMatchHeader(etag_));
 609   return headers;
 610 }
 611
 612 bool InitiateUploadExistingFileRequest::GetContentData(
 613     std::string* upload_content_type,
 614     std::string* upload_content) {
 615   base::DictionaryValue root;
 616   if (!parent_resource_id_.empty()) {
 617     scoped_ptr<base::ListValue> parents(new base::ListValue);
 618     parents->Append(util::CreateParentValue(parent_resource_id_).release());
 619     root.Set("parents", parents.release());
 620   }
 621
 622   if (!title_.empty())
 623     root.SetString("title", title_);
 624
 625   if (!modified_date_.is_null())
 626     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 627
 628   if (!last_viewed_by_me_date_.is_null()) {
 629     root.SetString("lastViewedByMeDate",
 630                    util::FormatTimeAsString(last_viewed_by_me_date_));
 631   }
 632
 633   if (root.empty())
 634     return false;
 635
 636   *upload_content_type = util::kContentTypeApplicationJson;
 637   base::JSONWriter::Write(&root, upload_content);
 638   DVLOG(1) << "InitiateUploadExistingFile data: " << *upload_content_type
 639            << ", [" << *upload_content << "]";
 640   return true;
 641 }
 642
 643 //============================ ResumeUploadRequest ===========================
 644
 645 ResumeUploadRequest::ResumeUploadRequest(
 646     RequestSender* sender,
 647     const GURL& upload_location,
 648     int64 start_position,
 649     int64 end_position,
 650     int64 content_length,
 651     const std::string& content_type,
 652     const base::FilePath& local_file_path,
 653     const UploadRangeCallback& callback,
 654     const ProgressCallback& progress_callback)
 655     : ResumeUploadRequestBase(sender,
 656                               upload_location,
 657                               start_position,
 658                               end_position,
 659                               content_length,
 660                               content_type,
 661                               local_file_path),
 662       callback_(callback),
 663       progress_callback_(progress_callback) {
 664   DCHECK(!callback_.is_null());
 665 }
 666
 667 ResumeUploadRequest::~ResumeUploadRequest() {}
 668
 669 void ResumeUploadRequest::OnRangeRequestComplete(
 670     const UploadRangeResponse& response,
 671     scoped_ptr<base::Value> value) {
 672   DCHECK(CalledOnValidThread());
 673   ParseFileResourceWithUploadRangeAndRun(callback_, response, value.Pass());
 674 }
 675
 676 void ResumeUploadRequest::OnURLFetchUploadProgress(
 677     const net::URLFetcher* source, int64 current, int64 total) {
 678   if (!progress_callback_.is_null())
 679     progress_callback_.Run(current, total);
 680 }
 681
 682 //========================== GetUploadStatusRequest ==========================
 683
 684 GetUploadStatusRequest::GetUploadStatusRequest(
 685     RequestSender* sender,
 686     const GURL& upload_url,
 687     int64 content_length,
 688     const UploadRangeCallback& callback)
 689     : GetUploadStatusRequestBase(sender,
 690                                  upload_url,
 691                                  content_length),
 692       callback_(callback) {
 693   DCHECK(!callback.is_null());
 694 }
 695
 696 GetUploadStatusRequest::~GetUploadStatusRequest() {}
 697
 698 void GetUploadStatusRequest::OnRangeRequestComplete(
 699     const UploadRangeResponse& response,
 700     scoped_ptr<base::Value> value) {
 701   DCHECK(CalledOnValidThread());
 702   ParseFileResourceWithUploadRangeAndRun(callback_, response, value.Pass());
 703 }
 704
 705 //======================= MultipartUploadNewFileRequest =======================
 706
 707 MultipartUploadNewFileRequest::MultipartUploadNewFileRequest(
 708     RequestSender* sender,
 709     const std::string& title,
 710     const std::string& parent_resource_id,
 711     const std::string& content_type,
 712     int64 content_length,
 713     const base::Time& modified_date,
 714     const base::Time& last_viewed_by_me_date,
 715     const base::FilePath& local_file_path,
 716     const DriveApiUrlGenerator& url_generator,
 717     const FileResourceCallback& callback,
 718     const ProgressCallback& progress_callback)
 719     : MultipartUploadRequestBase(sender,
 720                                  title,
 721                                  parent_resource_id,
 722                                  content_type,
 723                                  content_length,
 724                                  modified_date,
 725                                  last_viewed_by_me_date,
 726                                  local_file_path,
 727                                  callback,
 728                                  progress_callback),
 729       url_generator_(url_generator) {
 730 }
 731
 732 MultipartUploadNewFileRequest::~MultipartUploadNewFileRequest() {
 733 }
 734
 735 GURL MultipartUploadNewFileRequest::GetURL() const {
 736   return url_generator_.GetMultipartUploadNewFileUrl(has_modified_date());
 737 }
 738
 739 net::URLFetcher::RequestType MultipartUploadNewFileRequest::GetRequestType()
 740     const {
 741   return net::URLFetcher::POST;
 742 }
 743
 744 //======================= MultipartUploadExistingFileRequest ===================
 745
 746 MultipartUploadExistingFileRequest::MultipartUploadExistingFileRequest(
 747     RequestSender* sender,
 748     const std::string& title,
 749     const std::string& resource_id,
 750     const std::string& parent_resource_id,
 751     const std::string& content_type,
 752     int64 content_length,
 753     const base::Time& modified_date,
 754     const base::Time& last_viewed_by_me_date,
 755     const base::FilePath& local_file_path,
 756     const std::string& etag,
 757     const DriveApiUrlGenerator& url_generator,
 758     const FileResourceCallback& callback,
 759     const ProgressCallback& progress_callback)
 760     : MultipartUploadRequestBase(sender,
 761                                  title,
 762                                  parent_resource_id,
 763                                  content_type,
 764                                  content_length,
 765                                  modified_date,
 766                                  last_viewed_by_me_date,
 767                                  local_file_path,
 768                                  callback,
 769                                  progress_callback),
 770       resource_id_(resource_id),
 771       etag_(etag),
 772       url_generator_(url_generator) {
 773 }
 774
 775 MultipartUploadExistingFileRequest::~MultipartUploadExistingFileRequest() {
 776 }
 777
 778 std::vector<std::string>
 779 MultipartUploadExistingFileRequest::GetExtraRequestHeaders() const {
 780   std::vector<std::string> headers(
 781       MultipartUploadRequestBase::GetExtraRequestHeaders());
 782   headers.push_back(util::GenerateIfMatchHeader(etag_));
 783   return headers;
 784 }
 785
 786 GURL MultipartUploadExistingFileRequest::GetURL() const {
 787   return url_generator_.GetMultipartUploadExistingFileUrl(
 788       resource_id_, has_modified_date());
 789 }
 790
 791 net::URLFetcher::RequestType
 792 MultipartUploadExistingFileRequest::GetRequestType() const {
 793   return net::URLFetcher::PUT;
 794 }
 795
 796 //========================== DownloadFileRequest ==========================
 797
 798 DownloadFileRequest::DownloadFileRequest(
 799     RequestSender* sender,
 800     const DriveApiUrlGenerator& url_generator,
 801     const std::string& resource_id,
 802     const base::FilePath& output_file_path,
 803     const DownloadActionCallback& download_action_callback,
 804     const GetContentCallback& get_content_callback,
 805     const ProgressCallback& progress_callback)
 806     : DownloadFileRequestBase(
 807           sender,
 808           download_action_callback,
 809           get_content_callback,
 810           progress_callback,
 811           url_generator.GenerateDownloadFileUrl(resource_id),
 812           output_file_path) {
 813 }
 814
 815 DownloadFileRequest::~DownloadFileRequest() {
 816 }
 817
 818 //========================== PermissionsInsertRequest ==========================
 819
 820 PermissionsInsertRequest::PermissionsInsertRequest(
 821     RequestSender* sender,
 822     const DriveApiUrlGenerator& url_generator,
 823     const EntryActionCallback& callback)
 824     : EntryActionRequest(sender, callback),
 825       url_generator_(url_generator),
 826       type_(PERMISSION_TYPE_USER),
 827       role_(PERMISSION_ROLE_READER) {
 828 }
 829
 830 PermissionsInsertRequest::~PermissionsInsertRequest() {
 831 }
 832
 833 GURL PermissionsInsertRequest::GetURL() const {
 834   return url_generator_.GetPermissionsInsertUrl(id_);
 835 }
 836
 837 net::URLFetcher::RequestType
 838 PermissionsInsertRequest::GetRequestType() const {
 839   return net::URLFetcher::POST;
 840 }
 841
 842 bool PermissionsInsertRequest::GetContentData(std::string* upload_content_type,
 843                                               std::string* upload_content) {
 844   *upload_content_type = util::kContentTypeApplicationJson;
 845
 846   base::DictionaryValue root;
 847   switch (type_) {
 848     case PERMISSION_TYPE_ANYONE:
 849       root.SetString("type", "anyone");
 850       break;
 851     case PERMISSION_TYPE_DOMAIN:
 852       root.SetString("type", "domain");
 853       break;
 854     case PERMISSION_TYPE_GROUP:
 855       root.SetString("type", "group");
 856       break;
 857     case PERMISSION_TYPE_USER:
 858       root.SetString("type", "user");
 859       break;
 860   }
 861   switch (role_) {
 862     case PERMISSION_ROLE_OWNER:
 863       root.SetString("role", "owner");
 864       break;
 865     case PERMISSION_ROLE_READER:
 866       root.SetString("role", "reader");
 867       break;
 868     case PERMISSION_ROLE_WRITER:
 869       root.SetString("role", "writer");
 870       break;
 871     case PERMISSION_ROLE_COMMENTER:
 872       root.SetString("role", "reader");
 873       {
 874         base::ListValue* list = new base::ListValue;
 875         list->AppendString("commenter");
 876         root.Set("additionalRoles", list);
 877       }
 878       break;
 879   }
 880   root.SetString("value", value_);
 881   base::JSONWriter::Write(&root, upload_content);
 882   return true;
 883 }
 884
 885 }  // namespace drive
 886 }  // namespace google_apis