1 files changed, 61 insertions, 18 deletions

diff --git a/chromium/base/memory/discardable_memory_emulated.cc b/chromium/base/memory/discardable_memory_emulated.cc
index ed7c42c750f..340a181834a 100644
--- a/chromium/base/memory/discardable_memory_emulated.cc
+++ b/chromium/base/memory/discardable_memory_emulated.cc
@@ -5,60 +5,103 @@
 #include "base/memory/discardable_memory_emulated.h"
 
 #include "base/lazy_instance.h"
-#include "base/memory/discardable_memory_provider.h"
+#include "base/memory/discardable_memory_manager.h"
 
 namespace base {
-
 namespace {
 
-base::LazyInstance<internal::DiscardableMemoryProvider>::Leaky g_provider =
-    LAZY_INSTANCE_INITIALIZER;
+// This is admittedly pretty magical.
+const size_t kEmulatedMemoryLimit = 512 * 1024 * 1024;
+const size_t kEmulatedSoftMemoryLimit = 32 * 1024 * 1024;
+const size_t kEmulatedBytesToKeepUnderModeratePressure = 4 * 1024 * 1024;
+const size_t kEmulatedHardMemoryLimitExpirationTimeMs = 1000;
+
+struct SharedState {
+  SharedState()
+      : manager(kEmulatedMemoryLimit,
+                kEmulatedSoftMemoryLimit,
+                kEmulatedBytesToKeepUnderModeratePressure,
+                TimeDelta::FromMilliseconds(
+                    kEmulatedHardMemoryLimitExpirationTimeMs)) {}
+
+  internal::DiscardableMemoryManager manager;
+};
+LazyInstance<SharedState>::Leaky g_shared_state = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace internal {
 
-DiscardableMemoryEmulated::DiscardableMemoryEmulated(size_t size)
-    : is_locked_(false) {
-  g_provider.Pointer()->Register(this, size);
+DiscardableMemoryEmulated::DiscardableMemoryEmulated(size_t bytes)
+    : bytes_(bytes),
+      is_locked_(false) {
+  g_shared_state.Pointer()->manager.Register(this, bytes);
 }
 
 DiscardableMemoryEmulated::~DiscardableMemoryEmulated() {
   if (is_locked_)
     Unlock();
-  g_provider.Pointer()->Unregister(this);
+  g_shared_state.Pointer()->manager.Unregister(this);
+}
+
+// static
+void DiscardableMemoryEmulated::RegisterMemoryPressureListeners() {
+  g_shared_state.Pointer()->manager.RegisterMemoryPressureListener();
+}
+
+// static
+void DiscardableMemoryEmulated::UnregisterMemoryPressureListeners() {
+  g_shared_state.Pointer()->manager.UnregisterMemoryPressureListener();
+}
+
+// static
+bool DiscardableMemoryEmulated::ReduceMemoryUsage() {
+  return g_shared_state.Pointer()->manager.ReduceMemoryUsage();
+}
+
+// static
+void DiscardableMemoryEmulated::PurgeForTesting() {
+  g_shared_state.Pointer()->manager.PurgeAll();
 }
 
 bool DiscardableMemoryEmulated::Initialize() {
-  return Lock() == DISCARDABLE_MEMORY_PURGED;
+  return Lock() != DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
 }
 
-LockDiscardableMemoryStatus DiscardableMemoryEmulated::Lock() {
+DiscardableMemoryLockStatus DiscardableMemoryEmulated::Lock() {
   DCHECK(!is_locked_);
 
   bool purged = false;
-  memory_ = g_provider.Pointer()->Acquire(this, &purged);
-  if (!memory_)
-    return DISCARDABLE_MEMORY_FAILED;
+  if (!g_shared_state.Pointer()->manager.AcquireLock(this, &purged))
+    return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
 
   is_locked_ = true;
-  return purged ? DISCARDABLE_MEMORY_PURGED : DISCARDABLE_MEMORY_SUCCESS;
+  return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
+                : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
 }
 
 void DiscardableMemoryEmulated::Unlock() {
   DCHECK(is_locked_);
-  g_provider.Pointer()->Release(this, memory_.Pass());
+  g_shared_state.Pointer()->manager.ReleaseLock(this);
   is_locked_ = false;
 }
 
 void* DiscardableMemoryEmulated::Memory() const {
+  DCHECK(is_locked_);
   DCHECK(memory_);
   return memory_.get();
 }
 
-// static
-void DiscardableMemoryEmulated::PurgeForTesting() {
-  g_provider.Pointer()->PurgeAll();
+bool DiscardableMemoryEmulated::AllocateAndAcquireLock() {
+  if (memory_)
+    return true;
+
+  memory_.reset(new uint8[bytes_]);
+  return false;
+}
+
+void DiscardableMemoryEmulated::Purge() {
+  memory_.reset();
 }
 
 }  // namespace internal