TabContentsWrapper -> TabContents, part 31.

chrome/browser/task_manager/task_manager_resource_providers.cc

 // Copyright (c) 2012 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 19 matching lines @@
 #include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/tab_contents/background_contents.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 168 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTabContentsResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 // static
 gfx::ImageSkia* TaskManagerTabContentsResource::prerender_icon_ = NULL;
 
 TaskManagerTabContentsResource::TaskManagerTabContentsResource(
-    TabContentsWrapper* tab_contents)
+    TabContents* tab_contents)
     : TaskManagerRendererResource(
           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.GetImageSkiaNamed(IDR_PRERENDER);
   }
   for (BrowserList::const_iterator i = BrowserList::begin();
@@ skipping 82 matching lines @@
   else
     return cache.GetNameOfProfileAtIndex(index);
 }
 
 gfx::ImageSkia TaskManagerTabContentsResource::GetIcon() const {
   if (IsPrerendering())
     return *prerender_icon_;
   return tab_contents_->favicon_tab_helper()->GetFavicon();
 }
 
-TabContentsWrapper* TaskManagerTabContentsResource::GetTabContents() const {
+TabContents* 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_->web_contents()->GetURL().host());
   }
@@ skipping 22 matching lines @@
   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 WebContents's behalf, so ignore it.
   if (origin_pid)
     return NULL;
 
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
-  std::map<TabContentsWrapper*, TaskManagerTabContentsResource*>::iterator
-      res_iter = resources_.find(wrapper);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+  std::map<TabContents*, TaskManagerTabContentsResource*>::iterator
+      res_iter = resources_.find(tab_contents);
   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 TabContentsWrappers.
+  // Add all the existing TabContentses.
   for (TabContentsIterator iterator; !iterator.done(); ++iterator)
     Add(*iterator);
 
   // Then we register for notifications to get new tabs.
   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());
@@ skipping 19 matching lines @@
       this, chrome::NOTIFICATION_INSTANT_COMMITTED,
       content::NotificationService::AllBrowserContextsAndSources());
 
   // Delete all the resources.
   STLDeleteContainerPairSecondPointers(resources_.begin(), resources_.end());
 
   resources_.clear();
 }
 
 void TaskManagerTabContentsResourceProvider::AddToTaskManager(
-    TabContentsWrapper* tab_contents) {
+    TabContents* tab_contents) {
   TaskManagerTabContentsResource* resource =
       new TaskManagerTabContentsResource(tab_contents);
   resources_[tab_contents] = resource;
   task_manager_->AddResource(resource);
 }
 
-void TaskManagerTabContentsResourceProvider::Add(
-    TabContentsWrapper* tab_contents) {
+void TaskManagerTabContentsResourceProvider::Add(TabContents* tab_contents) {
   if (!updating_)
     return;
 
   // Don't add dead tabs or tabs that haven't yet connected.
   if (!tab_contents->web_contents()->GetRenderProcessHost()->GetHandle() ||
       !tab_contents->web_contents()->WillNotifyDisconnection()) {
     return;
   }
 
-  std::map<TabContentsWrapper*, TaskManagerTabContentsResource*>::const_iterator
+  std::map<TabContents*, TaskManagerTabContentsResource*>::const_iterator
       iter = resources_.find(tab_contents);
   if (iter != resources_.end()) {
     // The case may happen that we have added a WebContents 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.
     return;
   }
   AddToTaskManager(tab_contents);
 }
 
-void TaskManagerTabContentsResourceProvider::Remove(
-    TabContentsWrapper* tab_contents) {
+void TaskManagerTabContentsResourceProvider::Remove(TabContents* tab_contents) {
   if (!updating_)
     return;
-  std::map<TabContentsWrapper*, TaskManagerTabContentsResource*>::iterator
+  std::map<TabContents*, TaskManagerTabContentsResource*>::iterator
       iter = resources_.find(tab_contents);
   if (iter == resources_.end()) {
     // Since WebContents are destroyed asynchronously (see TabContentsCollector
     // in navigation_controller.cc), we can be notified of a tab being removed
     // that we don't know.  This can happen if the user closes a tab and quickly
     // opens the task manager, before the tab is actually destroyed.
     return;
   }
 
   // Remove the resource from the Task Manager.
   TaskManagerTabContentsResource* resource = iter->second;
   task_manager_->RemoveResource(resource);
   // And from the provider.
   resources_.erase(iter);
   // Finally, delete the resource.
   delete resource;
 }
 
-void TaskManagerTabContentsResourceProvider::Update(
-    TabContentsWrapper* tab_contents) {
+void TaskManagerTabContentsResourceProvider::Update(TabContents* tab_contents) {
   if (!updating_)
     return;
-  std::map<TabContentsWrapper*, TaskManagerTabContentsResource*>::iterator
+  std::map<TabContents*, TaskManagerTabContentsResource*>::iterator
       iter = resources_.find(tab_contents);
   DCHECK(iter != resources_.end());
   if (iter != resources_.end())
     iter->second->InstantCommitted();
 }
 
 void TaskManagerTabContentsResourceProvider::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  TabContentsWrapper* tab_contents;
+  TabContents* tab_contents;
   if (type == chrome::NOTIFICATION_INSTANT_COMMITTED) {
-    tab_contents = content::Source<TabContentsWrapper>(source).ptr();
+    tab_contents = content::Source<TabContents>(source).ptr();
   } else {
-    tab_contents = TabContentsWrapper::GetCurrentWrapperForContents(
+    tab_contents = TabContents::FromWebContents(
         content::Source<WebContents>(source).ptr());
   }
-  // A background page does not have a TabContentsWrapper.
+  // A background page does not have a TabContents.
   if (!tab_contents)
     return;
   switch (type) {
     case content::NOTIFICATION_WEB_CONTENTS_CONNECTED:
       Add(tab_contents);
       break;
     case content::NOTIFICATION_WEB_CONTENTS_SWAPPED:
       Remove(tab_contents);
       Add(tab_contents);
       break;
@@ skipping 977 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }