Time-based removal of temporary file systems via BrowsingDataRemover

chrome/browser/browsing_data_remover_unittest.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 "base/message_loop.h"
 #include "base/platform_file.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/test/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_path_manager.h"
+#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 
 namespace {
 
 const char kTestkOrigin1[] = "http://host1:1/";
 const char kTestkOrigin2[] = "http://host2:1/";
 const char kTestkOrigin3[] = "http://host3:1/";
 
 const GURL kOrigin1(kTestkOrigin1);
 const GURL kOrigin2(kTestkOrigin2);
@@ skipping 83 matching lines @@
     sandbox_->ValidateFileSystemRootAndGetURL(
         origin, type, false, NewCallback(this,
             &RemoveFileSystemTester::FindFileSystemPathCallback));
     BlockUntilNotified();
     return found_file_system_;
   }
 
   virtual void PopulateTestFileSystemData(TestingProfile* profile) {
     // Set up kOrigin1 with a temporary file system, kOrigin2 with a persistent
     // file system, and kOrigin3 with both.
-    sandbox_ = profile->GetFileSystemContext()->path_manager()->
+    profile_ = profile;
+    sandbox_ = profile_->GetFileSystemContext()->path_manager()->
         sandbox_provider();
 
     CreateDirectoryForOriginAndType(kOrigin1,
         fileapi::kFileSystemTypeTemporary);
     CreateDirectoryForOriginAndType(kOrigin2,
         fileapi::kFileSystemTypePersistent);
     CreateDirectoryForOriginAndType(kOrigin3,
         fileapi::kFileSystemTypeTemporary);
     CreateDirectoryForOriginAndType(kOrigin3,
         fileapi::kFileSystemTypePersistent);
 
+    FilePath temp("tempfile.tmp");
+    TouchTestFileForOriginAndType(kOrigin1, fileapi::kFileSystemTypeTemporary,
+        temp, base::Time::Now());
+    TouchTestFileForOriginAndType(kOrigin2, fileapi::kFileSystemTypePersistent,
+        temp, base::Time::Now());
+    TouchTestFileForOriginAndType(kOrigin3, fileapi::kFileSystemTypePersistent,
+        temp, base::Time::Now());
+    TouchTestFileForOriginAndType(kOrigin3, fileapi::kFileSystemTypeTemporary,
+        temp, base::Time::Now());
+
     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin1,
         fileapi::kFileSystemTypePersistent));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin1,
         fileapi::kFileSystemTypeTemporary));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin2,
         fileapi::kFileSystemTypePersistent));
     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin2,
         fileapi::kFileSystemTypeTemporary));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3,
         fileapi::kFileSystemTypePersistent));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3,
         fileapi::kFileSystemTypeTemporary));
   }
 
   void CreateDirectoryForOriginAndType(const GURL& origin,
                                        fileapi::FileSystemType type) {
+    fileapi::FileSystemTestOriginHelper helper(origin, type);
+    helper.SetUp(profile_->GetFileSystemContext(),
+      sandbox_->GetFileSystemFileUtil());
     FilePath target = sandbox_->ValidateFileSystemRootAndGetPathOnFileThread(
         origin, type, FilePath(), true);
     EXPECT_TRUE(file_util::DirectoryExists(target));
   }
 
+  void TouchTestFileForOriginAndType(const GURL& origin,
+                                     fileapi::FileSystemType type,
+                                     const FilePath& path,
+                                     const base::Time& modified) {
+    // We can use a raw pointer here for the same reason that `sandbox_` can be
+    // a raw pointer: everything is destroyed when the profile destroys the
+    // FileSystemContext in which they each live.
+    fileapi::FileSystemFileUtil* file_util = sandbox_->GetFileSystemFileUtil();
+
+    // The operation context, though, we'll have to destroy ourselves.
+    scoped_ptr<fileapi::FileSystemOperationContext>
+        op_context(new fileapi::FileSystemOperationContext(
+            profile_->GetFileSystemContext(), file_util));
+    op_context->set_src_origin_url(origin);
+    op_context->set_src_type(type);
+
+    bool created;
+    base::PlatformFileError status = file_util->EnsureFileExists(
+        op_context.get(), path, &created);
+    EXPECT_EQ(base::PLATFORM_FILE_OK, status);
+    EXPECT_TRUE(created);
+  }
+
  private:
+  // We own neither of these pointers; we shouldn't destroy them.
   fileapi::SandboxMountPointProvider* sandbox_;
+  TestingProfile* profile_;
   bool found_file_system_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveFileSystemTester);
 };
 
 class BrowsingDataRemoverTest : public testing::Test {
  public:
   BrowsingDataRemoverTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         db_thread_(BrowserThread::DB, &message_loop_),
@@ skipping 93 matching lines @@
   EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin2,
       fileapi::kFileSystemTypePersistent));
   EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin2,
       fileapi::kFileSystemTypeTemporary));
   EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin3,
       fileapi::kFileSystemTypePersistent));
   EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin3,
       fileapi::kFileSystemTypeTemporary));
 }
 
+TEST_F(BrowsingDataRemoverTest, RemoveFileSystemsForLastHour) {
+  scoped_ptr<RemoveFileSystemTester> tester(new RemoveFileSystemTester());
+
+  tester->PopulateTestFileSystemData(GetProfile());
+
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
+      base::Time::Now(), BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+
+  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin1,
+      fileapi::kFileSystemTypePersistent));
+  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin1,
+      fileapi::kFileSystemTypeTemporary));
+  EXPECT_TRUE(tester->FileSystemContainsOriginAndType(kOrigin2,
+      fileapi::kFileSystemTypePersistent));
+  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin2,
+      fileapi::kFileSystemTypeTemporary));
+  EXPECT_TRUE(tester->FileSystemContainsOriginAndType(kOrigin3,
+      fileapi::kFileSystemTypePersistent));
+  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin3,
+      fileapi::kFileSystemTypeTemporary));
+}
+
 }  // namespace