drive: Also lock SearchOperation when locking 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"
@@ skipping 281 matching lines @@
       util::GetDriveMyDriveRootPath(), &entry);
   if (error != FILE_ERROR_OK || !entry.resource_id().empty())
     return error;
 
   entry.set_resource_id(about_resource.root_folder_id());
   return resource_metadata->RefreshEntry(entry);
 }
 
 }  // namespace
 
+LoaderController::LoaderController()
+    : lock_count_(0),
+      weak_ptr_factory_(this) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+LoaderController::~LoaderController() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+scoped_ptr<base::ScopedClosureRunner> LoaderController::GetLock() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  ++lock_count_;
+  return make_scoped_ptr(new base::ScopedClosureRunner(
+      base::Bind(&LoaderController::Unlock,
+                 weak_ptr_factory_.GetWeakPtr())));
+}
+
+void LoaderController::ScheduleRun(const base::Closure& task) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!task.is_null());
+
+  if (lock_count_ > 0) {
+    pending_tasks_.push_back(task);
+  } else {
+    task.Run();
+  }
+}
+
+void LoaderController::Unlock() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_LT(0, lock_count_);
+
+  if (--lock_count_ > 0)
+    return;
+
+  std::vector<base::Closure> tasks;
+  tasks.swap(pending_tasks_);
+  for (size_t i = 0; i < tasks.size(); ++i)
+    tasks[i].Run();
+}
+
 ChangeListLoader::ChangeListLoader(
     base::SequencedTaskRunner* blocking_task_runner,
     ResourceMetadata* resource_metadata,
     JobScheduler* scheduler,
-    DriveServiceInterface* drive_service)
+    DriveServiceInterface* drive_service,
+    LoaderController* loader_controller)
     : blocking_task_runner_(blocking_task_runner),
       resource_metadata_(resource_metadata),
       scheduler_(scheduler),
       drive_service_(drive_service),
-      lock_count_(0),
+      loader_controller_(loader_controller),
       loaded_(false),
       weak_ptr_factory_(this) {
 }
 
 ChangeListLoader::~ChangeListLoader() {
   STLDeleteElements(&fast_fetch_feed_fetcher_set_);
 }
 
 bool ChangeListLoader::IsRefreshing() const {
   // Callback for change list loading is stored in pending_load_callback_[""].
@@ skipping 78 matching lines @@
         base::Bind(
             callback,
             google_apis::HTTP_NO_CONTENT,
             base::Passed(scoped_ptr<google_apis::AboutResource>(
                 new google_apis::AboutResource(*cached_about_resource_)))));
   } else {
     UpdateAboutResource(callback);
   }
 }
 
-scoped_ptr<base::ScopedClosureRunner> ChangeListLoader::GetLock() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ++lock_count_;
-  return make_scoped_ptr(new base::ScopedClosureRunner(
-      base::Bind(&ChangeListLoader::Unlock,
-                 weak_ptr_factory_.GetWeakPtr())));
-}
-
 void ChangeListLoader::LoadDirectoryIfNeededAfterGetEntry(
     const base::FilePath& directory_path,
     const FileOperationCallback& callback,
     bool should_try_loading_parent,
     const ResourceEntry* entry,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Should load grand root first if My Drive's resource ID is not set.
@@ skipping 328 matching lines @@
 
   ChangeListProcessor* change_list_processor =
       new ChangeListProcessor(resource_metadata_);
   // Don't send directory content change notification while performing
   // the initial content retrieval.
   const bool should_notify_changed_directories = is_delta_update;
 
   util::Log(logging::LOG_INFO,
             "Apply change lists (is delta: %d)",
             is_delta_update);
-  ApplyChange(base::Bind(
+  loader_controller_->ScheduleRun(base::Bind(
       base::IgnoreResult(
           &base::PostTaskAndReplyWithResult<FileError, FileError>),
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&ChangeListProcessor::Apply,
                  base::Unretained(change_list_processor),
                  base::Passed(&about_resource),
                  base::Passed(&change_lists),
                  is_delta_update),
       base::Bind(&ChangeListLoader::LoadChangeListFromServerAfterUpdate,
@@ skipping 89 matching lines @@
 
   if (error != FILE_ERROR_OK) {
     LOG(ERROR) << "Failed to load directory: "
                << directory_fetch_info.local_id()
                << ": " << FileErrorToString(error);
     callback.Run(error);
     return;
   }
 
   base::FilePath* directory_path = new base::FilePath;
-  ApplyChange(base::Bind(
+  loader_controller_->ScheduleRun(base::Bind(
       base::IgnoreResult(
           &base::PostTaskAndReplyWithResult<FileError, FileError>),
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&ChangeListProcessor::RefreshDirectory,
                  resource_metadata_,
                  directory_fetch_info,
                  base::Passed(&change_lists),
                  directory_path),
       base::Bind(&ChangeListLoader::LoadDirectoryFromServerAfterRefresh,
@@ skipping 13 matching lines @@
 
   DVLOG(1) << "Directory loaded: " << directory_fetch_info.ToString();
   callback.Run(error);
   // Also notify the observers.
   if (error == FILE_ERROR_OK && !directory_path->empty()) {
     FOR_EACH_OBSERVER(ChangeListLoaderObserver, observers_,
                       OnDirectoryChanged(*directory_path));
   }
 }
 
-void ChangeListLoader::ApplyChange(const base::Closure& closure) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!closure.is_null());
-  if (lock_count_ > 0) {
-    pending_apply_closures_.push_back(closure);
-  } else {
-    closure.Run();
-  }
-}
-
-void ChangeListLoader::Unlock() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_LT(0, lock_count_);
-
-  if (--lock_count_ > 0)
-    return;
-
-  std::vector<base::Closure> callbacks;
-  callbacks.swap(pending_apply_closures_);
-  for (size_t i = 0; i < callbacks.size(); ++i)
-    callbacks[i].Run();
-}
-
 void ChangeListLoader::UpdateAboutResource(
     const google_apis::AboutResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scheduler_->GetAboutResource(
       base::Bind(&ChangeListLoader::UpdateAboutResourceAfterGetAbout,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
@@ skipping 17 matching lines @@
 
     cached_about_resource_.reset(
         new google_apis::AboutResource(*about_resource));
   }
 
   callback.Run(status, about_resource.Pass());
 }
 
 }  // namespace internal
 }  // namespace drive