gdata: Remove FindEntryByPathAndRunSync() from GDataWapiFeedLoader.

chrome/browser/chromeos/gdata/gdata_file_system.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/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 561 matching lines @@
 }
 
 void GDataFileSystem::CheckForUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ContentOrigin initial_origin = directory_service_->origin();
   if (initial_origin == FROM_SERVER) {
     directory_service_->set_origin(REFRESHING);
     feed_loader_->ReloadFromServerIfNeeded(
         initial_origin,
         directory_service_->largest_changestamp(),
-        directory_service_->root()->GetFilePath(),
         base::Bind(&GDataFileSystem::OnUpdateChecked,
                    ui_weak_ptr_,
                    initial_origin));
   }
 }
 
 void GDataFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
-                                      GDataFileError error,
-                                      GDataEntry* /* entry */) {
+                                      GDataFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != GDATA_FILE_OK)
     directory_service_->set_origin(initial_origin);
-  }
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // This should be called from UI thread, from GDataSystemService shutdown.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->RemoveObserver(this);
 
   // Cancel all the in-flight operations.
   // This asynchronously cancels the URL fetch operations.
@@ skipping 98 matching lines @@
                    ui_weak_ptr_,
                    search_file_path,
                    callback)));
     return;
   } else if (directory_service_->origin() == UNINITIALIZED) {
     // Load root feed from this disk cache. Upon completion, kick off server
     // fetching.
     directory_service_->set_origin(INITIALIZING);
     feed_loader_->LoadFromCache(
         true,  // should_load_from_server
-        search_file_path,
         // This is the initial load, hence we'll notify when it's done.
-        base::Bind(&GDataFileSystem::RunAndNotifyInitialLoadFinished,
+        base::Bind(&GDataFileSystem::FindAndNotifyInitialLoadFinished,
                    ui_weak_ptr_,
+                   search_file_path,
                    callback));
     return;
   }
 
   // Post a task to the same thread, rather than calling it here, as
   // FindEntryByPath() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                  ui_weak_ptr_,
@@ skipping 1294 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK ||
       !entry_proto->file_info().is_directory()) {
     LOG(ERROR) << "Directory entry not found: " << file_path.value();
     return;
   }
 
   feed_loader_->LoadFromServer(
       directory_service_->origin(),
-      0,  // Not delta feed.
-      0,  // Not used.
+      0,  // start_changestamp - Not a delta feed.
+      0,  // root_feed_changestamp - Not used.
       true,  // multiple feeds
-      file_path,
       std::string(),  // No search query
-      GURL(), /* feed not explicitly set */
-      entry_proto->resource_id(),
-      FindEntryCallback(),  // Not used.
+      GURL(),  // feed_to_load - Feed not explicitly set
+      entry_proto->resource_id(),  // Load the feed for this directory.
+      FileOperationCallback(),  // load_finished_callback.
       base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
-                 ui_weak_ptr_));
+                 ui_weak_ptr_,
+                 file_path));
 }
 
 void GDataFileSystem::OnRequestDirectoryRefresh(
+    const FilePath& directory_path,
     GetDocumentsParams* params,
     GDataFileError error) {
   DCHECK(params);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  const FilePath& directory_path = params->search_file_path;
   if (error != GDATA_FILE_OK) {
     LOG(ERROR) << "Failed to refresh directory: " << directory_path.value()
                << ": " << error;
     return;
   }
 
   int64 unused_delta_feed_changestamp = 0;
   FeedToFileResourceMapUmaStats unused_uma_stats;
   FileResourceIdMap file_map;
   GDataWapiFeedProcessor feed_processor(directory_service_.get());
@@ skipping 379 matching lines @@
       new std::vector<DocumentFeed*>);
 
   ContentOrigin initial_origin = directory_service_->origin();
   feed_loader_->LoadFromServer(
       initial_origin,
       0, 0,  // We don't use change stamps when fetching search
       // data; we always fetch the whole result feed.
       false,  // Stop fetching search results after first feed
       // chunk to avoid displaying huge number of search
       // results (especially since we don't cache them).
-      FilePath(),  // Not used.
       search_query,
       next_feed,
       std::string(),  // No directory resource ID.
-      FindEntryCallback(),  // Not used.
+      FileOperationCallback(),  // Not used.
       base::Bind(&GDataFileSystem::OnSearch, ui_weak_ptr_, callback));
 }
 
 void GDataFileSystem::OnDirectoryChanged(const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(directory_path));
 }
 
 void GDataFileSystem::OnDocumentFeedFetched(int num_accumulated_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDocumentFeedFetched(num_accumulated_entries));
 }
 
 void GDataFileSystem::OnFeedFromServerLoaded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnFeedFromServerLoaded());
 }
 
 void GDataFileSystem::LoadRootFeedFromCacheForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->LoadFromCache(
       false,  // should_load_from_server.
-      // search_path doesn't matter if FindEntryCallback parameter is null .
-      FilePath(),
-      FindEntryCallback());
+      FileOperationCallback());
 }
 
 GDataFileError GDataFileSystem::UpdateFromFeedForTesting(
     const std::vector<DocumentFeed*>& feed_list,
     int64 start_changestamp,
     int64 root_feed_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return feed_loader_->UpdateFromFeed(feed_list,
                                       start_changestamp,
@@ skipping 342 matching lines @@
 
 void GDataFileSystem::NotifyFileSystemToBeUnmounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "File System is to be unmounted";
   // Notify the observers that the file system is being unmounted.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnFileSystemBeingUnmounted());
 }
 
-void GDataFileSystem::RunAndNotifyInitialLoadFinished(
+void GDataFileSystem::FindAndNotifyInitialLoadFinished(
+    const FilePath& search_file_path,
     const FindEntryCallback& callback,
-    GDataFileError error,
-    GDataEntry* entry) {
+    GDataFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  callback.Run(error, entry);
+  // TODO(satorux): Remove this: crbug.com/141196.
+  directory_service_->FindEntryByPathAndRunSync(search_file_path, callback);
 
   DVLOG(1) << "RunAndNotifyInitialLoadFinished";
 
   // Notify the observers that root directory has been initialized.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnInitialLoadFinished());
 }
 
 GDataFileError GDataFileSystem::AddNewDirectory(
     const FilePath& directory_path, base::Value* entry_value) {
@@ skipping 588 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata