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_uploader.h" 6 7 #include <algorithm> 8 9 #include "base/bind.h" 10 #include "base/callback.h" 11 #include "base/file_util.h" 12 #include "base/strings/string_number_conversions.h" 13 #include "base/task_runner_util.h" 14 #include "chrome/browser/drive/drive_service_interface.h" 15 #include "content/public/browser/browser_thread.h" 16 #include "content/public/browser/power_save_blocker.h" 17 #include "google_apis/drive/gdata_wapi_parser.h" 18 19 using content::BrowserThread; 20 using google_apis::CancelCallback; 21 using google_apis::GDATA_CANCELLED; 22 using google_apis::GDataErrorCode; 23 using google_apis::GDATA_NO_SPACE; 24 using google_apis::HTTP_CONFLICT; 25 using google_apis::HTTP_CREATED; 26 using google_apis::HTTP_FORBIDDEN; 27 using google_apis::HTTP_NOT_FOUND; 28 using google_apis::HTTP_PRECONDITION; 29 using google_apis::HTTP_RESUME_INCOMPLETE; 30 using google_apis::HTTP_SUCCESS; 31 using google_apis::ProgressCallback; 32 using google_apis::ResourceEntry; 33 using google_apis::UploadRangeResponse; 34 35 namespace drive { 36 37 namespace { 38 // Upload data is split to multiple HTTP request each conveying kUploadChunkSize 39 // bytes (except the request for uploading the last chunk of data). 40 // The value must be a multiple of 512KB according to the spec of GData WAPI and 41 // Drive API v2. It is set to a smaller value than 2^31 for working around 42 // server side error (crbug.com/264089). 43 const int64 kUploadChunkSize = (1LL << 30); // 1GB 44 } // namespace 45 46 // Structure containing current upload information of file, passed between 47 // DriveServiceInterface methods and callbacks. 48 struct DriveUploader::UploadFileInfo { 49 UploadFileInfo(const base::FilePath& local_path, 50 const std::string& content_type, 51 const UploadCompletionCallback& callback, 52 const ProgressCallback& progress_callback) 53 : file_path(local_path), 54 content_type(content_type), 55 completion_callback(callback), 56 progress_callback(progress_callback), 57 content_length(0), 58 next_start_position(-1), 59 power_save_blocker(content::PowerSaveBlocker::Create( 60 content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension, 61 "Upload in progress")), 62 cancelled(false), 63 weak_ptr_factory_(this) { 64 } 65 66 ~UploadFileInfo() { 67 } 68 69 // Useful for printf debugging. 70 std::string DebugString() const { 71 return "file_path=[" + file_path.AsUTF8Unsafe() + 72 "], content_type=[" + content_type + 73 "], content_length=[" + base::UintToString(content_length) + 74 "]"; 75 } 76 77 // Returns the callback to cancel the upload represented by this struct. 78 CancelCallback GetCancelCallback() { 79 return base::Bind(&UploadFileInfo::Cancel, weak_ptr_factory_.GetWeakPtr()); 80 } 81 82 // The local file path of the file to be uploaded. 83 const base::FilePath file_path; 84 85 // Content-Type of file. 86 const std::string content_type; 87 88 // Callback to be invoked once the upload has finished. 89 const UploadCompletionCallback completion_callback; 90 91 // Callback to periodically notify the upload progress. 92 const ProgressCallback progress_callback; 93 94 // Location URL where file is to be uploaded to, returned from 95 // InitiateUpload. Used for the subsequent ResumeUpload requests. 96 GURL upload_location; 97 98 // Header content-Length. 99 int64 content_length; 100 101 int64 next_start_position; 102 103 // Blocks system suspend while upload is in progress. 104 scoped_ptr<content::PowerSaveBlocker> power_save_blocker; 105 106 // Fields for implementing cancellation. |cancel_callback| is non-null if 107 // there is an in-flight HTTP request. In that case, |cancell_callback| will 108 // cancel the operation. |cancelled| is initially false and turns to true 109 // once Cancel() is called. DriveUploader will check this field before after 110 // an async task other than HTTP requests and cancels the subsequent requests 111 // if this is flagged to true. 112 CancelCallback cancel_callback; 113 bool cancelled; 114 115 private: 116 // Cancels the upload represented by this struct. 117 void Cancel() { 118 cancelled = true; 119 if (!cancel_callback.is_null()) 120 cancel_callback.Run(); 121 } 122 123 base::WeakPtrFactory<UploadFileInfo> weak_ptr_factory_; 124 DISALLOW_COPY_AND_ASSIGN(UploadFileInfo); 125 }; 126 127 DriveUploader::DriveUploader(DriveServiceInterface* drive_service, 128 base::TaskRunner* blocking_task_runner) 129 : drive_service_(drive_service), 130 blocking_task_runner_(blocking_task_runner), 131 weak_ptr_factory_(this) { 132 } 133 134 DriveUploader::~DriveUploader() {} 135 136 CancelCallback DriveUploader::UploadNewFile( 137 const std::string& parent_resource_id, 138 const base::FilePath& local_file_path, 139 const std::string& title, 140 const std::string& content_type, 141 const UploadCompletionCallback& callback, 142 const ProgressCallback& progress_callback) { 143 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 144 DCHECK(!parent_resource_id.empty()); 145 DCHECK(!local_file_path.empty()); 146 DCHECK(!title.empty()); 147 DCHECK(!content_type.empty()); 148 DCHECK(!callback.is_null()); 149 150 return StartUploadFile( 151 scoped_ptr<UploadFileInfo>(new UploadFileInfo(local_file_path, 152 content_type, 153 callback, 154 progress_callback)), 155 base::Bind(&DriveUploader::StartInitiateUploadNewFile, 156 weak_ptr_factory_.GetWeakPtr(), 157 parent_resource_id, 158 title)); 159 } 160 161 CancelCallback DriveUploader::UploadExistingFile( 162 const std::string& resource_id, 163 const base::FilePath& local_file_path, 164 const std::string& content_type, 165 const std::string& etag, 166 const UploadCompletionCallback& callback, 167 const ProgressCallback& progress_callback) { 168 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 169 DCHECK(!resource_id.empty()); 170 DCHECK(!local_file_path.empty()); 171 DCHECK(!content_type.empty()); 172 DCHECK(!callback.is_null()); 173 174 return StartUploadFile( 175 scoped_ptr<UploadFileInfo>(new UploadFileInfo(local_file_path, 176 content_type, 177 callback, 178 progress_callback)), 179 base::Bind(&DriveUploader::StartInitiateUploadExistingFile, 180 weak_ptr_factory_.GetWeakPtr(), 181 resource_id, 182 etag)); 183 } 184 185 CancelCallback DriveUploader::ResumeUploadFile( 186 const GURL& upload_location, 187 const base::FilePath& local_file_path, 188 const std::string& content_type, 189 const UploadCompletionCallback& callback, 190 const ProgressCallback& progress_callback) { 191 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 192 DCHECK(!local_file_path.empty()); 193 DCHECK(!content_type.empty()); 194 DCHECK(!callback.is_null()); 195 196 scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo( 197 local_file_path, content_type, 198 callback, progress_callback)); 199 upload_file_info->upload_location = upload_location; 200 201 return StartUploadFile( 202 upload_file_info.Pass(), 203 base::Bind(&DriveUploader::StartGetUploadStatus, 204 weak_ptr_factory_.GetWeakPtr())); 205 } 206 207 CancelCallback DriveUploader::StartUploadFile( 208 scoped_ptr<UploadFileInfo> upload_file_info, 209 const StartInitiateUploadCallback& start_initiate_upload_callback) { 210 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 211 DVLOG(1) << "Uploading file: " << upload_file_info->DebugString(); 212 213 UploadFileInfo* info_ptr = upload_file_info.get(); 214 base::PostTaskAndReplyWithResult( 215 blocking_task_runner_.get(), 216 FROM_HERE, 217 base::Bind(&base::GetFileSize, 218 info_ptr->file_path, 219 &info_ptr->content_length), 220 base::Bind(&DriveUploader::StartUploadFileAfterGetFileSize, 221 weak_ptr_factory_.GetWeakPtr(), 222 base::Passed(&upload_file_info), 223 start_initiate_upload_callback)); 224 return info_ptr->GetCancelCallback(); 225 } 226 227 void DriveUploader::StartUploadFileAfterGetFileSize( 228 scoped_ptr<UploadFileInfo> upload_file_info, 229 const StartInitiateUploadCallback& start_initiate_upload_callback, 230 bool get_file_size_result) { 231 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 232 233 if (!get_file_size_result) { 234 UploadFailed(upload_file_info.Pass(), HTTP_NOT_FOUND); 235 return; 236 } 237 DCHECK_GE(upload_file_info->content_length, 0); 238 239 if (upload_file_info->cancelled) { 240 UploadFailed(upload_file_info.Pass(), GDATA_CANCELLED); 241 return; 242 } 243 start_initiate_upload_callback.Run(upload_file_info.Pass()); 244 } 245 246 void DriveUploader::StartInitiateUploadNewFile( 247 const std::string& parent_resource_id, 248 const std::string& title, 249 scoped_ptr<UploadFileInfo> upload_file_info) { 250 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 251 252 UploadFileInfo* info_ptr = upload_file_info.get(); 253 info_ptr->cancel_callback = drive_service_->InitiateUploadNewFile( 254 info_ptr->content_type, 255 info_ptr->content_length, 256 parent_resource_id, 257 title, 258 base::Bind(&DriveUploader::OnUploadLocationReceived, 259 weak_ptr_factory_.GetWeakPtr(), 260 base::Passed(&upload_file_info))); 261 } 262 263 void DriveUploader::StartInitiateUploadExistingFile( 264 const std::string& resource_id, 265 const std::string& etag, 266 scoped_ptr<UploadFileInfo> upload_file_info) { 267 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 268 269 UploadFileInfo* info_ptr = upload_file_info.get(); 270 info_ptr->cancel_callback = drive_service_->InitiateUploadExistingFile( 271 info_ptr->content_type, 272 info_ptr->content_length, 273 resource_id, 274 etag, 275 base::Bind(&DriveUploader::OnUploadLocationReceived, 276 weak_ptr_factory_.GetWeakPtr(), 277 base::Passed(&upload_file_info))); 278 } 279 280 void DriveUploader::OnUploadLocationReceived( 281 scoped_ptr<UploadFileInfo> upload_file_info, 282 GDataErrorCode code, 283 const GURL& upload_location) { 284 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 285 286 DVLOG(1) << "Got upload location [" << upload_location.spec() 287 << "] for [" << upload_file_info->file_path.value() << "]"; 288 289 if (code != HTTP_SUCCESS) { 290 if (code == HTTP_PRECONDITION) 291 code = HTTP_CONFLICT; // ETag mismatch. 292 UploadFailed(upload_file_info.Pass(), code); 293 return; 294 } 295 296 upload_file_info->upload_location = upload_location; 297 upload_file_info->next_start_position = 0; 298 UploadNextChunk(upload_file_info.Pass()); 299 } 300 301 void DriveUploader::StartGetUploadStatus( 302 scoped_ptr<UploadFileInfo> upload_file_info) { 303 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 304 DCHECK(upload_file_info); 305 306 UploadFileInfo* info_ptr = upload_file_info.get(); 307 info_ptr->cancel_callback = drive_service_->GetUploadStatus( 308 info_ptr->upload_location, 309 info_ptr->content_length, 310 base::Bind(&DriveUploader::OnUploadRangeResponseReceived, 311 weak_ptr_factory_.GetWeakPtr(), 312 base::Passed(&upload_file_info))); 313 } 314 315 void DriveUploader::UploadNextChunk( 316 scoped_ptr<UploadFileInfo> upload_file_info) { 317 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 318 DCHECK(upload_file_info); 319 DCHECK_GE(upload_file_info->next_start_position, 0); 320 DCHECK_LE(upload_file_info->next_start_position, 321 upload_file_info->content_length); 322 323 if (upload_file_info->cancelled) { 324 UploadFailed(upload_file_info.Pass(), GDATA_CANCELLED); 325 return; 326 } 327 328 // Limit the size of data uploaded per each request by kUploadChunkSize. 329 const int64 end_position = std::min( 330 upload_file_info->content_length, 331 upload_file_info->next_start_position + kUploadChunkSize); 332 333 UploadFileInfo* info_ptr = upload_file_info.get(); 334 info_ptr->cancel_callback = drive_service_->ResumeUpload( 335 info_ptr->upload_location, 336 info_ptr->next_start_position, 337 end_position, 338 info_ptr->content_length, 339 info_ptr->content_type, 340 info_ptr->file_path, 341 base::Bind(&DriveUploader::OnUploadRangeResponseReceived, 342 weak_ptr_factory_.GetWeakPtr(), 343 base::Passed(&upload_file_info)), 344 base::Bind(&DriveUploader::OnUploadProgress, 345 weak_ptr_factory_.GetWeakPtr(), 346 info_ptr->progress_callback, 347 info_ptr->next_start_position, 348 info_ptr->content_length)); 349 } 350 351 void DriveUploader::OnUploadRangeResponseReceived( 352 scoped_ptr<UploadFileInfo> upload_file_info, 353 const UploadRangeResponse& response, 354 scoped_ptr<ResourceEntry> entry) { 355 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 356 357 if (response.code == HTTP_CREATED || response.code == HTTP_SUCCESS) { 358 // When uploading a new file, we expect HTTP_CREATED, and when uploading 359 // an existing file (to overwrite), we expect HTTP_SUCCESS. 360 // There is an exception: if we uploading an empty file, uploading a new 361 // file also returns HTTP_SUCCESS on Drive API v2. The correct way of the 362 // fix should be uploading the metadata only. However, to keep the 363 // compatibility with GData WAPI during the migration period, we just 364 // relax the condition here. 365 // TODO(hidehiko): Upload metadata only for empty files, after GData WAPI 366 // code is gone. 367 DVLOG(1) << "Successfully created uploaded file=[" 368 << upload_file_info->file_path.value() << "]"; 369 370 // Done uploading. 371 upload_file_info->completion_callback.Run( 372 HTTP_SUCCESS, GURL(), entry.Pass()); 373 return; 374 } 375 376 // ETag mismatch. 377 if (response.code == HTTP_PRECONDITION) { 378 UploadFailed(upload_file_info.Pass(), HTTP_CONFLICT); 379 return; 380 } 381 382 // If code is 308 (RESUME_INCOMPLETE) and |range_received| starts with 0 383 // (meaning that the data is uploaded from the beginning of the file), 384 // proceed to upload the next chunk. 385 if (response.code != HTTP_RESUME_INCOMPLETE || 386 response.start_position_received != 0) { 387 DVLOG(1) 388 << "UploadNextChunk http code=" << response.code 389 << ", start_position_received=" << response.start_position_received 390 << ", end_position_received=" << response.end_position_received; 391 UploadFailed( 392 upload_file_info.Pass(), 393 response.code == HTTP_FORBIDDEN ? GDATA_NO_SPACE : response.code); 394 return; 395 } 396 397 DVLOG(1) << "Received range " << response.start_position_received 398 << "-" << response.end_position_received 399 << " for [" << upload_file_info->file_path.value() << "]"; 400 401 upload_file_info->next_start_position = response.end_position_received; 402 UploadNextChunk(upload_file_info.Pass()); 403 } 404 405 void DriveUploader::OnUploadProgress(const ProgressCallback& callback, 406 int64 start_position, 407 int64 total_size, 408 int64 progress_of_chunk, 409 int64 total_of_chunk) { 410 if (!callback.is_null()) 411 callback.Run(start_position + progress_of_chunk, total_size); 412 } 413 414 void DriveUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info, 415 GDataErrorCode error) { 416 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 417 418 DVLOG(1) << "Upload failed " << upload_file_info->DebugString(); 419 420 if (upload_file_info->next_start_position < 0) { 421 // Discard the upload location because no request could succeed with it. 422 // Maybe it's obsolete. 423 upload_file_info->upload_location = GURL(); 424 } 425 426 upload_file_info->completion_callback.Run( 427 error, upload_file_info->upload_location, scoped_ptr<ResourceEntry>()); 428 } 429 430 } // namespace drive 431
