Time-based removal of temporary file systems via BrowsingDataRemover

chrome/browser/browsing_data_remover.cc

 // Copyright (c) 2011 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/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 
+#include "base/logging.h"
+
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/platform_file.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/io_thread.h"
@@ skipping 19 matching lines @@
 #include "content/common/notification_source.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_errors.h"
 #include "net/base/transport_security_state.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "webkit/database/database_tracker.h"
 #include "webkit/database/database_util.h"
-#include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/sandbox_mount_point_provider.h"
+#include "webkit/quota/quota_types.h"
+#include "webkit/quota/quota_manager.h"
 
 // Done so that we can use PostTask on BrowsingDataRemovers and not have
 // BrowsingDataRemover implement RefCounted.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(BrowsingDataRemover);
 
 bool BrowsingDataRemover::removing_ = false;
 
 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
                                          base::Time delete_begin,
                                          base::Time delete_end)
     : profile_(profile),
+      quota_manager_(NULL),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(delete_begin),
       delete_end_(delete_end),
       ALLOW_THIS_IN_INITIALIZER_LIST(database_cleared_callback_(
           this, &BrowsingDataRemover::OnClearedDatabases)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cache_callback_(
           this, &BrowsingDataRemover::DoClearCache)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(appcache_got_info_callback_(
-          this, &BrowsingDataRemover::OnGotAppCacheInfo)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(appcache_deleted_callback_(
-          this, &BrowsingDataRemover::OnAppCacheDeleted)),
-      appcaches_to_be_deleted_count_(0),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetRequestContextForMedia()),
       waiting_for_clear_databases_(false),
       waiting_for_clear_history_(false),
+      waiting_for_clear_temporary_quota_managed_data_(false),
+      waiting_for_clear_persistent_quota_managed_data_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_cache_(false),
-      waiting_for_clear_appcache_(false),
       waiting_for_clear_gears_data_(false),
-      waiting_for_clear_file_systems_(false) {
+      temporary_quota_origins_to_delete_count_(0) {
   DCHECK(profile);
 }
 
 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
                                          TimePeriod time_period,
                                          base::Time delete_end)
     : profile_(profile),
+      quota_manager_(NULL),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(CalculateBeginDeleteTime(time_period)),
       delete_end_(delete_end),
       ALLOW_THIS_IN_INITIALIZER_LIST(database_cleared_callback_(
           this, &BrowsingDataRemover::OnClearedDatabases)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cache_callback_(
           this, &BrowsingDataRemover::DoClearCache)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(appcache_got_info_callback_(
-          this, &BrowsingDataRemover::OnGotAppCacheInfo)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(appcache_deleted_callback_(
-          this, &BrowsingDataRemover::OnAppCacheDeleted)),
-      appcaches_to_be_deleted_count_(0),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetRequestContextForMedia()),
       waiting_for_clear_databases_(false),
       waiting_for_clear_history_(false),
+      waiting_for_clear_temporary_quota_managed_data_(false),
+      waiting_for_clear_persistent_quota_managed_data_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_cache_(false),
-      waiting_for_clear_appcache_(false),
-      waiting_for_clear_lso_data_(false),
       waiting_for_clear_gears_data_(false),
-      waiting_for_clear_file_systems_(false) {
+      temporary_quota_origins_to_delete_count_(0) {
   DCHECK(profile);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   DCHECK(all_done());
 }
 
 void BrowsingDataRemover::Remove(int remove_mask) {
   DCHECK(!removing_);
   removing_ = true;
@@ skipping 78 matching lines @@
           GetCookieMonster();
     }
     if (cookie_monster)
       cookie_monster->DeleteAllCreatedBetween(delete_begin_, delete_end_, true);
 
     // REMOVE_COOKIES is actually "cookies and other site data" so we make sure
     // to remove other data such local databases, STS state, etc. These only can
     // be removed if a WEBKIT thread exists, so check that first:
     if (BrowserThread::IsMessageLoopValid(BrowserThread::WEBKIT)) {
       // We assume the end time is now.
       profile_->GetWebKitContext()->DeleteDataModifiedSince(delete_begin_);

[michaeln, 2011/07/26 22:40:19]

Unfortunately, removal of "WebDOMLocalStorage" is not taken care of via the
QuotaManager, so this is still needed.

     }
 
+    // We'll start by using the quota system to clear out AppCaches, WebSQL DBs,
+    // and File Systems.
+    quota_manager_ = profile_->GetQuotaManager();
+    if (quota_manager_) {
+      waiting_for_clear_temporary_quota_managed_data_ = true;
+      waiting_for_clear_persistent_quota_managed_data_ = true;
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          NewRunnableMethod(
+              this,
+              &BrowsingDataRemover::ClearQuotaManagedDataOnIOThread));
+    }
+
     database_tracker_ = profile_->GetDatabaseTracker();
     if (database_tracker_.get()) {
       waiting_for_clear_databases_ = true;
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           NewRunnableMethod(
               this,
               &BrowsingDataRemover::ClearDatabasesOnFILEThread));

[michaeln, 2011/07/26 22:40:19]

Removal of WebSQLDatabases is taken care of by going thru the QuotaManager, so i
think this isn't needed anymore.

     }
 
-    appcache_service_ = profile_->GetAppCacheService();
-    if (appcache_service_.get()) {
-      waiting_for_clear_appcache_ = true;
-      BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE,
-          NewRunnableMethod(
-              this,
-              &BrowsingDataRemover::ClearAppCacheOnIOThread));

[michaeln, 2011/07/26 22:40:19]

hoooray for deleted code!

-    }
-
     waiting_for_clear_gears_data_ = true;
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(
             this,
             &BrowsingDataRemover::ClearGearsDataOnFILEThread,
             profile_->GetPath()));
 
-    waiting_for_clear_file_systems_ = true;
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(
-            this,
-            &BrowsingDataRemover::ClearFileSystemsOnFILEThread));
-
     if (profile_->GetTransportSecurityState()) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(
               profile_->GetTransportSecurityState(),
               &net::TransportSecurityState::DeleteSince,
               delete_begin_));
     }
   }
 
@@ skipping 244 matching lines @@
 
 void BrowsingDataRemover::ClearDatabasesOnFILEThread() {
   // This function should be called on the FILE thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   int rv = database_tracker_->DeleteDataModifiedSince(
       delete_begin_, &database_cleared_callback_);
   if (rv != net::ERR_IO_PENDING)
     OnClearedDatabases(rv);
 }
 
-void BrowsingDataRemover::OnClearedAppCache() {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    bool result = BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &BrowsingDataRemover::OnClearedAppCache));
-    DCHECK(result);
-    return;
+void BrowsingDataRemover::ClearQuotaManagedDataOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(waiting_for_clear_temporary_quota_managed_data_);
+  DCHECK(waiting_for_clear_persistent_quota_managed_data_);
+
+  // Ask the QuotaManager for all origins with temporary quota modified within
+  // the user-specified timeframe, and deal with the resulting set in
+  // OnGotQuotaManagedOrigins().
+  temporary_quota_origins_to_delete_count_ = 0;
+  persistent_quota_origins_to_delete_count_ = 0;
+
+  // If we're deleting since the beginning of time, ask the QuotaManager for all
+  // origins with persistent quota modified within the user-specified timeframe,
+  // and deal with the resulting set in OnGotPersistentQuotaManagedOrigins.
+  if (delete_begin_ == base::Time()) {
+// FIXME(mkwst): This is broken. If I run persistent and temp, I get segfaults.
+//  I suspect that my mock sucks. :)
+    // profile_->GetQuotaManager()->GetOriginsModifiedSince(
+        // quota::kStorageTypePersistent, delete_begin_, NewCallback(this,
+            // &BrowsingDataRemover::OnGotPersistentQuotaManagedOrigins));
+    waiting_for_clear_persistent_quota_managed_data_ = false;
+  } else {
+    // If not deleting since the beginning of time, we're done with any
+    // persistent quota.
+    waiting_for_clear_persistent_quota_managed_data_ = false;
   }
-  waiting_for_clear_appcache_ = false;
-  NotifyAndDeleteIfDone();
+
+  // Do the same for temporary quota, regardless.
+  profile_->GetQuotaManager()->GetOriginsModifiedSince(
+      quota::kStorageTypeTemporary, delete_begin_, NewCallback(this,
+          &BrowsingDataRemover::OnGotTemporaryQuotaManagedOrigins));
 }
 
-void BrowsingDataRemover::ClearAppCacheOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(waiting_for_clear_appcache_);
-  appcache_info_ = new appcache::AppCacheInfoCollection;
-  appcache_service_->GetAllAppCacheInfo(
-      appcache_info_, &appcache_got_info_callback_);
-  // continues in OnGotAppCacheInfo.
+void BrowsingDataRemover::OnGotTemporaryQuotaManagedOrigins(
+    const std::set<GURL>& origins) {
+  // Walk through the origins passed in, delete temporary quota from each that
+  // isn't protected.
+  std::set<GURL>::iterator origin;
+  for (origin = origins.begin(); origin != origins.end(); ++origin) {
+    if (special_storage_policy_->IsStorageProtected(origin->GetOrigin()))
+      continue;
+    ++temporary_quota_origins_to_delete_count_;
+    quota_manager_->DeleteOriginData(origin->GetOrigin(),
+        quota::kStorageTypeTemporary, NewCallback(this,
+            &BrowsingDataRemover::OnTemporaryQuotaManagedOriginDeletion));
+  }
+  CheckTemporaryQuotaManagedDataDeletionStatus();
 }
 
