gdata: Remove use of GetGDataEntryByPath() from StartFileUploadOnUIThread

chrome/browser/chromeos/gdata/gdata_file_system.cc

 // Copyright (c) 2012 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/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 735 matching lines @@
   FeedToFileResourceMapUmaStats()
       : num_regular_files(0),
         num_hosted_documents(0) {}
 
   typedef std::map<DocumentEntry::EntryKind, int> EntryKindToCountMap;
   int num_regular_files;
   int num_hosted_documents;
   EntryKindToCountMap num_files_with_entry_kind;
 };
 
+// GDataFileSystem::StartFileUploadParams implementation.
+struct GDataFileSystem::StartFileUploadParams {
+  StartFileUploadParams(const FilePath& in_local_file_path,
+                        const FilePath& in_remote_file_path,
+                        const FileOperationCallback& in_callback)
+      : local_file_path(in_local_file_path),
+        remote_file_path(in_remote_file_path),
+        callback(in_callback) {}
+
+  const FilePath local_file_path;
+  const FilePath remote_file_path;
+  const FileOperationCallback callback;
+};
 
 // GDataFileSystem class implementation.
 
 GDataFileSystem::GDataFileSystem(
     Profile* profile,
     GDataCache* cache,
     DocumentsServiceInterface* documents_service,
     GDataUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
@@ skipping 456 matching lines @@
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileInfoOnBlockingPool,
                  local_file_path,
                  error,
                  file_size,
                  content_type),
       base::Bind(&GDataFileSystem::StartFileUploadOnUIThread,
                  ui_weak_ptr_,
-                 local_file_path,
-                 remote_dest_file_path,
-                 callback,
+                 StartFileUploadParams(local_file_path,
+                                       remote_dest_file_path,
+                                       callback),
                  base::Owned(error),
                  base::Owned(file_size),
                  base::Owned(content_type)));
 }
 
 void GDataFileSystem::StartFileUploadOnUIThread(
-    const FilePath& local_file,
-    const FilePath& remote_dest_file,
-    const FileOperationCallback& callback,
+    const StartFileUploadParams& params,
     GDataFileError* error,
     int64* file_size,
     std::string* content_type) {
   // This method needs to run on the UI thread as required by
   // GDataUploader::UploadNewFile().
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(file_size);
   DCHECK(content_type);
 
   if (*error != GDATA_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(*error);
+    if (!params.callback.is_null())
+      params.callback.Run(*error);
 
     return;
   }
 
   // Make sure the destination directory exists.
-  GDataEntry* dest_dir = GetGDataEntryByPath(remote_dest_file.DirName());
-  if (!dest_dir || !dest_dir->AsGDataDirectory()) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
-    NOTREACHED();
+  GetEntryInfoByPath(
+      params.remote_file_path.DirName(),
+      base::Bind(
+          &GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo,
+          ui_weak_ptr_,
+          params,
+          *file_size,
+          *content_type));
+}
+
+void GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo(
+    const StartFileUploadParams& params,
+    int64 file_size,
+    std::string content_type,
+    GDataFileError error,
+    scoped_ptr<GDataEntryProto> entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (entry_proto.get() && !entry_proto->file_info().is_directory())
+    error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
+
+  if (error != GDATA_FILE_OK) {
+    if (!params.callback.is_null())
+      params.callback.Run(error);
     return;
   }
+  DCHECK(entry_proto.get());
 
   // Fill in values of UploadFileInfo.
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo);
-  upload_file_info->file_path = local_file;
-  upload_file_info->file_size = *file_size;
-  upload_file_info->gdata_path = remote_dest_file;
+  upload_file_info->file_path = params.local_file_path;
+  upload_file_info->file_size = file_size;
+  upload_file_info->gdata_path = params.remote_file_path;
   // Use the file name as the title.
-  upload_file_info->title = remote_dest_file.BaseName().value();
-  upload_file_info->content_length = *file_size;
+  upload_file_info->title = params.remote_file_path.BaseName().value();
+  upload_file_info->content_length = file_size;
   upload_file_info->all_bytes_present = true;
-  upload_file_info->content_type = *content_type;
-  upload_file_info->initial_upload_location =
-      dest_dir->AsGDataDirectory()->upload_url();
+  upload_file_info->content_type = content_type;
+  upload_file_info->initial_upload_location = GURL(entry_proto->upload_url());
 
   upload_file_info->completion_callback =
       base::Bind(&GDataFileSystem::OnTransferCompleted,
                  ui_weak_ptr_,
-                 callback);
+                 params.callback);
 
   uploader_->UploadNewFile(upload_file_info.Pass());
 }
 
 void GDataFileSystem::OnTransferCompleted(
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
@@ skipping 2766 matching lines @@
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
   if (!callback.is_null())
     callback.Run(result);
 }
 
 }  // namespace gdata