Drive: add a method to clear all local cache.

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 220 matching lines @@
 // Appends |resource_id| ID to |resource_ids| unconditionally.
 void CollectAnyFile(std::vector<std::string>* resource_ids,
                     const std::string& resource_id,
                     const GDataCacheEntry& /* cache_entry */) {
   DCHECK(resource_ids);
 
   resource_ids->push_back(resource_id);
 }
 
 // Runs callback with pointers dereferenced.
-// Used to implement SetMountedStateOnUIThread.
-void RunSetMountedStateCallback(const SetMountedStateCallback& callback,
-                                GDataFileError* error,
-                                FilePath* cache_file_path) {
+// Used to implement SetMountedStateOnUIThread and ClearAllOnUIThread.
+void RunChangeCacheStateCallback(const ChangeCacheStateCallback& callback,
+                                 const GDataFileError* error,
+                                 const FilePath* cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(cache_file_path);
 
   if (!callback.is_null())
     callback.Run(*error, *cache_file_path);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement *OnUIThread methods.
@@ skipping 311 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(error),
                  resource_id,
                  md5,
                  callback));
 }
 
 void GDataCache::SetMountedStateOnUIThread(
     const FilePath& file_path,
     bool to_mount,
-    const SetMountedStateCallback& callback) {
+    const ChangeCacheStateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataCache::SetMountedState,
                  base::Unretained(this),
                  file_path,
                  to_mount,
                  error,
                  cache_file_path),
-      base::Bind(&RunSetMountedStateCallback,
+      base::Bind(&RunChangeCacheStateCallback,
                  callback,
                  base::Owned(error),
                  base::Owned(cache_file_path)));
 }
 
 void GDataCache::MarkDirtyOnUIThread(const std::string& resource_id,
                                      const std::string& md5,
                                      const GetFileFromCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 74 matching lines @@
                  base::Unretained(this),
                  resource_id,
                  error),
       base::Bind(&RunCacheOperationCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  ""  /* md5 */));
 }
 
+void GDataCache::ClearAllOnUIThread(const ChangeCacheStateCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  GDataFileError* error = new GDataFileError(GDATA_FILE_OK);
+
+  blocking_task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&GDataCache::ClearAll,
+                 base::Unretained(this),
+                 error),
+      base::Bind(&RunChangeCacheStateCallback,
+                 callback,
+                 base::Owned(error),
+                 &cache_root_path_));
+}
+
 void GDataCache::RequestInitializeOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GDataCache::Initialize, base::Unretained(this)));
 }
 
 void GDataCache::ForceRescanOnUIThreadForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 733 matching lines @@
   for (size_t i = 0; i < paths_to_delete.size(); ++i) {
     DeleteFilesSelectively(paths_to_delete[i], path_to_keep);
   }
 
   // Now that all file operations have completed, remove from cache map.
   metadata_->RemoveCacheEntry(resource_id);
 
   *error = GDATA_FILE_OK;
 }
 
+void GDataCache::ClearAll(GDataFileError* error) {
+  AssertOnSequencedWorkerPool();
+  DCHECK(error);
+
+  bool success = file_util::Delete(cache_root_path_, true);
+  Initialize();
+
+  if (success)
+    *error = GDATA_FILE_OK;

[satorux1, 2012/08/03 17:17:31]

*error = success ? GDATA_FILE_OK : GDATA_FILE_ERROR_FAILED

[yoshiki, 2012/08/03 18:23:15]

Done.

+  else
+    *error = GDATA_FILE_ERROR_FAILED;
+}
+
 void GDataCache::OnPinned(GDataFileError* error,
                           const std::string& resource_id,
                           const std::string& md5,
                           const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 
@@ skipping 99 matching lines @@
     const GDataCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata