Remove some TabContentses from extensions.

chrome/browser/extensions/browser_event_router.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/extensions/browser_event_router.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/extension_action/extension_page_actions_api_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
@@ skipping 71 matching lines @@
   // Init() can happen after the browser is running, so catch up with any
   // windows that already exist.
   for (BrowserList::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end(); ++iter) {
     RegisterForBrowserNotifications(*iter);
 
     // Also catch up our internal bookkeeping of tab entries.
     Browser* browser = *iter;
     if (browser->tab_strip_model()) {
       for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
-        WebContents* contents =
-            chrome::GetTabContentsAt(browser, i)->web_contents();
+        WebContents* contents = chrome::GetWebContentsAt(browser, i);
         int tab_id = ExtensionTabUtil::GetTabId(contents);
         tab_entries_[tab_id] = TabEntry();
       }
     }
   }
 
   initialized_ = true;
 }
 
 BrowserEventRouter::BrowserEventRouter(Profile* profile)
@@ skipping 10 matching lines @@
   RegisterForBrowserNotifications(browser);
 }
 
 void BrowserEventRouter::RegisterForBrowserNotifications(Browser* browser) {
   if (!profile_->IsSameProfile(browser->profile()))
     return;
   // Start listening to TabStripModel events for this browser.
   browser->tab_strip_model()->AddObserver(this);
 
   for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
-    RegisterForTabNotifications(
-        chrome::GetTabContentsAt(browser, i)->web_contents());
+    RegisterForTabNotifications(chrome::GetWebContentsAt(browser, i));
   }
 }
 
 void BrowserEventRouter::RegisterForTabNotifications(WebContents* contents) {
   registrar_.Add(
       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(&contents->GetController()));
 
   // Observing NOTIFICATION_WEB_CONTENTS_DESTROYED is necessary because it's
   // possible for tabs to be created, detached and then destroyed without
@@ skipping 152 matching lines @@
 
 void BrowserEventRouter::TabSelectionChanged(
     TabStripModel* tab_strip_model,
     const TabStripSelectionModel& old_model) {
   TabStripSelectionModel::SelectedIndices new_selection =
       tab_strip_model->selection_model().selected_indices();
   ListValue* all = new ListValue();
 
   for (size_t i = 0; i < new_selection.size(); ++i) {
     int index = new_selection[i];
-    TabContents* contents = tab_strip_model->GetTabContentsAt(index);
+    WebContents* contents = tab_strip_model->GetWebContentsAt(index);
     if (!contents)
       break;
-    int tab_id = ExtensionTabUtil::GetTabId(contents->web_contents());
+    int tab_id = ExtensionTabUtil::GetTabId(contents);
     all->Append(Value::CreateIntegerValue(tab_id));
   }
 
   scoped_ptr<ListValue> args(new ListValue());
   DictionaryValue* select_info = new DictionaryValue();
 
   select_info->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTabStripModel(tab_strip_model)));
 
   select_info->Set(tab_keys::kTabIdsKey, all);
@@ skipping 205 matching lines @@
   args->Append(data);
 
   DispatchEventToExtension(profile, extension_id, "pageActions", args.Pass(),
                            EventRouter::USER_GESTURE_ENABLED);
 }
 
 void BrowserEventRouter::BrowserActionExecuted(
     const ExtensionAction& browser_action,
     Browser* browser) {
   Profile* profile = browser->profile();
-  TabContents* tab_contents = NULL;
+  WebContents* web_contents = NULL;
   int tab_id = 0;
-  if (!ExtensionTabUtil::GetDefaultTab(browser, &tab_contents, &tab_id))
+  if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, &tab_id))
     return;
-  ExtensionActionExecuted(profile, browser_action, tab_contents);
+  ExtensionActionExecuted(profile, browser_action, web_contents);
 }
 
 void BrowserEventRouter::PageActionExecuted(Profile* profile,
                                             const ExtensionAction& page_action,
                                             int tab_id,
                                             const std::string& url,
                                             int button) {
   DispatchOldPageActionEvent(profile, page_action.extension_id(),
                              page_action.id(), tab_id, url, button);
-  TabContents* tab_contents = NULL;
+  WebContents* web_contents = NULL;
   if (!ExtensionTabUtil::GetTabById(tab_id, profile, profile->IsOffTheRecord(),
-                                    NULL, NULL, &tab_contents, NULL)) {
+                                    NULL, NULL, &web_contents, NULL)) {
     return;
   }
-  ExtensionActionExecuted(profile, page_action, tab_contents);
+  ExtensionActionExecuted(profile, page_action, web_contents);
 }
 
 void BrowserEventRouter::ScriptBadgeExecuted(
     Profile* profile,
     const ExtensionAction& script_badge,
     int tab_id) {
-  TabContents* tab_contents = NULL;
+  WebContents* web_contents = NULL;
   if (!ExtensionTabUtil::GetTabById(tab_id, profile, profile->IsOffTheRecord(),
-                                    NULL, NULL, &tab_contents, NULL)) {
+                                    NULL, NULL, &web_contents, NULL)) {
     return;
   }
-  ExtensionActionExecuted(profile, script_badge, tab_contents);
+  ExtensionActionExecuted(profile, script_badge, web_contents);
 }
 
 void BrowserEventRouter::CommandExecuted(Profile* profile,
                                          const std::string& extension_id,
                                          const std::string& command) {
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(Value::CreateStringValue(command));
 
   DispatchEventToExtension(profile,
                            extension_id,
                            "commands.onCommand",
                            args.Pass(),
                            EventRouter::USER_GESTURE_ENABLED);
 }
 
 void BrowserEventRouter::ExtensionActionExecuted(
     Profile* profile,
     const ExtensionAction& extension_action,
-    TabContents* tab_contents) {
+    WebContents* web_contents) {
   const char* event_name = NULL;
   switch (extension_action.action_type()) {
     case Extension::ActionInfo::TYPE_BROWSER:
       event_name = "browserAction.onClicked";
       break;
     case Extension::ActionInfo::TYPE_PAGE:
       event_name = "pageAction.onClicked";
       break;
     case Extension::ActionInfo::TYPE_SCRIPT_BADGE:
       event_name = "scriptBadge.onClicked";
       break;
   }
 
   if (event_name) {
     scoped_ptr<ListValue> args(new ListValue());
     DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
-        tab_contents->web_contents(),
+        web_contents,
         ExtensionTabUtil::INCLUDE_PRIVACY_SENSITIVE_FIELDS);
     args->Append(tab_value);
 
     DispatchEventToExtension(profile,
                              extension_action.extension_id(),
                              event_name,
                              args.Pass(),
                              EventRouter::USER_GESTURE_ENABLED);
   }
 }
 
 }  // namespace extensions