Time-based removal of temporary file systems via BrowsingDataRemover

chrome/browser/browsing_data_remover.cc

Index: chrome/browser/browsing_data_remover.cc
diff --git a/chrome/browser/browsing_data_remover.cc b/chrome/browser/browsing_data_remover.cc
index 74e294c9e66b0cecc6a62bfc5317582ad1432dd8..92bedebe82833978a6b04f5741f558e64c91f8ca 100644
--- a/chrome/browser/browsing_data_remover.cc
+++ b/chrome/browser/browsing_data_remover.cc
@@ -7,6 +7,8 @@
 #include <map>
 #include <set>
 
+#include "base/logging.h"
+
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/platform_file.h"
@@ -560,23 +562,48 @@ void BrowsingDataRemover::ClearFileSystemsOnFILEThread() {
   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);
+        scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator> files(
+            file_util->CreateFileEnumerator(op_context.get(), fs_context->
+                path_manager()->sandbox_provider()->
+                    ValidateFileSystemRootAndGetPathOnFileThread(origin,
+                        fileapi::kFileSystemTypeTemporary, FilePath(), false)));

[ericu, 2011/06/08 18:40:24]

This isn't the right path to pass to CreateFileEnumerator.  You want to pass in
the virtual path of the directory under which you want to check, which in this
case is "/".  Since you've set the src_origin_url and src_type, the context
tells it everything else it needs to know.

However, this still doesn't quite do what you want.  Thanks to "touch", which
can change modification times, and thanks to the fact that one might delete from
a filesystem without setting a mod time on anything that's still around, you'll
miss some modifications.  [That deletion thing's a bug of mine--I haven't yet
made directories' mtimes get updated by deletions of their contents.]

Kinuko, can he leverage the quota code to find out what's really been touched in
this timeframe?

[Use mkwst_at_chromium.org plz., 2011/06/08 19:00:09]

Gah.  Yeah, that makes sense.  I'll try it out tomorrow when I'm back in front
of my computer. :)
I looked at the quota code, but there didn't seem to be any public methods
hanging off QuotaDatabase to pull last modified; setters for last accessed, but
not exactly what I need.  That does seem to be a much more efficient way of
doing things though, if it's actually recording timestamps when things are
touched.

+        FilePath current;
+        while (!(current = files->Next()).empty()) {
+          LOG(INFO) << "Path: " << current.MaybeAsASCII();
+        }
+      }
     }
-    // TODO(mkwst): Else? Decide what to do for time-based deletion: crbug/63700
   }
 
   BrowserThread::PostTask(