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

chrome/browser/chromeos/gdata/gdata_file_system_unittest.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 <errno.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 408 matching lines @@
   }
 
   FilePath GetCacheFilePath(const std::string& resource_id,
                             const std::string& md5,
                             GDataCache::CacheSubDirectoryType sub_dir_type,
                             GDataCache::CachedFileOrigin file_origin) {
     return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
                                     file_origin);
   }
 
+  // Helper function to call GetCacheEntry from origin thread.
+  // Note: This method calls RunAllPendingForIO.
+  scoped_ptr<GDataCache::CacheEntry> GetCacheEntryFromOriginThread(
+      const std::string& resource_id,
+      const std::string& md5) {
+    scoped_ptr<GDataCache::CacheEntry> cache_entry;
+    content::BrowserThread::GetBlockingPool()
+        ->GetSequencedTaskRunner(sequence_token_)->PostTask(
+            FROM_HERE,
+            base::Bind(
+                &GDataFileSystemTest::GetCacheEntryFromOriginThreadInternal,
+                base::Unretained(this),
+                resource_id,
+                md5,
+                &cache_entry));
+    RunAllPendingForIO();
+    return cache_entry.Pass();
+  }
+
+  // Used to implement GetCacheEntry.
+  void GetCacheEntryFromOriginThreadInternal(
+      const std::string& resource_id,
+      const std::string& md5,
+      scoped_ptr<GDataCache::CacheEntry>* cache_entry) {
+    cache_entry->reset(cache_->GetCacheEntry(resource_id, md5).release());
+  }
+
   // Returns true if the cache entry exists for the given resource ID and MD5.
   bool CacheEntryExists(const std::string& resource_id,
                         const std::string& md5) {
-    return file_system_->cache_->GetCacheEntry(resource_id, md5).get();
+    return GetCacheEntryFromOriginThread(resource_id, md5).get();
   }
 
   // Returns true if the cache file exists for the given resource ID and MD5.
   bool CacheFileExists(const std::string& resource_id,
                        const std::string& md5) {
     const FilePath file_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::CACHE_TYPE_TMP,
         GDataCache::CACHED_FILE_FROM_SERVER);
@@ skipping 93 matching lines @@
 
   void VerifyRemoveFromCache(base::PlatformFileError error,
                              const std::string& resource_id,
                              const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     scoped_ptr<GDataCache::CacheEntry> cache_entry =
-        file_system_->cache_->GetCacheEntry(resource_id, md5);
+        GetCacheEntryFromOriginThread(resource_id, md5);
     if (cache_entry.get())
       EXPECT_TRUE(cache_entry->IsDirty());
 
     // If entry doesn't exist, verify that:
     // - no files with "<resource_id>.* exists in persistent and tmp dirs
     // - no "<resource_id>" symlink exists in pinned and outgoing dirs.
     std::vector<PathToVerify> paths_to_verify;
     paths_to_verify.push_back(  // Index 0: CACHE_TYPE_TMP.
         PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
                      GDataCache::CACHE_TYPE_TMP,
@@ skipping 353 matching lines @@
           base::PLATFORM_FILE_OK :
           base::PLATFORM_FILE_ERROR_NOT_FOUND,
           resource.expected_file_extension);
       EXPECT_EQ(1, num_callback_invocations_);
 
       // Verify cache state.
       std::string md5;
       if (GDataCache::IsCachePresent(resource.cache_state))
          md5 = resource.md5;
       scoped_ptr<GDataCache::CacheEntry> cache_entry =
-          file_system_->cache_->GetCacheEntry(resource.resource_id, md5);
+          GetCacheEntryFromOriginThread(resource.resource_id, md5);
       ASSERT_TRUE(cache_entry.get());
       EXPECT_EQ(resource.cache_state, cache_entry->cache_state);
       EXPECT_EQ(resource.expected_sub_dir_type, cache_entry->sub_dir_type);
     }
   }
 
   void VerifyCacheFileState(base::PlatformFileError error,
                             const std::string& resource_id,
                             const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     scoped_ptr<GDataCache::CacheEntry> cache_entry =
-        file_system_->cache_->GetCacheEntry(resource_id, md5);
+        GetCacheEntryFromOriginThread(resource_id, md5);
     if (GDataCache::IsCachePresent(expected_cache_state_) ||
         GDataCache::IsCachePinned(expected_cache_state_)) {
       ASSERT_TRUE(cache_entry.get());
       EXPECT_EQ(expected_cache_state_, cache_entry->cache_state);
       EXPECT_EQ(expected_sub_dir_type_, cache_entry->sub_dir_type);
     } else {
       EXPECT_FALSE(cache_entry.get());
     }
 
     // Verify actual cache file.
@@ skipping 2875 matching lines @@
   // Verify that the file was properly closed.
   EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
 
   // Verify that the cache state was changed as expected.
   VerifyCacheStateAfterCloseFile(callback_helper_->last_error_,
                                  file_resource_id,
                                  file_md5);
 }
 
 }   // namespace gdata