| OLD | NEW |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 #include "google_apis/drive/gdata_wapi_requests.h" | 5 #include "google_apis/drive/gdata_wapi_requests.h" |
| 6 | 6 |
| 7 #include "base/location.h" | |
| 8 #include "base/sequenced_task_runner.h" | |
| 9 #include "base/task_runner_util.h" | |
| 10 #include "base/values.h" | |
| 11 #include "google_apis/drive/gdata_wapi_parser.h" | |
| 12 #include "google_apis/drive/gdata_wapi_url_generator.h" | 7 #include "google_apis/drive/gdata_wapi_url_generator.h" |
| 13 #include "google_apis/drive/request_sender.h" | |
| 14 #include "google_apis/drive/request_util.h" | |
| 15 #include "third_party/libxml/chromium/libxml_utils.h" | |
| 16 | |
| 17 using net::URLFetcher; | |
| 18 | 8 |
| 19 namespace google_apis { | 9 namespace google_apis { |
| 20 | 10 |
| 21 namespace { | |
| 22 | |
| 23 // Parses the JSON value to ResourceList. | |
| 24 scoped_ptr<ResourceList> ParseResourceListOnBlockingPool( | |
| 25 scoped_ptr<base::Value> value) { | |
| 26 DCHECK(value); | |
| 27 | |
| 28 return ResourceList::ExtractAndParse(*value); | |
| 29 } | |
| 30 | |
| 31 // Runs |callback| with |error| and |resource_list|, but replace the error code | |
| 32 // with GDATA_PARSE_ERROR, if there was a parsing error. | |
| 33 void DidParseResourceListOnBlockingPool( | |
| 34 const GetResourceListCallback& callback, | |
| 35 GDataErrorCode error, | |
| 36 scoped_ptr<ResourceList> resource_list) { | |
| 37 DCHECK(!callback.is_null()); | |
| 38 | |
| 39 // resource_list being NULL indicates there was a parsing error. | |
| 40 if (!resource_list) | |
| 41 error = GDATA_PARSE_ERROR; | |
| 42 | |
| 43 callback.Run(error, resource_list.Pass()); | |
| 44 } | |
| 45 | |
| 46 // Parses the JSON value to ResourceList on the blocking pool and runs | |
| 47 // |callback| on the UI thread once parsing is done. | |
| 48 void ParseResourceListAndRun( | |
| 49 scoped_refptr<base::TaskRunner> blocking_task_runner, | |
| 50 const GetResourceListCallback& callback, | |
| 51 GDataErrorCode error, | |
| 52 scoped_ptr<base::Value> value) { | |
| 53 DCHECK(!callback.is_null()); | |
| 54 | |
| 55 if (!value) { | |
| 56 callback.Run(error, scoped_ptr<ResourceList>()); | |
| 57 return; | |
| 58 } | |
| 59 | |
| 60 base::PostTaskAndReplyWithResult( | |
| 61 blocking_task_runner, | |
| 62 FROM_HERE, | |
| 63 base::Bind(&ParseResourceListOnBlockingPool, base::Passed(&value)), | |
| 64 base::Bind(&DidParseResourceListOnBlockingPool, callback, error)); | |
| 65 } | |
| 66 | |
| 67 // Parses the JSON value to AccountMetadata and runs |callback| on the UI | |
| 68 // thread once parsing is done. | |
| 69 void ParseAccounetMetadataAndRun(const GetAccountMetadataCallback& callback, | |
| 70 GDataErrorCode error, | |
| 71 scoped_ptr<base::Value> value) { | |
| 72 DCHECK(!callback.is_null()); | |
| 73 | |
| 74 if (!value) { | |
| 75 callback.Run(error, scoped_ptr<AccountMetadata>()); | |
| 76 return; | |
| 77 } | |
| 78 | |
| 79 // Parsing AccountMetadata is cheap enough to do on UI thread. | |
| 80 scoped_ptr<AccountMetadata> entry = | |
| 81 google_apis::AccountMetadata::CreateFrom(*value); | |
| 82 if (!entry) { | |
| 83 callback.Run(GDATA_PARSE_ERROR, scoped_ptr<AccountMetadata>()); | |
| 84 return; | |
| 85 } | |
| 86 | |
| 87 callback.Run(error, entry.Pass()); | |
| 88 } | |
| 89 | |
| 90 // Parses the |value| to ResourceEntry with error handling. | |
| 91 // This is designed to be used for ResumeUploadRequest and | |
| 92 // GetUploadStatusRequest. | |
| 93 scoped_ptr<ResourceEntry> ParseResourceEntry(scoped_ptr<base::Value> value) { | |
| 94 scoped_ptr<ResourceEntry> entry; | |
| 95 if (value.get()) { | |
| 96 entry = ResourceEntry::ExtractAndParse(*value); | |
| 97 | |
| 98 // Note: |value| may be NULL, in particular if the callback is for a | |
| 99 // failure. | |
| 100 if (!entry.get()) | |
| 101 LOG(WARNING) << "Invalid entry received on upload."; | |
| 102 } | |
| 103 | |
| 104 return entry.Pass(); | |
| 105 } | |
| 106 | |
| 107 // Extracts the open link url from the JSON Feed. Used by AuthorizeApp(). | |
| 108 void ParseOpenLinkAndRun(const std::string& app_id, | |
| 109 const AuthorizeAppCallback& callback, | |
| 110 GDataErrorCode error, | |
| 111 scoped_ptr<base::Value> value) { | |
| 112 DCHECK(!callback.is_null()); | |
| 113 | |
| 114 if (!value) { | |
| 115 callback.Run(error, GURL()); | |
| 116 return; | |
| 117 } | |
| 118 | |
| 119 // Parsing ResourceEntry is cheap enough to do on UI thread. | |
| 120 scoped_ptr<ResourceEntry> resource_entry = ParseResourceEntry(value.Pass()); | |
| 121 if (!resource_entry) { | |
| 122 callback.Run(GDATA_PARSE_ERROR, GURL()); | |
| 123 return; | |
| 124 } | |
| 125 | |
| 126 // Look for the link to open the file with the app with |app_id|. | |
| 127 const ScopedVector<Link>& resource_links = resource_entry->links(); | |
| 128 GURL open_link; | |
| 129 for (size_t i = 0; i < resource_links.size(); ++i) { | |
| 130 const Link& link = *resource_links[i]; | |
| 131 if (link.type() == Link::LINK_OPEN_WITH && link.app_id() == app_id) { | |
| 132 open_link = link.href(); | |
| 133 break; | |
| 134 } | |
| 135 } | |
| 136 | |
| 137 if (open_link.is_empty()) | |
| 138 error = GDATA_OTHER_ERROR; | |
| 139 | |
| 140 callback.Run(error, open_link); | |
| 141 } | |
| 142 | |
| 143 } // namespace | |
| 144 | |
| 145 //============================ GetResourceListRequest ======================== | |
| 146 | |
| 147 GetResourceListRequest::GetResourceListRequest( | |
| 148 RequestSender* sender, | |
| 149 const GDataWapiUrlGenerator& url_generator, | |
| 150 const GURL& override_url, | |
| 151 int64 start_changestamp, | |
| 152 const std::string& search_string, | |
| 153 const std::string& directory_resource_id, | |
| 154 const GetResourceListCallback& callback) | |
| 155 : GetDataRequest( | |
| 156 sender, | |
| 157 base::Bind(&ParseResourceListAndRun, | |
| 158 make_scoped_refptr(sender->blocking_task_runner()), | |
| 159 callback)), | |
| 160 url_generator_(url_generator), | |
| 161 override_url_(override_url), | |
| 162 start_changestamp_(start_changestamp), | |
| 163 search_string_(search_string), | |
| 164 directory_resource_id_(directory_resource_id) { | |
| 165 DCHECK(!callback.is_null()); | |
| 166 } | |
| 167 | |
| 168 GetResourceListRequest::~GetResourceListRequest() {} | |
| 169 | |
| 170 GURL GetResourceListRequest::GetURL() const { | |
| 171 return url_generator_.GenerateResourceListUrl(override_url_, | |
| 172 start_changestamp_, | |
| 173 search_string_, | |
| 174 directory_resource_id_); | |
| 175 } | |
| 176 | |
| 177 //============================ SearchByTitleRequest ========================== | |
| 178 | |
| 179 SearchByTitleRequest::SearchByTitleRequest( | |
| 180 RequestSender* sender, | |
| 181 const GDataWapiUrlGenerator& url_generator, | |
| 182 const std::string& title, | |
| 183 const std::string& directory_resource_id, | |
| 184 const GetResourceListCallback& callback) | |
| 185 : GetDataRequest( | |
| 186 sender, | |
| 187 base::Bind(&ParseResourceListAndRun, | |
| 188 make_scoped_refptr(sender->blocking_task_runner()), | |
| 189 callback)), | |
| 190 url_generator_(url_generator), | |
| 191 title_(title), | |
| 192 directory_resource_id_(directory_resource_id) { | |
| 193 DCHECK(!callback.is_null()); | |
| 194 } | |
| 195 | |
| 196 SearchByTitleRequest::~SearchByTitleRequest() {} | |
| 197 | |
| 198 GURL SearchByTitleRequest::GetURL() const { | |
| 199 return url_generator_.GenerateSearchByTitleUrl( | |
| 200 title_, directory_resource_id_); | |
| 201 } | |
| 202 | |
| 203 //============================ GetResourceEntryRequest ======================= | 11 //============================ GetResourceEntryRequest ======================= |
| 204 | 12 |
| 205 GetResourceEntryRequest::GetResourceEntryRequest( | 13 GetResourceEntryRequest::GetResourceEntryRequest( |
| 206 RequestSender* sender, | 14 RequestSender* sender, |
| 207 const GDataWapiUrlGenerator& url_generator, | 15 const GDataWapiUrlGenerator& url_generator, |
| 208 const std::string& resource_id, | 16 const std::string& resource_id, |
| 209 const GURL& embed_origin, | 17 const GURL& embed_origin, |
| 210 const GetDataCallback& callback) | 18 const GetDataCallback& callback) |
| 211 : GetDataRequest(sender, callback), | 19 : GetDataRequest(sender, callback), |
| 212 url_generator_(url_generator), | 20 url_generator_(url_generator), |
| 213 resource_id_(resource_id), | 21 resource_id_(resource_id), |
| 214 embed_origin_(embed_origin) { | 22 embed_origin_(embed_origin) { |
| 215 DCHECK(!callback.is_null()); | 23 DCHECK(!callback.is_null()); |
| 216 } | 24 } |
| 217 | 25 |
| 218 GetResourceEntryRequest::~GetResourceEntryRequest() {} | 26 GetResourceEntryRequest::~GetResourceEntryRequest() {} |
| 219 | 27 |
| 220 GURL GetResourceEntryRequest::GetURL() const { | 28 GURL GetResourceEntryRequest::GetURL() const { |
| 221 return url_generator_.GenerateEditUrlWithEmbedOrigin( | 29 return url_generator_.GenerateEditUrlWithEmbedOrigin( |
| 222 resource_id_, embed_origin_); | 30 resource_id_, embed_origin_); |
| 223 } | 31 } |
| 224 | 32 |
| 225 //========================= GetAccountMetadataRequest ======================== | |
| 226 | |
| 227 GetAccountMetadataRequest::GetAccountMetadataRequest( | |
| 228 RequestSender* sender, | |
| 229 const GDataWapiUrlGenerator& url_generator, | |
| 230 const GetAccountMetadataCallback& callback, | |
| 231 bool include_installed_apps) | |
| 232 : GetDataRequest(sender, | |
| 233 base::Bind(&ParseAccounetMetadataAndRun, callback)), | |
| 234 url_generator_(url_generator), | |
| 235 include_installed_apps_(include_installed_apps) { | |
| 236 DCHECK(!callback.is_null()); | |
| 237 } | |
| 238 | |
| 239 GetAccountMetadataRequest::~GetAccountMetadataRequest() {} | |
| 240 | |
| 241 GURL GetAccountMetadataRequest::GetURL() const { | |
| 242 return url_generator_.GenerateAccountMetadataUrl(include_installed_apps_); | |
| 243 } | |
| 244 | |
| 245 //=========================== DeleteResourceRequest ========================== | |
| 246 | |
| 247 DeleteResourceRequest::DeleteResourceRequest( | |
| 248 RequestSender* sender, | |
| 249 const GDataWapiUrlGenerator& url_generator, | |
| 250 const EntryActionCallback& callback, | |
| 251 const std::string& resource_id, | |
| 252 const std::string& etag) | |
| 253 : EntryActionRequest(sender, callback), | |
| 254 url_generator_(url_generator), | |
| 255 resource_id_(resource_id), | |
| 256 etag_(etag) { | |
| 257 DCHECK(!callback.is_null()); | |
| 258 } | |
| 259 | |
| 260 DeleteResourceRequest::~DeleteResourceRequest() {} | |
| 261 | |
| 262 GURL DeleteResourceRequest::GetURL() const { | |
| 263 return url_generator_.GenerateEditUrl(resource_id_); | |
| 264 } | |
| 265 | |
| 266 URLFetcher::RequestType DeleteResourceRequest::GetRequestType() const { | |
| 267 return URLFetcher::DELETE_REQUEST; | |
| 268 } | |
| 269 | |
| 270 std::vector<std::string> | |
| 271 DeleteResourceRequest::GetExtraRequestHeaders() const { | |
| 272 std::vector<std::string> headers; | |
| 273 headers.push_back(util::GenerateIfMatchHeader(etag_)); | |
| 274 return headers; | |
| 275 } | |
| 276 | |
| 277 //========================== CreateDirectoryRequest ========================== | |
| 278 | |
| 279 CreateDirectoryRequest::CreateDirectoryRequest( | |
| 280 RequestSender* sender, | |
| 281 const GDataWapiUrlGenerator& url_generator, | |
| 282 const GetDataCallback& callback, | |
| 283 const std::string& parent_resource_id, | |
| 284 const std::string& directory_title) | |
| 285 : GetDataRequest(sender, callback), | |
| 286 url_generator_(url_generator), | |
| 287 parent_resource_id_(parent_resource_id), | |
| 288 directory_title_(directory_title) { | |
| 289 DCHECK(!callback.is_null()); | |
| 290 } | |
| 291 | |
| 292 CreateDirectoryRequest::~CreateDirectoryRequest() {} | |
| 293 | |
| 294 GURL CreateDirectoryRequest::GetURL() const { | |
| 295 return url_generator_.GenerateContentUrl(parent_resource_id_); | |
| 296 } | |
| 297 | |
| 298 URLFetcher::RequestType | |
| 299 CreateDirectoryRequest::GetRequestType() const { | |
| 300 return URLFetcher::POST; | |
| 301 } | |
| 302 | |
| 303 bool CreateDirectoryRequest::GetContentData(std::string* upload_content_type, | |
| 304 std::string* upload_content) { | |
| 305 upload_content_type->assign("application/atom+xml"); | |
| 306 XmlWriter xml_writer; | |
| 307 xml_writer.StartWriting(); | |
| 308 xml_writer.StartElement("entry"); | |
| 309 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 310 | |
| 311 xml_writer.StartElement("category"); | |
| 312 xml_writer.AddAttribute("scheme", | |
| 313 "http://schemas.google.com/g/2005#kind"); | |
| 314 xml_writer.AddAttribute("term", | |
| 315 "http://schemas.google.com/docs/2007#folder"); | |
| 316 xml_writer.EndElement(); // Ends "category" element. | |
| 317 | |
| 318 xml_writer.WriteElement("title", directory_title_); | |
| 319 | |
| 320 xml_writer.EndElement(); // Ends "entry" element. | |
| 321 xml_writer.StopWriting(); | |
| 322 upload_content->assign(xml_writer.GetWrittenString()); | |
| 323 DVLOG(1) << "CreateDirectory data: " << *upload_content_type << ", [" | |
| 324 << *upload_content << "]"; | |
| 325 return true; | |
| 326 } | |
| 327 | |
| 328 //=========================== RenameResourceRequest ========================== | |
| 329 | |
| 330 RenameResourceRequest::RenameResourceRequest( | |
| 331 RequestSender* sender, | |
| 332 const GDataWapiUrlGenerator& url_generator, | |
| 333 const EntryActionCallback& callback, | |
| 334 const std::string& resource_id, | |
| 335 const std::string& new_title) | |
| 336 : EntryActionRequest(sender, callback), | |
| 337 url_generator_(url_generator), | |
| 338 resource_id_(resource_id), | |
| 339 new_title_(new_title) { | |
| 340 DCHECK(!callback.is_null()); | |
| 341 } | |
| 342 | |
| 343 RenameResourceRequest::~RenameResourceRequest() {} | |
| 344 | |
| 345 URLFetcher::RequestType RenameResourceRequest::GetRequestType() const { | |
| 346 return URLFetcher::PUT; | |
| 347 } | |
| 348 | |
| 349 std::vector<std::string> | |
| 350 RenameResourceRequest::GetExtraRequestHeaders() const { | |
| 351 std::vector<std::string> headers; | |
| 352 headers.push_back(util::kIfMatchAllHeader); | |
| 353 return headers; | |
| 354 } | |
| 355 | |
| 356 GURL RenameResourceRequest::GetURL() const { | |
| 357 return url_generator_.GenerateEditUrl(resource_id_); | |
| 358 } | |
| 359 | |
| 360 bool RenameResourceRequest::GetContentData(std::string* upload_content_type, | |
| 361 std::string* upload_content) { | |
| 362 upload_content_type->assign("application/atom+xml"); | |
| 363 XmlWriter xml_writer; | |
| 364 xml_writer.StartWriting(); | |
| 365 xml_writer.StartElement("entry"); | |
| 366 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 367 | |
| 368 xml_writer.WriteElement("title", new_title_); | |
| 369 | |
| 370 xml_writer.EndElement(); // Ends "entry" element. | |
| 371 xml_writer.StopWriting(); | |
| 372 upload_content->assign(xml_writer.GetWrittenString()); | |
| 373 DVLOG(1) << "RenameResourceRequest data: " << *upload_content_type << ", [" | |
| 374 << *upload_content << "]"; | |
| 375 return true; | |
| 376 } | |
| 377 | |
| 378 //=========================== AuthorizeAppRequest ========================== | |
| 379 | |
| 380 AuthorizeAppRequest::AuthorizeAppRequest( | |
| 381 RequestSender* sender, | |
| 382 const GDataWapiUrlGenerator& url_generator, | |
| 383 const AuthorizeAppCallback& callback, | |
| 384 const std::string& resource_id, | |
| 385 const std::string& app_id) | |
| 386 : GetDataRequest(sender, | |
| 387 base::Bind(&ParseOpenLinkAndRun, app_id, callback)), | |
| 388 url_generator_(url_generator), | |
| 389 resource_id_(resource_id), | |
| 390 app_id_(app_id) { | |
| 391 DCHECK(!callback.is_null()); | |
| 392 } | |
| 393 | |
| 394 AuthorizeAppRequest::~AuthorizeAppRequest() {} | |
| 395 | |
| 396 URLFetcher::RequestType AuthorizeAppRequest::GetRequestType() const { | |
| 397 return URLFetcher::PUT; | |
| 398 } | |
| 399 | |
| 400 std::vector<std::string> | |
| 401 AuthorizeAppRequest::GetExtraRequestHeaders() const { | |
| 402 std::vector<std::string> headers; | |
| 403 headers.push_back(util::kIfMatchAllHeader); | |
| 404 return headers; | |
| 405 } | |
| 406 | |
| 407 bool AuthorizeAppRequest::GetContentData(std::string* upload_content_type, | |
| 408 std::string* upload_content) { | |
| 409 upload_content_type->assign("application/atom+xml"); | |
| 410 XmlWriter xml_writer; | |
| 411 xml_writer.StartWriting(); | |
| 412 xml_writer.StartElement("entry"); | |
| 413 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 414 xml_writer.AddAttribute("xmlns:docs", "http://schemas.google.com/docs/2007"); | |
| 415 xml_writer.WriteElement("docs:authorizedApp", app_id_); | |
| 416 | |
| 417 xml_writer.EndElement(); // Ends "entry" element. | |
| 418 xml_writer.StopWriting(); | |
| 419 upload_content->assign(xml_writer.GetWrittenString()); | |
| 420 DVLOG(1) << "AuthorizeAppRequest data: " << *upload_content_type << ", [" | |
| 421 << *upload_content << "]"; | |
| 422 return true; | |
| 423 } | |
| 424 | |
| 425 GURL AuthorizeAppRequest::GetURL() const { | |
| 426 return url_generator_.GenerateEditUrl(resource_id_); | |
| 427 } | |
| 428 | |
| 429 //======================= AddResourceToDirectoryRequest ====================== | |
| 430 | |
| 431 AddResourceToDirectoryRequest::AddResourceToDirectoryRequest( | |
| 432 RequestSender* sender, | |
| 433 const GDataWapiUrlGenerator& url_generator, | |
| 434 const EntryActionCallback& callback, | |
| 435 const std::string& parent_resource_id, | |
| 436 const std::string& resource_id) | |
| 437 : EntryActionRequest(sender, callback), | |
| 438 url_generator_(url_generator), | |
| 439 parent_resource_id_(parent_resource_id), | |
| 440 resource_id_(resource_id) { | |
| 441 DCHECK(!callback.is_null()); | |
| 442 } | |
| 443 | |
| 444 AddResourceToDirectoryRequest::~AddResourceToDirectoryRequest() {} | |
| 445 | |
| 446 GURL AddResourceToDirectoryRequest::GetURL() const { | |
| 447 return url_generator_.GenerateContentUrl(parent_resource_id_); | |
| 448 } | |
| 449 | |
| 450 URLFetcher::RequestType | |
| 451 AddResourceToDirectoryRequest::GetRequestType() const { | |
| 452 return URLFetcher::POST; | |
| 453 } | |
| 454 | |
| 455 bool AddResourceToDirectoryRequest::GetContentData( | |
| 456 std::string* upload_content_type, std::string* upload_content) { | |
| 457 upload_content_type->assign("application/atom+xml"); | |
| 458 XmlWriter xml_writer; | |
| 459 xml_writer.StartWriting(); | |
| 460 xml_writer.StartElement("entry"); | |
| 461 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 462 | |
| 463 xml_writer.WriteElement( | |
| 464 "id", url_generator_.GenerateEditUrlWithoutParams(resource_id_).spec()); | |
| 465 | |
| 466 xml_writer.EndElement(); // Ends "entry" element. | |
| 467 xml_writer.StopWriting(); | |
| 468 upload_content->assign(xml_writer.GetWrittenString()); | |
| 469 DVLOG(1) << "AddResourceToDirectoryRequest data: " << *upload_content_type | |
| 470 << ", [" << *upload_content << "]"; | |
| 471 return true; | |
| 472 } | |
| 473 | |
| 474 //==================== RemoveResourceFromDirectoryRequest ==================== | |
| 475 | |
| 476 RemoveResourceFromDirectoryRequest::RemoveResourceFromDirectoryRequest( | |
| 477 RequestSender* sender, | |
| 478 const GDataWapiUrlGenerator& url_generator, | |
| 479 const EntryActionCallback& callback, | |
| 480 const std::string& parent_resource_id, | |
| 481 const std::string& document_resource_id) | |
| 482 : EntryActionRequest(sender, callback), | |
| 483 url_generator_(url_generator), | |
| 484 resource_id_(document_resource_id), | |
| 485 parent_resource_id_(parent_resource_id) { | |
| 486 DCHECK(!callback.is_null()); | |
| 487 } | |
| 488 | |
| 489 RemoveResourceFromDirectoryRequest::~RemoveResourceFromDirectoryRequest() { | |
| 490 } | |
| 491 | |
| 492 GURL RemoveResourceFromDirectoryRequest::GetURL() const { | |
| 493 return url_generator_.GenerateResourceUrlForRemoval( | |
| 494 parent_resource_id_, resource_id_); | |
| 495 } | |
| 496 | |
| 497 URLFetcher::RequestType | |
| 498 RemoveResourceFromDirectoryRequest::GetRequestType() const { | |
| 499 return URLFetcher::DELETE_REQUEST; | |
| 500 } | |
| 501 | |
| 502 std::vector<std::string> | |
| 503 RemoveResourceFromDirectoryRequest::GetExtraRequestHeaders() const { | |
| 504 std::vector<std::string> headers; | |
| 505 headers.push_back(util::kIfMatchAllHeader); | |
| 506 return headers; | |
| 507 } | |
| 508 | |
| 509 //======================= InitiateUploadNewFileRequest ======================= | |
| 510 | |
| 511 InitiateUploadNewFileRequest::InitiateUploadNewFileRequest( | |
| 512 RequestSender* sender, | |
| 513 const GDataWapiUrlGenerator& url_generator, | |
| 514 const InitiateUploadCallback& callback, | |
| 515 const std::string& content_type, | |
| 516 int64 content_length, | |
| 517 const std::string& parent_resource_id, | |
| 518 const std::string& title) | |
| 519 : InitiateUploadRequestBase(sender, callback, content_type, content_length), | |
| 520 url_generator_(url_generator), | |
| 521 parent_resource_id_(parent_resource_id), | |
| 522 title_(title) { | |
| 523 } | |
| 524 | |
| 525 InitiateUploadNewFileRequest::~InitiateUploadNewFileRequest() {} | |
| 526 | |
| 527 GURL InitiateUploadNewFileRequest::GetURL() const { | |
| 528 return url_generator_.GenerateInitiateUploadNewFileUrl(parent_resource_id_); | |
| 529 } | |
| 530 | |
| 531 net::URLFetcher::RequestType | |
| 532 InitiateUploadNewFileRequest::GetRequestType() const { | |
| 533 return net::URLFetcher::POST; | |
| 534 } | |
| 535 | |
| 536 bool InitiateUploadNewFileRequest::GetContentData( | |
| 537 std::string* upload_content_type, | |
| 538 std::string* upload_content) { | |
| 539 upload_content_type->assign("application/atom+xml"); | |
| 540 XmlWriter xml_writer; | |
| 541 xml_writer.StartWriting(); | |
| 542 xml_writer.StartElement("entry"); | |
| 543 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 544 xml_writer.AddAttribute("xmlns:docs", | |
| 545 "http://schemas.google.com/docs/2007"); | |
| 546 xml_writer.WriteElement("title", title_); | |
| 547 xml_writer.EndElement(); // Ends "entry" element. | |
| 548 xml_writer.StopWriting(); | |
| 549 upload_content->assign(xml_writer.GetWrittenString()); | |
| 550 DVLOG(1) << "InitiateUploadNewFile: " << *upload_content_type << ", [" | |
| 551 << *upload_content << "]"; | |
| 552 return true; | |
| 553 } | |
| 554 | |
| 555 //===================== InitiateUploadExistingFileRequest ==================== | |
| 556 | |
| 557 InitiateUploadExistingFileRequest::InitiateUploadExistingFileRequest( | |
| 558 RequestSender* sender, | |
| 559 const GDataWapiUrlGenerator& url_generator, | |
| 560 const InitiateUploadCallback& callback, | |
| 561 const std::string& content_type, | |
| 562 int64 content_length, | |
| 563 const std::string& resource_id, | |
| 564 const std::string& etag) | |
| 565 : InitiateUploadRequestBase(sender, callback, content_type, content_length), | |
| 566 url_generator_(url_generator), | |
| 567 resource_id_(resource_id), | |
| 568 etag_(etag) { | |
| 569 } | |
| 570 | |
| 571 InitiateUploadExistingFileRequest::~InitiateUploadExistingFileRequest() {} | |
| 572 | |
| 573 GURL InitiateUploadExistingFileRequest::GetURL() const { | |
| 574 return url_generator_.GenerateInitiateUploadExistingFileUrl(resource_id_); | |
| 575 } | |
| 576 | |
| 577 net::URLFetcher::RequestType | |
| 578 InitiateUploadExistingFileRequest::GetRequestType() const { | |
| 579 return net::URLFetcher::PUT; | |
| 580 } | |
| 581 | |
| 582 bool InitiateUploadExistingFileRequest::GetContentData( | |
| 583 std::string* upload_content_type, | |
| 584 std::string* upload_content) { | |
| 585 // According to the document there is no need to send the content-type. | |
| 586 // However, the server would return 500 server error without the | |
| 587 // content-type. | |
| 588 // As its workaround, send "text/plain" content-type here. | |
| 589 *upload_content_type = "text/plain"; | |
| 590 *upload_content = ""; | |
| 591 return true; | |
| 592 } | |
| 593 | |
| 594 std::vector<std::string> | |
| 595 InitiateUploadExistingFileRequest::GetExtraRequestHeaders() const { | |
| 596 std::vector<std::string> headers( | |
| 597 InitiateUploadRequestBase::GetExtraRequestHeaders()); | |
| 598 headers.push_back(util::GenerateIfMatchHeader(etag_)); | |
| 599 return headers; | |
| 600 } | |
| 601 | |
| 602 //============================ ResumeUploadRequest =========================== | |
| 603 | |
| 604 ResumeUploadRequest::ResumeUploadRequest( | |
| 605 RequestSender* sender, | |
| 606 const UploadRangeCallback& callback, | |
| 607 const ProgressCallback& progress_callback, | |
| 608 const GURL& upload_location, | |
| 609 int64 start_position, | |
| 610 int64 end_position, | |
| 611 int64 content_length, | |
| 612 const std::string& content_type, | |
| 613 const base::FilePath& local_file_path) | |
| 614 : ResumeUploadRequestBase(sender, | |
| 615 upload_location, | |
| 616 start_position, | |
| 617 end_position, | |
| 618 content_length, | |
| 619 content_type, | |
| 620 local_file_path), | |
| 621 callback_(callback), | |
| 622 progress_callback_(progress_callback) { | |
| 623 DCHECK(!callback_.is_null()); | |
| 624 } | |
| 625 | |
| 626 ResumeUploadRequest::~ResumeUploadRequest() {} | |
| 627 | |
| 628 void ResumeUploadRequest::OnRangeRequestComplete( | |
| 629 const UploadRangeResponse& response, scoped_ptr<base::Value> value) { | |
| 630 callback_.Run(response, ParseResourceEntry(value.Pass())); | |
| 631 } | |
| 632 | |
| 633 void ResumeUploadRequest::OnURLFetchUploadProgress( | |
| 634 const URLFetcher* source, int64 current, int64 total) { | |
| 635 if (!progress_callback_.is_null()) | |
| 636 progress_callback_.Run(current, total); | |
| 637 } | |
| 638 | |
| 639 //========================== GetUploadStatusRequest ========================== | |
| 640 | |
| 641 GetUploadStatusRequest::GetUploadStatusRequest( | |
| 642 RequestSender* sender, | |
| 643 const UploadRangeCallback& callback, | |
| 644 const GURL& upload_url, | |
| 645 int64 content_length) | |
| 646 : GetUploadStatusRequestBase(sender, upload_url, content_length), | |
| 647 callback_(callback) { | |
| 648 DCHECK(!callback.is_null()); | |
| 649 } | |
| 650 | |
| 651 GetUploadStatusRequest::~GetUploadStatusRequest() {} | |
| 652 | |
| 653 void GetUploadStatusRequest::OnRangeRequestComplete( | |
| 654 const UploadRangeResponse& response, scoped_ptr<base::Value> value) { | |
| 655 callback_.Run(response, ParseResourceEntry(value.Pass())); | |
| 656 } | |
| 657 | |
| 658 //========================== DownloadFileRequest ========================== | |
| 659 | |
| 660 DownloadFileRequest::DownloadFileRequest( | |
| 661 RequestSender* sender, | |
| 662 const GDataWapiUrlGenerator& url_generator, | |
| 663 const DownloadActionCallback& download_action_callback, | |
| 664 const GetContentCallback& get_content_callback, | |
| 665 const ProgressCallback& progress_callback, | |
| 666 const std::string& resource_id, | |
| 667 const base::FilePath& output_file_path) | |
| 668 : DownloadFileRequestBase( | |
| 669 sender, | |
| 670 download_action_callback, | |
| 671 get_content_callback, | |
| 672 progress_callback, | |
| 673 url_generator.GenerateDownloadFileUrl(resource_id), | |
| 674 output_file_path) { | |
| 675 } | |
| 676 | |
| 677 DownloadFileRequest::~DownloadFileRequest() { | |
| 678 } | |
| 679 | |
| 680 } // namespace google_apis | 33 } // namespace google_apis |
| OLD | NEW |