Run the DOMStorageBrowserTest.SanityCheck against the mojo based implementation.

content/browser/leveldb_wrapper_impl.cc

 // Copyright 2016 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/leveldb_wrapper_impl.h"
 
 #include "base/bind.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/common/common_type_converters.h"
@@ skipping 70 matching lines @@
 
 void LevelDBWrapperImpl::EnableAggressiveCommitDelay() {
   s_aggressive_flushing_enabled_ = true;
 }
 
 void LevelDBWrapperImpl::Put(mojo::Array<uint8_t> key,
                              mojo::Array<uint8_t> value,
                              const mojo::String& source,
                              const PutCallback& callback) {
   if (!map_) {
-    on_load_complete_tasks_.push_back(
+    LoadMap(
         base::Bind(&LevelDBWrapperImpl::Put, base::Unretained(this),
                    base::Passed(&key), base::Passed(&value), source, callback));
-    LoadMap();
     return;
   }
 
   bool has_old_item = false;
   mojo::Array<uint8_t> old_value;
   size_t old_item_size = 0;
   auto found = map_->find(key);
   if (found != map_->end()) {
     if (found->second.Equals(value)) {
       callback.Run(true);  // Key already has this value.
@@ skipping 34 matching lines @@
               key.Clone(), value.Clone(), old_value.Clone(), source);
         });
   }
   callback.Run(true);
 }
 
 void LevelDBWrapperImpl::Delete(mojo::Array<uint8_t> key,
                                 const mojo::String& source,
                                 const DeleteCallback& callback) {
   if (!map_) {
-    on_load_complete_tasks_.push_back(
+    LoadMap(
         base::Bind(&LevelDBWrapperImpl::Delete, base::Unretained(this),
                    base::Passed(&key), source, callback));
-    LoadMap();
     return;
   }
 
   auto found = map_->find(key);
   if (found == map_->end()) {
     callback.Run(true);
     return;
   }
 
   if (database_) {
     CreateCommitBatchIfNeeded();
     commit_batch_->changed_values[key.Clone()] = mojo::Array<uint8_t>(nullptr);
   }
 
   mojo::Array<uint8_t> old_value = std::move(found->second);
   map_->erase(found);
   bytes_used_ -= key.size() + old_value.size();
   observers_.ForAllPtrs(
       [&key, &source, &old_value](mojom::LevelDBObserver* observer) {
         observer->KeyDeleted(
             key.Clone(), old_value.Clone(), source);
       });
   callback.Run(true);
 }
 
 void LevelDBWrapperImpl::DeleteAll(const mojo::String& source,
                                    const DeleteAllCallback& callback) {
   if (!map_) {
-    on_load_complete_tasks_.push_back(
+    LoadMap(
         base::Bind(&LevelDBWrapperImpl::DeleteAll, base::Unretained(this),
                     source, callback));
-    LoadMap();
     return;
   }
 
   if (database_ && !map_->empty()) {
     CreateCommitBatchIfNeeded();
     commit_batch_->clear_all_first = true;
     commit_batch_->changed_values.clear();
   }
   map_->clear();
   bytes_used_ = 0;
   observers_.ForAllPtrs(
       [&source](mojom::LevelDBObserver* observer) {
         observer->AllDeleted(source);
       });
   callback.Run(true);
 }
 
 void LevelDBWrapperImpl::Get(mojo::Array<uint8_t> key,
                              const GetCallback& callback) {
   if (!map_) {
-    on_load_complete_tasks_.push_back(
+    LoadMap(
         base::Bind(&LevelDBWrapperImpl::Get, base::Unretained(this),
                    base::Passed(&key), callback));
-    LoadMap();
     return;
   }
 
   auto found = map_->find(key);
   if (found == map_->end()) {
     callback.Run(false, mojo::Array<uint8_t>());
     return;
   }
   callback.Run(true, found->second.Clone());
 }
 
 void LevelDBWrapperImpl::GetAll(const mojo::String& source,
                                 const GetAllCallback& callback) {
   if (!map_) {
-    on_load_complete_tasks_.push_back(
+    LoadMap(
         base::Bind(&LevelDBWrapperImpl::GetAll, base::Unretained(this),
                    source, callback));
-    LoadMap();
     return;
   }
 
   mojo::Array<mojom::KeyValuePtr> all(map_->size());
   for (const auto& it : (*map_)) {
     mojom::KeyValuePtr kv = mojom::KeyValue::New();
     kv->key = it.first.Clone();
     kv->value = it.second.Clone();
     all.push_back(std::move(kv));
   }
   callback.Run(leveldb::DatabaseError::OK, std::move(all));
   observers_.ForAllPtrs(
       [source](mojom::LevelDBObserver* observer) {
         observer->GetAllComplete(source);
       });
 }
 
 void LevelDBWrapperImpl::OnConnectionError() {
   if (!bindings_.empty())
     return;
   no_bindings_callback_.Run();
 }
 
-void LevelDBWrapperImpl::LoadMap() {
+void LevelDBWrapperImpl::LoadMap(const base::Closure& completion_callback) {
+  DCHECK(!map_);
+  on_load_complete_tasks_.push_back(completion_callback);
+  if (on_load_complete_tasks_.size() > 1)
+    return;
+
   // TODO(michaeln): Import from sqlite localstorage db.
-  DCHECK(!map_);
   database_->GetPrefixed(mojo::Array<uint8_t>::From(prefix_),
                          base::Bind(&LevelDBWrapperImpl::OnLoadComplete,
                                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void LevelDBWrapperImpl::OnLoadComplete(
     leveldb::DatabaseError status,
     mojo::Array<leveldb::KeyValuePtr> data) {
   DCHECK(!map_);
   map_.reset(new ValueMap);
@@ skipping 90 matching lines @@
                               weak_ptr_factory_.GetWeakPtr()));
 }
 
 void LevelDBWrapperImpl::OnCommitComplete(leveldb::DatabaseError error) {
   // TODO(michaeln): What if it fails, uma here or in the DB class?
   --commit_batches_in_flight_;
   StartCommitTimer();
 }
 
 }  // namespace content