New Task Manager - Phase 1.3.2: Implement Tab Contents Task Providing

Part 3 of 3: Implementing a task-manager representation of WebContents
owned
by the TabStripModel.

R=nick@chromium.org
BUG=470990
TEST=browser_tests --gtest_filter=TabContentsTagTest.*

Committed: https://crrev.com/543b07d4fb0b807639e8d29a0249794f240db091
Cr-Commit-Position: refs/heads/master@{#337936}

Review URL: https://codereview.chromium.org/1212663002

Cr-Commit-Position: refs/heads/master@{#338101}

24 files changed, 616 insertions, 174 deletions

diff --git a/chrome/browser/prerender/prerender_browsertest.cc b/chrome/browser/prerender/prerender_browsertest.cc
index c08cfaa..7eb1e0f 100644
--- a/chrome/browser/prerender/prerender_browsertest.cc
+++ b/chrome/browser/prerender/prerender_browsertest.cc
@@ -49,9 +49,8 @@
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "chrome/browser/safe_browsing/test_database_manager.h"
-#include "chrome/browser/task_management/providers/task_provider_observer.h"
 #include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
-#include "chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h"
+#include "chrome/browser/task_management/task_management_browsertest_util.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
@@ -4088,92 +4087,58 @@ IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithNaCl,
 
 namespace {
 
-// Defines a test class for testing that will act as a mock task manager.
-class MockTaskManager : public task_management::TaskProviderObserver {
- public:
-  MockTaskManager() {}
-  ~MockTaskManager() override {}
-
-  // task_management::Task_providerObserver:
-  void TaskAdded(task_management::Task* task) override {
-    EXPECT_FALSE(ContainsKey(provided_tasks_, task));
-    provided_tasks_.insert(task);
-  }
-
-  void TaskRemoved(task_management::Task* task) override {
-    EXPECT_TRUE(ContainsKey(provided_tasks_, task));
-    provided_tasks_.erase(task);
-  }
-
-  base::string16 GetPrerenderTitlePrefix() const {
-    return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
-                                      base::string16());
-  }
-
-  const std::set<task_management::WebContentsTag*>& tracked_tags() const {
-    return task_management::WebContentsTagsManager::GetInstance()->
-        tracked_tags();
-  }
-
-  const std::set<task_management::Task*>& provided_tasks() const {
-    return provided_tasks_;
-  }
-
- private:
-  std::set<task_management::Task*> provided_tasks_;
+base::string16 GetPrerenderTitlePrefix() {
+  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
+                                    base::string16());
+}
 
-  DISALLOW_COPY_AND_ASSIGN(MockTaskManager);
-};
+const std::vector<task_management::WebContentsTag*>& GetTrackedTags() {
+  return task_management::WebContentsTagsManager::GetInstance()->
+      tracked_tags();
+}
 
 // Tests the correct recording of tags for the prerender WebContents.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, TaskManagementTagsBasic) {
-  MockTaskManager task_manager;
-  EXPECT_TRUE(task_manager.tracked_tags().empty());
+  // Browser tests start with a single tab.
+  EXPECT_EQ(1U, GetTrackedTags().size());
 
   // Start prerendering a page and make sure it's correctly tagged.
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
-  EXPECT_FALSE(task_manager.tracked_tags().empty());
-
-  // TODO(afakhry): Once we start tagging the tab contents the below tests
-  // must be changed.
-  EXPECT_EQ(1U, task_manager.tracked_tags().size());
+  EXPECT_EQ(2U, GetTrackedTags().size());
 
   // Swap in the prerendered content and make sure its tag is removed.
   NavigateToDestURL();
-  EXPECT_TRUE(task_manager.tracked_tags().empty());
+  EXPECT_EQ(1U, GetTrackedTags().size());
 }
 
 // Tests that the task manager will be provided by tasks that correspond to
 // prerendered WebContents.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, TaskManagementTasksProvided) {
-  MockTaskManager task_manager;
-  EXPECT_TRUE(task_manager.tracked_tags().empty());
+  task_management::MockWebContentsTaskManager task_manager;
+  // Browser tests start with a single tab.
+  EXPECT_EQ(1U, GetTrackedTags().size());
 
-  task_management::WebContentsTaskProvider provider;
-  provider.SetObserver(&task_manager);
+  task_manager.StartObserving();
 
-  // Still empty, no pre-existing tasks.
-  EXPECT_TRUE(task_manager.provided_tasks().empty());
+  // The pre-existing tab is provided.
+  EXPECT_EQ(1U, task_manager.tasks().size());
 
   // Start prerendering a page.
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
-  EXPECT_FALSE(task_manager.tracked_tags().empty());
 
-  // TODO(afakhry): The below may not be true after we support more tags.
-  EXPECT_EQ(1U, task_manager.tracked_tags().size());
-  ASSERT_EQ(1U, task_manager.provided_tasks().size());
+  EXPECT_EQ(2U, GetTrackedTags().size());
+  ASSERT_EQ(2U, task_manager.tasks().size());
 
-  const task_management::Task* task = *task_manager.provided_tasks().begin();
+  const task_management::Task* task = task_manager.tasks().back();
   EXPECT_EQ(task_management::Task::RENDERER, task->GetType());
   const base::string16 title = task->title();
-  const base::string16 expected_prefix = task_manager.GetPrerenderTitlePrefix();
+  const base::string16 expected_prefix = GetPrerenderTitlePrefix();
   EXPECT_TRUE(base::StartsWith(title,
                                expected_prefix,
                                base::CompareCase::INSENSITIVE_ASCII));
 
   NavigateToDestURL();
-  // TODO(afakhry): The below may not be true after we support more tags.
-  EXPECT_TRUE(task_manager.provided_tasks().empty());
+  EXPECT_EQ(1U, task_manager.tasks().size());
 }
 
 }  // namespace
diff --git a/chrome/browser/task_management/providers/web_contents/background_contents_tag_browsertest.cc b/chrome/browser/task_management/providers/web_contents/background_contents_tag_browsertest.cc
index c70fa3b..ec17c4d 100644
--- a/chrome/browser/task_management/providers/web_contents/background_contents_tag_browsertest.cc
+++ b/chrome/browser/task_management/providers/web_contents/background_contents_tag_browsertest.cc
@@ -4,9 +4,8 @@
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
-#include "chrome/browser/task_management/providers/task_provider_observer.h"
 #include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
