TabContentsWrapper -> TabContents, part 12.

chrome/browser/extensions/extension_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/extension_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"
 #include "chrome/browser/extensions/extension_event_names.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_window_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(TOOLKIT_GTK)
 #include "ui/base/x/active_window_watcher_x.h"
@@ skipping 61 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 =
-            browser->GetTabContentsWrapperAt(i)->web_contents();
+        WebContents* contents = browser->GetTabContentsAt(i)->web_contents();
         int tab_id = ExtensionTabUtil::GetTabId(contents);
         tab_entries_[tab_id] = TabEntry();
       }
     }
   }
 
   initialized_ = true;
 }
 
 ExtensionBrowserEventRouter::ExtensionBrowserEventRouter(Profile* profile)
@@ skipping 25 matching lines @@
   browser->tab_strip_model()->AddObserver(this);
 
   // If this is a new window, it isn't ready at this point, so we register to be
   // notified when it is. If this is an existing window, this is a no-op that we
   // just do to reduce code complexity.
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
       content::Source<Browser>(browser));
 
   for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
     RegisterForTabNotifications(
-        browser->GetTabContentsWrapperAt(i)->web_contents());
+        browser->GetTabContentsAt(i)->web_contents());
   }
 }
 
 void ExtensionBrowserEventRouter::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
@@ skipping 101 matching lines @@
 
 void ExtensionBrowserEventRouter::TabCreatedAt(WebContents* contents,
                                                int index,
                                                bool active) {
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEventWithTab(profile, "", events::kOnTabCreated, contents, active);
 
   RegisterForTabNotifications(contents);
 }
 
-void ExtensionBrowserEventRouter::TabInsertedAt(TabContentsWrapper* contents,
+void ExtensionBrowserEventRouter::TabInsertedAt(TabContents* contents,
                                                 int index,
                                                 bool active) {
   // If tab is new, send created event.
   int tab_id = ExtensionTabUtil::GetTabId(contents->web_contents());
   if (!GetTabEntry(contents->web_contents())) {
     tab_entries_[tab_id] = TabEntry();
 
     TabCreatedAt(contents->web_contents(), index, active);
     return;
   }
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kNewWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents->web_contents())));
   object_args->Set(tab_keys::kNewPositionKey, Value::CreateIntegerValue(
       index));
   args.Append(object_args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabAttached, json_args);
 }
 
-void ExtensionBrowserEventRouter::TabDetachedAt(TabContentsWrapper* contents,
+void ExtensionBrowserEventRouter::TabDetachedAt(TabContents* contents,
                                                 int index) {
   if (!GetTabEntry(contents->web_contents())) {
     // The tab was removed. Don't send detach event.
     return;
   }
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(
       ExtensionTabUtil::GetTabId(contents->web_contents())));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kOldWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents->web_contents())));
   object_args->Set(tab_keys::kOldPositionKey, Value::CreateIntegerValue(
       index));
   args.Append(object_args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabDetached, json_args);
 }
 
 void ExtensionBrowserEventRouter::TabClosingAt(TabStripModel* tab_strip_model,
-                                               TabContentsWrapper* contents,
+                                               TabContents* contents,
                                                int index) {
   int tab_id = ExtensionTabUtil::GetTabId(contents->web_contents());
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->SetBoolean(tab_keys::kWindowClosing,
                           tab_strip_model->closing_all());
   args.Append(object_args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabRemoved, json_args);
 
   int removed_count = tab_entries_.erase(tab_id);
   DCHECK_GT(removed_count, 0);
 
   UnregisterForTabNotifications(contents->web_contents());
 }
 
 void ExtensionBrowserEventRouter::ActiveTabChanged(
-    TabContentsWrapper* old_contents,
-    TabContentsWrapper* new_contents,
+    TabContents* old_contents,
+    TabContents* new_contents,
     int index,
     bool user_gesture) {
   ListValue args;
   int tab_id = ExtensionTabUtil::GetTabId(new_contents->web_contents());
   args.Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(new_contents->web_contents())));
   args.Append(object_args);
@@ skipping 17 matching lines @@
 
 void ExtensionBrowserEventRouter::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];
-    TabContentsWrapper* contents = tab_strip_model->GetTabContentsAt(index);
+    TabContents* contents = tab_strip_model->GetTabContentsAt(index);
     if (!contents)
       break;
     int tab_id = ExtensionTabUtil::GetTabId(contents->web_contents());
     all->Append(Value::CreateIntegerValue(tab_id));
   }
 
   ListValue args;
   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);
   args.Append(select_info);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   // The onHighlighted event replaced onHighlightChanged.
   Profile* profile = tab_strip_model->profile();
   DispatchEvent(profile, events::kOnTabHighlightChanged, json_args);
   DispatchEvent(profile, events::kOnTabHighlighted, json_args);
 }
 
