extensions: Generate hash of extension ID at a higher level

extensions/common/features/feature.h

 // Copyright 2013 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.
 
 #ifndef EXTENSIONS_COMMON_FEATURES_FEATURE_H_
 #define EXTENSIONS_COMMON_FEATURES_FEATURE_H_
 
 #include <set>
 #include <string>
 
 #include "base/values.h"
+#include "components/crx_file/id_util.h"
 #include "extensions/common/manifest.h"
 
+using crx_file::id_util::HashedIdInHex;
+
 class GURL;
 
 namespace extensions {
 
 class Extension;
 
 // Represents a single feature accessible to an extension developer, such as a
 // top-level manifest key, a permission, or a programmatic API. A feature can
 // express requirements for where it can be accessed, and supports testing
 // support for those requirements. If platforms are not specified, then feature
@@ skipping 86 matching lines @@
 
   // Tests whether this is an internal API or not.
   virtual bool IsInternal() const = 0;
 
   // Returns true if the feature is available to be parsed into a new extension
   // manifest.
   Availability IsAvailableToManifest(const std::string& extension_id,
                                      Manifest::Type type,
                                      Manifest::Location location,
                                      int manifest_version) const {
-    return IsAvailableToManifest(extension_id, type, location, manifest_version,
+    return IsAvailableToManifest(extension_id, HashedIdInHex(extension_id),
+                                 type, location, manifest_version,
                                  GetCurrentPlatform());
   }
   virtual Availability IsAvailableToManifest(const std::string& extension_id,
+                                             const std::string& hashed_id,
                                              Manifest::Type type,
                                              Manifest::Location location,
                                              int manifest_version,
                                              Platform platform) const = 0;
 
   // Returns true if the feature is available to |extension|.
   Availability IsAvailableToExtension(const Extension* extension) const;
 
   // Returns true if the feature is available to be used in the specified
   // extension and context.
@@ skipping 16 matching lines @@
   // without needing to know information about an Extension or any other
   // contextual information. Typically used when the Feature is purely
   // configured by command line flags and/or Chrome channel.
   //
   // Generally try not to use this function. Even if you don't think a Feature
   // relies on an Extension now - maybe it will, one day, so if there's an
   // Extension available (or a runtime context, etc) then use the more targeted
   // method instead.
   Availability IsAvailableToEnvironment() const;
 
-  virtual bool IsIdInBlacklist(const std::string& extension_id) const = 0;
-  virtual bool IsIdInWhitelist(const std::string& extension_id) const = 0;
+  bool IsIdInBlacklist(const std::string& extension_id) {
+    return IsIdInBlacklist(extension_id, HashedIdInHex(extension_id));
+  }
+
+  bool IsIdInWhitelist(const std::string& extension_id) {
+    return IsIdInWhitelist(extension_id, HashedIdInHex(extension_id));
+  }
+
+  virtual bool IsIdInBlacklist(const std::string& extension_id,
+                               const std::string& hashed_id) const = 0;
+  virtual bool IsIdInWhitelist(const std::string& extension_id,
+                               const std::string& hashed_id) const = 0;
 
  protected:
   std::string name_;
   bool no_parent_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_FEATURES_FEATURE_H_