Convert multiple boolean params to mask in getExtensionByIdInternal.

chrome/browser/extensions/extension_service.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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 507 matching lines @@
 
   ExtensionMediaPlayerEventRouter::GetInstance()->Init(profile_);
   extensions::InputImeEventRouter::GetInstance()->Init();
 #endif
 #endif  // defined(ENABLE_EXTENSIONS)
   event_routers_initialized_ = true;
 }
 
 const Extension* ExtensionService::GetExtensionById(
     const std::string& id, bool include_disabled) const {
-  return GetExtensionByIdInternal(id, true, include_disabled, false);
+  int include_mask = ExtensionService::INCLUDE_ENABLED;
+  if (include_disabled) {
+    include_mask |= ExtensionService::INCLUDE_DISABLED;
+  }
+  return GetExtensionByIdInternal(id, include_mask);
 }
 
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!ready_);  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
   component_loader_->LoadAll();
   extensions::InstalledLoader(this).LoadAllExtensions();
@@ skipping 22 matching lines @@
 bool ExtensionService::UpdateExtension(
     const std::string& id,
     const FilePath& extension_path,
     const GURL& download_url,
     CrxInstaller** out_crx_installer) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const extensions::PendingExtensionInfo* pending_extension_info =
       pending_extension_manager()->GetById(id);
 
+  int include_mask = ExtensionService::INCLUDE_ENABLED;
+  include_mask |= ExtensionService::INCLUDE_DISABLED;
   const Extension* extension =
-      GetExtensionByIdInternal(id, true, true, false);
+      GetExtensionByIdInternal(id, include_mask);
   if (!pending_extension_info && !extension) {
     LOG(WARNING) << "Will not update extension " << id
                  << " because it is not installed or pending";
     // Delete extension_path since we're not creating a CrxInstaller
     // that would do it for us.
     if (!BrowserThread::PostTask(
             BrowserThread::FILE, FROM_HERE,
             base::Bind(
                 &extension_file_util::DeleteFile, extension_path, false)))
       NOTREACHED();
@@ skipping 239 matching lines @@
 
 void ExtensionService::EnableExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (IsExtensionEnabled(extension_id))
     return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::ENABLED);
   extension_prefs_->RemoveDisableReason(extension_id);
 
-  const Extension* extension =
-      GetExtensionByIdInternal(extension_id, false, true, false);
+  const Extension* extension = GetExtensionByIdInternal(extension_id,
+      ExtensionService::INCLUDE_DISABLED);
   // This can happen if sync enables an extension that is not
   // installed yet.
   if (!extension)
     return;
 
   // Move it over to the enabled list.
   extensions_.Insert(make_scoped_refptr(extension));
   disabled_extensions_.Remove(extension->id());
 
   // Make sure any browser action contained within it is not hidden.
@@ skipping 23 matching lines @@
   // |extension| can be NULL if sync disables an extension that is not
   // installed yet.
   if (extension &&
       !system_->management_policy()->UserMayModifySettings(extension, NULL)) {
     return;
   }
 
   extension_prefs_->SetExtensionState(extension_id, Extension::DISABLED);
   extension_prefs_->SetDisableReason(extension_id, disable_reason);
 
-  extension = GetExtensionByIdInternal(extension_id, true, false, true);
+  int include_mask = ExtensionService::INCLUDE_ENABLED;
+  include_mask |= ExtensionService::INCLUDE_TERMINATED;
+  extension = GetExtensionByIdInternal(extension_id, include_mask);
   if (!extension)
     return;
 
   // Move it over to the disabled list.
   disabled_extensions_.Insert(make_scoped_refptr(extension));
   if (extensions_.Contains(extension->id()))
     extensions_.Remove(extension->id());
   else
     terminated_extensions_.Remove(extension->id());
 
@@ skipping 900 matching lines @@
 }
 
 void ExtensionService::HandleExtensionAlertDetails() {
   extension_error_ui_->ShowExtensions();
 }
 
 void ExtensionService::UnloadExtension(
     const std::string& extension_id,
     extension_misc::UnloadedExtensionReason reason) {
   // Make sure the extension gets deleted after we return from this function.
+  int include_mask = ExtensionService::INCLUDE_ENABLED;
+  include_mask |= ExtensionService::INCLUDE_DISABLED;
   scoped_refptr<const Extension> extension(
-      GetExtensionByIdInternal(extension_id, true, true, false));
+      GetExtensionByIdInternal(extension_id, include_mask));
 
   // This method can be called via PostTask, so the extension may have been
   // unloaded by the time this runs.
   if (!extension) {
     // In case the extension may have crashed/uninstalled. Allow the profile to
     // clean up its RequestContexts.
     system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     return;
   }
 
@@ skipping 196 matching lines @@
   // maintain backwards compatibility while still having "omnibox" in the
   // manifest. If a user installs the extension on Chrome 9, the browser
   // will record the permissions it recognized, not including "omnibox."
   // When upgrading to Chrome 10, "omnibox" will be recognized and Chrome
   // will disable the extension and prompt the user to approve the increase
   // in privileges. The extension could then release a new version that
   // removes the "omnibox" permission. When the user upgrades, Chrome will
   // still remember that "omnibox" had been granted, so that if the
   // extension once again includes "omnibox" in an upgrade, the extension
   // can upgrade without requiring this user's approval.
-  const Extension* old = GetExtensionByIdInternal(extension->id(),
-                                                  true, true, false);
+  int include_mask = ExtensionService::INCLUDE_ENABLED;
+  include_mask |= ExtensionService::INCLUDE_DISABLED;
+  const Extension* old =
+      GetExtensionByIdInternal(extension->id(), include_mask);
   bool is_extension_upgrade = old != NULL;
   bool is_privilege_increase = false;
   bool previously_disabled = false;
   Extension::DisableReason disable_reason =
       extension_prefs_->GetDisableReason(extension->id());
 
   // We only need to compare the granted permissions to the current permissions
   // if the extension is not allowed to silently increase its permissions.
   if (!extension->CanSilentlyIncreasePermissions()) {
     // Add all the recognized permissions if the granted permissions list
@@ skipping 116 matching lines @@
     pending_extension_manager()->Remove(id);
   } else {
     // We explicitly want to re-enable an uninstalled external
     // extension; if we're here, that means the user is manually
     // installing the extension.
     if (IsExternalExtensionUninstalled(id)) {
       initial_enable = true;
     }
   }
 
+  int include_mask = ExtensionService::INCLUDE_ENABLED;
+  include_mask |= ExtensionService::INCLUDE_DISABLED;
   // Do not record the install histograms for upgrades.
-  if (!GetExtensionByIdInternal(extension->id(), true, true, false)) {
+  if (!GetExtensionByIdInternal(extension->id(), include_mask)) {
     UMA_HISTOGRAM_ENUMERATION("Extensions.InstallType",
                               extension->GetType(), 100);
     RecordPermissionMessagesHistogram(
         extension, "Extensions.Permissions_Install");
   }
 
   // Certain extension locations are specific enough that we can
   // auto-acknowledge any extension that came from one of them.
   if (extension->location() == Extension::EXTERNAL_POLICY_DOWNLOAD) {
     AcknowledgeExternalExtension(extension->id());
@@ skipping 15 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension));
 
   // Transfer ownership of |extension| to AddExtension.
   AddExtension(scoped_extension);
 }
 
 const Extension* ExtensionService::GetExtensionByIdInternal(
-    const std::string& id, bool include_enabled, bool include_disabled,
-    bool include_terminated) const {
+    const std::string& id, const int include_mask) const {
   std::string lowercase_id = StringToLowerASCII(id);
-  if (include_enabled) {
+  if (include_mask & ExtensionService::INCLUDE_ENABLED) {

[Mihai Parparita -not on Chrome, 2012/08/15 00:10:07]

Nit: since you're in ExtensionService already, you can drop the
ExtensionService:: prefix.

     const Extension* extension = extensions_.GetByID(lowercase_id);
     if (extension)
       return extension;
   }
-  if (include_disabled) {
+  if (include_mask & ExtensionService::INCLUDE_DISABLED) {
     const Extension* extension = disabled_extensions_.GetByID(lowercase_id);
     if (extension)
       return extension;
   }
-  if (include_terminated) {
+  if (include_mask & ExtensionService::INCLUDE_TERMINATED) {
     const Extension* extension = terminated_extensions_.GetByID(lowercase_id);
     if (extension)
       return extension;
   }
   return NULL;
 }
 
 void ExtensionService::TrackTerminatedExtension(const Extension* extension) {
   if (!terminated_extensions_.Contains(extension->id()))
     terminated_extensions_.Insert(make_scoped_refptr(extension));
 
   UnloadExtension(extension->id(), extension_misc::UNLOAD_REASON_TERMINATE);
 }
 
 void ExtensionService::UntrackTerminatedExtension(const std::string& id) {
   std::string lowercase_id = StringToLowerASCII(id);
   terminated_extensions_.Remove(lowercase_id);
 }
 
 const Extension* ExtensionService::GetTerminatedExtension(
     const std::string& id) const {
-  return GetExtensionByIdInternal(id, false, false, true);
+  return GetExtensionByIdInternal(id, ExtensionService::INCLUDE_TERMINATED);
 }
 
 const Extension* ExtensionService::GetInstalledExtension(
     const std::string& id) const {
-  return GetExtensionByIdInternal(id, true, true, true);
+  int include_mask = ExtensionService::INCLUDE_ENABLED;
+  include_mask |= ExtensionService::INCLUDE_DISABLED;
+  include_mask |= ExtensionService::INCLUDE_TERMINATED;
+  return GetExtensionByIdInternal(id, include_mask);
 }
 
 bool ExtensionService::ExtensionBindingsAllowed(const GURL& url) {
   // Allow bindings for all packaged extensions and component hosted apps.
   const Extension* extension = extensions_.GetExtensionOrAppByURL(
       ExtensionURLInfo(url));
   return extension && (!extension->is_hosted_app() ||
                        extension->location() == Extension::COMPONENT);
 }
 
@@ skipping 310 matching lines @@
 
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }