Drive: add a method to clear all local cache.

chrome/browser/chromeos/gdata/gdata_cache_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 <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 95 matching lines @@
   *out_to_fetch = to_fetch;
   *out_to_upload = to_upload;
 }
 
 // Copies results from GetResourceIdsCallback.
 void OnGetResourceIds(std::vector<std::string>* out_resource_ids,
                       const std::vector<std::string>& resource_ids) {
   *out_resource_ids = resource_ids;
 }
 
+// Copies results from ClearAllOnUIThread.
+void OnClearAll(GDataFileError* out_error,
+                FilePath* out_file_path,
+                GDataFileError error,
+                const FilePath& file_path) {
+  *out_file_path = file_path;
+  *out_error = error;
+}
+
 }  // namespace
 
 class GDataCacheTest : public testing::Test {
  protected:
   GDataCacheTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         cache_(NULL),
         num_callback_invocations_(0),
         expected_error_(GDATA_FILE_OK),
@@ skipping 584 matching lines @@
 
     // FilePath::Extension returns ".", so strip it.
     std::string unescaped_md5 = util::UnescapeCacheFileName(
         base_name.Extension().substr(1));
     EXPECT_EQ(md5, unescaped_md5);
     std::string unescaped_resource_id = util::UnescapeCacheFileName(
         base_name.RemoveExtension().value());
     EXPECT_EQ(resource_id, unescaped_resource_id);
   }
 
+  // Returns the number of the cache files with name <resource_id>, and Confirm
+  // that they have the <md5>. This should return 1 or 0.
+  size_t CountCacheFiles(const std::string& resource_id,
+                         const std::string& md5) {
+    FilePath path = GetCacheFilePath(
+        resource_id, "*",
+        (test_util::ToCacheEntry(expected_cache_state_).is_pinned() ?
+         GDataCache::CACHE_TYPE_PERSISTENT :
+         GDataCache::CACHE_TYPE_TMP),
+        GDataCache::CACHED_FILE_FROM_SERVER);
+    file_util::FileEnumerator enumerator(path.DirName(), false,
+                                         file_util::FileEnumerator::FILES,
+                                         path.BaseName().value());
+    size_t num_files_found = 0;
+    for (FilePath current = enumerator.Next(); !current.empty();
+         current = enumerator.Next()) {
+      ++num_files_found;
+      EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
+                FilePath::kExtensionSeparator +
+                util::EscapeCacheFileName(md5),
+                current.BaseName().value());
+    }
+    return num_files_found;
+  }
+
   static FilePath GetTestFilePath(const FilePath::StringType& filename) {
     FilePath path;
     std::string error;
     PathService::Get(chrome::DIR_TEST_DATA, &path);
     path = path.AppendASCII("chromeos")
         .AppendASCII("gdata")
         .AppendASCII(filename.c_str());
     EXPECT_TRUE(file_util::PathExists(path)) <<
         "Couldn't find " << path.value();
     return path;
@@ skipping 68 matching lines @@
   // |md5|.
   md5 = "new_md5";
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's only one file with name <resource_id>, i.e. previously
   // cached file with the different md5 should be deleted.
-  FilePath path = GetCacheFilePath(
-      resource_id, "*",
-      (test_util::ToCacheEntry(expected_cache_state_).is_pinned() ?
-       GDataCache::CACHE_TYPE_PERSISTENT :
-       GDataCache::CACHE_TYPE_TMP),
-      GDataCache::CACHED_FILE_FROM_SERVER);
-  file_util::FileEnumerator enumerator(path.DirName(), false,
-                                       file_util::FileEnumerator::FILES,
-                                       path.BaseName().value());
-  size_t num_files_found = 0;
-  for (FilePath current = enumerator.Next(); !current.empty();
-       current = enumerator.Next()) {
-    ++num_files_found;
-    EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
-              FilePath::kExtensionSeparator +
-              util::EscapeCacheFileName(md5),
-              current.BaseName().value());
-  }
-  EXPECT_EQ(1U, num_files_found);
+  EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
 }
 
 TEST_F(GDataCacheTest, GetFromCacheSimple) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   // First store a file to cache.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
@@ skipping 617 matching lines @@
   sort(resource_ids.begin(), resource_ids.end());
   ASSERT_EQ(6U, resource_ids.size());
   EXPECT_EQ("dirty:existing", resource_ids[0]);
   EXPECT_EQ("dirty_and_pinned:existing", resource_ids[1]);
   EXPECT_EQ("pinned:existing", resource_ids[2]);
   EXPECT_EQ("pinned:non-existent", resource_ids[3]);
   EXPECT_EQ("tmp:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?", resource_ids[4]);
   EXPECT_EQ("tmp:resource_id", resource_ids[5]);
 }
 
+
+TEST_F(GDataCacheTest, ClearAllOnUIThread) {
+  PrepareForInitCacheTest();
+
+  std::string resource_id("pdf:1a2b");
+  std::string md5("abcdef0123456789");
+
+  // Store an existing file.
+  TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
+                   GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
+                   GDataCache::CACHE_TYPE_TMP);
+  EXPECT_EQ(1, num_callback_invocations_);
+
+  // Verify that there's only one cached file.
+  EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
+
+  // Clear cache.
+  GDataFileError error = GDATA_FILE_OK;
+  FilePath file_path;
+  cache_->ClearAllOnUIThread(base::Bind(&OnClearAll,
+                                        &error,
+                                        &file_path));
+  test_util::RunBlockingPoolTask();
+  EXPECT_EQ(GDATA_FILE_OK, error);
+
+  // Verify that all the cache is removed.
+  VerifyRemoveFromCache(error, resource_id, md5);
+  EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
+}
+
 }   // namespace gdata