chrome/browser/content_settings/content_settings_utils.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/content_settings/content_settings_utils.h"
   6
   7 #include <vector>
   8
   9 #include "base/command_line.h"
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/content_settings/content_settings_provider.h"
  16 #include "chrome/browser/content_settings/content_settings_rule.h"
  17 #include "chrome/browser/content_settings/host_content_settings_map.h"
  18 #include "chrome/common/chrome_switches.h"
  19 #include "chrome/common/content_settings_pattern.h"
  20 #include "url/gurl.h"
  21
  22 namespace {
  23
  24 // The names of the ContentSettingsType values, for use with dictionary prefs.
  25 const char* kTypeNames[] = {
  26   "cookies",
  27   "images",
  28   "javascript",
  29   "plugins",
  30   "popups",
  31   "geolocation",
  32   "notifications",
  33   "auto-select-certificate",
  34   "fullscreen",
  35   "mouselock",
  36   "mixed-script",
  37   "media-stream",
  38   "media-stream-mic",
  39   "media-stream-camera",
  40   "register-protocol-handler",
  41   "ppapi-broker",
  42   "multiple-automatic-downloads",
  43   "midi-sysex",
  44   "push-messaging",
  45   "ssl-cert-decisions",
  46 #if defined(OS_WIN)
  47   "metro-switch-to-desktop",
  48 #elif defined(OS_ANDROID) || defined(OS_CHROMEOS)
  49   "protected-media-identifier",
  50 #endif
  51 #if defined(OS_ANDROID)
  52   "app-banner",
  53 #endif
  54 };
  55 COMPILE_ASSERT(arraysize(kTypeNames) == CONTENT_SETTINGS_NUM_TYPES,
  56                type_names_incorrect_size);
  57
  58 const char kPatternSeparator[] = ",";
  59
  60 }  // namespace
  61
  62 namespace content_settings {
  63
  64 std::string GetTypeName(ContentSettingsType type) {
  65   return std::string(kTypeNames[type]);
  66 }
  67
  68 bool GetTypeFromName(const std::string& name,
  69                      ContentSettingsType* return_setting) {
  70   for (size_t type = 0; type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
  71     if (name.compare(kTypeNames[type]) == 0) {
  72       *return_setting = static_cast<ContentSettingsType>(type);
  73       return true;
  74     }
  75   }
  76   return false;
  77 }
  78
  79 std::string ContentSettingToString(ContentSetting setting) {
  80   switch (setting) {
  81     case CONTENT_SETTING_ALLOW:
  82       return "allow";
  83     case CONTENT_SETTING_ASK:
  84       return "ask";
  85     case CONTENT_SETTING_BLOCK:
  86       return "block";
  87     case CONTENT_SETTING_SESSION_ONLY:
  88       return "session";
  89     case CONTENT_SETTING_DEFAULT:
  90       return "default";
  91     case CONTENT_SETTING_NUM_SETTINGS:
  92       NOTREACHED();
  93   }
  94
  95   return std::string();
  96 }
  97
  98 ContentSetting ContentSettingFromString(const std::string& name) {
  99   if (name == "allow")
 100     return CONTENT_SETTING_ALLOW;
 101   if (name == "ask")
 102     return CONTENT_SETTING_ASK;
 103   if (name == "block")
 104     return CONTENT_SETTING_BLOCK;
 105   if (name == "session")
 106     return CONTENT_SETTING_SESSION_ONLY;
 107
 108   NOTREACHED() << name << " is not a recognized content setting.";
 109   return CONTENT_SETTING_DEFAULT;
 110 }
 111
 112 std::string CreatePatternString(
 113     const ContentSettingsPattern& item_pattern,
 114     const ContentSettingsPattern& top_level_frame_pattern) {
 115   return item_pattern.ToString()
 116          + std::string(kPatternSeparator)
 117          + top_level_frame_pattern.ToString();
 118 }
 119
 120 PatternPair ParsePatternString(const std::string& pattern_str) {
 121   std::vector<std::string> pattern_str_list;
 122   base::SplitString(pattern_str, kPatternSeparator[0], &pattern_str_list);
 123
 124   // If the |pattern_str| is an empty string then the |pattern_string_list|
 125   // contains a single empty string. In this case the empty string will be
 126   // removed to signal an invalid |pattern_str|. Invalid pattern strings are
 127   // handle by the "if"-statment below. So the order of the if statements here
 128   // must be preserved.
 129   if (pattern_str_list.size() == 1) {
 130     if (pattern_str_list[0].empty()) {
 131       pattern_str_list.pop_back();
 132     } else {
 133       pattern_str_list.push_back("*");
 134     }
 135   }
 136
 137   if (pattern_str_list.size() > 2 ||
 138       pattern_str_list.size() == 0) {
 139     return PatternPair(ContentSettingsPattern(),
 140                        ContentSettingsPattern());
 141   }
 142
 143   PatternPair pattern_pair;
 144   pattern_pair.first =
 145       ContentSettingsPattern::FromString(pattern_str_list[0]);
 146   pattern_pair.second =
 147       ContentSettingsPattern::FromString(pattern_str_list[1]);
 148   return pattern_pair;
 149 }
 150
 151 ContentSetting ValueToContentSetting(const base::Value* value) {
 152   ContentSetting setting = CONTENT_SETTING_DEFAULT;
 153   bool valid = ParseContentSettingValue(value, &setting);
 154   DCHECK(valid);
 155   return setting;
 156 }
 157
 158 bool ParseContentSettingValue(const base::Value* value,
 159                               ContentSetting* setting) {
 160   if (!value) {
 161     *setting = CONTENT_SETTING_DEFAULT;
 162     return true;
 163   }
 164   int int_value = -1;
 165   if (!value->GetAsInteger(&int_value))
 166     return false;
 167   *setting = IntToContentSetting(int_value);
 168   return *setting != CONTENT_SETTING_DEFAULT;
 169 }
 170
 171 base::Value* GetContentSettingValueAndPatterns(
 172     const ProviderInterface* provider,
 173     const GURL& primary_url,
 174     const GURL& secondary_url,
 175     ContentSettingsType content_type,
 176     const std::string& resource_identifier,
 177     bool include_incognito,
 178     ContentSettingsPattern* primary_pattern,
 179     ContentSettingsPattern* secondary_pattern) {
 180   if (include_incognito) {
 181     // Check incognito-only specific settings. It's essential that the
 182     // |RuleIterator| gets out of scope before we get a rule iterator for the
 183     // normal mode.
 184     scoped_ptr<RuleIterator> incognito_rule_iterator(
 185         provider->GetRuleIterator(content_type, resource_identifier, true));
 186     base::Value* value = GetContentSettingValueAndPatterns(
 187         incognito_rule_iterator.get(), primary_url, secondary_url,
 188         primary_pattern, secondary_pattern);
 189     if (value)
 190       return value;
 191   }
 192   // No settings from the incognito; use the normal mode.
 193   scoped_ptr<RuleIterator> rule_iterator(
 194       provider->GetRuleIterator(content_type, resource_identifier, false));
 195   return GetContentSettingValueAndPatterns(
 196       rule_iterator.get(), primary_url, secondary_url,
 197       primary_pattern, secondary_pattern);
 198 }
 199
 200 base::Value* GetContentSettingValueAndPatterns(
 201     RuleIterator* rule_iterator,
 202     const GURL& primary_url,
 203     const GURL& secondary_url,
 204     ContentSettingsPattern* primary_pattern,
 205     ContentSettingsPattern* secondary_pattern) {
 206   while (rule_iterator->HasNext()) {
 207     const Rule& rule = rule_iterator->Next();
 208     if (rule.primary_pattern.Matches(primary_url) &&
 209         rule.secondary_pattern.Matches(secondary_url)) {
 210       if (primary_pattern)
 211         *primary_pattern = rule.primary_pattern;
 212       if (secondary_pattern)
 213         *secondary_pattern = rule.secondary_pattern;
 214       return rule.value.get()->DeepCopy();
 215     }
 216   }
 217   return NULL;
 218 }
 219
 220 base::Value* GetContentSettingValue(const ProviderInterface* provider,
 221                                     const GURL& primary_url,
 222                                     const GURL& secondary_url,
 223                                     ContentSettingsType content_type,
 224                                     const std::string& resource_identifier,
 225                                     bool include_incognito) {
 226   return GetContentSettingValueAndPatterns(provider, primary_url, secondary_url,
 227                                content_type, resource_identifier,
 228                                include_incognito, NULL, NULL);
 229 }
 230
 231 ContentSetting GetContentSetting(const ProviderInterface* provider,
 232                                  const GURL& primary_url,
 233                                  const GURL& secondary_url,
 234                                  ContentSettingsType content_type,
 235                                  const std::string& resource_identifier,
 236                                  bool include_incognito) {
 237   scoped_ptr<base::Value> value(
 238       GetContentSettingValue(provider, primary_url, secondary_url,
 239                              content_type, resource_identifier,
 240                              include_incognito));
 241   return ValueToContentSetting(value.get());
 242 }
 243
 244 void GetRendererContentSettingRules(const HostContentSettingsMap* map,
 245                                     RendererContentSettingRules* rules) {
 246   map->GetSettingsForOneType(
 247       CONTENT_SETTINGS_TYPE_IMAGES, std::string(), &(rules->image_rules));
 248   map->GetSettingsForOneType(
 249       CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string(), &(rules->script_rules));
 250 }
 251
 252 }  // namespace content_settings