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/files/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/drive_api_parser.h" 18 19 using content::BrowserThread; 20 using google_apis::CancelCallback; 21 using google_apis::FileResource; 22 using google_apis::GDATA_CANCELLED; 23 using google_apis::GDataErrorCode; 24 using google_apis::GDATA_NO_SPACE; 25 using google_apis::HTTP_CONFLICT; 26 using google_apis::HTTP_CREATED; 27 using google_apis::HTTP_FORBIDDEN; 28 using google_apis::HTTP_NOT_FOUND; 29 using google_apis::HTTP_PRECONDITION; 30 using google_apis::HTTP_RESUME_INCOMPLETE; 31 using google_apis::HTTP_SUCCESS; 32 using google_apis::ProgressCallback; 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( 128 DriveServiceInterface* drive_service, 129 const scoped_refptr<base::TaskRunner>& blocking_task_runner) 130 : drive_service_(drive_service), 131 blocking_task_runner_(blocking_task_runner), 132 weak_ptr_factory_(this) { 133 } 134 135 DriveUploader::~DriveUploader() {} 136 137 CancelCallback DriveUploader::UploadNewFile( 138 const std::string& parent_resource_id, 139 const base::FilePath& local_file_path, 140 const std::string& title, 141 const std::string& content_type, 142 const UploadNewFileOptions& options, 143 const UploadCompletionCallback& callback, 144 const ProgressCallback& progress_callback) { 145 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 146 DCHECK(!parent_resource_id.empty()); 147 DCHECK(!local_file_path.empty()); 148 DCHECK(!title.empty()); 149 DCHECK(!content_type.empty()); 150 DCHECK(!callback.is_null()); 151 152 return StartUploadFile( 153 scoped_ptr<UploadFileInfo>(new UploadFileInfo(local_file_path, 154 content_type, 155 callback, 156 progress_callback)), 157 base::Bind(&DriveUploader::StartInitiateUploadNewFile, 158 weak_ptr_factory_.GetWeakPtr(), 159 parent_resource_id, 160 title, 161 options)); 162 } 163 164 CancelCallback DriveUploader::UploadExistingFile( 165 const std::string& resource_id, 166 const base::FilePath& local_file_path, 167 const std::string& content_type, 168 const UploadExistingFileOptions& options, 169 const UploadCompletionCallback& callback, 170 const ProgressCallback& progress_callback) { 171 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 172 DCHECK(!resource_id.empty()); 173 DCHECK(!local_file_path.empty()); 174 DCHECK(!content_type.empty()); 175 DCHECK(!callback.is_null()); 176 177 return StartUploadFile( 178 scoped_ptr<UploadFileInfo>(new UploadFileInfo(local_file_path, 179 content_type, 180 callback, 181 progress_callback)), 182 base::Bind(&DriveUploader::StartInitiateUploadExistingFile, 183 weak_ptr_factory_.GetWeakPtr(), 184 resource_id, 185 options)); 186 } 187 188 CancelCallback DriveUploader::ResumeUploadFile( 189 const GURL& upload_location, 190 const base::FilePath& local_file_path, 191 const std::string& content_type, 192 const UploadCompletionCallback& callback, 193 const ProgressCallback& progress_callback) { 194 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 195 DCHECK(!local_file_path.empty()); 196 DCHECK(!content_type.empty()); 197 DCHECK(!callback.is_null()); 198 199 scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo( 200 local_file_path, content_type, 201 callback, progress_callback)); 202 upload_file_info->upload_location = upload_location; 203 204 return StartUploadFile( 205 upload_file_info.Pass(), 206 base::Bind(&DriveUploader::StartGetUploadStatus, 207 weak_ptr_factory_.GetWeakPtr())); 208 } 209 210 CancelCallback DriveUploader::StartUploadFile( 211 scoped_ptr<UploadFileInfo> upload_file_info, 212 const StartInitiateUploadCallback& start_initiate_upload_callback) { 213 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 214 DVLOG(1) << "Uploading file: " << upload_file_info->DebugString(); 215 216 UploadFileInfo* info_ptr = upload_file_info.get(); 217 base::PostTaskAndReplyWithResult( 218 blocking_task_runner_.get(), 219 FROM_HERE, 220 base::Bind(&base::GetFileSize, 221 info_ptr->file_path, 222 &info_ptr->content_length), 223 base::Bind(&DriveUploader::StartUploadFileAfterGetFileSize, 224 weak_ptr_factory_.GetWeakPtr(), 225 base::Passed(&upload_file_info), 226 start_initiate_upload_callback)); 227 return info_ptr->GetCancelCallback(); 228 } 229 230 void DriveUploader::StartUploadFileAfterGetFileSize( 231 scoped_ptr<UploadFileInfo> upload_file_info, 232 const StartInitiateUploadCallback& start_initiate_upload_callback, 233 bool get_file_size_result) { 234 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 235 236 if (!get_file_size_result) { 237 UploadFailed(upload_file_info.Pass(), HTTP_NOT_FOUND); 238 return; 239 } 240 DCHECK_GE(upload_file_info->content_length, 0); 241 242 if (upload_file_info->cancelled) { 243 UploadFailed(upload_file_info.Pass(), GDATA_CANCELLED); 244 return; 245 } 246 start_initiate_upload_callback.Run(upload_file_info.Pass()); 247 } 248 249 void DriveUploader::StartInitiateUploadNewFile( 250 const std::string& parent_resource_id, 251 const std::string& title, 252 const UploadNewFileOptions& options, 253 scoped_ptr<UploadFileInfo> upload_file_info) { 254 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 255 256 UploadFileInfo* info_ptr = upload_file_info.get(); 257 info_ptr->cancel_callback = drive_service_->InitiateUploadNewFile( 258 info_ptr->content_type, 259 info_ptr->content_length, 260 parent_resource_id, 261 title, 262 options, 263 base::Bind(&DriveUploader::OnUploadLocationReceived, 264 weak_ptr_factory_.GetWeakPtr(), 265 base::Passed(&upload_file_info))); 266 } 267 268 void DriveUploader::StartInitiateUploadExistingFile( 269 const std::string& resource_id, 270 const UploadExistingFileOptions& options, 271 scoped_ptr<UploadFileInfo> upload_file_info) { 272 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 273 274 UploadFileInfo* info_ptr = upload_file_info.get(); 275 info_ptr->cancel_callback = drive_service_->InitiateUploadExistingFile( 276 info_ptr->content_type, 277 info_ptr->content_length, 278 resource_id, 279 options, 280 base::Bind(&DriveUploader::OnUploadLocationReceived, 281 weak_ptr_factory_.GetWeakPtr(), 282 base::Passed(&upload_file_info))); 283 } 284 285 void DriveUploader::OnUploadLocationReceived( 286 scoped_ptr<UploadFileInfo> upload_file_info, 287 GDataErrorCode code, 288 const GURL& upload_location) { 289 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 290 291 DVLOG(1) << "Got upload location [" << upload_location.spec() 292 << "] for [" << upload_file_info->file_path.value() << "]"; 293 294 if (code != HTTP_SUCCESS) { 295 if (code == HTTP_PRECONDITION) 296 code = HTTP_CONFLICT; // ETag mismatch. 297 UploadFailed(upload_file_info.Pass(), code); 298 return; 299 } 300 301 upload_file_info->upload_location = upload_location; 302 upload_file_info->next_start_position = 0; 303 UploadNextChunk(upload_file_info.Pass()); 304 } 305 306 void DriveUploader::StartGetUploadStatus( 307 scoped_ptr<UploadFileInfo> upload_file_info) { 308 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 309 DCHECK(upload_file_info); 310 311 UploadFileInfo* info_ptr = upload_file_info.get(); 312 info_ptr->cancel_callback = drive_service_->GetUploadStatus( 313 info_ptr->upload_location, 314 info_ptr->content_length, 315 base::Bind(&DriveUploader::OnUploadRangeResponseReceived, 316 weak_ptr_factory_.GetWeakPtr(), 317 base::Passed(&upload_file_info))); 318 } 319 320 void DriveUploader::UploadNextChunk( 321 scoped_ptr<UploadFileInfo> upload_file_info) { 322 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 323 DCHECK(upload_file_info); 324 DCHECK_GE(upload_file_info->next_start_position, 0); 325 DCHECK_LE(upload_file_info->next_start_position, 326 upload_file_info->content_length); 327 328 if (upload_file_info->cancelled) { 329 UploadFailed(upload_file_info.Pass(), GDATA_CANCELLED); 330 return; 331 } 332 333 // Limit the size of data uploaded per each request by kUploadChunkSize. 334 const int64 end_position = std::min( 335 upload_file_info->content_length, 336 upload_file_info->next_start_position + kUploadChunkSize); 337 338 UploadFileInfo* info_ptr = upload_file_info.get(); 339 info_ptr->cancel_callback = drive_service_->ResumeUpload( 340 info_ptr->upload_location, 341 info_ptr->next_start_position, 342 end_position, 343 info_ptr->content_length, 344 info_ptr->content_type, 345 info_ptr->file_path, 346 base::Bind(&DriveUploader::OnUploadRangeResponseReceived, 347 weak_ptr_factory_.GetWeakPtr(), 348 base::Passed(&upload_file_info)), 349 base::Bind(&DriveUploader::OnUploadProgress, 350 weak_ptr_factory_.GetWeakPtr(), 351 info_ptr->progress_callback, 352 info_ptr->next_start_position, 353 info_ptr->content_length)); 354 } 355 356 void DriveUploader::OnUploadRangeResponseReceived( 357 scoped_ptr<UploadFileInfo> upload_file_info, 358 const UploadRangeResponse& response, 359 scoped_ptr<FileResource> entry) { 360 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 361 362 if (response.code == HTTP_CREATED || response.code == HTTP_SUCCESS) { 363 // When uploading a new file, we expect HTTP_CREATED, and when uploading 364 // an existing file (to overwrite), we expect HTTP_SUCCESS. 365 // There is an exception: if we uploading an empty file, uploading a new 366 // file also returns HTTP_SUCCESS on Drive API v2. The correct way of the 367 // fix should be uploading the metadata only. However, to keep the 368 // compatibility with GData WAPI during the migration period, we just 369 // relax the condition here. 370 // TODO(hidehiko): Upload metadata only for empty files, after GData WAPI 371 // code is gone. 372 DVLOG(1) << "Successfully created uploaded file=[" 373 << upload_file_info->file_path.value() << "]"; 374 375 // Done uploading. 376 upload_file_info->completion_callback.Run( 377 HTTP_SUCCESS, GURL(), entry.Pass()); 378 return; 379 } 380 381 // ETag mismatch. 382 if (response.code == HTTP_PRECONDITION) { 383 UploadFailed(upload_file_info.Pass(), HTTP_CONFLICT); 384 return; 385 } 386 387 // If code is 308 (RESUME_INCOMPLETE) and |range_received| starts with 0 388 // (meaning that the data is uploaded from the beginning of the file), 389 // proceed to upload the next chunk. 390 if (response.code != HTTP_RESUME_INCOMPLETE || 391 response.start_position_received != 0) { 392 DVLOG(1) 393 << "UploadNextChunk http code=" << response.code 394 << ", start_position_received=" << response.start_position_received 395 << ", end_position_received=" << response.end_position_received; 396 UploadFailed( 397 upload_file_info.Pass(), 398 response.code == HTTP_FORBIDDEN ? GDATA_NO_SPACE : response.code); 399 return; 400 } 401 402 DVLOG(1) << "Received range " << response.start_position_received 403 << "-" << response.end_position_received 404 << " for [" << upload_file_info->file_path.value() << "]"; 405 406 upload_file_info->next_start_position = response.end_position_received; 407 UploadNextChunk(upload_file_info.Pass()); 408 } 409 410 void DriveUploader::OnUploadProgress(const ProgressCallback& callback, 411 int64 start_position, 412 int64 total_size, 413 int64 progress_of_chunk, 414 int64 total_of_chunk) { 415 if (!callback.is_null()) 416 callback.Run(start_position + progress_of_chunk, total_size); 417 } 418 419 void DriveUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info, 420 GDataErrorCode error) { 421 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 422 423 DVLOG(1) << "Upload failed " << upload_file_info->DebugString(); 424 425 if (upload_file_info->next_start_position < 0) { 426 // Discard the upload location because no request could succeed with it. 427 // Maybe it's obsolete. 428 upload_file_info->upload_location = GURL(); 429 } 430 431 upload_file_info->completion_callback.Run( 432 error, upload_file_info->upload_location, scoped_ptr<FileResource>()); 433 } 434 435 } // namespace drive 436
