AddEntryToDirectory now takes a FilePath and scoped_ptr<DocumentEntry>

chrome/browser/chromeos/gdata/drive_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/drive_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 255 matching lines @@
     const FilePath& path,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   if (!callback.is_null())
     callback.Run(error, path, entry_proto.Pass());
 }
 
 }  // namespace
 
 // DriveFileSystem::CreateDirectoryParams struct implementation.
-struct DriveFileSystem::CreateDirectoryParams {
-  CreateDirectoryParams(const FilePath& created_directory_path,
-                        const FilePath& target_directory_path,
-                        bool is_exclusive,
-                        bool is_recursive,
-                        const FileOperationCallback& callback);
-  ~CreateDirectoryParams();
-
-  const FilePath created_directory_path;
-  const FilePath target_directory_path;
-  const bool is_exclusive;
-  const bool is_recursive;
-  FileOperationCallback callback;
-};
-
 DriveFileSystem::CreateDirectoryParams::CreateDirectoryParams(
     const FilePath& created_directory_path,
     const FilePath& target_directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback)
     : created_directory_path(created_directory_path),
       target_directory_path(target_directory_path),
       is_exclusive(is_exclusive),
       is_recursive(is_recursive),
@@ skipping 77 matching lines @@
         callback(in_callback) {}
 
   const FilePath local_file_path;
   const FilePath remote_file_path;
   const FileOperationCallback callback;
 };
 
 // DriveFileSystem::AddUploadedFileParams implementation.
 struct DriveFileSystem::AddUploadedFileParams {
   AddUploadedFileParams(UploadMode upload_mode,
-                        DriveDirectory* parent_dir,
-                        scoped_ptr<DriveEntry> new_entry,
+                        const FilePath& directory_path,
+                        scoped_ptr<DocumentEntry> doc_entry,
                         const FilePath& file_content_path,
                         DriveCache::FileOperationType cache_operation,
                         const base::Closure& callback)
   : upload_mode(upload_mode),
-    parent_dir(parent_dir),
-    new_entry(new_entry.Pass()),
+    directory_path(directory_path),
+    doc_entry(doc_entry.Pass()),
     file_content_path(file_content_path),
     cache_operation(cache_operation),
     callback(callback) {
   }
 
   UploadMode upload_mode;
-  DriveDirectory* parent_dir;
-  scoped_ptr<DriveEntry> new_entry;
+  FilePath directory_path;
+  scoped_ptr<DocumentEntry> doc_entry;
   FilePath file_content_path;
   DriveCache::FileOperationType cache_operation;
   base::Closure callback;
   std::string resource_id;
   std::string md5;
 };
 
 
 // DriveFileSystem class implementation.
 
