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 "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(
       const base::FilePath& data_path,
@@ skipping 29 matching lines @@
       mojo::InterfaceRequest<LevelDBWrapper> request);
 
  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);

[michaeln, 2016/02/26 21:59:25]

+1 the OnFooHappened naming, i'd vote to rename this to match and to put it at
the end of the method list, at least after all the open related things since
closing happens after opening. OnAllBindingsClosed()?

 
+  // 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 mojo::String& origin,
+      LevelDBObserverPtr observer,
+      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_;
 
   scoped_refptr<DOMStorageContextImpl> context_;
 
+  enum ConnectionState {
+    NO_CONNECTION,
+    CONNECITON_IN_PROGRESS,
+    CONNECTED
+  } connection_state_;
+
+  scoped_ptr<MojoAppConnection> file_system_connection_;
+  filesystem::FileSystemPtr file_system_;
+  filesystem::DirectoryPtr directory_;

[michaeln, 2016/02/26 21:59:25]

Do we need to retain all of these things for the life of the object? How are
these related and what implications does deleting one that spawned another have?

I guess these FooPtr types are 'smart' scopers of some kind?

[Elliot Glaysher, 2016/03/02 23:06:20]

So we want to keep |file_system_| (now profile_system_) and |directory_| alive
while we're asking for a directory, and then |directory_| gets nulled when we
pass ownership to leveldb. I just added code to tear these down once we have
|database_|.

We do need to keep the |leveldb_connection_| alive for the lifetime of this
object though.
Yes.

+
+  scoped_ptr<MojoAppConnection> leveldb_connection_;
+  leveldb::LevelDBServicePtr leveldb_;
+  leveldb::LevelDBDatabasePtr database_;

[michaeln, 2016/02/26 21:59:25]

Do mojo things have thread affinity with regard to destruction? I don't think
this class makes any promises about which thread its dtor'd on.

[Elliot Glaysher, 2016/03/02 23:06:20]

They have strong affinity for the thread they were created on.

(Could this explain the current crashing on trunk? crbug.com/590345. That stack
trace mutates quite a bit with this patch so I might be introducing a different
shutdown bug here, but...) 

+
+  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_