Define the ExtensionId typedef, and use it in extension.h.

extensions/common/extension.h

 // Copyright (c) 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_EXTENSION_H_
 #define EXTENSIONS_COMMON_EXTENSION_H_
 
 #include <algorithm>
 #include <iosfwd>
 #include <map>
@@ skipping 30 matching lines @@
 namespace gfx {
 class ImageSkia;
 }
 
 namespace extensions {
 class PermissionsData;
 class APIPermissionSet;
 class ManifestPermissionSet;
 class PermissionSet;
 
+// Uniquely identifies an Extension, using 32 characters from the alphabet
+// 'a'-'p'.  An empty string represents "no extension".
+//
+// Note: If this gets used heavily in files that don't otherwise need to include
+// extension.h, we should pull it into a dedicated header.
+typedef std::string ExtensionId;
+
 // Represents a Chrome extension.
 // Once created, an Extension object is immutable, with the exception of its
 // RuntimeData. This makes it safe to use on any thread, since access to the
 // RuntimeData is protected by a lock.
 class Extension : public base::RefCountedThreadSafe<Extension> {
  public:
   struct ManifestData;
 
   typedef std::map<const std::string, linked_ptr<ManifestData> >
       ManifestDataMap;
@@ skipping 103 matching lines @@
                                          const base::DictionaryValue& value,
                                          int flags,
                                          std::string* error);
 
   // In a few special circumstances, we want to create an Extension and give it
   // an explicit id. Most consumers should just use the other Create() method.
   static scoped_refptr<Extension> Create(const base::FilePath& path,
                                          Manifest::Location location,
                                          const base::DictionaryValue& value,
                                          int flags,
-                                         const std::string& explicit_id,
+                                         const ExtensionId& explicit_id,
                                          std::string* error);
 
   // Valid schemes for web extent URLPatterns.
   static const int kValidWebExtentSchemes;
 
   // Valid schemes for host permission URLPatterns.
   static const int kValidHostPermissionSchemes;
 
   // The mimetype used for extensions.
   static const char kMimeType[];
@@ skipping 35 matching lines @@
   // Does a simple base64 encoding of |input| into |output|.
   static bool ProducePEM(const std::string& input, std::string* output);
 
   // Expects base64 encoded |input| and formats into |output| including
   // the appropriate header & footer.
   static bool FormatPEMForFileOutput(const std::string& input,
                                      std::string* output,
                                      bool is_public);
 
   // Returns the base extension url for a given |extension_id|.
-  static GURL GetBaseURLFromExtensionId(const std::string& extension_id);
+  static GURL GetBaseURLFromExtensionId(const ExtensionId& extension_id);
 
   // DEPRECATED: These methods have been moved to PermissionsData.
   // TODO(rdevlin.cronin): remove these once all calls have been updated.
   bool HasAPIPermission(APIPermission::ID permission) const;
   bool HasAPIPermission(const std::string& permission_name) const;
   scoped_refptr<const PermissionSet> GetActivePermissions() const;
 
   // Whether context menu should be shown for page and browser actions.
   bool ShowConfigureContextMenus() const;
 
@@ skipping 26 matching lines @@
   // Sets |data| to be associated with the key. Takes ownership of |data|.
   // Can only be called before InitValue is finished. Not thread-safe;
   // all SetManifestData calls should be on only one thread.
   void SetManifestData(const std::string& key, ManifestData* data);
 
   // Accessors:
 
   const base::FilePath& path() const { return path_; }
   const GURL& url() const { return extension_url_; }
   Manifest::Location location() const;
-  const std::string& id() const;
+  const ExtensionId& id() const;
   const base::Version* version() const { return version_.get(); }
   const std::string VersionString() const;
   const std::string& name() const { return name_; }
   const std::string& short_name() const { return short_name_; }
   const std::string& non_localized_name() const { return non_localized_name_; }
   // Base64-encoded version of the key used to sign this extension.
   // In pseudocode, returns
   // base::Base64Encode(RSAPrivateKey(pem_file).ExportPublicKey()).
   const std::string& public_key() const { return public_key_; }
   const std::string& description() const { return description_; }
@@ skipping 45 matching lines @@
   // Theme-related.
   bool is_theme() const;
 
  private:
   friend class base::RefCountedThreadSafe<Extension>;
 
   // Chooses the extension ID for an extension based on a variety of criteria.
   // The chosen ID will be set in |manifest|.
   static bool InitExtensionID(extensions::Manifest* manifest,
                               const base::FilePath& path,
-                              const std::string& explicit_id,
+                              const ExtensionId& explicit_id,
                               int creation_flags,
                               base::string16* error);
 
   Extension(const base::FilePath& path,
             scoped_ptr<extensions::Manifest> manifest);
   virtual ~Extension();
 
   // Initialize the extension from a parsed manifest.
   // TODO(aa): Rename to just Init()? There's no Value here anymore.
   // TODO(aa): It is really weird the way this class essentially contains a copy
@@ skipping 99 matching lines @@
   // granted it that access).
   bool wants_file_access_;
 
   // The flags that were passed to InitFromValue.
   int creation_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(Extension);
 };
 
 typedef std::vector<scoped_refptr<const Extension> > ExtensionList;
-typedef std::set<std::string> ExtensionIdSet;
-typedef std::vector<std::string> ExtensionIdList;
+typedef std::set<ExtensionId> ExtensionIdSet;
+typedef std::vector<ExtensionId> ExtensionIdList;
 
 // Handy struct to pass core extension info around.
 struct ExtensionInfo {
   ExtensionInfo(const base::DictionaryValue* manifest,
-                const std::string& id,
+                const ExtensionId& id,
                 const base::FilePath& path,
                 Manifest::Location location);
   ~ExtensionInfo();
 
   scoped_ptr<base::DictionaryValue> extension_manifest;
-  std::string extension_id;
+  ExtensionId extension_id;
   base::FilePath extension_path;
   Manifest::Location extension_location;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionInfo);
 };
 
 struct InstalledExtensionInfo {
   // The extension being installed - this should always be non-NULL.
   const Extension* extension;
@@ skipping 46 matching lines @@
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
       const PermissionSet* permissions,
       Reason reason);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_EXTENSION_H_