Move CrxFile, FileReader, ExtensionResource to src/extensions.

chrome/common/extensions/extension.cc

 // 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.
 
 #include "chrome/common/extensions/extension.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 29 matching lines @@
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_handler_helpers.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/extensions/permissions/api_permission_set.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
-#include "crypto/sha2.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
+#include "extensions/common/id_util.h"
 #include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/url_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "grit/generated_resources.h"
 #endif
@@ skipping 22 matching lines @@
 const char kKeyBeginFooterMarker[] = "-----END";
 const char kKeyInfoEndMarker[] = "KEY-----";
 const char kPublic[] = "PUBLIC";
 const char kPrivate[] = "PRIVATE";
 
 const int kRSAKeySize = 1024;
 
 const char kDefaultSandboxedPageContentSecurityPolicy[] =
     "sandbox allow-scripts allow-forms allow-popups";
 
-// Converts a normal hexadecimal string into the alphabet used by extensions.
-// We use the characters 'a'-'p' instead of '0'-'f' to avoid ever having a
-// completely numeric host, since some software interprets that as an IP
-// address.
-static void ConvertHexadecimalToIDAlphabet(std::string* id) {
-  for (size_t i = 0; i < id->size(); ++i) {
-    int val;
-    if (base::HexStringToInt(base::StringPiece(id->begin() + i,
-                                               id->begin() + i + 1),
-                             &val)) {
-      (*id)[i] = val + 'a';
-    } else {
-      (*id)[i] = 'a';
-    }
-  }
-}
-
 // A singleton object containing global data needed by the extension objects.
 class ExtensionConfig {
  public:
   static ExtensionConfig* GetInstance() {
     return Singleton<ExtensionConfig>::get();
   }
 
   Extension::ScriptingWhitelist* whitelist() { return &scripting_whitelist_; }
 
  private:
@@ skipping 68 matching lines @@
 scoped_ptr<ActionInfo> LoadExtensionActionInfoHelper(
     const Extension* extension,
     const DictionaryValue* extension_action,
     string16* error) {
   return manifest_handler_helpers::LoadActionInfo(
       extension, extension_action, error);
 }
 
 }  // namespace
 
-const base::FilePath::CharType Extension::kManifestFilename[] =
-    FILE_PATH_LITERAL("manifest.json");
-const base::FilePath::CharType Extension::kLocaleFolder[] =
-    FILE_PATH_LITERAL("_locales");
-const base::FilePath::CharType Extension::kMessagesFilename[] =
-    FILE_PATH_LITERAL("messages.json");
-const base::FilePath::CharType Extension::kPlatformSpecificFolder[] =
-    FILE_PATH_LITERAL("_platform_specific");
-
 #if defined(OS_WIN)
 const char Extension::kExtensionRegistryPath[] =
     "Software\\Google\\Chrome\\Extensions";
 #endif
 
-// first 16 bytes of SHA256 hashed public key.
-const size_t Extension::kIdSize = 16;
-
 const char Extension::kMimeType[] = "application/x-chrome-extension";
 
 const int Extension::kValidWebExtentSchemes =
     URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS;
 
 const int Extension::kValidHostPermissionSchemes = URLPattern::SCHEME_CHROMEUI |
                                                    URLPattern::SCHEME_HTTP |
                                                    URLPattern::SCHEME_HTTPS |
                                                    URLPattern::SCHEME_FILE |
                                                    URLPattern::SCHEME_FTP;
@@ skipping 61 matching lines @@
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
   }
 
   return extension;
 }
 
 // static
 bool Extension::IdIsValid(const std::string& id) {
   // Verify that the id is legal.
-  if (id.size() != (kIdSize * 2))
+  if (id.size() != (id_util::kIdSize * 2))
     return false;
 
   // We only support lowercase IDs, because IDs can be used as URL components
   // (where GURL will lowercase it).
   std::string temp = StringToLowerASCII(id);
   for (size_t i = 0; i < temp.size(); i++)
     if (temp[i] < 'a' || temp[i] > 'p')
       return false;
 
   return true;
 }
 
 // static
