mandoline filesystem: Save cookie data to the mojo:filesystem.

sql/mojo/vfs_unittest.cc

 // Copyright 2015 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 "components/filesystem/public/interfaces/file_system.mojom.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 #include "mojo/util/capture_util.h"
 #include "sql/mojo/mojo_vfs.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 12 matching lines @@
     delete [] reinterpret_cast<uint8_t*>(ptr);
   }
 };
 
 }  // namespace base
 
 namespace sql {
 
 const char kFileName[] = "TestingDatabase.db";
 
-class VFSTest : public mojo::test::ApplicationTestBase {
+class VFSTest : public mojo::test::ApplicationTestBase,
+                public filesystem::FileSystemClient {
  public:
-  VFSTest() {}
+  VFSTest() : binding_(this) {}
   ~VFSTest() override {}
 
   sqlite3_vfs* vfs() {
     return sqlite3_vfs_find(NULL);
   }
 
   scoped_ptr<sqlite3_file> MakeFile() {
     return scoped_ptr<sqlite3_file>(reinterpret_cast<sqlite3_file*>(
         new uint8_t[vfs()->szOsFile]));
   }
 
   void SetUp() override {
     mojo::test::ApplicationTestBase::SetUp();
 
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From("mojo:filesystem");
     application_impl()->ConnectToService(request.Pass(), &files_);
 
+    filesystem::FileSystemClientPtr client;
+    binding_.Bind(GetProxy(&client));
+
     filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
     filesystem::DirectoryPtr directory;
-    files_->OpenFileSystem("temp", GetProxy(&directory), mojo::Capture(&error));
+    files_->OpenFileSystem("temp", GetProxy(&directory), client.Pass(),
+                           mojo::Capture(&error));
     ASSERT_TRUE(files_.WaitForIncomingResponse());
     ASSERT_EQ(filesystem::FILE_ERROR_OK, error);
 
     vfs_.reset(new ScopedMojoFilesystemVFS(directory.Pass()));
   }
 
   void TearDown() override {
     vfs_.reset();
     mojo::test::ApplicationTestBase::TearDown();
   }
 
+  void OnFileSystemShutdown() override {
+  }
+
  private:
   filesystem::FileSystemPtr files_;
   scoped_ptr<ScopedMojoFilesystemVFS> vfs_;
+  mojo::Binding<filesystem::FileSystemClient> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(VFSTest);
 };
 
 TEST_F(VFSTest, TestInstalled) {
   EXPECT_EQ("mojo", vfs()->zName);
 }
 
 TEST_F(VFSTest, ExclusiveOpen) {
   // Opening a non-existent file exclusively should work.
@@ skipping 27 matching lines @@
   scoped_ptr<sqlite3_file> file2(MakeFile());
   rc = vfs()->xOpen(vfs(), kFileName, file2.get(),
                     SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
                     &out_flags);
   EXPECT_EQ(SQLITE_OK, rc);
 
   file->pMethods->xClose(file.get());
   file->pMethods->xClose(file2.get());
 }
 
+TEST_F(VFSTest, NullFilenameOpen) {
+  // Opening a file with a null filename should return a valid file object.
+  scoped_ptr<sqlite3_file> file(MakeFile());
+  int out_flags;
+  int rc = vfs()->xOpen(
+      vfs(), nullptr, file.get(),
+      SQLITE_OPEN_DELETEONCLOSE | SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
+      &out_flags);
+  EXPECT_EQ(SQLITE_OK, rc);
+
+  file->pMethods->xClose(file.get());
+}
+
 TEST_F(VFSTest, DeleteOnClose) {
   {
     scoped_ptr<sqlite3_file> file(MakeFile());
     int out_flags;
     int rc = vfs()->xOpen(
         vfs(), kFileName, file.get(),
         SQLITE_OPEN_DELETEONCLOSE | SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
         &out_flags);
     EXPECT_EQ(SQLITE_OK, rc);
     file->pMethods->xClose(file.get());
@@ skipping 180 matching lines @@
   EXPECT_EQ(SQLITE_OK, rc);
 
   rc = file->pMethods->xFileSize(file.get(), &size);
   EXPECT_EQ(SQLITE_OK, rc);
   EXPECT_EQ(kCharsToThree, size);
 
   file->pMethods->xClose(file.get());
 }
 
 }  // namespace sql