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 542 matching lines @@
         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 100 matching lines @@
                    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 1301 matching lines @@
 
   feed_loader_->LoadFromServer(
       directory_service_->origin(),
       0,  // Not delta feed.
       0,  // Not used.
       true,  // multiple feeds
       file_path,
       std::string(),  // No search query
       GURL(), /* feed not explicitly set */
       entry_proto->resource_id(),
-      FindEntryCallback(),  // Not used.
+      FileOperationCallback(),  // Not used.
       base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
                  ui_weak_ptr_));
 }
 
 void GDataFileSystem::OnRequestDirectoryRefresh(
     GetDocumentsParams* params,
     GDataFileError error) {
   DCHECK(params);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 428 matching lines @@
       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));
 }
 
@@ skipping 11 matching lines @@
                     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 329 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);

[achuithb, 2012/08/14 23:57:36]

Why not just fix this? It's easy, right?

[satorux1, 2012/08/15 00:03:26]

I'll fix this in the next patch, which makes things much cleaner. Stay tuned.

 
   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 544 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