Make LevelDBObserver an associated interface to LevelDBWrapper.

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 78 matching lines @@
   MojoState(service_manager::Connector* connector,
             const base::FilePath& subdirectory)
       : connector_(connector),
         // TODO(michaeln): Enable writing to disk when db is versioned,
         // for now using an empty subdirectory to use an in-memory db.
         // subdirectory_(subdirectory),
         connection_state_(NO_CONNECTION),
         weak_ptr_factory_(this) {}
 
   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(service_manager::mojom::ConnectResult::SUCCEEDED,
              file_service_connection_->GetResult());
   }
 
   void OnUserServiceConnectionError() {
     CHECK(false);
   }
 
   // Part of our asynchronous directory opening called from OpenLocalStorage().
   void OnDirectoryOpened(filesystem::mojom::FileError err);
   void OnDatabaseOpened(leveldb::mojom::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);
 
   service_manager::Connector* const connector_;
   const base::FilePath subdirectory_;
 
   enum ConnectionState {
     NO_CONNECTION,
     CONNECTION_IN_PROGRESS,
     CONNECTION_FINISHED
   } connection_state_;
 
   std::unique_ptr<service_manager::Connection> file_service_connection_;
 
   file::mojom::FileSystemPtr file_system_;
   filesystem::mojom::DirectoryPtr directory_;
 
   leveldb::mojom::LevelDBServicePtr leveldb_service_;
   leveldb::mojom::LevelDBDatabasePtr database_;
 
   std::vector<base::Closure> on_database_opened_callbacks_;
 
   // Maps between an origin and its prefixed LevelDB view.
   std::map<url::Origin, std::unique_ptr<LevelDBWrapperImpl>> level_db_wrappers_;
 
   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) {
     CHECK(connector_);
     file_service_connection_ =
         connector_->Connect(file::mojom::kServiceName);
     connection_state_ = CONNECTION_IN_PROGRESS;
     file_service_connection_->AddConnectionCompletedClosure(
         base::Bind(&MojoState::OnUserServiceConnectionComplete,
                    weak_ptr_factory_.GetWeakPtr()));
@@ skipping 15 matching lines @@
       leveldb_service_->OpenInMemory(
           MakeRequest(&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(&observer), base::Passed(&request)));
+                   origin, base::Passed(&request)));
     return;
   }
 
-  BindLocalStorage(origin, std::move(observer), std::move(request));
+  BindLocalStorage(origin, std::move(request));
 }
 
 void DOMStorageContextWrapper::MojoState::OnDirectoryOpened(
     filesystem::mojom::FileError err) {
   if (err != filesystem::mojom::FileError::OK) {
     // We failed to open the directory; continue with startup so that we create
     // the |level_db_wrappers_|.
     OnDatabaseOpened(leveldb::mojom::DatabaseError::IO_ERROR);
     return;
   }
@@ skipping 24 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) {
   // Delay for a moment after a value is set in anticipation
   // of other values being set, so changes are batched.
   const int kCommitDefaultDelaySecs = 5;
 
   // To avoid excessive IO we apply limits to the amount of data being written
   // and the frequency of writes.
   const int kMaxBytesPerHour = kPerStorageAreaQuota;
   const int kMaxCommitsPerHour = 60;
 
   auto found = level_db_wrappers_.find(origin);
   if (found == level_db_wrappers_.end()) {
     level_db_wrappers_[origin] = base::MakeUnique<LevelDBWrapperImpl>(
         database_.get(), origin.Serialize(),
         kPerStorageAreaQuota + kPerStorageAreaOverQuotaAllowance,
         base::TimeDelta::FromSeconds(kCommitDefaultDelaySecs), kMaxBytesPerHour,
         kMaxCommitsPerHour,
         base::Bind(&MojoState::OnLevelDDWrapperHasNoBindings,
                    base::Unretained(this), origin));
     found = level_db_wrappers_.find(origin);
   }
 
   found->second->Bind(std::move(request));
-  found->second->AddObserver(std::move(observer));
 }
 
 DOMStorageContextWrapper::DOMStorageContextWrapper(
     service_manager::Connector* connector,
     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 140 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(observer), std::move(request));
+  mojo_state_->OpenLocalStorage(origin, std::move(request));
 }
 
 void DOMStorageContextWrapper::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   DOMStorageContextImpl::PurgeOption purge_option =
       DOMStorageContextImpl::PURGE_UNOPENED;
   if (memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
     purge_option = DOMStorageContextImpl::PURGE_AGGRESSIVE;
   }
@@ skipping 23 matching lines @@
 }
 
 void DOMStorageContextWrapper::PurgeMemory(DOMStorageContextImpl::PurgeOption
     purge_option) {
   context_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&DOMStorageContextImpl::PurgeMemory, context_, purge_option));
 }
 
 }  // namespace content