| OLD | NEW |
|---|
| (Empty) |
| 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/google_apis/gdata_wapi_requests.h" | |
| 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 "chrome/browser/google_apis/gdata_wapi_parser.h" | |
| 12 #include "chrome/browser/google_apis/gdata_wapi_url_generator.h" | |
| 13 #include "chrome/browser/google_apis/request_sender.h" | |
| 14 #include "chrome/browser/google_apis/request_util.h" | |
| 15 #include "third_party/libxml/chromium/libxml_utils.h" | |
| 16 | |
| 17 using net::URLFetcher; | |
| 18 | |
| 19 namespace google_apis { | |
| 20 | |
| 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 ======================= | |
| 204 | |
| 205 GetResourceEntryRequest::GetResourceEntryRequest( | |
| 206 RequestSender* sender, | |
| 207 const GDataWapiUrlGenerator& url_generator, | |
| 208 const std::string& resource_id, | |
| 209 const GURL& embed_origin, | |
| 210 const GetDataCallback& callback) | |
| 211 : GetDataRequest(sender, callback), | |
| 212 url_generator_(url_generator), | |
| 213 resource_id_(resource_id), | |
| 214 embed_origin_(embed_origin) { | |
| 215 DCHECK(!callback.is_null()); | |
| 216 } | |
| 217 | |
| 218 GetResourceEntryRequest::~GetResourceEntryRequest() {} | |
| 219 | |
| 220 GURL GetResourceEntryRequest::GetURL() const { | |
| 221 return url_generator_.GenerateEditUrlWithEmbedOrigin( | |
| 222 resource_id_, embed_origin_); | |
| 223 } | |
| 224 | |
| 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 //============================ CopyHostedDocumentRequest ===================== | |
| 329 | |
| 330 CopyHostedDocumentRequest::CopyHostedDocumentRequest( | |
| 331 RequestSender* sender, | |
| 332 const GDataWapiUrlGenerator& url_generator, | |
| 333 const GetDataCallback& callback, | |
| 334 const std::string& resource_id, | |
| 335 const std::string& new_title) | |
| 336 : GetDataRequest(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 CopyHostedDocumentRequest::~CopyHostedDocumentRequest() {} | |
| 344 | |
| 345 URLFetcher::RequestType CopyHostedDocumentRequest::GetRequestType() const { | |
| 346 return URLFetcher::POST; | |
| 347 } | |
| 348 | |
| 349 GURL CopyHostedDocumentRequest::GetURL() const { | |
| 350 return url_generator_.GenerateResourceListRootUrl(); | |
| 351 } | |
| 352 | |
| 353 bool CopyHostedDocumentRequest::GetContentData( | |
| 354 std::string* upload_content_type, | |
| 355 std::string* upload_content) { | |
| 356 upload_content_type->assign("application/atom+xml"); | |
| 357 XmlWriter xml_writer; | |
| 358 xml_writer.StartWriting(); | |
| 359 xml_writer.StartElement("entry"); | |
| 360 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 361 | |
| 362 xml_writer.WriteElement("id", resource_id_); | |
| 363 xml_writer.WriteElement("title", new_title_); | |
| 364 | |
| 365 xml_writer.EndElement(); // Ends "entry" element. | |
| 366 xml_writer.StopWriting(); | |
| 367 upload_content->assign(xml_writer.GetWrittenString()); | |
| 368 DVLOG(1) << "CopyHostedDocumentRequest data: " << *upload_content_type | |
| 369 << ", [" << *upload_content << "]"; | |
| 370 return true; | |
| 371 } | |
| 372 | |
| 373 //=========================== RenameResourceRequest ========================== | |
| 374 | |
| 375 RenameResourceRequest::RenameResourceRequest( | |
| 376 RequestSender* sender, | |
| 377 const GDataWapiUrlGenerator& url_generator, | |
| 378 const EntryActionCallback& callback, | |
| 379 const std::string& resource_id, | |
| 380 const std::string& new_title) | |
| 381 : EntryActionRequest(sender, callback), | |
| 382 url_generator_(url_generator), | |
| 383 resource_id_(resource_id), | |
| 384 new_title_(new_title) { | |
| 385 DCHECK(!callback.is_null()); | |
| 386 } | |
| 387 | |
| 388 RenameResourceRequest::~RenameResourceRequest() {} | |
| 389 | |
| 390 URLFetcher::RequestType RenameResourceRequest::GetRequestType() const { | |
| 391 return URLFetcher::PUT; | |
| 392 } | |
| 393 | |
| 394 std::vector<std::string> | |
| 395 RenameResourceRequest::GetExtraRequestHeaders() const { | |
| 396 std::vector<std::string> headers; | |
| 397 headers.push_back(util::kIfMatchAllHeader); | |
| 398 return headers; | |
| 399 } | |
| 400 | |
| 401 GURL RenameResourceRequest::GetURL() const { | |
| 402 return url_generator_.GenerateEditUrl(resource_id_); | |
| 403 } | |
| 404 | |
| 405 bool RenameResourceRequest::GetContentData(std::string* upload_content_type, | |
| 406 std::string* upload_content) { | |
| 407 upload_content_type->assign("application/atom+xml"); | |
| 408 XmlWriter xml_writer; | |
| 409 xml_writer.StartWriting(); | |
| 410 xml_writer.StartElement("entry"); | |
| 411 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 412 | |
| 413 xml_writer.WriteElement("title", new_title_); | |
| 414 | |
| 415 xml_writer.EndElement(); // Ends "entry" element. | |
| 416 xml_writer.StopWriting(); | |
| 417 upload_content->assign(xml_writer.GetWrittenString()); | |
| 418 DVLOG(1) << "RenameResourceRequest data: " << *upload_content_type << ", [" | |
| 419 << *upload_content << "]"; | |
| 420 return true; | |
| 421 } | |
| 422 | |
| 423 //=========================== AuthorizeAppRequest ========================== | |
| 424 | |
| 425 AuthorizeAppRequest::AuthorizeAppRequest( | |
| 426 RequestSender* sender, | |
| 427 const GDataWapiUrlGenerator& url_generator, | |
| 428 const AuthorizeAppCallback& callback, | |
| 429 const std::string& resource_id, | |
| 430 const std::string& app_id) | |
| 431 : GetDataRequest(sender, | |
| 432 base::Bind(&ParseOpenLinkAndRun, app_id, callback)), | |
| 433 url_generator_(url_generator), | |
| 434 resource_id_(resource_id), | |
| 435 app_id_(app_id) { | |
| 436 DCHECK(!callback.is_null()); | |
| 437 } | |
| 438 | |
| 439 AuthorizeAppRequest::~AuthorizeAppRequest() {} | |
| 440 | |
| 441 URLFetcher::RequestType AuthorizeAppRequest::GetRequestType() const { | |
| 442 return URLFetcher::PUT; | |
| 443 } | |
| 444 | |
| 445 std::vector<std::string> | |
| 446 AuthorizeAppRequest::GetExtraRequestHeaders() const { | |
| 447 std::vector<std::string> headers; | |
| 448 headers.push_back(util::kIfMatchAllHeader); | |
| 449 return headers; | |
| 450 } | |
| 451 | |
| 452 bool AuthorizeAppRequest::GetContentData(std::string* upload_content_type, | |
| 453 std::string* upload_content) { | |
| 454 upload_content_type->assign("application/atom+xml"); | |
| 455 XmlWriter xml_writer; | |
| 456 xml_writer.StartWriting(); | |
| 457 xml_writer.StartElement("entry"); | |
| 458 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 459 xml_writer.AddAttribute("xmlns:docs", "http://schemas.google.com/docs/2007"); | |
| 460 xml_writer.WriteElement("docs:authorizedApp", app_id_); | |
| 461 | |
| 462 xml_writer.EndElement(); // Ends "entry" element. | |
| 463 xml_writer.StopWriting(); | |
| 464 upload_content->assign(xml_writer.GetWrittenString()); | |
| 465 DVLOG(1) << "AuthorizeAppRequest data: " << *upload_content_type << ", [" | |
| 466 << *upload_content << "]"; | |
| 467 return true; | |
| 468 } | |
| 469 | |
| 470 GURL AuthorizeAppRequest::GetURL() const { | |
| 471 return url_generator_.GenerateEditUrl(resource_id_); | |
| 472 } | |
| 473 | |
| 474 //======================= AddResourceToDirectoryRequest ====================== | |
| 475 | |
| 476 AddResourceToDirectoryRequest::AddResourceToDirectoryRequest( | |
| 477 RequestSender* sender, | |
| 478 const GDataWapiUrlGenerator& url_generator, | |
| 479 const EntryActionCallback& callback, | |
| 480 const std::string& parent_resource_id, | |
| 481 const std::string& resource_id) | |
| 482 : EntryActionRequest(sender, callback), | |
| 483 url_generator_(url_generator), | |
| 484 parent_resource_id_(parent_resource_id), | |
| 485 resource_id_(resource_id) { | |
| 486 DCHECK(!callback.is_null()); | |
| 487 } | |
| 488 | |
| 489 AddResourceToDirectoryRequest::~AddResourceToDirectoryRequest() {} | |
| 490 | |
| 491 GURL AddResourceToDirectoryRequest::GetURL() const { | |
| 492 return url_generator_.GenerateContentUrl(parent_resource_id_); | |
| 493 } | |
| 494 | |
| 495 URLFetcher::RequestType | |
| 496 AddResourceToDirectoryRequest::GetRequestType() const { | |
| 497 return URLFetcher::POST; | |
| 498 } | |
| 499 | |
| 500 bool AddResourceToDirectoryRequest::GetContentData( | |
| 501 std::string* upload_content_type, std::string* upload_content) { | |
| 502 upload_content_type->assign("application/atom+xml"); | |
| 503 XmlWriter xml_writer; | |
| 504 xml_writer.StartWriting(); | |
| 505 xml_writer.StartElement("entry"); | |
| 506 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 507 | |
| 508 xml_writer.WriteElement( | |
| 509 "id", url_generator_.GenerateEditUrlWithoutParams(resource_id_).spec()); | |
| 510 | |
| 511 xml_writer.EndElement(); // Ends "entry" element. | |
| 512 xml_writer.StopWriting(); | |
| 513 upload_content->assign(xml_writer.GetWrittenString()); | |
| 514 DVLOG(1) << "AddResourceToDirectoryRequest data: " << *upload_content_type | |
| 515 << ", [" << *upload_content << "]"; | |
| 516 return true; | |
| 517 } | |
| 518 | |
| 519 //==================== RemoveResourceFromDirectoryRequest ==================== | |
| 520 | |
| 521 RemoveResourceFromDirectoryRequest::RemoveResourceFromDirectoryRequest( | |
| 522 RequestSender* sender, | |
| 523 const GDataWapiUrlGenerator& url_generator, | |
| 524 const EntryActionCallback& callback, | |
| 525 const std::string& parent_resource_id, | |
| 526 const std::string& document_resource_id) | |
| 527 : EntryActionRequest(sender, callback), | |
| 528 url_generator_(url_generator), | |
| 529 resource_id_(document_resource_id), | |
| 530 parent_resource_id_(parent_resource_id) { | |
| 531 DCHECK(!callback.is_null()); | |
| 532 } | |
| 533 | |
| 534 RemoveResourceFromDirectoryRequest::~RemoveResourceFromDirectoryRequest() { | |
| 535 } | |
| 536 | |
| 537 GURL RemoveResourceFromDirectoryRequest::GetURL() const { | |
| 538 return url_generator_.GenerateResourceUrlForRemoval( | |
| 539 parent_resource_id_, resource_id_); | |
| 540 } | |
| 541 | |
| 542 URLFetcher::RequestType | |
| 543 RemoveResourceFromDirectoryRequest::GetRequestType() const { | |
| 544 return URLFetcher::DELETE_REQUEST; | |
| 545 } | |
| 546 | |
| 547 std::vector<std::string> | |
| 548 RemoveResourceFromDirectoryRequest::GetExtraRequestHeaders() const { | |
| 549 std::vector<std::string> headers; | |
| 550 headers.push_back(util::kIfMatchAllHeader); | |
| 551 return headers; | |
| 552 } | |
| 553 | |
| 554 //======================= InitiateUploadNewFileRequest ======================= | |
| 555 | |
| 556 InitiateUploadNewFileRequest::InitiateUploadNewFileRequest( | |
| 557 RequestSender* sender, | |
| 558 const GDataWapiUrlGenerator& url_generator, | |
| 559 const InitiateUploadCallback& callback, | |
| 560 const std::string& content_type, | |
| 561 int64 content_length, | |
| 562 const std::string& parent_resource_id, | |
| 563 const std::string& title) | |
| 564 : InitiateUploadRequestBase(sender, callback, content_type, content_length), | |
| 565 url_generator_(url_generator), | |
| 566 parent_resource_id_(parent_resource_id), | |
| 567 title_(title) { | |
| 568 } | |
| 569 | |
| 570 InitiateUploadNewFileRequest::~InitiateUploadNewFileRequest() {} | |
| 571 | |
| 572 GURL InitiateUploadNewFileRequest::GetURL() const { | |
| 573 return url_generator_.GenerateInitiateUploadNewFileUrl(parent_resource_id_); | |
| 574 } | |
| 575 | |
| 576 net::URLFetcher::RequestType | |
| 577 InitiateUploadNewFileRequest::GetRequestType() const { | |
| 578 return net::URLFetcher::POST; | |
| 579 } | |
| 580 | |
| 581 bool InitiateUploadNewFileRequest::GetContentData( | |
| 582 std::string* upload_content_type, | |
| 583 std::string* upload_content) { | |
| 584 upload_content_type->assign("application/atom+xml"); | |
| 585 XmlWriter xml_writer; | |
| 586 xml_writer.StartWriting(); | |
| 587 xml_writer.StartElement("entry"); | |
| 588 xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom"); | |
| 589 xml_writer.AddAttribute("xmlns:docs", | |
| 590 "http://schemas.google.com/docs/2007"); | |
| 591 xml_writer.WriteElement("title", title_); | |
| 592 xml_writer.EndElement(); // Ends "entry" element. | |
| 593 xml_writer.StopWriting(); | |
| 594 upload_content->assign(xml_writer.GetWrittenString()); | |
| 595 DVLOG(1) << "InitiateUploadNewFile: " << *upload_content_type << ", [" | |
| 596 << *upload_content << "]"; | |
| 597 return true; | |
| 598 } | |
| 599 | |
| 600 //===================== InitiateUploadExistingFileRequest ==================== | |
| 601 | |
| 602 InitiateUploadExistingFileRequest::InitiateUploadExistingFileRequest( | |
| 603 RequestSender* sender, | |
| 604 const GDataWapiUrlGenerator& url_generator, | |
| 605 const InitiateUploadCallback& callback, | |
| 606 const std::string& content_type, | |
| 607 int64 content_length, | |
| 608 const std::string& resource_id, | |
| 609 const std::string& etag) | |
| 610 : InitiateUploadRequestBase(sender, callback, content_type, content_length), | |
| 611 url_generator_(url_generator), | |
| 612 resource_id_(resource_id), | |
| 613 etag_(etag) { | |
| 614 } | |
| 615 | |
| 616 InitiateUploadExistingFileRequest::~InitiateUploadExistingFileRequest() {} | |
| 617 | |
| 618 GURL InitiateUploadExistingFileRequest::GetURL() const { | |
| 619 return url_generator_.GenerateInitiateUploadExistingFileUrl(resource_id_); | |
| 620 } | |
| 621 | |
| 622 net::URLFetcher::RequestType | |
| 623 InitiateUploadExistingFileRequest::GetRequestType() const { | |
| 624 return net::URLFetcher::PUT; | |
| 625 } | |
| 626 | |
| 627 bool InitiateUploadExistingFileRequest::GetContentData( | |
| 628 std::string* upload_content_type, | |
| 629 std::string* upload_content) { | |
| 630 // According to the document there is no need to send the content-type. | |
| 631 // However, the server would return 500 server error without the | |
| 632 // content-type. | |
| 633 // As its workaround, send "text/plain" content-type here. | |
| 634 *upload_content_type = "text/plain"; | |
| 635 *upload_content = ""; | |
| 636 return true; | |
| 637 } | |
| 638 | |
| 639 std::vector<std::string> | |
| 640 InitiateUploadExistingFileRequest::GetExtraRequestHeaders() const { | |
| 641 std::vector<std::string> headers( | |
| 642 InitiateUploadRequestBase::GetExtraRequestHeaders()); | |
| 643 headers.push_back(util::GenerateIfMatchHeader(etag_)); | |
| 644 return headers; | |
| 645 } | |
| 646 | |
| 647 //============================ ResumeUploadRequest =========================== | |
| 648 | |
| 649 ResumeUploadRequest::ResumeUploadRequest( | |
| 650 RequestSender* sender, | |
| 651 const UploadRangeCallback& callback, | |
| 652 const ProgressCallback& progress_callback, | |
| 653 const GURL& upload_location, | |
| 654 int64 start_position, | |
| 655 int64 end_position, | |
| 656 int64 content_length, | |
| 657 const std::string& content_type, | |
| 658 const base::FilePath& local_file_path) | |
| 659 : ResumeUploadRequestBase(sender, | |
| 660 upload_location, | |
| 661 start_position, | |
| 662 end_position, | |
| 663 content_length, | |
| 664 content_type, | |
| 665 local_file_path), | |
| 666 callback_(callback), | |
| 667 progress_callback_(progress_callback) { | |
| 668 DCHECK(!callback_.is_null()); | |
| 669 } | |
| 670 | |
| 671 ResumeUploadRequest::~ResumeUploadRequest() {} | |
| 672 | |
| 673 void ResumeUploadRequest::OnRangeRequestComplete( | |
| 674 const UploadRangeResponse& response, scoped_ptr<base::Value> value) { | |
| 675 callback_.Run(response, ParseResourceEntry(value.Pass())); | |
| 676 } | |
| 677 | |
| 678 void ResumeUploadRequest::OnURLFetchUploadProgress( | |
| 679 const URLFetcher* source, int64 current, int64 total) { | |
| 680 if (!progress_callback_.is_null()) | |
| 681 progress_callback_.Run(current, total); | |
| 682 } | |
| 683 | |
| 684 //========================== GetUploadStatusRequest ========================== | |
| 685 | |
| 686 GetUploadStatusRequest::GetUploadStatusRequest( | |
| 687 RequestSender* sender, | |
| 688 const UploadRangeCallback& callback, | |
| 689 const GURL& upload_url, | |
| 690 int64 content_length) | |
| 691 : GetUploadStatusRequestBase(sender, upload_url, content_length), | |
| 692 callback_(callback) { | |
| 693 DCHECK(!callback.is_null()); | |
| 694 } | |
| 695 | |
| 696 GetUploadStatusRequest::~GetUploadStatusRequest() {} | |
| 697 | |
| 698 void GetUploadStatusRequest::OnRangeRequestComplete( | |
| 699 const UploadRangeResponse& response, scoped_ptr<base::Value> value) { | |
| 700 callback_.Run(response, ParseResourceEntry(value.Pass())); | |
| 701 } | |
| 702 | |
| 703 //========================== DownloadFileRequest ========================== | |
| 704 | |
| 705 DownloadFileRequest::DownloadFileRequest( | |
| 706 RequestSender* sender, | |
| 707 const GDataWapiUrlGenerator& url_generator, | |
| 708 const DownloadActionCallback& download_action_callback, | |
| 709 const GetContentCallback& get_content_callback, | |
| 710 const ProgressCallback& progress_callback, | |
| 711 const std::string& resource_id, | |
| 712 const base::FilePath& output_file_path) | |
| 713 : DownloadFileRequestBase( | |
| 714 sender, | |
| 715 download_action_callback, | |
| 716 get_content_callback, | |
| 717 progress_callback, | |
| 718 url_generator.GenerateDownloadFileUrl(resource_id), | |
| 719 output_file_path) { | |
| 720 } | |
| 721 | |
| 722 DownloadFileRequest::~DownloadFileRequest() { | |
| 723 } | |
| 724 | |
| 725 } // namespace google_apis | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 96413002:
Move c/b/google_apis to google_apis/drive. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src