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

sql/mojo/mojo_vfs.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 "sql/mojo/mojo_vfs.h"
 
 #include "base/logging.h"
 #include "base/rand_util.h"
+#include "base/strings/stringprintf.h"
 #include "components/filesystem/public/interfaces/file.mojom.h"
 #include "components/filesystem/public/interfaces/file_system.mojom.h"
 #include "components/filesystem/public/interfaces/types.mojom.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/util/capture_util.h"
 #include "third_party/sqlite/sqlite3.h"
 
 using mojo::Capture;
 
 namespace sql {
@@ skipping 177 matching lines @@
 }
 
 int MojoVFSSectorSize(sqlite3_file* pFile) {
   DVLOG(1) << "MojoVFSSectorSize(*)";
   // Use the default sector size.
   return 0;
 }
 
 int MojoVFSDeviceCharacteristics(sqlite3_file* pFile) {
   DVLOG(1) << "MojoVFSDeviceCharacteristics(*)";
-  NOTIMPLEMENTED();
+  // TODO(erg): Figure out what to return here. (This function is super spammy,
+  // so not leaving a NOTIMPLEMENTED().)

[Scott Hess - ex-Googler, 2015/07/21 21:55:24]

I think "return 0;" is a fine implementation of this.  Any other implementation
either needs to reflect per-platform characteristics or requires guarantees from
the implementation.

Reading the Windows and Unix implementations makes me think this probably makes
sense:
  return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN |
      SQLITE_IOCAP_POWERSAFE_OVERWRITE;
The first is technically not true for Unix, but I think that it will work fine.

   return 0;
 }
 
 static sqlite3_io_methods mojo_vfs_io_methods = {
     1,                            /* iVersion */
     MojoVFSClose,                 /* xClose */
     MojoVFSRead,                  /* xRead */
     MojoVFSWrite,                 /* xWrite */
     MojoVFSTruncate,              /* xTruncate */
     MojoVFSSync,                  /* xSync */
@@ skipping 21 matching lines @@
     open_flags = filesystem::kFlagOpenAlways;
   } else {
     open_flags = filesystem::kFlagOpen;
   }
   open_flags |= filesystem::kFlagRead;
   if (flags & SQLITE_OPEN_READWRITE)
     open_flags |= filesystem::kFlagWrite;
   if (flags & SQLITE_OPEN_DELETEONCLOSE)
     open_flags |= filesystem::kDeleteOnClose;
 
+  mojo::String mojo_name;
+  if (name) {
+    // Don't let callers open the pattern of our temporary databases. When we
+    // open with a null name and SQLITE_OPEN_DELETEONCLOSE, we unlink the
+    // database after we open it. If we create a database here, close it
+    // normally, and then open the same file through the other path, we could
+    // delete the database.
+    CHECK(strncmp("Temp_", name, 5) != 0);
+    mojo_name = name;
+  } else {
+    DCHECK(flags & SQLITE_OPEN_DELETEONCLOSE);
+    static int temp_number = 0;
+    mojo_name = base::StringPrintf("Temp_%d.db", temp_number++);
+  }
+
   // Grab the incoming file
   filesystem::FilePtr file_ptr;
   filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
-  GetRootDirectory(mojo_vfs)->OpenFile(mojo::String(name), GetProxy(&file_ptr),
+  GetRootDirectory(mojo_vfs)->OpenFile(mojo_name, GetProxy(&file_ptr),
                                        open_flags, Capture(&error));
   GetRootDirectory(mojo_vfs).WaitForIncomingResponse();
   if (error != filesystem::FILE_ERROR_OK) {
     // TODO(erg): Translate more of the mojo error codes into sqlite error
     // codes.
     return SQLITE_CANTOPEN;
   }
 
   // Set the method table so we can be closed (and run the manual dtor call to
   // match the following placement news).
@@ skipping 142 matching lines @@
 
   CHECK(sqlite3_vfs_register(parent_, 1) == SQLITE_OK);
   CHECK(sqlite3_vfs_unregister(&mojo_vfs) == SQLITE_OK);
 }
 
 filesystem::DirectoryPtr& ScopedMojoFilesystemVFS::GetDirectory() {
   return root_directory_;
 }
 
 }  // namespace sql