Adds MemoryPressureListener.

chrome/browser/memory_purger.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 "chrome/browser/memory_purger.h"
 
 #include <set>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/memory/memory_pressure_handler.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/browser/webdata/web_data_service_factory.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/resource_context.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ResourceContext;
 
+namespace {
+
 // PurgeMemoryHelper -----------------------------------------------------------
 
 // This is a small helper class used to ensure that the objects we want to use
 // on multiple threads are properly refed, so they don't get deleted out from
 // under us.
 class PurgeMemoryIOHelper
     : public base::RefCountedThreadSafe<PurgeMemoryIOHelper> {
  public:
   PurgeMemoryIOHelper() {
     safe_browsing_service_ = g_browser_process->safe_browsing_service();
@@ skipping 28 matching lines @@
   for (size_t i = 0; i < request_context_getters_.size(); ++i) {
     request_context_getters_[i]->GetURLRequestContext()->proxy_service()->
         PurgeMemory();
   }
 
 #if defined(FULL_SAFE_BROWSING)
   safe_browsing_service_->database_manager()->PurgeMemory();
 #endif
 }
 
+void PurgeAllOnMemoryPressure(
+    base::MemoryPressureHandler::MemoryPressureType memory_pressure_type) {
+  if (memory_pressure_type >=
+      base::MemoryPressureHandler::MEMORY_PRESSURE_MODERATE)
+    MemoryPurger::PurgeAll();

[joth, 2013/06/05 16:51:23]

this seems completely wrong use of MemoryPurger::PurgeAll() - we're not just
about to hibernate to disk. We maybe still in foreground, and this will drop
caches that will need re-creating on the very next frame.

I think the individual subsystems that the MemoryPurger pokes each need to be
migrated to be MemoryPressureListener aware and apply the fine grained policy
appropriate to that domain.

eventually, MemoryPurger::PurgeAll() would just be a synonym for broadcasting a
MemoryPressureListener(CRITICAL) state. (maybe we have a dedicated
CRITICAL_SUSPEND state for it)

[bulach, 2013/06/05 19:02:11]

should I separate this for the time being then?

[joth, 2013/06/05 19:28:58]

Yes. Given pkasting's general skeptism about MemoryPurger::PurgeAll() ever
working, and my suspension this will often do the wrong thing even if the purger
otherwise were working correctly, I'd drop this part of the CL altogether.

[bulach, 2013/06/06 09:28:30]

sgtm.. removed this altogether from the latest patchset.
I also chatted with mnaganov, we'll be adding the various
"MemoryPressure::Listener" in separate patches as soon as this lands.

+}
+
+struct LeakyLazyMemoryPressureListenerTraits {
+  static const bool kRegisterOnExit = false;
+  static const bool kAllowedToAccessOnNonjoinableThread = true;
+
+  static base::MemoryPressureHandler::Listener* New(void* instance) {
+    return new (instance) base::MemoryPressureHandler::Listener(
+        base::Bind(&PurgeAllOnMemoryPressure));
+  }
+
+  static void Delete(base::MemoryPressureHandler::Listener* instance) {
+  }
+};
+
+base::LazyInstance<base::MemoryPressureHandler::Listener,
+                   LeakyLazyMemoryPressureListenerTraits>
+    g_memory_pressure_listener = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
 // -----------------------------------------------------------------------------
 
 // static
 void MemoryPurger::PurgeAll() {
   PurgeBrowser();
   PurgeRenderers();
 
   // TODO(pkasting):
   // * Tell the plugin processes to release their free memory?  Other stuff?
   // * Enumerate what other processes exist and what to do for them.
@@ skipping 62 matching lines @@
           content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance())
     PurgeRendererForHost(i.GetCurrentValue());
 }
 
 // static
 void MemoryPurger::PurgeRendererForHost(content::RenderProcessHost* host) {
   // Direct the renderer to free everything it can.
   host->Send(new ChromeViewMsg_PurgeMemory());
 }
+
+// static
+void MemoryPurger::RegisterMemoryPressureListener() {
+  CHECK(g_memory_pressure_listener.Pointer());
+}