Notify the browser process about a bloated renderer via the GRC.

The renderer sends a RendererIsBloated event to the GRC service.
The GRC turns the event into a PageIsBloated signal and sends the
signal to the tab manager in the browser process. The tab manager
then reloads the bloated tab.

Subsequent CL will add a notification from the tab manager to the
web contents, so that it can show an inforbar after the reload.

Bug: 835806
Change-Id: I23d0987094f1c6864534abeb57f8cce3273172ff
Reviewed-on: https://chromium-review.googlesource.com/1073419
Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Will Harris <wfh@chromium.org>
Reviewed-by: Steven Holte <holte@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Chris Hamilton <chrisha@chromium.org>
Reviewed-by: François Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565680}

chrome/browser/resource_coordinator/page_signal_receiver.cc

@@ -46,6 +46,15 @@ void PageSignalReceiver::NotifyPageAlmostIdle(
     observer.OnPageAlmostIdle(web_contents_iter->second);
 }
 
+void PageSignalReceiver::NotifyRendererIsBloated(
+    const CoordinationUnitID& page_cu_id) {
+  auto web_contents_iter = cu_id_web_contents_map_.find(page_cu_id);
+  if (web_contents_iter == cu_id_web_contents_map_.end())
+    return;
+  for (auto& observer : observers_)
+    observer.OnRendererIsBloated(web_contents_iter->second);
+}
+
 void PageSignalReceiver::SetExpectedTaskQueueingDuration(
     const CoordinationUnitID& page_cu_id,
     base::TimeDelta duration) {

chrome/browser/resource_coordinator/page_signal_receiver.h

@@ -25,6 +25,7 @@ class PageSignalObserver {
   // managed by the client. Thus the clients are responsible for checking the
   // passed |web_contents| by themselves.
   virtual void OnPageAlmostIdle(content::WebContents* web_contents) {}
+  virtual void OnRendererIsBloated(content::WebContents* web_contents) {}
   virtual void OnExpectedTaskQueueingDurationSet(
       content::WebContents* web_contents,
       base::TimeDelta duration) {}
@@ -52,6 +53,7 @@ class PageSignalReceiver : public mojom::PageSignalReceiver {
 
   // mojom::PageSignalReceiver implementation.
   void NotifyPageAlmostIdle(const CoordinationUnitID& page_cu_id) override;
+  void NotifyRendererIsBloated(const CoordinationUnitID& page_cu_id) override;
   void SetExpectedTaskQueueingDuration(const CoordinationUnitID& page_cu_id,
                                        base::TimeDelta duration) override;
   void SetLifecycleState(const CoordinationUnitID& page_cu_id,

chrome/browser/resource_coordinator/tab_lifecycle_unit.cc

@@ -28,7 +28,6 @@
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/page_importance_signals.h"
 #include "url/gurl.h"
 
 namespace resource_coordinator {
@@ -45,7 +44,20 @@ bool IsFrozenOrPendingFreeze(LifecycleUnitState state) {
          state == LifecycleUnitState::PENDING_FREEZE;
 }
 
-}  // namespace
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+enum class BloatedRendererHandlingInBrowser {
+  kReloaded = 0,
+  kCannotReload = 1,
+  kCannotShutdown = 2,
+  kMaxValue = kCannotShutdown
+};
+
+void RecordBloatedRendererHandling(BloatedRendererHandlingInBrowser handling) {
+  UMA_HISTOGRAM_ENUMERATION("BloatedRenderer.HandlingInBrowser", handling);
+}
+
+}  // anonymous namespace
 
 TabLifecycleUnitSource::TabLifecycleUnit::TabLifecycleUnit(
     base::ObserverList<TabLifecycleObserver>* observers,
@@ -524,6 +536,54 @@ bool TabLifecycleUnitSource::TabLifecycleUnit::DiscardTab() {
   return Discard(DiscardReason::kExternal);
 }
 
+bool TabLifecycleUnitSource::TabLifecycleUnit::CanReloadBloatedTab() {
+  // Can't reload a tab that isn't in a TabStripModel, which is needed for
+  // showing an infobar.
+  if (!tab_strip_model_)
+    return false;
+
+  if (GetWebContents()->IsCrashed())
+    return false;
+
+  // Do not reload tabs that don't have a valid URL (most probably they have
+  // just been opened and discarding them would lose the URL).
+  if (!GetWebContents()->GetLastCommittedURL().is_valid() ||
+      GetWebContents()->GetLastCommittedURL().is_empty()) {
+    return false;
+  }
+
+  // Do not reload tabs in which the user has entered text in a form.
+  if (GetWebContents()->GetPageImportanceSignals().had_form_interaction)
+    return false;
+
+  // TODO(ulan): Check if the navigation controller has POST data.
+
+  return true;
+}
+
+void TabLifecycleUnitSource::TabLifecycleUnit::ReloadBloatedTab() {
+  if (CanReloadBloatedTab()) {
+    const size_t expected_page_count = 1u;
+    const bool skip_unload_handlers = true;
+    if (GetRenderProcessHost()->FastShutdownIfPossible(expected_page_count,
+                                                       skip_unload_handlers)) {
+      // TODO(ulan): Notify the WebContents that the page is bloated to give
+      // it a chance to show the infobar after the reload.
+      const bool check_for_repost = true;
+      GetWebContents()->GetController().Reload(content::ReloadType::NORMAL,
+                                               check_for_repost);
+      RecordBloatedRendererHandling(
+          BloatedRendererHandlingInBrowser::kReloaded);
+    } else {
+      RecordBloatedRendererHandling(
+          BloatedRendererHandlingInBrowser::kCannotShutdown);
+    }
+  } else {
+    RecordBloatedRendererHandling(
+        BloatedRendererHandlingInBrowser::kCannotReload);
+  }
+}
+
 bool TabLifecycleUnitSource::TabLifecycleUnit::FreezeTab() {
   return Freeze();
 }

chrome/browser/resource_coordinator/tab_lifecycle_unit.h

@@ -5,6 +5,7 @@
 #ifndef CHROME_BROWSER_RESOURCE_COORDINATOR_TAB_LIFECYCLE_UNIT_H_
 #define CHROME_BROWSER_RESOURCE_COORDINATOR_TAB_LIFECYCLE_UNIT_H_
 
+#include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
@@ -15,6 +16,7 @@
 #include "chrome/browser/resource_coordinator/time.h"
 #include "content/public/browser/visibility.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/page_importance_signals.h"
 
 class TabStripModel;
 
@@ -76,6 +78,10 @@ class TabLifecycleUnitSource::TabLifecycleUnit
   // unit.
   void UpdateLifecycleState(mojom::LifecycleState state);
 
+  // Reloads the tab because its renderer is bloated and shows an infobar
+  // explaining that it was reloaded because it ran out of memory.
+  void ReloadBloatedTab();
+
   // LifecycleUnit:
   TabLifecycleUnitExternal* AsTabLifecycleUnitExternal() override;
   base::string16 GetTitle() const override;
@@ -111,6 +117,13 @@ class TabLifecycleUnitSource::TabLifecycleUnit
   friend class TabLifecycleUnitSource;
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(TabLifecycleUnitTest, CanReloadBloatedTab);
+  FRIEND_TEST_ALL_PREFIXES(TabLifecycleUnitTest, CannotReloadBloatedTabCrashed);
+  FRIEND_TEST_ALL_PREFIXES(TabLifecycleUnitTest,
+                           CannotReloadBloatedTabInvalidURL);
+  FRIEND_TEST_ALL_PREFIXES(TabLifecycleUnitTest,
+                           CannotReloadBloatedTabPendingUserInteraction);
+
   // Determines if the tab is a media tab, and populates an optional
   // |decision_details| with full details.
   bool IsMediaTabImpl(DecisionDetails* decision_details) const;
@@ -137,6 +150,8 @@ class TabLifecycleUnitSource::TabLifecycleUnit
   void DidStartLoading() override;
   void OnVisibilityChanged(content::Visibility visibility) override;
 
+  bool CanReloadBloatedTab();
+
   // List of observers to notify when the discarded state or the auto-
   // discardable state of this tab changes.
   base::ObserverList<TabLifecycleObserver>* observers_;

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.cc

@@ -229,6 +229,11 @@ void TabLifecycleUnitSource::OnLifecycleStateChanged(
     lifecycle_unit->UpdateLifecycleState(state);
 }
 
+void TabLifecycleUnitSource::OnRendererIsBloated(
+    content::WebContents* web_contents) {
+  GetTabLifecycleUnit(web_contents)->ReloadBloatedTab();
+}
+
 }  // namespace resource_coordinator
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.h

@@ -114,6 +114,7 @@ class TabLifecycleUnitSource : public BrowserListObserver,
   // PageSignalObserver:
   void OnLifecycleStateChanged(content::WebContents* web_contents,
                                mojom::LifecycleState state) override;
+  void OnRendererIsBloated(content::WebContents* web_contents) override;
 
   // Tracks the BrowserList and all TabStripModels.
   BrowserTabStripTracker browser_tab_strip_tracker_;

chrome/browser/resource_coordinator/tab_lifecycle_unit_unittest.cc

@@ -332,4 +332,39 @@ TEST_F(TabLifecycleUnitTest, NotifiedOfWebContentsVisibilityChanges) {
   tab_lifecycle_unit.RemoveObserver(&observer);
 }
 
+TEST_F(TabLifecycleUnitTest, CanReloadBloatedTab) {
+  TabLifecycleUnit tab_lifecycle_unit(&observers_, web_contents_,
+                                      tab_strip_model_.get());
+  EXPECT_TRUE(tab_lifecycle_unit.CanReloadBloatedTab());
+}
+
+TEST_F(TabLifecycleUnitTest, CannotReloadBloatedTabCrashed) {
+  TabLifecycleUnit tab_lifecycle_unit(&observers_, web_contents_,
+                                      tab_strip_model_.get());
+
+  web_contents_->SetIsCrashed(base::TERMINATION_STATUS_PROCESS_CRASHED, 0);
+
+  EXPECT_FALSE(tab_lifecycle_unit.CanReloadBloatedTab());
+}
+
+TEST_F(TabLifecycleUnitTest, CannotReloadBloatedTabInvalidURL) {
+  TabLifecycleUnit tab_lifecycle_unit(&observers_, web_contents_,
+                                      tab_strip_model_.get());
+
+  content::WebContentsTester::For(web_contents_)
+      ->SetLastCommittedURL(GURL("invalid :)"));
+
+  EXPECT_FALSE(tab_lifecycle_unit.CanReloadBloatedTab());
+}
+
+TEST_F(TabLifecycleUnitTest, CannotReloadBloatedTabPendingUserInteraction) {
+  TabLifecycleUnit tab_lifecycle_unit(&observers_, web_contents_,
+                                      tab_strip_model_.get());
+  content::PageImportanceSignals signals;
+  signals.had_form_interaction = true;
+  content::WebContentsTester::For(web_contents_)
+      ->SetPageImportanceSignals(signals);
+  EXPECT_FALSE(tab_lifecycle_unit.CanReloadBloatedTab());
+}
+
 }  // namespace resource_coordinator

chrome/browser/resource_coordinator/tab_manager_browsertest.cc

@@ -118,6 +118,12 @@ class TabManagerTest : public InProcessBrowserTest {
         ->UpdateLifecycleState(mojom::LifecycleState::kFrozen);
   }
 
+  void ReloadBloatedTab(content::WebContents* contents) {
+    static_cast<TabLifecycleUnitSource::TabLifecycleUnit*>(
+        TabLifecycleUnitExternal::FromWebContents(contents))
+        ->ReloadBloatedTab();
+  }
+
   base::SimpleTestTickClock test_clock_;
   ScopedSetTickClockForTesting scoped_set_tick_clock_for_testing_;
 };
@@ -1115,6 +1121,25 @@ IN_PROC_BROWSER_TEST_F(TabManagerTest,
   EXPECT_TRUE(IsTabDiscarded(browser4->tab_strip_model()->GetWebContentsAt(1)));
 }
 
+// TODO(ulan): Enable the test after fixing crbug.com/850921.
+IN_PROC_BROWSER_TEST_F(TabManagerTest, DISABLED_ReloadBloatedTab) {
+  content::WindowedNotificationObserver load(
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::NotificationService::AllSources());
+  OpenURLParams url(GURL(chrome::kChromeUIAboutURL), content::Referrer(),
+                    WindowOpenDisposition::CURRENT_TAB,
+                    ui::PAGE_TRANSITION_TYPED, false);
+  browser()->OpenURL(url);
+  load.Wait();
+
+  content::WindowedNotificationObserver reload(
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::NotificationService::AllSources());
+  auto* tsm = browser()->tab_strip_model();
+  ReloadBloatedTab(tsm->GetWebContentsAt(0));
+  reload.Wait();
+}
+
 }  // namespace resource_coordinator
 
 #endif  // OS_WIN || OS_MAXOSX || OS_LINUX || defined(OS_CHROMEOS)