@@ skipping 563 matching lines @@
           callback));
 }
 
 void DriveFileSystem::RenameAfterGetEntryInfo(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(error, file_path);
+    callback.Run(error, file_path);
     return;
   }
   DCHECK(entry_proto.get());
 
   // Drop the .g<something> extension from |new_name| if the file being
   // renamed is a hosted document and |new_name| has the same .g<something>
   // extension as the file.
   FilePath::StringType file_name = new_name;
   if (entry_proto->has_file_specific_info() &&
       entry_proto->file_specific_info().is_hosted_document()) {
@@ skipping 334 matching lines @@
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
            base::Bind(callback, DRIVE_FILE_ERROR_NOT_FOUND));
     }
     return;
   }
 
   drive_service_->CreateDirectory(
       last_parent_dir_url,
       first_missing_path.BaseName().value(),
-      base::Bind(&DriveFileSystem::OnCreateDirectoryCompleted,
+      base::Bind(&DriveFileSystem::AddNewDirectory,
                  ui_weak_ptr_,
                  CreateDirectoryParams(
                      first_missing_path,
                      directory_path,
                      is_exclusive,
                      is_recursive,
                      callback)));
 }
 
 void DriveFileSystem::CreateFile(const FilePath& file_path,
@@ skipping 818 matching lines @@
   if (!about.get()) {
     callback.Run(DRIVE_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
   callback.Run(DRIVE_FILE_OK,
                about->quota_bytes_total(),
                about->quota_bytes_used());
 }
 
-void DriveFileSystem::OnCreateDirectoryCompleted(
+void DriveFileSystem::AddNewDirectory(
     const CreateDirectoryParams& params,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
-
     return;
   }
 
-  base::DictionaryValue* dict_value = NULL;
-  base::Value* created_entry = NULL;
-  if (data.get() && data->GetAsDictionary(&dict_value) && dict_value)
-    dict_value->Get("entry", &created_entry);
-  error = AddNewDirectory(params.created_directory_path.DirName(),
-                          created_entry);
+  resource_metadata_->AddEntryToDirectory(
+      params.created_directory_path.DirName(),
+      scoped_ptr<DocumentEntry>(DocumentEntry::ExtractAndParse(*data)),
+      base::Bind(&DriveFileSystem::ContinueCreateDirectory,
+                 ui_weak_ptr_,
+                 params));
+}
+
+void DriveFileSystem::ContinueCreateDirectory(
+    const CreateDirectoryParams& params,
+    DriveFileError error,
+    const FilePath& moved_file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
-
     return;
   }
 
+  OnDirectoryChanged(moved_file_path.DirName());
+
   // Not done yet with recursive directory creation?
   if (params.target_directory_path != params.created_directory_path &&
       params.is_recursive) {
     CreateDirectory(params.target_directory_path,
                     params.is_exclusive,
                     params.is_recursive,
                     params.callback);
-    return;
-  }
-
-  if (!params.callback.is_null()) {
+  } else if (!params.callback.is_null()) {
     // Finally done with the create request.
     params.callback.Run(DRIVE_FILE_OK);
   }
 }
 
 void DriveFileSystem::OnSearch(const SearchCallback& callback,
                                GetDocumentsParams* params,
                                DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 139 matching lines @@
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
-  scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
-  if (!doc_entry.get()) {
-    callback.Run(DRIVE_FILE_ERROR_FAILED);
-    return;
-  }
-
-  DriveEntry* entry = resource_metadata_->FromDocumentEntry(*doc_entry);
-  if (!entry) {
-    callback.Run(DRIVE_FILE_ERROR_FAILED);
-    return;
-  }
-
   // |entry| was added in the root directory on the server, so we should
   // first add it to |root_| to mirror the state and then move it to the
   // destination directory by MoveEntryFromRootDirectory().
   resource_metadata_->AddEntryToDirectory(
-      resource_metadata_->root(),
-      entry,
+      resource_metadata_->root()->GetFilePath(),
+      scoped_ptr<DocumentEntry>(DocumentEntry::ExtractAndParse(*data)),
       base::Bind(&DriveFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void DriveFileSystem::OnMoveEntryFromRootDirectoryCompleted(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
@@ skipping 152 matching lines @@
   // Nothing much to do here for now.
 }
 
 void DriveFileSystem::RenameEntryLocally(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   const DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(error, FilePath());
+    callback.Run(error, FilePath());
     return;
   }
 
   DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
   if (!entry) {
-    if (!callback.is_null())
-      callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
   DCHECK(entry->parent());
   entry->set_title(new_name);
   // After changing the title of the entry, call MoveEntryToDirectory() to
   // remove the entry from its parent directory and then add it back in order to
   // go through the file name de-duplication.
   // TODO(achuith/satorux/zel): This code is fragile. The title has been
   // changed, but not the file_name. MoveEntryToDirectory calls RemoveChild to
@@ skipping 34 matching lines @@
       base::Bind(&DriveFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
 void DriveFileSystem::NotifyAndRunFileMoveCallback(
     const FileMoveCallback& callback,
     DriveFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (error == DRIVE_FILE_OK)
     OnDirectoryChanged(moved_file_path.DirName());
 
-  if (!callback.is_null())
-    callback.Run(error, moved_file_path);
+  callback.Run(error, moved_file_path);
 }
 
 void DriveFileSystem::NotifyAndRunFileOperationCallback(
     const FileOperationCallback& callback,
     DriveFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == DRIVE_FILE_OK)
@@ skipping 37 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Notify the observers that root directory has been initialized.
   FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnInitialLoadFinished());
 
   callback.Run(error);
 }
 
-DriveFileError DriveFileSystem::AddNewDirectory(
-    const FilePath& directory_path, base::Value* entry_value) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!entry_value)
-    return DRIVE_FILE_ERROR_FAILED;
-
-  scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::CreateFrom(*entry_value));
-
-  if (!doc_entry.get())
-    return DRIVE_FILE_ERROR_FAILED;
-
-  // Find parent directory element within the cached file system snapshot.
-  DriveEntry* entry = resource_metadata_->FindEntryByPathSync(directory_path);
-  if (!entry)
-    return DRIVE_FILE_ERROR_FAILED;
-
-  // Check if parent is a directory since in theory since this is a callback
-  // something could in the meantime have nuked the parent dir and created a
-  // file with the exact same name.
-  DriveDirectory* parent_dir = entry->AsDriveDirectory();
-  if (!parent_dir)
-    return DRIVE_FILE_ERROR_FAILED;
-
-  DriveEntry* new_entry =
-      resource_metadata_->FromDocumentEntry(*doc_entry);
-  if (!new_entry)
-    return DRIVE_FILE_ERROR_FAILED;
-
-  resource_metadata_->AddEntryToDirectory(
-      parent_dir,
-      new_entry,
-      base::Bind(&DriveFileSystem::NotifyAndRunFileMoveCallback,
-                 ui_weak_ptr_,
-                 FileMoveCallback()));
-  return DRIVE_FILE_OK;
-}
-
 DriveFileSystem::FindMissingDirectoryResult
 DriveFileSystem::FindFirstMissingParentDirectory(
     const FilePath& directory_path,
     GURL* last_dir_content_url,
     FilePath* first_missing_parent_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Let's find which how deep is the existing directory structure and
   // get the first element that's missing.
   std::vector<FilePath::StringType> path_parts;
@@ skipping 15 matching lines @@
     } else {
       *first_missing_parent_path = current_path;
       return FOUND_MISSING;
     }
   }
   return DIRECTORY_ALREADY_PRESENT;
 }
 
 void DriveFileSystem::AddUploadedFile(
     UploadMode upload_mode,
-    const FilePath& virtual_dir_path,
+    const FilePath& directory_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     DriveCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Post a task to the same thread, rather than calling it here, as
   // AddUploadedFile() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&DriveFileSystem::AddUploadedFileOnUIThread,
                  ui_weak_ptr_,
                  upload_mode,
-                 virtual_dir_path,
+                 directory_path,
                  base::Passed(&entry),
                  file_content_path,
                  cache_operation,
                  callback));
 }
 
 void DriveFileSystem::AddUploadedFileOnUIThread(
     UploadMode upload_mode,
-    const FilePath& virtual_dir_path,
-    scoped_ptr<DocumentEntry> entry,
+    const FilePath& directory_path,
+    scoped_ptr<DocumentEntry> doc_entry,
     const FilePath& file_content_path,
     DriveCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(doc_entry.get());
 
-  // ScopedClosureRunner ensures that the specified callback is always invoked
-  // upon return or passed on.
-  base::ScopedClosureRunner callback_runner(callback);
-
-  if (!entry.get()) {
-    NOTREACHED();
-    return;
-  }
-
-  DriveEntry* dir_entry = resource_metadata_->FindEntryByPathSync(
-      virtual_dir_path);
-  if (!dir_entry)
-    return;
-
-  DriveDirectory* parent_dir  = dir_entry->AsDriveDirectory();
-  if (!parent_dir)
-    return;
-
-  scoped_ptr<DriveEntry> new_entry(
-      resource_metadata_->FromDocumentEntry(*entry));
-  if (!new_entry.get())
-    return;
-
-  const std::string& resource_id = new_entry->resource_id();
+  const std::string& resource_id = doc_entry->resource_id();
   AddUploadedFileParams* params =
       new AddUploadedFileParams(upload_mode,
-                                parent_dir,
-                                new_entry.Pass(),
+                                directory_path,
+                                doc_entry.Pass(),
                                 file_content_path,
                                 cache_operation,
-                                callback_runner.Release());
+                                callback);
 
   const FileMoveCallback file_move_callback =
       base::Bind(&DriveFileSystem::ContinueAddUploadedFile,
                  ui_weak_ptr_, params);
 
   if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Remove the existing entry.
     resource_metadata_->RemoveEntryFromParent(resource_id, file_move_callback);
   } else {
     file_move_callback.Run(DRIVE_FILE_OK, FilePath());
   }
 }
 
 void DriveFileSystem::ContinueAddUploadedFile(
     AddUploadedFileParams* params,
     DriveFileError error,
-    const FilePath& file_path) {
+    const FilePath& /* file_path */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(DRIVE_FILE_OK, error);
-  DCHECK(params->new_entry.get());
-  DriveFile* file = params->new_entry->AsDriveFile();
-  DCHECK(file);
+  DCHECK(params->doc_entry.get());
 
-  params->resource_id = file->resource_id();
-  params->md5 = file->file_md5();
+  params->resource_id = params->doc_entry->resource_id();
+  params->md5 = params->doc_entry->file_md5();
+  DCHECK(!params->resource_id.empty());
+  DCHECK(!params->md5.empty());
+
   resource_metadata_->AddEntryToDirectory(
-      params->parent_dir,
-      params->new_entry.release(),
-      base::Bind(&DriveFileSystem::NotifyAndRunFileMoveCallback,
+      params->directory_path,
+      params->doc_entry.Pass(),
+      base::Bind(&DriveFileSystem::AddUploadedFileToCache,
                  ui_weak_ptr_,
-                 base::Bind(&DriveFileSystem::AddUploadedFileToCache,
-                            ui_weak_ptr_,
-                            base::Owned(params))));
+                 base::Owned(params)));
 }
 
 void DriveFileSystem::AddUploadedFileToCache(
     AddUploadedFileParams* params,
     DriveFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!params->resource_id.empty());
+  DCHECK(!params->md5.empty());
+  DCHECK(!params->resource_id.empty());
+  DCHECK(!params->callback.is_null());
+
+  if (error != DRIVE_FILE_OK) {
+    params->callback.Run();
+    return;
+  }
+
+  OnDirectoryChanged(file_path.DirName());
 
   if (params->upload_mode == UPLOAD_NEW_FILE) {
     // Add the file to the cache if we have uploaded a new file.
     cache_->StoreOnUIThread(params->resource_id,
                             params->md5,
                             params->file_content_path,
                             params->cache_operation,
                             base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                        params->callback));
   } else if (params->upload_mode == UPLOAD_EXISTING_FILE) {
@@ skipping 420 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   DriveEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata