Encapsulate change list and directory loading into a common interface.

This CL introduces a new pure virtual class, DriveChangeListLoader,
which we can specialize to load from the users default corpus or from
users team drives.

The first specialziation is DefaultCorpusChangeListLoader, which now
contains the existing change_list_loader, start_page_token_loader and
directory_loader objects.

Follow up work is to introduce a TeamDriveChangeListLoader which can
load change lists and retreive directories for specific team drives.

Bug: 715355

Change-Id: Ica88b2190c7d4abac6955784db7aada287f8be2c
Reviewed-on: https://chromium-review.googlesource.com/1064653
Commit-Queue: Stuart Langley <slangley@chromium.org>
Reviewed-by: Naoki Fukino <fukino@chromium.org>
Cr-Commit-Position: refs/heads/master@{#560939}

components/drive/BUILD.gn

@@ -105,8 +105,11 @@ if (is_chromeos) {
       "chromeos/change_list_loader_observer.h",
       "chromeos/change_list_processor.cc",
       "chromeos/change_list_processor.h",
+      "chromeos/default_corpus_change_list_loader.cc",
+      "chromeos/default_corpus_change_list_loader.h",
       "chromeos/directory_loader.cc",
       "chromeos/directory_loader.h",
+      "chromeos/drive_change_list_loader.h",
       "chromeos/drive_file_util.cc",
       "chromeos/drive_file_util.h",
       "chromeos/file_cache.cc",

components/drive/chromeos/default_corpus_change_list_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/default_corpus_change_list_loader.h"
+
+#include <memory>
+
+#include "components/drive/file_system_core_util.h"
+
+namespace drive {
+namespace internal {
+
+DefaultCorpusChangeListLoader::DefaultCorpusChangeListLoader(
+    EventLogger* logger,
+    base::SequencedTaskRunner* blocking_task_runner,
+    ResourceMetadata* resource_metadata,
+    JobScheduler* scheduler,
+    AboutResourceLoader* about_resource_loader,
+    LoaderController* apply_task_controller)
+    : logger_(logger),
+      blocking_task_runner_(blocking_task_runner),
+      resource_metadata_(resource_metadata),
+      scheduler_(scheduler),
+      about_resource_loader_(about_resource_loader),
+      loader_controller_(apply_task_controller) {
+  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(),
+      loader_controller_);
+
+  directory_loader_ = std::make_unique<DirectoryLoader>(
+      logger_, blocking_task_runner_.get(), resource_metadata_, scheduler_,
+      about_resource_loader_, start_page_token_loader_.get(),
+      loader_controller_);
+}
+
+DefaultCorpusChangeListLoader::~DefaultCorpusChangeListLoader() = default;
+
+void DefaultCorpusChangeListLoader::AddObserver(
+    ChangeListLoaderObserver* observer) {
+  change_list_loader_->AddObserver(observer);
+  directory_loader_->AddObserver(observer);
+}
+
+void DefaultCorpusChangeListLoader::RemoveObserver(
+    ChangeListLoaderObserver* observer) {
+  change_list_loader_->RemoveObserver(observer);
+  directory_loader_->RemoveObserver(observer);
+}
+
+bool DefaultCorpusChangeListLoader::IsRefreshing() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  return change_list_loader_->IsRefreshing();
+}
+
+void DefaultCorpusChangeListLoader::LoadIfNeeded(
+    const FileOperationCallback& callback) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+  change_list_loader_->LoadIfNeeded(callback);
+}
+
+void DefaultCorpusChangeListLoader::ReadDirectory(
+    const base::FilePath& directory_path,
+    const ReadDirectoryEntriesCallback& entries_callback,
+    const FileOperationCallback& completion_callback) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+  directory_loader_->ReadDirectory(directory_path, entries_callback,
+                                   completion_callback);
+
+  // Also start loading all of the user's contents.
+  change_list_loader_->LoadIfNeeded(base::DoNothing());
+}
+
+void DefaultCorpusChangeListLoader::CheckForUpdates(
+    const FileOperationCallback& callback) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  change_list_loader_->CheckForUpdates(callback);
+}
+
+}  // namespace internal
+}  // namespace drive

components/drive/chromeos/default_corpus_change_list_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_DEFAULT_CORPUS_CHANGE_LIST_LOADER_H_
+#define COMPONENTS_DRIVE_CHROMEOS_DEFAULT_CORPUS_CHANGE_LIST_LOADER_H_
+
+#include "base/macros.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"
+#include "components/drive/chromeos/start_page_token_loader.h"
+
+namespace drive {
+
+class EventLogger;
+class JobScheduler;
+
+namespace internal {
+
+class AboutResourceLoader;
+class ChangeListLoader;
+class DirectoryLoader;
+class LoaderController;
+class ResourceMetadata;
+class StartPageTokenLoader;
+
+// Loads change lists, the full resource list, and directory contents for the
+// users default corpus.
+class DefaultCorpusChangeListLoader : public DriveChangeListLoader {
+ public:
+  DefaultCorpusChangeListLoader(EventLogger* logger,
+                                base::SequencedTaskRunner* blocking_task_runner,
+                                ResourceMetadata* resource_metadata,
+                                JobScheduler* scheduler,
+                                AboutResourceLoader* about_resource_loader,
+                                LoaderController* apply_task_controller);
+
+  ~DefaultCorpusChangeListLoader() override;
+
+  void AddObserver(ChangeListLoaderObserver* observer) override;
+  void RemoveObserver(ChangeListLoaderObserver* observer) override;
+
+  bool IsRefreshing() override;
+  void LoadIfNeeded(const FileOperationCallback& callback) override;
+  void ReadDirectory(const base::FilePath& directory_path,
+                     const ReadDirectoryEntriesCallback& entries_callback,
+                     const FileOperationCallback& completion_callback) override;
+  void CheckForUpdates(const FileOperationCallback& callback) override;
+
+ private:
+  std::unique_ptr<internal::ChangeListLoader> change_list_loader_;
+  std::unique_ptr<internal::DirectoryLoader> directory_loader_;
+  std::unique_ptr<internal::StartPageTokenLoader> start_page_token_loader_;
+
+  EventLogger* logger_;  // Not owned.
+  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_);
+
+  DISALLOW_COPY_AND_ASSIGN(DefaultCorpusChangeListLoader);
+};
+
+}  // namespace internal
+}  // namespace drive
+
+#endif  // COMPONENTS_DRIVE_CHROMEOS_DEFAULT_CORPUS_CHANGE_LIST_LOADER_H_

components/drive/chromeos/drive_change_list_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_DRIVE_CHANGE_LIST_LOADER_H_
+#define COMPONENTS_DRIVE_CHROMEOS_DRIVE_CHANGE_LIST_LOADER_H_
+
+#include "components/drive/chromeos/file_system_interface.h"
+#include "components/drive/file_errors.h"
+
+namespace drive {
+namespace internal {
+
+class ChangeListLoaderObserver;
+
+// DriveChangeListLoader provides an abstraction for loading change lists, the
+// full resource list amd directory contents, from Google Drive API.
+// Implementations of the interface can, for example, include:
+// - An implementation to retrieve from the users default corpus.
+// - An implementation to retrieve from a specific team drive.
+class DriveChangeListLoader {
+ public:
+  virtual ~DriveChangeListLoader() = default;
+
+  // Adds and removes an observer for change list loading events.
+  virtual void AddObserver(ChangeListLoaderObserver* observer) = 0;
+  virtual void RemoveObserver(ChangeListLoaderObserver* observer) = 0;
+
+  // Indicates whether there is a request for full resource list or change
+  // list fetching is in flight (i.e. directory contents fetching does not
+  // count).
+  virtual bool IsRefreshing() = 0;
+
+  // Starts the change list loading if needed.
+  // |callback| must not be null.
+  virtual void LoadIfNeeded(const FileOperationCallback& callback) = 0;
+
+  // Check for updates on the server. May do nothing if a change list is
+  // already in the process of being loaded.
+  // |callback| must not be null.
+  virtual void CheckForUpdates(const FileOperationCallback& callback) = 0;
+
+  // Reads the given directory contents.
+  // |entries_callback| can be null.
+  // |completion_callback| must not be null.
+  virtual void ReadDirectory(
+      const base::FilePath& directory_path,
+      const ReadDirectoryEntriesCallback& entries_callback,
+      const FileOperationCallback& completion_callback) = 0;
+};
+
+}  // namespace internal
+}  // namespace drive
+
+#endif  // COMPONENTS_DRIVE_CHROMEOS_DRIVE_CHANGE_LIST_LOADER_H_

components/drive/chromeos/file_system.cc

@@ -12,8 +12,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "components/drive/chromeos/about_resource_loader.h"
-#include "components/drive/chromeos/change_list_loader.h"
-#include "components/drive/chromeos/directory_loader.h"
+#include "components/drive/chromeos/default_corpus_change_list_loader.h"
 #include "components/drive/chromeos/file_cache.h"
 #include "components/drive/chromeos/file_system/copy_operation.h"
 #include "components/drive/chromeos/file_system/create_directory_operation.h"
@@ -330,8 +329,7 @@ FileSystem::FileSystem(PrefService* pref_service,
 FileSystem::~FileSystem() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-  directory_loader_->RemoveObserver(this);
-  change_list_loader_->RemoveObserver(this);
+  default_corpus_change_list_loader_->RemoveObserver(this);
 }
 
 void FileSystem::Reset(const FileOperationCallback& callback) {
@@ -354,19 +352,14 @@ void FileSystem::ResetComponents() {
 
   about_resource_loader_ =
       std::make_unique<internal::AboutResourceLoader>(scheduler_);
-  start_page_token_loader_ = std::make_unique<internal::StartPageTokenLoader>(
-      drive::util::kTeamDriveIdDefaultCorpus, scheduler_);
   loader_controller_ = std::make_unique<internal::LoaderController>();
-  change_list_loader_ = std::make_unique<internal::ChangeListLoader>(
-      logger_, blocking_task_runner_.get(), resource_metadata_, scheduler_,
-      about_resource_loader_.get(), start_page_token_loader_.get(),
-      loader_controller_.get());
-  change_list_loader_->AddObserver(this);
-  directory_loader_ = std::make_unique<internal::DirectoryLoader>(
-      logger_, blocking_task_runner_.get(), resource_metadata_, scheduler_,
-      about_resource_loader_.get(), start_page_token_loader_.get(),
-      loader_controller_.get());
-  directory_loader_->AddObserver(this);
+
+  default_corpus_change_list_loader_ =
+      std::make_unique<internal::DefaultCorpusChangeListLoader>(
+          logger_, blocking_task_runner_.get(), resource_metadata_, scheduler_,
+          about_resource_loader_.get(), loader_controller_.get());
+
+  default_corpus_change_list_loader_->AddObserver(this);
 
   sync_client_ = std::make_unique<internal::SyncClient>(
       blocking_task_runner_.get(), delegate, scheduler_, resource_metadata_,
@@ -411,7 +404,7 @@ void FileSystem::CheckForUpdates() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DVLOG(1) << "CheckForUpdates";
 
-  change_list_loader_->CheckForUpdates(
+  default_corpus_change_list_loader_->CheckForUpdates(
       base::Bind(&FileSystem::OnUpdateChecked, weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ -672,11 +665,8 @@ void FileSystem::ReadDirectory(
   if (entries_callback && hide_hosted_docs)
     entries_callback = base::Bind(&FilterHostedDocuments, entries_callback);
 
-  directory_loader_->ReadDirectory(
+  default_corpus_change_list_loader_->ReadDirectory(
       directory_path, entries_callback, completion_callback);
-
-  // Also start loading all of the user's contents.
-  change_list_loader_->LoadIfNeeded(base::DoNothing());
 }
 
 void FileSystem::GetAvailableSpace(
@@ -895,7 +885,7 @@ void FileSystem::GetMetadata(
   DCHECK(callback);
 
   FileSystemMetadata metadata;
-  metadata.refreshing = change_list_loader_->IsRefreshing();
+  metadata.refreshing = default_corpus_change_list_loader_->IsRefreshing();
 
   // Metadata related to delta update.
   metadata.last_update_check_time = last_update_check_time_;

components/drive/chromeos/file_system.h

@@ -40,12 +40,10 @@ class JobScheduler;
 
 namespace internal {
 class AboutResourceLoader;
-class ChangeListLoader;
-class DirectoryLoader;
+class DriveChangeListLoader;
 class FileCache;
 class LoaderController;
 class ResourceMetadata;
-class StartPageTokenLoader;
 class SyncClient;
 }  // namespace internal
 
@@ -188,8 +186,8 @@ class FileSystem : public FileSystemInterface,
   void OnInitialLoadComplete() override;
 
   // Used by tests.
-  internal::ChangeListLoader* change_list_loader_for_testing() {
-    return change_list_loader_.get();
+  internal::DriveChangeListLoader* change_list_loader_for_testing() {
+    return default_corpus_change_list_loader_.get();
   }
   internal::SyncClient* sync_client_for_testing() { return sync_client_.get(); }
 
@@ -271,16 +269,12 @@ class FileSystem : public FileSystemInterface,
   // Used to load about resource.
   std::unique_ptr<internal::AboutResourceLoader> about_resource_loader_;
 
-  // Used to load the start page token for the users default corpus
-  std::unique_ptr<internal::StartPageTokenLoader> start_page_token_loader_;
-
   // Used to control ChangeListLoader.
   std::unique_ptr<internal::LoaderController> loader_controller_;
 
-  // The loader is used to load the change lists.
-  std::unique_ptr<internal::ChangeListLoader> change_list_loader_;
-
-  std::unique_ptr<internal::DirectoryLoader> directory_loader_;
+  // Used to retrieve changelists from the default corpus.
+  std::unique_ptr<internal::DriveChangeListLoader>
+      default_corpus_change_list_loader_;
 
   std::unique_ptr<internal::SyncClient> sync_client_;
 

components/drive/file_system_unittest.cc

@@ -19,7 +19,7 @@
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "components/drive/chromeos/change_list_loader.h"
+#include "components/drive/chromeos/drive_change_list_loader.h"
 #include "components/drive/chromeos/drive_test_util.h"
 #include "components/drive/chromeos/fake_free_disk_space_getter.h"
 #include "components/drive/chromeos/file_system_observer.h"