[SessionStorage] Save SessionStorageNamespaceImpl for re-use.

Since the tab restore code keeps a reference to the session namespaces
of recently closed tabs (see sessions::ContentPlatformSpecificTabData
and sessions::TabRestoreService), a SessionStorageNamespaceImpl can
outlive the destruction of the browser window. A session restore can
also happen without the browser context being shutdown or destroyed in
between.

This change keeps track of all 'alive' namespaces in a map. When a
SessionStorageNamespaceImpl is created and there is an entry alive in
that map, then that object is used instead. This allows the browser to
re-use objects that are still alive thanks to the sessions component.

Bug: 811189
Change-Id: I5c9e94ab4fe7b0017264c0f8f522d20134ea0c2b
Reviewed-on: https://chromium-review.googlesource.com/930325
Commit-Queue: Daniel Murphy <dmurph@chromium.org>
Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#539304}

content/browser/dom_storage/dom_storage_context_wrapper.cc

@@ -393,6 +393,26 @@ void DOMStorageContextWrapper::SetLocalStorageDatabaseForTesting(
                      base::Unretained(mojo_state_), std::move(database)));
 }
 
+scoped_refptr<SessionStorageNamespaceImpl>
+DOMStorageContextWrapper::MaybeGetExistingNamespace(
+    const std::string& namespace_id) const {
+  auto it = alive_namespaces_.find(namespace_id);
+  return (it != alive_namespaces_.end()) ? it->second : nullptr;
+}
+
+void DOMStorageContextWrapper::AddNamespace(
+    const std::string& namespace_id,
+    SessionStorageNamespaceImpl* session_namespace) {
+  DCHECK(alive_namespaces_.find(namespace_id) == alive_namespaces_.end());
+  alive_namespaces_[namespace_id] = session_namespace;
+}
+
+void DOMStorageContextWrapper::RemoveNamespace(
+    const std::string& namespace_id) {
+  DCHECK(alive_namespaces_.find(namespace_id) != alive_namespaces_.end());
+  alive_namespaces_.erase(namespace_id);
+}
+
 void DOMStorageContextWrapper::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   DOMStorageContextImpl::PurgeOption purge_option =

content/browser/dom_storage/dom_storage_context_wrapper.h

@@ -36,6 +36,7 @@ namespace content {
 class DOMStorageContextImpl;
 class LocalStorageContextMojo;
 class SessionStorageContextMojo;
+class SessionStorageNamespaceImpl;
 
 // This is owned by Storage Partition and encapsulates all its dom storage
 // state.
@@ -101,6 +102,14 @@ class CONTENT_EXPORT DOMStorageContextWrapper
     return mojo_task_runner_.get();
   }
 
+  scoped_refptr<SessionStorageNamespaceImpl> MaybeGetExistingNamespace(
+      const std::string& namespace_id) const;
+
+  void AddNamespace(const std::string& namespace_id,
+                    SessionStorageNamespaceImpl* session_namespace);
+
+  void RemoveNamespace(const std::string& namespace_id);
+
   // Called on UI thread when the system is under memory pressure.
   void OnMemoryPressure(
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
@@ -117,6 +126,18 @@ class CONTENT_EXPORT DOMStorageContextWrapper
   SessionStorageContextMojo* mojo_session_state_ = nullptr;
   scoped_refptr<base::SequencedTaskRunner> mojo_task_runner_;
 
+  // Since the tab restore code keeps a reference to the session namespaces
+  // of recently closed tabs (see sessions::ContentPlatformSpecificTabData and
+  // sessions::TabRestoreService), a SessionStorageNamespaceImpl can outlive the
+  // destruction of the browser window. A session restore can also happen
+  // without the browser context being shutdown or destroyed in between. The
+  // design of SessionStorageNamespaceImpl assumes there is only one object per
+  // namespace. A session restore creates new objects for all tabs while the
+  // Profile wasn't destructed. This map allows the restored session to re-use
+  // the SessionStorageNamespaceImpl objects that are still alive thanks to the
+  // sessions component.
+  std::map<std::string, SessionStorageNamespaceImpl*> alive_namespaces_;
+
   base::FilePath legacy_localstorage_path_;
 
   // To receive memory pressure signals.

content/browser/dom_storage/dom_storage_session.h

@@ -52,6 +52,7 @@ class CONTENT_EXPORT DOMStorageSession {
   const std::string& namespace_id() const { return namespace_id_; }
   void SetShouldPersist(bool should_persist);
   bool should_persist() const;
+  DOMStorageContextWrapper* context() const { return context_wrapper_.get(); }
   bool IsFromContext(DOMStorageContextWrapper* context);
 
   std::unique_ptr<DOMStorageSession> Clone();

content/browser/dom_storage/session_storage_namespace_impl.cc

@@ -23,8 +23,14 @@ scoped_refptr<SessionStorageNamespaceImpl> SessionStorageNamespaceImpl::Create(
 scoped_refptr<SessionStorageNamespaceImpl> SessionStorageNamespaceImpl::Create(
     scoped_refptr<DOMStorageContextWrapper> context,
     const std::string& namepace_id) {
-  return base::WrapRefCounted(new SessionStorageNamespaceImpl(
-      DOMStorageSession::CreateWithNamespace(std::move(context), namepace_id)));
+  scoped_refptr<SessionStorageNamespaceImpl> existing =
+      context->MaybeGetExistingNamespace(namepace_id);
+  if (!existing) {
+    existing = base::WrapRefCounted(
+        new SessionStorageNamespaceImpl(DOMStorageSession::CreateWithNamespace(
+            std::move(context), namepace_id)));
+  }
+  return existing;
 }
 
 // static
@@ -61,9 +67,12 @@ bool SessionStorageNamespaceImpl::IsFromContext(
 
 SessionStorageNamespaceImpl::SessionStorageNamespaceImpl(
     std::unique_ptr<DOMStorageSession> session)
-    : session_(std::move(session)) {}
+    : session_(std::move(session)) {
+  session_->context()->AddNamespace(session_->namespace_id(), this);
+}
 
 SessionStorageNamespaceImpl::~SessionStorageNamespaceImpl() {
+  session_->context()->RemoveNamespace(session_->namespace_id());
 }
 
 }  // namespace content

content/browser/dom_storage/session_storage_namespace_impl.h

@@ -19,14 +19,15 @@ class DOMStorageSession;
 
 class SessionStorageNamespaceImpl : public SessionStorageNamespace {
  public:
-  // Constructs a |SessionStorageNamespaceImpl| and allocates a new ID for it.
+  // Constructs a SessionStorageNamespaceImpl and allocates a new ID for it.
   //
   // The CONTENT_EXPORT allows TestRenderViewHost to instantiate these.
   CONTENT_EXPORT static scoped_refptr<SessionStorageNamespaceImpl> Create(
       scoped_refptr<DOMStorageContextWrapper> context);
 
-  // Constructs a |SessionStorageNamespaceImpl| and assigns |namepace_id|
-  // to it.
+  // If there is an existing SessionStorageNamespaceImpl with the given id in
+  // the DOMStorageContextWrapper, this will return that object. Otherwise this
+  // constructs a SessionStorageNamespaceImpl and assigns |namepace_id| to it.
   static scoped_refptr<SessionStorageNamespaceImpl> Create(
       scoped_refptr<DOMStorageContextWrapper> context,
       const std::string& namepace_id);