Convert Web Store Inline Install IPCs to mojo

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/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/extensions/webstore_inline_installer.h"
 #include "chrome/browser/extensions/webstore_inline_installer_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/extensions/api/webstore/webstore_api_constants.h"
-#include "chrome/common/extensions/chrome_extension_messages.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 10 matching lines @@
 #include "extensions/browser/extension_web_contents_observer.h"
 #include "extensions/browser/image_loader.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "url/url_constants.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/web_applications/web_app_win.h"
 #endif
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::WebContents;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(extensions::TabHelper);
 
 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 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 ExtensionId& extension_id) override {
     SendInstallStageChangedMessage(extension_id,
                                    api::webstore::INSTALL_STAGE_DOWNLOADING);
   }
   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));
+      auto iter =
+          tab_helper_->inline_install_progress_listeners_.find(extension_id);
+      DCHECK(iter != tab_helper_->inline_install_progress_listeners_.end());
+      iter->second->InlineInstallDownloadProgress(percent_downloaded);
     }
   }
   void OnBeginCrxInstall(const ExtensionId& extension_id) override {
     SendInstallStageChangedMessage(extension_id,
                                    api::webstore::INSTALL_STAGE_INSTALLING);
   }
   void OnShutdown() override { install_observer_.RemoveAll(); }
 
   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));
+      auto iter =
+          tab_helper_->inline_install_progress_listeners_.find(extension_id);
+      DCHECK(iter != tab_helper_->inline_install_progress_listeners_.end());
+      iter->second->InlineInstallStageChanged(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.
   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);
 };
 
+TabHelper::~TabHelper() {
+  RemoveScriptExecutionObserver(ActivityLog::GetInstance(profile_));
+}
+
 TabHelper::TabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       extension_app_(NULL),
       pending_web_app_action_(NONE),
       last_committed_nav_entry_unique_id_(0),
       update_shortcut_on_load_complete_(false),
       script_executor_(
           new ScriptExecutor(web_contents, &script_execution_observers_)),
       extension_action_runner_(new ExtensionActionRunner(web_contents)),
       webstore_inline_installer_factory_(new WebstoreInlineInstallerFactory()),
       registry_observer_(this),
+      bindings_(web_contents, this),
       image_loader_ptr_factory_(this),
       weak_ptr_factory_(this) {
   // The ActiveTabPermissionManager requires a session ID; ensure this
   // WebContents has one.
   SessionTabHelper::CreateForWebContents(web_contents);
   // The Unretained() is safe because ForEachFrame is synchronous.
   web_contents->ForEachFrame(
       base::Bind(&TabHelper::SetTabId, base::Unretained(this)));
   active_tab_permission_granter_.reset(new ActiveTabPermissionGranter(
       web_contents,
@@ skipping 13 matching lines @@
       set_delegate(this);
 
   BookmarkManagerPrivateDragEventRouter::CreateForWebContents(web_contents);
 
   registrar_.Add(this,
                  content::NOTIFICATION_LOAD_STOP,
                  content::Source<NavigationController>(
                      &web_contents->GetController()));
 }
 
-TabHelper::~TabHelper() {
-  RemoveScriptExecutionObserver(ActivityLog::GetInstance(profile_));
-}
-
 void TabHelper::CreateHostedAppFromWebContents() {
   DCHECK(CanCreateBookmarkApp());
   if (pending_web_app_action_ != NONE)
     return;
 
   // Start fetching web app info for CreateApplicationShortcut dialog and show
   // the dialog when the data is available in OnDidGetApplicationInfo.
   GetApplicationInfo(CREATE_HOSTED_APP);
 }
 
@@ skipping 130 matching lines @@
                         OnDidGetWebApplicationInfo)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool TabHelper::OnMessageReceived(const IPC::Message& message,
                                   content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(TabHelper, message, render_frame_host)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_InlineWebstoreInstall,
-                        OnInlineWebstoreInstall)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_GetAppInstallState,
                         OnGetAppInstallState)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_ContentScriptsExecuting,
                         OnContentScriptsExecuting)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void TabHelper::DidCloneToNewWebContents(WebContents* old_web_contents,
@@ skipping 40 matching lines @@
       NOTREACHED();
       break;
   }
 
   // The hosted app action will be cleared once the installation completes or
   // fails.
   if (pending_web_app_action_ != CREATE_HOSTED_APP)
     pending_web_app_action_ = NONE;
 }
 
