chromeos: Stop calling gdata::GDataCache::GetCacheEntry on UI thread

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 182 matching lines @@
 //
 // |callback| is run on the thread represented by |relay_proxy|.
 void OnTransferRegularFileCompleteForCopy(
     const FileOperationCallback& callback,
     scoped_refptr<base::MessageLoopProxy> relay_proxy,
     base::PlatformFileError error) {
   if (!callback.is_null())
     relay_proxy->PostTask(FROM_HERE, base::Bind(callback, error));
 }
 
+// Gets a cache entry from a GDataCache, must be called on the blocking pool.
+// The result value is copied to cache_entry on success.
+void GetCacheEntryOnBlockingPool(
+    GDataCache* cache,
+    const std::string& resource_id,
+    const std::string& md5,
+    GDataCache::CacheEntry* cache_entry,
+    bool* success) {
+  scoped_ptr<GDataCache::CacheEntry> value(
+      cache->GetCacheEntry(resource_id, md5));
+  *success = value.get();
+  if (*success)
+    *cache_entry = *value;
+}
+
 // Runs GetFileCallback with pointers dereferenced.
 // Used for PostTaskAndReply().
 void RunGetFileCallbackHelper(const GetFileCallback& callback,
                               base::PlatformFileError* error,
                               FilePath* file_path,
                               std::string* mime_type,
                               GDataFileType* file_type) {
   DCHECK(error);
   DCHECK(file_path);
   DCHECK(mime_type);
@@ skipping 2689 matching lines @@
 void GDataFileSystem::OnFileDownloaded(
     const GetFileFromCacheParams& params,
     GDataErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If user cancels download of a pinned-but-not-fetched file, mark file as
   // unpinned so that we do not sync the file again.
   if (status == GDATA_CANCELLED) {
-    bool pinning_cancelled = false;
-    {
-      // To access root_. Limit the scope as SetPinStateOnUIThread() will
-      // acquire the lock.
-      base::AutoLock lock(lock_);
-      // TODO(satorux): Should not call this on UI thread. crbug.com/131826.
-      scoped_ptr<GDataCache::CacheEntry> cache_entry = cache_->GetCacheEntry(
-          params.resource_id,
-          params.md5);
-      if (cache_entry.get() && cache_entry->IsPinned())
-        pinning_cancelled = true;
-    }
-    // TODO(hshi): http://crbug.com/127138 notify when file properties change.
-    // This allows file manager to clear the "Available offline" checkbox.
-    if (pinning_cancelled) {
-      SetPinStateOnUIThread(params.virtual_file_path, false,
-                            FileOperationCallback());
-    }
+    GDataCache::CacheEntry* cache_entry = new GDataCache::CacheEntry;
+    bool* success = new bool(false);
+    PostBlockingPoolSequencedTaskAndReply(
+        FROM_HERE,
+        base::Bind(&GetCacheEntryOnBlockingPool,
+                   cache_,
+                   params.resource_id,
+                   params.md5,
+                   cache_entry,
+                   success),
+        base::Bind(&GDataFileSystem::UnpinIfPinned,
+                   ui_weak_ptr_,
+                   params.virtual_file_path,
+                   base::Owned(cache_entry),
+                   base::Owned(success)));
   }
 
   // At this point, the disk can be full or nearly full for several reasons:
   // - The expected file size was incorrect and the file was larger
   // - There was an in-flight download operation and it used up space
   // - The disk became full for some user actions we cannot control
   //   (ex. the user might have downloaded a large file from a regular web site)
   //
   // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
   // and try to free up space, even if the file was downloaded successfully.
   bool* has_enough_space = new bool(false);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataFileSystem::FreeDiskSpaceIfNeeded,
                  base::Unretained(this),
                  has_enough_space),
       base::Bind(&GDataFileSystem::OnFileDownloadedAndSpaceChecked,
                  ui_weak_ptr_,
                  params,
                  status,
                  content_url,
                  downloaded_file_path,
                  base::Owned(has_enough_space)));
 }
 
+void GDataFileSystem::UnpinIfPinned(const FilePath& file_path,
+                                    GDataCache::CacheEntry* cache_entry,
+                                    bool* cache_entry_is_valid) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // TODO(hshi): http://crbug.com/127138 notify when file properties change.
+  // This allows file manager to clear the "Available offline" checkbox.
+  if (*cache_entry_is_valid && cache_entry->IsPinned())
+    SetPinStateOnUIThread(file_path, false, FileOperationCallback());
+}
+
 void GDataFileSystem::OnFileDownloadedAndSpaceChecked(
     const GetFileFromCacheParams& params,
     GDataErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path,
     bool* has_enough_space) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::PlatformFileError error = GDataToPlatformError(status);
 
@@ skipping 1232 matching lines @@
     base::PlatformFileError error,
     const std::string& resource_id,
     const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!callback.is_null())
     callback.Run(error);
 }
 
 }  // namespace gdata