memory coordinator: Throttle foreground renderers on SUSPENDED state

content/browser/memory/memory_coordinator.cc

 // Copyright 2016 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/memory/memory_coordinator.h"
 
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/metrics/histogram_macros.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 70 matching lines @@
 
   // Can't send a message to a child that doesn't exist.
   auto iter = children_.find(render_process_id);
   if (iter == children_.end())
     return false;
 
   // Can't send a message to a child that isn't bound.
   if (!iter->second.handle->child().is_bound())
     return false;
 
+  // We don't suspend foreground renderers. Throttle them instead.
+  if (memory_state == mojom::MemoryState::SUSPENDED &&
+      iter->second.is_visible)
+    memory_state = mojom::MemoryState::THROTTLED;
+
   // A nop doesn't need to be sent, but is considered successful.
   if (iter->second.memory_state == memory_state)
     return true;
 
-  // Can't throttle the given renderer.
-  if (memory_state == mojom::MemoryState::THROTTLED &&
-      !CanThrottleRenderer(render_process_id))
-    return false;
-
   // Can't suspend the given renderer.
   if (memory_state == mojom::MemoryState::SUSPENDED &&
       !CanSuspendRenderer(render_process_id))
     return false;
 
   // Update the internal state and send the message.
   iter->second.memory_state = memory_state;
   iter->second.handle->child()->OnStateChange(memory_state);
   return true;
 }
@@ skipping 46 matching lines @@
       new MemoryCoordinatorHandleImpl(std::move(request), this,
                                       dummy_render_process_id));
   handle->AddChild(std::move(child));
   CreateChildInfoMapEntry(dummy_render_process_id, std::move(handle));
 }
 
 void MemoryCoordinator::OnConnectionError(int render_process_id) {
   children_.erase(render_process_id);
 }
 
-bool MemoryCoordinator::CanThrottleRenderer(int render_process_id) {
-  // If there is no delegate (i.e. unittests), renderers are always
-  // throttleable.
-  // TODO(bashi): We check |delegate_| to avoid calling FromID() on a
-  // wrong thread in tests. Figure out a better way to handle tests.
-  if (!delegate_)
-    return true;
-  auto* render_process_host = RenderProcessHost::FromID(render_process_id);
-  return render_process_host && render_process_host->IsProcessBackgrounded();
-}
-
 bool MemoryCoordinator::CanSuspendRenderer(int render_process_id) {
   // If there is no delegate (i.e. unittests), renderers are always suspendable.
   if (!delegate_)
     return true;
   auto* render_process_host = RenderProcessHost::FromID(render_process_id);
   if (!render_process_host || !render_process_host->IsProcessBackgrounded())
     return false;
   return delegate_->CanSuspendBackgroundedRenderer(render_process_id);
 }
 
 void MemoryCoordinator::SetDelegateForTesting(
     std::unique_ptr<MemoryCoordinatorDelegate> delegate) {
   CHECK(!delegate_);
   delegate_ = std::move(delegate);
 }
 
 void MemoryCoordinator::CreateChildInfoMapEntry(
     int render_process_id,
     std::unique_ptr<MemoryCoordinatorHandleImpl> handle) {
   auto& child_info = children_[render_process_id];
   // Process always start with normal memory state.
   // We'll set renderer's memory state to the current global state when the
   // corresponding renderer process is ready to communicate. Renderer processes
   // call AddChild() when they are ready.
   child_info.memory_state = mojom::MemoryState::NORMAL;
+  child_info.is_visible = true;
   child_info.handle = std::move(handle);
 }
 
 MemoryCoordinator::ChildInfo::ChildInfo() {}
 
 MemoryCoordinator::ChildInfo::ChildInfo(const ChildInfo& rhs) {
   // This is a nop, but exists for compatibility with STL containers.
 }
 
 MemoryCoordinator::ChildInfo::~ChildInfo() {}
 
 }  // namespace content