Make TabLoader a client of memory coordinator

chrome/browser/sessions/tab_loader.cc

 // Copyright 2015 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/sessions/tab_loader.h"
 
 #include <algorithm>
 #include <string>
 
+#include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/memory_pressure_monitor.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "chrome/browser/sessions/session_restore_stats_collector.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "components/favicon/content/content_favicon_driver.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/content_features.h"
 
 using content::NavigationController;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 void TabLoader::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED: {
@@ skipping 35 matching lines @@
   if (!shared_tab_loader_)
     shared_tab_loader_ = new TabLoader(restore_started);
 
   shared_tab_loader_->stats_collector_->TrackTabs(tabs);
   shared_tab_loader_->StartLoading(tabs);
 }
 
 TabLoader::TabLoader(base::TimeTicks restore_started)
     : memory_pressure_listener_(
           base::Bind(&TabLoader::OnMemoryPressure, base::Unretained(this))),
+      memory_state_(base::MemoryState::NORMAL),

[sky, 2016/09/26 16:41:57]

Should this be initialized to the real value? By that I mean if the memory
coordinate client is enabled shouldn't this query for the current value?

[hajimehoshi, 2016/09/27 05:59:16]

chrisha@: IIUC the initial value should always be NORMAL, but is this correct?

[bashi, 2016/09/29 06:30:52]

Yes. Current plan is that the initial state is NORMAL.

       force_load_delay_multiplier_(1),
       loading_enabled_(true),
       restore_started_(restore_started) {
   stats_collector_ = new SessionRestoreStatsCollector(
       restore_started,
       base::MakeUnique<
           SessionRestoreStatsCollector::UmaStatsReportingDelegate>());
   shared_tab_loader_ = this;
   this_retainer_ = this;
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
 TabLoader::~TabLoader() {
   DCHECK(tabs_loading_.empty() && tabs_to_load_.empty());
   DCHECK(shared_tab_loader_ == this);
   shared_tab_loader_ = nullptr;
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
 
 void TabLoader::StartLoading(const std::vector<RestoredTab>& tabs) {
   // Add the tabs to the list of tabs loading/to load and register them for
   // notifications. Also, restore the favicons of the background tabs (the title
   // has already been set by now).This avoids having blank icons in case the
   // restore is halted due to memory pressure. Also, when multiple tabs are
   // restored to a single window, the title may not appear, and the user will
   // have no way of finding out which tabs corresponds to which page if the icon
   // is a generic grey one.
@@ skipping 17 matching lines @@
   if (delegate_)
     return;
 
   // Create a TabLoaderDelegate which will allow OS specific behavior for tab
   // loading.
   if (!delegate_) {
     delegate_ = TabLoaderDelegate::Create(this);
     // There is already at least one tab loading (the active tab). As such we
     // only have to start the timeout timer here. But, don't restore background
     // tabs if the system is under memory pressure.
-    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level =
-        CurrentMemoryPressureLevel();
-
-    if (memory_pressure_level !=
-        base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
-      OnMemoryPressure(memory_pressure_level);
+    if (ShouldPurgeMemory()) {
+      PurgeMemory();
       return;
     }
 
     StartFirstTimer();
   }
 }
 
 void TabLoader::LoadNextTab() {
   // LoadNextTab should only get called after we have started the tab
   // loading.
   CHECK(delegate_);
 
   // Abort if loading is not enabled.
   if (!loading_enabled_)
     return;
 
   if (!tabs_to_load_.empty()) {
     // Check the memory pressure before restoring the next tab, and abort if
     // there is pressure. This is important on the Mac because of the sometimes
     // large delay between a memory pressure event and receiving a notification
     // of that event (in that case tab restore can trigger memory pressure but
     // will complete before the notification arrives).
-    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level =
-        CurrentMemoryPressureLevel();
-    if (memory_pressure_level !=
-        base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
-      OnMemoryPressure(memory_pressure_level);
+    if (ShouldPurgeMemory()) {
+      PurgeMemory();
       return;
     }
 
     NavigationController* controller = tabs_to_load_.front();
     DCHECK(controller);
     tabs_loading_.insert(controller);
     tabs_to_load_.pop_front();
     controller->LoadIfNecessary();
     content::WebContents* contents = controller->GetWebContents();
     if (contents) {
@@ skipping 58 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  content::Source<NavigationController>(controller));
 }
 
 void TabLoader::HandleTabClosedOrLoaded(NavigationController* controller) {
   RemoveTab(controller);
   if (delegate_)
     LoadNextTab();
 }
 
-base::MemoryPressureListener::MemoryPressureLevel
-    TabLoader::CurrentMemoryPressureLevel() {
-  if (base::MemoryPressureMonitor::Get())
-    return base::MemoryPressureMonitor::Get()->GetCurrentPressureLevel();
-
-  return base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
+bool TabLoader::ShouldPurgeMemory() const {
+  if (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) {

[sky, 2016/09/26 16:41:57]

no {}

[hajimehoshi, 2016/09/27 05:59:15]

Done.

+    return memory_state_ != base::MemoryState::NORMAL;
+  }
+  if (base::MemoryPressureMonitor::Get()) {
+    return base::MemoryPressureMonitor::Get()->GetCurrentPressureLevel() !=
+        base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
+  }
+  return false;
 }
 
 void TabLoader::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  PurgeMemory();
+}
+
+void TabLoader::OnMemoryStateChange(base::MemoryState state) {
+  memory_state_ = state;
+  switch (state) {
+    case base::MemoryState::NORMAL:
+      break;
+    case base::MemoryState::THROTTLED:
+      PurgeMemory();
+      break;
+    case base::MemoryState::SUSPENDED:
+      // Note that SUSPENDED never occurs in the main browser process so far.
+      // Fall through.
+    case base::MemoryState::UNKNOWN:
+      NOTREACHED();
+      break;
+  }
+}
+
+void TabLoader::PurgeMemory() {

[chrisha, 2016/09/26 14:18:53]

PurgeMemory isn't the best name here, as it's not actually freeing up any
memory. Rather, it's stopping further use of memory. Rename this
StopLoadingTabs, and ShouldStopLoadingTabs?

[sky, 2016/09/26 16:41:57]

SGTM

[hajimehoshi, 2016/09/27 05:59:16]

Done.

   // When receiving a resource pressure level warning, we stop pre-loading more
   // tabs since we are running in danger of loading more tabs by throwing out
   // old ones.
   if (tabs_to_load_.empty())
     return;
   // Stop the timer and suppress any tab loads while we clean the list.
   SetTabLoadingEnabled(false);
   while (!tabs_to_load_.empty()) {
     NavigationController* tab = tabs_to_load_.front();
     tabs_to_load_.pop_front();
     RemoveTab(tab);
 
     // Notify the stats collector that a tab's loading has been deferred due to
     // memory pressure.
     stats_collector_->DeferTab(tab);
   }
   // By calling |LoadNextTab| explicitly, we make sure that the
   // |NOTIFICATION_SESSION_RESTORE_DONE| event gets sent.
   LoadNextTab();
 }
 
 // static
 TabLoader* TabLoader::shared_tab_loader_ = nullptr;