gdata: Convert FindEntryByResourceIdSync() to asynchronous.

chrome/browser/chromeos/gdata/gdata_util.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_util.h"
 
 #include <string>
 #include <vector>
 #include <utility>
 
@@ skipping 17 matching lines @@
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "net/base/escape.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
+using content::BrowserThread;
+
 namespace gdata {
 namespace util {
 
 namespace {
 
 const char kGDataSpecialRootPath[] = "/special";
 
 const char kGDataMountPointPath[] = "/special/drive";
 
 const FilePath::CharType* kGDataMountPointPathComponents[] = {
@@ skipping 37 matching lines @@
   }
   std::string edit_url;
   if (!dict_val->GetString("url", &edit_url)) {
     NOTREACHED() << "url field doesn't exist in " << json;
     return;
   }
   *url = GURL(edit_url);
   DVLOG(1) << "edit url " << *url;
 }
 
-void OpenEditURLUIThread(Profile* profile, GURL* edit_url) {
+void OpenEditURLUIThread(Profile* profile, const GURL* edit_url) {
   Browser* browser = browser::FindLastActiveWithProfile(profile);
   if (browser) {
     browser->OpenURL(content::OpenURLParams(*edit_url, content::Referrer(),
         CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
   }
 }
 
+// Invoked upon completion of FindEntryByResourceId initiated by
+// ModifyGDataFileResourceUrl.
+void OnFindEntryByResourceId(Profile* profile,
+                             const std::string& resource_id,
+                             base::PlatformFileError error,
+                             GDataEntry* entry) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (error != base::PLATFORM_FILE_OK || !entry || !entry->AsGDataFile())
+    return;
+
+  const std::string& file_name = entry->AsGDataFile()->file_name();
+  const GURL edit_url = GetFileResourceUrl(resource_id, file_name);
+  OpenEditURLUIThread(profile, &edit_url);
+  DVLOG(1) << "OnFindEntryByResourceId " << edit_url;
+}
+
 // Invoked upon completion of GetFileInfoByPathAsync initiated by
 // InsertGDataCachePathPermissions.
 void OnGetFileInfoForInsertGDataCachePathsPermissions(
     Profile* profile,
     std::vector<std::pair<FilePath, int> >* cache_paths,
     const base::Closure& callback,
     base::PlatformFileError error,
     scoped_ptr<GDataFileProto> file_info) {
   DCHECK(profile);
   DCHECK(cache_paths);
@@ skipping 64 matching lines @@
   std::string url(base::StringPrintf(
       "%s:%s",
       chrome::kDriveScheme,
       net::EscapePath(resource_id).c_str()));
   return GURL(url);
 }
 
 void ModifyGDataFileResourceUrl(Profile* profile,
                                 const FilePath& gdata_cache_path,
                                 GURL* url) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   GDataFileSystem* file_system = GetGDataFileSystem(profile);
   if (!file_system)
     return;
   GDataCache* cache = GetGDataCache(profile);
   if (!cache)
     return;
 
-  // Handle hosted documents. The edit url is in the temporary file, so we
-  // read it on a blocking thread.
   if (cache->GetCacheDirectoryPath(
           GDataCache::CACHE_TYPE_TMP_DOCUMENTS).IsParent(
       gdata_cache_path)) {
+    // Handle hosted documents. The edit url is in the temporary file, so we
+    // read it on a blocking thread.
     GURL* edit_url = new GURL();
     content::BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
         base::Bind(&GetHostedDocumentURLBlockingThread,
                    gdata_cache_path, edit_url),
         base::Bind(&OpenEditURLUIThread, profile, base::Owned(edit_url)));
     *url = GURL();
-    return;
-  }
-
-  // Handle all other gdata files.
-  if (cache->GetCacheDirectoryPath(
-          GDataCache::CACHE_TYPE_TMP).IsParent(gdata_cache_path)) {
+  } else if (cache->GetCacheDirectoryPath(
+      GDataCache::CACHE_TYPE_TMP).IsParent(gdata_cache_path)) {
+    // Handle all other gdata files.
     const std::string resource_id =
         gdata_cache_path.BaseName().RemoveExtension().AsUTF8Unsafe();
-    GDataEntry* entry = NULL;
-    file_system->FindEntryByResourceIdSync(
-        resource_id, base::Bind(&ReadOnlyFindEntryCallback, &entry));
-
-    std::string file_name;
-    if (entry && entry->AsGDataFile())
-      file_name = entry->AsGDataFile()->file_name();
-
-    *url = gdata::util::GetFileResourceUrl(resource_id, file_name);
-    DVLOG(1) << "ModifyGDataFileResourceUrl " << *url;
+    file_system->FindEntryByResourceId(resource_id,
+                                       base::Bind(&OnFindEntryByResourceId,
+                                                  profile,
+                                                  resource_id));
+    *url = GURL();
   }
 }
 
 bool IsUnderGDataMountPoint(const FilePath& path) {
   return GetGDataMountPointPath() == path ||
          GetGDataMountPointPath().IsParent(path);
 }
 
 GDataSearchPathType GetSearchPathStatus(const FilePath& path) {
   std::vector<std::string> components;
@@ skipping 173 matching lines @@
   // Assign the extracted extensions to md5 and extra_extension.
   int extension_count = extensions.size();
   *md5 = (extension_count > 0) ? extensions[extension_count - 1] :
                                  std::string();
   *extra_extension = (extension_count > 1) ? extensions[extension_count - 2] :
                                              std::string();
 }
 
 }  // namespace util
 }  // namespace gdata