Add an abstraction to get the root_folder_id from change list loading.

Currently change list loader and directory loader use AboutResourceLoader to
get the root folder id. However, with team drives the root folder id is a
constant (the team drive id) and we need a way to supply this value when the
change list loader and directory loader are loading changelists for team
drives.

The RootFolderIdLoader pure virtual class allows us to provide an abstraction
for reading the root folder id either from AboutResource or a constant string.

Bug: 835703, 715355
Change-Id: I7d0766c5f813353186d3fbd3f6b20219c809eb4e
Reviewed-on: https://chromium-review.googlesource.com/1068527
Commit-Queue: Stuart Langley <slangley@chromium.org>
Reviewed-by: Naoki Fukino <fukino@chromium.org>
Reviewed-by: Sasha Morrissey <sashab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#561706}

components/drive/BUILD.gn

@@ -100,6 +100,8 @@ if (is_chromeos) {
     sources = [
       "chromeos/about_resource_loader.cc",
       "chromeos/about_resource_loader.h",
+      "chromeos/about_resource_root_folder_id_loader.cc",
+      "chromeos/about_resource_root_folder_id_loader.h",
       "chromeos/change_list_loader.cc",
       "chromeos/change_list_loader.h",
       "chromeos/change_list_loader_observer.h",
@@ -151,6 +153,7 @@ if (is_chromeos) {
       "chromeos/remove_stale_cache_files.h",
       "chromeos/resource_metadata.cc",
       "chromeos/resource_metadata.h",
+      "chromeos/root_folder_id_loader.h",
       "chromeos/search_metadata.cc",
       "chromeos/search_metadata.h",
       "chromeos/start_page_token_loader.cc",

components/drive/change_list_loader_unittest.cc

@@ -16,6 +16,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/drive/chromeos/about_resource_loader.h"
+#include "components/drive/chromeos/about_resource_root_folder_id_loader.h"
 #include "components/drive/chromeos/change_list_loader_observer.h"
 #include "components/drive/chromeos/drive_test_util.h"
 #include "components/drive/chromeos/file_cache.h"
@@ -111,12 +112,14 @@ class ChangeListLoaderTest : public testing::Test {
     ASSERT_EQ(FILE_ERROR_OK, metadata_->Initialize());
 
     about_resource_loader_.reset(new AboutResourceLoader(scheduler_.get()));
+    root_folder_id_loader_ = std::make_unique<AboutResourceRootFolderIdLoader>(
+        about_resource_loader_.get());
     start_page_token_loader_.reset(new StartPageTokenLoader(
         drive::util::kTeamDriveIdDefaultCorpus, scheduler_.get()));
     loader_controller_.reset(new LoaderController);
     change_list_loader_.reset(new ChangeListLoader(
         logger_.get(), base::ThreadTaskRunnerHandle::Get().get(),
-        metadata_.get(), scheduler_.get(), about_resource_loader_.get(),
+        metadata_.get(), scheduler_.get(), root_folder_id_loader_.get(),
         start_page_token_loader_.get(), loader_controller_.get()));
   }
 
@@ -157,6 +160,7 @@ class ChangeListLoaderTest : public testing::Test {
   std::unique_ptr<StartPageTokenLoader> start_page_token_loader_;
   std::unique_ptr<LoaderController> loader_controller_;
   std::unique_ptr<ChangeListLoader> change_list_loader_;
+  std::unique_ptr<AboutResourceRootFolderIdLoader> root_folder_id_loader_;
 };
 
 TEST_F(ChangeListLoaderTest, Load) {
@@ -254,11 +258,13 @@ TEST_F(ChangeListLoaderTest, Load_LocalMetadataAvailable) {
 
   // Reset loader.
   about_resource_loader_.reset(new AboutResourceLoader(scheduler_.get()));
+  root_folder_id_loader_ = std::make_unique<AboutResourceRootFolderIdLoader>(
+      about_resource_loader_.get());
   start_page_token_loader_.reset(new StartPageTokenLoader(
       drive::util::kTeamDriveIdDefaultCorpus, scheduler_.get()));
   change_list_loader_.reset(new ChangeListLoader(
       logger_.get(), base::ThreadTaskRunnerHandle::Get().get(), metadata_.get(),
-      scheduler_.get(), about_resource_loader_.get(),
+      scheduler_.get(), root_folder_id_loader_.get(),
       start_page_token_loader_.get(), loader_controller_.get()));
 
   // Add a file to the service.

components/drive/chromeos/about_resource_root_folder_id_loader.cc

+// Copyright 2018 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 "components/drive/chromeos/about_resource_root_folder_id_loader.h"
+
+#include <memory>
+
+#include "components/drive/chromeos/about_resource_loader.h"
+#include "google_apis/drive/drive_api_parser.h"
+
+namespace drive {
+namespace internal {
+
+AboutResourceRootFolderIdLoader::AboutResourceRootFolderIdLoader(
+    AboutResourceLoader* about_resource_loader)
+    : about_resource_loader_(about_resource_loader), weak_ptr_factory_(this) {}
+
+AboutResourceRootFolderIdLoader::~AboutResourceRootFolderIdLoader() = default;
+
+void AboutResourceRootFolderIdLoader::GetRootFolderId(
+    const RootFolderIdCallback& callback) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+  // After the initial load GetAboutResource will just return the cached value,
+  // avoiding any network calls.
+  about_resource_loader_->GetAboutResource(
+      base::BindRepeating(&AboutResourceRootFolderIdLoader::OnGetAboutResource,
+                          weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void AboutResourceRootFolderIdLoader::OnGetAboutResource(
+    const RootFolderIdCallback& callback,
+    google_apis::DriveApiErrorCode status,
+    std::unique_ptr<google_apis::AboutResource> about_resource) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  FileError error = GDataToFileError(status);
+
+  if (error != FILE_ERROR_OK) {
+    callback.Run(error, base::nullopt);
+    return;
+  }
+
+  DCHECK(about_resource);
+
+  callback.Run(error, about_resource->root_folder_id());
+}
+
+}  // namespace internal
+}  // namespace drive

components/drive/chromeos/about_resource_root_folder_id_loader.h

+// Copyright 2018 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.
+
+#ifndef COMPONENTS_DRIVE_CHROMEOS_ABOUT_RESOURCE_ROOT_FOLDER_ID_LOADER_H_
+#define COMPONENTS_DRIVE_CHROMEOS_ABOUT_RESOURCE_ROOT_FOLDER_ID_LOADER_H_
+
+#include <memory>
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
+#include "components/drive/chromeos/root_folder_id_loader.h"
+#include "google_apis/drive/drive_api_error_codes.h"
+
+namespace google_apis {
+class AboutResource;
+}  // namespace google_apis
+
+namespace drive {
+namespace internal {
+
+class AboutResourceLoader;
+
+// Retrieves the root folder id from the about resource loader. This is used
+// to get the root folder ID for the users default corpus. As the value is
+// constant we just use GetAboutResource which will usually retrieve a
+// cached value.
+class AboutResourceRootFolderIdLoader : public RootFolderIdLoader {
+ public:
+  explicit AboutResourceRootFolderIdLoader(
+      AboutResourceLoader* about_resource_loader);
+  ~AboutResourceRootFolderIdLoader() override;
+
+  void GetRootFolderId(const RootFolderIdCallback& callback) override;
+
+ private:
+  void OnGetAboutResource(
+      const RootFolderIdCallback& callback,
+      google_apis::DriveApiErrorCode error,
+      std::unique_ptr<google_apis::AboutResource> about_resource);
+
+  AboutResourceLoader* about_resource_loader_;  // Not owned.
+
+  THREAD_CHECKER(thread_checker_);
+
+  base::WeakPtrFactory<AboutResourceRootFolderIdLoader> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(AboutResourceRootFolderIdLoader);
+};
+
+}  // namespace internal
+}  // namespace drive
+
+#endif  // COMPONENTS_DRIVE_CHROMEOS_ABOUT_RESOURCE_ROOT_FOLDER_ID_LOADER_H_

components/drive/chromeos/change_list_loader.cc

@@ -17,11 +17,11 @@
 #include "base/synchronization/cancellation_flag.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "components/drive/chromeos/about_resource_loader.h"
 #include "components/drive/chromeos/change_list_loader_observer.h"
 #include "components/drive/chromeos/change_list_processor.h"
 #include "components/drive/chromeos/loader_controller.h"
 #include "components/drive/chromeos/resource_metadata.h"
+#include "components/drive/chromeos/root_folder_id_loader.h"
 #include "components/drive/chromeos/start_page_token_loader.h"
 #include "components/drive/drive_api_util.h"
 #include "components/drive/event_logger.h"
@@ -236,7 +236,7 @@ ChangeListLoader::ChangeListLoader(
     base::SequencedTaskRunner* blocking_task_runner,
     ResourceMetadata* resource_metadata,
     JobScheduler* scheduler,
-    AboutResourceLoader* about_resource_loader,
+    RootFolderIdLoader* root_folder_id_loader,
     StartPageTokenLoader* start_page_token_loader,
     LoaderController* loader_controller)
     : logger_(logger),
@@ -244,7 +244,7 @@ ChangeListLoader::ChangeListLoader(
       in_shutdown_(new base::CancellationFlag),
       resource_metadata_(resource_metadata),
       scheduler_(scheduler),
-      about_resource_loader_(about_resource_loader),
+      root_folder_id_loader_(root_folder_id_loader),
       start_page_token_loader_(start_page_token_loader),
       loader_controller_(loader_controller),
       loaded_(false),
@@ -356,30 +356,29 @@ void ChangeListLoader::LoadAfterGetLocalStartPageToken(
     pending_load_callback_.push_back(base::DoNothing());
   }
 
-  about_resource_loader_->GetAboutResource(
-      base::Bind(&ChangeListLoader::LoadAfterGetAboutResource,
+  root_folder_id_loader_->GetRootFolderId(
+      base::Bind(&ChangeListLoader::LoadAfterGetRootFolderId,
                  weak_ptr_factory_.GetWeakPtr(), *local_start_page_token));
 }
 
-void ChangeListLoader::LoadAfterGetAboutResource(
+void ChangeListLoader::LoadAfterGetRootFolderId(
     const std::string& local_start_page_token,
-    google_apis::DriveApiErrorCode status,
-    std::unique_ptr<google_apis::AboutResource> about_resource) {
+    FileError error,
+    base::Optional<std::string> root_folder_id) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!change_feed_fetcher_);
 
-  FileError error = GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     OnChangeListLoadComplete(error);
     return;
   }
 
-  DCHECK(about_resource);
+  DCHECK(root_folder_id);
 
   start_page_token_loader_->GetStartPageToken(
       base::Bind(&ChangeListLoader::LoadAfterGetStartPageToken,
                  weak_ptr_factory_.GetWeakPtr(), local_start_page_token,
-                 about_resource->root_folder_id()));
+                 std::move(root_folder_id.value())));
 }
 
 void ChangeListLoader::LoadAfterGetStartPageToken(

components/drive/chromeos/change_list_loader.h

@@ -27,7 +27,6 @@ class Time;
 }  // namespace base
 
 namespace google_apis {
-class AboutResource;
 class StartPageToken;
 }  // namespace google_apis
 
@@ -38,7 +37,7 @@ class JobScheduler;
 
 namespace internal {
 
-class AboutResourceLoader;
+class RootFolderIdLoader;
 class ChangeList;
 class ChangeListLoaderObserver;
 class ChangeListProcessor;
@@ -64,7 +63,7 @@ class ChangeListLoader {
                    base::SequencedTaskRunner* blocking_task_runner,
                    ResourceMetadata* resource_metadata,
                    JobScheduler* scheduler,
-                   AboutResourceLoader* about_resource_loader,
+                   RootFolderIdLoader* root_folder_id_loader,
                    StartPageTokenLoader* start_page_token_loader,
                    LoaderController* apply_task_controller);
   ~ChangeListLoader();
@@ -100,10 +99,9 @@ class ChangeListLoader {
       bool is_initial_load,
       const std::string* local_start_page_token,
       FileError error);
-  void LoadAfterGetAboutResource(
-      const std::string& local_start_page_token,
-      google_apis::DriveApiErrorCode status,
-      std::unique_ptr<google_apis::AboutResource> about_resource);
+  void LoadAfterGetRootFolderId(const std::string& local_start_page_token,
+                                FileError error,
+                                base::Optional<std::string> root_folder_id);
 
   void LoadAfterGetStartPageToken(
       const std::string& local_start_page_token,
@@ -161,7 +159,7 @@ class ChangeListLoader {
   std::unique_ptr<base::CancellationFlag> in_shutdown_;
   ResourceMetadata* resource_metadata_;  // Not owned.
   JobScheduler* scheduler_;  // Not owned.
-  AboutResourceLoader* about_resource_loader_;  // Not owned.
+  RootFolderIdLoader* root_folder_id_loader_;      // Not owned.
   StartPageTokenLoader* start_page_token_loader_;  // Not owned.
   LoaderController* loader_controller_;  // Not owned.
   base::ObserverList<ChangeListLoaderObserver> observers_;

components/drive/chromeos/default_corpus_change_list_loader.cc

@@ -6,6 +6,7 @@
 
 #include <memory>
 
+#include "components/drive/chromeos/about_resource_root_folder_id_loader.h"
 #include "components/drive/file_system_core_util.h"
 
 namespace drive {
@@ -22,19 +23,21 @@ DefaultCorpusChangeListLoader::DefaultCorpusChangeListLoader(
       blocking_task_runner_(blocking_task_runner),
       resource_metadata_(resource_metadata),
       scheduler_(scheduler),
-      about_resource_loader_(about_resource_loader),
       loader_controller_(apply_task_controller) {
+  root_folder_id_loader_ =
+      std::make_unique<AboutResourceRootFolderIdLoader>(about_resource_loader);
+
   start_page_token_loader_ = std::make_unique<StartPageTokenLoader>(
       util::kTeamDriveIdDefaultCorpus, scheduler_);
 
   change_list_loader_ = std::make_unique<ChangeListLoader>(
       logger_, blocking_task_runner_.get(), resource_metadata_, scheduler_,
-      about_resource_loader_, start_page_token_loader_.get(),
+      root_folder_id_loader_.get(), start_page_token_loader_.get(),
       loader_controller_);
 
   directory_loader_ = std::make_unique<DirectoryLoader>(
       logger_, blocking_task_runner_.get(), resource_metadata_, scheduler_,
-      about_resource_loader_, start_page_token_loader_.get(),
+      root_folder_id_loader_.get(), start_page_token_loader_.get(),
       loader_controller_);
 }
 

components/drive/chromeos/default_corpus_change_list_loader.h

@@ -5,7 +5,10 @@
 #ifndef COMPONENTS_DRIVE_CHROMEOS_DEFAULT_CORPUS_CHANGE_LIST_LOADER_H_
 #define COMPONENTS_DRIVE_CHROMEOS_DEFAULT_CORPUS_CHANGE_LIST_LOADER_H_
 
+#include <memory>
+
 #include "base/macros.h"
+#include "components/drive/chromeos/about_resource_root_folder_id_loader.h"
 #include "components/drive/chromeos/change_list_loader.h"
 #include "components/drive/chromeos/directory_loader.h"
 #include "components/drive/chromeos/drive_change_list_loader.h"
@@ -49,6 +52,8 @@ class DefaultCorpusChangeListLoader : public DriveChangeListLoader {
   void CheckForUpdates(const FileOperationCallback& callback) override;
 
  private:
+  std::unique_ptr<internal::AboutResourceRootFolderIdLoader>
+      root_folder_id_loader_;
   std::unique_ptr<internal::ChangeListLoader> change_list_loader_;
   std::unique_ptr<internal::DirectoryLoader> directory_loader_;
   std::unique_ptr<internal::StartPageTokenLoader> start_page_token_loader_;
@@ -57,7 +62,6 @@ class DefaultCorpusChangeListLoader : public DriveChangeListLoader {
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   ResourceMetadata* resource_metadata_;         // Not owned.
   JobScheduler* scheduler_;                     // Not owned.
-  AboutResourceLoader* about_resource_loader_;  // Not owned.
   LoaderController* loader_controller_;         // Not owned.
 
   THREAD_CHECKER(thread_checker_);

components/drive/chromeos/directory_loader.cc

@@ -16,11 +16,11 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
-#include "components/drive/chromeos/about_resource_loader.h"
 #include "components/drive/chromeos/change_list_loader_observer.h"
 #include "components/drive/chromeos/change_list_processor.h"
 #include "components/drive/chromeos/loader_controller.h"
 #include "components/drive/chromeos/resource_metadata.h"
+#include "components/drive/chromeos/root_folder_id_loader.h"
 #include "components/drive/chromeos/start_page_token_loader.h"
 #include "components/drive/drive_api_util.h"
 #include "components/drive/event_logger.h"
@@ -202,14 +202,14 @@ DirectoryLoader::DirectoryLoader(
     base::SequencedTaskRunner* blocking_task_runner,
     ResourceMetadata* resource_metadata,
     JobScheduler* scheduler,
-    AboutResourceLoader* about_resource_loader,
+    RootFolderIdLoader* root_folder_id_loader,
     StartPageTokenLoader* start_page_token_loader,
     LoaderController* loader_controller)
     : logger_(logger),
       blocking_task_runner_(blocking_task_runner),
       resource_metadata_(resource_metadata),
       scheduler_(scheduler),
-      about_resource_loader_(about_resource_loader),
+      root_folder_id_loader_(root_folder_id_loader),
       start_page_token_loader_(start_page_token_loader),
       loader_controller_(loader_controller),
       weak_ptr_factory_(this) {}
@@ -298,8 +298,8 @@ void DirectoryLoader::ReadDirectoryAfterGetEntry(
   if (pending_load_callback_[local_id].size() > 1)
     return;
 
-  about_resource_loader_->GetAboutResource(
-      base::Bind(&DirectoryLoader::ReadDirectoryAfterGetAboutResource,
+  root_folder_id_loader_->GetRootFolderId(
+      base::Bind(&DirectoryLoader::ReadDirectoryAfterGetRootFolderId,
                  weak_ptr_factory_.GetWeakPtr(), local_id));
 }
 
@@ -333,24 +333,22 @@ void DirectoryLoader::ReadDirectoryAfterLoadParent(
                  base::Owned(entry)));
 }
 
-void DirectoryLoader::ReadDirectoryAfterGetAboutResource(
+void DirectoryLoader::ReadDirectoryAfterGetRootFolderId(
     const std::string& local_id,
-    google_apis::DriveApiErrorCode status,
-    std::unique_ptr<google_apis::AboutResource> about_resource) {
+    FileError error,
+    base::Optional<std::string> root_folder_id) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-  FileError error = GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     OnDirectoryLoadComplete(local_id, error);
     return;
   }
 
-  DCHECK(about_resource);
+  DCHECK(root_folder_id);
 
-  start_page_token_loader_->GetStartPageToken(
-      base::Bind(&DirectoryLoader::ReadDirectoryAfterGetStartPageToken,
-                 weak_ptr_factory_.GetWeakPtr(), local_id,
-                 about_resource->root_folder_id()));
+  start_page_token_loader_->GetStartPageToken(base::Bind(
+      &DirectoryLoader::ReadDirectoryAfterGetStartPageToken,
+      weak_ptr_factory_.GetWeakPtr(), local_id, root_folder_id.value()));
 }
 
 void DirectoryLoader::ReadDirectoryAfterGetStartPageToken(
@@ -378,12 +376,14 @@ void DirectoryLoader::ReadDirectoryAfterGetStartPageToken(
       base::BindOnce(&DirectoryLoader::ReadDirectoryAfterCheckLocalState,
                      weak_ptr_factory_.GetWeakPtr(),
                      start_page_token->start_page_token(), local_id,
-                     base::Owned(entry), base::Owned(local_start_page_token)));
+                     root_folder_id, base::Owned(entry),
+                     base::Owned(local_start_page_token)));
 }
 
 void DirectoryLoader::ReadDirectoryAfterCheckLocalState(
     const std::string& remote_start_page_token,
     const std::string& local_id,
+    const std::string& root_folder_id,
     const ResourceEntry* entry,
     const std::string* local_start_page_token,
     FileError error) {
@@ -418,7 +418,7 @@ void DirectoryLoader::ReadDirectoryAfterCheckLocalState(
         "load directory from server %s; directory start page token: %s ",
         directory_fetch_info.ToString().c_str(),
         directory_start_page_token.c_str());
-    LoadDirectoryFromServer(directory_fetch_info);
+    LoadDirectoryFromServer(directory_fetch_info, root_folder_id);
     return;
   }
 
@@ -435,7 +435,7 @@ void DirectoryLoader::ReadDirectoryAfterCheckLocalState(
         "remove start page token: %s",
         directory_fetch_info.ToString().c_str(),
         local_start_page_token->c_str(), remote_start_page_token.c_str());
-    LoadDirectoryFromServer(directory_fetch_info);
+    LoadDirectoryFromServer(directory_fetch_info, root_folder_id);
     return;
   }
 
@@ -452,7 +452,7 @@ void DirectoryLoader::ReadDirectoryAfterCheckLocalState(
   } else {
     // Start fetching the directory content, and mark it with the changestamp
     // |remote_changestamp|.
-    LoadDirectoryFromServer(directory_fetch_info);
+    LoadDirectoryFromServer(directory_fetch_info, root_folder_id);
   }
 }
 
@@ -533,7 +533,8 @@ void DirectoryLoader::SendEntries(const std::string& local_id,
 }
 
 void DirectoryLoader::LoadDirectoryFromServer(
-    const DirectoryFetchInfo& directory_fetch_info) {
+    const DirectoryFetchInfo& directory_fetch_info,
+    const std::string& root_folder_id) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!directory_fetch_info.empty());
   DVLOG(1) << "Start loading directory: " << directory_fetch_info.ToString();
@@ -547,13 +548,9 @@ void DirectoryLoader::LoadDirectoryFromServer(
                directory_fetch_info.ToString().c_str(),
                start_page_token->start_page_token().c_str());
 
-  const google_apis::AboutResource* about_resource =
-      about_resource_loader_->cached_about_resource();
-  DCHECK(about_resource);
+  FeedFetcher* fetcher =
+      new FeedFetcher(this, directory_fetch_info, root_folder_id);
 
-  FeedFetcher* fetcher = new FeedFetcher(this,
-                                         directory_fetch_info,
-                                         about_resource->root_folder_id());
   fast_fetch_feed_fetcher_set_.insert(base::WrapUnique(fetcher));
   fetcher->Run(
       base::Bind(&DirectoryLoader::LoadDirectoryFromServerAfterLoad,

components/drive/chromeos/directory_loader.h

@@ -27,10 +27,6 @@ namespace base {
 class SequencedTaskRunner;
 }  // namespace base
 
-namespace google_apis {
-class AboutResource;
-}  // namespace google_apis
-
 namespace drive {
 
 class EventLogger;
@@ -39,7 +35,7 @@ class ResourceEntry;
 
 namespace internal {
 
-class AboutResourceLoader;
+class RootFolderIdLoader;
 class ChangeListLoaderObserver;
 class DirectoryFetchInfo;
 class LoaderController;
@@ -53,7 +49,7 @@ class DirectoryLoader {
                   base::SequencedTaskRunner* blocking_task_runner,
                   ResourceMetadata* resource_metadata,
                   JobScheduler* scheduler,
-                  AboutResourceLoader* about_resource_loader,
+                  RootFolderIdLoader* root_folder_id_loader,
                   StartPageTokenLoader* start_page_token_loader,
                   LoaderController* apply_task_controller);
   ~DirectoryLoader();
@@ -86,10 +82,10 @@ class DirectoryLoader {
       const ReadDirectoryEntriesCallback& entries_callback,
       const FileOperationCallback& completion_callback,
       FileError error);
-  void ReadDirectoryAfterGetAboutResource(
+  void ReadDirectoryAfterGetRootFolderId(
       const std::string& local_id,
-      google_apis::DriveApiErrorCode status,
-      std::unique_ptr<google_apis::AboutResource> about_resource);
+      FileError error,
+      base::Optional<std::string> root_folder_id);
   void ReadDirectoryAfterGetStartPageToken(
       const std::string& local_id,
       const std::string& root_folder_id,
@@ -99,6 +95,7 @@ class DirectoryLoader {
   void ReadDirectoryAfterCheckLocalState(
       const std::string& remote_start_page_token,
       const std::string& local_id,
+      const std::string& root_folder_id,
       const ResourceEntry* entry,
       const std::string* local_start_page_token,
       FileError error);
@@ -118,7 +115,8 @@ class DirectoryLoader {
   // ================= Implementation for directory loading =================
   // Loads the directory contents from server, and updates the local metadata.
   // Runs |callback| when it is finished.
-  void LoadDirectoryFromServer(const DirectoryFetchInfo& directory_fetch_info);
+  void LoadDirectoryFromServer(const DirectoryFetchInfo& directory_fetch_info,
+                               const std::string& root_folder_id);
 
   // Part of LoadDirectoryFromServer() for a normal directory.
   void LoadDirectoryFromServerAfterLoad(
@@ -136,7 +134,7 @@ class DirectoryLoader {
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   ResourceMetadata* resource_metadata_;  // Not owned.
   JobScheduler* scheduler_;  // Not owned.
-  AboutResourceLoader* about_resource_loader_;  // Not owned.
+  RootFolderIdLoader* root_folder_id_loader_;      // Not owned.
   StartPageTokenLoader* start_page_token_loader_;  // Not owned
   LoaderController* loader_controller_;  // Not owned.
   base::ObserverList<ChangeListLoaderObserver> observers_;

components/drive/chromeos/root_folder_id_loader.h

+// Copyright 2018 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.
+
+#ifndef COMPONENTS_DRIVE_CHROMEOS_ROOT_FOLDER_ID_LOADER_H_
+#define COMPONENTS_DRIVE_CHROMEOS_ROOT_FOLDER_ID_LOADER_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "base/optional.h"
+#include "components/drive/file_errors.h"
+
+namespace drive {
+namespace internal {
+
+using RootFolderIdCallback =
+    base::RepeatingCallback<void(FileError, base::Optional<std::string>)>;
+
+// RootFolderIdLoader is an interface that will load the root_folder_id for
+// change list loader and directory loader.
+class RootFolderIdLoader {
+ public:
+  virtual ~RootFolderIdLoader() = default;
+
+  // Retrieve the root folder id, which may be obtained from the server or
+  // potentially could be a constant value.
+  virtual void GetRootFolderId(const RootFolderIdCallback& callback) = 0;
+};
+
+}  // namespace internal
+}  // namespace drive
+
+#endif  // COMPONENTS_DRIVE_CHROMEOS_ROOT_FOLDER_ID_LOADER_H_

components/drive/directory_loader_unittest.cc

@@ -13,6 +13,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/drive/chromeos/about_resource_loader.h"
+#include "components/drive/chromeos/about_resource_root_folder_id_loader.h"
 #include "components/drive/chromeos/change_list_loader_observer.h"
 #include "components/drive/chromeos/drive_test_util.h"
 #include "components/drive/chromeos/file_cache.h"
@@ -100,12 +101,14 @@ class DirectoryLoaderTest : public testing::Test {
     ASSERT_EQ(FILE_ERROR_OK, metadata_->Initialize());
 
     about_resource_loader_.reset(new AboutResourceLoader(scheduler_.get()));
+    root_folder_id_loader_ = std::make_unique<AboutResourceRootFolderIdLoader>(
+        about_resource_loader_.get());
     start_page_token_loader_.reset(new StartPageTokenLoader(
         drive::util::kTeamDriveIdDefaultCorpus, scheduler_.get()));
     loader_controller_.reset(new LoaderController);
     directory_loader_.reset(new DirectoryLoader(
         logger_.get(), base::ThreadTaskRunnerHandle::Get().get(),
-        metadata_.get(), scheduler_.get(), about_resource_loader_.get(),
+        metadata_.get(), scheduler_.get(), root_folder_id_loader_.get(),
         start_page_token_loader_.get(), loader_controller_.get()));
   }
 
@@ -140,6 +143,7 @@ class DirectoryLoaderTest : public testing::Test {
   std::unique_ptr<StartPageTokenLoader> start_page_token_loader_;
   std::unique_ptr<LoaderController> loader_controller_;
   std::unique_ptr<DirectoryLoader> directory_loader_;
+  std::unique_ptr<AboutResourceRootFolderIdLoader> root_folder_id_loader_;
 };
 
 TEST_F(DirectoryLoaderTest, ReadDirectory_GrandRoot) {

components/drive/file_system/operation_test_base.cc

@@ -6,6 +6,7 @@
 
 #include "base/task_scheduler/post_task.h"
 #include "components/drive/chromeos/about_resource_loader.h"
+#include "components/drive/chromeos/about_resource_root_folder_id_loader.h"
 #include "components/drive/chromeos/change_list_loader.h"
 #include "components/drive/chromeos/fake_free_disk_space_getter.h"
 #include "components/drive/chromeos/file_cache.h"
@@ -122,12 +123,15 @@ void OperationTestBase::SetUp() {
   // Makes sure the FakeDriveService's content is loaded to the metadata_.
   about_resource_loader_.reset(new internal::AboutResourceLoader(
       scheduler_.get()));
+  root_folder_id_loader_ =
+      std::make_unique<internal::AboutResourceRootFolderIdLoader>(
+          about_resource_loader_.get());
   start_page_token_loader_.reset(new internal::StartPageTokenLoader(
       drive::util::kTeamDriveIdDefaultCorpus, scheduler_.get()));
   loader_controller_.reset(new internal::LoaderController);
   change_list_loader_.reset(new internal::ChangeListLoader(
       logger_.get(), blocking_task_runner_.get(), metadata_.get(),
-      scheduler_.get(), about_resource_loader_.get(),
+      scheduler_.get(), root_folder_id_loader_.get(),
       start_page_token_loader_.get(), loader_controller_.get()));
   change_list_loader_->LoadIfNeeded(
       google_apis::test_util::CreateCopyResultCallback(&error));

components/drive/file_system/operation_test_base.h

@@ -31,6 +31,7 @@ class JobScheduler;
 
 namespace internal {
 class AboutResourceLoader;
+class AboutResourceRootFolderIdLoader;
 class ChangeListLoader;
 class FileCache;
 class LoaderController;
@@ -161,6 +162,8 @@ class OperationTestBase : public testing::Test {
   std::unique_ptr<internal::StartPageTokenLoader> start_page_token_loader_;
   std::unique_ptr<internal::LoaderController> loader_controller_;
   std::unique_ptr<internal::ChangeListLoader> change_list_loader_;
+  std::unique_ptr<internal::AboutResourceRootFolderIdLoader>
+      root_folder_id_loader_;
 };
 
 }  // namespace file_system

components/drive/sync_client_unittest.cc

@@ -14,6 +14,7 @@
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/drive/chromeos/about_resource_loader.h"
+#include "components/drive/chromeos/about_resource_root_folder_id_loader.h"
 #include "components/drive/chromeos/change_list_loader.h"
 #include "components/drive/chromeos/drive_test_util.h"
 #include "components/drive/chromeos/fake_free_disk_space_getter.h"
@@ -138,12 +139,15 @@ class SyncClientTest : public testing::Test {
     ASSERT_EQ(FILE_ERROR_OK, metadata_->Initialize());
 
     about_resource_loader_.reset(new AboutResourceLoader(scheduler_.get()));
+    root_folder_id_loader_ = std::make_unique<AboutResourceRootFolderIdLoader>(
+        about_resource_loader_.get());
+
     start_page_token_loader_.reset(new StartPageTokenLoader(
         drive::util::kTeamDriveIdDefaultCorpus, scheduler_.get()));
     loader_controller_.reset(new LoaderController);
     change_list_loader_.reset(new ChangeListLoader(
         logger_.get(), base::ThreadTaskRunnerHandle::Get().get(),
-        metadata_.get(), scheduler_.get(), about_resource_loader_.get(),
+        metadata_.get(), scheduler_.get(), root_folder_id_loader_.get(),
         start_page_token_loader_.get(), loader_controller_.get()));
     ASSERT_NO_FATAL_FAILURE(SetUpTestData());
 
@@ -265,6 +269,7 @@ class SyncClientTest : public testing::Test {
   std::unique_ptr<LoaderController> loader_controller_;
   std::unique_ptr<ChangeListLoader> change_list_loader_;
   std::unique_ptr<SyncClient> sync_client_;
+  std::unique_ptr<AboutResourceRootFolderIdLoader> root_folder_id_loader_;
 
   std::map<std::string, std::string> resource_ids_;  // Name-to-id map.
 };