Some fleshing out the mojo based localstorage 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 "mojo/common/common_type_converters.h"
 
 namespace content {
 
 LevelDBWrapperImpl::LevelDBWrapperImpl(
     leveldb::LevelDBDatabase* database,
     const std::string& prefix,
+    size_t max_size,
     const base::Closure& no_bindings_callback)
     : prefix_(prefix),
       no_bindings_callback_(no_bindings_callback),
-      database_(database) {
+      database_(database),
+      bytes_used_(0),
+      max_size_(max_size) {
   bindings_.set_connection_error_handler(base::Bind(
       &LevelDBWrapperImpl::OnConnectionError, base::Unretained(this)));
 }
 
 void LevelDBWrapperImpl::Bind(LevelDBWrapperRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 LevelDBWrapperImpl::~LevelDBWrapperImpl() {}
 
+void LevelDBWrapperImpl::AddObserver(LevelDBObserverPtr observer) {
+  observers_.AddInterfacePtr(std::move(observer));
+}
+
 void LevelDBWrapperImpl::Put(mojo::Array<uint8_t> key,
                              mojo::Array<uint8_t> value,
                              const mojo::String& source,
                              const PutCallback& callback) {
-  NOTIMPLEMENTED();
-  callback.Run(leveldb::DatabaseError::NOT_SUPPORTED);
+  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()) {
+    old_value = std::move(found->second);
+    old_item_size = key.size() + old_value.size();
+    has_old_item = true;
+  }
+  size_t new_item_size = key.size() + value.size();
+  size_t new_bytes_used = bytes_used_ - old_item_size + new_item_size;
+
+  // Only check quota if the size is increasing, this allows
+  // shrinking changes to pre-existing maps that are over budget.
+  if (new_item_size > old_item_size && new_bytes_used > max_size_) {
+    callback.Run(false);
+    return;
+  }
+
+  map_[key.Clone()] = value.Clone();
+  bytes_used_ = new_bytes_used;
+  if (!has_old_item) {
+    // We added a new key/value pair.
+    observers_.ForAllPtrs(
+        [&key, &value, &source](LevelDBObserver* observer) {
+          observer->KeyAdded(key.Clone(), value.Clone(), source);

[michaeln, 2016/03/29 22:20:46]

like we've talked about, the repeated cloning is not so great

+        });
+  } else {
+    // We changed the value for an existing key.
+    observers_.ForAllPtrs(
+        [&key, &value, &source, &old_value](LevelDBObserver* observer) {
+          observer->KeyChanged(
+              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) {
-  NOTIMPLEMENTED();
-  callback.Run(leveldb::DatabaseError::NOT_SUPPORTED);
+  auto found = map_.find(key);
+  if (found == map_.end()) {
+    callback.Run(true);
+    return;
+  }
+
+  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](LevelDBObserver* observer) {
+        observer->KeyDeleted(
+            key.Clone(),  old_value.Clone(), source);
+      });
+  callback.Run(true);
 }
 
-void LevelDBWrapperImpl::DeleteAll(LevelDBObserverPtr observer,
-                                   const mojo::String& source,
+void LevelDBWrapperImpl::DeleteAll(const mojo::String& source,
                                    const DeleteAllCallback& callback) {
-  // TODO(jam): store observer and call it when changes occur.
-  NOTIMPLEMENTED();
-  callback.Run(leveldb::DatabaseError::NOT_SUPPORTED);
+  map_.clear();
+  bytes_used_ = 0;
+  observers_.ForAllPtrs(
+      [&source](LevelDBObserver* observer) {
+        observer->AllDeleted(source);
+      });
+  callback.Run(true);
 }
 
-void LevelDBWrapperImpl::Get(mojo::Array<uint8_t> key,

[michaeln, 2016/03/29 22:20:46]

we don't have a use for this method in the localstorage impl, so i've taken this
out for now at least

[jam, 2016/03/30 17:15:16]

it doesn't harm to keep it there, so let's not remove it. leveldbwrapper is
supposed to be a reusable wrapper around leveldb, and this is a core method of
leveldb's APIs

[michaeln, 2016/03/30 21:57:01]

Done.

The comment about general purpose'ness is a good point.

I feel like the in memory map based impl in this cl limits the general
purpose'ness somewhat. It puts practical datasize constraints on its use. That's
not a problem with localstorage, but it could be overly constraining for other
applications.

I guess we can retain more general purposes'ness behind the same api.

If max_size is <size_t>::max() and the observer is null, the wrapper can
function as more of a straight passthru with no change-eventing or
size-constraining. Without the need to raise events, we don't need to provide
the old values when changing or removing them. And without the need for size
constraints, we don't need to know how much is in there. It could still provide
a write buffer and some amount of read buffering.

Some impl details to deal with in a later cl.

-                             const GetCallback& callback) {
-  NOTIMPLEMENTED();
-  callback.Run(leveldb::DatabaseError::NOT_SUPPORTED, mojo::Array<uint8_t>());
-}
+void LevelDBWrapperImpl::GetAll(uint64_t request_id,
+                                const GetAllCallback& callback) {
 
-void LevelDBWrapperImpl::GetAll(LevelDBObserverPtr observer,
-                                const GetAllCallback& callback) {
-  // TODO(jam): store observer and call it when changes occur.
-  NOTIMPLEMENTED();
-  callback.Run(leveldb::DatabaseError::NOT_SUPPORTED,
-               mojo::Array<KeyValuePtr>());
+  mojo::Array<KeyValuePtr> all(map_.size());
+  for (const auto& it : map_) {
+    KeyValuePtr kv = 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(
+      [request_id](LevelDBObserver* observer) {
+        observer->GetAllComplete(request_id);
+      });
 }
 
 void LevelDBWrapperImpl::OnConnectionError() {
   if (!bindings_.empty())
     return;
 
   no_bindings_callback_.Run();
 }
 
 }  // namespace content