Make RenderThreadImpl a client of memory coordinator

content/renderer/render_thread_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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory_allocator.h"
+#include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 859 matching lines @@
       time_zone_monitor_binding_.CreateInterfacePtrAndBind());
 
 #if defined(OS_LINUX)
   ChildProcess::current()->SetIOThreadPriority(base::ThreadPriority::DISPLAY);
   ChildThreadImpl::current()->SetThreadPriority(
       categorized_worker_pool_->background_worker_thread_id(),
       base::ThreadPriority::BACKGROUND);
 #endif
 
   is_renderer_suspended_ = false;
+
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);

[haraken, 2016/10/07 11:45:30]

I'd call this in Shutdown().

[hajimehoshi, 2016/10/11 07:05:32]

Done.

 }
 
 void RenderThreadImpl::Shutdown() {
   FOR_EACH_OBSERVER(
       RenderThreadObserver, observers_, OnRenderProcessShutdown());
 
   if (memory_observer_) {
     message_loop()->RemoveTaskObserver(memory_observer_.get());
     memory_observer_.reset();
   }
@@ skipping 1213 matching lines @@
   // EmbeddedSharedWorkerStub will self-destruct.
   new EmbeddedSharedWorkerStub(
       params.url, params.name, params.content_security_policy,
       params.security_policy_type, params.creation_address_space,
       params.pause_on_start, params.route_id);
 }
 
 void RenderThreadImpl::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   TRACE_EVENT0("memory","RenderThreadImpl::OnMemoryPressure");
+  if (blink_platform_impl_) {
+    blink::WebMemoryCoordinator::onMemoryPressure(
+        static_cast<blink::WebMemoryPressureLevel>(memory_pressure_level));
+  }
+  ClearMemory(memory_pressure_level ==
+      base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
+}
+
+void RenderThreadImpl::OnMemoryStateChange(base::MemoryState state) {
+  // TODO(hajimehoshi): Adjust the size of this memory usage according to
+  // |state|. RenderThreadImpl doesn't have a feature to limit memory usage at
+  // present.
+  if (blink_platform_impl_) {
+    blink::WebMemoryCoordinator::onMemoryStateChange(
+        static_cast<blink::MemoryState>(state));
+  }
+  switch (state) {
+    case base::MemoryState::NORMAL:
+      break;
+    case base::MemoryState::THROTTLED:
+      ClearMemory(false);
+      break;
+    case base::MemoryState::SUSPENDED:
+      ClearMemory(true);
+      break;
+    case base::MemoryState::UNKNOWN:
+      NOTREACHED();
+      break;
+  }
+}
+
+void RenderThreadImpl::ClearMemory(bool critical) {

[haraken, 2016/10/07 11:45:30]

I'd avoid introducing the boolean flag. Alternately, you can move
ReleaseFreeMemory() to the caller side; i.e.,

  case base::MemoryState::THROTTLED:
    ReleaseFreeMemory();
    break;
  case base::MemoryState::SUSPENDED:
    ReleaseFreeMemory();
    ClearMemory();
    break;

[hajimehoshi, 2016/10/11 07:05:32]

Done.

   ReleaseFreeMemory();
 
   // Do not call into blink if it is not initialized.
-  if (blink_platform_impl_) {
-    blink::WebMemoryCoordinator::onMemoryPressure(
-        static_cast<blink::WebMemoryPressureLevel>(memory_pressure_level));
-
-    if (memory_pressure_level ==
-        base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
-      // Purge Skia font cache, by setting it to 0 and then again to the
-      // previous limit.
-      size_t font_cache_limit = SkGraphics::SetFontCacheLimit(0);
-      SkGraphics::SetFontCacheLimit(font_cache_limit);
-    }
+  if (blink_platform_impl_ && critical) {
+    // Purge Skia font cache, by setting it to 0 and then again to the
+    // previous limit.
+    size_t font_cache_limit = SkGraphics::SetFontCacheLimit(0);
+    SkGraphics::SetFontCacheLimit(font_cache_limit);
   }
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RenderThreadImpl::GetFileThreadTaskRunner() {
   DCHECK(message_loop()->task_runner()->BelongsToCurrentThread());
   if (!file_thread_) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
@@ skipping 170 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content