Integrated obfuscation with quota; all unit tests now pass

webkit/fileapi/obfuscated_file_system_file_util_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 <algorithm>
 #include <set>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/scoped_temp_dir.h"
 #include "base/sys_string_conversions.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_test_helper.h"
 #include "webkit/fileapi/obfuscated_file_system_file_util.h"
 
 using namespace fileapi;
 
 namespace {
 
 FilePath UTF8ToFilePath(const std::string& str) {
   FilePath::StringType result;
 #if defined(OS_POSIX)
   result = str;
@@ skipping 59 matching lines @@
   {false, FILE_PATH_LITERAL("file 0"), 38},
   {false, FILE_PATH_LITERAL("file 2"), 60},
   {false, FILE_PATH_LITERAL("file 3"), 0},
   {false, FILE_PATH_LITERAL("dir a/file 0"), 39},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 0"), 40},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 1"), 41},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 2"), 42},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 3"), 50},
 };
 
+struct OriginEnumerationTestRecord {
+  std::string origin_url;
+  bool has_temporary;
+  bool has_persistent;
+};
+
+const OriginEnumerationTestRecord kOriginEnumerationTestRecords[] = {
+  {"http://example.com", false, true},
+  {"http://example1.com", true, false},
+  {"https://example1.com", true, true},
+  {"file://", false, true},
+  {"http://example.com:8000", false, true},
+};
+
 }  // namespace (anonymous)
 
 // TODO(ericu): The vast majority of this and the other FSFU subclass tests
 // could theoretically be shared.  It would basically be a FSFU interface
 // compliance test, and only the subclass-specific bits that look into the
 // implementation would need to be written per-subclass.
 class ObfuscatedFileSystemFileUtilTest : public testing::Test {
  public:
-  ObfuscatedFileSystemFileUtilTest() {
+  ObfuscatedFileSystemFileUtilTest()
+      : origin_(GURL("http://www.example.com")),
+        type_(kFileSystemTypeTemporary),
+        test_helper_(origin_, type_) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
     obfuscated_file_system_file_util_ =
         new ObfuscatedFileSystemFileUtil(data_dir_.path());
+    test_helper_.SetUp(data_dir_.path(),
+                       false, // incognito
+                       false, // unlimited quota
+                       NULL, // quota::QuotaManagerProxy
+                       obfuscated_file_system_file_util_.get());
   }
 
   FileSystemOperationContext* NewContext() {
-    FileSystemOperationContext *context =
-        new FileSystemOperationContext(NULL, NULL);
-    context->set_src_origin_url(GURL("http://example.com"));
-    context->set_dest_origin_url(GURL("http://example.com"));
-    context->set_src_type(kFileSystemTypeTemporary);
-    context->set_dest_type(kFileSystemTypeTemporary);
+    FileSystemOperationContext* context = test_helper_.NewOperationContext();
     context->set_allowed_bytes_growth(1024 * 1024);
-
     return context;
   }
 
   ObfuscatedFileSystemFileUtil* ofsfu() {
     return obfuscated_file_system_file_util_.get();
   }
 
   const FilePath& test_directory() const {
     return data_dir_.path();
   }
 
+  const GURL& origin_url() const {
+    return origin_;
+  }
+
+  FileSystemType type() const {
+    return type_;
+  }
+
   int64 GetSize(const FilePath& path) {
     int64 size;
     EXPECT_TRUE(file_util::GetFileSize(path, &size));
     return size;
   }
 
   void CheckFileAndCloseHandle(
       const FilePath& virtual_path, PlatformFile file_handle) {
     scoped_ptr<FileSystemOperationContext> context(NewContext());
     FilePath local_path;
@@ skipping 166 matching lines @@
                   context.get(), path, last_access_time, last_modified_time));
     context.reset(NewContext());
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
         context.get(), path, &file_info, &local_path));
     EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT());
   }
 
  private:
   ScopedTempDir data_dir_;
   scoped_refptr<ObfuscatedFileSystemFileUtil> obfuscated_file_system_file_util_;
+  GURL origin_;
+  FileSystemType type_;
+  FileSystemTestOriginHelper test_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileSystemFileUtilTest);
 };
 
 TEST_F(ObfuscatedFileSystemFileUtilTest, TestCreateAndDeleteFile) {
   base::PlatformFile file_handle = base::kInvalidPlatformFileValue;
   bool created;
   FilePath path = UTF8ToFilePath("fake/file");
   scoped_ptr<FileSystemOperationContext> context(NewContext());
   int file_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE;
@@ skipping 476 matching lines @@
           base::CreatePlatformFile(
               local_src_path, file_flags, &created, &error_code);
       EXPECT_TRUE(created);
       ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
       ASSERT_TRUE(
           base::TruncatePlatformFile(file_handle, test_case.data_file_size));
       EXPECT_TRUE(base::ClosePlatformFile(file_handle));
     }
   }
 
-  const GURL origin_url("http://example.com");
-  fileapi::FileSystemType type = kFileSystemTypeTemporary;
-  EXPECT_TRUE(ofsfu()->MigrateFromOldSandbox(origin_url, type, root_path));
+  EXPECT_TRUE(ofsfu()->MigrateFromOldSandbox(origin_url(), type(), root_path));
 
   FilePath new_root =
     test_directory().AppendASCII("000").Append(
-        ofsfu()->GetDirectoryNameForType(type)).AppendASCII("Legacy");
+        ofsfu()->GetDirectoryNameForType(type())).AppendASCII("Legacy");
   for (size_t i = 0; i < arraysize(kMigrationTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Validating kMigrationTestPath " << i);
     const MigrationTestCaseRecord& test_case = kMigrationTestCases[i];
     FilePath local_data_path = new_root.Append(test_case.path);
 #if defined(OS_WIN)
     local_data_path = local_data_path.NormalizeWindowsPathSeparators();
 #endif
     scoped_ptr<FileSystemOperationContext> context(NewContext());
     base::PlatformFileInfo ofsfu_file_info;
     FilePath data_path;
@@ skipping 11 matching lines @@
       ASSERT_TRUE(file_util::GetFileInfo(local_data_path, &platform_file_info));
       EXPECT_EQ(test_case.data_file_size, platform_file_info.size);
       EXPECT_FALSE(platform_file_info.is_directory);
       scoped_ptr<FileSystemOperationContext> context(NewContext());
       EXPECT_EQ(local_data_path, data_path);
       EXPECT_EQ(platform_file_info.size, ofsfu_file_info.size);
       EXPECT_FALSE(ofsfu_file_info.is_directory);
     }
   }
 }
+
+TEST_F(ObfuscatedFileSystemFileUtilTest, TestOriginEnumerator) {
+  scoped_ptr<ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator>
+      enumerator(ofsfu()->CreateOriginEnumerator());
+  EXPECT_TRUE(enumerator.get());
+  EXPECT_EQ(GURL(), enumerator->Next());
+  EXPECT_FALSE(enumerator->HasFileSystemType(kFileSystemTypeTemporary));
+  EXPECT_FALSE(enumerator->HasFileSystemType(kFileSystemTypePersistent));
+
+  std::set<GURL> origins_expected;
+
+  for (size_t i = 0; i < arraysize(kOriginEnumerationTestRecords); ++i) {
+    SCOPED_TRACE(testing::Message() <<
+        "Validating kOriginEnumerationTestRecords " << i);
+    const OriginEnumerationTestRecord& record =
+        kOriginEnumerationTestRecords[i];
+    GURL origin_url(record.origin_url);
+    origins_expected.insert(origin_url);
+    if (record.has_temporary) {
+      scoped_ptr<FileSystemOperationContext> context(NewContext());
+      context->set_src_origin_url(origin_url);
+      context->set_src_type(kFileSystemTypeTemporary);
+      bool created = false;
+      ASSERT_EQ(base::PLATFORM_FILE_OK,
+                ofsfu()->EnsureFileExists(context.get(),
+                    FilePath().AppendASCII("file"), &created));
+      EXPECT_TRUE(created);
+    }
+    if (record.has_persistent) {
+      scoped_ptr<FileSystemOperationContext> context(NewContext());
+      context->set_src_origin_url(origin_url);
+      context->set_src_type(kFileSystemTypePersistent);
+      bool created = false;
+      ASSERT_EQ(base::PLATFORM_FILE_OK,
+                ofsfu()->EnsureFileExists(context.get(),
+                    FilePath().AppendASCII("file"), &created));
+      EXPECT_TRUE(created);
+    }
+  }
+  enumerator.reset(ofsfu()->CreateOriginEnumerator());
+  EXPECT_TRUE(enumerator.get());
+  std::set<GURL> origins_found;
+  GURL origin;
+  while (!(origin = enumerator->Next()).is_empty()) {
+    origins_found.insert(origin);
+    SCOPED_TRACE(testing::Message() << "Handling " << origin.spec());
+    bool found = false;
+    for (size_t i = 0; !found && i < arraysize(kOriginEnumerationTestRecords);
+        ++i) {
+      const OriginEnumerationTestRecord& record =
+          kOriginEnumerationTestRecords[i];
+      if (GURL(record.origin_url) != origin)
+        continue;
+      found = true;
+      EXPECT_EQ(record.has_temporary,
+          enumerator->HasFileSystemType(kFileSystemTypeTemporary));
+      EXPECT_EQ(record.has_persistent,
+          enumerator->HasFileSystemType(kFileSystemTypePersistent));
+    }
+    EXPECT_TRUE(found);
+  }
+
+  std::set<GURL> diff;
+  std::set_symmetric_difference(origins_expected.begin(),
+      origins_expected.end(), origins_found.begin(), origins_found.end(),
+      inserter(diff, diff.begin()));
+  EXPECT_TRUE(diff.empty());
+}