Fix incorrect DCHECK in task manager's WebContentsEntry.

chrome/browser/task_manager/providers/web_contents/subframe_task_browsertest.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 "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/task_manager/mock_web_contents_task_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace task_manager {
 
 namespace {
@@ skipping 105 matching lines @@
   // iframes, we expect not to have any SubframeTasks.
   NavigateTo(kSimplePageUrl);
 
   ASSERT_EQ(1U, task_manager.tasks().size());
   const Task* simple_page_task = task_manager.tasks().front();
   EXPECT_EQ(Task::RENDERER, simple_page_task->GetType());
   EXPECT_EQ(PrefixExpectedTabTitle("Title Of Awesomeness"),
             simple_page_task->title());
 }
 
+// Allows listening to unresponsive task events.
+class HungWebContentsTaskManager : public MockWebContentsTaskManager {
+ public:
+  HungWebContentsTaskManager() : unresponsive_task_(nullptr) {}
+  void TaskUnresponsive(Task* task) override { unresponsive_task_ = task; }
+
+  Task* unresponsive_task() { return unresponsive_task_; }
+
+ private:
+  Task* unresponsive_task_;
+};
+
+// If sites are isolated, makes sure that subframe tasks can react to
+// unresponsive renderers.
+IN_PROC_BROWSER_TEST_F(SubframeTaskBrowserTest, TaskManagerHungSubframe) {
+  // This test only makes sense if we have subframe processes.
+  if (!content::AreAllSitesIsolatedForTesting())
+    return;
+
+  HungWebContentsTaskManager task_manager;
+  EXPECT_TRUE(task_manager.tasks().empty());
+  task_manager.StartObserving();
+
+  NavigateTo(kCrossSitePageUrl);
+
+  // We expect SubframeTasks for b.com and c.com, in either order.
+  ASSERT_EQ(3U, task_manager.tasks().size());
+  const Task* subframe_task_1 = task_manager.tasks()[1];
+  const Task* subframe_task_2 = task_manager.tasks()[2];
+
+  EXPECT_EQ(Task::RENDERER, subframe_task_1->GetType());
+  EXPECT_EQ(Task::RENDERER, subframe_task_2->GetType());
+
+  EXPECT_TRUE(base::StartsWith(subframe_task_1->title(),
+                               GetExpectedSubframeTitlePrefix(),
+                               base::CompareCase::INSENSITIVE_ASCII));
+  EXPECT_TRUE(base::StartsWith(subframe_task_2->title(),
+                               GetExpectedSubframeTitlePrefix(),
+                               base::CompareCase::INSENSITIVE_ASCII));
+
+  // Nothing should have hung yet.
+  EXPECT_EQ(nullptr, task_manager.unresponsive_task());
+
+  // Simulate a hang in one of the subframe processes.
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  std::vector<content::RenderFrameHost*> frames = web_contents->GetAllFrames();
+  content::RenderFrameHost* subframe1 = frames[1];
+  SimulateUnresponsiveRenderer(web_contents,
+                               subframe1->GetView()->GetRenderWidgetHost());
+
+  // Verify task_observer saw one of the two subframe tasks.  (There's a race,
+  // so it could be either one.)
+  Task* unresponsive_task = task_manager.unresponsive_task();
+  EXPECT_NE(nullptr, unresponsive_task);
+  EXPECT_TRUE(unresponsive_task == subframe_task_1 ||
+              unresponsive_task == subframe_task_2);
+}
+
 // A test for top document isolation and how subframes show up in the task
 // manager as SubframeTasks.
 class SubframeTaskTDIBrowserTest : public InProcessBrowserTest {
  public:
   SubframeTaskTDIBrowserTest() {}
   ~SubframeTaskTDIBrowserTest() override {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     InProcessBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kTopDocumentIsolation);
@@ skipping 56 matching lines @@
                                       base::UTF8ToUTF16(new_title));
   EXPECT_TRUE(ExecuteScript(web_contents, script));
   base::string16 actual_title = title_watcher.WaitAndGetTitle();
   EXPECT_EQ(new_title, base::UTF16ToUTF8(actual_title));
 
   EXPECT_EQ(PrefixExpectedTabTitle(new_title), main_task->title());
   EXPECT_EQ(PrefixExpectedTDIRowTitle(new_title), tdi_task->title());
 }
 
 }  // namespace task_manager