gdata: Get rid of GDataFileSystem::GetCacheState()

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 172 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 28 matching lines @@
 // OnTransferCompleted.
 void OnAddUploadFileCompleted(
     const FileOperationCallback& callback,
     base::PlatformFileError error,
     scoped_ptr<UploadFileInfo> /* upload_file_info */){
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run(error);
 }
 
-// Used to implement GetCacheState.
-void RunGetCacheStateCallbackHelper(
-    const GetCacheStateCallback& callback,
-    GDataCache::CacheEntry* cache_entry,
-    bool* success) {
-  DCHECK(cache_entry);
-  DCHECK(success);
-  if (callback.is_null())
-    return;
-
-  callback.Run(
-      base::PLATFORM_FILE_OK,
-      *success ? cache_entry->cache_state : GDataCache::CACHE_STATE_NONE);
-}
-
 // The class to wait for the initial load of root feed and runs the callback
 // after the initialization.
 class InitialLoadObserver : public GDataFileSystemInterface::Observer {
  public:
   InitialLoadObserver(GDataFileSystemInterface* file_system,
                       const base::Closure& callback)
       : file_system_(file_system), callback_(callback) {}
 
   virtual void OnInitialLoadFinished() OVERRIDE {
     if (!callback_.is_null())
@@ skipping 2004 matching lines @@
                   upload_file_info_ptr->gdata_path.DirName(),
                   upload_file_info_ptr->entry.get(),
                   upload_file_info_ptr->file_path,
                   GDataCache::FILE_OPERATION_MOVE,
                   base::Bind(&OnAddUploadFileCompleted,
                              callback,
                              error,
                              base::Passed(&upload_file_info)));
 }
 
-void GDataFileSystem::GetCacheState(const std::string& resource_id,
-                                    const std::string& md5,
-                                    const GetCacheStateCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
-         BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  // Always post a task to the UI thread to call GetCacheStateOnUIThread even if
-  // GetCacheState is called on the UI thread. This ensures that, regardless of
-  // whether GDataFileSystem is locked or not, GDataFileSystem is unlocked when
-  // GetCacheStateOnUIThread is called.
-  const bool posted = BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&GDataFileSystem::GetCacheStateOnUIThread,
-                 ui_weak_ptr_,
-                 resource_id,
-                 md5,
-                 CreateRelayCallback(callback)));
-  DCHECK(posted);
-}
-
-void GDataFileSystem::GetCacheStateOnUIThread(
-    const std::string& resource_id,
-    const std::string& md5,
-    const GetCacheStateCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  GDataEntry* entry = root_->GetEntryByResourceId(resource_id);
-  if (!entry || !entry->AsGDataFile()) {
-    const bool posted = BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(callback,
-                   base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                   GDataCache::CACHE_STATE_NONE));
-    DCHECK(posted);
-    return;
-  }
-
-  GDataCache::CacheEntry* cache_entry = new GDataCache::CacheEntry;
-  bool* success = new bool(false);
-  PostBlockingPoolSequencedTaskAndReply(
-      FROM_HERE,
-      sequence_token_,
-      base::Bind(&GetCacheEntryOnBlockingPool,
-                 cache_,
-                 resource_id,
-                 md5,
-                 cache_entry,
-                 success),
-      base::Bind(&RunGetCacheStateCallbackHelper,
-                 callback,
-                 base::Owned(cache_entry),
-                 base::Owned(success)));
-}
-
 void GDataFileSystem::GetAvailableSpace(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::GetAvailableSpaceOnUIThread,
                                ui_weak_ptr_,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::GetAvailableSpaceOnUIThread(
@@ skipping 479 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) {
-    GDataCache::CacheEntry* cache_entry = new GDataCache::CacheEntry;
-    bool* success = new bool(false);
-    PostBlockingPoolSequencedTaskAndReply(
-        FROM_HERE,
-        sequence_token_,
-        base::Bind(&GetCacheEntryOnBlockingPool,
-                   cache_,
-                   params.resource_id,
-                   params.md5,
-                   cache_entry,
-                   success),
+    cache_->GetCacheEntryOnUIThread(
+        params.resource_id,
+        params.md5,
         base::Bind(&GDataFileSystem::UnpinIfPinned,
                    ui_weak_ptr_,
                    params.resource_id,
-                   params.md5,
-                   base::Owned(cache_entry),
-                   base::Owned(success)));
+                   params.md5));
   }
 
   // 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,
       sequence_token_,
       base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  0,
                  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 std::string& resource_id,
-                                    const std::string& md5,
-                                    GDataCache::CacheEntry* cache_entry,
-                                    bool* cache_entry_is_valid) {
+void GDataFileSystem::UnpinIfPinned(
+    const std::string& resource_id,
+    const std::string& md5,
+    bool success,
+    const GDataCache::CacheEntry& cache_entry) {
   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())
+  if (success && cache_entry.IsPinned())
     cache_->UnpinOnUIThread(resource_id, md5, CacheOperationCallback());
 }
 
 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));
@@ skipping 947 matching lines @@
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
   if (!callback.is_null())
     callback.Run(result);
 }
 
 }  // namespace gdata