-std::string Extension::GenerateIdForPath(const base::FilePath& path) {
-  base::FilePath new_path = Extension::MaybeNormalizePath(path);
-  std::string path_bytes =
-      std::string(reinterpret_cast<const char*>(new_path.value().data()),
-                  new_path.value().size() * sizeof(base::FilePath::CharType));
-  std::string id;
-  return GenerateId(path_bytes, &id) ? id : "";
-}
-
-// static
 bool Extension::IsExtension(const base::FilePath& file_name) {
   return file_name.MatchesExtension(chrome::kExtensionFileExtension);
 }
 
 void Extension::GetBasicInfo(bool enabled,
                              DictionaryValue* info) const {
   info->SetString(info_keys::kIdKey, id());
   info->SetString(info_keys::kNameKey, name());
   info->SetBoolean(info_keys::kEnabledKey, enabled);
   info->SetBoolean(info_keys::kKioskEnabledKey, kiosk_enabled());
@@ skipping 112 matching lines @@
   return base::Base64Decode(working, output);
 }
 
 // static
 bool Extension::ProducePEM(const std::string& input, std::string* output) {
   DCHECK(output);
   return (input.length() == 0) ? false : base::Base64Encode(input, output);
 }
 
 // static
-bool Extension::GenerateId(const std::string& input, std::string* output) {
-  DCHECK(output);
-  uint8 hash[Extension::kIdSize];
-  crypto::SHA256HashString(input, hash, sizeof(hash));
-  *output = StringToLowerASCII(base::HexEncode(hash, sizeof(hash)));
-  ConvertHexadecimalToIDAlphabet(output);
-
-  return true;
-}
-
-// static
 bool Extension::FormatPEMForFileOutput(const std::string& input,
                                        std::string* output,
                                        bool is_public) {
   DCHECK(output);
   if (input.length() == 0)
     return false;
   *output = "";
   output->append(kKeyBeginHeaderMarker);
   output->append(" ");
   output->append(is_public ? kPublic : kPrivate);
@@ skipping 708 matching lines @@
                                 int creation_flags,
                                 string16* error) {
   if (!explicit_id.empty()) {
     manifest->set_extension_id(explicit_id);
     return true;
   }
 
   if (manifest->HasKey(keys::kPublicKey)) {
     std::string public_key;
     std::string public_key_bytes;
-    std::string extension_id;
     if (!manifest->GetString(keys::kPublicKey, &public_key) ||
-        !ParsePEMKeyBytes(public_key, &public_key_bytes) ||
-        !GenerateId(public_key_bytes, &extension_id)) {
+        !ParsePEMKeyBytes(public_key, &public_key_bytes)) {
       *error = ASCIIToUTF16(errors::kInvalidKey);
       return false;
     }
+    std::string extension_id = id_util::GenerateId(public_key_bytes);
     manifest->set_extension_id(extension_id);
     return true;
   }
 
   if (creation_flags & REQUIRE_KEY) {
     *error = ASCIIToUTF16(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.
-    std::string extension_id = GenerateIdForPath(path);
+    std::string extension_id = id_util::GenerateIdForPath(path);
     if (extension_id.empty()) {
       NOTREACHED() << "Could not create ID from path.";
       return false;
     }
     manifest->set_extension_id(extension_id);
     return true;
   }
 }
 
-// static
-base::FilePath Extension::MaybeNormalizePath(const base::FilePath& path) {
-#if defined(OS_WIN)
-  // Normalize any drive letter to upper-case. We do this for consistency with
-  // net_utils::FilePathToFileURL(), which does the same thing, to make string
-  // comparisons simpler.
-  std::wstring path_str = path.value();
-  if (path_str.size() >= 2 && path_str[0] >= L'a' && path_str[0] <= L'z' &&
-      path_str[1] == ':')
-    path_str[0] += ('A' - 'a');
-
-  return base::FilePath(path_str);
-#else
-  return path;
-#endif
-}
-
 bool Extension::LoadManagedModeFeatures(string16* error) {
   if (!manifest_->HasKey(keys::kContentPack))
     return true;
   const DictionaryValue* content_pack_value = NULL;
   if (!manifest_->GetDictionary(keys::kContentPack, &content_pack_value)) {
     *error = ASCIIToUTF16(errors::kInvalidContentPack);
     return false;
   }
 
   if (!LoadManagedModeSites(content_pack_value, error))
@@ skipping 45 matching lines @@
       finished_parsing_manifest_(false),
       is_storage_isolated_(false),
       launch_container_(extension_misc::LAUNCH_TAB),
       launch_width_(0),
       launch_height_(0),
       display_in_launcher_(true),
       display_in_new_tab_page_(true),
       wants_file_access_(false),
       creation_flags_(0) {
   DCHECK(path.empty() || path.IsAbsolute());
-  path_ = MaybeNormalizePath(path);
+  path_ = id_util::MaybeNormalizePath(path);
 }
 
 Extension::~Extension() {
 }
 
 bool Extension::InitFromValue(int flags, string16* error) {
   DCHECK(error);
 
   base::AutoLock auto_lock(runtime_data_lock_);
 
@@ skipping 1199 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions