Cleanup: Make ExtensionService::OnExtensionInstalled take a bitmask instead of

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 "base/bind.h"
@@ skipping 26 matching lines @@
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/browser/install_flag.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/user_script.h"
@@ skipping 66 matching lines @@
       // 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),
-      has_requirement_errors_(false),
-      blacklist_state_(extensions::NOT_BLACKLISTED),
-      install_wait_for_idle_(true),
       update_from_settings_page_(false),
-      is_ephemeral_(false),
+      install_flags_(kInstallFlagNone),
       installer_(service_weak->profile()) {
   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()->set_skip_post_install_ui(
         approval->skip_post_install_ui);
   }
 
   if (approval->skip_install_dialog) {
     // Mark the extension as approved, but save the expected manifest and ID
     // so we can check that they match the CRX's.
     approved_ = true;
     expected_manifest_check_level_ = approval->manifest_check_level;
     if (expected_manifest_check_level_ !=
         WebstoreInstaller::MANIFEST_CHECK_LEVEL_NONE)
       expected_manifest_.reset(approval->manifest->DeepCopy());
     expected_id_ = approval->extension_id;
   }
   if (approval->minimum_version.get()) {
     expected_version_.reset(new Version(*approval->minimum_version));
     expected_version_strict_checking_ = false;
   }
 
   show_dialog_callback_ = approval->show_dialog_callback;
-  is_ephemeral_ = approval->is_ephemeral;
+  set_is_ephemeral(approval->is_ephemeral);
 }
 
 CrxInstaller::~CrxInstaller() {
   // Make sure the UI is deleted on the ui thread.
   if (client_) {
     BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, client_);
     client_ = NULL;
   }
 }
 
@@ skipping 343 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_)
     return;
 
   if (!requirement_errors.empty()) {
     if (error_on_unsupported_requirements_) {
       ReportFailureFromUIThread(CrxInstallerError(
           base::UTF8ToUTF16(JoinString(requirement_errors, ' '))));
       return;
     }
-    has_requirement_errors_ = true;
+    install_flags_ |= kInstallFlagHasRequirementErrors;
   }
 
   ExtensionSystem::Get(profile())->blacklist()->IsBlacklisted(
       extension()->id(),
       base::Bind(&CrxInstaller::OnBlacklistChecked, this));
 }
 
 void CrxInstaller::OnBlacklistChecked(
     extensions::BlacklistState blacklist_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!service_weak_)
     return;
 
-  blacklist_state_ = blacklist_state;
+  if (blacklist_state == extensions::BLACKLISTED_MALWARE) {
+    install_flags_ |= kInstallFlagIsBlacklistedForMalware;
+  }
 
-  if ((blacklist_state_ == extensions::BLACKLISTED_MALWARE ||
-       blacklist_state_ == extensions::BLACKLISTED_UNKNOWN) &&
+  if ((blacklist_state == extensions::BLACKLISTED_MALWARE ||
+       blacklist_state == extensions::BLACKLISTED_UNKNOWN) &&
       !allow_silent_install_) {
     // User tried to install a blacklisted extension. Show an error and
     // refuse to install it.
     ReportFailureFromUIThread(extensions::CrxInstallerError(
         l10n_util::GetStringFUTF16(IDS_EXTENSION_IS_BLACKLISTED,
                                    base::UTF8ToUTF16(extension()->name()))));
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.BlockCRX",
                               extension()->location(),
                               Manifest::NUM_LOCATIONS);
     return;
@@ skipping 251 matching lines @@
 
     // We update the extension's granted permissions if the user already
     // approved the install (client_ is non NULL), or we are allowed to install
     // this silently.
     if ((client_ || allow_silent_install_) && grant_permissions_) {
       PermissionsUpdater perms_updater(profile());
       perms_updater.GrantActivePermissions(extension());
     }
   }
 
-  service_weak_->OnExtensionInstalled(extension(),
-                                      page_ordinal_,
-                                      has_requirement_errors_,
-                                      blacklist_state_,
-                                      is_ephemeral_,
-                                      install_wait_for_idle_);
+  service_weak_->OnExtensionInstalled(
+      extension(), page_ordinal_, install_flags_);
   NotifyCrxInstallComplete(true);
 }
 
 void CrxInstaller::NotifyCrxInstallBegin() {
   InstallTrackerFactory::GetForProfile(profile())
       ->OnBeginCrxInstall(expected_id_);
 }
 
 void CrxInstaller::NotifyCrxInstallComplete(bool success) {
   // Some users (such as the download shelf) need to know when a
@@ skipping 71 matching lines @@
   if (!prefs->DidExtensionEscalatePermissions(extension()->id()))
     return;
 
   if (client_) {
     AddRef();  // Balanced in InstallUIProceed() and InstallUIAbort().
     client_->ConfirmReEnable(this, extension());
   }
 }
 
 }  // namespace extensions