-#include "chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h"
+#include "chrome/browser/task_management/task_management_browsertest_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/switches.h"
@@ -18,9 +17,7 @@ namespace task_management {
 // properly and the TagsManager records these tags. It is also used to test that
 // the WebContentsTaskProvider will be able to provide the appropriate
 // BackgroundContentsTask.
-class BackgroundContentsTagTest
-    : public ExtensionBrowserTest,
-      public TaskProviderObserver {
+class BackgroundContentsTagTest : public ExtensionBrowserTest {
  public:
   BackgroundContentsTagTest() {}
   ~BackgroundContentsTagTest() override {}
@@ -37,109 +34,92 @@ class BackgroundContentsTagTest
                                       base::UTF8ToUTF16(extension->name()));
   }
 
-  // task_management::Task_providerObserver:
-  void TaskAdded(Task* task) override {
-    CHECK(task);
-    ASSERT_FALSE(provided_tasks_.count(task));
-    provided_tasks_.insert(task);
-  }
-
-  void TaskRemoved(Task* task) override {
-    CHECK(task);
-    ASSERT_TRUE(provided_tasks_.count(task));
-    provided_tasks_.erase(task);
-  }
-
   WebContentsTagsManager* tags_manager() const {
     return WebContentsTagsManager::GetInstance();
   }
 
-  const std::set<Task*>& provided_tasks() const { return provided_tasks_; }
-
  protected:
-  // ExtensionApiTest:
+  // ExtensionBrowserTest:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Pass flags to make testing apps easier.
     ExtensionBrowserTest::SetUpCommandLine(command_line);
     test_data_dir_ = test_data_dir_.AppendASCII("api_test");
-    base::CommandLine::ForCurrentProcess()->AppendSwitch(
-        switches::kDisablePopupBlocking);
-    base::CommandLine::ForCurrentProcess()->AppendSwitch(
-        extensions::switches::kAllowHTTPBackgroundPage);
+    command_line->AppendSwitch(switches::kDisableRendererBackgrounding);
+    command_line->AppendSwitch(switches::kDisablePopupBlocking);
+    command_line->AppendSwitch(extensions::switches::kAllowHTTPBackgroundPage);
   }
 
  private:
-  std::set<Task*> provided_tasks_;
-
   DISALLOW_COPY_AND_ASSIGN(BackgroundContentsTagTest);
 };
 
 // Tests that loading an extension that has a background contents will result in
 // the tags manager recording a WebContentsTag.
 IN_PROC_BROWSER_TEST_F(BackgroundContentsTagTest, TagsManagerRecordsATag) {
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
-  EXPECT_TRUE(LoadBackgroundExtension());
-  EXPECT_FALSE(tags_manager()->tracked_tags().empty());
+  // Browser tests start with only one tab available.
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
+  auto extension = LoadBackgroundExtension();
+  ASSERT_NE(nullptr, extension);
+  EXPECT_EQ(2U, tags_manager()->tracked_tags().size());
+
+  // Unload the extension.
+  UnloadExtension(extension->id());
   EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
-  EXPECT_TRUE(provided_tasks().empty());
 }
 
 // Tests that background contents creation while the provider is being observed
 // will also provide tasks.
 IN_PROC_BROWSER_TEST_F(BackgroundContentsTagTest, TasksProvidedWhileObserving) {
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  MockWebContentsTaskManager task_manager;
+  EXPECT_TRUE(task_manager.tasks().empty());
+  // Browser tests start with only one tab available.
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 
-  WebContentsTaskProvider provider;
-  provider.SetObserver(this);
+  task_manager.StartObserving();
 
-  // Still empty, no pre-existing tasks.
-  EXPECT_TRUE(provided_tasks().empty());
+  // The pre-existing tab is provided.
+  EXPECT_EQ(1U, task_manager.tasks().size());
 
   auto extension = LoadBackgroundExtension();
   ASSERT_NE(nullptr, extension);
-  EXPECT_FALSE(tags_manager()->tracked_tags().empty());
-  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
-  EXPECT_FALSE(provided_tasks().empty());
-  EXPECT_EQ(1U, provided_tasks().size());
+  EXPECT_EQ(2U, tags_manager()->tracked_tags().size());
+  EXPECT_EQ(2U, task_manager.tasks().size());
 
-  // Now check the provided task.
-  const Task* task = *provided_tasks().begin();
+  // Now check the newly provided task.
+  const Task* task = task_manager.tasks().back();
   EXPECT_EQ(Task::RENDERER, task->GetType());
   EXPECT_EQ(GetBackgroundTaskExpectedName(extension), task->title());
 
   // Unload the extension.
   UnloadExtension(extension->id());
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  EXPECT_EQ(1U, task_manager.tasks().size());
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 }
 
 // Tests providing a pre-existing background task to the observing operation.
 IN_PROC_BROWSER_TEST_F(BackgroundContentsTagTest, PreExistingTasksAreProvided) {
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  MockWebContentsTaskManager task_manager;
+  EXPECT_TRUE(task_manager.tasks().empty());
+  // Browser tests start with only one tab available.
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
   auto extension = LoadBackgroundExtension();
   ASSERT_NE(nullptr, extension);
-  EXPECT_FALSE(tags_manager()->tracked_tags().empty());
-  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
+  EXPECT_EQ(2U, tags_manager()->tracked_tags().size());
 
-  WebContentsTaskProvider provider;
-  provider.SetObserver(this);
+  task_manager.StartObserving();
 
   // Pre-existing task will be provided to us.
-  EXPECT_FALSE(provided_tasks().empty());
-  EXPECT_EQ(1U, provided_tasks().size());
+  EXPECT_EQ(2U, task_manager.tasks().size());
 
   // Now check the provided task.
-  const Task* task = *provided_tasks().begin();
+  const Task* task = task_manager.tasks().back();
   EXPECT_EQ(Task::RENDERER, task->GetType());
   EXPECT_EQ(GetBackgroundTaskExpectedName(extension), task->title());
 
   // Unload the extension.
   UnloadExtension(extension->id());
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  EXPECT_EQ(1U, task_manager.tasks().size());
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 }
 
 }  // namespace task_management
diff --git a/chrome/browser/task_management/providers/web_contents/devtools_tag_browsertest.cc b/chrome/browser/task_management/providers/web_contents/devtools_tag_browsertest.cc
index 68fdb7d..c009d52 100644
--- a/chrome/browser/task_management/providers/web_contents/devtools_tag_browsertest.cc
+++ b/chrome/browser/task_management/providers/web_contents/devtools_tag_browsertest.cc
@@ -3,9 +3,8 @@
 // found in the LICENSE file.
 
 #include "chrome/browser/devtools/devtools_window_testing.h"
-#include "chrome/browser/task_management/providers/task_provider_observer.h"
 #include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
-#include "chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h"
+#include "chrome/browser/task_management/task_management_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
@@ -24,13 +23,10 @@ const char kTestPage2[] = "files/devtools/navigate_back.html";
 // properly by a DevToolsTag and that the TagsManager records these tags. It
 // will also test that the WebContentsTaskProvider will be able to provide the
 // appropriate DevToolsTask.
-class DevToolsTagTest
-    : public InProcessBrowserTest,
-      public TaskProviderObserver {
+class DevToolsTagTest : public InProcessBrowserTest {
  public:
   DevToolsTagTest()
-      : devtools_window_(nullptr),
-        provided_tasks_() {
+      : devtools_window_(nullptr) {
     CHECK(test_server()->Start());
   }
 
@@ -50,28 +46,12 @@ class DevToolsTagTest
     DevToolsWindowTesting::CloseDevToolsWindowSync(devtools_window_);
   }
 
-  // task_management::Task_providerObserver:
-  void TaskAdded(Task* task) override {
-    CHECK(task);
-    ASSERT_FALSE(provided_tasks_.count(task));
-    provided_tasks_.insert(task);
-  }
-
-  void TaskRemoved(Task* task) override {
-    CHECK(task);
-    ASSERT_TRUE(provided_tasks_.count(task));
-    provided_tasks_.erase(task);
-  }
-
   WebContentsTagsManager* tags_manager() const {
     return WebContentsTagsManager::GetInstance();
   }
 
-  const std::set<Task*>& provided_tasks() const { return provided_tasks_; }
-
  private:
   DevToolsWindow* devtools_window_;
-  std::set<Task*> provided_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsTagTest);
 };
@@ -79,52 +59,48 @@ class DevToolsTagTest
 // Tests that opening a DevToolsWindow will result in tagging its main
 // WebContents and that tag will be recorded by the TagsManager.
 IN_PROC_BROWSER_TEST_F(DevToolsTagTest, TagsManagerRecordsATag) {
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  // Browser tests start with a single tab.
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 
-  // Loading a page will not result in tagging its WebContents.
-  // TODO(afakhry): Once we start tagging the tab contents, this will change.
-  // Fix it.
+  // Navigating the same tab to the test page won't change the number of tracked
+  // tags. No devtools yet.
   LoadTestPage(kTestPage1);
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 
   // Test both docked and undocked devtools.
   OpenDevToolsWindow(true);
-  EXPECT_FALSE(tags_manager()->tracked_tags().empty());
-  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
+  EXPECT_EQ(2U, tags_manager()->tracked_tags().size());
   CloseDevToolsWindow();
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 
   // For the undocked devtools there will be two tags one for the main contents
   // and one for the toolbox contents
   OpenDevToolsWindow(false);
-  EXPECT_FALSE(tags_manager()->tracked_tags().empty());
-  EXPECT_EQ(2U, tags_manager()->tracked_tags().size());
+  EXPECT_EQ(3U, tags_manager()->tracked_tags().size());
   CloseDevToolsWindow();
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 }
 
 IN_PROC_BROWSER_TEST_F(DevToolsTagTest, DevToolsTaskIsProvided) {
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  MockWebContentsTaskManager task_manager;
+  EXPECT_TRUE(task_manager.tasks().empty());
+  // Browser tests start with a single tab.
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
 
-  WebContentsTaskProvider provider;
-  provider.SetObserver(this);
+  task_manager.StartObserving();
 
-  // Still empty, no pre-existing tasks.
-  EXPECT_TRUE(provided_tasks().empty());
+  // The pre-existing tab is provided.
+  EXPECT_EQ(1U, task_manager.tasks().size());
 
   LoadTestPage(kTestPage1);
-  // TODO(afakhry): This will change soon.
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
+  EXPECT_EQ(1U, task_manager.tasks().size());
 
   OpenDevToolsWindow(true);
-  EXPECT_FALSE(tags_manager()->tracked_tags().empty());
-  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
-  EXPECT_FALSE(provided_tasks().empty());
-  EXPECT_EQ(1U, provided_tasks().size());
+  EXPECT_EQ(2U, tags_manager()->tracked_tags().size());
+  EXPECT_EQ(2U, task_manager.tasks().size());
 
-  const Task* task = *provided_tasks().begin();
+  const Task* task = task_manager.tasks().back();
   EXPECT_EQ(Task::RENDERER, task->GetType());
 
   // Navigating to a new page will not change the title of the devtools main
@@ -135,8 +111,8 @@ IN_PROC_BROWSER_TEST_F(DevToolsTagTest, DevToolsTaskIsProvided) {
   EXPECT_EQ(title1, title2);
 
   CloseDevToolsWindow();
-  EXPECT_TRUE(provided_tasks().empty());
-  EXPECT_TRUE(tags_manager()->tracked_tags().empty());
+  EXPECT_EQ(1U, tags_manager()->tracked_tags().size());
+  EXPECT_EQ(1U, task_manager.tasks().size());
 }
 
 }  // namespace task_management
