Support an --install-from-webstore command line switch

chrome/browser/extensions/webstore_inline_installer.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/webstore_inline_installer.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/string_util.h"
@@ skipping 129 matching lines @@
  private:
   virtual ~SafeWebstoreResponseParser() {}
 
   WebstoreInlineInstaller* client_;
 
   std::string webstore_data_;
   std::string error_;
   scoped_ptr<DictionaryValue> parsed_webstore_data_;
 };
 
-WebstoreInlineInstaller::WebstoreInlineInstaller(WebContents* web_contents,
-                                                 int install_id,
-                                                 int return_route_id,
-                                                 std::string webstore_item_id,
-                                                 GURL requestor_url,
-                                                 Delegate* delegate)
+WebstoreInlineInstaller::WebstoreInlineInstaller(
+    WebContents* web_contents,
+    std::string webstore_item_id,
+    VerifiedSiteRequired require_verified_site,
+    GURL requestor_url,
+    Callback callback)
     : content::WebContentsObserver(web_contents),
-      install_id_(install_id),
-      return_route_id_(return_route_id),
       id_(webstore_item_id),
+      require_verified_site_(require_verified_site == REQUIRE_VERIFIED_SITE),
       requestor_url_(requestor_url),
-      delegate_(delegate),
+      callback_(callback),
+      skip_post_install_ui_(false),
       average_rating_(0.0),
       rating_count_(0) {
+  CHECK(!callback.is_null());
 }
 
 void WebstoreInlineInstaller::BeginInstall() {
   AddRef(); // Balanced in CompleteInstall or WebContentsDestroyed.
 
   if (!Extension::IdIsValid(id_)) {
     CompleteInstall(kInvalidWebstoreItemId);
     return;
   }
 
@@ skipping 113 matching lines @@
       return;
     }
     icon_url = GURL(extension_urls::GetWebstoreLaunchURL()).Resolve(
         icon_url_string);
     if (!icon_url.is_valid()) {
       CompleteInstall(kInvalidWebstoreResponseError);
       return;
     }
   }
 
-  // Verified site is required
-  if (webstore_data->HasKey(kVerifiedSiteKey)) {
+  // Check for a verified site if required.
+  if (require_verified_site_) {
+    if (!webstore_data->HasKey(kVerifiedSiteKey)) {
+      CompleteInstall(kNoVerifiedSiteError);
+      return;
+    }
     std::string verified_site;
     if (!webstore_data->GetString(kVerifiedSiteKey, &verified_site)) {
       CompleteInstall(kInvalidWebstoreResponseError);
       return;
     }
-
     if (!IsRequestorURLInVerifiedSite(requestor_url_, verified_site)) {
       CompleteInstall(kNotFromVerifiedSiteError);
       return;
     }
-  } else {
-    CompleteInstall(kNoVerifiedSiteError);
-    return;
   }
 
   scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
       this,
       id_,
       manifest,
       "", // We don't have any icon data.
       icon_url,
       Profile::FromBrowserContext(web_contents()->GetBrowserContext())->
           GetRequestContext());
@@ skipping 36 matching lines @@
       id_,
       localized_name_,
       localized_description_,
       &error);
   if (!dummy_extension_) {
     OnWebstoreParseFailure(id_, WebstoreInstallHelper::Delegate::MANIFEST_ERROR,
                            kInvalidManifestError);
     return;
   }
 
-  install_ui_.reset(
-      ExtensionInstallUI::CreateInstallPromptWithWebContents(web_contents()));
+  install_ui_.reset(new ExtensionInstallPrompt(NULL, web_contents(), profile));
   install_ui_->ConfirmInlineInstall(this, dummy_extension_, &icon_, prompt);
   // Control flow finishes up in InstallUIProceed or InstallUIAbort.
 }
 
 void WebstoreInlineInstaller::OnWebstoreParseFailure(
     const std::string& id,
     InstallHelperResultCode result_code,
     const std::string& error_message) {
   CompleteInstall(error_message);
 }
 
 void WebstoreInlineInstaller::InstallUIProceed() {
   // Check if the tab has gone away in the meantime.
   if (!web_contents()) {
     CompleteInstall("");
     return;
   }
 
   Profile* profile = Profile::FromBrowserContext(
       web_contents()->GetBrowserContext());
 
   scoped_ptr<WebstoreInstaller::Approval> approval(
       WebstoreInstaller::Approval::CreateWithNoInstallPrompt(
           profile,
           id_,
           scoped_ptr<base::DictionaryValue>(manifest_.get()->DeepCopy())));
-  approval->use_app_installed_bubble = true;
+  if (skip_post_install_ui_)
+    approval->skip_post_install_ui = true;
+  else
+    approval->use_app_installed_bubble = true;
 
   scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
       profile, this, &(web_contents()->GetController()), id_, approval.Pass(),
       WebstoreInstaller::FLAG_INLINE_INSTALL);
   installer->Start();
 }
 
 void WebstoreInlineInstaller::InstallUIAbort(bool user_initiated) {
   CompleteInstall(kUserCancelledError);
 }
 
 void WebstoreInlineInstaller::WebContentsDestroyed(WebContents* web_contents) {
+  callback_.Reset();
   // Abort any in-progress fetches.
   if (webstore_data_url_fetcher_.get()) {
     webstore_data_url_fetcher_.reset();
     Release(); // Matches the AddRef in BeginInstall.
   }
 }
 
 void WebstoreInlineInstaller::OnExtensionInstallSuccess(const std::string& id) {
   CHECK_EQ(id_, id);
   CompleteInstall("");
 }
 
 void WebstoreInlineInstaller::OnExtensionInstallFailure(
     const std::string& id, const std::string& error) {
   CHECK_EQ(id_, id);
   CompleteInstall(error);
 }
 
 void WebstoreInlineInstaller::CompleteInstall(const std::string& error) {
-  // Only bother responding if there's still a tab contents to send back the
-  // response to.
-  if (web_contents()) {
-    if (error.empty()) {
-      delegate_->OnInlineInstallSuccess(install_id_, return_route_id_);
-    } else {
-      delegate_->OnInlineInstallFailure(install_id_, return_route_id_, error);
-    }
-  }
+  if (!callback_.is_null())
+    callback_.Run(error.empty(), error);
 
   Release(); // Matches the AddRef in BeginInstall.
 }
 
 // static
 bool WebstoreInlineInstaller::IsRequestorURLInVerifiedSite(
     const GURL& requestor_url,
     const std::string& verified_site) {
   // Turn the verified site (which may be a bare domain, or have a port and/or a
   // path) into a URL that can be parsed by URLPattern.
@@ skipping 10 matching lines @@
     DLOG(WARNING) << "Could not parse " << verified_site_url <<
         " as URL pattern " << parse_result;
     return false;
   }
   verified_site_pattern.SetScheme("*");
 
   return verified_site_pattern.MatchesURL(requestor_url);
 }
 
 }  // namespace extensions