Replace bools in extension creation with flags.

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 257 matching lines @@
      URLPattern::SCHEME_CHROMEUI) & ~URLPattern::SCHEME_FILE;
 
 //
 // Extension
 //
 
 // static
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
                                            Location location,
                                            const DictionaryValue& value,
-                                           bool require_key,
-                                           bool strict_error_checks,
+                                           int flags,
                                            std::string* error) {
   scoped_refptr<Extension> extension = new Extension(path, location);
 
-  if (!extension->InitFromValue(value, require_key, strict_error_checks, error))
+  if (!extension->InitFromValue(value, flags, error))
     return NULL;
   return extension;
 }
 
 namespace {
 const char* kGalleryUpdateHttpUrl =
     "http://clients2.google.com/service/update2/crx";
 const char* kGalleryUpdateHttpsUrl =
     "https://clients2.google.com/service/update2/crx";
 }  // namespace
@@ skipping 1101 matching lines @@
   }
 
   result->swap(decoded);
 }
 
 GURL Extension::GetBaseURLFromExtensionId(const std::string& extension_id) {
   return GURL(std::string(chrome::kExtensionScheme) +
               chrome::kStandardSchemeSeparator + extension_id + "/");
 }
 
-bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
-                              bool strict_error_checks, std::string* error) {
+bool Extension::InitFromValue(const DictionaryValue& source, int flags,
+                              std::string* error) {
   // When strict error checks are enabled, make URL pattern parsing strict.
   URLPattern::ParseOption parse_strictness =
-      (strict_error_checks ? URLPattern::PARSE_STRICT
-                           : URLPattern::PARSE_LENIENT);
+      (flags & STRICT_ERROR_CHECKS ? URLPattern::PARSE_STRICT
+                                   : URLPattern::PARSE_LENIENT);
 
   if (source.HasKey(keys::kPublicKey)) {
     std::string public_key_bytes;
     if (!source.GetString(keys::kPublicKey,
                           &public_key_) ||
         !ParsePEMKeyBytes(public_key_,
                           &public_key_bytes) ||
         !GenerateId(public_key_bytes, &id_)) {
       *error = errors::kInvalidKey;
       return false;
     }
-  } else if (require_key) {
+  } else if (flags & REQUIRE_KEY) {
     *error = errors::kInvalidKey;
     return false;
   } else {
     // If there is a path, we generate the ID from it. This is useful for
     // development mode, because it keeps the ID stable across restarts and
     // reloading the extension.
     id_ = Extension::GenerateIdForPath(path());
     if (id_.empty()) {
       NOTREACHED() << "Could not create ID from path.";
       return false;
@@ skipping 1127 matching lines @@
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}
 
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     Reason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}