mojo leveldb: Get profile and leveldb connected to DOMStorageContext.

content/browser/dom_storage/dom_storage_context_wrapper.h

 // 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.
 
 #ifndef CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_CONTEXT_WRAPPER_H_
 #define CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_CONTEXT_WRAPPER_H_
 
 #include <map>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "components/filesystem/public/interfaces/directory.mojom.h"
+#include "components/filesystem/public/interfaces/file_system.mojom.h"
+#include "components/leveldb/public/interfaces/leveldb.mojom.h"
+#include "components/profile_service/public/interfaces/profile.mojom.h"
 #include "content/common/content_export.h"
 #include "content/common/storage_partition_service.mojom.h"
 #include "content/public/browser/dom_storage_context.h"
 
 namespace base {
 class FilePath;
 }
 
 namespace storage {
 class SpecialStoragePolicy;
 }
 
 namespace content {
 
 class DOMStorageContextImpl;
 class LevelDBWrapperImpl;
+class MojoAppConnection;
 
 // This is owned by Storage Partition and encapsulates all its dom storage
 // state.
 class CONTENT_EXPORT DOMStorageContextWrapper :
     NON_EXPORTED_BASE(public DOMStorageContext),
     public base::RefCountedThreadSafe<DOMStorageContextWrapper> {
  public:
   // If |data_path| is empty, nothing will be saved to disk.
   DOMStorageContextWrapper(
+      uint32_t mojo_user_id,
       const base::FilePath& data_path,
       storage::SpecialStoragePolicy* special_storage_policy);
 
   // DOMStorageContext implementation.
   void GetLocalStorageUsage(
       const GetLocalStorageUsageCallback& callback) override;
   void GetSessionStorageUsage(
       const GetSessionStorageUsageCallback& callback) override;
   void DeleteLocalStorage(const GURL& origin) override;
   void DeleteSessionStorage(const SessionStorageUsageInfo& usage_info) override;
@@ skipping 21 matching lines @@
  private:
   friend class DOMStorageMessageFilter;  // for access to context()
   friend class SessionStorageNamespaceImpl;  // ditto
   friend class base::RefCountedThreadSafe<DOMStorageContextWrapper>;
 
   ~DOMStorageContextWrapper() override;
   DOMStorageContextImpl* context() const { return context_.get(); }
 
   void LevelDBWrapperImplHasNoBindings(const std::string& origin);
 
+  // Part of our asynchronous directory opening called from OpenLocalStorage().
+  void OnDirectoryOpened(filesystem::FileError err);
+  void OnDatabaseOpened(leveldb::DatabaseError status);
+
+  void OnCrudWritten(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 mojo::String& origin,
+      mojo::InterfaceRequest<LevelDBWrapper> request);
+
   // Used for mojo-based LocalStorage implementation (behind
   // --mojo-local-storage for now). Maps between an origin and its prefixed
   // LevelDB view.
   std::map<std::string, scoped_ptr<LevelDBWrapperImpl>> level_db_wrappers_;
 
+  uint32_t mojo_user_id_;

[michaeln, 2016/03/05 01:38:54]

I'd prefer to factor the new mojo based impl out into a separate class (an inner
class would be fine or a class declared in an anon namespace in the .cc) rather
than co-mingle old/new code in the same class. This class can own an instance of
the new object and when Shutdown() is called, delete it. Shutdown() is called on
the ui thread so that would help with our thread affinity.

Eventually the new code will subsume the old code, but we have a ways to go
before can do that.

[Elliot Glaysher, 2016/03/10 21:00:35]

Moved all implementation details into their own inner class.

   scoped_refptr<DOMStorageContextImpl> context_;
 
+  enum ConnectionState {
+    NO_CONNECTION,
+    CONNECITON_IN_PROGRESS,
+    CONNECTED
+  } connection_state_;
+
+  scoped_ptr<MojoAppConnection> profile_connection_;
+  profile::ProfileServicePtr profile_service_;
+  filesystem::DirectoryPtr directory_;
+
+  scoped_ptr<MojoAppConnection> leveldb_connection_;
+  leveldb::LevelDBServicePtr leveldb_;
+  leveldb::LevelDBDatabasePtr database_;

[michaeln, 2016/03/05 01:38:54]

Since we only need leveldb_connection_ and database_ for the lifetime of the
object and the others are only transiently needed during the connection
sequence, it might be nice to not store the transients as direct datamembers.

[Elliot Glaysher, 2016/03/10 21:00:35]

I previously tried to do this, and had problems. Tried again now and it looks
like I conflated this with the other threading problems. Done.

+
+  std::vector<base::Closure> on_database_opened_callbacks_;
+
+  base::WeakPtrFactory<DOMStorageContextWrapper> weak_ptr_factory_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(DOMStorageContextWrapper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOM_STORAGE_DOM_STORAGE_CONTEXT_WRAPPER_H_