DOMStorageContextImpl that's implemented in terms of the new dom_storage classes.

webkit/dom_storage/dom_storage_context.h

 // 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 WEBKIT_DOM_STORAGE_DOM_STORAGE_CONTEXT_H_
 #define WEBKIT_DOM_STORAGE_DOM_STORAGE_CONTEXT_H_
 #pragma once
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
+#include "googleurl/src/gurl.h"
 
 class FilePath;
-class GURL;
 class NullableString16;
 
 namespace base {
 class Time;
 }
 
 namespace quota {
 class SpecialStoragePolicy;
 }
 
@@ skipping 19 matching lines @@
 // Session Namespaces are cloned by initially making a shallow copy of
 // all contained Areas, the shallow copies refer to the same refcounted Map,
 // and does a deep copy-on-write if needed.
 //
 // Classes intended to be used by an embedder are DomStorageContext,
 // DomStorageHost, and DomStorageSession. The other classes are for
 // internal consumption.
 class DomStorageContext
     : public base::RefCountedThreadSafe<DomStorageContext> {
  public:
+  struct UsageInfo {
+    GURL origin;
+    size_t data_size;
+    base::Time last_modified;
+  };
+
   // An interface for observing LocalStorage events on the
   // background thread.
   class EventObserver {
    public:
     virtual void OnDomStorageItemSet(
         const 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(
         const DomStorageArea* area,
         const string16& key,
         const string16& old_value,
         const GURL& page_url) = 0;
     virtual void OnDomStorageAreaCleared(
         const DomStorageArea* area,
         const GURL& page_url) = 0;
     virtual ~EventObserver() {}
   };
 
   DomStorageContext(const FilePath& directory,  // empty for incognito profiles
                     quota::SpecialStoragePolicy* special_storage_policy,
                     DomStorageTaskRunner* task_runner);
+  const FilePath& directory() const { return directory_; }
   DomStorageTaskRunner* task_runner() const { return task_runner_; }
   DomStorageNamespace* GetStorageNamespace(int64 namespace_id);
 
+  void GetUsageInfo(std::vector<UsageInfo>* info);
+  void DeleteOrigin(const GURL& origin);;
+  void DeleteDataModifiedSince(const base::Time& cutoff);
+  void PurgeMemory();
+
+  // Used by content settings to alter the behavior around
+  // what data to keep and what data to discard at shutdown.
+  // The policy is not so straight forward to describe, see
+  // the implementation for details.
+  void SetClearLocalState(bool clear_local_state) {
+    clear_local_state_ = clear_local_state;
+  }
+  void SaveSessionState() {
+    save_session_state_ = true;
+  }
+
+  // Called when the BrowserContext/Profile is going away.
+  void Shutdown();
+
   // Methods to add, remove, and notify EventObservers.
   void AddEventObserver(EventObserver* observer);
   void RemoveEventObserver(EventObserver* observer);
   void NotifyItemSet(
       const DomStorageArea* area,
       const string16& key,
       const string16& new_value,
       const NullableString16& old_value,
       const GURL& page_url);
   void NotifyItemRemoved(
@@ skipping 19 matching lines @@
   friend class base::RefCountedThreadSafe<DomStorageContext>;
   typedef std::map<int64, scoped_refptr<DomStorageNamespace> >
       StorageNamespaceMap;
 
   ~DomStorageContext();
 
   // Collection of namespaces keyed by id.
   StorageNamespaceMap namespaces_;
 
   // Where localstorage data is stored, maybe empty for the incognito use case.
-  FilePath directory_;
+  const FilePath directory_;
 
   // Used to schedule sequenced background tasks.
   scoped_refptr<DomStorageTaskRunner> task_runner_;
 
   // List of objects observing local storage events.
   ObserverList<EventObserver> event_observers_;
 
   // We use a 32 bit identifier for per tab storage sessions.
   // At a tab per second, this range is large enough for 68 years.
   base::AtomicSequenceNumber session_id_sequence_;
+
+  bool clear_local_state_;
+  bool save_session_state_;
+
+  scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
 };
 
 }  // namespace dom_storage
 
 #endif  // WEBKIT_DOM_STORAGE_DOM_STORAGE_CONTEXT_H_