drive: Also lock SearchOperation when locking ChangeListLoader

chrome/browser/chromeos/drive/file_system/search_operation.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/chromeos/drive/file_system/search_operation.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/task_runner_util.h"
+#include "chrome/browser/chromeos/drive/change_list_loader.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/resource_entry_conversion.h"
 #include "chrome/browser/chromeos/drive/resource_metadata.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/gdata_wapi_parser.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
@@ skipping 48 matching lines @@
   }
 
   return FILE_ERROR_OK;
 }
 
 }  // namespace
 
 SearchOperation::SearchOperation(
     base::SequencedTaskRunner* blocking_task_runner,
     JobScheduler* scheduler,
-    internal::ResourceMetadata* metadata)
+    internal::ResourceMetadata* metadata,
+    internal::LoaderController* loader_controller)
     : blocking_task_runner_(blocking_task_runner),
       scheduler_(scheduler),
       metadata_(metadata),
+      loader_controller_(loader_controller),
       weak_ptr_factory_(this) {
 }
 
 SearchOperation::~SearchOperation() {
 }
 
 void SearchOperation::Search(const std::string& search_query,
                              const GURL& next_link,
                              const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 34 matching lines @@
 
   scoped_ptr<std::vector<SearchResultInfo> > result(
       new std::vector<SearchResultInfo>);
   if (resource_list->entries().empty()) {
     // Short cut. If the resource entry is empty, we don't need to refresh
     // the resource metadata.
     callback.Run(FILE_ERROR_OK, next_url, result.Pass());
     return;
   }
 
+  // ResolveSearchResultOnBlockingPool() may add entries newly created on the
+  // server to the local metadata.
+  // This may race with sync tasks so we should ask LoaderController here.
   std::vector<SearchResultInfo>* result_ptr = result.get();
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner_.get(),
+  loader_controller_->ScheduleRun(base::Bind(
+      base::IgnoreResult(
+          &base::PostTaskAndReplyWithResult<FileError, FileError>),
+      blocking_task_runner_,
       FROM_HERE,
       base::Bind(&ResolveSearchResultOnBlockingPool,
                  metadata_,
                  base::Passed(&resource_list),
                  result_ptr),
       base::Bind(&SearchOperation::SearchAfterResolveSearchResult,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  next_url,
-                 base::Passed(&result)));
+                 base::Passed(&result))));
 }
 
 void SearchOperation::SearchAfterResolveSearchResult(
     const SearchCallback& callback,
     const GURL& next_link,
     scoped_ptr<std::vector<SearchResultInfo> > result,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(result);
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error, GURL(), scoped_ptr<std::vector<SearchResultInfo> >());
     return;
   }
 
   callback.Run(error, next_link, result.Pass());
 }
 
 }  // namespace file_system
 }  // namespace drive