Use DriveService for proper resource id resolution in ChangeListLoader.

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"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/drive/change_list_loader_observer.h"
 #include "chrome/browser/chromeos/drive/change_list_processor.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/logging.h"
 #include "chrome/browser/chromeos/drive/resource_metadata.h"
 #include "chrome/browser/drive/drive_api_util.h"
+#include "chrome/browser/drive/drive_service_interface.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace internal {
 
 typedef base::Callback<void(FileError, ScopedVector<ChangeList>)>
@@ skipping 141 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,
+                       DriveServiceInterface* drive_service,
                        const std::string& directory_resource_id,
                        const std::string& root_folder_id)
       : scheduler_(scheduler),
+        drive_service_(drive_service),
         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 {
     if (util::IsDriveV2ApiEnabled() && root_folder_id_.empty()) {
@@ skipping 78 matching lines @@
                      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());
   }
 
+  // Fixes resource IDs in |change_list| into the format that |drive_service_|
+  // can understand. Note that |change_list| contains IDs in GData WAPI format
+  // since currently we always use WAPI for fast fetch, regardless of the flag.
   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()));
-      }
+      if (entry->has_resource_id())
+        entry->set_resource_id(FixResourceId(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()));
-      }
+      if (entry->has_parent_local_id())
+        entry->set_parent_local_id(FixResourceId(entry->parent_local_id()));
     }
   }
 
-  std::string UpgradeResourceIdFromGDataWapiToDriveApiV2(
-      const std::string& resource_id) {
+  std::string FixResourceId(const std::string& resource_id) {
     if (resource_id == util::kWapiRootDirectoryResourceId)
       return root_folder_id_;
-    return drive::util::CanonicalizeResourceId(resource_id);
+    return drive_service_->CanonicalizeResourceId(resource_id);
   }
 
   JobScheduler* scheduler_;
+  DriveServiceInterface* drive_service_;
   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,
-    JobScheduler* scheduler)
+    JobScheduler* scheduler,
+    DriveServiceInterface* drive_service)
     : blocking_task_runner_(blocking_task_runner),
       resource_metadata_(resource_metadata),
       scheduler_(scheduler),
+      drive_service_(drive_service),
       last_known_remote_changestamp_(0),
       loaded_(false),
       weak_ptr_factory_(this) {
 }
 
 ChangeListLoader::~ChangeListLoader() {
   STLDeleteElements(&fast_fetch_feed_fetcher_set_);
 }
 
 bool ChangeListLoader::IsRefreshing() const {
@@ skipping 428 matching lines @@
             &ChangeListLoader
                 ::DoLoadGrandRootDirectoryFromServerAfterGetResourceEntryByPath,
             weak_ptr_factory_.GetWeakPtr(),
             directory_fetch_info,
             callback));
     return;
   }
 
   FastFetchFeedFetcher* fetcher = new FastFetchFeedFetcher(
       scheduler_,
+      drive_service_,
       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));
 }
@@ skipping 186 matching lines @@
       FOR_EACH_OBSERVER(ChangeListLoaderObserver, observers_,
                         OnDirectoryChanged(*dir_iter));
     }
   }
 
   callback.Run();
 }
 
 }  // namespace internal
 }  // namespace drive