drive: Stop comparing resource ID against kDriveGrandRootLocalId

chrome/browser/chromeos/drive/change_list_loader.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/drive/change_list_loader.h"
 
 #include <set>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ skipping 433 matching lines @@
     callback.Run(FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   // drive/other does not exist on the server.
   if (entry->local_id() == util::kDriveOtherDirLocalId) {
     callback.Run(FILE_ERROR_OK);
     return;
   }
 
-  Load(DirectoryFetchInfo(entry->resource_id(),
+  Load(DirectoryFetchInfo(entry->local_id(),
+                          entry->resource_id(),
                           entry->directory_specific_info().changestamp()),
        callback);
 }
 
 void ChangeListLoader::LoadDirectoryIfNeededAfterLoadParent(
     const base::FilePath& directory_path,
     const FileOperationCallback& callback,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
@@ skipping 22 matching lines @@
 void ChangeListLoader::Load(const DirectoryFetchInfo& directory_fetch_info,
                             const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Check if this is the first time this ChangeListLoader do loading.
   // Note: IsRefreshing() depends on pending_load_callback_ so check in advance.
   const bool is_initial_load = (!loaded_ && !IsRefreshing());
 
   // Register the callback function to be called when it is loaded.
-  const std::string& resource_id = directory_fetch_info.resource_id();
-  pending_load_callback_[resource_id].push_back(callback);
+  const std::string& local_id = directory_fetch_info.local_id();
+  pending_load_callback_[local_id].push_back(callback);
 
   // If loading task for |resource_id| is already running, do nothing.
-  if (pending_load_callback_[resource_id].size() > 1)
+  if (pending_load_callback_[local_id].size() > 1)
     return;
 
   // For initial loading, even for directory fetching, we do load the full
   // resource list from the server to sync up. So we register a dummy
   // callback to indicate that update for full hierarchy is running.
-  if (is_initial_load && !resource_id.empty()) {
+  if (is_initial_load && !directory_fetch_info.empty()) {
     pending_load_callback_[""].push_back(
         base::Bind(&util::EmptyFileOperationCallback));
   }
 
   // Check the current status of local metadata, and start loading if needed.
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&ResourceMetadata::GetLargestChangestamp,
                  base::Unretained(resource_metadata_)),
       base::Bind(&ChangeListLoader::LoadAfterGetLargestChangestamp,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_fetch_info,
                  is_initial_load));
 }
 
 void ChangeListLoader::LoadAfterGetLargestChangestamp(
     const DirectoryFetchInfo& directory_fetch_info,
     bool is_initial_load,
     int64 local_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (is_initial_load && local_changestamp > 0) {
     // The local data is usable. Flush callbacks to tell loading was successful.
     OnChangeListLoadComplete(FILE_ERROR_OK);
 
     // Continues to load from server in background.
     // Put dummy callbacks to indicate that fetching is still continuing.
-    pending_load_callback_[directory_fetch_info.resource_id()].push_back(
+    pending_load_callback_[directory_fetch_info.local_id()].push_back(
         base::Bind(&util::EmptyFileOperationCallback));
     if (!directory_fetch_info.empty()) {
       pending_load_callback_[""].push_back(
           base::Bind(&util::EmptyFileOperationCallback));
     }
   }
 
   if (directory_fetch_info.empty()) {
     UpdateAboutResource(base::Bind(&ChangeListLoader::LoadAfterGetAboutResource,
                                    weak_ptr_factory_.GetWeakPtr(),
@@ skipping 68 matching lines @@
     // callback, as there is no need to fetch the directory.
     if (directory_changestamp >= remote_changestamp) {
       LoadAfterLoadDirectory(directory_fetch_info, is_initial_load,
                              start_changestamp, FILE_ERROR_OK);
       return;
     }
 
     // Start fetching the directory content, and mark it with the changestamp
     // |remote_changestamp|.
     DirectoryFetchInfo new_directory_fetch_info(
-        directory_fetch_info.resource_id(), remote_changestamp);
+        directory_fetch_info.local_id(), directory_fetch_info.resource_id(),
+        remote_changestamp);
     LoadDirectoryFromServer(
         new_directory_fetch_info,
         base::Bind(&ChangeListLoader::LoadAfterLoadDirectory,
                    weak_ptr_factory_.GetWeakPtr(),
                    directory_fetch_info,
                    is_initial_load,
                    start_changestamp));
   }
 }
 
@@ skipping 42 matching lines @@
 
 void ChangeListLoader::OnDirectoryLoadComplete(
     const DirectoryFetchInfo& directory_fetch_info,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   util::Log(logging::LOG_INFO,
             "Fast-fetch complete: %s => %s",
             directory_fetch_info.ToString().c_str(),
             FileErrorToString(error).c_str());
-  const std::string& resource_id = directory_fetch_info.resource_id();
-  LoadCallbackMap::iterator it = pending_load_callback_.find(resource_id);
+  const std::string& local_id = directory_fetch_info.local_id();
+  LoadCallbackMap::iterator it = pending_load_callback_.find(local_id);
   if (it != pending_load_callback_.end()) {
-    DVLOG(1) << "Running callback for " << resource_id;
+    DVLOG(1) << "Running callback for " << local_id;
     const std::vector<FileOperationCallback>& callbacks = it->second;
     for (size_t i = 0; i < callbacks.size(); ++i) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(callbacks[i], error));
     }
     pending_load_callback_.erase(it);
   }
 }
 
@@ skipping 93 matching lines @@
 
 void ChangeListLoader::LoadDirectoryFromServer(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(!directory_fetch_info.empty());
   DCHECK(cached_about_resource_);
   DVLOG(1) << "Start loading directory: " << directory_fetch_info.ToString();
 
-  if (directory_fetch_info.resource_id() == util::kDriveGrandRootLocalId) {
+  if (directory_fetch_info.local_id() == util::kDriveGrandRootLocalId) {
     // Load for a grand root directory means slightly different from other
     // directories. It should have two directories; <other> and mydrive root.
     // <other> directory should always exist, but mydrive root should be
     // created by root resource id retrieved from the server.
     base::FilePath* changed_directory_path = new base::FilePath;
     base::PostTaskAndReplyWithResult(
         blocking_task_runner_,
         FROM_HERE,
         base::Bind(&AddMyDriveIfNeeded,
                    resource_metadata_,
@@ skipping 30 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(!directory_fetch_info.empty());
 
   // Delete the fetcher.
   fast_fetch_feed_fetcher_set_.erase(fetcher);
   delete fetcher;
 
   if (error != FILE_ERROR_OK) {
     LOG(ERROR) << "Failed to load directory: "
-               << directory_fetch_info.resource_id()
+               << directory_fetch_info.local_id()
                << ": " << FileErrorToString(error);
     callback.Run(error);
     return;
   }
 
   base::FilePath* directory_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&ChangeListProcessor::RefreshDirectory,
@@ skipping 55 matching lines @@
 
     cached_about_resource_.reset(
         new google_apis::AboutResource(*about_resource));
   }
 
   callback.Run(status, about_resource.Pass());
 }
 
 }  // namespace internal
 }  // namespace drive