chrome/browser/extensions/api/content_settings/content_settings_helpers.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/api/content_settings/content_settings_helpers.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "components/content_settings/core/browser/website_settings_info.h"
  11 #include "components/content_settings/core/browser/website_settings_registry.h"
  12 #include "content/public/common/url_constants.h"
  13 #include "extensions/common/url_pattern.h"
  14
  15 namespace {
  16
  17 const char kNoPathWildcardsError[] =
  18     "Path wildcards in file URL patterns are not allowed.";
  19 const char kNoPathsError[] = "Specific paths are not allowed.";
  20 const char kInvalidPatternError[] = "The pattern \"*\" is invalid.";
  21
  22 const char* const kContentSettingNames[] = {
  23   "default",
  24   "allow",
  25   "block",
  26   "ask",
  27   "session_only",
  28   "detect_important_content"
  29 };
  30 static_assert(arraysize(kContentSettingNames) <=
  31               CONTENT_SETTING_NUM_SETTINGS,
  32               "kContentSettingNames has an unexpected number of elements");
  33
  34 // TODO(bauerb): Move this someplace where it can be reused.
  35 std::string GetDefaultPort(const std::string& scheme) {
  36   if (scheme == url::kHttpScheme)
  37     return "80";
  38   if (scheme == url::kHttpsScheme)
  39     return "443";
  40   NOTREACHED();
  41   return std::string();
  42 }
  43
  44 }  // namespace
  45
  46 namespace extensions {
  47 namespace content_settings_helpers {
  48
  49 ContentSettingsPattern ParseExtensionPattern(const std::string& pattern_str,
  50                                              std::string* error) {
  51   const int kAllowedSchemes =
  52       URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS |
  53       URLPattern::SCHEME_FILE;
  54   URLPattern url_pattern(kAllowedSchemes);
  55   URLPattern::ParseResult result = url_pattern.Parse(pattern_str);
  56   if (result != URLPattern::PARSE_SUCCESS) {
  57     *error = URLPattern::GetParseResultString(result);
  58     return ContentSettingsPattern();
  59   } else {
  60     scoped_ptr<ContentSettingsPattern::BuilderInterface> builder(
  61         ContentSettingsPattern::CreateBuilder(false));
  62     builder->WithHost(url_pattern.host());
  63     if (url_pattern.match_subdomains())
  64       builder->WithDomainWildcard();
  65
  66     std::string scheme = url_pattern.scheme();
  67     if (scheme == "*")
  68       builder->WithSchemeWildcard();
  69     else
  70       builder->WithScheme(scheme);
  71
  72     std::string port = url_pattern.port();
  73     if (port.empty() && scheme != "file") {
  74       if (scheme == "*")
  75         port = "*";
  76       else
  77         port = GetDefaultPort(scheme);
  78     }
  79     if (port == "*")
  80       builder->WithPortWildcard();
  81     else
  82       builder->WithPort(port);
  83
  84     std::string path = url_pattern.path();
  85     if (scheme == "file") {
  86       // For file URLs we allow only exact path matches.
  87       if (path.find_first_of("*?") != std::string::npos) {
  88         *error = kNoPathWildcardsError;
  89         return ContentSettingsPattern();
  90       } else {
  91         builder->WithPath(path);
  92       }
  93     } else if (path != "/*") {
  94       // For other URLs we allow only paths which match everything.
  95       *error = kNoPathsError;
  96       return ContentSettingsPattern();
  97     }
  98
  99     ContentSettingsPattern pattern = builder->Build();
 100     if (!pattern.IsValid())
 101       *error = kInvalidPatternError;
 102     return pattern;
 103   }
 104 }
 105
 106 ContentSettingsType StringToContentSettingsType(
 107     const std::string& content_type) {
 108   const content_settings::WebsiteSettingsInfo* info =
 109       content_settings::WebsiteSettingsRegistry::GetInstance()->GetByName(
 110           content_type);
 111   if (info)
 112     return info->type();
 113
 114   return CONTENT_SETTINGS_TYPE_DEFAULT;
 115 }
 116
 117 std::string ContentSettingsTypeToString(ContentSettingsType type) {
 118   return content_settings::WebsiteSettingsRegistry::GetInstance()
 119       ->Get(type)
 120       ->name();
 121 }
 122
 123 bool StringToContentSetting(const std::string& setting_str,
 124                             ContentSetting* setting) {
 125   for (size_t type = 0; type < arraysize(kContentSettingNames); ++type) {
 126     if (setting_str == kContentSettingNames[type]) {
 127       *setting = static_cast<ContentSetting>(type);
 128       return true;
 129     }
 130   }
 131   return false;
 132 }
 133
 134 const char* ContentSettingToString(ContentSetting setting) {
 135   size_t index = static_cast<size_t>(setting);
 136   DCHECK_LT(index, arraysize(kContentSettingNames));
 137   return kContentSettingNames[index];
 138 }
 139
 140 }  // namespace content_settings_helpers
 141 }  // namespace extensions