-void ExtensionBrowserEventRouter::TabMoved(TabContentsWrapper* contents,
+void ExtensionBrowserEventRouter::TabMoved(TabContents* contents,
                                            int from_index,
                                            int to_index) {
   ListValue args;
   args.Append(Value::CreateIntegerValue(
       ExtensionTabUtil::GetTabId(contents->web_contents())));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents->web_contents())));
   object_args->Set(tab_keys::kFromIndexKey, Value::CreateIntegerValue(
@@ skipping 147 matching lines @@
     OnBrowserWindowReady(browser);
 #if defined(OS_MACOSX)
   } else if (type == content::NOTIFICATION_NO_KEY_WINDOW) {
     OnBrowserSetLastActive(NULL);
 #endif
   } else {
     NOTREACHED();
   }
 }
 
-void ExtensionBrowserEventRouter::TabChangedAt(TabContentsWrapper* contents,
+void ExtensionBrowserEventRouter::TabChangedAt(TabContents* contents,
                                                int index,
                                                TabChangeType change_type) {
   TabUpdated(contents->web_contents(), false);
 }
 
 void ExtensionBrowserEventRouter::TabReplacedAt(
     TabStripModel* tab_strip_model,
-    TabContentsWrapper* old_contents,
-    TabContentsWrapper* new_contents,
+    TabContents* old_contents,
+    TabContents* new_contents,
     int index) {
   TabClosingAt(tab_strip_model, old_contents, index);
   TabInsertedAt(new_contents, index, tab_strip_model->active_index() == index);
 }
 
 void ExtensionBrowserEventRouter::TabPinnedStateChanged(
-    TabContentsWrapper* contents,
+    TabContents* contents,
     int index) {
   TabStripModel* tab_strip = NULL;
   int tab_index;
 
   if (ExtensionTabUtil::GetTabStripModel(
         contents->web_contents(), &tab_strip, &tab_index)) {
     DictionaryValue* changed_properties = new DictionaryValue();
     changed_properties->SetBoolean(tab_keys::kPinnedKey,
                                    tab_strip->IsTabPinned(tab_index));
     DispatchTabUpdatedEvent(contents->web_contents(), changed_properties);
@@ skipping 20 matching lines @@
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   DispatchEventToExtension(profile, extension_id, "pageActions", json_args);
 }
 
 void ExtensionBrowserEventRouter::BrowserActionExecuted(
     const std::string& extension_id, Browser* browser) {
   Profile* profile = browser->profile();
-  TabContentsWrapper* tab_contents = NULL;
+  TabContents* tab_contents = NULL;
   int tab_id = 0;
   if (!ExtensionTabUtil::GetDefaultTab(browser, &tab_contents, &tab_id))
     return;
   ExtensionActionExecuted(profile, extension_id, tab_contents);
 }
 
 void ExtensionBrowserEventRouter::PageActionExecuted(
     Profile* profile,
     const std::string& extension_id,
     const std::string& page_action_id,
     int tab_id,
     const std::string& url,
     int button) {
   DispatchOldPageActionEvent(profile, extension_id, page_action_id, tab_id, url,
                              button);
-  TabContentsWrapper* tab_contents = NULL;
+  TabContents* tab_contents = NULL;
   if (!ExtensionTabUtil::GetTabById(tab_id, profile, profile->IsOffTheRecord(),
                                     NULL, NULL, &tab_contents, NULL)) {
     return;
   }
   ExtensionActionExecuted(profile, extension_id, tab_contents);
 }
 
 void ExtensionBrowserEventRouter::CommandExecuted(
     Profile* profile,
     const std::string& extension_id,
     const std::string& command) {
   ListValue args;
   args.Append(Value::CreateStringValue(command));
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   DispatchEventToExtension(profile,
                            extension_id,
                            "experimental.keybinding.onCommand",
                            json_args);
 }
 
 void ExtensionBrowserEventRouter::ExtensionActionExecuted(
     Profile* profile,
     const std::string& extension_id,
-    TabContentsWrapper* tab_contents) {
+    TabContents* tab_contents) {
   const extensions::Extension* extension =
       profile->GetExtensionService()->GetExtensionById(extension_id, false);
   if (!extension)
     return;
 
   const char* event_name = NULL;
   switch (extension->declared_action_type()) {
     case ExtensionAction::TYPE_NONE:
       break;
     case ExtensionAction::TYPE_BROWSER:
       event_name = "browserAction.onClicked";
       break;
     case ExtensionAction::TYPE_PAGE:
       event_name = "pageAction.onClicked";
       break;
   }
 
   if (event_name) {
     DispatchEventWithTab(profile,
                          extension_id,
                          event_name,
                          tab_contents->web_contents(),
                          true);
   }
 }