-void BrowsingDataRemover::OnGotAppCacheInfo(int rv) {
-  using appcache::AppCacheInfoVector;
-  typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
+void BrowsingDataRemover::OnGotPersistentQuotaManagedOrigins(
+    const std::set<GURL>& origins) {
+  // Walk through the origins passed in, delete temporary quota from each that
+  // isn't protected.
+  bool deleting = false;
+  std::set<GURL>::iterator origin;
+  for (origin = origins.begin(); origin != origins.end(); ++origin) {
+    if (special_storage_policy_->IsStorageProtected(origin->GetOrigin()))
+      continue;
+    deleting = true;
+    ++persistent_quota_origins_to_delete_count_;
+    quota_manager_->DeleteOriginData(origin->GetOrigin(),
+        quota::kStorageTypePersistent, NewCallback(this,
+            &BrowsingDataRemover::OnPersistentQuotaManagedOriginDeletion));
+  }
+  CheckPersistentQuotaManagedDataDeletionStatus();
+}
 
-  for (InfoByOrigin::const_iterator origin =
-           appcache_info_->infos_by_origin.begin();
-       origin != appcache_info_->infos_by_origin.end(); ++origin) {
-    if (special_storage_policy_->IsStorageProtected(origin->first))
-      continue;
-    for (AppCacheInfoVector::const_iterator info = origin->second.begin();
-         info != origin->second.end(); ++info) {
-      if (info->creation_time > delete_begin_) {
-        ++appcaches_to_be_deleted_count_;
-        appcache_service_->DeleteAppCacheGroup(
-            info->manifest_url, &appcache_deleted_callback_);
-      }
-    }
+void BrowsingDataRemover::OnTemporaryQuotaManagedOriginDeletion(
+    quota::QuotaStatusCode status) {
+  if (status != quota::kQuotaStatusOk) {
+    // TODO(mkwst): Not really anything pretty I can think of to do here.
   }
 
-  if (!appcaches_to_be_deleted_count_)
-    OnClearedAppCache();
-  // else continues in OnAppCacheDeleted
+  --temporary_quota_origins_to_delete_count_;
+  CheckTemporaryQuotaManagedDataDeletionStatus();
 }
 
-void BrowsingDataRemover::OnAppCacheDeleted(int rv) {
-  --appcaches_to_be_deleted_count_;
-  if (!appcaches_to_be_deleted_count_)
-    OnClearedAppCache();
+void BrowsingDataRemover::OnPersistentQuotaManagedOriginDeletion(
+    quota::QuotaStatusCode status) {
+  if (status != quota::kQuotaStatusOk) {
+    // TODO(mkwst): Not really anything pretty I can think of to do here.
+  }
+
+  --persistent_quota_origins_to_delete_count_;
+  CheckPersistentQuotaManagedDataDeletionStatus();
 }
 
-void BrowsingDataRemover::ClearFileSystemsOnFILEThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(waiting_for_clear_file_systems_);
-  scoped_refptr<fileapi::FileSystemContext>
-      fs_context(profile_->GetFileSystemContext());
-  scoped_ptr<fileapi::SandboxMountPointProvider::OriginEnumerator>
-      origin_enumerator(fs_context->path_manager()->sandbox_provider()->
-          CreateOriginEnumerator());
-
-  GURL origin;
-  while (!(origin = origin_enumerator->Next()).is_empty()) {
-    if (special_storage_policy_->IsStorageProtected(origin))
-      continue;
-    if (delete_begin_ == base::Time()) {
-      // If the user chooses to delete browsing data "since the beginning of
-      // time" remove both temporary and persistent file systems entirely.
-      fs_context->DeleteDataForOriginAndTypeOnFileThread(origin,
-          fileapi::kFileSystemTypeTemporary);
-      fs_context->DeleteDataForOriginAndTypeOnFileThread(origin,
-          fileapi::kFileSystemTypePersistent);
-    }
-    // TODO(mkwst): Else? Decide what to do for time-based deletion: crbug/63700
+void BrowsingDataRemover::CheckTemporaryQuotaManagedDataDeletionStatus() {
+  if (temporary_quota_origins_to_delete_count_ == 0 &&
+      waiting_for_clear_temporary_quota_managed_data_) {
+    waiting_for_clear_temporary_quota_managed_data_ = false;
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            this,
+            &BrowsingDataRemover::NotifyAndDeleteIfDone));
   }
-
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(this, &BrowsingDataRemover::OnClearedFileSystems));
 }
 
-void BrowsingDataRemover::OnClearedFileSystems() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  waiting_for_clear_file_systems_ = false;
-  NotifyAndDeleteIfDone();
+void BrowsingDataRemover::CheckPersistentQuotaManagedDataDeletionStatus() {
+  if (persistent_quota_origins_to_delete_count_ == 0 &&
+      waiting_for_clear_persistent_quota_managed_data_) {
+    waiting_for_clear_persistent_quota_managed_data_ = false;
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            this,
+            &BrowsingDataRemover::NotifyAndDeleteIfDone));
+  }
 }
 
 // static
 void BrowsingDataRemover::ClearGearsData(const FilePath& profile_dir) {
   FilePath plugin_data = profile_dir.AppendASCII("Plugin Data");
   if (file_util::DirectoryExists(plugin_data))
     file_util::Delete(plugin_data, true);
 }
 
 void BrowsingDataRemover::OnClearedGearsData() {
@@ skipping 15 matching lines @@
 
   ClearGearsData(profile_dir);
   OnClearedGearsData();
 }
 
 void BrowsingDataRemover::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
   waiting_for_clear_lso_data_ = false;
   NotifyAndDeleteIfDone();
 }