Simplify ExtensionInstallChecker into a single-use class

chrome/browser/extensions/crx_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/crx_installer.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 90 matching lines @@
 scoped_refptr<CrxInstaller> CrxInstaller::Create(
     ExtensionService* service,
     std::unique_ptr<ExtensionInstallPrompt> client,
     const WebstoreInstaller::Approval* approval) {
   return new CrxInstaller(service->AsWeakPtr(), std::move(client), approval);
 }
 
 CrxInstaller::CrxInstaller(base::WeakPtr<ExtensionService> service_weak,
                            std::unique_ptr<ExtensionInstallPrompt> client,
                            const WebstoreInstaller::Approval* approval)
-    : install_directory_(service_weak->install_directory()),
+    : profile_(service_weak->profile()),
+      install_directory_(service_weak->install_directory()),
       install_source_(Manifest::INTERNAL),
       approved_(false),
       hash_check_failed_(false),
       expected_manifest_check_level_(
           WebstoreInstaller::MANIFEST_CHECK_LEVEL_STRICT),
       fail_install_if_unexpected_version_(false),
       extensions_enabled_(service_weak->extensions_enabled()),
       delete_source_(false),
       create_app_shortcut_(false),
       service_weak_(service_weak),
       // See header file comment on |client_| for why we use a raw pointer here.
       client_(client.release()),
       apps_require_extension_mime_type_(false),
       allow_silent_install_(false),
       grant_permissions_(true),
       install_cause_(extension_misc::INSTALL_CAUSE_UNSET),
       creation_flags_(Extension::NO_FLAGS),
       off_store_install_allow_reason_(OffStoreInstallDisallowed),
       did_handle_successfully_(true),
       error_on_unsupported_requirements_(false),
       update_from_settings_page_(false),
-      install_flags_(kInstallFlagNone),
-      install_checker_(service_weak->profile()) {
+      install_flags_(kInstallFlagNone) {
   installer_task_runner_ = service_weak->GetFileTaskRunner();
   if (!approval)
     return;
 
   CHECK(profile()->IsSameProfile(approval->profile));
   if (client_) {
     client_->install_ui()->SetUseAppInstalledBubble(
         approval->use_app_installed_bubble);
     client_->install_ui()->SetSkipPostInstallUI(approval->skip_post_install_ui);
   }
@@ skipping 203 matching lines @@
       // manually if they want.
       delete_source_ = false;
       did_handle_successfully_ = false;
 
       return CrxInstallError(
           CrxInstallError::ERROR_OFF_STORE,
           l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALL_DISALLOWED_ON_SITE));
     }
   }
 
-  if (install_checker_.extension()->is_app()) {
+  if (extension_->is_app()) {
     // If the app was downloaded, apps_require_extension_mime_type_
     // will be set.  In this case, check that it was served with the
     // right mime type.  Make an exception for file URLs, which come
     // from the users computer and have no headers.
     if (!download_url_.SchemeIsFile() &&
         apps_require_extension_mime_type_ &&
         original_mime_type_ != Extension::kMimeType) {
       return CrxInstallError(l10n_util::GetStringFUTF16(
           IDS_EXTENSION_INSTALL_INCORRECT_APP_CONTENT_TYPE,
           base::ASCIIToUTF16(Extension::kMimeType)));
@@ skipping 12 matching lines @@
             l10n_util::GetStringUTF16(IDS_EXTENSION_WEB_STORE_TITLE)));
       }
 
       // For self-hosted apps, verify that the entire extent is on the same
       // host (or a subdomain of the host) the download happened from.  There's
       // no way for us to verify that the app controls any other hosts.
       URLPattern pattern(UserScript::ValidUserScriptSchemes());
       pattern.SetHost(download_url_.host());
       pattern.SetMatchSubdomains(true);
 
-      URLPatternSet patterns = install_checker_.extension()->web_extent();
+      URLPatternSet patterns = extension_->web_extent();
       for (URLPatternSet::const_iterator i = patterns.begin();
            i != patterns.end(); ++i) {
         if (!pattern.MatchesHost(i->host())) {
           return CrxInstallError(l10n_util::GetStringUTF16(
               IDS_EXTENSION_INSTALL_INCORRECT_INSTALL_HOST));
         }
       }
     }
   }
 
@@ skipping 22 matching lines @@
   DCHECK(installer_task_runner_->RunsTasksOnCurrentThread());
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UnpackSuccessInstallSource",
                             install_source(), Manifest::NUM_LOCATIONS);
 
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UnpackSuccessInstallCause",
                             install_cause(),
                             extension_misc::NUM_INSTALL_CAUSES);
 
-  install_checker_.set_extension(extension);
+  extension_ = extension;
   temp_dir_ = temp_dir;
   if (!install_icon.empty())
     install_icon_.reset(new SkBitmap(install_icon));
 
   if (original_manifest)
     original_manifest_.reset(new Manifest(
         Manifest::INVALID_LOCATION,
         std::unique_ptr<base::DictionaryValue>(original_manifest->DeepCopy())));
 
   // We don't have to delete the unpack dir explicity since it is a child of
@@ skipping 58 matching lines @@
                 base::UTF8ToUTF16(extension()->name()),
                 base::UTF8ToUTF16(imported_module->name()))));
         return;
       }
     }
   }
 
   // Run the policy, requirements and blacklist checks in parallel. Skip the
   // checks if the extension is a bookmark app.
   if (extension()->from_bookmark()) {
-    CrxInstaller::OnInstallChecksComplete(0);
+    ConfirmInstall();
   } else {
-    install_checker_.Start(
-        ExtensionInstallChecker::CHECK_ALL,
-        false /* fail fast */,
+    install_checker_ =
+        base::MakeUnique<ExtensionInstallChecker>(profile_, extension_);
+    install_checker_->Start(
+        ExtensionInstallChecker::CHECK_ALL, false /* fail fast */,
         base::Bind(&CrxInstaller::OnInstallChecksComplete, this));
   }
 }
 
 void CrxInstaller::OnInstallChecksComplete(int failed_checks) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_)
     return;
 
   // Check for requirement errors.
