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 15 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));
+      tab_helper_->inline_install_status_->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));
-    }
+    if (observe_install_stage_ && extension_id == extension_id_)
+      tab_helper_->inline_install_status_->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_)),
       location_bar_controller_(new LocationBarController(web_contents)),
       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 11 matching lines @@
   ChromeExtensionWebContentsObserver::CreateForWebContents(web_contents);
   ExtensionWebContentsObserver::GetForWebContents(web_contents)->dispatcher()->
       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_));
+  content::RenderFrameHost* host = web_contents->GetMainFrame();
+  if (host)
+    host->GetRemoteInterfaces()->GetInterface(&inline_install_status_);
 }
 
 void TabHelper::CreateApplicationShortcuts() {
   DCHECK(CanCreateApplicationShortcuts());
   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_SHORTCUT);
@@ skipping 150 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 13 matching lines @@
   NavigationEntry* entry =
       web_contents()->GetController().GetLastCommittedEntry();
   if (!entry || last_committed_nav_entry_unique_id_ != entry->GetUniqueID())
     return;
   last_committed_nav_entry_unique_id_ = 0;
 
   switch (pending_web_app_action_) {
 #if !defined(OS_MACOSX)
     case CREATE_SHORTCUT: {
       chrome::ShowCreateWebAppShortcutsDialog(
-          web_contents()->GetTopLevelNativeWindow(),
-          web_contents());
+          web_contents()->GetTopLevelNativeWindow(), web_contents());
       break;
     }
 #endif
     case CREATE_HOSTED_APP: {
       if (web_app_info_.app_url.is_empty())
         web_app_info_.app_url = web_contents()->GetURL();
 
       if (web_app_info_.title.empty())
         web_app_info_.title = web_contents()->GetTitle();
       if (web_app_info_.title.empty())
@@ skipping 13 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) {
-  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()) {
-    NOTREACHED();
-    return;
-  }
+void TabHelper::DoInlineInstall(int install_id,
+                                int return_route_id,
+                                const std::string& webstore_item_id,
+                                int listeners_mask,
+                                const DoInlineInstallCallback& callback) {
+  content::RenderFrameHost* host = web_contents()->GetMainFrame();
+  if (bindings_.GetCurrentTargetFrame() == host) {

[Devlin, 2017/04/12 01:16:07]

We should handle the case of the message not being from the main frame (probably
with a notreached, since there should be renderer-side checks for this).

Also, when the full body of a method needs to be behind some check like this,
it's often cleaner to do:
if (!some_condition)
  return;
// lots of code here

rather than
if (some_condition) {
  // lots of code here
}

[catmullings, 2017/04/14 20:59:40]

Done.

+    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()) {

[Devlin, 2017/04/12 01:16:07]

if host is the main frame, it can't have a parent.

[catmullings, 2017/04/14 20:59:40]

Done.

+      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));
-    return;
-  }
+    if (pending_inline_installations_.count(webstore_item_id) != 0) {
+      callback.Run(install_id, false, webstore_install::kInstallInProgressError,
+                   webstore_install::INSTALL_IN_PROGRESS);
+      return;
+    }
 
-  pending_inline_installations_.insert(webstore_item_id);
-  // 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) {
+    pending_inline_installations_.insert(webstore_item_id);
+    // 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));
-  } 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);
+                     return_route_id, webstore_item_id, callback));
+    } 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,

[Devlin, 2017/04/12 01:16:07]

Does this compile?  InlineInstallObserver doesn't take a return_route_id param
anymore.

[catmullings, 2017/04/14 20:59:40]

It does compile. According to the constructor definition, it takes a routing_id
https://cs.chromium.org/chromium/src/chrome/browser/extensions/tab_helper.cc?...

I've removed the return_route_id from the InlineInstallObserver class, since
it's no longer needed.

+                webstore_item_id, observe_download_progress,
+                observe_install_stage);
+      }
+
+      WebstoreStandaloneInstaller::Callback completion_callback = base::Bind(
+          &TabHelper::OnInlineInstallComplete, weak_ptr_factory_.GetWeakPtr(),
+          callback, install_id, return_route_id, webstore_item_id);
+      scoped_refptr<WebstoreInlineInstaller> installer(
+          webstore_inline_installer_factory_->CreateInstaller(
+              web_contents(), host, webstore_item_id, requestor_url,
+              completion_callback));
+      installer->BeginInstall();
     }
-
-    WebstoreStandaloneInstaller::Callback callback = base::Bind(
-        &TabHelper::OnInlineInstallComplete, weak_ptr_factory_.GetWeakPtr(),
-        install_id, return_route_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,
                                      int callback_id) {
   ExtensionRegistry* registry =
       ExtensionRegistry::Get(web_contents()->GetBrowserContext());
   const ExtensionSet& extensions = registry->enabled_extensions();
@@ skipping 68 matching lines @@
   }
 }
 
 WindowController* TabHelper::GetExtensionWindowController() const  {
   return ExtensionTabUtil::GetWindowControllerOfTab(web_contents());
 }
 
 void TabHelper::OnReenableComplete(int install_id,
                                    int return_route_id,
                                    const ExtensionId& extension_id,
+                                   const DoInlineInstallCallback& callback,
                                    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(callback, 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,
+void TabHelper::OnInlineInstallComplete(const DoInlineInstallCallback& callback,
+                                        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));
+  callback.Run(install_id, success, success ? std::string() : error, result);
 }
 
 WebContents* TabHelper::GetAssociatedWebContents() const {
   return web_contents();
 }
 
 void TabHelper::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
@@ skipping 33 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