content_settings_utils.cc revision 68043e1e95eeb07d5cae7aca370b26518b0867d6
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 22namespace { 23 24// The names of the ContentSettingsType values, for use with dictionary prefs. 25const 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 "save-password", 45#if defined(OS_WIN) 46 "metro-switch-to-desktop", 47#elif defined(OS_ANDROID) 48 "protected-media-identifier", 49#endif 50}; 51COMPILE_ASSERT(arraysize(kTypeNames) == CONTENT_SETTINGS_NUM_TYPES, 52 type_names_incorrect_size); 53 54const char kPatternSeparator[] = ","; 55 56} // namespace 57 58namespace content_settings { 59 60std::string GetTypeName(ContentSettingsType type) { 61 return std::string(kTypeNames[type]); 62} 63 64std::string CreatePatternString( 65 const ContentSettingsPattern& item_pattern, 66 const ContentSettingsPattern& top_level_frame_pattern) { 67 return item_pattern.ToString() 68 + std::string(kPatternSeparator) 69 + top_level_frame_pattern.ToString(); 70} 71 72PatternPair ParsePatternString(const std::string& pattern_str) { 73 std::vector<std::string> pattern_str_list; 74 base::SplitString(pattern_str, kPatternSeparator[0], &pattern_str_list); 75 76 // If the |pattern_str| is an empty string then the |pattern_string_list| 77 // contains a single empty string. In this case the empty string will be 78 // removed to signal an invalid |pattern_str|. Invalid pattern strings are 79 // handle by the "if"-statment below. So the order of the if statements here 80 // must be preserved. 81 if (pattern_str_list.size() == 1) { 82 if (pattern_str_list[0].empty()) { 83 pattern_str_list.pop_back(); 84 } else { 85 pattern_str_list.push_back("*"); 86 } 87 } 88 89 if (pattern_str_list.size() > 2 || 90 pattern_str_list.size() == 0) { 91 return PatternPair(ContentSettingsPattern(), 92 ContentSettingsPattern()); 93 } 94 95 PatternPair pattern_pair; 96 pattern_pair.first = 97 ContentSettingsPattern::FromString(pattern_str_list[0]); 98 pattern_pair.second = 99 ContentSettingsPattern::FromString(pattern_str_list[1]); 100 return pattern_pair; 101} 102 103ContentSetting ValueToContentSetting(const base::Value* value) { 104 ContentSetting setting = CONTENT_SETTING_DEFAULT; 105 bool valid = ParseContentSettingValue(value, &setting); 106 DCHECK(valid); 107 return setting; 108} 109 110bool ParseContentSettingValue(const base::Value* value, 111 ContentSetting* setting) { 112 if (!value) { 113 *setting = CONTENT_SETTING_DEFAULT; 114 return true; 115 } 116 int int_value = -1; 117 if (!value->GetAsInteger(&int_value)) 118 return false; 119 *setting = IntToContentSetting(int_value); 120 return *setting != CONTENT_SETTING_DEFAULT; 121} 122 123base::Value* GetContentSettingValueAndPatterns( 124 const ProviderInterface* provider, 125 const GURL& primary_url, 126 const GURL& secondary_url, 127 ContentSettingsType content_type, 128 const std::string& resource_identifier, 129 bool include_incognito, 130 ContentSettingsPattern* primary_pattern, 131 ContentSettingsPattern* secondary_pattern) { 132 if (include_incognito) { 133 // Check incognito-only specific settings. It's essential that the 134 // |RuleIterator| gets out of scope before we get a rule iterator for the 135 // normal mode. 136 scoped_ptr<RuleIterator> incognito_rule_iterator( 137 provider->GetRuleIterator(content_type, resource_identifier, true)); 138 base::Value* value = GetContentSettingValueAndPatterns( 139 incognito_rule_iterator.get(), primary_url, secondary_url, 140 primary_pattern, secondary_pattern); 141 if (value) 142 return value; 143 } 144 // No settings from the incognito; use the normal mode. 145 scoped_ptr<RuleIterator> rule_iterator( 146 provider->GetRuleIterator(content_type, resource_identifier, false)); 147 return GetContentSettingValueAndPatterns( 148 rule_iterator.get(), primary_url, secondary_url, 149 primary_pattern, secondary_pattern); 150} 151 152base::Value* GetContentSettingValueAndPatterns( 153 RuleIterator* rule_iterator, 154 const GURL& primary_url, 155 const GURL& secondary_url, 156 ContentSettingsPattern* primary_pattern, 157 ContentSettingsPattern* secondary_pattern) { 158 while (rule_iterator->HasNext()) { 159 const Rule& rule = rule_iterator->Next(); 160 if (rule.primary_pattern.Matches(primary_url) && 161 rule.secondary_pattern.Matches(secondary_url)) { 162 if (primary_pattern) 163 *primary_pattern = rule.primary_pattern; 164 if (secondary_pattern) 165 *secondary_pattern = rule.secondary_pattern; 166 return rule.value.get()->DeepCopy(); 167 } 168 } 169 return NULL; 170} 171 172base::Value* GetContentSettingValue(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 return GetContentSettingValueAndPatterns(provider, primary_url, secondary_url, 179 content_type, resource_identifier, 180 include_incognito, NULL, NULL); 181} 182 183ContentSetting GetContentSetting(const ProviderInterface* provider, 184 const GURL& primary_url, 185 const GURL& secondary_url, 186 ContentSettingsType content_type, 187 const std::string& resource_identifier, 188 bool include_incognito) { 189 scoped_ptr<base::Value> value( 190 GetContentSettingValue(provider, primary_url, secondary_url, 191 content_type, resource_identifier, 192 include_incognito)); 193 return ValueToContentSetting(value.get()); 194} 195 196void GetRendererContentSettingRules(const HostContentSettingsMap* map, 197 RendererContentSettingRules* rules) { 198 map->GetSettingsForOneType( 199 CONTENT_SETTINGS_TYPE_IMAGES, std::string(), &(rules->image_rules)); 200 map->GetSettingsForOneType( 201 CONTENT_SETTINGS_TYPE_JAVASCRIPT, std::string(), &(rules->script_rules)); 202} 203 204} // namespace content_settings 205