blob: e2babca971330b35f83c961c3a34b7b66afe4bb6 [file] [log] [blame]
// 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/user_script.h"
#include <stddef.h>
#include <stdint.h>
#include <memory>
#include <utility>
#include "base/atomic_sequence_num.h"
#include "base/command_line.h"
#include "base/pickle.h"
#include "base/strings/pattern.h"
#include "base/strings/string_util.h"
#include "extensions/common/switches.h"
namespace {
// This cannot be a plain int or int64_t because we need to generate unique IDs
// from multiple threads.
base::AtomicSequenceNumber g_user_script_id_generator;
bool UrlMatchesGlobs(const std::vector<std::string>* globs,
const GURL& url) {
for (auto glob = globs->cbegin(); glob != globs->cend(); ++glob) {
if (base::MatchPattern(url.spec(), *glob))
return true;
}
return false;
}
} // namespace
namespace extensions {
// The bitmask for valid user script injectable schemes used by URLPattern.
enum {
kValidUserScriptSchemes = URLPattern::SCHEME_CHROMEUI |
URLPattern::SCHEME_HTTP |
URLPattern::SCHEME_HTTPS |
URLPattern::SCHEME_FILE |
URLPattern::SCHEME_FTP
};
// static
const char UserScript::kFileExtension[] = ".user.js";
// static
int UserScript::GenerateUserScriptID() {
return g_user_script_id_generator.GetNext();
}
bool UserScript::IsURLUserScript(const GURL& url,
const std::string& mime_type) {
return base::EndsWith(url.ExtractFileName(), kFileExtension,
base::CompareCase::INSENSITIVE_ASCII) &&
mime_type != "text/html";
}
// static
int UserScript::ValidUserScriptSchemes(bool canExecuteScriptEverywhere) {
if (canExecuteScriptEverywhere)
return URLPattern::SCHEME_ALL;
int valid_schemes = kValidUserScriptSchemes;
if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kExtensionsOnChromeURLs)) {
valid_schemes &= ~URLPattern::SCHEME_CHROMEUI;
}
return valid_schemes;
}
UserScript::File::File(const base::FilePath& extension_root,
const base::FilePath& relative_path,
const GURL& url)
: extension_root_(extension_root),
relative_path_(relative_path),
url_(url) {
}
UserScript::File::File() {}
// File content is not copied.
UserScript::File::File(const File& other)
: extension_root_(other.extension_root_),
relative_path_(other.relative_path_),
url_(other.url_) {}
UserScript::File::~File() {}
UserScript::UserScript()
: run_location_(DOCUMENT_IDLE),
consumer_instance_type_(TAB),
user_script_id_(-1),
emulate_greasemonkey_(false),
match_all_frames_(false),
match_about_blank_(false),
incognito_enabled_(false) {}
UserScript::~UserScript() {
}
// static.
std::unique_ptr<UserScript> UserScript::CopyMetadataFrom(
const UserScript& other) {
std::unique_ptr<UserScript> script(new UserScript());
script->run_location_ = other.run_location_;
script->name_space_ = other.name_space_;
script->name_ = other.name_;
script->description_ = other.description_;
script->version_ = other.version_;
script->globs_ = other.globs_;
script->exclude_globs_ = other.exclude_globs_;
script->url_set_ = other.url_set_;
script->exclude_url_set_ = other.exclude_url_set_;
// Note: File content is not copied.
for (const std::unique_ptr<File>& file : other.js_scripts()) {
std::unique_ptr<File> file_copy(new File(*file));
script->js_scripts_.push_back(std::move(file_copy));
}
for (const std::unique_ptr<File>& file : other.css_scripts()) {
std::unique_ptr<File> file_copy(new File(*file));
script->css_scripts_.push_back(std::move(file_copy));
}
script->host_id_ = other.host_id_;
script->consumer_instance_type_ = other.consumer_instance_type_;
script->user_script_id_ = other.user_script_id_;
script->emulate_greasemonkey_ = other.emulate_greasemonkey_;
script->match_all_frames_ = other.match_all_frames_;
script->match_about_blank_ = other.match_about_blank_;
script->incognito_enabled_ = other.incognito_enabled_;
return script;
}
void UserScript::add_url_pattern(const URLPattern& pattern) {
url_set_.AddPattern(pattern);
}
void UserScript::add_exclude_url_pattern(const URLPattern& pattern) {
exclude_url_set_.AddPattern(pattern);
}
bool UserScript::MatchesURL(const GURL& url) const {
if (!url_set_.is_empty()) {
if (!url_set_.MatchesURL(url))
return false;
}
if (!exclude_url_set_.is_empty()) {
if (exclude_url_set_.MatchesURL(url))
return false;
}
if (!globs_.empty()) {
if (!UrlMatchesGlobs(&globs_, url))
return false;
}
if (!exclude_globs_.empty()) {
if (UrlMatchesGlobs(&exclude_globs_, url))
return false;
}
return true;
}
bool UserScript::MatchesDocument(const GURL& effective_document_url,
bool is_subframe) const {
if (is_subframe && !match_all_frames())
return false;
return MatchesURL(effective_document_url);
}
void UserScript::File::Pickle(base::Pickle* pickle) const {
pickle->WriteString(url_.spec());
// Do not write path. It's not needed in the renderer.
// Do not write content. It will be serialized by other means.
}
void UserScript::File::Unpickle(const base::Pickle& pickle,
base::PickleIterator* iter) {
// Read the url from the pickle.
std::string url;
CHECK(iter->ReadString(&url));
set_url(GURL(url));
}
void UserScript::Pickle(base::Pickle* pickle) const {
// Write the simple types to the pickle.
pickle->WriteInt(run_location());
pickle->WriteInt(user_script_id_);
pickle->WriteBool(emulate_greasemonkey());
pickle->WriteBool(match_all_frames());
pickle->WriteBool(match_about_blank());
pickle->WriteBool(is_incognito_enabled());
PickleHostID(pickle, host_id_);
pickle->WriteInt(consumer_instance_type());
PickleGlobs(pickle, globs_);
PickleGlobs(pickle, exclude_globs_);
PickleURLPatternSet(pickle, url_set_);
PickleURLPatternSet(pickle, exclude_url_set_);
PickleScripts(pickle, js_scripts_);
PickleScripts(pickle, css_scripts_);
}
void UserScript::PickleGlobs(base::Pickle* pickle,
const std::vector<std::string>& globs) const {
pickle->WriteUInt32(globs.size());
for (auto glob = globs.cbegin(); glob != globs.cend(); ++glob) {
pickle->WriteString(*glob);
}
}
void UserScript::PickleHostID(base::Pickle* pickle,
const HostID& host_id) const {
pickle->WriteInt(host_id.type());
pickle->WriteString(host_id.id());
}
void UserScript::PickleURLPatternSet(base::Pickle* pickle,
const URLPatternSet& pattern_list) const {
pickle->WriteUInt32(pattern_list.patterns().size());
for (auto pattern = pattern_list.begin(); pattern != pattern_list.end();
++pattern) {
pickle->WriteInt(pattern->valid_schemes());
pickle->WriteString(pattern->GetAsString());
}
}
void UserScript::PickleScripts(base::Pickle* pickle,
const FileList& scripts) const {
pickle->WriteUInt32(scripts.size());
for (const std::unique_ptr<File>& file : scripts)
file->Pickle(pickle);
}
void UserScript::Unpickle(const base::Pickle& pickle,
base::PickleIterator* iter) {
// Read the run location.
int run_location = 0;
CHECK(iter->ReadInt(&run_location));
CHECK(run_location >= 0 && run_location < RUN_LOCATION_LAST);
run_location_ = static_cast<RunLocation>(run_location);
CHECK(iter->ReadInt(&user_script_id_));
CHECK(iter->ReadBool(&emulate_greasemonkey_));
CHECK(iter->ReadBool(&match_all_frames_));
CHECK(iter->ReadBool(&match_about_blank_));
CHECK(iter->ReadBool(&incognito_enabled_));
UnpickleHostID(pickle, iter, &host_id_);
int consumer_instance_type = 0;
CHECK(iter->ReadInt(&consumer_instance_type));
consumer_instance_type_ =
static_cast<ConsumerInstanceType>(consumer_instance_type);
UnpickleGlobs(pickle, iter, &globs_);
UnpickleGlobs(pickle, iter, &exclude_globs_);
UnpickleURLPatternSet(pickle, iter, &url_set_);
UnpickleURLPatternSet(pickle, iter, &exclude_url_set_);
UnpickleScripts(pickle, iter, &js_scripts_);
UnpickleScripts(pickle, iter, &css_scripts_);
}
void UserScript::UnpickleGlobs(const base::Pickle& pickle,
base::PickleIterator* iter,
std::vector<std::string>* globs) {
uint32_t num_globs = 0;
CHECK(iter->ReadUInt32(&num_globs));
globs->clear();
for (uint32_t i = 0; i < num_globs; ++i) {
std::string glob;
CHECK(iter->ReadString(&glob));
globs->push_back(glob);
}
}
void UserScript::UnpickleHostID(const base::Pickle& pickle,
base::PickleIterator* iter,
HostID* host_id) {
int type = 0;
std::string id;
CHECK(iter->ReadInt(&type));
CHECK(iter->ReadString(&id));
*host_id = HostID(static_cast<HostID::HostType>(type), id);
}
void UserScript::UnpickleURLPatternSet(const base::Pickle& pickle,
base::PickleIterator* iter,
URLPatternSet* pattern_list) {
uint32_t num_patterns = 0;
CHECK(iter->ReadUInt32(&num_patterns));
pattern_list->ClearPatterns();
for (uint32_t i = 0; i < num_patterns; ++i) {
int valid_schemes;
CHECK(iter->ReadInt(&valid_schemes));
std::string pattern_str;
CHECK(iter->ReadString(&pattern_str));
URLPattern pattern(kValidUserScriptSchemes);
URLPattern::ParseResult result = pattern.Parse(pattern_str);
CHECK(URLPattern::ParseResult::kSuccess == result)
<< URLPattern::GetParseResultString(result) << " "
<< pattern_str.c_str();
pattern.SetValidSchemes(valid_schemes);
pattern_list->AddPattern(pattern);
}
}
void UserScript::UnpickleScripts(const base::Pickle& pickle,
base::PickleIterator* iter,
FileList* scripts) {
uint32_t num_files = 0;
CHECK(iter->ReadUInt32(&num_files));
scripts->clear();
for (uint32_t i = 0; i < num_files; ++i) {
std::unique_ptr<File> file(new File());
file->Unpickle(pickle, iter);
scripts->push_back(std::move(file));
}
}
UserScriptIDPair::UserScriptIDPair(int id, const HostID& host_id)
: id(id), host_id(host_id) {}
UserScriptIDPair::UserScriptIDPair(int id) : id(id), host_id(HostID()) {}
bool operator<(const UserScriptIDPair& a, const UserScriptIDPair& b) {
return a.id < b.id;
}
} // namespace extensions