content/public/test/web_contents_tester.h

@@ -156,6 +156,9 @@ class WebContentsTester {
 
   // Resets the state around PauseSubresourceLoadingCalled.
   virtual void ResetPauseSubresourceLoadingCalled() = 0;
+
+  // Sets the return value of GetPageImportanceSignals().
+  virtual void SetPageImportanceSignals(PageImportanceSignals signals) = 0;
 };
 
 }  // namespace content

content/test/test_web_contents.cc

@@ -449,4 +449,8 @@ void TestWebContents::ResetPauseSubresourceLoadingCalled() {
   pause_subresource_loading_called_ = false;
 }
 
+void TestWebContents::SetPageImportanceSignals(PageImportanceSignals signals) {
+  page_importance_signals_ = signals;
+}
+
 }  // namespace content

content/test/test_web_contents.h

@@ -150,6 +150,8 @@ class TestWebContents : public WebContentsImpl, public WebContentsTester {
 
   void TestDidFinishLoad(const GURL& url);
 
+  void SetPageImportanceSignals(PageImportanceSignals signals) override;
+
  protected:
   // The deprecated WebContentsTester still needs to subclass this.
   explicit TestWebContents(BrowserContext* browser_context);

services/resource_coordinator/coordination_unit/process_coordination_unit_impl.cc

@@ -67,6 +67,10 @@ void ProcessCoordinationUnitImpl::SetPID(int64_t pid) {
   SetProperty(mojom::PropertyType::kPID, pid);
 }
 
+void ProcessCoordinationUnitImpl::OnRendererIsBloated() {
+  SendEvent(mojom::Event::kRendererIsBloated);
+}
+
 const std::set<FrameCoordinationUnitImpl*>&
 ProcessCoordinationUnitImpl::GetFrameCoordinationUnits() const {
   return frame_coordination_units_;
@@ -86,6 +90,11 @@ ProcessCoordinationUnitImpl::GetAssociatedPageCoordinationUnits() const {
   return page_cus;
 }
 
+void ProcessCoordinationUnitImpl::OnEventReceived(mojom::Event event) {
+  for (auto& observer : observers())
+    observer.OnProcessEventReceived(this, event);
+}
+
 void ProcessCoordinationUnitImpl::OnPropertyChanged(
     const mojom::PropertyType property_type,
     int64_t value) {

services/resource_coordinator/coordination_unit/process_coordination_unit_impl.h

@@ -35,6 +35,7 @@ class ProcessCoordinationUnitImpl
   void SetLaunchTime(base::Time launch_time) override;
   void SetMainThreadTaskLoadIsLow(bool main_thread_task_load_is_low) override;
   void SetPID(int64_t pid) override;
+  void OnRendererIsBloated() override;
 
   // Private implementation properties.
   void set_private_footprint_kb(uint64_t private_footprint_kb) {
@@ -54,6 +55,7 @@ class ProcessCoordinationUnitImpl
   friend class FrameCoordinationUnitImpl;
 
   // CoordinationUnitInterface implementation.
+  void OnEventReceived(mojom::Event event) override;
   void OnPropertyChanged(mojom::PropertyType property_type,
                          int64_t value) override;
 

services/resource_coordinator/observers/page_signal_generator_impl.cc

@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "base/metrics/histogram_macros.h"
 #include "services/resource_coordinator/coordination_unit/frame_coordination_unit_impl.h"
 #include "services/resource_coordinator/coordination_unit/page_coordination_unit_impl.h"
 #include "services/resource_coordinator/coordination_unit/process_coordination_unit_impl.h"
@@ -20,6 +21,24 @@ namespace resource_coordinator {
     receiver->METHOD(__VA_ARGS__);                                \
   });
 
+namespace {
+
+// These values are persisted to logs. Entries should not be renumbered and
+// numeric values should never be reused.
+enum class BloatedRendererHandlingInResourceCoordinator {
+  kForwardedToBrowser = 0,
+  kIgnoredDueToMultiplePages = 1,
+  kMaxValue = kIgnoredDueToMultiplePages
+};
+
+void RecordBloatedRendererHandling(
+    BloatedRendererHandlingInResourceCoordinator handling) {
+  UMA_HISTOGRAM_ENUMERATION("BloatedRenderer.HandlingInResourceCoordinator",
+                            handling);
+}
+
+}  // anonymous namespace
+
 // static
 constexpr base::TimeDelta PageSignalGeneratorImpl::kLoadedAndIdlingTimeout =
     base::TimeDelta::FromSeconds(1);
@@ -55,6 +74,7 @@ void PageSignalGeneratorImpl::AddReceiver(
 // Process CUs should be observed for:
 // 1- kExpectedTaskQueueingDuration property for reporting EQT
 // 2- kMainThreadTaskLoadIsLow property changes for PageAlmostIdle detection
+// 3- kRendererIsBloated event for reloading bloated pages.
 bool PageSignalGeneratorImpl::ShouldObserve(
     const CoordinationUnitBase* coordination_unit) {
   auto cu_type = coordination_unit->id().type;
@@ -175,6 +195,26 @@ void PageSignalGeneratorImpl::OnPageEventReceived(
   page_data->idling_timer.Stop();
 }
 
+void PageSignalGeneratorImpl::OnProcessEventReceived(
+    const ProcessCoordinationUnitImpl* process_cu,
+    const mojom::Event event) {
+  if (event == mojom::Event::kRendererIsBloated) {
+    std::set<PageCoordinationUnitImpl*> page_cus =
+        process_cu->GetAssociatedPageCoordinationUnits();
+    // Currently bloated renderer handling supports only a single page.
+    if (page_cus.size() == 1u) {
+      auto* page_cu = *page_cus.begin();
+      DISPATCH_PAGE_SIGNAL(receivers_, NotifyRendererIsBloated, page_cu->id());
+      RecordBloatedRendererHandling(
+          BloatedRendererHandlingInResourceCoordinator::kForwardedToBrowser);
+    } else {
+      RecordBloatedRendererHandling(
+          BloatedRendererHandlingInResourceCoordinator::
+              kIgnoredDueToMultiplePages);
+    }
+  }
+}
+
 void PageSignalGeneratorImpl::BindToInterface(
     resource_coordinator::mojom::PageSignalGeneratorRequest request,
     const service_manager::BindSourceInfo& source_info) {

services/resource_coordinator/observers/page_signal_generator_impl.h

@@ -64,6 +64,8 @@ class PageSignalGeneratorImpl : public CoordinationUnitGraphObserver,
                             const mojom::Event event) override;
   void OnPageEventReceived(const PageCoordinationUnitImpl* page_cu,
                            const mojom::Event event) override;
+  void OnProcessEventReceived(const ProcessCoordinationUnitImpl* page_cu,
+                              const mojom::Event event) override;
 
   void BindToInterface(
       resource_coordinator::mojom::PageSignalGeneratorRequest request,

services/resource_coordinator/observers/page_signal_generator_impl_unittest.cc

@@ -7,6 +7,8 @@
 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/resource_coordinator/coordination_unit/coordination_unit_test_harness.h"
 #include "services/resource_coordinator/coordination_unit/frame_coordination_unit_impl.h"
 #include "services/resource_coordinator/coordination_unit/mock_coordination_unit_graphs.h"
@@ -18,6 +20,8 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
+
 namespace resource_coordinator {
 
 class MockPageSignalGeneratorImpl : public PageSignalGeneratorImpl {
@@ -50,6 +54,7 @@ class MockPageSignalReceiver : public mojom::PageSignalReceiver {
                          mojom::LifecycleState) override {}
   MOCK_METHOD1(NotifyNonPersistentNotificationCreated,
                void(const CoordinationUnitID& page_cu_id));
+  MOCK_METHOD1(NotifyRendererIsBloated, void(const CoordinationUnitID& cu_id));
 
  private:
   mojo::Binding<mojom::PageSignalReceiver> binding_;
@@ -309,4 +314,40 @@ TEST_F(PageSignalGeneratorImplTest, NonPersistentNotificationCreatedEvent) {
   ::testing::Mock::VerifyAndClear(&mock_receiver);
 }
 
+TEST_F(PageSignalGeneratorImplTest, NotifyRendererIsBloatedSinglePage) {
+  MockSinglePageInSingleProcessCoordinationUnitGraph cu_graph(
+      coordination_unit_graph());
+  auto* process = cu_graph.process.get();
+  auto* psg = page_signal_generator();
+
+  // Create a mock receiver and register it against the psg.
+  mojom::PageSignalReceiverPtr mock_receiver_ptr;
+  MockPageSignalReceiver mock_receiver(mojo::MakeRequest(&mock_receiver_ptr));
+  psg->AddReceiver(std::move(mock_receiver_ptr));
+
+  base::RunLoop run_loop;
+  EXPECT_CALL(mock_receiver, NotifyRendererIsBloated(_));
+  process->OnRendererIsBloated();
+  run_loop.RunUntilIdle();
+  ::testing::Mock::VerifyAndClear(&mock_receiver);
+}
+
+TEST_F(PageSignalGeneratorImplTest, NotifyRendererIsBloatedMultiplePages) {
+  MockMultiplePagesInSingleProcessCoordinationUnitGraph cu_graph(
+      coordination_unit_graph());
+  auto* process = cu_graph.process.get();
+  auto* psg = page_signal_generator();
+
+  // Create a mock receiver and register it against the psg.
+  mojom::PageSignalReceiverPtr mock_receiver_ptr;
+  MockPageSignalReceiver mock_receiver(mojo::MakeRequest(&mock_receiver_ptr));
+  psg->AddReceiver(std::move(mock_receiver_ptr));
+
+  base::RunLoop run_loop;
+  EXPECT_CALL(mock_receiver, NotifyRendererIsBloated(_)).Times(0);
+  process->OnRendererIsBloated();
+  run_loop.RunUntilIdle();
+  ::testing::Mock::VerifyAndClear(&mock_receiver);
+}
+
 }  // namespace resource_coordinator

services/resource_coordinator/public/mojom/coordination_unit.mojom

@@ -108,6 +108,12 @@ interface ProcessCoordinationUnit {
   SetLaunchTime(mojo_base.mojom.Time launch_time);
   SetMainThreadTaskLoadIsLow(bool main_thread_task_load_is_low);
   SetPID(int64 pid);
+
+  // Event signals.
+
+  // Fired when one of the renderer heaps is about to exceed its limit.
+  // If nothing is done, then the renderer is likely to crash with OOM.
+  OnRendererIsBloated();
 };
 
 // There is exactly one SystemCoordinationUnit at all times.

services/resource_coordinator/public/mojom/page_signal.mojom

@@ -16,6 +16,7 @@ import "mojo/public/mojom/base/time.mojom";
 // PageSignalGenerator::AddReceiver.
 interface PageSignalReceiver {
   NotifyPageAlmostIdle(CoordinationUnitID page_cu_id);
+  NotifyRendererIsBloated(CoordinationUnitID page_cu_id);
   SetExpectedTaskQueueingDuration(CoordinationUnitID page_cu_id,
                                   mojo_base.mojom.TimeDelta duration);
   SetLifecycleState(CoordinationUnitID page_cu_id,

services/resource_coordinator/public/mojom/signals.mojom

@@ -17,6 +17,8 @@ enum Event {
   // This signal is sent to a SystemCU when all ProcessCU CPU usage estimates
   // have been updated and are coherent.
   kProcessCPUUsageReady,
+  // This signal is set to the renderer ProcessCU.
+  kRendererIsBloated,
 };
 
 // Defines the Storage property keys that can be get/set on the

third_party/blink/renderer/controller/bloated_renderer_detector.cc

@@ -5,6 +5,7 @@
 #include "third_party/blink/renderer/controller/bloated_renderer_detector.h"
 
 #include "third_party/blink/renderer/platform/bindings/v8_per_isolate_data.h"
+#include "third_party/blink/renderer/platform/instrumentation/resource_coordinator/renderer_resource_coordinator.h"
 
 namespace blink {
 
@@ -26,7 +27,7 @@ BloatedRendererDetector::OnNearV8HeapLimitOnMainThreadImpl() {
   if (uptime.InMinutes() < kMinimumUptimeInMinutes) {
     return NearV8HeapLimitHandling::kIgnoredDueToSmallUptime;
   }
-  // TODO(ulan): Send message to the browser.
+  RendererResourceCoordinator::Get().OnRendererIsBloated();
   return NearV8HeapLimitHandling::kForwardedToBrowser;
 }
 

third_party/blink/renderer/platform/instrumentation/resource_coordinator/renderer_resource_coordinator.cc

@@ -62,4 +62,10 @@ void RendererResourceCoordinator::SetMainThreadTaskLoadIsLow(
   service_->SetMainThreadTaskLoadIsLow(main_thread_task_load_is_low);
 }
 
+void RendererResourceCoordinator::OnRendererIsBloated() {
+  if (!service_)
+    return;
+  service_->OnRendererIsBloated();
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/instrumentation/resource_coordinator/renderer_resource_coordinator.h

@@ -30,6 +30,7 @@ class PLATFORM_EXPORT RendererResourceCoordinator
 
   void SetExpectedTaskQueueingDuration(base::TimeDelta);
   void SetMainThreadTaskLoadIsLow(bool);
+  void OnRendererIsBloated();
 
  protected:
   RendererResourceCoordinator();

tools/metrics/histograms/enums.xml

@@ -3311,6 +3311,17 @@ uploading your change for review.  These are checked by presubmit scripts.
   <int value="5" label="Blacklist disabled."/>
 </enum>
 
+<enum name="BloatedRendererHandlingInBrowser">
+  <int value="0" label="Reloaded the bloated tab"/>
+  <int value="1" label="Cannot reload the bloated tab"/>
+  <int value="2" label="Cannot shutdown the renderer process"/>
+</enum>
+
+<enum name="BloatedRendererHandlingInResourceCoordinator">
+  <int value="0" label="Forwarded handling to the browser process"/>
+  <int value="1" label="Ignored due to multiple pages in the renderer process"/>
+</enum>
+
 <enum name="BlobBrokenReason">
   <int value="0" label="Unknown"/>
   <int value="1" label="There is not enough memory to store this blob"/>

tools/metrics/histograms/histograms.xml

@@ -8742,6 +8742,23 @@ uploading your change for review.
   </summary>
 </histogram>
 
+<histogram name="BloatedRenderer.HandlingInBrowser"
+    enum="BloatedRendererHandlingInBrowser">
+  <owner>ulan@chromium.org</owner>
+  <summary>
+    Records how a bloated renderer was handled in the browser process.
+  </summary>
+</histogram>
+
+<histogram name="BloatedRenderer.HandlingInResourceCoordinator"
+    enum="BloatedRendererHandlingInResourceCoordinator">
+  <owner>ulan@chromium.org</owner>
+  <summary>
+    Records how a bloated renderer was handled in the resource coordinator
+    service.
+  </summary>
+</histogram>
+
 <histogram name="BloatedRenderer.V8.NearV8HeapLimitHandling"
     enum="NearV8HeapLimitHandling">
   <owner>ulan@chromium.org</owner>