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/callback.h"
 #include "base/file_util.h"
+#include "base/logging.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"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
@@ skipping 17 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_manager.h"
+#include "webkit/quota/quota_types.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) {
+      waiting_for_clear_gears_data_(false) {
   DCHECK(profile);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   DCHECK(all_done());
 }
 
 void BrowsingDataRemover::Remove(int remove_mask) {
   DCHECK(!removing_);
   removing_ = true;
@@ skipping 81 matching lines @@
       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_);
     }
 
+    // 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));
     }
 
-    appcache_service_ = profile_->GetAppCacheService();
-    if (appcache_service_.get()) {
-      waiting_for_clear_appcache_ = true;
-      BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE,
-          NewRunnableMethod(
-              this,
-              &BrowsingDataRemover::ClearAppCacheOnIOThread));
-    }
-
     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 220 matching lines @@
       }
       default: {
         NOTREACHED() << "bad state";
         next_cache_state_ = STATE_NONE;  // Stop looping.
         break;
       }
     }
   }
 }
 
 void BrowsingDataRemover::OnClearedDatabases(int rv) {

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

can be deleted?

[Mike West, 2011/07/27 12:49:18]

Done.

   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     bool result = BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &BrowsingDataRemover::OnClearedDatabases, rv));
     DCHECK(result);
     return;
   }
   // Notify the UI thread that we are done.
   database_tracker_ = NULL;
   waiting_for_clear_databases_ = false;
 
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearDatabasesOnFILEThread() {

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

ditto?

[Mike West, 2011/07/27 12:49:18]

Done.

   // 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()) {
+    profile_->GetQuotaManager()->GetOriginsModifiedSince(
+        quota::kStorageTypePersistent, delete_begin_, NewCallback(this,
+            &BrowsingDataRemover::OnGotPersistentQuotaManagedOrigins));
+  } 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>::const_iterator origin;
+  for (origin = origins.begin(); origin != origins.end(); ++origin) {
+    if (special_storage_policy_->IsStorageProtected(origin->GetOrigin()))
+      continue;
+    ++temporary_quota_origins_to_delete_count_;

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

There is a codepath where the QuotaManager will invoke the callback prior to
return from DeleteOriginData. It's not really an expected case in chrome, but it
does exist. Not sure if it's worth it, but consider computing the full 'count'
prior to making the DeleteOriginData calls.

[Mike West, 2011/07/27 12:49:18]

I'll ping you about this.  I'm not sure I understand why I'd want to do that
(or, really, how I'd go about doing it without a lot of overhead. :) ).

+    quota_manager_->DeleteOriginData(origin->GetOrigin(),
+        quota::kStorageTypeTemporary, NewCallback(this,
+            &BrowsingDataRemover::OnTemporaryQuotaManagedOriginDeletion));
+  }
+  if (temporary_quota_origins_to_delete_count_ == 0)
+    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.
+  std::set<GURL>::const_iterator origin;
+  for (origin = origins.begin(); origin != origins.end(); ++origin) {
+    if (special_storage_policy_->IsStorageProtected(origin->GetOrigin()))
+      continue;
+    ++persistent_quota_origins_to_delete_count_;
+    quota_manager_->DeleteOriginData(origin->GetOrigin(),
+        quota::kStorageTypePersistent, NewCallback(this,
+            &BrowsingDataRemover::OnPersistentQuotaManagedOriginDeletion));
+  }
+  if (persistent_quota_origins_to_delete_count_ == 0)
+    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(

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

There's a fair amount of code duplication between

OnTemporaryQuotaManagedOriginDeletion()
OnPersistentQuotaManagedOriginDeletio()
and
CheckTemporaryQuotaManagedDataDeletionStatus()
CheckPersistentQuotaManagedDataDeletionStatus()

Maybe condense this to fewer methods.

void OnQuotaManagerOriginDeleted() {
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  --quota_origins_to_delete_count_;  // TEMP and PERSISTENT
  if (!quota_origins_to_delete_count_)
    PostTask(&OnClearedQuotaManager);
}

void OnClearedQuotaManager() {
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  waiting_for_clear_quota_manager_ = false;
  NotifyAndDeleteIfDone();
}

[Mike West, 2011/07/27 12:49:18]

I agree in part, and I've made some changes here, but I don't see a way around
at least some duplication. See comments in .h and the new unit tests.

+    quota::QuotaStatusCode status) {
+  DCHECK_GT(temporary_quota_origins_to_delete_count_, 0);
+  if (status != quota::kQuotaStatusOk) {
+    // TODO(mkwst): We should add the GURL to StatusCallback; this is a pretty
+    // worthless error message otherwise.
+    DLOG(ERROR) << "Couldn't remove origin. Status: " << status;
   }
 
-  if (!appcaches_to_be_deleted_count_)
-    OnClearedAppCache();
-  // else continues in OnAppCacheDeleted
+  --temporary_quota_origins_to_delete_count_;
+  if (temporary_quota_origins_to_delete_count_ == 0)
+    CheckTemporaryQuotaManagedDataDeletionStatus();
 }
 
-void BrowsingDataRemover::OnAppCacheDeleted(int rv) {
-  --appcaches_to_be_deleted_count_;
-  if (!appcaches_to_be_deleted_count_)
-    OnClearedAppCache();
+void BrowsingDataRemover::OnPersistentQuotaManagedOriginDeletion(
+    quota::QuotaStatusCode status) {
+  DCHECK_GT(persistent_quota_origins_to_delete_count_, 0);
+  if (status != quota::kQuotaStatusOk)
+    DLOG(ERROR) << "Couldn't remove origin. Status: " << status;
+
+  --persistent_quota_origins_to_delete_count_;
+  if (persistent_quota_origins_to_delete_count_ == 0)
+    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());
+void BrowsingDataRemover::CheckTemporaryQuotaManagedDataDeletionStatus() {
+  DCHECK_EQ(temporary_quota_origins_to_delete_count_, 0);
+  DCHECK(waiting_for_clear_temporary_quota_managed_data_);
 
-  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
+  waiting_for_clear_temporary_quota_managed_data_ = false;
+
+  if (!waiting_for_clear_persistent_quota_managed_data_ &&
+      !waiting_for_clear_temporary_quota_managed_data_) {
+    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() {
+  DCHECK_EQ(persistent_quota_origins_to_delete_count_, 0);
+  DCHECK(waiting_for_clear_persistent_quota_managed_data_);
+
+  waiting_for_clear_persistent_quota_managed_data_ = false;
+  if (!waiting_for_clear_persistent_quota_managed_data_ &&
+      !waiting_for_clear_temporary_quota_managed_data_) {
+    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();
 }