drive: Replace GetResourceListCallback in DriveServiceInterface with FileListCallback

chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc

 // Copyright 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/sync_file_system/drive_backend/sync_engine_initializer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/browser/drive/drive_api_service.h"
-#include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/gdata_wapi_parser.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 // Functions below are for wrapping the access to legacy GData WAPI classes.
 
-bool HasNoParents(const google_apis::ResourceEntry& entry) {
-  return !entry.GetLinkByType(google_apis::Link::LINK_PARENT);
+bool HasNoParents(const google_apis::FileResource& entry) {
+  return entry.parents().empty();
 }
 
-bool HasFolderAsParent(const google_apis::ResourceEntry& entry,
+bool HasFolderAsParent(const google_apis::FileResource& entry,
                        const std::string& parent_id) {
-  const ScopedVector<google_apis::Link>& links = entry.links();
-  for (ScopedVector<google_apis::Link>::const_iterator itr = links.begin();
-       itr != links.end(); ++itr) {
-    const google_apis::Link& link = **itr;
-    if (link.type() != google_apis::Link::LINK_PARENT)
-      continue;
-    if (drive::util::ExtractResourceIdFromUrl(link.href()) == parent_id)
+  for (size_t i = 0; i < entry.parents().size(); ++i) {
+    if (entry.parents()[i].file_id() == parent_id)
       return true;
   }
   return false;
 }
 
-bool LessOnCreationTime(const google_apis::ResourceEntry& left,
-                        const google_apis::ResourceEntry& right) {
-  return left.published_time() < right.published_time();
+bool LessOnCreationTime(const google_apis::FileResource& left,
+                        const google_apis::FileResource& right) {
+  return left.created_date() < right.created_date();
 }
 
 typedef base::Callback<void(scoped_ptr<SyncTaskToken> token,
                             google_apis::GDataErrorCode error,
                             scoped_ptr<google_apis::ResourceList> resources)>
     TokenAndResourceListCallback;
 
-ScopedVector<google_apis::FileResource> ConvertResourceEntriesToFileResources(
-    const ScopedVector<google_apis::ResourceEntry>& entries) {
-  ScopedVector<google_apis::FileResource> resources;
-  for (ScopedVector<google_apis::ResourceEntry>::const_iterator itr =
-           entries.begin();
-       itr != entries.end();
-       ++itr) {
-    resources.push_back(
-        drive::util::ConvertResourceEntryToFileResource(
-            **itr).release());
-  }
-  return resources.Pass();
-}
-
 // Functions above are for wrapping the access to legacy GData WAPI classes.
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace
 
 SyncEngineInitializer::SyncEngineInitializer(
     SyncEngineContext* sync_context,
     const base::FilePath& database_path,
     leveldb::Env* env_override)
     : sync_context_(sync_context),
@@ skipping 102 matching lines @@
       kSyncRootFolderTitle,
       std::string(),  // parent_folder_id
       base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidFindSyncRoot(
     scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
-    scoped_ptr<google_apis::ResourceList> resource_list) {
+    scoped_ptr<google_apis::FileList> file_list) {
   cancel_callback_.Reset();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to find sync root.");
     SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
-  if (!resource_list) {
+  if (!file_list) {
     NOTREACHED();
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Got invalid resource list.");
     SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
-  ScopedVector<google_apis::ResourceEntry>* entries =
-      resource_list->mutable_entries();
-  for (ScopedVector<google_apis::ResourceEntry>::iterator itr =
-           entries->begin();
-       itr != entries->end(); ++itr) {
-    google_apis::ResourceEntry* entry = *itr;
+  ScopedVector<google_apis::FileResource>* items = file_list->mutable_items();
+  for (ScopedVector<google_apis::FileResource>::iterator itr = items->begin();
+       itr != items->end(); ++itr) {
+    google_apis::FileResource* entry = *itr;
 
     // Ignore deleted folder.
-    if (entry->deleted())
+    if (entry->labels().is_trashed())
       continue;
 
     // Pick an orphaned folder or a direct child of the root folder and
     // ignore others.
     DCHECK(!root_folder_id_.empty());
     if (!HasNoParents(*entry) && !HasFolderAsParent(*entry, root_folder_id_))
       continue;
 
     if (!sync_root_folder_ || LessOnCreationTime(*entry, *sync_root_folder_)) {
       sync_root_folder_.reset(entry);
       *itr = NULL;
     }
   }
 
   set_used_network(true);
   // If there are more results, retrieve them.
-  GURL next_url;
-  if (resource_list->GetNextFeedURL(&next_url)) {
+  if (!file_list->next_link().is_empty()) {
     cancel_callback_ = sync_context_->GetDriveService()->GetRemainingFileList(
-        next_url,
+        file_list->next_link(),
         base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(&token)));
     return;
   }
 
   if (!sync_root_folder_) {
     CreateSyncRoot(token.Pass());
     return;
   }
@@ skipping 34 matching lines @@
 
   FindSyncRoot(token.Pass());
 }
 
 void SyncEngineInitializer::DetachSyncRoot(scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   set_used_network(true);
   cancel_callback_ =
       sync_context_->GetDriveService()->RemoveResourceFromDirectory(
           root_folder_id_,
-          sync_root_folder_->resource_id(),
+          sync_root_folder_->file_id(),
           base::Bind(&SyncEngineInitializer::DidDetachSyncRoot,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidDetachSyncRoot(
     scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error) {
   cancel_callback_.Reset();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to detach sync root.");
     SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
   ListAppRootFolders(token.Pass());
 }
 
 void SyncEngineInitializer::ListAppRootFolders(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   set_used_network(true);
   cancel_callback_ =
-      sync_context_->GetDriveService()->GetResourceListInDirectory(
-          sync_root_folder_->resource_id(),
+      sync_context_->GetDriveService()->GetFileListInDirectory(
+          sync_root_folder_->file_id(),
           base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidListAppRootFolders(
     scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
-    scoped_ptr<google_apis::ResourceList> resource_list) {
+    scoped_ptr<google_apis::FileList> file_list) {
   cancel_callback_.Reset();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to get initial app-root folders.");
     SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
-  if (!resource_list) {
+  if (!file_list) {
     NOTREACHED();
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Got invalid initial app-root list.");
     SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
-  ScopedVector<google_apis::ResourceEntry>* new_entries =
-      resource_list->mutable_entries();
+  ScopedVector<google_apis::FileResource>* new_entries =
+      file_list->mutable_items();
   app_root_folders_.insert(app_root_folders_.end(),
                            new_entries->begin(), new_entries->end());
   new_entries->weak_clear();
 
   set_used_network(true);
-  GURL next_url;
-  if (resource_list->GetNextFeedURL(&next_url)) {
+  if (!file_list->next_link().is_empty()) {
     cancel_callback_ =
         sync_context_->GetDriveService()->GetRemainingFileList(
-            next_url,
+            file_list->next_link(),
             base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
                        weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
     return;
   }
 
   PopulateDatabase(token.Pass());
 }
 
 void SyncEngineInitializer::PopulateDatabase(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   metadata_database_->PopulateInitialData(
       largest_change_id_,
-      *drive::util::ConvertResourceEntryToFileResource(
-          *sync_root_folder_),
-      ConvertResourceEntriesToFileResources(app_root_folders_),
+      *sync_root_folder_,
+      app_root_folders_,
       base::Bind(&SyncEngineInitializer::DidPopulateDatabase,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidPopulateDatabase(
     scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to populate initial data"
               " to MetadataDatabase.");
     SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[Initialize] Completed successfully.");
   SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system