Home | History | Annotate | Download | only in common 
      1 // Copyright 2013 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 "extensions/common/user_script.h"
      6 
      7 #include "base/command_line.h"
      8 #include "base/pickle.h"
      9 #include "base/strings/string_util.h"
     10 #include "extensions/common/switches.h"
     11 
     12 namespace {
     13 
     14 bool UrlMatchesGlobs(const std::vector<std::string>* globs,
     15                      const GURL& url) {
     16   for (std::vector<std::string>::const_iterator glob = globs->begin();
     17        glob != globs->end(); ++glob) {
     18     if (MatchPattern(url.spec(), *glob))
     19       return true;
     20   }
     21 
     22   return false;
     23 }
     24 
     25 }  // namespace
     26 
     27 namespace extensions {
     28 
     29 // The bitmask for valid user script injectable schemes used by URLPattern.
     30 enum {
     31   kValidUserScriptSchemes = URLPattern::SCHEME_CHROMEUI |
     32                             URLPattern::SCHEME_HTTP |
     33                             URLPattern::SCHEME_HTTPS |
     34                             URLPattern::SCHEME_FILE |
     35                             URLPattern::SCHEME_FTP
     36 };
     37 
     38 // static
     39 const char UserScript::kFileExtension[] = ".user.js";
     40 
     41 bool UserScript::IsURLUserScript(const GURL& url,
     42                                  const std::string& mime_type) {
     43   return EndsWith(url.ExtractFileName(), kFileExtension, false) &&
     44       mime_type != "text/html";
     45 }
     46 
     47 // static
     48 int UserScript::ValidUserScriptSchemes(bool canExecuteScriptEverywhere) {
     49   if (canExecuteScriptEverywhere)
     50     return URLPattern::SCHEME_ALL;
     51   int valid_schemes = kValidUserScriptSchemes;
     52   if (!CommandLine::ForCurrentProcess()->HasSwitch(
     53       switches::kExtensionsOnChromeURLs)) {
     54     valid_schemes &= ~URLPattern::SCHEME_CHROMEUI;
     55   }
     56   return valid_schemes;
     57 }
     58 
     59 UserScript::File::File(const base::FilePath& extension_root,
     60                        const base::FilePath& relative_path,
     61                        const GURL& url)
     62     : extension_root_(extension_root),
     63       relative_path_(relative_path),
     64       url_(url) {
     65 }
     66 
     67 UserScript::File::File() {}
     68 
     69 UserScript::File::~File() {}
     70 
     71 UserScript::UserScript()
     72     : run_location_(DOCUMENT_IDLE),
     73       user_script_id_(-1),
     74       emulate_greasemonkey_(false),
     75       match_all_frames_(false),
     76       match_about_blank_(false),
     77       incognito_enabled_(false) {}
     78 
     79 UserScript::~UserScript() {
     80 }
     81 
     82 void UserScript::add_url_pattern(const URLPattern& pattern) {
     83   url_set_.AddPattern(pattern);
     84 }
     85 
     86 void UserScript::add_exclude_url_pattern(const URLPattern& pattern) {
     87   exclude_url_set_.AddPattern(pattern);
     88 }
     89 
     90 bool UserScript::MatchesURL(const GURL& url) const {
     91   if (!url_set_.is_empty()) {
     92     if (!url_set_.MatchesURL(url))
     93       return false;
     94   }
     95 
     96   if (!exclude_url_set_.is_empty()) {
     97     if (exclude_url_set_.MatchesURL(url))
     98       return false;
     99   }
    100 
    101   if (!globs_.empty()) {
    102     if (!UrlMatchesGlobs(&globs_, url))
    103       return false;
    104   }
    105 
    106   if (!exclude_globs_.empty()) {
    107     if (UrlMatchesGlobs(&exclude_globs_, url))
    108       return false;
    109   }
    110 
    111   return true;
    112 }
    113 
    114 void UserScript::File::Pickle(::Pickle* pickle) const {
    115   pickle->WriteString(url_.spec());
    116   // Do not write path. It's not needed in the renderer.
    117   // Do not write content. It will be serialized by other means.
    118 }
    119 
    120 void UserScript::File::Unpickle(const ::Pickle& pickle, PickleIterator* iter) {
    121   // Read the url from the pickle.
    122   std::string url;
    123   CHECK(pickle.ReadString(iter, &url));
    124   set_url(GURL(url));
    125 }
    126 
    127 void UserScript::Pickle(::Pickle* pickle) const {
    128   // Write the simple types to the pickle.
    129   pickle->WriteInt(run_location());
    130   pickle->WriteString(extension_id());
    131   pickle->WriteInt64(user_script_id_);
    132   pickle->WriteBool(emulate_greasemonkey());
    133   pickle->WriteBool(match_all_frames());
    134   pickle->WriteBool(match_about_blank());
    135   pickle->WriteBool(is_incognito_enabled());
    136 
    137   PickleGlobs(pickle, globs_);
    138   PickleGlobs(pickle, exclude_globs_);
    139   PickleURLPatternSet(pickle, url_set_);
    140   PickleURLPatternSet(pickle, exclude_url_set_);
    141   PickleScripts(pickle, js_scripts_);
    142   PickleScripts(pickle, css_scripts_);
    143 }
    144 
    145 void UserScript::PickleGlobs(::Pickle* pickle,
    146                              const std::vector<std::string>& globs) const {
    147   pickle->WriteUInt64(globs.size());
    148   for (std::vector<std::string>::const_iterator glob = globs.begin();
    149        glob != globs.end(); ++glob) {
    150     pickle->WriteString(*glob);
    151   }
    152 }
    153 
    154 void UserScript::PickleURLPatternSet(::Pickle* pickle,
    155                                      const URLPatternSet& pattern_list) const {
    156   pickle->WriteUInt64(pattern_list.patterns().size());
    157   for (URLPatternSet::const_iterator pattern = pattern_list.begin();
    158        pattern != pattern_list.end(); ++pattern) {
    159     pickle->WriteInt(pattern->valid_schemes());
    160     pickle->WriteString(pattern->GetAsString());
    161   }
    162 }
    163 
    164 void UserScript::PickleScripts(::Pickle* pickle,
    165                                const FileList& scripts) const {
    166   pickle->WriteUInt64(scripts.size());
    167   for (FileList::const_iterator file = scripts.begin();
    168        file != scripts.end(); ++file) {
    169     file->Pickle(pickle);
    170   }
    171 }
    172 
    173 void UserScript::Unpickle(const ::Pickle& pickle, PickleIterator* iter) {
    174   // Read the run location.
    175   int run_location = 0;
    176   CHECK(pickle.ReadInt(iter, &run_location));
    177   CHECK(run_location >= 0 && run_location < RUN_LOCATION_LAST);
    178   run_location_ = static_cast<RunLocation>(run_location);
    179 
    180   CHECK(pickle.ReadString(iter, &extension_id_));
    181   CHECK(pickle.ReadInt64(iter, &user_script_id_));
    182   CHECK(pickle.ReadBool(iter, &emulate_greasemonkey_));
    183   CHECK(pickle.ReadBool(iter, &match_all_frames_));
    184   CHECK(pickle.ReadBool(iter, &match_about_blank_));
    185   CHECK(pickle.ReadBool(iter, &incognito_enabled_));
    186 
    187   UnpickleGlobs(pickle, iter, &globs_);
    188   UnpickleGlobs(pickle, iter, &exclude_globs_);
    189   UnpickleURLPatternSet(pickle, iter, &url_set_);
    190   UnpickleURLPatternSet(pickle, iter, &exclude_url_set_);
    191   UnpickleScripts(pickle, iter, &js_scripts_);
    192   UnpickleScripts(pickle, iter, &css_scripts_);
    193 }
    194 
    195 void UserScript::UnpickleGlobs(const ::Pickle& pickle, PickleIterator* iter,
    196                                std::vector<std::string>* globs) {
    197   uint64 num_globs = 0;
    198   CHECK(pickle.ReadUInt64(iter, &num_globs));
    199   globs->clear();
    200   for (uint64 i = 0; i < num_globs; ++i) {
    201     std::string glob;
    202     CHECK(pickle.ReadString(iter, &glob));
    203     globs->push_back(glob);
    204   }
    205 }
    206 
    207 void UserScript::UnpickleURLPatternSet(const ::Pickle& pickle,
    208                                        PickleIterator* iter,
    209                                        URLPatternSet* pattern_list) {
    210   uint64 num_patterns = 0;
    211   CHECK(pickle.ReadUInt64(iter, &num_patterns));
    212 
    213   pattern_list->ClearPatterns();
    214   for (uint64 i = 0; i < num_patterns; ++i) {
    215     int valid_schemes;
    216     CHECK(pickle.ReadInt(iter, &valid_schemes));
    217 
    218     std::string pattern_str;
    219     CHECK(pickle.ReadString(iter, &pattern_str));
    220 
    221     URLPattern pattern(kValidUserScriptSchemes);
    222     URLPattern::ParseResult result = pattern.Parse(pattern_str);
    223     CHECK(URLPattern::PARSE_SUCCESS == result) <<
    224         URLPattern::GetParseResultString(result) << " " << pattern_str.c_str();
    225 
    226     pattern.SetValidSchemes(valid_schemes);
    227     pattern_list->AddPattern(pattern);
    228   }
    229 }
    230 
    231 void UserScript::UnpickleScripts(const ::Pickle& pickle, PickleIterator* iter,
    232                                  FileList* scripts) {
    233   uint64 num_files = 0;
    234   CHECK(pickle.ReadUInt64(iter, &num_files));
    235   scripts->clear();
    236   for (uint64 i = 0; i < num_files; ++i) {
    237     File file;
    238     file.Unpickle(pickle, iter);
    239     scripts->push_back(file);
    240   }
    241 }
    242 
    243 }  // namespace extensions
    244