diff --git a/chrome/browser/task_management/providers/web_contents/prerender_tag.cc b/chrome/browser/task_management/providers/web_contents/prerender_tag.cc
index 6e6ae3d..499756c 100644
--- a/chrome/browser/task_management/providers/web_contents/prerender_tag.cc
+++ b/chrome/browser/task_management/providers/web_contents/prerender_tag.cc
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include "chrome/browser/task_management/providers/web_contents/prerender_tag.h"
-#include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
 
 namespace task_management {
 
diff --git a/chrome/browser/task_management/providers/web_contents/renderer_task.cc b/chrome/browser/task_management/providers/web_contents/renderer_task.cc
index 33cef0e..32acdb1 100644
--- a/chrome/browser/task_management/providers/web_contents/renderer_task.cc
+++ b/chrome/browser/task_management/providers/web_contents/renderer_task.cc
@@ -11,9 +11,11 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/grit/generated_resources.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace task_management {
 
@@ -141,4 +143,29 @@ const gfx::ImageSkia* RendererTask::GetFaviconFromWebContents(
   return image.ToImageSkia();
 }
 
+// static
+const base::string16 RendererTask::PrefixRendererTitle(
+    const base::string16& title,
+    bool is_app,
+    bool is_extension,
+    bool is_incognito) {
+  int message_id = IDS_TASK_MANAGER_TAB_PREFIX;
+
+  if (is_incognito && !is_app && !is_extension) {
+    message_id = IDS_TASK_MANAGER_TAB_INCOGNITO_PREFIX;
+  } else if (is_app) {
+    if (is_incognito)
+      message_id = IDS_TASK_MANAGER_APP_INCOGNITO_PREFIX;
+    else
+      message_id = IDS_TASK_MANAGER_APP_PREFIX;
+  } else if (is_extension) {
+    if (is_incognito)
+      message_id = IDS_TASK_MANAGER_EXTENSION_INCOGNITO_PREFIX;
+    else
+      message_id = IDS_TASK_MANAGER_EXTENSION_PREFIX;
+  }
+
+  return l10n_util::GetStringFUTF16(message_id, title);
+}
+
 }  // namespace task_management
diff --git a/chrome/browser/task_management/providers/web_contents/renderer_task.h b/chrome/browser/task_management/providers/web_contents/renderer_task.h
index 5fcb445..ed88fd0 100644
--- a/chrome/browser/task_management/providers/web_contents/renderer_task.h
+++ b/chrome/browser/task_management/providers/web_contents/renderer_task.h
@@ -55,6 +55,13 @@ class RendererTask : public Task {
   static const gfx::ImageSkia* GetFaviconFromWebContents(
       content::WebContents* web_contents);
 
+  // Prefixes the given renderer |title| with the appropriate string based on
+  // whether it's an app, an extension, or incognito.
+  static const base::string16 PrefixRendererTitle(const base::string16& title,
+                                                  bool is_app,
+                                                  bool is_extension,
+                                                  bool is_incognito);
+
   content::WebContents* web_contents() const { return web_contents_; }
 
  private:
diff --git a/chrome/browser/task_management/providers/web_contents/tab_contents_tag.cc b/chrome/browser/task_management/providers/web_contents/tab_contents_tag.cc
new file mode 100644
index 0000000..9ac341c
--- /dev/null
+++ b/chrome/browser/task_management/providers/web_contents/tab_contents_tag.cc
@@ -0,0 +1,20 @@
+// 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/task_management/providers/web_contents/tab_contents_tag.h"
+
+namespace task_management {
+
+TabContentsTask* TabContentsTag::CreateTask() const {
+  return new TabContentsTask(web_contents());
+}
+
+TabContentsTag::TabContentsTag(content::WebContents* web_contents)
+    : WebContentsTag(web_contents) {
+}
+
+TabContentsTag::~TabContentsTag() {
+}
+
+}  // namespace task_management
diff --git a/chrome/browser/task_management/providers/web_contents/tab_contents_tag.h b/chrome/browser/task_management/providers/web_contents/tab_contents_tag.h
new file mode 100644
index 0000000..777a62f
--- /dev/null
+++ b/chrome/browser/task_management/providers/web_contents/tab_contents_tag.h
@@ -0,0 +1,30 @@
+// 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.
+
+#ifndef CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_TAB_CONTENTS_TAG_H_
+#define CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_TAB_CONTENTS_TAG_H_
+
+#include "chrome/browser/task_management/providers/web_contents/tab_contents_task.h"
+#include "chrome/browser/task_management/providers/web_contents/web_contents_tag.h"
+
+namespace task_management {
+
+// Defines a concrete UserData type for WebContents owned by the TabStripModel.
+class TabContentsTag : public WebContentsTag {
+ public:
+  // task_management::WebContentsTag:
+  TabContentsTask* CreateTask() const override;
+
+ private:
+  friend class WebContentsTags;
+
+  explicit TabContentsTag(content::WebContents* web_contents);
+  ~TabContentsTag() override;
+
+  DISALLOW_COPY_AND_ASSIGN(TabContentsTag);
+};
+
+}  // namespace task_management
+
+#endif  // CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_TAB_CONTENTS_TAG_H_
diff --git a/chrome/browser/task_management/providers/web_contents/tab_contents_tag_browsertest.cc b/chrome/browser/task_management/providers/web_contents/tab_contents_tag_browsertest.cc
new file mode 100644
index 0000000..77ea415
--- /dev/null
+++ b/chrome/browser/task_management/providers/web_contents/tab_contents_tag_browsertest.cc
@@ -0,0 +1,200 @@
+// 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/strings/utf_string_conversions.h"
+#include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
+#include "chrome/browser/task_management/task_management_browsertest_util.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 "net/test/embedded_test_server/embedded_test_server.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/page_transition_types.h"
+
+namespace task_management {
+
+namespace {
+
+// Defines a test page file path along with its expected task manager reported
+// values.
+struct TestPageData {
+  const char* page_file;
+  const char* title;
+  Task::Type task_type;
+  int expected_prefix_message;
+};
+
+// The below test files are available in src/chrome/test/data/
+// TODO(afakhry): Add more test pages here as needed (e.g. pages that are hosted
+// in the tabs as apps or extensions).
+const TestPageData kTestPages[] = {
+    {
+        "/title1.html",
+        "",
+        Task::RENDERER,
+        IDS_TASK_MANAGER_TAB_PREFIX
+    },
+    {
+        "/title2.html",
+        "Title Of Awesomeness",
+        Task::RENDERER,
+        IDS_TASK_MANAGER_TAB_PREFIX
+    },
+    {
+        "/title3.html",
+        "Title Of More Awesomeness",
+        Task::RENDERER,
+        IDS_TASK_MANAGER_TAB_PREFIX
+    },
+};
+
+const size_t kTestPagesLength = arraysize(kTestPages);
+
+}  // namespace
+
+// Defines a browser test class for testing the task manager tracking of tab
+// contents.
+class TabContentsTagTest : public InProcessBrowserTest {
+ public:
+  TabContentsTagTest() {
+    EXPECT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  }
+  ~TabContentsTagTest() override {}
+
+  void AddNewTestTabAt(int index, const char* test_page_file) {
+    int tabs_count_before = tabs_count();
+    GURL url = GetUrlOfFile(test_page_file);
+    AddTabAtIndex(index, url, ui::PAGE_TRANSITION_TYPED);
+    EXPECT_EQ(++tabs_count_before, tabs_count());
+  }
+
+  void NavigateToUrl(const char* test_page_file) {
+    ui_test_utils::NavigateToURL(browser(), GetUrlOfFile(test_page_file));
+  }
+
+  void CloseTabAt(int index) {
+    browser()->tab_strip_model()->CloseWebContentsAt(index,
+                                                     TabStripModel::CLOSE_NONE);
+  }
+
+  base::string16 GetTestPageExpectedTitle(const TestPageData& page_data) const {
+    // Pages with no title should fall back to their URL.
+    base::string16 title = base::UTF8ToUTF16(page_data.title);
+    if (title.empty()) {
+      GURL url = GetUrlOfFile(page_data.page_file);
+      title = base::UTF8ToUTF16(url.spec());
+    }
+    return l10n_util::GetStringFUTF16(page_data.expected_prefix_message, title);
+  }
+
+  base::string16 GetAboutBlankExpectedTitle() const {
+    return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_TAB_PREFIX,
+                                      base::UTF8ToUTF16("about:blank"));
+  }
+
+  int tabs_count() const { return browser()->tab_strip_model()->count(); }
+
+  const std::vector<WebContentsTag*>& tracked_tags() const {
+    return WebContentsTagsManager::GetInstance()->tracked_tags();
+  }
+
+ private:
+  GURL GetUrlOfFile(const char* test_page_file) const {
+    return embedded_test_server()->GetURL(test_page_file);
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(TabContentsTagTest);
+};
+
+// Tests that TabContentsTags are being recorded correctly by the
+// WebContentsTagsManager.
+IN_PROC_BROWSER_TEST_F(TabContentsTagTest, BasicTagsTracking) {
+  // Browser tests start with a single tab.
+  EXPECT_EQ(1, tabs_count());
+  EXPECT_EQ(1U, tracked_tags().size());
+
+  // Add a bunch of tabs and make sure we're tracking them.
+  AddNewTestTabAt(0, kTestPages[0].page_file);
+  EXPECT_EQ(2, tabs_count());
+  EXPECT_EQ(2U, tracked_tags().size());
+
+  AddNewTestTabAt(1, kTestPages[1].page_file);
+  EXPECT_EQ(3, tabs_count());
+  EXPECT_EQ(3U, tracked_tags().size());
+
+  // Navigating the selected tab doesn't change the number of tabs nor the
+  // number of tags.
+  NavigateToUrl(kTestPages[2].page_file);
+  EXPECT_EQ(3, tabs_count());
+  EXPECT_EQ(3U, tracked_tags().size());
+
+  // Close a bunch of tabs and make sure we can notice that.
+  CloseTabAt(0);
+  CloseTabAt(0);
+  EXPECT_EQ(1, tabs_count());
+  EXPECT_EQ(1U, tracked_tags().size());
+}
+
+// Tests that the pre-task-manager-existing tabs are given to the task manager
+// once it starts observing.
+IN_PROC_BROWSER_TEST_F(TabContentsTagTest, PreExistingTaskProviding) {
+  // We start with the "about:blank" tab.
+  EXPECT_EQ(1, tabs_count());
+  EXPECT_EQ(1U, tracked_tags().size());
+
+  // Add a bunch of tabs and make sure when the task manager is created and
+  // starts observing sees those pre-existing tabs.
+  AddNewTestTabAt(0, kTestPages[0].page_file);
+  EXPECT_EQ(2, tabs_count());
+  EXPECT_EQ(2U, tracked_tags().size());
+  AddNewTestTabAt(1, kTestPages[1].page_file);
+  EXPECT_EQ(3, tabs_count());
+  EXPECT_EQ(3U, tracked_tags().size());
+
+  MockWebContentsTaskManager task_manager;
+  EXPECT_TRUE(task_manager.tasks().empty());
+  task_manager.StartObserving();
+  EXPECT_EQ(3U, task_manager.tasks().size());
+}
+
+// Tests that the task manager sees the correct tabs with their correct
+// corresponding tasks data.
+IN_PROC_BROWSER_TEST_F(TabContentsTagTest, PostExistingTaskProviding) {
+  // We start with the "about:blank" tab.
+  EXPECT_EQ(1, tabs_count());
+  EXPECT_EQ(1U, tracked_tags().size());
+
+  MockWebContentsTaskManager task_manager;
+  EXPECT_TRUE(task_manager.tasks().empty());
+  task_manager.StartObserving();
+  EXPECT_EQ(1U, task_manager.tasks().size());
+
+  const Task* first_tab_task = task_manager.tasks()[0];
+  EXPECT_EQ(Task::RENDERER, first_tab_task->GetType());
+  EXPECT_EQ(GetAboutBlankExpectedTitle(), first_tab_task->title());
+
+  // Add the test pages in order and test the provided tasks.
+  for (auto& test_page_data : kTestPages) {
+    AddNewTestTabAt(0, test_page_data.page_file);
+
+    const Task* task = task_manager.tasks().back();
+    EXPECT_EQ(test_page_data.task_type, task->GetType());
+    EXPECT_EQ(GetTestPageExpectedTitle(test_page_data), task->title());
+  }
+
+  EXPECT_EQ(1 + kTestPagesLength, task_manager.tasks().size());
+
+  // Close the last tab that was added. Make sure it doesn't show up in the
+  // task manager.
+  CloseTabAt(0);
+  EXPECT_EQ(kTestPagesLength, task_manager.tasks().size());
+  const base::string16 closed_tab_title =
+      GetTestPageExpectedTitle(kTestPages[kTestPagesLength - 1]);
+  for (auto& task : task_manager.tasks())
+    EXPECT_NE(closed_tab_title, task->title());
+}
+
+}  // namespace task_management
diff --git a/chrome/browser/task_management/providers/web_contents/tab_contents_task.cc b/chrome/browser/task_management/providers/web_contents/tab_contents_task.cc
new file mode 100644
index 0000000..fdca98d
--- /dev/null
+++ b/chrome/browser/task_management/providers/web_contents/tab_contents_task.cc
@@ -0,0 +1,75 @@
+// 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/task_management/providers/web_contents/tab_contents_task.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/web_contents.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/process_map.h"
+#include "extensions/common/constants.h"
+
+namespace task_management {
+
+namespace {
+
+bool HostsExtension(content::WebContents* web_contents) {
+  DCHECK(web_contents);
+  return web_contents->GetURL().SchemeIs(extensions::kExtensionScheme);
+}
+
+}  // namespace
+
+
+TabContentsTask::TabContentsTask(content::WebContents* web_contents)
+    : RendererTask(base::string16(),
+                   RendererTask::GetFaviconFromWebContents(web_contents),
+                   web_contents) {
+  set_title(GetCurrentTitle());
+}
+
+TabContentsTask::~TabContentsTask() {
+}
+
+void TabContentsTask::OnTitleChanged(content::NavigationEntry* entry) {
+  set_title(GetCurrentTitle());
+}
+
+void TabContentsTask::OnFaviconChanged() {
+  set_icon(*RendererTask::GetFaviconFromWebContents(web_contents()));
+}
+
+Task::Type TabContentsTask::GetType() const {
+  // A tab that loads an extension URL is considered to be an extension even
+  // though it's tracked as a TabContentsTask.
+  return HostsExtension(web_contents()) ? Task::EXTENSION : Task::RENDERER;
+}
+
+base::string16 TabContentsTask::GetCurrentTitle() const {
+  // Check if the URL is an app and if the tab is hoisting an extension.
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents()->GetBrowserContext());
+  extensions::ProcessMap* process_map = extensions::ProcessMap::Get(profile);
+  extensions::ExtensionRegistry* extension_registry =
+      extensions::ExtensionRegistry::Get(profile);
+  GURL url = web_contents()->GetURL();
+  base::string16 url_spec = base::UTF8ToUTF16(url.spec());
+
+  bool is_app = process_map->Contains(process_id()) &&
+      extension_registry->enabled_extensions().GetAppByURL(url) != nullptr;
+  bool is_extension = HostsExtension(web_contents());
+  bool is_incognito = profile->IsOffTheRecord();
+
+  base::string16 tab_title =
+      RendererTask::GetTitleFromWebContents(web_contents());
+
+  // Fall back to the URL if the title is empty.
+  return PrefixRendererTitle(tab_title.empty() ? url_spec : tab_title,
+                             is_app,
+                             is_extension,
+                             is_incognito);
+}
+
+}  // namespace task_management
diff --git a/chrome/browser/task_management/providers/web_contents/tab_contents_task.h b/chrome/browser/task_management/providers/web_contents/tab_contents_task.h
new file mode 100644
index 0000000..2005967
--- /dev/null
+++ b/chrome/browser/task_management/providers/web_contents/tab_contents_task.h
@@ -0,0 +1,32 @@
+// 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.
+
+#ifndef CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_TAB_CONTENTS_TASK_H_
+#define CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_TAB_CONTENTS_TASK_H_
+
+#include "chrome/browser/task_management/providers/web_contents/renderer_task.h"
+
+namespace task_management {
+
+// Defines a task manager representation of WebContents owned by the
+// TabStripModel.
+class TabContentsTask : public RendererTask {
+ public:
+  explicit TabContentsTask(content::WebContents* web_contents);
+  ~TabContentsTask() override;
+
+  // task_management::RendererTask:
+  void OnTitleChanged(content::NavigationEntry* entry) override;
+  void OnFaviconChanged() override;
+  Type GetType() const override;
+
+ private:
+  base::string16 GetCurrentTitle() const;
+
+  DISALLOW_COPY_AND_ASSIGN(TabContentsTask);
+};
+
+}  // namespace task_management
+
+#endif  // CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_TAB_CONTENTS_TASK_H_
diff --git a/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.cc b/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.cc
index 44d0c64..8c13df2 100644
--- a/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.cc
+++ b/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.cc
@@ -16,7 +16,7 @@ WebContentsTagsManager* WebContentsTagsManager::GetInstance() {
 
 void WebContentsTagsManager::AddTag(WebContentsTag* tag) {
   DCHECK(tag);
-  tracked_tags_.insert(tag);
+  tracked_tags_.push_back(tag);
 
   if (provider_)
     provider_->OnWebContentsTagCreated(tag);
@@ -24,7 +24,9 @@ void WebContentsTagsManager::AddTag(WebContentsTag* tag) {
 
 void WebContentsTagsManager::RemoveTag(WebContentsTag* tag) {
   DCHECK(tag);
-  tracked_tags_.erase(tag);
+  tracked_tags_.erase(std::find(tracked_tags_.begin(),
+                                tracked_tags_.end(),
+                                tag));
 
   // No need to inform the provider here. The provider will create an entry
   // for each WebContents it's tracking which is a WebContentsObserver and
diff --git a/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h b/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h
index da4a315..81aaa91 100644
--- a/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h
+++ b/chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h
@@ -5,7 +5,7 @@
 #ifndef CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_WEB_CONTENTS_TAGS_MANAGER_H_
 #define CHROME_BROWSER_TASK_MANAGEMENT_PROVIDERS_WEB_CONTENTS_WEB_CONTENTS_TAGS_MANAGER_H_
 
-#include <set>
+#include <vector>
 
 #include "chrome/browser/task_management/providers/web_contents/web_contents_tag.h"
 
@@ -39,7 +39,7 @@ class WebContentsTagsManager {
   // or else the corresponding task for the |tag| will continue to exist.
   void ClearFromProvider(const WebContentsTag* tag);
 
-  const std::set<WebContentsTag*>& tracked_tags() const {
+  const std::vector<WebContentsTag*>& tracked_tags() const {
     return tracked_tags_;
   }
 
@@ -53,7 +53,7 @@ class WebContentsTagsManager {
   WebContentsTaskProvider* provider_;
 
   // A set of all the WebContentsTags seen so far.
-  std::set<WebContentsTag*> tracked_tags_;
+  std::vector<WebContentsTag*> tracked_tags_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsTagsManager);
 };
diff --git a/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.cc b/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.cc
index 4c24931..fa93a16 100644
--- a/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.cc
+++ b/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.cc
@@ -255,11 +255,15 @@ void WebContentsEntry::ClearTaskForFrame(RenderFrameHost* render_frame_host) {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-WebContentsTaskProvider::WebContentsTaskProvider() : entries_map_() {
+WebContentsTaskProvider::WebContentsTaskProvider()
+    : entries_map_(),
+      is_updating_(false) {
 }
 
 WebContentsTaskProvider::~WebContentsTaskProvider() {
-  STLDeleteValues(&entries_map_);
+  if (is_updating_) {
+    StopUpdating();
+  }
 }
 
 void WebContentsTaskProvider::OnWebContentsTagCreated(
@@ -328,6 +332,8 @@ bool WebContentsTaskProvider::HasWebContents(
 }
 
 void WebContentsTaskProvider::StartUpdating() {
+  is_updating_ = true;
+
   // 1- Collect all pre-existing WebContents from the WebContentsTagsManager.
   WebContentsTagsManager* tags_manager = WebContentsTagsManager::GetInstance();
   for (auto& tag : tags_manager->tracked_tags())
@@ -338,6 +344,8 @@ void WebContentsTaskProvider::StartUpdating() {
 }
 
 void WebContentsTaskProvider::StopUpdating() {
+  is_updating_ = false;
+
   // 1- Stop observing.
   WebContentsTagsManager::GetInstance()->ClearProvider();
 
diff --git a/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h b/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h
index cc9c7f3..aeff7cc 100644
--- a/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h
+++ b/chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h
@@ -58,6 +58,10 @@ class WebContentsTaskProvider : public TaskProvider {
   typedef std::map<content::WebContents*, WebContentsEntry*> EntryMap;
   EntryMap entries_map_;
 
+  // True if this provider is listening to WebContentsTags and updating its
+  // observers, false otherwise.
+  bool is_updating_;
+
   DISALLOW_COPY_AND_ASSIGN(WebContentsTaskProvider);
 };
 
diff --git a/chrome/browser/task_management/task_management_browsertest_util.cc b/chrome/browser/task_management/task_management_browsertest_util.cc
new file mode 100644
index 0000000..a644a57
--- /dev/null
+++ b/chrome/browser/task_management/task_management_browsertest_util.cc
@@ -0,0 +1,39 @@
+// 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/task_management/task_management_browsertest_util.h"
+
+#include "base/stl_util.h"
+
+namespace task_management {
+
+MockWebContentsTaskManager::MockWebContentsTaskManager()
+    : tasks_(),
+      provider_() {
+}
+
+MockWebContentsTaskManager::~MockWebContentsTaskManager() {
+}
+
+void MockWebContentsTaskManager::TaskAdded(Task* task) {
+  DCHECK(task);
+  DCHECK(!ContainsValue(tasks_, task));
+  tasks_.push_back(task);
+}
+
+void MockWebContentsTaskManager::TaskRemoved(Task* task) {
+  DCHECK(task);
+  DCHECK(ContainsValue(tasks_, task));
+  tasks_.erase(std::find(tasks_.begin(), tasks_.end(), task));
+}
+
+void MockWebContentsTaskManager::StartObserving() {
+  provider_.SetObserver(this);
+}
+
+void MockWebContentsTaskManager::StopObserving() {
+  provider_.ClearObserver();
+}
+
+}  // namespace task_management
diff --git a/chrome/browser/task_management/task_management_browsertest_util.h b/chrome/browser/task_management/task_management_browsertest_util.h
new file mode 100644
index 0000000..6ba4855
--- /dev/null
+++ b/chrome/browser/task_management/task_management_browsertest_util.h
@@ -0,0 +1,40 @@
+// 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.
+
+#ifndef CHROME_BROWSER_TASK_MANAGEMENT_TASK_MANAGEMENT_BROWSERTEST_UTIL_H_
+#define CHROME_BROWSER_TASK_MANAGEMENT_TASK_MANAGEMENT_BROWSERTEST_UTIL_H_
+
+#include "chrome/browser/task_management/providers/task_provider_observer.h"
+#include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
+#include "chrome/browser/task_management/providers/web_contents/web_contents_task_provider.h"
+
+namespace task_management {
+
+// Defines a test class that will act as a task manager that is designed to
+// only observe the WebContents-based tasks.
+class MockWebContentsTaskManager : public TaskProviderObserver {
+ public:
+  MockWebContentsTaskManager();
+  ~MockWebContentsTaskManager() override;
+
+  // task_management::TaskProviderObserver:
+  void TaskAdded(Task* task) override;
+  void TaskRemoved(Task* task) override;
+
+  // Start / Stop observing the WebContentsTaskProvider.
+  void StartObserving();
+  void StopObserving();
+
+  const std::vector<Task*>& tasks() const { return tasks_; }
+
+ private:
+  std::vector<Task*> tasks_;
+  WebContentsTaskProvider provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockWebContentsTaskManager);
+};
+
+}  // namespace task_management
+
+#endif  // CHROME_BROWSER_TASK_MANAGEMENT_TASK_MANAGEMENT_BROWSERTEST_UTIL_H_
diff --git a/chrome/browser/task_management/web_contents_tags.cc b/chrome/browser/task_management/web_contents_tags.cc
index 9371a0d..1e5a720 100644
--- a/chrome/browser/task_management/web_contents_tags.cc
+++ b/chrome/browser/task_management/web_contents_tags.cc
@@ -7,6 +7,7 @@
 #include "chrome/browser/task_management/providers/web_contents/background_contents_tag.h"
 #include "chrome/browser/task_management/providers/web_contents/devtools_tag.h"
 #include "chrome/browser/task_management/providers/web_contents/prerender_tag.h"
+#include "chrome/browser/task_management/providers/web_contents/tab_contents_tag.h"
 #include "chrome/browser/task_management/providers/web_contents/web_contents_tags_manager.h"
 #include "content/public/browser/web_contents.h"
 
@@ -70,6 +71,17 @@ void WebContentsTags::CreateForPrerenderContents(
 }
 
 // static
+void WebContentsTags::CreateForTabContents(content::WebContents* web_contents) {
+#if defined(ENABLE_TASK_MANAGER)
+  if (!WebContentsTag::FromWebContents(web_contents)) {
+    TagWebContents(web_contents,
+                   new TabContentsTag(web_contents),
+                   WebContentsTag::kTagKey);
+  }
+#endif  // defined(ENABLE_TASK_MANAGER)
+}
+
+// static
 void WebContentsTags::ClearTag(content::WebContents* web_contents) {
 #if defined(ENABLE_TASK_MANAGER)
   const WebContentsTag* tag = WebContentsTag::FromWebContents(web_contents);
diff --git a/chrome/browser/task_management/web_contents_tags.h b/chrome/browser/task_management/web_contents_tags.h
index 3c92939..c2794f6 100644
--- a/chrome/browser/task_management/web_contents_tags.h
+++ b/chrome/browser/task_management/web_contents_tags.h
@@ -46,6 +46,13 @@ class WebContentsTags {
   // owned by |web_contents|.
   static void CreateForPrerenderContents(content::WebContents* web_contents);
 
+  // Tag a WebContents owned by the TabStripModel so that it shows up in the
+  // task manager. Calling this function creates a TabContentsTag, and attaches
+  // it to |web_contents|. If an instance is already attached, this does
+  // nothing. The resulting tag does not have to be cleaned up by the caller, as
+  // it is owned by |web_contents|.
+  static void CreateForTabContents(content::WebContents* web_contents);
+
   // Clears the task-manager tag, created by any of the above functions, from
   // the given |web_contents| if any.
   // Clearing the tag is necessary only when you need to re-tag an existing
diff --git a/chrome/browser/ui/browser.cc b/chrome/browser/ui/browser.cc
index 8805274..242f79b 100644
--- a/chrome/browser/ui/browser.cc
+++ b/chrome/browser/ui/browser.cc
@@ -84,6 +84,7 @@
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/browser/tab_contents/retargeting_details.h"
 #include "chrome/browser/tab_contents/tab_util.h"
+#include "chrome/browser/task_management/web_contents_tags.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/translate/chrome_translate_client.h"
@@ -1691,6 +1692,9 @@ void Browser::WebContentsCreated(WebContents* source_contents,
   // AddNewContents.
   TabHelpers::AttachTabHelpers(new_contents);
 
+  // Make the tab show up in the task manager.
+  task_management::WebContentsTags::CreateForTabContents(new_contents);
+
   // Notify.
   RetargetingDetails details;
   details.source_web_contents = source_contents;
diff --git a/chrome/browser/ui/browser_navigator.cc b/chrome/browser/ui/browser_navigator.cc
index 7be37f7..fbd9415 100644
--- a/chrome/browser/ui/browser_navigator.cc
+++ b/chrome/browser/ui/browser_navigator.cc
@@ -17,6 +17,7 @@
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
+#include "chrome/browser/task_management/web_contents_tags.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
@@ -59,6 +60,9 @@ class BrowserNavigatorWebContentsAdoption {
  public:
   static void AttachTabHelpers(content::WebContents* contents) {
     TabHelpers::AttachTabHelpers(contents);
+
+    // Make the tab show up in the task manager.
+    task_management::WebContentsTags::CreateForTabContents(contents);
   }
 };
 
diff --git a/chrome/browser/ui/browser_tab_strip_model_delegate.cc b/chrome/browser/ui/browser_tab_strip_model_delegate.cc
index 3fcd438..dcf1492 100644
--- a/chrome/browser/ui/browser_tab_strip_model_delegate.cc
+++ b/chrome/browser/ui/browser_tab_strip_model_delegate.cc
@@ -10,6 +10,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
+#include "chrome/browser/task_management/web_contents_tags.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_navigator.h"
@@ -85,6 +86,9 @@ Browser* BrowserTabStripModelDelegate::CreateNewStripWithContents(
 void BrowserTabStripModelDelegate::WillAddWebContents(
     content::WebContents* contents) {
   TabHelpers::AttachTabHelpers(contents);
+
+  // Make the tab show up in the task manager.
+  task_management::WebContentsTags::CreateForTabContents(contents);
 }
 
 int BrowserTabStripModelDelegate::GetDragActions() const {
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index d05eee0..9a22d16 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -3019,6 +3019,10 @@
       'browser/task_management/providers/web_contents/renderer_task.h',
       'browser/task_management/providers/web_contents/subframe_task.cc',
       'browser/task_management/providers/web_contents/subframe_task.h',
+      'browser/task_management/providers/web_contents/tab_contents_tag.cc',
+      'browser/task_management/providers/web_contents/tab_contents_tag.h',
+      'browser/task_management/providers/web_contents/tab_contents_task.cc',
+      'browser/task_management/providers/web_contents/tab_contents_task.h',
       'browser/task_management/providers/web_contents/web_contents_tag.cc',
       'browser/task_management/providers/web_contents/web_contents_tag.h',
       'browser/task_management/providers/web_contents/web_contents_tags_manager.cc',
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index f5c869f..142639a 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -406,6 +406,9 @@
       'browser/tab_contents/view_source_browsertest.cc',
       'browser/task_management/providers/web_contents/background_contents_tag_browsertest.cc',
       'browser/task_management/providers/web_contents/devtools_tag_browsertest.cc',
+      'browser/task_management/providers/web_contents/tab_contents_tag_browsertest.cc',
+      'browser/task_management/task_management_browsertest_util.cc',
+      'browser/task_management/task_management_browsertest_util.h',
       'browser/task_manager/task_manager_browsertest.cc',
       'browser/task_manager/task_manager_browsertest_util.cc',
       'browser/task_manager/task_manager_browsertest_util.h',