Support filesystem files from BlobURLRequestJob

webkit/blob/blob_url_request_job_unittest.cc

Index: webkit/blob/blob_url_request_job_unittest.cc
diff --git a/webkit/blob/blob_url_request_job_unittest.cc b/webkit/blob/blob_url_request_job_unittest.cc
index 3afde19a95c4ea9e0315df7ba66bd32570be2555..7696418c4ab768d9469d6cd28e13e6ae260699e1 100644
--- a/webkit/blob/blob_url_request_job_unittest.cc
+++ b/webkit/blob/blob_url_request_job_unittest.cc
@@ -27,16 +27,40 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/blob/blob_data.h"
 #include "webkit/blob/blob_url_request_job.h"
+#include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_operation_context.h"
+#include "webkit/fileapi/file_system_task_runners.h"
+#include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/mock_file_system_options.h"
+#include "webkit/fileapi/sandbox_mount_point_provider.h"

[kinuko, 2012/10/18 11:57:54]

I think we can avoid including this file. (See comments below)

[hashimoto, 2012/10/18 13:38:13]

Done.

+#include "webkit/quota/mock_special_storage_policy.h"

[kinuko, 2012/10/18 11:57:54]

ditto

[hashimoto, 2012/10/18 13:38:13]

Done.

 
 namespace webkit_blob {
 
-static const int kBufferSize = 1024;
-static const char kTestData1[] = "Hello";
-static const char kTestData2[] = "Here it is data.";
-static const char kTestFileData1[] = "0123456789";
-static const char kTestFileData2[] = "This is sample file.";
-static const char kTestContentType[] = "foo/bar";
-static const char kTestContentDisposition[] = "attachment; filename=foo.txt";
+namespace {
+
+const int kBufferSize = 1024;
+const char kTestData1[] = "Hello";
+const char kTestData2[] = "Here it is data.";
+const char kTestFileData1[] = "0123456789";
+const char kTestFileData2[] = "This is sample file.";
+const char kTestFileSystemFileData1[] = "abcdefghijklmnop";
+const char kTestFileSystemFileData2[] = "File system file test data.";
+const char kTestContentType[] = "foo/bar";
+const char kTestContentDisposition[] = "attachment; filename=foo.txt";
+
+const char kFileSystemURLOrigin[] = "http://remote";
+
+GURL GetFileSystemURL(const std::string& filename) {
+  std::string url_string = "filesystem:";
+  url_string += kFileSystemURLOrigin;
+  url_string += fileapi::kTemporaryDir;
+  url_string += "/";
+  url_string += filename;
+  return GURL(url_string);

[kinuko, 2012/10/18 11:57:54]

Can we use GetFileSystemRootURI()? something like:

GURL(fileapi::GetFileSystemRootURI(GURL(kFileSystemURLOrigin),
fileapi::kFileSystemTypeTemporary).spec() + filename)

[hashimoto, 2012/10/18 13:38:13]

Done.

+}
+
+}  // namespace
 
 class BlobURLRequestJobTest : public testing::Test {
  public:
@@ -164,17 +188,84 @@ class BlobURLRequestJobTest : public testing::Test {
     test_finished_event_->Wait();
   }
 
+  void WriteFileSystemFile(const std::string& filename,
+                           const char* buf, int buf_size,
+                           base::Time* modification_time) {
+    fileapi::FileSystemURL url(GURL(kFileSystemURLOrigin),
+                               fileapi::kFileSystemTypeTemporary,
+                               FilePath().AppendASCII(filename));
+
+    fileapi::FileSystemFileUtil* file_util = file_system_context_->
+        sandbox_provider()->GetFileUtil(fileapi::kFileSystemTypeTemporary);

[kinuko, 2012/10/18 11:57:54]

file_system_context_->GetFileUtil(type) should work.

It might be nicer to define some constant for fileapi::kFileSystemTypeTemporary
so that we can easily change testing fs type if necessary (e.g. we can instead
use kFileSystemTypeTest for simpler tests) & save typing.

[hashimoto, 2012/10/18 13:38:13]

Done.

Here I was mimicking file_system_url_request_job_unittest.cc, and
file_system_file_stream_reader_unitteest.cc is also doing the same thing.
Should I also fix them?
Done.

[kinuko, 2012/10/19 04:07:19]

I see... could you fix them as well in a separate patch?  Directly using
sandbox_provider() is not very portable unless we're specifically interested in
testing the SandboxMountPointProvider.

+
+    fileapi::FileSystemOperationContext context(file_system_context_);
+    context.set_allowed_bytes_growth(1024);
+
+    base::PlatformFile handle = base::kInvalidPlatformFileValue;
+    bool created = false;
+    ASSERT_EQ(base::PLATFORM_FILE_OK, file_util->CreateOrOpen(
+        &context,
+        url,
+        base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE,
+        &handle,
+        &created));
+    EXPECT_TRUE(created);
+    ASSERT_NE(base::kInvalidPlatformFileValue, handle);
+    ASSERT_EQ(buf_size,
+        base::WritePlatformFile(handle, 0 /* offset */, buf, buf_size));
+    base::ClosePlatformFile(handle);
+
+    base::PlatformFileInfo file_info;
+    FilePath platform_path;
+    ASSERT_EQ(base::PLATFORM_FILE_OK,
+              file_util->GetFileInfo(&context, url, &file_info,
+                                     &platform_path));
+    if (modification_time)
+      *modification_time = file_info.last_modified;
+  }
+
   void SetUpTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
 
     net::URLRequest::Deprecated::RegisterProtocolFactory(
         "blob", &BlobURLRequestJobFactory);
     url_request_delegate_.reset(new MockURLRequestDelegate(this));
+
+    // Prepare file system.

[kinuko, 2012/10/18 11:57:54]

It feels a bit heavy to run this setup for every test.  Can we only setup
filesystem env for the tests that use FileSystemURL?

[hashimoto, 2012/10/18 13:38:13]

Sorry, it looks my understanding of webkit/fileapi code is not so good.
You mean there is a light weight utility which can be used to provide
FileSystemContext for tests?

[kinuko, 2012/10/19 04:07:19]

As we chatted I meant we shouldn't always do this but can put this part in a
separate function and call it only in tests that are related to FileSystemURL.

+    special_storage_policy_ = new quota::MockSpecialStoragePolicy;
+    file_system_context_ = new fileapi::FileSystemContext(
+        fileapi::FileSystemTaskRunners::CreateMockTaskRunners(),
+        new quota::MockSpecialStoragePolicy,

[kinuko, 2012/10/18 11:57:54]

special_storage_policy_ ?

Actually I think you can pass NULL here.

[hashimoto, 2012/10/18 13:38:13]

Sorry, something went wrong during merge.
Done.

+        NULL,
+        temp_dir_.path(),
+        fileapi::CreateDisallowFileAccessOptions());
+    file_system_context_->sandbox_provider()->ValidateFileSystemRoot(
+        GURL(kFileSystemURLOrigin), fileapi::kFileSystemTypeTemporary,
+        true /* create */, base::Bind(&OnValidateFileSystem));

[kinuko, 2012/10/18 11:57:54]

Can we instead call file_system_context_->OpenFileSystem() here?

[hashimoto, 2012/10/18 13:38:13]

Done.

+    MessageLoop::current()->RunAllPending();
+
+    ASSERT_EQ(static_cast<int>(arraysize(kTestFileData1) - 1),
+              file_util::WriteFile(temp_file1_, kTestFileData1,
+                                   arraysize(kTestFileData1) - 1));
+
+    // Prepare files on file system.
+    const char kFileSystemFilename1[] = "FileSystemFile1.dat";
+    temp_file_system_file1_ = GetFileSystemURL(kFileSystemFilename1);
+    WriteFileSystemFile(kFileSystemFilename1, kTestFileSystemFileData1,
+                        arraysize(kTestFileSystemFileData1),
+                        &temp_file_system_file_modification_time1_);
+    const char kFileSystemFilename2[] = "FileSystemFile2.dat";
+    temp_file_system_file2_ = GetFileSystemURL(kFileSystemFilename2);
+    WriteFileSystemFile(kFileSystemFilename2, kTestFileSystemFileData2,
+                        arraysize(kTestFileSystemFileData2),
+                        &temp_file_system_file_modification_time2_);
   }
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
 
+    file_system_context_ = NULL;
+
     request_.reset();
     url_request_delegate_.reset();
 
@@ -221,6 +312,10 @@ class BlobURLRequestJobTest : public testing::Test {
       MessageLoop::current()->PostTask(FROM_HERE, task);
   }
 
+  static void OnValidateFileSystem(base::PlatformFileError result) {
+    ASSERT_EQ(base::PLATFORM_FILE_OK, result);
+  }
+
   void TestSuccessRequest(BlobData* blob_data,
                           const std::string& expected_response) {
     PushNextTask(base::Bind(&BlobURLRequestJobTest::VerifyResponse,
@@ -250,6 +345,7 @@ class BlobURLRequestJobTest : public testing::Test {
         request_.get(),
         empty_context_.network_delegate(),
         blob_data,
+        file_system_context_,
         base::MessageLoopProxy::current());
 
     // Start the request.
@@ -320,16 +416,68 @@ class BlobURLRequestJobTest : public testing::Test {
     TestSuccessRequest(blob_data, result);
   }
 
+  void TestGetSimpleFileSystemFileRequest() {
+    scoped_refptr<BlobData> blob_data(new BlobData());
+    blob_data->AppendFileSystemFile(temp_file_system_file1_, 0, -1,
+                                    base::Time());
+    TestSuccessRequest(blob_data, kTestFileSystemFileData1);
+  }
+
+  void TestGetLargeFileSystemFileRequest() {
+    std::string large_data;
+    large_data.reserve(kBufferSize * 5);
+    for (int i = 0; i < kBufferSize * 5; ++i)
+      large_data.append(1, static_cast<char>(i % 256));
+
+    const char kFilename[] = "LargeBlob.dat";
+    WriteFileSystemFile(kFilename, large_data.data(), large_data.size(), NULL);
+
+    scoped_refptr<BlobData> blob_data(new BlobData());
+    blob_data->AppendFileSystemFile(GetFileSystemURL(kFilename),
+                                    0, -1, base::Time());
+    TestSuccessRequest(blob_data, large_data);
+  }
+
+  void TestGetNonExistentFileSystemFileRequest() {
+    GURL non_existent_file = GetFileSystemURL("non-existent.dat");
+    scoped_refptr<BlobData> blob_data(new BlobData());
+    blob_data->AppendFileSystemFile(non_existent_file, 0, -1, base::Time());
+    TestErrorRequest(blob_data, 404);
+  }
+
+  void TestGetChangedFileSystemFileRequest() {
+    scoped_refptr<BlobData> blob_data(new BlobData());
+    base::Time old_time =
+        temp_file_system_file_modification_time1_ -
+        base::TimeDelta::FromSeconds(10);
+    blob_data->AppendFileSystemFile(temp_file_system_file1_, 0, 3, old_time);
+    TestErrorRequest(blob_data, 404);
+  }
+
+  void TestGetSlicedFileSystemFileRequest() {
+    scoped_refptr<BlobData> blob_data(new BlobData());
+    blob_data->AppendFileSystemFile(temp_file_system_file1_, 2, 4,
+                                    temp_file_system_file_modification_time1_);
+    std::string result(kTestFileSystemFileData1 + 2, 4);
+    TestSuccessRequest(blob_data, result);
+  }
+
   scoped_refptr<BlobData> BuildComplicatedData(std::string* expected_result) {
     scoped_refptr<BlobData> blob_data(new BlobData());
     blob_data->AppendData(kTestData1 + 1, 2);
     blob_data->AppendFile(temp_file1_, 2, 3, temp_file_modification_time1_);
-    blob_data->AppendData(kTestData2 + 3, 4);
-    blob_data->AppendFile(temp_file2_, 4, 5, temp_file_modification_time2_);
+    blob_data->AppendFileSystemFile(temp_file_system_file1_, 3, 4,
+                                    temp_file_system_file_modification_time1_);
+    blob_data->AppendData(kTestData2 + 4, 5);
+    blob_data->AppendFile(temp_file2_, 5, 6, temp_file_modification_time2_);
+    blob_data->AppendFileSystemFile(temp_file_system_file2_, 6, 7,
+                                    temp_file_system_file_modification_time2_);
     *expected_result = std::string(kTestData1 + 1, 2);
     *expected_result += std::string(kTestFileData1 + 2, 3);
-    *expected_result += std::string(kTestData2 + 3, 4);
-    *expected_result += std::string(kTestFileData2 + 4, 5);
+    *expected_result += std::string(kTestFileSystemFileData1 + 3, 4);
+    *expected_result += std::string(kTestData2 + 4, 5);
+    *expected_result += std::string(kTestFileData2 + 5, 6);
+    *expected_result += std::string(kTestFileSystemFileData2 + 6, 7);
     return blob_data;
   }
 
@@ -395,6 +543,10 @@ class BlobURLRequestJobTest : public testing::Test {
   FilePath temp_file2_;
   base::Time temp_file_modification_time1_;
   base::Time temp_file_modification_time2_;
+  GURL temp_file_system_file1_;
+  GURL temp_file_system_file2_;
+  base::Time temp_file_system_file_modification_time1_;
+  base::Time temp_file_system_file_modification_time2_;
   scoped_ptr<base::Thread> io_thread_;
   static BlobURLRequestJob* blob_url_request_job_;
 
@@ -403,6 +555,8 @@ class BlobURLRequestJobTest : public testing::Test {
   net::URLRequestContext empty_context_;
   scoped_ptr<net::URLRequest> request_;
   scoped_ptr<MockURLRequestDelegate> url_request_delegate_;
+  scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy_;
+  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
   int expected_status_code_;
   std::string expected_response_;
 };
@@ -434,6 +588,28 @@ TEST_F(BlobURLRequestJobTest, TestGetChangedFileRequest) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestGetChangedFileRequest);
 }
 
+TEST_F(BlobURLRequestJobTest, TestGetSimpleFileSystemFileRequest) {
+  RunTestOnIOThread(&BlobURLRequestJobTest::TestGetSimpleFileSystemFileRequest);
+}
+
+TEST_F(BlobURLRequestJobTest, TestGetLargeFileSystemFileRequest) {
+  RunTestOnIOThread(&BlobURLRequestJobTest::TestGetLargeFileSystemFileRequest);
+}
+
+TEST_F(BlobURLRequestJobTest, TestGetSlicedFileSystemFileRequest) {
+  RunTestOnIOThread(&BlobURLRequestJobTest::TestGetSlicedFileSystemFileRequest);
+}
+
+TEST_F(BlobURLRequestJobTest, TestGetNonExistentFileSystemFileRequest) {
+  RunTestOnIOThread(
+      &BlobURLRequestJobTest::TestGetNonExistentFileSystemFileRequest);
+}
+
+TEST_F(BlobURLRequestJobTest, TestGetChangedFileSystemFileRequest) {
+  RunTestOnIOThread(
+      &BlobURLRequestJobTest::TestGetChangedFileSystemFileRequest);
+}
+
 TEST_F(BlobURLRequestJobTest, TestGetComplicatedDataAndFileRequest) {
   RunTestOnIOThread(
       &BlobURLRequestJobTest::TestGetComplicatedDataAndFileRequest);