mojo leveldb: Get profile and leveldb connected to DOMStorageContext.

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"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "components/filesystem/public/interfaces/file_system.mojom.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/leveldb_wrapper_impl.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/local_storage_usage_info.h"
+#include "content/public/browser/mojo_app_connection.h"
 #include "content/public/browser/session_storage_usage_info.h"
+#include "mojo/common/common_type_converters.h"
 
 namespace content {
 namespace {
 
 const char kLocalStorageDirectory[] = "Local Storage";
 const char kSessionStorageDirectory[] = "Session Storage";
 
 void InvokeLocalStorageUsageCallbackHelper(
       const DOMStorageContext::GetLocalStorageUsageCallback& callback,
       const std::vector<LocalStorageUsageInfo>* infos) {
@@ skipping 26 matching lines @@
       new std::vector<SessionStorageUsageInfo>;
   context->GetSessionStorageUsage(infos);
   reply_task_runner->PostTask(
       FROM_HERE, base::Bind(&InvokeSessionStorageUsageCallbackHelper, callback,
                             base::Owned(infos)));
 }
 
 }  // namespace
 
 DOMStorageContextWrapper::DOMStorageContextWrapper(
+    BrowserContext* context,
     const base::FilePath& data_path,
-    storage::SpecialStoragePolicy* special_storage_policy) {
+    storage::SpecialStoragePolicy* special_storage_policy)
+    : browser_context_(context),
+      connection_state_(NO_CONNECTION),
+      weak_ptr_factory_(this) {
   base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
   context_ = new DOMStorageContextImpl(
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kLocalStorageDirectory),
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kSessionStorageDirectory),
       special_storage_policy,
       new DOMStorageWorkerPoolTaskRunner(
           worker_pool,
           worker_pool->GetNamedSequenceToken("dom_storage_primary"),
           worker_pool->GetNamedSequenceToken("dom_storage_commit"),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)
               .get()));
 }
 
 DOMStorageContextWrapper::~DOMStorageContextWrapper() {
+  LOG(ERROR) << "Size of level_db_wrappers_: " << level_db_wrappers_.size();

[jam, 2016/03/03 16:32:10]

nit: change from LOG(ERROR) to something else that doesn't show up for everyone,
or only LOG(ERROR) if the container isn't empty?

 }
 
 void DOMStorageContextWrapper::GetLocalStorageUsage(
     const GetLocalStorageUsageCallback& callback) {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&GetLocalStorageUsageHelper,
                  base::ThreadTaskRunnerHandle::Get(), context_, callback));
 }