-  if (!install_checker_.requirement_errors().empty()) {
+  if (!install_checker_->requirement_errors().empty()) {
     if (error_on_unsupported_requirements_) {
       ReportFailureFromUIThread(
           CrxInstallError(CrxInstallError::ERROR_DECLINED,
                           base::UTF8ToUTF16(base::JoinString(
-                              install_checker_.requirement_errors(), " "))));
+                              install_checker_->requirement_errors(), " "))));
       return;
     }
     install_flags_ |= kInstallFlagHasRequirementErrors;
   }
 
   // Check the blacklist state.
-  if (install_checker_.blacklist_state() == BLACKLISTED_MALWARE) {
+  if (install_checker_->blacklist_state() == BLACKLISTED_MALWARE) {
     install_flags_ |= kInstallFlagIsBlacklistedForMalware;
   }
 
-  if ((install_checker_.blacklist_state() == BLACKLISTED_MALWARE ||
-       install_checker_.blacklist_state() == BLACKLISTED_UNKNOWN) &&
+  if ((install_checker_->blacklist_state() == BLACKLISTED_MALWARE ||
+       install_checker_->blacklist_state() == BLACKLISTED_UNKNOWN) &&
       !allow_silent_install_) {
     // User tried to install a blacklisted extension. Show an error and
     // refuse to install it.
     ReportFailureFromUIThread(CrxInstallError(
         CrxInstallError::ERROR_DECLINED,
         l10n_util::GetStringFUTF16(IDS_EXTENSION_IS_BLACKLISTED,
                                    base::UTF8ToUTF16(extension()->name()))));
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.BlockCRX",
                               extension()->location(),
                               Manifest::NUM_LOCATIONS);
     return;
   }
 
   // NOTE: extension may still be blacklisted, but we're forced to silently
   // install it. In this case, ExtensionService::OnExtensionInstalled needs to
   // deal with it.
 
   // Check for policy errors.
-  if (!install_checker_.policy_error().empty()) {
+  if (!install_checker_->policy_error().empty()) {
     // We don't want to show the error infobar for installs from the WebStore,
     // because the WebStore already shows an error dialog itself.
     // Note: |client_| can be NULL in unit_tests!
     if (extension()->from_webstore() && client_)
       client_->install_ui()->SetSkipPostInstallUI(true);
     ReportFailureFromUIThread(
         CrxInstallError(CrxInstallError::ERROR_DECLINED,
-                        base::UTF8ToUTF16(install_checker_.policy_error())));
+                        base::UTF8ToUTF16(install_checker_->policy_error())));
     return;
   }
 
   ConfirmInstall();
 }
 
 void CrxInstaller::ConfirmInstall() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionService* service = service_weak_.get();
   if (!service || service->browser_terminating())
     return;
 
-  if (KioskModeInfo::IsKioskOnly(install_checker_.extension().get())) {
+  if (KioskModeInfo::IsKioskOnly(extension())) {
     bool in_kiosk_mode = false;
 #if defined(OS_CHROMEOS)
     user_manager::UserManager* user_manager = user_manager::UserManager::Get();
     in_kiosk_mode = user_manager && user_manager->IsLoggedInAsKioskApp();
 #endif
     if (!in_kiosk_mode) {
       ReportFailureFromUIThread(CrxInstallError(
           CrxInstallError::ERROR_DECLINED,
           l10n_util::GetStringUTF16(IDS_EXTENSION_INSTALL_KIOSK_MODE_ONLY)));
       return;
@@ skipping 118 matching lines @@
 
   // This is lame, but we must reload the extension because absolute paths
   // inside the content scripts are established inside InitFromValue() and we
   // just moved the extension.
   // TODO(aa): All paths to resources inside extensions should be created
   // lazily and based on the Extension's root path at that moment.
   // TODO(rdevlin.cronin): Continue removing std::string errors and replacing
   // with base::string16
   std::string extension_id = extension()->id();
   std::string error;
-  install_checker_.set_extension(
-      file_util::LoadExtension(
-          version_dir,
-          install_source_,
-          // Note: modified by UpdateCreationFlagsAndCompleteInstall.
-          creation_flags_,
-          &error).get());
+  extension_ = file_util::LoadExtension(
+      version_dir, install_source_,
+      // Note: modified by UpdateCreationFlagsAndCompleteInstall.
+      creation_flags_, &error);
 
   if (extension()) {
     ReportSuccessFromFileThread();
   } else {
     LOG(ERROR) << error << " " << extension_id << " " << download_url_;
     ReportFailureFromFileThread(CrxInstallError(base::UTF8ToUTF16(error)));
   }
 }
 
 void CrxInstaller::ReportFailureFromFileThread(const CrxInstallError& error) {
@@ skipping 167 matching lines @@
         ExtensionInstallPrompt::GetReEnablePromptTypeForExtension(
             service->profile(), extension());
     client_->ShowDialog(base::Bind(&CrxInstaller::OnInstallPromptDone, this),
                         extension(), nullptr,
                         base::MakeUnique<ExtensionInstallPrompt::Prompt>(type),
                         ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   }
 }
 
 }  // namespace extensions