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

mojo/services/network/network_service_delegate.cc

Index: mojo/services/network/network_service_delegate.cc
diff --git a/mojo/services/network/network_service_delegate.cc b/mojo/services/network/network_service_delegate.cc
index b3b1c8e8a4bf546bfa4e8ccdc22ddcebc2330811..137747409464d3bff91fbfc9d4763a8c6c6cc5c8 100644
--- a/mojo/services/network/network_service_delegate.cc
+++ b/mojo/services/network/network_service_delegate.cc
@@ -6,23 +6,97 @@
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
+#include "base/bind.h"
+#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "mojo/application/public/cpp/application_connection.h"
+#include "mojo/common/message_pump_mojo.h"
 #include "mojo/services/network/network_service_impl.h"
 #include "mojo/services/network/url_loader_factory_impl.h"
+#include "mojo/util/capture_util.h"
+#include "sql/mojo/mojo_vfs.h"
 
-NetworkServiceDelegate::NetworkServiceDelegate() : app_(nullptr) {}
+namespace {
 
-NetworkServiceDelegate::~NetworkServiceDelegate() {}
+const char kSQLThreadName[] = "SQL_IO_Thread";
+
+// SQL blocks on the filesystem service, so perform all SQL functions on a
+// separate thread.
+class SQLThread : public base::Thread {
+ public:
+  SQLThread(filesystem::DirectoryPtr directory)
+      : base::Thread(kSQLThreadName),
+        directory_info_(directory.PassInterface().Pass()) {
+    base::Thread::Options options;
+    options.message_pump_factory =
+        base::Bind(&mojo::common::MessagePumpMojo::Create);
+    StartWithOptions(options);
+  }
+  ~SQLThread() override { Stop(); }
+
+  void Init() override {
+    filesystem::DirectoryPtr directory;
+    directory.Bind(directory_info_.Pass());
+    vfs_.reset(new sql::ScopedMojoFilesystemVFS(directory.Pass()));
+  }
+
+  void CleanUp() override {
+    vfs_.reset();
+  }
+
+ private:
+  // Our VFS which wraps sqlite so that we can reuse the current sqlite code.
+  scoped_ptr<sql::ScopedMojoFilesystemVFS> vfs_;
+
+  // This member is used to safely pass data from one thread to another. It is
+  // set in the constructor and is consumed in Init().
+  mojo::InterfacePtrInfo<filesystem::Directory> directory_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(SQLThread);
+};
+
+}  // namespace
+
+NetworkServiceDelegate::NetworkServiceDelegate()
+    : app_(nullptr) {
+}
+
+NetworkServiceDelegate::~NetworkServiceDelegate() {
+}
 
 void NetworkServiceDelegate::Initialize(mojo::ApplicationImpl* app) {
   app_ = app;
+
+  mojo::URLRequestPtr request(mojo::URLRequest::New());
+  request->url = mojo::String::From("mojo:filesystem");
+  app_->ConnectToService(request.Pass(), &files_);
+
+  filesystem::FileError error = filesystem::FILE_ERROR_FAILED;
+  filesystem::DirectoryPtr directory;
+  files_->OpenFileSystem("origin", GetProxy(&directory), mojo::Capture(&error));
+  files_.WaitForIncomingResponse();
+
+  io_worker_thread_.reset(new SQLThread(directory.Pass()));
+
+  // TODO(erg): Find everything else that writes to the filesystem and
+  // transition it to proxying mojo:filesystem. We shouldn't have any path
+  // calculation code here, but sadly need it until the transition is done. In
+  // the mean time, manually handle the user-data-dir switch (which gets set in
+  // tests) so that tests are writing to a temp dir.
   base::FilePath base_path;
-  CHECK(PathService::Get(base::DIR_TEMP, &base_path));
-  base_path = base_path.Append(FILE_PATH_LITERAL("network_service"));
-  context_.reset(new mojo::NetworkContext(base_path));
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch("user-data-dir")) {

[jam, 2015/06/25 15:28:24]

seems this should use a constant

+    base_path = command_line->GetSwitchValuePath("user-data-dir");
+  } else {
+    CHECK(PathService::Get(base::DIR_TEMP, &base_path));

[jam, 2015/06/25 15:28:24]

why have all the services that need to write to disk (there may be more than
this one) look for user-data-dir and if it's not there create a temp, as opposed
to do this once in the shell process and then always have it pass user-data-dir
(which may be temp)?

[Elliot Glaysher, 2015/06/25 22:46:48]

We don't want these services to actually have any dependency on paths or to do
any calculation. We want services (other than the filesystem process) to have
any interaction with the disk at all. This entire block here should be deleted
two or three patch sets in the future, but is scaffolding for now.

(This code here has nothing to do with where we put cookies. It exists for just
the network disk cache at this point.)

+    base_path = base_path.Append(FILE_PATH_LITERAL("network_service"));
+  }
+
+  context_.reset(new mojo::NetworkContext(
+      base_path, io_worker_thread_->task_runner()));
 }
 
 bool NetworkServiceDelegate::ConfigureIncomingConnection(
@@ -38,6 +112,10 @@ void NetworkServiceDelegate::Quit() {
   // destruction and it is the last moment we know for sure that it is
   // running.
   context_.reset();
+
+  // Destroy the io worker thread here so that we can commit any pending
+  // cookies here.
+  io_worker_thread_.reset();
 }
 
 void NetworkServiceDelegate::Create(