drive: Stop using resource ID to access local metadata in CreateDirectoryOperation

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

 // Copyright (c) 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/create_directory_operation.h"
 
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_system/operation_observer.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/resource_entry_conversion.h"
 #include "chrome/browser/google_apis/gdata_errorcode.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace file_system {
 
 namespace {
 
 // Part of CreateDirectoryRecursively(). Adds an |entry| for new directory
 // to |metadata|, and return the status. If succeeded, |file_path| will store
 // the path to the result file.
 FileError UpdateLocalStateForCreateDirectoryRecursively(
     internal::ResourceMetadata* metadata,
-    const ResourceEntry& entry,
+    scoped_ptr<google_apis::ResourceEntry> resource_entry,
     base::FilePath* file_path) {
   DCHECK(metadata);
   DCHECK(file_path);
 
+  ResourceEntry entry;
+  std::string parent_resource_id;
+  if (!ConvertToResourceEntry(*resource_entry, &entry, &parent_resource_id))
+    return FILE_ERROR_NOT_A_FILE;
+
+  std::string parent_local_id;
+  FileError result = metadata->GetIdByResourceId(parent_resource_id,
+                                                 &parent_local_id);
+  if (result != FILE_ERROR_OK)
+    return result;
+  entry.set_parent_local_id(parent_local_id);
+
   std::string local_id;
-  FileError result = metadata->AddEntry(entry, &local_id);
+  result = metadata->AddEntry(entry, &local_id);
   // Depending on timing, a metadata may be updated by change list already.
   // So, FILE_ERROR_EXISTS is not an error.
   if (result == FILE_ERROR_EXISTS)
     result = metadata->GetIdByResourceId(entry.resource_id(), &local_id);
 
   if (result == FILE_ERROR_OK)
     *file_path = metadata->GetFilePath(local_id);
 
   return result;
 }
@@ skipping 50 matching lines @@
     ResourceEntry* entry) {
   DCHECK(metadata);
   DCHECK(entry);
 
   std::vector<base::FilePath::StringType> components;
   directory_path.GetComponents(&components);
 
   if (components.empty() || components[0] != util::kDriveGrandRootDirName)
     return base::FilePath();
 
-  std::string resource_id = util::kDriveGrandRootSpecialResourceId;
+  std::string local_id = util::kDriveGrandRootSpecialResourceId;
   for (size_t i = 1; i < components.size(); ++i) {
-    std::string child_resource_id =
-        metadata->GetChildResourceId(resource_id, components[i]);
-    if (child_resource_id.empty())
+    std::string child_local_id = metadata->GetChildId(local_id, components[i]);
+    if (child_local_id.empty())
       break;
-    resource_id = child_resource_id;
+    local_id = child_local_id;
   }
 
-  FileError error = metadata->GetResourceEntryById(resource_id, entry);
+  FileError error = metadata->GetResourceEntryById(local_id, entry);
   DCHECK_EQ(FILE_ERROR_OK, error);
 
   if (!entry->file_info().is_directory())
     return base::FilePath();
 
-  return metadata->GetFilePath(resource_id);
+  return metadata->GetFilePath(local_id);
 }
 
 void CreateDirectoryOperation::CreateDirectoryAfterGetExistingDeepestDirectory(
     const base::FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback,
     ResourceEntry* existing_deepest_directory_entry,
     const base::FilePath& existing_deepest_directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 56 matching lines @@
     scoped_ptr<google_apis::ResourceEntry> resource_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   FileError error = GDataToFileError(gdata_error);
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
   DCHECK(resource_entry);
-
-  ResourceEntry entry;
-  std::string parent_resource_id;
-  if (!ConvertToResourceEntry(*resource_entry, &entry, &parent_resource_id)) {
-    callback.Run(FILE_ERROR_NOT_A_FILE);
-    return;
-  }
-
-  // TODO(hashimoto): Resolve local ID before use. crbug.com/260514
-  entry.set_parent_local_id(parent_resource_id);
+  const std::string& resource_id = resource_entry->resource_id();
 
   // Note that the created directory may be renamed inside
   // ResourceMetadata::AddEntry due to name confliction.
   // What we actually need here is the new created path (not the path we try
   // to create).
   base::FilePath* file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&UpdateLocalStateForCreateDirectoryRecursively,
                  metadata_,
-                 entry,
+                 base::Passed(&resource_entry),
                  file_path),
       base::Bind(&CreateDirectoryOperation::
                      CreateDirectoryRecursivelyAfterUpdateLocalState,
                  weak_ptr_factory_.GetWeakPtr(),
-                 resource_entry->resource_id(),
+                 resource_id,
                  remaining_path,
                  callback,
                  base::Owned(file_path)));
 }
 
 void CreateDirectoryOperation::CreateDirectoryRecursivelyAfterUpdateLocalState(
     const std::string& resource_id,
     const base::FilePath& remaining_path,
     const FileOperationCallback& callback,
     base::FilePath* file_path,
@@ skipping 13 matching lines @@
     callback.Run(FILE_ERROR_OK);
     return;
   }
 
   // Create descendant directories.
   CreateDirectoryRecursively(resource_id, remaining_path, callback);
 }
 
 }  // namespace file_system
 }  // namespace drive