Get rid of a bunch of tab_contents.h includes from chrome. These are all trivial changes to use W...

chrome/browser/task_manager/task_manager_resource_providers.cc

 // Copyright (c) 2011 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_manager/task_manager_resource_providers.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_child_process_host.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/browser/renderer_host/render_view_host.h"
-#include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/common/process_type.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_MACOSX)
@@ skipping 153 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTabContentsResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 // static
 SkBitmap* TaskManagerTabContentsResource::prerender_icon_ = NULL;
 
 TaskManagerTabContentsResource::TaskManagerTabContentsResource(
     TabContentsWrapper* tab_contents)
     : TaskManagerRendererResource(
-          tab_contents->tab_contents()->GetRenderProcessHost()->GetHandle(),
-          tab_contents->tab_contents()->GetRenderViewHost()),
+          tab_contents->web_contents()->GetRenderProcessHost()->GetHandle(),
+          tab_contents->web_contents()->GetRenderViewHost()),
       tab_contents_(tab_contents),
       is_instant_preview_(false) {
   if (!prerender_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     prerender_icon_ = rb.GetBitmapNamed(IDR_PRERENDER);
   }
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     if ((*i)->instant() &&
         (*i)->instant()->GetPreviewContents() == tab_contents_) {
@@ skipping 10 matching lines @@
   DCHECK(is_instant_preview_);
   is_instant_preview_ = false;
 }
 
 bool TaskManagerTabContentsResource::IsPrerendering() const {
   prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(
           tab_contents_->profile());
   return prerender_manager &&
          prerender_manager->IsWebContentsPrerendering(
-             tab_contents_->tab_contents());
+             tab_contents_->web_contents());
 }
 
 bool TaskManagerTabContentsResource::HostsExtension() const {
-  return tab_contents_->tab_contents()->GetURL().SchemeIs(
+  return tab_contents_->web_contents()->GetURL().SchemeIs(
       chrome::kExtensionScheme);
 }
 
 TaskManager::Resource::Type TaskManagerTabContentsResource::GetType() const {
   return HostsExtension() ? EXTENSION : RENDERER;
 }
 
 string16 TaskManagerTabContentsResource::GetTitle() const {
   // Fall back on the URL if there's no title.
-  TabContents* contents = tab_contents_->tab_contents();
+  WebContents* contents = tab_contents_->web_contents();
   string16 tab_title = contents->GetTitle();
   GURL url = contents->GetURL();
   if (tab_title.empty()) {
     tab_title = UTF8ToUTF16(url.spec());
     // Force URL to be LTR.
     tab_title = base::i18n::GetDisplayStringInLTRDirectionality(tab_title);
   } else {
     // Since the tab_title will be concatenated with
     // IDS_TASK_MANAGER_TAB_PREFIX, we need to explicitly set the tab_title to
     // be LTR format if there is no strong RTL charater in it. Otherwise, if
@@ skipping 43 matching lines @@
 
 TabContentsWrapper* TaskManagerTabContentsResource::GetTabContents() const {
   return tab_contents_;
 }
 
 const Extension* TaskManagerTabContentsResource::GetExtension() const {
   if (HostsExtension()) {
     ExtensionService* extension_service =
         tab_contents_->profile()->GetExtensionService();
     return extension_service->extensions()->GetByID(
-        tab_contents_->tab_contents()->GetURL().host());
+        tab_contents_->web_contents()->GetURL().host());
   }
 
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTabContentsResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerTabContentsResourceProvider::
     TaskManagerTabContentsResourceProvider(TaskManager* task_manager)
     :  updating_(false),
        task_manager_(task_manager) {
 }
 
 TaskManagerTabContentsResourceProvider::
     ~TaskManagerTabContentsResourceProvider() {
 }
 
 TaskManager::Resource* TaskManagerTabContentsResourceProvider::GetResource(
     int origin_pid,
     int render_process_host_id,
     int routing_id) {
-  TabContents* tab_contents =
-      tab_util::GetTabContentsByID(render_process_host_id, routing_id);
-  if (!tab_contents)  // Not one of our resource.
+  WebContents* web_contents =
+      tab_util::GetWebContentsByID(render_process_host_id, routing_id);
+  if (!web_contents)  // Not one of our resource.
     return NULL;
 
   // If an origin PID was specified then the request originated in a plugin
   // working on the TabContent's behalf, so ignore it.
   if (origin_pid)
     return NULL;
 
   TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents);
+      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
   std::map<TabContentsWrapper*, TaskManagerTabContentsResource*>::iterator
       res_iter = resources_.find(wrapper);
   if (res_iter == resources_.end()) {
     // Can happen if the tab was closed while a network request was being
     // performed.
     return NULL;
   }
   return res_iter->second;
 }
 
 void TaskManagerTabContentsResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
 
   // Add all the existing TabContents.
   for (TabContentsIterator iterator; !iterator.done(); ++iterator)
     Add(*iterator);
 
   // Then we register for notifications to get new tabs.
-  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_CONNECTED,
+  registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_SWAPPED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
                  content::NotificationService::AllBrowserContextsAndSources());
   // TAB_CONTENTS_DISCONNECTED should be enough to know when to remove a
   // resource.  This is an attempt at mitigating a crasher that seem to
   // indicate a resource is still referencing a deleted TabContents
   // (http://crbug.com/7321).
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, chrome::NOTIFICATION_INSTANT_COMMITTED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 void TaskManagerTabContentsResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
 
   // Then we unregister for notifications to get new tabs.
   registrar_.Remove(
-      this, content::NOTIFICATION_TAB_CONTENTS_CONNECTED,
+      this, content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Remove(
       this, content::NOTIFICATION_WEB_CONTENTS_SWAPPED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Remove(
       this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
       content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Remove(
       this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::NotificationService::AllBrowserContextsAndSources());
@@ skipping 14 matching lines @@
   resources_[tab_contents] = resource;
   task_manager_->AddResource(resource);
 }
 
 void TaskManagerTabContentsResourceProvider::Add(
     TabContentsWrapper* tab_contents) {
   if (!updating_)
     return;
 
   // Don't add dead tabs or tabs that haven't yet connected.
-  if (!tab_contents->tab_contents()->GetRenderProcessHost()->GetHandle() ||
-      !tab_contents->tab_contents()->WillNotifyDisconnection()) {
+  if (!tab_contents->web_contents()->GetRenderProcessHost()->GetHandle() ||
+      !tab_contents->web_contents()->WillNotifyDisconnection()) {
     return;
   }
 
   std::map<TabContentsWrapper*, TaskManagerTabContentsResource*>::const_iterator
       iter = resources_.find(tab_contents);
   if (iter != resources_.end()) {
     // The case may happen that we have added a TabContents as part of the
     // iteration performed during StartUpdating() call but the notification that
     // it has connected was not fired yet. So when the notification happens, we
     // already know about this tab and just ignore it.
@@ skipping 35 matching lines @@
   if (iter != resources_.end())
     iter->second->InstantCommitted();
 }
 
 void TaskManagerTabContentsResourceProvider::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   TabContentsWrapper* tab_contents;
   if (type == chrome::NOTIFICATION_INSTANT_COMMITTED) {
     tab_contents = content::Source<TabContentsWrapper>(source).ptr();
-  } else if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED ||
-             type == content::NOTIFICATION_WEB_CONTENTS_SWAPPED) {
-    WebContents* web_contents = content::Source<WebContents>(source).ptr();
-    tab_contents = TabContentsWrapper::GetCurrentWrapperForContents(
-        web_contents);
   } else {
     tab_contents = TabContentsWrapper::GetCurrentWrapperForContents(
-        content::Source<TabContents>(source).ptr());
+        content::Source<WebContents>(source).ptr());
   }
   // A background page does not have a TabContentsWrapper.
   if (!tab_contents)
     return;
   switch (type) {
-    case content::NOTIFICATION_TAB_CONTENTS_CONNECTED:
+    case content::NOTIFICATION_WEB_CONTENTS_CONNECTED:
       Add(tab_contents);
       break;
     case content::NOTIFICATION_WEB_CONTENTS_SWAPPED:
       Remove(tab_contents);
       Add(tab_contents);
       break;
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED:
       // If this DCHECK is triggered, it could explain http://crbug.com/7321 .
       DCHECK(resources_.find(tab_contents) ==
              resources_.end()) << "TAB_CONTENTS_DESTROYED with no associated "
@@ skipping 919 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }