src/chrome/browser/extensions/convert_user_script.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/convert_user_script.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/base64.h"
  11 #include "base/file_util.h"
  12 #include "base/files/file_path.h"
  13 #include "base/files/scoped_temp_dir.h"
  14 #include "base/json/json_file_value_serializer.h"
  15 #include "base/path_service.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "chrome/browser/extensions/user_script_master.h"
  19 #include "chrome/common/chrome_paths.h"
  20 #include "crypto/sha2.h"
  21 #include "extensions/common/constants.h"
  22 #include "extensions/common/extension.h"
  23 #include "extensions/common/file_util.h"
  24 #include "extensions/common/manifest_constants.h"
  25 #include "extensions/common/user_script.h"
  26 #include "url/gurl.h"
  27
  28 namespace extensions {
  29
  30 namespace keys = manifest_keys;
  31 namespace values = manifest_values;
  32
  33 scoped_refptr<Extension> ConvertUserScriptToExtension(
  34     const base::FilePath& user_script_path, const GURL& original_url,
  35     const base::FilePath& extensions_dir, base::string16* error) {
  36   std::string content;
  37   if (!base::ReadFileToString(user_script_path, &content)) {
  38     *error = base::ASCIIToUTF16("Could not read source file.");
  39     return NULL;
  40   }
  41
  42   if (!base::IsStringUTF8(content)) {
  43     *error = base::ASCIIToUTF16("User script must be UTF8 encoded.");
  44     return NULL;
  45   }
  46
  47   UserScript script;
  48   if (!UserScriptMaster::ScriptReloader::ParseMetadataHeader(content,
  49                                                              &script)) {
  50     *error = base::ASCIIToUTF16("Invalid script header.");
  51     return NULL;
  52   }
  53
  54   base::FilePath install_temp_dir =
  55       file_util::GetInstallTempDir(extensions_dir);
  56   if (install_temp_dir.empty()) {
  57     *error = base::ASCIIToUTF16(
  58         "Could not get path to profile temporary directory.");
  59     return NULL;
  60   }
  61
  62   base::ScopedTempDir temp_dir;
  63   if (!temp_dir.CreateUniqueTempDirUnderPath(install_temp_dir)) {
  64     *error = base::ASCIIToUTF16("Could not create temporary directory.");
  65     return NULL;
  66   }
  67
  68   // Create the manifest
  69   scoped_ptr<base::DictionaryValue> root(new base::DictionaryValue);
  70   std::string script_name;
  71   if (!script.name().empty() && !script.name_space().empty())
  72     script_name = script.name_space() + "/" + script.name();
  73   else
  74     script_name = original_url.spec();
  75
  76   // Create the public key.
  77   // User scripts are not signed, but the public key for an extension doubles as
  78   // its unique identity, and we need one of those. A user script's unique
  79   // identity is its namespace+name, so we hash that to create a public key.
  80   // There will be no corresponding private key, which means user scripts cannot
  81   // be auto-updated, or claimed in the gallery.
  82   char raw[crypto::kSHA256Length] = {0};
  83   std::string key;
  84   crypto::SHA256HashString(script_name, raw, crypto::kSHA256Length);
  85   base::Base64Encode(std::string(raw, crypto::kSHA256Length), &key);
  86
  87   // The script may not have a name field, but we need one for an extension. If
  88   // it is missing, use the filename of the original URL.
  89   if (!script.name().empty())
  90     root->SetString(keys::kName, script.name());
  91   else
  92     root->SetString(keys::kName, original_url.ExtractFileName());
  93
  94   // Not all scripts have a version, but we need one. Default to 1.0 if it is
  95   // missing.
  96   if (!script.version().empty())
  97     root->SetString(keys::kVersion, script.version());
  98   else
  99     root->SetString(keys::kVersion, "1.0");
 100
 101   root->SetString(keys::kDescription, script.description());
 102   root->SetString(keys::kPublicKey, key);
 103   root->SetBoolean(keys::kConvertedFromUserScript, true);
 104
 105   base::ListValue* js_files = new base::ListValue();
 106   js_files->Append(new base::StringValue("script.js"));
 107
 108   // If the script provides its own match patterns, we use those. Otherwise, we
 109   // generate some using the include globs.
 110   base::ListValue* matches = new base::ListValue();
 111   if (!script.url_patterns().is_empty()) {
 112     for (URLPatternSet::const_iterator i = script.url_patterns().begin();
 113          i != script.url_patterns().end(); ++i) {
 114       matches->Append(new base::StringValue(i->GetAsString()));
 115     }
 116   } else {
 117     // TODO(aa): Derive tighter matches where possible.
 118     matches->Append(new base::StringValue("http://*/*"));
 119     matches->Append(new base::StringValue("https://*/*"));
 120   }
 121
 122   // Read the exclude matches, if any are present.
 123   base::ListValue* exclude_matches = new base::ListValue();
 124   if (!script.exclude_url_patterns().is_empty()) {
 125     for (URLPatternSet::const_iterator i =
 126          script.exclude_url_patterns().begin();
 127          i != script.exclude_url_patterns().end(); ++i) {
 128       exclude_matches->Append(new base::StringValue(i->GetAsString()));
 129     }
 130   }
 131
 132   base::ListValue* includes = new base::ListValue();
 133   for (size_t i = 0; i < script.globs().size(); ++i)
 134     includes->Append(new base::StringValue(script.globs().at(i)));
 135
 136   base::ListValue* excludes = new base::ListValue();
 137   for (size_t i = 0; i < script.exclude_globs().size(); ++i)
 138     excludes->Append(new base::StringValue(script.exclude_globs().at(i)));
 139
 140   base::DictionaryValue* content_script = new base::DictionaryValue();
 141   content_script->Set(keys::kMatches, matches);
 142   content_script->Set(keys::kExcludeMatches, exclude_matches);
 143   content_script->Set(keys::kIncludeGlobs, includes);
 144   content_script->Set(keys::kExcludeGlobs, excludes);
 145   content_script->Set(keys::kJs, js_files);
 146
 147   if (script.run_location() == UserScript::DOCUMENT_START)
 148     content_script->SetString(keys::kRunAt, values::kRunAtDocumentStart);
 149   else if (script.run_location() == UserScript::DOCUMENT_END)
 150     content_script->SetString(keys::kRunAt, values::kRunAtDocumentEnd);
 151   else if (script.run_location() == UserScript::DOCUMENT_IDLE)
 152     // This is the default, but store it just in case we change that.
 153     content_script->SetString(keys::kRunAt, values::kRunAtDocumentIdle);
 154
 155   base::ListValue* content_scripts = new base::ListValue();
 156   content_scripts->Append(content_script);
 157
 158   root->Set(keys::kContentScripts, content_scripts);
 159
 160   base::FilePath manifest_path = temp_dir.path().Append(kManifestFilename);
 161   JSONFileValueSerializer serializer(manifest_path);
 162   if (!serializer.Serialize(*root)) {
 163     *error = base::ASCIIToUTF16("Could not write JSON.");
 164     return NULL;
 165   }
 166
 167   // Write the script file.
 168   if (!base::CopyFile(user_script_path,
 169                       temp_dir.path().AppendASCII("script.js"))) {
 170     *error = base::ASCIIToUTF16("Could not copy script file.");
 171     return NULL;
 172   }
 173
 174   // TODO(rdevlin.cronin): Continue removing std::string errors and replacing
 175   // with base::string16
 176   std::string utf8_error;
 177   scoped_refptr<Extension> extension = Extension::Create(
 178       temp_dir.path(),
 179       Manifest::INTERNAL,
 180       *root,
 181       Extension::NO_FLAGS,
 182       &utf8_error);
 183   *error = base::UTF8ToUTF16(utf8_error);
 184   if (!extension.get()) {
 185     NOTREACHED() << "Could not init extension " << *error;
 186     return NULL;
 187   }
 188
 189   temp_dir.Take();  // The caller takes ownership of the directory.
 190   return extension;
 191 }
 192
 193 }  // namespace extensions