mojo leveldb: Get profile and leveldb connected to DOMStorageContext.

components/profile_service/leveldb_thread.cc

+// Copyright 2016 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/profile_service/leveldb_thread.h"
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+#include "components/leveldb/leveldb_service_impl.h"
+#include "mojo/message_pump/message_pump_mojo.h"
+
+namespace profile {
+
+LevelDBThread::LevelDBThread(
+    scoped_ptr<mojo::MessageLoopRef> message_loop_ref,
+    mojo::InterfaceRequest<leveldb::LevelDBService> request)
+    : base::Thread("profile/LevelDBThread"),
+      parent_thread_message_loop_ref_(std::move(message_loop_ref)),
+      initial_leveldb_request_(std::move(request)) {
+  base::Thread::Options options;
+  options.message_pump_factory =
+      base::Bind(&mojo::common::MessagePumpMojo::Create);

[Ben Goodger (Google), 2016/03/11 23:21:37]

I don't believe you have to do this anymore.

[Elliot Glaysher, 2016/03/14 20:33:20]

If I don't do this, I get:

   Check failed: GetThreadWasQuitProperly().

on shutdown. Also, we're still manually calling this in mojo:font_service,
mojo:leveldb, etc.

[Ben Goodger (Google), 2016/03/14 22:25:57]

I think you should use another MessagePump type then. According to Yuzhu
MessagePumpMojo shouldn't be required anymore.

[Elliot Glaysher, 2016/03/14 23:14:53]

Done. (There's a weird interaction where Threads using non-custom message loops
need to have SetThreadWasQuitProperly() before they're destroyed, but custom
message loops don't need that.)

+  StartWithOptions(options);
+}
+
+LevelDBThread::~LevelDBThread() {}
+
+void LevelDBThread::OnServiceError() {
+  if (leveldb_bindings_->empty()) {
+    // We have released the last leveldb service holding on to our reference;
+    // release our service and bindings. We need to do this on connection error
+    // so that it happens on our db thread and not our parent thread.
+    leveldb_service_.reset();
+    leveldb_bindings_.reset();

[Ben Goodger (Google), 2016/03/11 23:21:37]

rather than use a scoped_ptr<mojo::BindingSet<>>, you could use mojo::BindingSet
& call CloseAllBindings() here.

[Elliot Glaysher, 2016/03/14 20:33:20]

I can not do that without getting CalledOnValidThread() errors.

(The problem is that even empty mojo::Callbacks have thread affinity to the
thread that created them. And BindingSet creates a non empty closure to call
this method on connection errors, and sets that up from the launched thread.)

[Ben Goodger (Google), 2016/03/14 22:25:57]

What thread is this called on and what thread are the bindings on?

[Elliot Glaysher, 2016/03/14 23:14:53]

This base::Thread is started up, and in LevelDBThread::Init(), we create the
BindingSet so that it's bound to this base::Thread. We also set the connection
error there, so it will run on this base::Thread too. However, this class's
destructor gets run on our spawner's thread, which is why we need to be able to
reset the bindings here on error.

+  }
+}
+
+void LevelDBThread::BindNewRequest(
+    mojo::InterfaceRequest<leveldb::LevelDBService> request) {
+  DCHECK_NE(GetThreadId(), base::PlatformThread::CurrentId());
+  task_runner()->PostTask(
+      FROM_HERE, base::Bind(&LevelDBThread::BindNewRequestImpl, this,
+                            base::Passed(&request)));
+}
+
+void LevelDBThread::BindNewRequestImpl(
+    mojo::InterfaceRequest<leveldb::LevelDBService> request) {

[Ben Goodger (Google), 2016/03/11 23:21:38]

nit: here, and elsewhere, the new hotness is to use the generated:

leveldb::LevelDBServiceRequest

+  DCHECK_EQ(GetThreadId(), base::PlatformThread::CurrentId());
+  DCHECK(leveldb_service_);
+  leveldb_bindings_->AddBinding(leveldb_service_.get(), std::move(request));
+}
+
+void LevelDBThread::Init() {
+  leveldb_service_.reset(new leveldb::LevelDBServiceImpl(
+      thread_message_loop_ref_.CreateRef()));
+  leveldb_bindings_.reset(new mojo::BindingSet<leveldb::LevelDBService>);
+  leveldb_bindings_->set_connection_error_handler(
+      base::Bind(&LevelDBThread::OnServiceError, base::Unretained(this)));
+  leveldb_bindings_->AddBinding(leveldb_service_.get(),
+                                std::move(initial_leveldb_request_));
+}
+
+void LevelDBThread::CleanUp() {
+  parent_thread_message_loop_ref_.reset();

[michaeln, 2016/03/16 03:11:12]

Maybe cleanup long lived objects with thread affinity here, a balancing delete
of the objects created in init.

+}
+
+}  // namespace profile