-void TabHelper::OnInlineWebstoreInstall(content::RenderFrameHost* host,
-                                        int install_id,
-                                        int return_route_id,
-                                        const std::string& webstore_item_id,
-                                        int listeners_mask) {
+void TabHelper::DoInlineInstall(
+    int install_id,
+    const std::string& webstore_item_id,
+    int listeners_mask,
+    mojom::InlineInstallProgressListenerPtr install_progress_listener,
+    DoInlineInstallCallback callback) {
+  content::RenderFrameHost* host = web_contents()->GetMainFrame();
+  if (bindings_.GetCurrentTargetFrame() != host) {
+    NOTREACHED();
+    return;
+  }
+
   GURL requestor_url(host->GetLastCommittedURL());
   // Check that the listener is reasonable. We should never get anything other
   // than an install stage listener, a download listener, or both.
   // The requestor_url should also be valid, and the renderer should disallow
   // child frames from sending the IPC.
   if ((listeners_mask & ~(api::webstore::INSTALL_STAGE_LISTENER |
                           api::webstore::DOWNLOAD_PROGRESS_LISTENER)) != 0 ||
-      !requestor_url.is_valid() || requestor_url == url::kAboutBlankURL ||
-      host->GetParent()) {
+      !requestor_url.is_valid() || requestor_url == url::kAboutBlankURL) {
     NOTREACHED();
     return;
   }
 
-  if (pending_inline_installations_.count(webstore_item_id) != 0) {
-    Send(new ExtensionMsg_InlineWebstoreInstallResponse(
-        return_route_id, install_id, false,
-        webstore_install::kInstallInProgressError,
-        webstore_install::INSTALL_IN_PROGRESS));
+  if (base::ContainsKey(install_callbacks_, webstore_item_id)) {
+    std::move(callback).Run(install_id, false,
+                            webstore_install::kInstallInProgressError,
+                            webstore_install::INSTALL_IN_PROGRESS);
     return;
   }
 
-  pending_inline_installations_.insert(webstore_item_id);
+  install_callbacks_[webstore_item_id] = std::move(callback);
+  inline_install_progress_listeners_[webstore_item_id] =
+      std::move(install_progress_listener);
   // Inform the Webstore API that an inline install is happening, in case the
   // page requested status updates.
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile_);
   if (registry->disabled_extensions().Contains(webstore_item_id) &&
       (ExtensionPrefs::Get(profile_)->GetDisableReasons(webstore_item_id) &
-           Extension::DISABLE_PERMISSIONS_INCREASE) != 0) {
-      // The extension was disabled due to permissions increase. Prompt for
-      // re-enable.
-      // TODO(devlin): We should also prompt for re-enable for other reasons,
-      // like user-disabled.
-      // For clarity, explicitly end any prior reenable process.
-      extension_reenabler_.reset();
-      extension_reenabler_ = ExtensionReenabler::PromptForReenable(
-          registry->disabled_extensions().GetByID(webstore_item_id), profile_,
-          web_contents(), requestor_url,
-          base::Bind(&TabHelper::OnReenableComplete,
-                     weak_ptr_factory_.GetWeakPtr(), install_id,
-                     return_route_id, webstore_item_id));
+       Extension::DISABLE_PERMISSIONS_INCREASE) != 0) {
+    // The extension was disabled due to permissions increase. Prompt for
+    // re-enable.
+    // TODO(devlin): We should also prompt for re-enable for other reasons,
+    // like user-disabled.
+    // For clarity, explicitly end any prior reenable process.
+    extension_reenabler_.reset();
+    extension_reenabler_ = ExtensionReenabler::PromptForReenable(
+        registry->disabled_extensions().GetByID(webstore_item_id), profile_,
+        web_contents(), requestor_url,
+        base::Bind(&TabHelper::OnReenableComplete,
+                   weak_ptr_factory_.GetWeakPtr(), install_id,
+                   webstore_item_id));
   } else {
     // TODO(devlin): We should adddress the case of the extension already
     // being installed and enabled.
     bool observe_download_progress =
         (listeners_mask & api::webstore::DOWNLOAD_PROGRESS_LISTENER) != 0;
     bool observe_install_stage =
         (listeners_mask & api::webstore::INSTALL_STAGE_LISTENER) != 0;
     if (observe_install_stage || observe_download_progress) {
       DCHECK_EQ(0u, install_observers_.count(webstore_item_id));
       install_observers_[webstore_item_id] =
           base::MakeUnique<InlineInstallObserver>(
-              this, web_contents()->GetBrowserContext(), return_route_id,
-              webstore_item_id, observe_download_progress,
-              observe_install_stage);
+              this, web_contents()->GetBrowserContext(), webstore_item_id,
+              observe_download_progress, observe_install_stage);
     }
 
     WebstoreStandaloneInstaller::Callback callback = base::Bind(
         &TabHelper::OnInlineInstallComplete, weak_ptr_factory_.GetWeakPtr(),
-        install_id, return_route_id, webstore_item_id);
+        install_id, webstore_item_id);
     scoped_refptr<WebstoreInlineInstaller> installer(
         webstore_inline_installer_factory_->CreateInstaller(
             web_contents(), host, webstore_item_id, requestor_url, callback));
     installer->BeginInstall();
   }
 }
 
 void TabHelper::OnGetAppInstallState(content::RenderFrameHost* host,
                                      const GURL& requestor_url,
                                      int return_route_id,
@@ skipping 70 matching lines @@
     extension_app_icon_ = *image.ToSkBitmap();
     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 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.";
       break;
     case ExtensionReenabler::NOT_ALLOWED:
       webstore_result = webstore_install::NOT_PERMITTED;
       error = "Install not permitted.";
       break;
     case ExtensionReenabler::ABORTED:
       webstore_result = webstore_install::ABORTED;
       error = "Aborted due to tab closing.";
       break;
   }
 
-  OnInlineInstallComplete(install_id, return_route_id, extension_id,
+  OnInlineInstallComplete(install_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 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,
-      success ? std::string() : error,
-      result));
+  auto iter = install_callbacks_.find(extension_id);
+  DCHECK(iter != install_callbacks_.end());
+  std::move(iter->second)
+      .Run(install_id, success, success ? std::string() : error, result);
+  install_callbacks_.erase(iter);
 }
 
 WebContents* TabHelper::GetAssociatedWebContents() const {
   return web_contents();
 }
 
 void TabHelper::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                     const Extension* extension,
                                     UnloadedExtensionReason reason) {
   DCHECK(extension_app_);
@@ skipping 32 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