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

mojo/services/network/network_service_delegate.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 "mojo/services/network/network_service_delegate.h"
 
 #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")) {
+    base_path = command_line->GetSwitchValuePath("user-data-dir");
+  } else {
+    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, io_worker_thread_->task_runner()));
 }
 
 bool NetworkServiceDelegate::ConfigureIncomingConnection(
     mojo::ApplicationConnection* connection) {
   DCHECK(context_);
   connection->AddService<mojo::NetworkService>(this);
   connection->AddService<mojo::URLLoaderFactory>(this);
   return true;
 }
 
 void NetworkServiceDelegate::Quit() {
   // Destroy the NetworkContext now as it requires MessageLoop::current() upon
   // 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(
     mojo::ApplicationConnection* connection,
     mojo::InterfaceRequest<mojo::NetworkService> request) {
   new mojo::NetworkServiceImpl(
       connection,
       context_.get(),
       app_->app_lifetime_helper()->CreateAppRefCount(),
       request.Pass());
 }
 
 void NetworkServiceDelegate::Create(
     mojo::ApplicationConnection* connection,
     mojo::InterfaceRequest<mojo::URLLoaderFactory> request) {
   new mojo::URLLoaderFactoryImpl(
       connection,
       context_.get(),
       app_->app_lifetime_helper()->CreateAppRefCount(),
       request.Pass());
 }