Extensions: Move id_util functions to crx_file component.

extensions/common/manifest_handlers/shared_module_info.cc

 // 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.
 
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
+#include "components/crx_file/id_util.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 namespace extensions {
 
 namespace keys = manifest_keys;
 namespace values = manifest_values;
@@ skipping 22 matching lines @@
 SharedModuleInfo::~SharedModuleInfo() {
 }
 
 // static
 void SharedModuleInfo::ParseImportedPath(const std::string& path,
                                          std::string* import_id,
                                          std::string* import_relative_path) {
   std::vector<std::string> tokens;
   Tokenize(path, std::string("/"), &tokens);
   if (tokens.size() > 2 && tokens[0] == kModulesDir &&
-      Extension::IdIsValid(tokens[1])) {
+      crx_file::id_util::IdIsValid(tokens[1])) {
     *import_id = tokens[1];
     *import_relative_path = tokens[2];
     for (size_t i = 3; i < tokens.size(); ++i)
       *import_relative_path += "/" + tokens[i];
   }
 }
 
 // static
 bool SharedModuleInfo::IsImportedPath(const std::string& path) {
   std::vector<std::string> tokens;
   Tokenize(path, std::string("/"), &tokens);
   if (tokens.size() > 2 && tokens[0] == kModulesDir &&
-      Extension::IdIsValid(tokens[1])) {
+      crx_file::id_util::IdIsValid(tokens[1])) {
     return true;
   }
   return false;
 }
 
 // static
 bool SharedModuleInfo::IsSharedModule(const Extension* extension) {
   CHECK(extension);
   return extension->manifest()->is_shared_module();
 }
@@ skipping 68 matching lines @@
     }
     if (export_value->HasKey(keys::kWhitelist)) {
       const base::ListValue* whitelist = NULL;
       if (!export_value->GetList(keys::kWhitelist, &whitelist)) {
         *error = base::ASCIIToUTF16(errors::kInvalidExportWhitelist);
         return false;
       }
       for (size_t i = 0; i < whitelist->GetSize(); ++i) {
         std::string extension_id;
         if (!whitelist->GetString(i, &extension_id) ||
-            !Extension::IdIsValid(extension_id)) {
+            !crx_file::id_util::IdIsValid(extension_id)) {
           *error = ErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidExportWhitelistString, base::IntToString(i));
           return false;
         }
         export_whitelist_.insert(extension_id);
       }
     }
     for (size_t i = 0; i < resources_list->GetSize(); ++i) {
       std::string resource_path;
       if (!resources_list->GetString(i, &resource_path)) {
@@ skipping 20 matching lines @@
     }
     for (size_t i = 0; i < import_list->GetSize(); ++i) {
       const base::DictionaryValue* import_entry = NULL;
       if (!import_list->GetDictionary(i, &import_entry)) {
         *error = base::ASCIIToUTF16(errors::kInvalidImport);
         return false;
       }
       std::string extension_id;
       imports_.push_back(ImportInfo());
       if (!import_entry->GetString(keys::kId, &extension_id) ||
-          !Extension::IdIsValid(extension_id)) {
+          !crx_file::id_util::IdIsValid(extension_id)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidImportId, base::IntToString(i));
         return false;
       }
       imports_.back().extension_id = extension_id;
       if (import_entry->HasKey(keys::kMinimumVersion)) {
         std::string min_version;
         if (!import_entry->GetString(keys::kMinimumVersion, &min_version)) {
           *error = ErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidImportVersion, base::IntToString(i));
@@ skipping 44 matching lines @@
 
 const std::vector<std::string> SharedModuleHandler::Keys() const {
   static const char* keys[] = {
     keys::kExport,
     keys::kImport
   };
   return std::vector<std::string>(keys, keys + arraysize(keys));
 }
 
 }  // namespace extensions