Some fleshing out the mojo based localstorage 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 66 matching lines @@
 // for now).
 class DOMStorageContextWrapper::MojoState {
  public:
   MojoState(const std::string& mojo_user_id, const base::FilePath& subdirectory)
       : mojo_user_id_(mojo_user_id),
         subdirectory_(subdirectory),
         connection_state_(NO_CONNECTION),
         weak_ptr_factory_(this) {}
 
   void OpenLocalStorage(const url::Origin& origin,
+                        mojom::LevelDBObserverPtr observer,
                         mojom::LevelDBWrapperRequest request);
 
  private:
-  void LevelDBWrapperImplHasNoBindings(const url::Origin& origin) {
+  void OnLevelDDWrapperHasNoBindings(const url::Origin& origin) {
     DCHECK(level_db_wrappers_.find(origin) != level_db_wrappers_.end());
     level_db_wrappers_.erase(origin);
   }
 
   // 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);
 
   // Maps between an origin and its prefixed LevelDB view.
   std::map<url::Origin, scoped_ptr<LevelDBWrapperImpl>> level_db_wrappers_;
 
   std::string mojo_user_id_;
   base::FilePath subdirectory_;
 
   enum ConnectionState {
     NO_CONNECTION,
     CONNECTION_IN_PROGRESS,
     CONNECTION_FINISHED
   } connection_state_;
 
   scoped_ptr<MojoAppConnection> profile_app_connection_;
   profile::ProfileServicePtr profile_service_;
   filesystem::DirectoryPtr directory_;
 
   leveldb::LevelDBServicePtr leveldb_service_;
   leveldb::LevelDBDatabasePtr database_;
 
   std::vector<base::Closure> on_database_opened_callbacks_;
 
   base::WeakPtrFactory<MojoState> weak_ptr_factory_;
 };
 
 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) {
     profile_app_connection_ = MojoAppConnection::Create(
         mojo_user_id_, "mojo:profile", kBrowserMojoAppUrl);
 
     connection_state_ = CONNECTION_IN_PROGRESS;
 
     if (!subdirectory_.empty()) {
       // We were given a subdirectory to write to. Get it and use a disk backed
@@ skipping 11 matching lines @@
           GetProxy(&database_),
           base::Bind(&MojoState::OnDatabaseOpened,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
   if (connection_state_ == CONNECTION_IN_PROGRESS) {
     // Queue this OpenLocalStorage call for when we have a level db pointer.
     on_database_opened_callbacks_.push_back(
         base::Bind(&MojoState::BindLocalStorage, weak_ptr_factory_.GetWeakPtr(),
-                   origin, base::Passed(&request)));
+                   origin, base::Passed(&observer), base::Passed(&request)));
     return;
   }
 
-  BindLocalStorage(origin, std::move(request));
+  BindLocalStorage(origin, std::move(observer), std::move(request));
 }
 
 void DOMStorageContextWrapper::MojoState::OnDirectoryOpened(
     filesystem::FileError err) {
   if (err != filesystem::FileError::OK) {
     // We failed to open the directory; continue with startup so that we create
     // the |level_db_wrappers_|.
     OnDatabaseOpened(leveldb::DatabaseError::IO_ERROR);
     return;
   }
@@ skipping 25 matching lines @@
   // |leveldb_| should be known to either be valid or invalid by now. Run our
   // delayed bindings.
   connection_state_ = CONNECTION_FINISHED;
   for (size_t i = 0; i < on_database_opened_callbacks_.size(); ++i)
     on_database_opened_callbacks_[i].Run();
   on_database_opened_callbacks_.clear();
 }
 
 void DOMStorageContextWrapper::MojoState::BindLocalStorage(
     const url::Origin& origin,
+    mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
-  if (level_db_wrappers_.find(origin) == level_db_wrappers_.end()) {
+  auto found = level_db_wrappers_.find(origin);
+  if (found == level_db_wrappers_.end()) {
     level_db_wrappers_[origin] = make_scoped_ptr(new LevelDBWrapperImpl(
         database_.get(),
         origin.Serialize(),
-        base::Bind(&MojoState::LevelDBWrapperImplHasNoBindings,
+        kPerStorageAreaQuota + kPerStorageAreaOverQuotaAllowance,
+        base::Bind(&MojoState::OnLevelDDWrapperHasNoBindings,
                    base::Unretained(this),
                    origin)));
+    found = level_db_wrappers_.find(origin);
   }
 
-  level_db_wrappers_[origin]->Bind(std::move(request));
+  found->second->Bind(std::move(request));
+  found->second->AddObserver(std::move(observer));
 }
 
 DOMStorageContextWrapper::DOMStorageContextWrapper(
     const std::string& mojo_user_id,
     const base::FilePath& profile_path,
     const base::FilePath& local_partition_path,
     storage::SpecialStoragePolicy* special_storage_policy) {
   base::FilePath storage_dir;
   if (!profile_path.empty())
     storage_dir = local_partition_path.AppendASCII(kLocalStorageDirectory);
@@ skipping 97 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 url::Origin& origin,
+    mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
-  mojo_state_->OpenLocalStorage(origin, std::move(request));
+  mojo_state_->OpenLocalStorage(
+      origin, std::move(observer), std::move(request));
 }
 
 }  // namespace content