[Extensions] Rework inline installation observation

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 <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
@@ skipping 11 matching lines @@
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_urls.h"
 #include "url/gurl.h"
 
 using content::WebContents;
 
 namespace extensions {
 
-const char kInvalidWebstoreItemId[] = "Invalid Chrome Web Store item ID";
-const char kWebstoreRequestError[] =
-    "Could not fetch data from the Chrome Web Store";
-const char kInvalidWebstoreResponseError[] = "Invalid Chrome Web Store reponse";
-const char kInvalidManifestError[] = "Invalid manifest";
-const char kUserCancelledError[] = "User cancelled install";
-const char kExtensionIsBlacklisted[] = "Extension is blacklisted";
-const char kInstallInProgressError[] = "An install is already in progress";
-
 WebstoreStandaloneInstaller::WebstoreStandaloneInstaller(
     const std::string& webstore_item_id,
     Profile* profile,
     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) {
 }
 
 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 (!crx_file::id_util::IdIsValid(id_)) {
-    CompleteInstall(webstore_install::INVALID_ID, kInvalidWebstoreItemId);
+    CompleteInstall(webstore_install::INVALID_ID,
+                    webstore_install::kInvalidWebstoreItemId);
     return;
   }
 
   webstore_install::Result result = webstore_install::OTHER_ERROR;
   std::string error;
   if (!EnsureUniqueInstall(&result, &error)) {
     CompleteInstall(result, error);
     return;
   }
 
@@ skipping 34 matching lines @@
 bool WebstoreStandaloneInstaller::EnsureUniqueInstall(
     webstore_install::Result* reason,
     std::string* error) {
   InstallTracker* tracker = InstallTracker::Get(profile_);
   DCHECK(tracker);
 
   const ActiveInstallData* existing_install_data =
       tracker->GetActiveInstall(id_);
   if (existing_install_data) {
     *reason = webstore_install::INSTALL_IN_PROGRESS;
-    *error = kInstallInProgressError;
+    *error = webstore_install::kInstallInProgressError;
     return false;
   }
 
   ActiveInstallData install_data(id_);
   InitInstallData(&install_data);
   scoped_active_install_.reset(new ScopedActiveInstall(tracker, install_data));
   return true;
 }
 
 void WebstoreStandaloneInstaller::CompleteInstall(
@@ skipping 58 matching lines @@
           true));
   approval->skip_post_install_ui = !ShouldShowPostInstallUI();
   approval->use_app_installed_bubble = ShouldShowAppInstalledBubble();
   approval->installing_icon = gfx::ImageSkia::CreateFrom1xBitmap(icon_);
   return approval;
 }
 
 void WebstoreStandaloneInstaller::OnInstallPromptDone(
     ExtensionInstallPrompt::Result result) {
   if (result == ExtensionInstallPrompt::Result::USER_CANCELED) {
-    CompleteInstall(webstore_install::USER_CANCELLED, kUserCancelledError);
+    CompleteInstall(webstore_install::USER_CANCELLED,
+                    webstore_install::kUserCancelledError);
     return;
   }
 
   if (result == ExtensionInstallPrompt::Result::ABORTED ||
       !CheckRequestorAlive()) {
     CompleteInstall(webstore_install::ABORTED, std::string());
     return;
   }
 
   DCHECK(result == ExtensionInstallPrompt::Result::ACCEPTED);
 
   std::unique_ptr<WebstoreInstaller::Approval> approval = CreateApproval();
 
   ExtensionService* extension_service =
       ExtensionSystem::Get(profile_)->extension_service();
   const Extension* installed_extension =
       extension_service->GetExtensionById(id_, true /* include disabled */);
   if (installed_extension) {
     std::string install_message;
     webstore_install::Result install_result = webstore_install::SUCCESS;
     bool done = true;
 
     if (ExtensionPrefs::Get(profile_)->IsExtensionBlacklisted(id_)) {
       // Don't install a blacklisted extension.
       install_result = webstore_install::BLACKLISTED;
-      install_message = kExtensionIsBlacklisted;
+      install_message = webstore_install::kExtensionIsBlacklisted;
     } 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.
 
     if (done) {
       CompleteInstall(install_result, install_message);
       return;
     }
   }
 
   scoped_refptr<WebstoreInstaller> installer =
       new WebstoreInstaller(profile_, this, GetWebContents(), id_,
                             std::move(approval), install_source_);
   installer->Start();
 }
 
 void WebstoreStandaloneInstaller::OnWebstoreRequestFailure() {
   OnWebStoreDataFetcherDone();
   CompleteInstall(webstore_install::WEBSTORE_REQUEST_ERROR,
-                  kWebstoreRequestError);
+                  webstore_install::kWebstoreRequestError);
 }
 
 void WebstoreStandaloneInstaller::OnWebstoreResponseParseSuccess(
     std::unique_ptr<base::DictionaryValue> webstore_data) {
   OnWebStoreDataFetcherDone();
 
   if (!CheckRequestorAlive()) {
     CompleteInstall(webstore_install::ABORTED, std::string());
     return;
   }
@@ skipping 10 matching lines @@
     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(webstore_install::INVALID_WEBSTORE_RESPONSE,
-                    kInvalidWebstoreResponseError);
+                    webstore_install::kInvalidWebstoreResponseError);
     return;
   }
 
   // Optional.
   show_user_count_ = true;
   webstore_data->GetBoolean(kShowUserCountKey, &show_user_count_);
 
   if (average_rating_ < ExtensionInstallPrompt::kMinExtensionRating ||
       average_rating_ > ExtensionInstallPrompt::kMaxExtensionRating) {
     CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE,
-                    kInvalidWebstoreResponseError);
+                    webstore_install::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(webstore_install::INVALID_WEBSTORE_RESPONSE,
-                    kInvalidWebstoreResponseError);
+                    webstore_install::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(webstore_install::INVALID_WEBSTORE_RESPONSE,
-                      kInvalidWebstoreResponseError);
+                      webstore_install::kInvalidWebstoreResponseError);
       return;
     }
     icon_url = GURL(extension_urls::GetWebstoreLaunchURL()).Resolve(
         icon_url_string);
     if (!icon_url.is_valid()) {
       CompleteInstall(webstore_install::INVALID_WEBSTORE_RESPONSE,
-                      kInvalidWebstoreResponseError);
+                      webstore_install::kInvalidWebstoreResponseError);
       return;
     }
   }
 
   // Assume ownership of webstore_data.
   webstore_data_ = std::move(webstore_data);
 
   scoped_refptr<WebstoreInstallHelper> helper =
       new WebstoreInstallHelper(this,
                                 id_,
@@ skipping 72 matching lines @@
       break;
   }
 
   CompleteInstall(install_result, error);
 }
 
 void WebstoreStandaloneInstaller::ShowInstallUI() {
   scoped_refptr<const Extension> localized_extension =
       GetLocalizedExtensionForDisplay();
   if (!localized_extension.get()) {
-    CompleteInstall(webstore_install::INVALID_MANIFEST, kInvalidManifestError);
+    CompleteInstall(webstore_install::INVALID_MANIFEST,
+                    webstore_install::kInvalidManifestError);
     return;
   }
 
   install_ui_ = CreateInstallUI();
   install_ui_->ShowDialog(
       base::Bind(&WebstoreStandaloneInstaller::OnInstallPromptDone, this),
       localized_extension.get(), &icon_, std::move(install_prompt_),
       ExtensionInstallPrompt::GetDefaultShowDialogCallback());
 }
 
 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