@@ skipping 65 matching lines @@
 void DOMStorageContextWrapper::Flush() {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE, DOMStorageTaskRunner::PRIMARY_SEQUENCE,
       base::Bind(&DOMStorageContextImpl::Flush, context_));
 }
 
 void DOMStorageContextWrapper::OpenLocalStorage(
     const mojo::String& origin,
     mojo::InterfaceRequest<LevelDBWrapper> request) {
+  // If we don't have a filesystem_connection_, we'll need to establish one.
+  if (connection_state_ == NO_CONNECTION) {
+    profile_connection_ = content::MojoAppConnection::Create(

[jam, 2016/03/03 16:32:10]

nit: here and in other places in the file, no need for for "content::"

+        browser_context_, "mojo:profile", content::kBrowserMojoAppUrl);
+    profile_connection_->GetInterface(&profile_service_);
+
+    profile_service_->GetDirectory(
+        GetProxy(&directory_),
+        base::Bind(&DOMStorageContextWrapper::OnDirectoryOpened,
+                   weak_ptr_factory_.GetWeakPtr()));
+    connection_state_ = CONNECITON_IN_PROGRESS;
+  }
+
+  if (connection_state_ == CONNECITON_IN_PROGRESS) {
+    // Queue this OpenLocalStorage call for when we have a level db pointer.
+    on_database_opened_callbacks_.push_back(
+        base::Bind(&DOMStorageContextWrapper::BindLocalStorage,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   origin,
+                   base::Passed(&request)));
+    return;
+  }
+
+  BindLocalStorage(origin, std::move(request));
+}
+
+void DOMStorageContextWrapper::LevelDBWrapperImplHasNoBindings(
+    const std::string& origin) {
+  // The DCHECK here broke on chrome-extensions.

[jam, 2016/03/03 16:32:10]

can you explain this some more? I don't understand how we would get this
callback and the origin isn't in the map

[Elliot Glaysher, 2016/03/04 18:42:43]

Fixing shutdown elsewhere fixed this. Changed back.

+  level_db_wrappers_.erase(origin);
+}
+
+void DOMStorageContextWrapper::OnDirectoryOpened(filesystem::FileError err) {
+  if (err != filesystem::FileError::OK) {
+    NOTREACHED();
+    return;
+  }
+
+  // Now that we have a directory, connect to the LevelDB service and get our
+  // database.
+  leveldb_connection_ = content::MojoAppConnection::Create(
+      browser_context_, "mojo:leveldb", content::kBrowserMojoAppUrl);
+  leveldb_connection_->GetInterface(&leveldb_);
+
+  leveldb_->Open(std::move(directory_), "dom_storage", GetProxy(&database_),

[jam, 2016/03/03 16:32:10]

s/dom_storage/local_storage


"dom_storage" in the code refers to both local storage and session storage, and
we'll want to store the latter separately. for now, this work is only addressing
local storage

+                 base::Bind(&DOMStorageContextWrapper::OnDatabaseOpened,
+                            weak_ptr_factory_.GetWeakPtr()));
+}
+
+void DOMStorageContextWrapper::OnDatabaseOpened(leveldb::DatabaseError status) {
+  if (status != leveldb::DatabaseError::OK) {
+    NOTREACHED();
+    return;
+  }
+
+  // Tear down the profile connection now; we no longer need it.
+  directory_.reset();
+  profile_service_.reset();
+  profile_connection_.reset();
+
+  // |database_| should be valid now. Run our delayed bindings.
+  connection_state_ = CONNECTED;
+  for (size_t i = 0; i < on_database_opened_callbacks_.size(); ++i)
+    on_database_opened_callbacks_[i].Run();
+  on_database_opened_callbacks_.clear();
+
+  database_->Put(mojo::Array<uint8_t>::From(std::string("key")),
+                 mojo::Array<uint8_t>::From(std::string("value")),
+                 base::Bind(&DOMStorageContextWrapper::OnCrudWritten,
+                            weak_ptr_factory_.GetWeakPtr()));
+}
+
+void DOMStorageContextWrapper::OnCrudWritten(leveldb::DatabaseError status) {
+  LOG(ERROR) << "Writing some crud to dom storage: " << status;
+}
+
+void DOMStorageContextWrapper::BindLocalStorage(
+    const mojo::String& origin,
+    mojo::InterfaceRequest<LevelDBWrapper> request) {
   if (level_db_wrappers_.find(origin) == level_db_wrappers_.end()) {
     level_db_wrappers_[origin] = make_scoped_ptr(new LevelDBWrapperImpl(
+        database_.get(),
         origin,
         base::Bind(&DOMStorageContextWrapper::LevelDBWrapperImplHasNoBindings,
                    base::Unretained(this),
                    origin.get())));
   }
-  // TODO(jam): call LevelDB service (once per this object) to open the database
-  // for LocalStorage and keep a pointer to it in this class. Then keep a map
-  // from origins to LevelDBWrapper object. Each call here for the same origin
-  // should use the same LevelDBWrapper object.
 
   level_db_wrappers_[origin]->Bind(std::move(request));
 }
 
-void DOMStorageContextWrapper::LevelDBWrapperImplHasNoBindings(
-    const std::string& origin) {
-  DCHECK(level_db_wrappers_.find(origin) != level_db_wrappers_.end());
-  level_db_wrappers_.erase(origin);
-}
-
 }  // namespace content