Run the DOMStorageBrowserTest.SanityCheck against the mojo based implementation.

content/browser/dom_storage/dom_storage_context_wrapper.cc

 // Copyright 2013 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 "content/browser/dom_storage/dom_storage_context_wrapper.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 80 matching lines @@
   void OpenLocalStorage(const url::Origin& origin,
                         mojom::LevelDBObserverPtr observer,
                         mojom::LevelDBWrapperRequest request);
 
  private:
   void OnLevelDDWrapperHasNoBindings(const url::Origin& origin) {
     DCHECK(level_db_wrappers_.find(origin) != level_db_wrappers_.end());
     level_db_wrappers_.erase(origin);
   }
 
+  void OnUserServiceConnectionComplete() {
+    CHECK_EQ(shell::mojom::ConnectResult::SUCCEEDED,
+             user_service_connection_->GetResult());
+  }
+
+  void OnUserServiceConnectionError() {
+    CHECK(false);
+  }
+
   // Part of our asynchronous directory opening called from OpenLocalStorage().
   void OnDirectoryOpened(filesystem::FileError err);
   void OnDatabaseOpened(leveldb::DatabaseError status);
 
   // The (possibly delayed) implementation of OpenLocalStorage(). Can be called
   // directly from that function, or through |on_database_open_callbacks_|.
   void BindLocalStorage(const url::Origin& origin,
                         mojom::LevelDBObserverPtr observer,
                         mojom::LevelDBWrapperRequest request);
 
@@ skipping 25 matching lines @@
 void DOMStorageContextWrapper::MojoState::OpenLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
   // If we don't have a filesystem_connection_, we'll need to establish one.
   if (connection_state_ == NO_CONNECTION) {
     CHECK(connector_);
     user_service_connection_ =
         connector_->Connect(user_service::kUserServiceName);
     connection_state_ = CONNECTION_IN_PROGRESS;
+    user_service_connection_->AddConnectionCompletedClosure(
+        base::Bind(&MojoState::OnUserServiceConnectionComplete,
+                   weak_ptr_factory_.GetWeakPtr()));
+    user_service_connection_->SetConnectionLostClosure(
+        base::Bind(&MojoState::OnUserServiceConnectionError,
+                   weak_ptr_factory_.GetWeakPtr()));
 
     if (!subdirectory_.empty()) {
       // We were given a subdirectory to write to. Get it and use a disk backed
       // database.
       user_service_connection_->GetInterface(&user_service_);
       user_service_->GetSubDirectory(
           mojo::String::From(subdirectory_.AsUTF8Unsafe()),
           GetProxy(&directory_),
           base::Bind(&MojoState::OnDirectoryOpened,
                      weak_ptr_factory_.GetWeakPtr()));
@@ skipping 203 matching lines @@
 
 void DOMStorageContextWrapper::OpenLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
   mojo_state_->OpenLocalStorage(
       origin, std::move(observer), std::move(request));
 }
 
 }  // namespace content