gdata: Get rid of GDataFileSystem::GetCacheState()

chrome/browser/chromeos/gdata/gdata_cache.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_cache.h"
 
 #include <vector>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/file_util.h"
@@ skipping 328 matching lines @@
                                  FilePath* cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(cache_file_path);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5, *cache_file_path);
 }
 
 // Runs callback with pointers dereferenced.
-// Used to implement GetResourceIdsOfBacklog().
+// Used to implement GetResourceIdsOfBacklogOnUIThread().
 void RunGetResourceIdsCallback(const GetResourceIdsCallback& callback,
                                std::vector<std::string>* to_fetch,
                                std::vector<std::string>* to_upload) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(to_fetch);
   DCHECK(to_upload);
 
   if (!callback.is_null())
     callback.Run(*to_fetch, *to_upload);
 }
 
+// Runs callback with pointers dereferenced.
+// Used to implement GetCacheEntryOnUIThread().
+void RunGetCacheEntryCallback(
+    const GDataCache::GetCacheEntryCallback& callback,
+    bool* success,
+    GDataCache::CacheEntry* cache_entry) {
+  DCHECK(success);
+  DCHECK(cache_entry);
+
+  if (!callback.is_null())
+    callback.Run(*success, *cache_entry);
+}
+
 }  // namespace
 
 std::string GDataCache::CacheEntry::ToString() const {
   std::vector<std::string> cache_states;
   if (GDataCache::IsCachePresent(cache_state))
     cache_states.push_back("present");
   if (GDataCache::IsCachePinned(cache_state))
     cache_states.push_back("pinned");
   if (GDataCache::IsCacheDirty(cache_state))
     cache_states.push_back("dirty");
@@ skipping 67 matching lines @@
 void GDataCache::AddObserver(Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
 void GDataCache::RemoveObserver(Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
+void GDataCache::GetCacheEntryOnUIThread(
+    const std::string& resource_id,
+    const std::string& md5,
+    const GetCacheEntryCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  bool* success = new bool(false);
+  GDataCache::CacheEntry* cache_entry = new GDataCache::CacheEntry;
+  pool_->GetSequencedTaskRunner(sequence_token_)->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&GDataCache::GetCacheEntryHelper,
+                 base::Unretained(this),
+                 resource_id,
+                 md5,
+                 success,
+                 cache_entry),
+      base::Bind(&RunGetCacheEntryCallback,
+                 callback,
+                 base::Owned(success),
+                 base::Owned(cache_entry)));
+}
+
 void GDataCache::GetResourceIdsOfBacklogOnUIThread(
     const GetResourceIdsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::vector<std::string>* to_fetch = new std::vector<std::string>;
   std::vector<std::string>* to_upload = new std::vector<std::string>;
   pool_->GetSequencedTaskRunner(sequence_token_)->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataCache::GetResourceIdsOfBacklog,
                  base::Unretained(this),
@@ skipping 998 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 
   if (*error == base::PLATFORM_FILE_OK)
     FOR_EACH_OBSERVER(Observer, observers_, OnCacheCommitted(resource_id));
 }
 
+void GDataCache::GetCacheEntryHelper(const std::string& resource_id,
+                                     const std::string& md5,
+                                     bool* success,
+                                     GDataCache::CacheEntry* cache_entry) {
+  AssertOnSequencedWorkerPool();
+  DCHECK(success);
+  DCHECK(cache_entry);
+
+  scoped_ptr<GDataCache::CacheEntry> value(GetCacheEntry(resource_id, md5));
+  *success = value.get();
+  if (*success)
+    *cache_entry = *value;
+}
+
 // static
 FilePath GDataCache::GetCacheRootPath(Profile* profile) {
   FilePath cache_base_path;
   chrome::GetUserCacheDirectory(profile->GetPath(), &cache_base_path);
   FilePath cache_root_path =
       cache_base_path.Append(chrome::kGDataCacheDirname);
   return cache_root_path.Append(kGDataCacheVersionDir);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata