Replace bools in extension creation with flags.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2011 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 181 matching lines @@
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   frontend_ = frontend;
 
   // Explicit UI loads are always noisy.
   alert_on_error_ = true;
 
   FilePath extension_path = path_in;
   file_util::AbsolutePath(&extension_path);
 
+  int flags = Extension::NO_FLAGS;
+  if (Extension::ShouldDoStrictErrorChecking(Extension::LOAD))
+    flags |= Extension::STRICT_ERROR_CHECKS;
   std::string error;
   scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
       extension_path,
       Extension::LOAD,
-      false,  // Don't require id
-      Extension::ShouldDoStrictErrorChecking(Extension::LOAD),
+      flags,
       &error));
 
   if (!extension) {
     ReportExtensionLoadError(extension_path, error);
     return;
   }
 
   // Report this as an installed extension so that it gets remembered in the
   // prefs.
   BrowserThread::PostTask(
@@ skipping 519 matching lines @@
 
 void ExtensionService::LoadComponentExtension(
     const ComponentExtensionInfo &info) {
   JSONStringValueSerializer serializer(info.manifest);
   scoped_ptr<Value> manifest(serializer.Deserialize(NULL, NULL));
   if (!manifest.get()) {
     DLOG(ERROR) << "Failed to parse manifest for extension";
     return;
   }
 
+  int flags = Extension::REQUIRE_KEY;
+  if (Extension::ShouldDoStrictErrorChecking(Extension::COMPONENT))
+    flags |= Extension::STRICT_ERROR_CHECKS;
   std::string error;
   scoped_refptr<const Extension> extension(Extension::Create(
       info.root_directory,
       Extension::COMPONENT,
       *static_cast<DictionaryValue*>(manifest.get()),
-      true,  // Require key
-      Extension::ShouldDoStrictErrorChecking(Extension::COMPONENT),
+      flags,
       &error));
   if (!extension.get()) {
     NOTREACHED() << error;
     return;
   }
   AddExtension(extension);
 }
 
 void ExtensionService::LoadAllExtensions() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 20 matching lines @@
 
     if (reload_reason != NOT_NEEDED) {
       // Reloading and extension reads files from disk.  We do this on the
       // UI thread because reloads should be very rare, and the complexity
       // added by delaying the time when the extensions service knows about
       // all extensions is significant.  See crbug.com/37548 for details.
       // |allow_io| disables tests that file operations run on the file
       // thread.
       base::ThreadRestrictions::ScopedAllowIO allow_io;
 
+      int flags = Extension::NO_FLAGS;
+      if (Extension::ShouldDoStrictErrorChecking(info->extension_location))
+        flags |= Extension::STRICT_ERROR_CHECKS;
       std::string error;
       scoped_refptr<const Extension> extension(
           extension_file_util::LoadExtension(
               info->extension_path,
               info->extension_location,
-              false,  // Don't require key
-              Extension::ShouldDoStrictErrorChecking(info->extension_location),
+              flags,
               &error));
 
       if (extension.get()) {
         extensions_info->at(i)->extension_manifest.reset(
             static_cast<DictionaryValue*>(
                 extension->manifest_value()->DeepCopy()));
         should_write_prefs = true;
       }
     }
   }
@@ skipping 93 matching lines @@
                            browser_action_count);
 }
 
 void ExtensionService::LoadInstalledExtension(const ExtensionInfo& info,
                                               bool write_to_prefs) {
   std::string error;
   scoped_refptr<const Extension> extension(NULL);
   if (!extension_prefs_->IsExtensionAllowedByPolicy(info.extension_id)) {
     error = errors::kDisabledByPolicy;
   } else if (info.extension_manifest.get()) {
-    bool require_key = info.extension_location != Extension::LOAD;
+    int flags = Extension::NO_FLAGS;
+    if (info.extension_location != Extension::LOAD)
+      flags |= Extension::REQUIRE_KEY;
+    if (Extension::ShouldDoStrictErrorChecking(info.extension_location))
+      flags |= Extension::STRICT_ERROR_CHECKS;
     extension = Extension::Create(
         info.extension_path,
         info.extension_location,
         *info.extension_manifest,
-        require_key,
-        Extension::ShouldDoStrictErrorChecking(info.extension_location),
+        flags,
         &error);
   } else {
     error = errors::kManifestUnreadable;
   }
 
   if (!extension) {
     ReportExtensionLoadError(info.extension_path,
                              error,
                              NotificationType::EXTENSION_INSTALL_ERROR,
                              false);
@@ skipping 824 matching lines @@
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
 PropertyBag* ExtensionService::GetPropertyBag(const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
 }