Use GData WAPI for FastFetch even if Drive API v2 is enabled.

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 160 matching lines @@
   int64 start_change_id_;
   ScopedVector<ChangeList> change_lists_;
   base::WeakPtrFactory<DeltaFeedFetcher> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DeltaFeedFetcher);
 };
 
 // Fetches the resource entries in the directory with |directory_resource_id|.
 class FastFetchFeedFetcher : public ChangeListLoader::FeedFetcher {
  public:
   FastFetchFeedFetcher(JobScheduler* scheduler,
-                       const std::string& directory_resource_id)
+                       const std::string& directory_resource_id,
+                       const std::string& root_folder_id)
       : scheduler_(scheduler),
         directory_resource_id_(directory_resource_id),
+        root_folder_id_(root_folder_id),
         weak_ptr_factory_(this) {
   }
 
   virtual ~FastFetchFeedFetcher() {
   }
 
   virtual void Run(const FeedFetcherCallback& callback) OVERRIDE {
-    scheduler_->GetResourceListInDirectory(
-        directory_resource_id_,
+    if (util::IsDriveV2ApiEnabled() && root_folder_id_.empty()) {
+      // The root folder id is not available yet. Fetch from the server.
+      scheduler_->GetAboutResource(
+          base::Bind(&FastFetchFeedFetcher::RunAfterGetAboutResource,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
+      return;
+    }
+
+    StartGetResourceListInDirectory(callback);
+  }
+
+ private:
+  void RunAfterGetAboutResource(
+      const FeedFetcherCallback& callback,
+      google_apis::GDataErrorCode status,
+      scoped_ptr<google_apis::AboutResource> about_resource) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK(!callback.is_null());
+
+    FileError error = GDataToFileError(status);
+    if (error != FILE_ERROR_OK) {
+      callback.Run(error, ScopedVector<ChangeList>());
+      return;
+    }
+
+    root_folder_id_ = about_resource->root_folder_id();
+    StartGetResourceListInDirectory(callback);
+  }
+
+  void StartGetResourceListInDirectory(const FeedFetcherCallback& callback) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK(!callback.is_null());
+    DCHECK(!directory_resource_id_.empty());
+    DCHECK(!util::IsDriveV2ApiEnabled() || !root_folder_id_.empty());
+
+    // We use WAPI's GetResourceListInDirectory even if Drive API v2 is
+    // enabled. This is the short term work around of the performance
+    // regression.
+
+    std::string resource_id = directory_resource_id_;
+    if (util::IsDriveV2ApiEnabled() &&
+        directory_resource_id_ == root_folder_id_) {
+      // GData WAPI doesn't accept the root directory id which is used in Drive
+      // API v2. So it is necessary to translate it here.
+      resource_id = util::kWapiRootDirectoryResourceId;
+    }
+
+    scheduler_->GetResourceListInDirectoryByWapi(
+        resource_id,
         base::Bind(&FastFetchFeedFetcher::OnFileListFetched,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
- private:
   void OnFileListFetched(
       const FeedFetcherCallback& callback,
       google_apis::GDataErrorCode status,
       scoped_ptr<google_apis::ResourceList> resource_list) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(!callback.is_null());
 
     FileError error = GDataToFileError(status);
     if (error != FILE_ERROR_OK) {
       callback.Run(error, ScopedVector<ChangeList>());
       return;
     }
 
     // Add the current change list to the list of collected lists.
     DCHECK(resource_list);
-    change_lists_.push_back(new ChangeList(*resource_list));
+    ChangeList* change_list = new ChangeList(*resource_list);
+    if (util::IsDriveV2ApiEnabled())
+      FixResourceIdInChangeList(change_list);
+    change_lists_.push_back(change_list);
 
     GURL next_url;
     if (resource_list->GetNextFeedURL(&next_url) && !next_url.is_empty()) {
       // There is the remaining result so fetch it.
       scheduler_->GetRemainingFileList(
           next_url,
           base::Bind(&FastFetchFeedFetcher::OnFileListFetched,
                      weak_ptr_factory_.GetWeakPtr(), callback));
       return;
     }
 
     // Note: The fetcher is managed by ChangeListLoader, and the instance
     // will be deleted in the callback. Do not touch the fields after this
     // invocation.
     callback.Run(FILE_ERROR_OK, change_lists_.Pass());
   }
 
+  void FixResourceIdInChangeList(ChangeList* change_list) {
+    std::vector<ResourceEntry>* entries = change_list->mutable_entries();
+    for (size_t i = 0; i < entries->size(); ++i) {
+      ResourceEntry* entry = &(*entries)[i];
+      if (entry->has_resource_id()) {
+        entry->set_resource_id(UpgradeResourceIdFromGDataWapiToDriveApiV2(
+            entry->resource_id()));
+      }
+
+      // Currently parent local id is the parent's resource id.
+      // It will be replaced by actual local id. (crbug.com/260514).
+      if (entry->has_parent_local_id()) {
+        entry->set_parent_local_id(UpgradeResourceIdFromGDataWapiToDriveApiV2(
+            entry->parent_local_id()));
+      }
+    }
+  }
+
+  std::string UpgradeResourceIdFromGDataWapiToDriveApiV2(
+      const std::string& resource_id) {
+    if (resource_id == util::kWapiRootDirectoryResourceId)
+      return root_folder_id_;
+    return drive::util::CanonicalizeResourceId(resource_id);
+  }
+
   JobScheduler* scheduler_;
   std::string directory_resource_id_;
+  std::string root_folder_id_;
   ScopedVector<ChangeList> change_lists_;
   base::WeakPtrFactory<FastFetchFeedFetcher> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(FastFetchFeedFetcher);
 };
 
 }  // namespace
 
 ChangeListLoader::ChangeListLoader(
     base::SequencedTaskRunner* blocking_task_runner,
     ResourceMetadata* resource_metadata,
@@ skipping 231 matching lines @@
     int64 local_changestamp,
     google_apis::GDataErrorCode status,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(GDataToFileError(status) == FILE_ERROR_OK,
             about_resource.get() != NULL);
 
   if (GDataToFileError(status) == FILE_ERROR_OK) {
     DCHECK(about_resource);
     last_known_remote_changestamp_ = about_resource->largest_change_id();
+    root_folder_id_ = about_resource->root_folder_id();
   }
 
   int64 remote_changestamp =
       about_resource ? about_resource->largest_change_id() : 0;
   if (remote_changestamp > 0 && local_changestamp >= remote_changestamp) {
     if (local_changestamp > remote_changestamp) {
       LOG(WARNING) << "Local resource metadata is fresher than server, local = "
                    << local_changestamp
                    << ", server = "
                    << remote_changestamp;
@@ skipping 106 matching lines @@
 }
 
 void ChangeListLoader::LoadDirectoryFromServerAfterGetAbout(
     const std::string& directory_resource_id,
     const FileOperationCallback& callback,
     google_apis::GDataErrorCode status,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (GDataToFileError(status) == FILE_ERROR_OK)
+  if (GDataToFileError(status) == FILE_ERROR_OK) {
+    DCHECK(about_resource);
     last_known_remote_changestamp_ = about_resource->largest_change_id();
+    root_folder_id_ = about_resource->root_folder_id();
+  }
 
   DoLoadDirectoryFromServer(
       DirectoryFetchInfo(directory_resource_id, last_known_remote_changestamp_),
       callback);
 }
 
 void ChangeListLoader::CheckChangestampAndLoadDirectoryIfNeeded(
     const DirectoryFetchInfo& directory_fetch_info,
     int64 local_changestamp,
     const FileOperationCallback& callback) {
@@ skipping 59 matching lines @@
             &ChangeListLoader
                 ::DoLoadGrandRootDirectoryFromServerAfterGetResourceEntryByPath,
             weak_ptr_factory_.GetWeakPtr(),
             directory_fetch_info,
             callback));
     return;
   }
 
   FastFetchFeedFetcher* fetcher = new FastFetchFeedFetcher(
       scheduler_,
-      directory_fetch_info.resource_id());
+      directory_fetch_info.resource_id(),
+      root_folder_id_);
   fast_fetch_feed_fetcher_set_.insert(fetcher);
   fetcher->Run(
       base::Bind(&ChangeListLoader::DoLoadDirectoryFromServerAfterLoad,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_fetch_info,
                  callback,
                  fetcher));
 }
 
 void
@@ skipping 184 matching lines @@
       FOR_EACH_OBSERVER(ChangeListLoaderObserver, observers_,
                         OnDirectoryChanged(*dir_iter));
     }
   }
 
   callback.Run();
 }
 
 }  // namespace internal
 }  // namespace drive