Revert of 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"
 
-namespace {
+NetworkServiceDelegate::NetworkServiceDelegate() : app_(nullptr) {}
 
-const char kSQLThreadName[] = "SQL_IO_Thread";
-const char kUserDataDir[] = "user-data-dir";
-
-// 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() {
-}
+NetworkServiceDelegate::~NetworkServiceDelegate() {}
 
 void NetworkServiceDelegate::Initialize(mojo::ApplicationImpl* app) {
   app_ = app;
-
-#if !defined(OS_ANDROID)
-  // TODO(erg): The following doesn't work when running the android
-  // apptests. It works in the mandoline shell (on desktop and on android), and
-  // in the apptests on desktop. However, on android, whenever we make the call
-  // to OpenFileSystem, the entire mojo system hangs to the point where writes
-  // to stderr that previously would have printed to our console aren't. The
-  // apptests are also fairly resistant to being run under gdb on android.
-  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()));
-#endif
-
-  // 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;
-  const base::CommandLine* command_line =
-      base::CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(kUserDataDir)) {
-    base_path = command_line->GetSwitchValuePath(kUserDataDir);
-  } else {
-    CHECK(PathService::Get(base::DIR_TEMP, &base_path));
-    base_path = base_path.Append(FILE_PATH_LITERAL("network_service"));
-  }
-
-  scoped_refptr<base::SequencedTaskRunner> worker_thread;
-#if !defined(OS_ANDROID)
-  worker_thread = io_worker_thread_->task_runner();
-#endif
-  context_.reset(new mojo::NetworkContext(base_path, worker_thread));
+  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));
 }
 
 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());
 }