drive: Simplify DownloadOperation by using ResourceEntry::local_id

chrome/browser/chromeos/drive/file_system/download_operation.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/drive/file_system/download_operation.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/task_runner_util.h"
@@ skipping 110 matching lines @@
       cache_file_path);
 }
 
 // Calls CheckPreConditionForEnsureFileDownloaded() with the entry specified by
 // the given file path.
 FileError CheckPreConditionForEnsureFileDownloadedByPath(
     internal::ResourceMetadata* metadata,
     internal::FileCache* cache,
     const base::FilePath& file_path,
     const base::FilePath& temporary_file_directory,
-    std::string* local_id,
     base::FilePath* cache_file_path,
     ResourceEntry* entry) {
-  FileError error = metadata->GetIdByPath(file_path, local_id);
+  std::string local_id;
+  FileError error = metadata->GetIdByPath(file_path, &local_id);
   if (error != FILE_ERROR_OK)
     return error;
   return CheckPreConditionForEnsureFileDownloaded(
-      metadata, cache, temporary_file_directory, *local_id, entry,
+      metadata, cache, temporary_file_directory, local_id, entry,
       cache_file_path);
 }
 
 // Creates a file with unique name in |dir| and stores the path to |temp_file|.
 // Additionally, sets the permission of the file to allow read access from
 // others and group member users (i.e, "-rw-r--r--").
 // We need this wrapper because Drive cache files may be read from other
 // processes (e.g., cros_disks for mounting zip files).
 bool CreateTemporaryReadableFileInDir(const base::FilePath& dir,
                                       base::FilePath* temp_file) {
@@ skipping 163 matching lines @@
                  base::Unretained(cache_),
                  local_id,
                  temporary_file_directory_,
                  drive_file_path,
                  cache_file_path,
                  entry),
       base::Bind(&DownloadOperation::EnsureFileDownloadedAfterCheckPreCondition,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params),
                  context,
-                 base::Owned(new std::string(local_id)),
                  base::Owned(drive_file_path),
                  base::Owned(cache_file_path)));
 }
 
 void DownloadOperation::EnsureFileDownloadedByPath(
     const base::FilePath& file_path,
     const ClientContext& context,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
     const GetFileCallback& completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!completion_callback.is_null());
 
-  std::string* local_id = new std::string;
   base::FilePath* drive_file_path = new base::FilePath(file_path);
   base::FilePath* cache_file_path = new base::FilePath;
   ResourceEntry* entry = new ResourceEntry;
   scoped_ptr<DownloadParams> params(new DownloadParams(
       initialized_callback, get_content_callback, completion_callback,
       make_scoped_ptr(entry)));
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CheckPreConditionForEnsureFileDownloadedByPath,
                  base::Unretained(metadata_),
                  base::Unretained(cache_),
                  file_path,
                  temporary_file_directory_,
-                 local_id,
                  cache_file_path,
                  entry),
       base::Bind(&DownloadOperation::EnsureFileDownloadedAfterCheckPreCondition,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&params),
                  context,
-                 base::Owned(local_id),
                  base::Owned(drive_file_path),
                  base::Owned(cache_file_path)));
 }
 
 void DownloadOperation::EnsureFileDownloadedAfterCheckPreCondition(
     scoped_ptr<DownloadParams> params,
     const ClientContext& context,
-    std::string* local_id,
     base::FilePath* drive_file_path,
     base::FilePath* cache_file_path,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
-  DCHECK(local_id);
   DCHECK(drive_file_path);
   DCHECK(cache_file_path);
 
   if (error != FILE_ERROR_OK) {
     // During precondition check, an error is found.
     params->OnError(error);
     return;
   }
 
   if (!cache_file_path->empty()) {
@@ skipping 16 matching lines @@
       base::Bind(&PrepareForDownloadFile,
                  base::Unretained(cache_),
                  size,
                  temporary_file_directory_,
                  temp_download_file_path),
       base::Bind(
           &DownloadOperation::EnsureFileDownloadedAfterPrepareForDownloadFile,
           weak_ptr_factory_.GetWeakPtr(),
           base::Passed(&params),
           context,
-          *local_id,
           *drive_file_path,
           base::Owned(temp_download_file_path)));
 }
 
 void DownloadOperation::EnsureFileDownloadedAfterPrepareForDownloadFile(
     scoped_ptr<DownloadParams> params,
     const ClientContext& context,
-    const std::string& local_id,
     const base::FilePath& drive_file_path,
     base::FilePath* temp_download_file_path,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(params);
   DCHECK(temp_download_file_path);
 
   if (error != FILE_ERROR_OK) {
     params->OnError(error);
     return;
   }
 
   DownloadParams* params_ptr = params.get();
   JobID id = scheduler_->DownloadFile(
       drive_file_path,
       params_ptr->entry().file_info().size(),
       *temp_download_file_path,
       params_ptr->entry().resource_id(),
       context,
       base::Bind(&DownloadOperation::EnsureFileDownloadedAfterDownloadFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  drive_file_path,
-                 local_id,
                  base::Passed(&params)),
       params_ptr->get_content_callback());
 
   // Notify via |initialized_callback| if necessary.
   params_ptr->OnStartDownloading(
       base::Bind(&DownloadOperation::CancelJob,
                  weak_ptr_factory_.GetWeakPtr(), id));
 }
 
 void DownloadOperation::EnsureFileDownloadedAfterDownloadFile(
     const base::FilePath& drive_file_path,
-    const std::string& local_id,
     scoped_ptr<DownloadParams> params,
     google_apis::GDataErrorCode gdata_error,
     const base::FilePath& downloaded_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  const std::string& local_id = params->entry().local_id();
   const std::string& md5 = params->entry().file_specific_info().md5();
   base::FilePath* cache_file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&UpdateLocalStateForDownloadFile,
                  base::Unretained(cache_),
                  local_id,
                  md5,
                  gdata_error,
@@ skipping 22 matching lines @@
   observer_->OnDirectoryChangedByOperation(file_path.DirName());
   params->OnComplete(*cache_file_path);
 }
 
 void DownloadOperation::CancelJob(JobID job_id) {
   scheduler_->CancelJob(job_id);
 }
 
 }  // namespace file_system
 }  // namespace drive