Framing for a DOMStorage backend that does not depend on in-process-webkit.

webkit/dom_storage/dom_storage_area.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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_BROWSER_IN_PROCESS_WEBKIT_DOM_STORAGE_AREA_H_
-#define CONTENT_BROWSER_IN_PROCESS_WEBKIT_DOM_STORAGE_AREA_H_
+#ifndef WEBKIT_DOM_STORAGE_DOM_STORAGE_AREA_H_
+#define WEBKIT_DOM_STORAGE_DOM_STORAGE_AREA_H_
 #pragma once
 
-#include "base/hash_tables.h"
+#include "base/file_path.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/nullable_string16.h"
 #include "base/string16.h"
-#include "content/common/dom_storage_common.h"
 #include "googleurl/src/gurl.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageArea.h"
+#include "webkit/dom_storage/dom_storage_task_runner.h"
 
-class DOMStorageNamespace;
-// Only use on the WebKit thread.  DOMStorageNamespace manages our registration
-// with DOMStorageContext.
-class DOMStorageArea {
+class FilePath;
+class GURL;
+
+namespace dom_storage {
+
+class DomStorageMap;
+
+// Not thread-safe, should only be called on the
+// background thread.

[benm (inactive), 2012/02/02 16:23:19]

Can you add comments to these classes like those you made in your last message
regarding who owns what?

[michaeln, 2012/02/03 00:33:42]

Done, added class with an overview on DomStorageContext.

+class DomStorageArea
+    : public base::RefCountedThreadSafe<DomStorageArea> {
+
  public:
-  DOMStorageArea(const string16& origin,
-                 int64 id,
-                 DOMStorageNamespace* owner);
-  ~DOMStorageArea();
+  DomStorageArea(int64 namespace_id,
+                 const GURL& origin,
+                 const FilePath& backing_file,
+                 DomStorageTaskRunner* task_runner);
+
+  const GURL& origin() const { return origin_; }
+  const int64 namespace_id() const { return namespace_id_; }
 
   unsigned Length();
   NullableString16 Key(unsigned index);
   NullableString16 GetItem(const string16& key);
-  NullableString16 SetItem(
-      const string16& key, const string16& value,
-      WebKit::WebStorageArea::Result* result);
-  NullableString16 RemoveItem(const string16& key);
+  bool SetItem(const string16& key, const string16& value,
+               NullableString16* old_value);
+  bool RemoveItem(const string16& key, string16* old_value);
   bool Clear();
-  void PurgeMemory();
 
-  int64 id() const { return id_; }
-
-  DOMStorageNamespace* owner() const { return owner_; }
+  DomStorageArea* ShallowCopy(int64 destination_namespace_id);
 
  private:
-  // Creates the underlying WebStorageArea on demand.
-  void CreateWebStorageAreaIfNecessary();
+  friend class base::RefCountedThreadSafe<DomStorageArea>;
 
-  // The origin this storage area represents.
-  string16 origin_;
-  GURL origin_url_;
+  ~DomStorageArea();
 
-  // The storage area we wrap.
-  scoped_ptr<WebKit::WebStorageArea> storage_area_;
-
-  // Our storage area id.  Unique to our parent WebKitContext.
-  int64 id_;
-
-  // The DOMStorageNamespace that owns us.
-  DOMStorageNamespace* owner_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(DOMStorageArea);
+  int64 namespace_id_;
+  GURL origin_;
+  FilePath backing_file_;
+  scoped_refptr<DomStorageTaskRunner> task_runner_;
+  scoped_refptr<DomStorageMap> map_;

[benm (inactive), 2012/02/02 16:23:19]

We're still planning on having a changed_values_ DomStorageMap here, right?

[michaeln, 2012/02/03 00:33:42]

yes, but i think just need strictly owned ValuesMap data member to keep track of
the changed_values_ in the area instead of the refcounted StorageMap obj

i've been staying away from coding logic to integrate these classes with
DomStorageDatabase (to keep the CL smaller)

+  // TODO(michaeln): make it so this class can persist stuff to disk

[benm (inactive), 2012/02/02 16:23:19]

Should just need a DomStorageDatabase instance and a way to get at the
underlying std::map in DomStorageMap.

[michaeln, 2012/02/03 00:33:42]

Right... i think a DomStorageMap.SwapValues(ValuesMap* map) could work?

 };
 
-#if defined(COMPILER_GCC)
-namespace __gnu_cxx {
+}  // namespace dom_storage
 
-template<>
-struct hash<DOMStorageArea*> {
-  std::size_t operator()(DOMStorageArea* const& p) const {
-    return reinterpret_cast<std::size_t>(p);
-  }
-};
-
-}  // namespace __gnu_cxx
-#endif
-
-#endif  // CONTENT_BROWSER_IN_PROCESS_WEBKIT_DOM_STORAGE_AREA_H_
+#endif  // WEBKIT_DOM_STORAGE_DOM_STORAGE_AREA_H_