Switch ScriptBadgeController and PageActionController to use WebContents.

chrome/browser/extensions/script_badge_controller.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/script_badge_controller.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/extensions/browser_event_router.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace extensions {
 
-ScriptBadgeController::ScriptBadgeController(TabContents* tab_contents,
+ScriptBadgeController::ScriptBadgeController(content::WebContents* web_contents,
                                              ScriptExecutor* script_executor)
     : ScriptExecutor::Observer(script_executor),
-      content::WebContentsObserver(tab_contents->web_contents()),
-      tab_contents_(tab_contents) {
+      content::WebContentsObserver(web_contents) {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(tab_contents->profile()));
+                 content::Source<Profile>(profile));
 }
 
 ScriptBadgeController::~ScriptBadgeController() {}
 
 std::vector<ExtensionAction*> ScriptBadgeController::GetCurrentActions() const {
   return current_actions_;
 }
 
 void ScriptBadgeController::GetAttentionFor(
     const std::string& extension_id) {
   ExtensionAction* script_badge = AddExtensionToCurrentActions(extension_id);
   if (!script_badge)
     return;
 
   // TODO(jyasskin): Modify the icon's appearance to indicate that the
   // extension is merely asking for permission to run:
   // http://crbug.com/133142
-  script_badge->SetAppearance(SessionID::IdForTab(tab_contents_),
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents());
+  script_badge->SetAppearance(SessionID::IdForTab(tab_contents),
                               ExtensionAction::WANTS_ATTENTION);
 
   NotifyChange();
 }
 
 LocationBarController::Action ScriptBadgeController::OnClicked(
     const std::string& extension_id, int mouse_button) {
   ExtensionService* service = GetExtensionService();
   if (!service)
     return ACTION_NONE;
 
   const Extension* extension = service->extensions()->GetByID(extension_id);
   CHECK(extension);
   ExtensionAction* script_badge = extension->script_badge();
   CHECK(script_badge);
 
   switch (mouse_button) {
-    case 1:  // left
-    case 2:  // middle
-      tab_contents_->extension_tab_helper()->active_tab_permission_manager()->
+    case 1:    // left
+    case 2: {  // middle
+      TabContents* tab_contents = TabContents::FromWebContents(web_contents());
+      tab_contents->extension_tab_helper()->active_tab_permission_manager()->
           GrantIfRequested(extension);
 
       // Even if clicking the badge doesn't immediately cause the extension to
       // run script on the page, we want to help users associate clicking with
       // the extension having permission to modify the page, so we make the icon
       // full-colored immediately.
-      if (script_badge->SetAppearance(SessionID::IdForTab(tab_contents_),
+      if (script_badge->SetAppearance(SessionID::IdForTab(tab_contents),
                                       ExtensionAction::ACTIVE))
         NotifyChange();
 
       // Fire the scriptBadge.onClicked event.
       GetExtensionService()->browser_event_router()->ScriptBadgeExecuted(
-          tab_contents_->profile(),
+          tab_contents->profile(),
           *script_badge,
-          SessionID::IdForTab(tab_contents_));
+          SessionID::IdForTab(tab_contents));
 
       // TODO(jyasskin): The fallback order should be user-defined popup ->
       // onClicked handler -> default popup.
       return ACTION_SHOW_SCRIPT_POPUP;
+    }
     case 3:  // right
       // Don't grant access on right clicks, so users can investigate
       // the extension without danger.
 
       return extension->ShowConfigureContextMenus() ?
           ACTION_SHOW_CONTEXT_MENU : ACTION_NONE;
   }
 
   return ACTION_NONE;
 }
@@ skipping 20 matching lines @@
         on_page_id,
         extension_id.c_str());
     char buf[1024];
     base::snprintf(buf, arraysize(buf), "%s", message.c_str());
     LOG(ERROR) << message;
     return;
   }
 }
 
 ExtensionService* ScriptBadgeController::GetExtensionService() {
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents());
   return extensions::ExtensionSystem::Get(
-      tab_contents_->profile())->extension_service();
+      tab_contents->profile())->extension_service();
 }
 
 int32 ScriptBadgeController::GetPageID() {
   content::NavigationEntry* nav_entry =
-      tab_contents_->web_contents()->GetController().GetActiveEntry();
+      web_contents()->GetController().GetActiveEntry();
   return nav_entry ? nav_entry->GetPageID() : -1;
 }
 
 void ScriptBadgeController::NotifyChange() {
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_LOCATION_BAR_UPDATED,
-      content::Source<Profile>(tab_contents_->profile()),
-      content::Details<TabContents>(tab_contents_));
+      content::Source<Profile>(tab_contents->profile()),
+      content::Details<content::WebContents>(web_contents()));
 }
 
 void ScriptBadgeController::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (details.is_in_page)
     return;
   extensions_in_current_actions_.clear();
   current_actions_.clear();
 }
@@ skipping 73 matching lines @@
   current_actions_.push_back(script_badge);
   return script_badge;
 }
 
 bool ScriptBadgeController::MarkExtensionExecuting(
     const std::string& extension_id) {
   ExtensionAction* script_badge = AddExtensionToCurrentActions(extension_id);
   if (!script_badge)
     return false;
 
-  script_badge->SetAppearance(SessionID::IdForTab(tab_contents_),
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents());
+  script_badge->SetAppearance(SessionID::IdForTab(tab_contents),
                               ExtensionAction::ACTIVE);
   return true;
 }
 
 bool ScriptBadgeController::EraseExtension(const Extension* extension) {
   if (extensions_in_current_actions_.erase(extension->id()) == 0)
     return false;
 
   size_t size_before = current_actions_.size();
 
   for (std::vector<ExtensionAction*>::iterator it = current_actions_.begin();
        it != current_actions_.end(); ++it) {
     // Safe to -> the extension action because we still have a handle to the
     // owner Extension.
     //
     // Also note that this means that when extensions are uninstalled their
     // script badges will disappear, even though they're still acting on the
     // page (since they would have already acted).
     if ((*it)->extension_id() == extension->id()) {
       current_actions_.erase(it);
       break;
     }
   }
 
   CHECK_EQ(size_before, current_actions_.size() + 1);
   return true;
 }
 
 }  // namespace extensions