TabContentsWrapper -> TabContents, part 12.

chrome/browser/extensions/extension_tab_helper.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_tab_helper.h"
 
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/page_action_controller.h"
 #include "chrome/browser/extensions/script_badge_controller.h"
 #include "chrome/browser/extensions/script_executor_impl.h"
 #include "chrome/browser/extensions/webstore_inline_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/ui/browser.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/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/gfx/image/image.h"
 
 using content::WebContents;
 using extensions::Extension;
 using extensions::ScriptBadgeController;
 using extensions::ScriptExecutorImpl;
 using extensions::PageActionController;
 
 namespace {
 
 const char kPermissionError[] = "permission_error";
 
 }  // namespace
 
-ExtensionTabHelper::ExtensionTabHelper(TabContentsWrapper* wrapper)
-    : content::WebContentsObserver(wrapper->web_contents()),
+ExtensionTabHelper::ExtensionTabHelper(TabContents* tab_contents)
+    : content::WebContentsObserver(tab_contents->web_contents()),
       delegate_(NULL),
       extension_app_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          extension_function_dispatcher_(wrapper->profile(), this)),
-      wrapper_(wrapper) {
+          extension_function_dispatcher_(tab_contents->profile(), this)),
+      tab_contents_(tab_contents) {
   if (extensions::switch_utils::IsActionBoxEnabled()) {
-    script_badge_controller_ = new ScriptBadgeController(wrapper);
+    script_badge_controller_ = new ScriptBadgeController(tab_contents);
   } else {
-    script_executor_.reset(new ScriptExecutorImpl(wrapper->web_contents()));
-    location_bar_controller_.reset(new PageActionController(wrapper));
+    script_executor_.reset(
+        new ScriptExecutorImpl(tab_contents->web_contents()));
+    location_bar_controller_.reset(new PageActionController(tab_contents));
   }
 }
 
 ExtensionTabHelper::~ExtensionTabHelper() {
 }
 
 void ExtensionTabHelper::CopyStateFrom(const ExtensionTabHelper& source) {
   SetExtensionApp(source.extension_app());
   extension_app_icon_ = source.extension_app_icon_;
 }
@@ skipping 63 matching lines @@
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   ExtensionService* service = profile->GetExtensionService();
   if (!service)
     return;
 
   for (ExtensionSet::const_iterator it = service->extensions()->begin();
        it != service->extensions()->end(); ++it) {
     ExtensionAction* browser_action = (*it)->browser_action();
     if (browser_action) {
       browser_action->ClearAllValuesForTab(
-          wrapper_->restore_tab_helper()->session_id().id());
+          tab_contents_->restore_tab_helper()->session_id().id());
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
           content::Source<ExtensionAction>(browser_action),
           content::NotificationService::NoDetails());
     }
 
     ExtensionAction* page_action = (*it)->page_action();
     if (page_action) {
       page_action->ClearAllValuesForTab(
-          wrapper_->restore_tab_helper()->session_id().id());
+          tab_contents_->restore_tab_helper()->session_id().id());
       PageActionStateChanged();
     }
   }
 }
 
 bool ExtensionTabHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionTabHelper, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_DidGetApplicationInfo,
                         OnDidGetApplicationInfo)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_InstallApplication,
                         OnInstallApplication)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_InlineWebstoreInstall,
                         OnInlineWebstoreInstall)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_GetAppNotifyChannel,
                         OnGetAppNotifyChannel)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_GetAppInstallState,
                         OnGetAppInstallState);
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ExtensionTabHelper::OnDidGetApplicationInfo(
     int32 page_id, const WebApplicationInfo& info) {
   web_app_info_ = info;
 
   if (delegate_)
-    delegate_->OnDidGetApplicationInfo(wrapper_, page_id);
+    delegate_->OnDidGetApplicationInfo(tab_contents_, page_id);
 }
 
 void ExtensionTabHelper::OnInstallApplication(const WebApplicationInfo& info) {
   if (delegate_)
-    delegate_->OnInstallApplication(wrapper_, info);
+    delegate_->OnInstallApplication(tab_contents_, info);
 }
 
 void ExtensionTabHelper::OnInlineWebstoreInstall(
     int install_id,
     int return_route_id,
     const std::string& webstore_item_id,
     const GURL& requestor_url) {
   scoped_refptr<WebstoreInlineInstaller> installer(new WebstoreInlineInstaller(
       web_contents(),
       install_id,
       return_route_id,
       webstore_item_id,
       requestor_url,
       this));
   installer->BeginInstall();
 }
 
 void ExtensionTabHelper::OnGetAppNotifyChannel(
     const GURL& requestor_url,
     const std::string& client_id,
     int return_route_id,
     int callback_id) {
 
   // Check for permission first.
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   ExtensionService* extension_service = profile->GetExtensionService();
   extensions::ProcessMap* process_map = extension_service->process_map();
   content::RenderProcessHost* process =
-      tab_contents_wrapper()->web_contents()->GetRenderProcessHost();
+      tab_contents()->web_contents()->GetRenderProcessHost();
   const Extension* extension =
       extension_service->GetInstalledApp(requestor_url);
 
   std::string error;
   if (!extension ||
       !extension->HasAPIPermission(
           ExtensionAPIPermission::kAppNotifications) ||
       !process_map->Contains(extension->id(), process->GetID()))
     error = kPermissionError;
 
   // Make sure the extension can cross to the main profile, if called from an
   // an incognito window.
   if (profile->IsOffTheRecord() &&
       !extension_service->CanCrossIncognito(extension))
     error = extension_misc::kAppNotificationsIncognitoError;
 
   if (!error.empty()) {
     Send(new ExtensionMsg_GetAppNotifyChannelResponse(
         return_route_id, "", error, callback_id));
     return;
   }
 
   AppNotifyChannelUI* ui = new AppNotifyChannelUIImpl(
-      profile, tab_contents_wrapper(), extension->name(),
+      profile, tab_contents(), extension->name(),
       AppNotifyChannelUI::NOTIFICATION_INFOBAR);
 
   scoped_refptr<AppNotifyChannelSetup> channel_setup(
       new AppNotifyChannelSetup(profile,
                                 extension->id(),
                                 client_id,
                                 requestor_url,
                                 return_route_id,
                                 callback_id,
                                 ui,
@@ skipping 118 matching lines @@
 void ExtensionTabHelper::OnInlineInstallFailure(int install_id,
                                                 int return_route_id,
                                                 const std::string& error) {
   Send(new ExtensionMsg_InlineWebstoreInstallResponse(
       return_route_id, install_id, false, error));
 }
 
 WebContents* ExtensionTabHelper::GetAssociatedWebContents() const {
   return web_contents();
 }