memory coordinator: Observe renderer visibility to update state

content/browser/memory/memory_coordinator_impl.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_impl.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/memory/memory_monitor.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_widget_host.h"
 #include "content/public/common/content_features.h"
 
 namespace content {
 
 namespace {
 
 // A expected renderer size. These values come from the median of appropriate
 // UMA stats.
 #if defined(OS_ANDROID) || defined(OS_IOS)
 const int kDefaultExpectedRendererSizeMB = 40;
@@ skipping 68 matching lines @@
   monitoring_interval_ =
       base::TimeDelta::FromSeconds(kDefaultMonitoringIntervalSeconds);
 }
 
 MemoryCoordinatorImpl::~MemoryCoordinatorImpl() {}
 
 void MemoryCoordinatorImpl::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK(last_state_change_.is_null());
   DCHECK(ValidateParameters());
+
+  notification_registrar_.Add(
+      this, NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+      NotificationService::AllBrowserContextsAndSources());
   ScheduleUpdateState(base::TimeDelta());
 }
 
 void MemoryCoordinatorImpl::OnChildAdded(int render_process_id) {
   // Populate the global state as an initial state of a newly created process.
   SetMemoryState(render_process_id, ToMojomMemoryState(current_state_));
 }
 
 base::MemoryState MemoryCoordinatorImpl::GetCurrentMemoryState() const {
   return current_state_;
 }
 
+void MemoryCoordinatorImpl::Observe(int type,
+                                    const NotificationSource& source,
+                                    const NotificationDetails& details) {
+  DCHECK(type == NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED);
+  RenderWidgetHost* render_widget_host = Source<RenderWidgetHost>(source).ptr();
+  RenderProcessHost* process = render_widget_host->GetProcess();
+  if (!process)
+    return;
+  auto iter = children().find(process->GetID());
+  if (iter == children().end())
+    return;
+  bool is_visible = *Details<bool>(details).ptr();
+  // We don't throttle/suspend a visible renderer for now.
+  auto new_state = is_visible ? mojom::MemoryState::NORMAL
+                              : ToMojomMemoryState(current_state_);
+  SetMemoryState(iter->first, new_state);
+}
+
 base::MemoryState MemoryCoordinatorImpl::CalculateNextState() {
   using MemoryState = base::MemoryState;
 
   int available = memory_monitor_->GetFreeMemoryUntilCriticalMB();
   if (available <= 0)
     return MemoryState::SUSPENDED;
 
   int expected_renderer_count = available / expected_renderer_size_;
 
   switch (current_state_) {
@@ skipping 48 matching lines @@
   // TODO(bashi): Maybe worth considering another state for the browser.
   auto state = current_state_ == MemoryState::SUSPENDED ? MemoryState::THROTTLED
                                                         : current_state_;
   base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(state);
 }
 
 void MemoryCoordinatorImpl::NotifyStateToChildren() {
   auto mojo_state = ToMojomMemoryState(current_state_);
   // It's OK to call SetMemoryState() unconditionally because it checks whether
   // this state transition is valid.
-  // TODO(bashi): In SUSPENDED state, we should update children's state
-  // accordingly when the foreground tab is changed (e.g. resume a renderer
-  // which becomes foreground and suspend a renderer which goes to background).
   for (auto& iter : children())
     SetMemoryState(iter.first, mojo_state);
 }
 
 void MemoryCoordinatorImpl::ScheduleUpdateState(base::TimeDelta delta) {
   task_runner_->PostDelayedTask(FROM_HERE, update_state_callback_, delta);
 }
 
 bool MemoryCoordinatorImpl::ValidateParameters() {
   return (new_renderers_until_throttled_ > new_renderers_until_suspended_) &&
       (new_renderers_back_to_normal_ > new_renderers_back_to_throttled_) &&
       (new_renderers_back_to_normal_ > new_renderers_until_throttled_) &&
       (new_renderers_back_to_throttled_ > new_renderers_until_suspended_);
 }
 
 }  // namespace content