drive: Implement lock mechanism to 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 290 matching lines @@
 
 ChangeListLoader::ChangeListLoader(
     base::SequencedTaskRunner* blocking_task_runner,
     ResourceMetadata* resource_metadata,
     JobScheduler* scheduler,
     DriveServiceInterface* drive_service)
     : blocking_task_runner_(blocking_task_runner),
       resource_metadata_(resource_metadata),
       scheduler_(scheduler),
       drive_service_(drive_service),
+      lock_count_(0),
       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);
-  base::PostTaskAndReplyWithResult(
+  ApplyChange(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,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(change_list_processor),
                  should_notify_changed_directories,
-                 base::Time::Now()));
+                 base::Time::Now())));
 }
 
 void ChangeListLoader::LoadChangeListFromServerAfterUpdate(
     ChangeListProcessor* change_list_processor,
     bool should_notify_changed_directories,
     const base::Time& start_time,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const base::TimeDelta elapsed = base::Time::Now() - start_time;
@@ skipping 75 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;
-  base::PostTaskAndReplyWithResult(
+  ApplyChange(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,
                  weak_ptr_factory_.GetWeakPtr(),
                  directory_fetch_info,
                  callback,
-                 base::Owned(directory_path)));
+                 base::Owned(directory_path))));
 }
 
 void ChangeListLoader::LoadDirectoryFromServerAfterRefresh(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback,
     const base::FilePath* directory_path,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   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