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 22 matching lines @@
 #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)
@@ skipping 13 matching lines @@
       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_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) {
+      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),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(CalculateBeginDeleteTime(time_period)),
       delete_end_(delete_end),
@@ skipping 467 matching lines @@
   --appcaches_to_be_deleted_count_;
   if (!appcaches_to_be_deleted_count_)
     OnClearedAppCache();
 }
 
 void BrowsingDataRemover::ClearFileSystemsOnFILEThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(waiting_for_clear_file_systems_);
   scoped_refptr<fileapi::FileSystemContext>
       fs_context(profile_->GetFileSystemContext());
+
+  // We own the reference to the OriginEnumerator, so we wrap it in a scoped_ptr
+  // to ensure that it's destroyed when we leave the FILE thread.
   scoped_ptr<fileapi::SandboxMountPointProvider::OriginEnumerator>
-      origin_enumerator(fs_context->path_manager()->sandbox_provider()->
+      origins(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);
+  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 by
+    // walking through all origins and deleting them if they're unprotected.
+    GURL origin;
+    while (!(origin = origins->Next()).is_empty()) {
+      if (special_storage_policy_->IsStorageProtected(origin))
+        continue;
+      fs_context->DeleteDataForOriginOnFileThread(origin);
     }
-    // TODO(mkwst): Else? Decide what to do for time-based deletion: crbug/63700
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(this, &BrowsingDataRemover::OnClearedFileSystems));
+  } else {
+    // Otherwise, ask the QuotaManager for all origins with temporary quota
+    // modified within the user-specified timeframe, and deal with the resulting
+    // set in ProcessTemporaryQuotaModifiedInTimeframe().
+    temporary_quota_origins_to_delete_count_ = 0;
+    profile_->GetQuotaManager()->GetOriginsModifiedSince(
+        quota::kStorageTypeTemporary, delete_begin_, NewCallback(this,
+            &BrowsingDataRemover::ProcessTemporaryQuotaModifiedInTimeframe));
   }
-
-  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::ProcessTemporaryQuotaModifiedInTimeframe(
+    const std::set<GURL>& origins) {
+  // The QuotaManager is owned by the profile; we can use a raw pointer here,
+  // and rely on the profile to destroy the object whenever it's reasonable.
+  quota::QuotaManager* quota_manager = profile_->GetQuotaManager();
+
+  // 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))
+      continue;
+    ++temporary_quota_origins_to_delete_count_;
+    quota_manager->DeleteOriginData(*origin, quota::kStorageTypeTemporary,
+        NewCallback(this, &BrowsingDataRemover::DeleteOriginDataCallback));
+  }
+  if (temporary_quota_origins_to_delete_count_ == 0) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(this, &BrowsingDataRemover::OnClearedFileSystems));
+  }
+}
+
+void BrowsingDataRemover::DeleteOriginDataCallback(
+    quota::QuotaStatusCode status) {
+  if (status != quota::kQuotaStatusOk) {
+    // TODO(mkwst): Not really anything pretty I can think of to do here.
+  }
+
+  --temporary_quota_origins_to_delete_count_;
+
+  if (temporary_quota_origins_to_delete_count_ == 0) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(this, &BrowsingDataRemover::OnClearedFileSystems));
+  }
+}
+
 // 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() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     bool result = BrowserThread::PostTask(
@@ skipping 13 matching lines @@
 
   ClearGearsData(profile_dir);
   OnClearedGearsData();
 }
 
 void BrowsingDataRemover::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
   waiting_for_clear_lso_data_ = false;
   NotifyAndDeleteIfDone();
 }