Switch LevelDBWrapper::GetAll to use the new Mojo sync IPC mechanism.

content/renderer/dom_storage/local_storage_area.h

 // 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.
 
 #ifndef CONTENT_RENDERER_DOM_STORAGE_LOCAL_STORAGE_AREA_H_
 #define CONTENT_RENDERER_DOM_STORAGE_LOCAL_STORAGE_AREA_H_
 
 #include "base/macros.h"
 #include "content/common/leveldb_wrapper.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "third_party/WebKit/public/platform/WebStorageArea.h"
 #include "url/origin.h"
 
 namespace content {
 class StoragePartitionService;
 
 // Maintains a complete cache of the origin's Map of key/value pairs for fast
 // access. The cache is primed on first access and changes are written to the
 // backend through the level db interface pointer. Mutations originating in
 // other processes are applied to the cache via the ApplyMutation method.
 class LocalStorageArea : public blink::WebStorageArea,

[michaeln, 2016/02/26 22:21:44]

The [Sycn] attribute looks good, i'm not sure of the code to use it just yet. 

In the current system there are two classes
- WebStorageAreaImpl
- DOMStorageCachedArea
There may be many instances of WebStorageAreaImpl for a origin but only one
instance of a DOMStorageCachedArea. The cached area is a refcounted object
shared by the areaimpls for the origin. That object maintains the cache.

In the new system, I think we want to retain that kind of split where multiple
WebStorageAreas utilize the same cache. As coded this class is starting to look
like a merger of the two.

[jam, 2016/02/29 23:47:47]

ah, I missed that there are multiple blink::WebStorageArea implementations in
content/renderer for the same origin. For some reason I thought this was handled
in Blink (I also missed CachedAreaHolder). Thanks for bringing this up, redone.

                          public LevelDBObserver {
  public:
   LocalStorageArea(const url::Origin& origin,
                    StoragePartitionService* storage_partition_service);
   ~LocalStorageArea() override;
 
   // blink::WebStorageArea.h:
   unsigned length() override;
   blink::WebString key(unsigned index) override;
   blink::WebString getItem(const blink::WebString& key) override;
   void setItem(const blink::WebString& key,
                const blink::WebString& value,
                const blink::WebURL& page_url,
                WebStorageArea::Result& result) override;
   void removeItem(const blink::WebString& key,
                   const blink::WebURL& page_url) override;
   void clear(const blink::WebURL& url) override;
   size_t memoryBytesUsedByCache() const override;
 
   // LevelDBObserver:
   void KeyChanged(mojo::Array<uint8_t> key,
                   mojo::Array<uint8_t> new_value,
                   mojo::Array<uint8_t> old_value,
                   const mojo::String& source) override;
   void KeyDeleted(mojo::Array<uint8_t> key,
                   const mojo::String& source) override;
   void AllDeleted(const mojo::String& source) override;
 
  private:
+  // Synchronously fetches the origin's local storage data if it hasn't been
+  // fetched already.
+  void EnsureLoaded();
+
+  bool loaded_;
   url::Origin origin_;
   LevelDBWrapperPtr leveldb_;
   mojo::Binding<LevelDBObserver> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalStorageArea);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_DOM_STORAGE_LOCAL_STORAGE_AREA_H_