Update the EphemeralAppLauncher for use by the webstorePrivate API

chrome/browser/extensions/webstore_standalone_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_standalone_installer.h"
 
 #include "base/values.h"
+#include "base/version.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/webstore_data_fetcher.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
@@ skipping 19 matching lines @@
     const Callback& callback)
     : id_(webstore_item_id),
       callback_(callback),
       profile_(profile),
       install_source_(WebstoreInstaller::INSTALL_SOURCE_INLINE),
       show_user_count_(true),
       average_rating_(0.0),
       rating_count_(0) {
 }
 
-WebstoreStandaloneInstaller::~WebstoreStandaloneInstaller() {}
-
-//
-// Private interface implementation.
-//
-
 void WebstoreStandaloneInstaller::BeginInstall() {
   // Add a ref to keep this alive for WebstoreDataFetcher.
   // All code paths from here eventually lead to either CompleteInstall or
   // AbortInstall, which both release this ref.
   AddRef();
 
   if (!Extension::IdIsValid(id_)) {
-    CompleteInstall(kInvalidWebstoreItemId);
+    CompleteInstall(INSTALL_INVALID_ID, kInvalidWebstoreItemId);
     return;
   }
 
   // Use the requesting page as the referrer both since that is more correct
   // (it is the page that caused this request to happen) and so that we can
   // track top sites that trigger inline install requests.
   webstore_data_fetcher_.reset(new WebstoreDataFetcher(
       this,
       profile_->GetRequestContext(),
       GetRequestorURL(),
       id_));
   webstore_data_fetcher_->Start();
 }
 
