[Extensions] Update TabHelper to use ExtensionId

chrome/browser/extensions/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/tab_helper.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 64 matching lines @@
 
 namespace extensions {
 
 // A helper class to watch the progress of inline installation and update the
 // renderer. Owned by the TabHelper.
 class TabHelper::InlineInstallObserver : public InstallObserver {
  public:
   InlineInstallObserver(TabHelper* tab_helper,
                         content::BrowserContext* browser_context,
                         int routing_id,
-                        const std::string& extension_id,
+                        const ExtensionId& extension_id,
                         bool observe_download_progress,
                         bool observe_install_stage)
       : tab_helper_(tab_helper),
         routing_id_(routing_id),
         extension_id_(extension_id),
         observe_download_progress_(observe_download_progress),
         observe_install_stage_(observe_install_stage),
         install_observer_(this) {
     DCHECK(tab_helper);
     DCHECK(observe_download_progress || observe_install_stage);
     InstallTracker* install_tracker =
         InstallTrackerFactory::GetForBrowserContext(browser_context);
     if (install_tracker)
       install_observer_.Add(install_tracker);
   }
   ~InlineInstallObserver() override {}
 
  private:
   // InstallObserver:
-  void OnBeginExtensionDownload(const std::string& extension_id) override {
+  void OnBeginExtensionDownload(const ExtensionId& extension_id) override {
     SendInstallStageChangedMessage(extension_id,
                                    api::webstore::INSTALL_STAGE_DOWNLOADING);
   }
-  void OnDownloadProgress(const std::string& extension_id,
+  void OnDownloadProgress(const ExtensionId& extension_id,
                           int percent_downloaded) override {
     if (observe_download_progress_ && extension_id == extension_id_) {
       tab_helper_->Send(new ExtensionMsg_InlineInstallDownloadProgress(
           routing_id_, percent_downloaded));
     }
   }
-  void OnBeginCrxInstall(const std::string& extension_id) override {
+  void OnBeginCrxInstall(const ExtensionId& extension_id) override {
     SendInstallStageChangedMessage(extension_id,
                                    api::webstore::INSTALL_STAGE_INSTALLING);
   }
   void OnShutdown() override { install_observer_.RemoveAll(); }
 
-  void SendInstallStageChangedMessage(const std::string& extension_id,
+  void SendInstallStageChangedMessage(const ExtensionId& extension_id,
                                       api::webstore::InstallStage stage) {
     if (observe_install_stage_ && extension_id == extension_id_) {
       tab_helper_->Send(
           new ExtensionMsg_InlineInstallStageChanged(routing_id_, stage));
     }
   }
 
   // The owning TabHelper (guaranteed to be valid).
   TabHelper* const tab_helper_;
 
   // The routing id to use in sending IPC updates.
   int routing_id_;
 
   // The id of the extension to observe.
-  std::string extension_id_;
+  ExtensionId extension_id_;
 
   // Whether or not to observe download/install progress.
   const bool observe_download_progress_;
   const bool observe_install_stage_;
 
   ScopedObserver<InstallTracker, InstallObserver> install_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(InlineInstallObserver);
 };
 
@@ skipping 103 matching lines @@
   }
 
   UpdateExtensionAppIcon(extension_app_);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
       content::Source<TabHelper>(this),
       content::NotificationService::NoDetails());
 }
 
-void TabHelper::SetExtensionAppById(const std::string& extension_app_id) {
+void TabHelper::SetExtensionAppById(const ExtensionId& extension_app_id) {
   const Extension* extension = GetExtension(extension_app_id);
   if (extension)
     SetExtensionApp(extension);
 }
 
-void TabHelper::SetExtensionAppIconById(const std::string& extension_app_id) {
+void TabHelper::SetExtensionAppIconById(const ExtensionId& extension_app_id) {
   const Extension* extension = GetExtension(extension_app_id);
   if (extension)
     UpdateExtensionAppIcon(extension);
 }
 
 SkBitmap* TabHelper::GetExtensionAppIcon() {
   if (extension_app_icon_.empty())
     return NULL;
 
   return &extension_app_icon_;
@@ skipping 245 matching lines @@
 void TabHelper::OnContentScriptsExecuting(
     content::RenderFrameHost* host,
     const ScriptExecutionObserver::ExecutingScriptsMap& executing_scripts_map,
     const GURL& on_url) {
   FOR_EACH_OBSERVER(
       ScriptExecutionObserver,
       script_execution_observers_,
       OnScriptsExecuted(web_contents(), executing_scripts_map, on_url));
 }
 
-const Extension* TabHelper::GetExtension(const std::string& extension_app_id) {
+const Extension* TabHelper::GetExtension(const ExtensionId& extension_app_id) {
   if (extension_app_id.empty())
     return NULL;
 
   content::BrowserContext* context = web_contents()->GetBrowserContext();
   return ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
       extension_app_id);
 }
 
 void TabHelper::UpdateExtensionAppIcon(const Extension* extension) {
   extension_app_icon_.reset();
@@ skipping 31 matching lines @@
     web_contents()->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TAB);
   }
 }
 
 WindowController* TabHelper::GetExtensionWindowController() const  {
   return ExtensionTabUtil::GetWindowControllerOfTab(web_contents());
 }
 
 void TabHelper::OnReenableComplete(int install_id,
                                    int return_route_id,
-                                   const std::string& extension_id,
+                                   const ExtensionId& extension_id,
                                    ExtensionReenabler::ReenableResult result) {
   // Map the re-enable results to webstore-install results.
   webstore_install::Result webstore_result = webstore_install::SUCCESS;
   std::string error;
   switch (result) {
     case ExtensionReenabler::REENABLE_SUCCESS:
       break;  // already set
     case ExtensionReenabler::USER_CANCELED:
       webstore_result = webstore_install::USER_CANCELLED;
       error = "User canceled install.";
@@ skipping 11 matching lines @@
   OnInlineInstallComplete(install_id, return_route_id, extension_id,
                           result == ExtensionReenabler::REENABLE_SUCCESS, error,
                           webstore_result);
   // Note: ExtensionReenabler contained the callback with the curried-in
   // |extension_id|; delete it last.
   extension_reenabler_.reset();
 }
 
 void TabHelper::OnInlineInstallComplete(int install_id,
                                         int return_route_id,
-                                        const std::string& extension_id,
+                                        const ExtensionId& extension_id,
                                         bool success,
                                         const std::string& error,
                                         webstore_install::Result result) {
   DCHECK_EQ(1u, pending_inline_installations_.count(extension_id));
   pending_inline_installations_.erase(extension_id);
   install_observers_.erase(extension_id);
   Send(new ExtensionMsg_InlineWebstoreInstallResponse(
       return_route_id,
       install_id,
       success,
@@ skipping 45 matching lines @@
   }
 }
 
 void TabHelper::SetTabId(content::RenderFrameHost* render_frame_host) {
   render_frame_host->Send(
       new ExtensionMsg_SetTabId(render_frame_host->GetRoutingID(),
                                 SessionTabHelper::IdForTab(web_contents())));
 }
 
 }  // namespace extensions