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 533 matching lines @@
         main_context_getter_->GetURLRequestContext());
   return request_context ? request_context->appcache_service()
                          : NULL;
 }
 
 void BrowsingDataRemover::ClearFileSystemsOnFILEThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(waiting_for_clear_file_systems_);
   scoped_refptr<fileapi::FileSystemContext>
       fs_context(profile_->GetFileSystemContext());
+
+  // As long as the FileSystemContext is refcounted, we can use a raw pointer
+  // here, and let the FileSystemContext delete the FileSystemFileUtil when
+  // it's destroyed.
+  fileapi::FileSystemFileUtil* file_util = fs_context->path_manager()->
+      sandbox_provider()->GetFileSystemFileUtil();
+
+  scoped_ptr<fileapi::FileSystemOperationContext>
+      op_context(new fileapi::FileSystemOperationContext(
+          fs_context.get(), file_util));
+
+  // 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()) {
+  while (!(origin = origins->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);
+      fs_context->DeleteDataForOriginOnFileThread(origin);
+    } else {
+      // Else, walk through the origin's temporary filesystem. If any file has
+      // been modified in the timeframe, remove the entire filesystem.
+      if (origins->HasFileSystemType(fileapi::kFileSystemTypeTemporary)) {
+        op_context->set_src_origin_url(origin);
+        op_context->set_src_type(fileapi::kFileSystemTypeTemporary);
+
+        // TODO(mkwst): Replace the FileEnumerator with a check against the
+        // quota system, once last_modified dates are available.
+        scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator> files(
+            file_util->CreateFileEnumerator(op_context.get(),
+                FilePath(FILE_PATH_LITERAL("/"))));
+
+        FilePath current;
+        bool was_modified = false;
+        while (!(current = files->Next()).empty()) {
+          base::PlatformFileInfo file_info;
+          FilePath platform_file_path;
+          base::PlatformFileError error_code;
+          error_code = file_util->GetFileInfo(op_context.get(), current,
+              &file_info, &platform_file_path);
+          if (error_code == base::PLATFORM_FILE_OK &&
+              file_info.last_modified >= delete_begin_) {
+            was_modified = true;
+            break;
+          }
+        }
+        if (was_modified) {
+          fs_context->DeleteDataForOriginAndTypeOnFileThread(origin,
+              fileapi::kFileSystemTypeTemporary);
+        }
+      }
     }
-    // TODO(mkwst): Else? Decide what to do for time-based deletion: crbug/63700
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(this, &BrowsingDataRemover::OnClearedFileSystems));
 }
 
 void BrowsingDataRemover::OnClearedFileSystems() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_file_systems_ = false;
@@ skipping 26 matching lines @@
 
   ClearGearsData(profile_dir);
   OnClearedGearsData();
 }
 
 void BrowsingDataRemover::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
   waiting_for_clear_lso_data_ = false;
   NotifyAndDeleteIfDone();
 }