Move ContentScripts out of Extension

chrome/common/extensions/extension_file_util.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_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 29 matching lines @@
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 const base::FilePath::CharType kTempDirectoryName[] = FILE_PATH_LITERAL("Temp");
 
 }  // namespace
 
 namespace extension_file_util {
 
-// Returns false and sets the error if script file can't be loaded,
-// or if it's not UTF-8 encoded.
-static bool IsScriptValid(const base::FilePath& path,
-                          const base::FilePath& relative_path,
-                          int message_id, std::string* error);
-
 base::FilePath InstallExtension(const base::FilePath& unpacked_source_dir,
                                 const std::string& id,
                                 const std::string& version,
                                 const base::FilePath& extensions_dir) {
   base::FilePath extension_dir = extensions_dir.AppendASCII(id);
   base::FilePath version_dir;
 
   // Create the extension directory if it doesn't exist already.
   if (!file_util::PathExists(extension_dir)) {
     if (!file_util::CreateDirectory(extension_dir))
@@ skipping 179 matching lines @@
 }
 
 bool ValidateExtension(const Extension* extension,
                        std::string* error,
                        std::vector<extensions::InstallWarning>* warnings) {
   // Ask registered manifest handlers to validate their paths.
   if (!extensions::ManifestHandler::ValidateExtension(
           extension, error, warnings))
     return false;
 
-  // TODO(yoz): Move this to content scripts manifest handler.
-  // Validate that claimed script resources actually exist,
-  // and are UTF-8 encoded.
-  ExtensionResource::SymlinkPolicy symlink_policy;
-  if ((extension->creation_flags() &
-       Extension::FOLLOW_SYMLINKS_ANYWHERE) != 0) {
-    symlink_policy = ExtensionResource::FOLLOW_SYMLINKS_ANYWHERE;
-  } else {
-    symlink_policy = ExtensionResource::SYMLINKS_MUST_RESOLVE_WITHIN_ROOT;
-  }
-
-  for (size_t i = 0; i < extension->content_scripts().size(); ++i) {
-    const extensions::UserScript& script = extension->content_scripts()[i];
-
-    for (size_t j = 0; j < script.js_scripts().size(); j++) {
-      const extensions::UserScript::File& js_script = script.js_scripts()[j];
-      const base::FilePath& path = ExtensionResource::GetFilePath(
-          js_script.extension_root(), js_script.relative_path(),
-          symlink_policy);
-      if (!IsScriptValid(path, js_script.relative_path(),
-                         IDS_EXTENSION_LOAD_JAVASCRIPT_FAILED, error))
-        return false;
-    }
-
-    for (size_t j = 0; j < script.css_scripts().size(); j++) {
-      const extensions::UserScript::File& css_script = script.css_scripts()[j];
-      const base::FilePath& path = ExtensionResource::GetFilePath(
-          css_script.extension_root(), css_script.relative_path(),
-          symlink_policy);
-      if (!IsScriptValid(path, css_script.relative_path(),
-                         IDS_EXTENSION_LOAD_CSS_FAILED, error))
-        return false;
-    }
-  }
-
   // Check children of extension root to see if any of them start with _ and is
   // not on the reserved list.
   if (!CheckForIllegalFilenames(extension->path(), error)) {
     return false;
   }
 
   // Check that extensions don't include private key files.
   std::vector<base::FilePath> private_keys =
       FindPrivateKeyFiles(extension->path());
   if (extension->creation_flags() & Extension::ERROR_ON_PRIVATE_KEY) {
@@ skipping 144 matching lines @@
   }
 
   // Add @@extension_id reserved message here, so it's available to
   // non-localized extensions too.
   returnValue->insert(
       std::make_pair(extensions::MessageBundle::kExtensionIdKey, extension_id));
 
   return returnValue;
 }
 
-static bool IsScriptValid(const base::FilePath& path,
-                          const base::FilePath& relative_path,
-                          int message_id,
-                          std::string* error) {
-  std::string content;
-  if (!file_util::PathExists(path) ||
-      !file_util::ReadFileToString(path, &content)) {
-    *error = l10n_util::GetStringFUTF8(
-        message_id,
-        relative_path.LossyDisplayName());
-    return false;
-  }
-
-  if (!IsStringUTF8(content)) {
-    *error = l10n_util::GetStringFUTF8(
-        IDS_EXTENSION_BAD_FILE_ENCODING,
-        relative_path.LossyDisplayName());
-    return false;
-  }
-
-  return true;
-}
-
 bool CheckForIllegalFilenames(const base::FilePath& extension_path,
                               std::string* error) {
   // Reserved underscore names.
   static const base::FilePath::CharType* reserved_names[] = {
     Extension::kLocaleFolder,
     FILE_PATH_LITERAL("__MACOSX"),
   };
   CR_DEFINE_STATIC_LOCAL(
       std::set<base::FilePath::StringType>, reserved_underscore_names,
       (reserved_names, reserved_names + arraysize(reserved_names)));
@@ skipping 105 matching lines @@
     return base::FilePath();
   }
   return temp_path;
 }
 
 void DeleteFile(const base::FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util