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

webkit/dom_storage/dom_storage_context.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_CONTEXT_H_
-#define CONTENT_BROWSER_IN_PROCESS_WEBKIT_DOM_STORAGE_CONTEXT_H_
+#ifndef WEBKIT_DOM_STORAGE_DOM_STORAGE_CONTEXT_H_
+#define WEBKIT_DOM_STORAGE_DOM_STORAGE_CONTEXT_H_
 #pragma once
 
 #include <map>
-#include <set>
 
+#include "base/atomic_sequence_num.h"
+#include "base/basictypes.h"
 #include "base/file_path.h"
-#include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/string16.h"
-#include "base/time.h"
-#include "content/common/content_export.h"
+#include "base/observer_list.h"
 
-class DOMStorageArea;
-class DOMStorageMessageFilter;
-class DOMStorageNamespace;
-class WebKitContext;
+class FilePath;
+class GURL;
+class NullableString16;
+
+namespace base {
+class Time;
+}
 
 namespace quota {
 class SpecialStoragePolicy;
 }
 
-// This is owned by WebKitContext and is all the dom storage information that's
-// shared by all the DOMStorageMessageFilters that share the same browser
-// context.  The specifics of responsibilities are fairly well documented here
-// and in StorageNamespace and StorageArea.  Everything is only to be accessed
-// on the WebKit thread unless noted otherwise.
-//
-// NOTE: Virtual methods facilitate mocking functions for testing.
-class CONTENT_EXPORT DOMStorageContext {
+namespace dom_storage {
+
+class DomStorageArea;
+class DomStorageNamespace;
+class DomStorageSession;
+class DomStorageTaskRunner;
+
+// One instance is allocated in the main process for each profile,
+// should be called only on the background thread.
+class DomStorageContext
+    : public base::RefCountedThreadSafe<DomStorageContext> {
  public:
-  DOMStorageContext(WebKitContext* webkit_context,
-                    quota::SpecialStoragePolicy* special_storage_policy);
-  virtual ~DOMStorageContext();
 
-  // Invalid storage id.  No storage session will ever report this value.
-  // Used in DOMStorageMessageFilter::OnStorageAreaId when coping with
-  // interactions with non-existent storage sessions.
-  static const int64 kInvalidStorageId = -1;
+  // An interface for observing LocalStorage events. Mutation events

[benm (inactive), 2012/01/31 18:03:38]

s/LocalStorage/DomStorage/

[michaeln, 2012/01/31 21:17:45]

Renderer's raise events associated with changes that originate within its
process w/o routing the event thru the browser process. Since sessionstorage is
only accessed from a single renderer, there's no need to invoke this interface
for it.

As coded in the CL in this snapshot it will get invoked for both types, but i'll
snip that so we only do this for localstorage.

+  // are raised on the background thread.
+  class EventObserver {
+   public:
+    virtual void OnDomStorageItemSet(
+        DomStorageArea* area,
+        const string16& key,
+        const string16& new_value,
+        const NullableString16& old_value,  // may be null on initial insert
+        const GURL& page_url) = 0;
+    virtual void OnDomStorageItemRemoved(
+        DomStorageArea* area,
+        const string16& key,
+        const string16& old_value,
+        const GURL& page_url) = 0;
+    virtual void OnDomStorageAreaCleared(
+        DomStorageArea* area,
+        const GURL& page_url) = 0;
 
-  // Allocate a new storage area id.  Only call on the WebKit thread.
-  int64 AllocateStorageAreaId();
+    virtual ~EventObserver() {}
+  };
 
-  // Allocate a new session storage id.  Only call on the UI or IO thread.
-  int64 AllocateSessionStorageNamespaceId();
+  DomStorageContext(const FilePath& directory,  // empty for incognito profiles
+                    quota::SpecialStoragePolicy* special_storage_policy,
+                    DomStorageTaskRunner* task_runner);
 
-  // Clones a session storage namespace and returns the cloned namespaces' id.
-  // Only call on the IO thread.
-  int64 CloneSessionStorage(int64 original_id);
+  // Methods to add, remove, and notify EventObservers.
+  void AddEventObserver(EventObserver* observer);
+  void RemoveEventObserver(EventObserver* observer);
+  void NotifyItemSet(
+        DomStorageArea* area,
+        const string16& key,
+        const string16& new_value,
+        const NullableString16& old_value,
+        const GURL& page_url);
+  void NotifyItemRemoved(
+        DomStorageArea* area,
+        const string16& key,
+        const string16& old_value,
+        const GURL& page_url);
+  void NotifyAreaCleared(
+      DomStorageArea* area,
+      const GURL& page_url);
 
-  // Various storage area methods.  The storage area is owned by one of the
-  // namespaces that's owned by this class.
-  void RegisterStorageArea(DOMStorageArea* storage_area);
-  void UnregisterStorageArea(DOMStorageArea* storage_area);
-  DOMStorageArea* GetStorageArea(int64 id);
-
-  // Called on WebKit thread when a session storage namespace can be deleted.
-  void DeleteSessionStorageNamespace(int64 namespace_id);
-
-  // Get a namespace from an id.  What's returned is owned by this class.  If
-  // allocation_allowed is true, then this function will create the storage
-  // namespace if it hasn't been already.
-  DOMStorageNamespace* GetStorageNamespace(int64 id, bool allocation_allowed);
-
-  // Sometimes an event from one DOM storage message filter requires
-  // communication to all of them.
-  typedef std::set<DOMStorageMessageFilter*> MessageFilterSet;
-  void RegisterMessageFilter(DOMStorageMessageFilter* message_filter);
-  void UnregisterMessageFilter(DOMStorageMessageFilter* MessageFilter);
-  const MessageFilterSet* GetMessageFilterSet() const;
+  DomStorageNamespace* GetStorageNamespace(int64 namespace_id);
 
   // Tells storage namespaces to purge any memory they do not need.
-  virtual void PurgeMemory();
+  void PurgeMemory();
 
   // Delete any local storage files that have been touched since the cutoff
   // date that's supplied. Protected origins, per the SpecialStoragePolicy,
   // are not deleted by this method.
   void DeleteDataModifiedSince(const base::Time& cutoff);
 
-  // Deletes a single local storage file.
-  void DeleteLocalStorageFile(const FilePath& file_path);
+  // Delete any local storage files which are allowed to be stored only until
+  // the end of the session. Protected origins, per the SpecialStoragePolicy,
+  // are not deleted by this method.
+  void DeleteSessionOnlyData();
 
   // Deletes the local storage file for the given origin.
-  void DeleteLocalStorageForOrigin(const string16& origin_id);
+  void DeleteLocalStorageForOrigin(const GURL& origin);
 
   // Deletes all local storage files.
   void DeleteAllLocalStorageFiles();
 
-  // The local storage directory.
-  static const FilePath::CharType kLocalStorageDirectory[];
-
-  // The local storage file extension.
-  static const FilePath::CharType kLocalStorageExtension[];
-
-  // Get the file name of the local storage file for the given origin.
-  FilePath GetLocalStorageFilePath(const string16& origin_id) const;
-
   void set_clear_local_state_on_exit_(bool clear_local_state) {
     clear_local_state_on_exit_ = clear_local_state;
   }
 
   // Disables the exit-time deletion for all data (also session-only data).
   void SaveSessionState() {
     save_session_state_ = true;
   }
 
-  void set_data_path_for_testing(const FilePath& data_path) {
-    data_path_ = data_path;
-  }
+ private:
+  friend class DomStorageSession;
+  friend class base::RefCountedThreadSafe<DomStorageContext>;
 
- private:
+  typedef std::map<int64, DomStorageNamespace*> StorageNamespaceMap;
 
-  FRIEND_TEST_ALL_PREFIXES(DOMStorageTest, SessionOnly);
-  FRIEND_TEST_ALL_PREFIXES(DOMStorageTest, SaveSessionState);
+  ~DomStorageContext();
 
-  // Get the local storage instance.  The object is owned by this class.
-  DOMStorageNamespace* CreateLocalStorage();
+  // These three methods may be called on any thread, tasks
+  // are scheduled on the background thread to perform the work.
+  int64 CreateSessionStorageNamespace();
+  void DeleteSessionStorageNamespace(int64 namespace_id);
+  int64 CloneSessionStorageNamespace(int64 existing_id);
 
-  // Get a new session storage namespace.  The object is owned by this class.
-  DOMStorageNamespace* CreateSessionStorage(int64 namespace_id);
+  void CreateSessionStorageNamespaceHelper(int64 new_id);
+  void DeleteSessionStorageNamespaceHelper(int64 namespace_id);
+  void CloneSessionStorageNamespaceHelper(int64 existing_id, int64 new_id);

[benm (inactive), 2012/01/31 18:03:38]

Why do we have these for session storage and not local storage?

[michaeln, 2012/01/31 21:17:45]

LocalStorage has a magic namespace_id of 0 and there is only one localstorage
namespace per-profile (ala DomStorageContext) that lives for the duration (and
persists on disk). It exists implicitly.

SessionStorage namespaces come and go with tabs, each new tab gets a unique
sessionstorage namespace_id, and when the tab closes it gets deleted. (and until
marja's session restore stuff comes along, none of this goes to disk). So these
namespace get explicitly created and destroyed by the embedder indirectly via
the DomStorageSession class.

 
-  // Used internally to register storage namespaces we create.
-  void RegisterStorageNamespace(DOMStorageNamespace* storage_namespace);
+  StorageNamespaceMap namespaces_;
 
-  // The WebKit thread half of CloneSessionStorage above.  Static because
-  // DOMStorageContext isn't ref counted thus we can't use a runnable method.
-  // That said, we know this is safe because this class is destroyed on the
-  // WebKit thread, so there's no way it could be destroyed before this is run.
-  static void CompleteCloningSessionStorage(DOMStorageContext* context,
-                                            int64 existing_id, int64 clone_id);
+  // Where data is stored, maybe empty for the incognito use case.
+  FilePath directory_;
 
-  // The last used storage_area_id and storage_namespace_id's.  For the storage
-  // namespaces, IDs allocated on the UI thread are positive and count up while
-  // IDs allocated on the IO thread are negative and count down.  This allows us
-  // to allocate unique IDs on both without any locking.  All storage area ids
-  // are allocated on the WebKit thread.
-  int64 last_storage_area_id_;
-  int64 last_session_storage_namespace_id_on_ui_thread_;
-  int64 last_session_storage_namespace_id_on_io_thread_;
+  scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
+  scoped_refptr<DomStorageTaskRunner> task_runner_;
 
   // True if the destructor should delete its files.
   bool clear_local_state_on_exit_;
 
   // If true, nothing (not even session-only data) should be deleted on exit.
   bool save_session_state_;
 
-  // Path where the browser context data is stored.
-  // TODO(pastarmovj): Keep in mind that unlike indexed db data_path_ variable
-  // this one still has to point to the upper level dir because of the
-  // MigrateLocalStorageDirectory function. Once this function disappears we can
-  // make it point directly to the dom storage path.
-  FilePath data_path_;
+  // List of objects observing local storage events.
+  ObserverList<EventObserver> event_observers_;
 
-  // All the DOMStorageMessageFilters that are attached to us. ONLY USE ON THE
-  // IO THREAD!
-  MessageFilterSet message_filter_set_;
-
-  // Maps ids to StorageAreas.  We do NOT own these objects.  StorageNamespace
-  // (which does own them) will notify us when we should remove the entries.
-  typedef std::map<int64, DOMStorageArea*> StorageAreaMap;
-  StorageAreaMap storage_area_map_;
-
-  // Maps ids to StorageNamespaces.  We own these objects.
-  typedef std::map<int64, DOMStorageNamespace*> StorageNamespaceMap;
-  StorageNamespaceMap storage_namespace_map_;
-
-  scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(DOMStorageContext);
+  base::AtomicSequenceNumber session_storage_id_sequence_;
 };
 
-#endif  // CONTENT_BROWSER_IN_PROCESS_WEBKIT_DOM_STORAGE_CONTEXT_H_
+}  // namespace dom_storage
+
+#endif  // WEBKIT_DOM_STORAGE_DOM_STORAGE_CONTEXT_H_