-bool WebstoreStandaloneInstaller::CheckInstallValid(
-    const base::DictionaryValue& manifest,
-    std::string* error) {
-  return true;
+//
+// Private interface implementation.
+//
+
+WebstoreStandaloneInstaller::~WebstoreStandaloneInstaller() {
+}
+
+void WebstoreStandaloneInstaller::AbortInstall() {
+  callback_.Reset();
+  // Abort any in-progress fetches.
+  if (webstore_data_fetcher_) {
+    webstore_data_fetcher_.reset();
+    Release();  // Matches the AddRef in BeginInstall.
+  }
+}
+
+void WebstoreStandaloneInstaller::CompleteInstall(InstallResult result,
+                                                  const std::string& error) {
+  if (!callback_.is_null())
+    callback_.Run(result == INSTALL_SUCCESS, error);
+  Release();  // Matches the AddRef in BeginInstall.
+}
+
+void WebstoreStandaloneInstaller::ProceedWithInstallPrompt() {
+  install_prompt_ = CreateInstallPrompt();
+  if (install_prompt_) {
+    ShowInstallUI();
+    // Control flow finishes up in InstallUIProceed or InstallUIAbort.
+  } else {
+    InstallUIProceed();
+  }
+}
+
+scoped_refptr<const Extension>
+WebstoreStandaloneInstaller::GetLocalizedExtensionForDisplay() {
+  if (!localized_extension_for_display_.get()) {
+    DCHECK(manifest_.get());
+    if (!manifest_.get())
+      return NULL;
+
+    std::string error;
+    localized_extension_for_display_ =
+        ExtensionInstallPrompt::GetLocalizedExtensionForDisplay(
+            manifest_.get(),
+            Extension::REQUIRE_KEY | Extension::FROM_WEBSTORE,
+            id_,
+            localized_name_,
+            localized_description_,
+            &error);
+  }
+  return localized_extension_for_display_.get();
+}
+
+void WebstoreStandaloneInstaller::OnManifestParsed() {
+  ProceedWithInstallPrompt();
 }
 
 scoped_ptr<ExtensionInstallPrompt>
 WebstoreStandaloneInstaller::CreateInstallUI() {
   return make_scoped_ptr(new ExtensionInstallPrompt(GetWebContents()));
 }
 
 scoped_ptr<WebstoreInstaller::Approval>
 WebstoreStandaloneInstaller::CreateApproval() const {
   scoped_ptr<WebstoreInstaller::Approval> approval(
       WebstoreInstaller::Approval::CreateWithNoInstallPrompt(
           profile_,
           id_,
           scoped_ptr<base::DictionaryValue>(manifest_.get()->DeepCopy()),
           true));
   approval->skip_post_install_ui = !ShouldShowPostInstallUI();
   approval->use_app_installed_bubble = ShouldShowAppInstalledBubble();
   approval->installing_icon = gfx::ImageSkia::CreateFrom1xBitmap(icon_);
   return approval.Pass();
 }
 
 void WebstoreStandaloneInstaller::OnWebstoreRequestFailure() {
   OnWebStoreDataFetcherDone();
-  CompleteInstall(kWebstoreRequestError);
+  CompleteInstall(INSTALL_WEBSTORE_REQUEST_ERROR, kWebstoreRequestError);
 }
 
 void WebstoreStandaloneInstaller::OnWebstoreResponseParseSuccess(
     scoped_ptr<base::DictionaryValue> webstore_data) {
   OnWebStoreDataFetcherDone();
 
   if (!CheckRequestorAlive()) {
-    CompleteInstall(std::string());
+    CompleteInstall(INSTALL_ABORTED, std::string());
     return;
   }
 
   std::string error;
 
   if (!CheckInlineInstallPermitted(*webstore_data, &error)) {
-    CompleteInstall(error);
+    CompleteInstall(INSTALL_NOT_PERMITTED, error);
     return;
   }
 
   if (!CheckRequestorPermitted(*webstore_data, &error)) {
-    CompleteInstall(error);
+    CompleteInstall(INSTALL_NOT_PERMITTED, error);
     return;
   }
 
   // Manifest, number of users, average rating and rating count are required.
   std::string manifest;
   if (!webstore_data->GetString(kManifestKey, &manifest) ||
       !webstore_data->GetString(kUsersKey, &localized_user_count_) ||
       !webstore_data->GetDouble(kAverageRatingKey, &average_rating_) ||
       !webstore_data->GetInteger(kRatingCountKey, &rating_count_)) {
-    CompleteInstall(kInvalidWebstoreResponseError);
+    CompleteInstall(INSTALL_INVALID_WEBSTORE_RESPONSE,
+                    kInvalidWebstoreResponseError);
     return;
   }
 
   // Optional.
   show_user_count_ = true;
   webstore_data->GetBoolean(kShowUserCountKey, &show_user_count_);
 
   if (average_rating_ < ExtensionInstallPrompt::kMinExtensionRating ||
       average_rating_ > ExtensionInstallPrompt::kMaxExtensionRating) {
-    CompleteInstall(kInvalidWebstoreResponseError);
+    CompleteInstall(INSTALL_INVALID_WEBSTORE_RESPONSE,
+                    kInvalidWebstoreResponseError);
     return;
   }
 
   // Localized name and description are optional.
   if ((webstore_data->HasKey(kLocalizedNameKey) &&
       !webstore_data->GetString(kLocalizedNameKey, &localized_name_)) ||
       (webstore_data->HasKey(kLocalizedDescriptionKey) &&
       !webstore_data->GetString(
           kLocalizedDescriptionKey, &localized_description_))) {
-    CompleteInstall(kInvalidWebstoreResponseError);
+    CompleteInstall(INSTALL_INVALID_WEBSTORE_RESPONSE,
+                    kInvalidWebstoreResponseError);
     return;
   }
 
   // Icon URL is optional.
   GURL icon_url;
   if (webstore_data->HasKey(kIconUrlKey)) {
     std::string icon_url_string;
     if (!webstore_data->GetString(kIconUrlKey, &icon_url_string)) {
-      CompleteInstall(kInvalidWebstoreResponseError);
+      CompleteInstall(INSTALL_INVALID_WEBSTORE_RESPONSE,
+                      kInvalidWebstoreResponseError);
       return;
     }
     icon_url = GURL(extension_urls::GetWebstoreLaunchURL()).Resolve(
         icon_url_string);
     if (!icon_url.is_valid()) {
-      CompleteInstall(kInvalidWebstoreResponseError);
+      CompleteInstall(INSTALL_INVALID_WEBSTORE_RESPONSE,
+                      kInvalidWebstoreResponseError);
       return;
     }
   }
 
   // Assume ownership of webstore_data.
   webstore_data_ = webstore_data.Pass();
 
   scoped_refptr<WebstoreInstallHelper> helper =
       new WebstoreInstallHelper(this,
                                 id_,
                                 manifest,
                                 std::string(),  // We don't have any icon data.
                                 icon_url,
                                 profile_->GetRequestContext());
   // The helper will call us back via OnWebstoreParseSucces or
   // OnWebstoreParseFailure.
   helper->Start();
 }
 
 void WebstoreStandaloneInstaller::OnWebstoreResponseParseFailure(
     const std::string& error) {
   OnWebStoreDataFetcherDone();
-  CompleteInstall(error);
+  CompleteInstall(INSTALL_INVALID_WEBSTORE_RESPONSE, error);
 }
 
 void WebstoreStandaloneInstaller::OnWebstoreParseSuccess(
     const std::string& id,
     const SkBitmap& icon,
     base::DictionaryValue* manifest) {
   CHECK_EQ(id_, id);
 
   if (!CheckRequestorAlive()) {
-    CompleteInstall(std::string());
+    CompleteInstall(INSTALL_ABORTED, std::string());
     return;
   }
 
   manifest_.reset(manifest);
   icon_ = icon;
 
-  std::string error;
-  if (!CheckInstallValid(*manifest, &error)) {
-    DCHECK(!error.empty());
-    CompleteInstall(error);
-    return;
-  }
-
-  install_prompt_ = CreateInstallPrompt();
-  if (install_prompt_) {
-    ShowInstallUI();
-    // Control flow finishes up in InstallUIProceed or InstallUIAbort.
-  } else {
-    InstallUIProceed();
-  }
+  OnManifestParsed();
 }
 
 void WebstoreStandaloneInstaller::OnWebstoreParseFailure(
     const std::string& id,
     InstallHelperResultCode result_code,
     const std::string& error_message) {
-  CompleteInstall(error_message);
+  InstallResult install_result = INSTALL_UNKNOWN_ERROR;
+  switch (result_code) {
+    case WebstoreInstallHelper::Delegate::MANIFEST_ERROR:
+      install_result = INSTALL_INVALID_MANIFEST;
+      break;
+    case WebstoreInstallHelper::Delegate::ICON_ERROR:
+      install_result = INSTALL_ICON_ERROR;
+      break;
+    default:
+      break;
+  }
+
+  CompleteInstall(install_result, error_message);
 }
 
 void WebstoreStandaloneInstaller::InstallUIProceed() {
   if (!CheckRequestorAlive()) {
-    CompleteInstall(std::string());
+    CompleteInstall(INSTALL_ABORTED, std::string());
     return;
   }
 
   scoped_ptr<WebstoreInstaller::Approval> approval = CreateApproval();
 
   ExtensionService* extension_service =
       ExtensionSystem::Get(profile_)->extension_service();
-  const Extension* extension =
+  const Extension* installed_extension =
       extension_service->GetExtensionById(id_, true /* include disabled */);
-  if (extension) {
-    std::string install_result;  // Empty string for install success.
+  if (installed_extension) {
+    std::string install_message;
+    InstallResult install_result = INSTALL_SUCCESS;
+    bool done = true;
 
     if (ExtensionPrefs::Get(profile_)->IsExtensionBlacklisted(id_)) {
       // Don't install a blacklisted extension.
-      install_result = kExtensionIsBlacklisted;
-    } else if (util::IsEphemeralApp(extension->id(), profile_) &&
+      install_result = INSTALL_BLACKLISTED;
+      install_message = kExtensionIsBlacklisted;
+    } else if (util::IsEphemeralApp(installed_extension->id(), profile_) &&
                !approval->is_ephemeral) {

[asargent_no_longer_on_chrome, 2014/06/18 20:25:10]

Something to think about for a future refactoring and not necessarily this CL-
can we make it so that WebstoreStandaloneInstaller doesn't have to know about
the specific concept of ephemeral apps, and instead has some generic hooks that
a subclass would implement (or a Delegate object that gets passed in)?

[tmdiep, 2014/06/18 22:28:34]

This is actually not specific to the EphemeralAppLauncher. If the user wants to
install an app and we already have it installed ephemerally, it just gets
promoted to a full install.

[asargent_no_longer_on_chrome, 2014/06/19 00:16:43]

Ah, ok, that makes sense. 

-      // If the target extension has already been installed ephemerally, it can
-      // be promoted to a regular installed extension and downloading from the
-      // Web Store is not necessary.
-      extension_service->PromoteEphemeralApp(extension, false);
+      // If the target extension has already been installed ephemerally and is
+      // up to date, it can be promoted to a regular installed extension and
+      // downloading from the Web Store is not necessary.
+      const Extension* extension_to_install = GetLocalizedExtensionForDisplay();
+      if (!extension_to_install) {
+        CompleteInstall(INSTALL_INVALID_MANIFEST, kInvalidManifestError);
+        return;
+      }
+
+      if (installed_extension->version()->CompareTo(
+              *extension_to_install->version()) < 0) {
+        // If the existing extension is out of date, proceed with the install
+        // to update the extension.
+        done = false;
+      } else {
+        extension_service->PromoteEphemeralApp(installed_extension, false);
+      }
     } else if (!extension_service->IsExtensionEnabled(id_)) {
       // If the extension is installed but disabled, and not blacklisted,
       // enable it.
       extension_service->EnableExtension(id_);
     }  // else extension is installed and enabled; no work to be done.
 
-    CompleteInstall(install_result);
-    return;
+    if (done) {
+      CompleteInstall(install_result, install_message);
+      return;
+    }
   }
 
   scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
       profile_,
       this,
       GetWebContents(),
       id_,
       approval.Pass(),
       install_source_);
   installer->Start();
 }
 
 void WebstoreStandaloneInstaller::InstallUIAbort(bool user_initiated) {
-  CompleteInstall(kUserCancelledError);
+  CompleteInstall(INSTALL_USER_CANCELLED, kUserCancelledError);
 }
 
 void WebstoreStandaloneInstaller::OnExtensionInstallSuccess(
     const std::string& id) {
   CHECK_EQ(id_, id);
-  CompleteInstall(std::string());
+  CompleteInstall(INSTALL_SUCCESS, std::string());
 }
 
 void WebstoreStandaloneInstaller::OnExtensionInstallFailure(
     const std::string& id,
     const std::string& error,
-    WebstoreInstaller::FailureReason cancelled) {
+    WebstoreInstaller::FailureReason reason) {
   CHECK_EQ(id_, id);
-  CompleteInstall(error);
-}
 
-void WebstoreStandaloneInstaller::AbortInstall() {
-  callback_.Reset();
-  // Abort any in-progress fetches.
-  if (webstore_data_fetcher_) {
-    webstore_data_fetcher_.reset();
-    Release();  // Matches the AddRef in BeginInstall.
+  InstallResult install_result = INSTALL_UNKNOWN_ERROR;
+  switch (reason) {
+    case WebstoreInstaller::FAILURE_REASON_CANCELLED:
+      install_result = INSTALL_USER_CANCELLED;
+      break;
+    case WebstoreInstaller::FAILURE_REASON_DEPENDENCY_NOT_FOUND:
+    case WebstoreInstaller::FAILURE_REASON_DEPENDENCY_NOT_SHARED_MODULE:
+      install_result = INSTALL_MISSING_DEPENDENCIES;
+      break;
+    default:
+      break;
   }
-}
 
-void WebstoreStandaloneInstaller::InvokeCallback(const std::string& error) {
-  if (!callback_.is_null())
-    callback_.Run(error.empty(), error);
-}
-
-void WebstoreStandaloneInstaller::CompleteInstall(const std::string& error) {
-  InvokeCallback(error);
-  Release();  // Matches the AddRef in BeginInstall.
+  CompleteInstall(install_result, error);
 }
 
 void WebstoreStandaloneInstaller::ShowInstallUI() {
-  std::string error;
-  localized_extension_for_display_ =
-      ExtensionInstallPrompt::GetLocalizedExtensionForDisplay(
-          manifest_.get(),
-          Extension::REQUIRE_KEY | Extension::FROM_WEBSTORE,
-          id_,
-          localized_name_,
-          localized_description_,
-          &error);
-  if (!localized_extension_for_display_.get()) {
-    CompleteInstall(kInvalidManifestError);
+  const Extension* localized_extension = GetLocalizedExtensionForDisplay();
+  if (!localized_extension) {
+    CompleteInstall(INSTALL_INVALID_MANIFEST, kInvalidManifestError);
     return;
   }
 
   install_ui_ = CreateInstallUI();
   install_ui_->ConfirmStandaloneInstall(
-      this, localized_extension_for_display_.get(), &icon_, *install_prompt_);
+      this, localized_extension, &icon_, *install_prompt_);
 }
 
 void WebstoreStandaloneInstaller::OnWebStoreDataFetcherDone() {
   // An instance of this class is passed in as a delegate for the
   // WebstoreInstallHelper, ExtensionInstallPrompt and WebstoreInstaller, and
   // therefore needs to remain alive until they are done. Clear the webstore
   // data fetcher to avoid calling Release in AbortInstall while any of these
   // operations are in progress.
   webstore_data_fetcher_.reset();
 }
 
 }  // namespace extensions