Purge browser cache for dom storage in a smarter way

content/browser/dom_storage/dom_storage_context_impl.cc

 // 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.
 
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
 
 static const int kSessionStoraceScavengingSeconds = 60;
 
 // Offset the session storage namespace ids generated by different contexts
 // to help identify when an id from one is mistakenly used in another.
 static int g_session_id_offset_sequence = 1;
 
+// Helper class that posts the memory pressure notification on dom storage task
+// runner.
+class DOMStorageContextImpl::DOMStorageMemoryPressureListener {
+ public:
+  DOMStorageMemoryPressureListener(DOMStorageTaskRunner* task_runner,
+                                   DOMStorageContextImpl* context)
+      : task_runner_(task_runner),
+        context_(context),
+        listener_(
+            base::Bind(&DOMStorageMemoryPressureListener::OnMemoryPressure,
+                       base::Unretained(this))) {}
+
+  void OnMemoryPressure(
+      base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+    base::AutoLock lock(lock_);
+    if (task_runner_) {
+      task_runner_->PostTask(
+          FROM_HERE, base::Bind(&DOMStorageContextImpl::PurgeMemory, context_,
+                                memory_pressure_level));
+    }
+  }
+
+  void Shutdown() {
+    base::AutoLock lock(lock_);

[michaeln, 2016/05/09 21:50:31]

Lets avoid leaks and locks for this. Having a separate helper with a
MemoryPressureListener to eves drop on OnMemoryPressure in a well known thread
looks good, but leaking and interlocking on shutdown does not.

What if...

A) We have the DOMStorageContextWrapper be responsible for setting up and
tearing down the MemoryPressureListener. The purpose of the wrapper class is to
help plug into other parts of chrome. The base::Listener could be created in the
ctor (called on the UI thread) and deleted in
DOMStorageContextWrapper::Shutdow() (aldo called on the UI thread). That might
be the most straightforward way of hooking into OnMemoryPressure() which whould
then PostTask on the sequence runner to the context impl.

There's probably other ways to avoid leaks and locks.

B) Another idea, lazily construct this inner Listener class.  PostTask to the
BrowserThread::IO to initialize it. We'll have to construct the
base::MemoryPressureListener on the IO thread. Then in
DOMStorageContextImpl::Shutdown() we call
BrowserThread::DeleteSoon(BrowserThread::IO, mem_listner_.release()). That
sounds more complicated that option A though.

[ssid, 2016/05/10 02:04:16]

listener in DOMStorageContextWrapper sounds like a good idea. I should have
looked into the code little more.

+    task_runner_ = nullptr;
+    context_ = nullptr;
+  }
+
+ private:
+  scoped_refptr<DOMStorageTaskRunner> task_runner_;
+  scoped_refptr<DOMStorageContextImpl> context_;
+  base::MemoryPressureListener listener_;
+  base::Lock lock_;
+};
+
 DOMStorageContextImpl::DOMStorageContextImpl(
     const base::FilePath& localstorage_directory,
     const base::FilePath& sessionstorage_directory,
     storage::SpecialStoragePolicy* special_storage_policy,
     DOMStorageTaskRunner* task_runner)
     : localstorage_directory_(localstorage_directory),
       sessionstorage_directory_(sessionstorage_directory),
       task_runner_(task_runner),
       session_id_offset_(abs((g_session_id_offset_sequence++ % 10)) * 1000),
       is_shutdown_(false),
       force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
       scavenging_started_(false) {
   // AtomicSequenceNum starts at 0 but we want to start session
   // namespace ids at one since zero is reserved for the
   // kLocalStorageNamespaceId.
   session_id_sequence_.GetNext();
 
   // Tests may run without task runners.
   if (task_runner_) {
+    // Created for each DOMStorageContextImpl object and is leaked since
+    // destruction is not thread safe.
+    leaked_memory_pressure_listener_ =
+        new DOMStorageMemoryPressureListener(task_runner, this);
+
     // Registering dump provider is safe even outside the task runner.
     base::trace_event::MemoryDumpManager::GetInstance()
         ->RegisterDumpProviderWithSequencedTaskRunner(
             this, "DOMStorage", task_runner_->GetSequencedTaskRunner(
                                     DOMStorageTaskRunner::PRIMARY_SEQUENCE),
             base::trace_event::MemoryDumpProvider::Options());
   }
 }
 
 DOMStorageContextImpl::~DOMStorageContextImpl() {
@@ skipping 118 matching lines @@
     entry.second->Flush();
 }
 
 void DOMStorageContextImpl::Shutdown() {
   DCHECK(!task_runner_ || task_runner_->IsRunningOnPrimarySequence());
   is_shutdown_ = true;
   StorageNamespaceMap::const_iterator it = namespaces_.begin();
   for (; it != namespaces_.end(); ++it)
     it->second->Shutdown();
 
+  leaked_memory_pressure_listener_->Shutdown();
+
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   if (localstorage_directory_.empty() && !session_storage_database_.get())
     return;
 
   // Respect the content policy settings about what to
   // keep and what to discard.
   if (force_keep_session_state_)
     return;  // Keep everything.
@@ skipping 161 matching lines @@
 
 void DOMStorageContextImpl::StartScavengingUnusedSessionStorage() {
   if (session_storage_database_.get()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DOMStorageContextImpl::FindUnusedNamespaces,
                               this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
+void DOMStorageContextImpl::PurgeMemory(
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  if (is_shutdown_)
+    return;
+
+  DOMStorageNamespace::PurgeOption option = DOMStorageNamespace::PURGE_UNOPENED;
+  if (memory_pressure_level ==
+      base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL)
+    option = DOMStorageNamespace::PURGE_AGGRESSIVE;
+  for (const auto& it : namespaces_)
+    it.second->PurgeMemory(option);
+}
+
 bool DOMStorageContextImpl::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   for (const auto& it : namespaces_) {
     it.second->OnMemoryDump(pmd);
   }
   if (session_storage_database_)
     session_storage_database_->OnMemoryDump(pmd);
   return true;
 }
@@ skipping 61 matching lines @@
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DOMStorageContextImpl::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
 }  // namespace content