| OLD | NEW |
|---|
| (Empty) |
| 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_frame/policy_settings.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "base/strings/string_util.h" | |
| 11 #include "base/strings/utf_string_conversions.h" | |
| 12 #include "base/win/registry.h" | |
| 13 #include "chrome_frame/utils.h" | |
| 14 #include "policy/policy_constants.h" | |
| 15 | |
| 16 namespace { | |
| 17 | |
| 18 // This array specifies the order in which registry keys are tested. Do not | |
| 19 // change this unless the decision is made product-wide (i.e., in Chrome's | |
| 20 // configuration policy provider). | |
| 21 const HKEY kRootKeys[] = { | |
| 22 HKEY_LOCAL_MACHINE, | |
| 23 HKEY_CURRENT_USER | |
| 24 }; | |
| 25 | |
| 26 } // namespace | |
| 27 | |
| 28 PolicySettings::RendererForUrl PolicySettings::GetRendererForUrl( | |
| 29 const wchar_t* url) { | |
| 30 RendererForUrl renderer = default_renderer_; | |
| 31 std::vector<std::wstring>::const_iterator it; | |
| 32 for (it = renderer_exclusion_list_.begin(); | |
| 33 it != renderer_exclusion_list_.end(); ++it) { | |
| 34 if (MatchPattern(url, (*it))) { | |
| 35 renderer = (renderer == RENDER_IN_HOST) ? | |
| 36 RENDER_IN_CHROME_FRAME : RENDER_IN_HOST; | |
| 37 break; | |
| 38 } | |
| 39 } | |
| 40 return renderer; | |
| 41 } | |
| 42 | |
| 43 PolicySettings::RendererForUrl PolicySettings::GetRendererForContentType( | |
| 44 const wchar_t* content_type) { | |
| 45 DCHECK(content_type); | |
| 46 RendererForUrl renderer = RENDERER_NOT_SPECIFIED; | |
| 47 std::vector<std::wstring>::const_iterator it; | |
| 48 for (it = content_type_list_.begin(); | |
| 49 it != content_type_list_.end(); ++it) { | |
| 50 if (lstrcmpiW(content_type, (*it).c_str()) == 0) { | |
| 51 renderer = RENDER_IN_CHROME_FRAME; | |
| 52 break; | |
| 53 } | |
| 54 } | |
| 55 return renderer; | |
| 56 } | |
| 57 | |
| 58 const CommandLine& PolicySettings::AdditionalLaunchParameters() const { | |
| 59 return additional_launch_parameters_; | |
| 60 } | |
| 61 | |
| 62 // static | |
| 63 void PolicySettings::ReadUrlSettings( | |
| 64 RendererForUrl* default_renderer, | |
| 65 std::vector<std::wstring>* renderer_exclusion_list) { | |
| 66 DCHECK(default_renderer); | |
| 67 DCHECK(renderer_exclusion_list); | |
| 68 | |
| 69 *default_renderer = RENDERER_NOT_SPECIFIED; | |
| 70 renderer_exclusion_list->clear(); | |
| 71 | |
| 72 base::win::RegKey config_key; | |
| 73 DWORD value = RENDERER_NOT_SPECIFIED; | |
| 74 std::wstring settings_value( | |
| 75 base::ASCIIToWide(policy::key::kChromeFrameRendererSettings)); | |
| 76 for (int i = 0; i < arraysize(kRootKeys); ++i) { | |
| 77 if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey, | |
| 78 KEY_READ) == ERROR_SUCCESS) && | |
| 79 (config_key.ReadValueDW(settings_value.c_str(), | |
| 80 &value) == ERROR_SUCCESS)) { | |
| 81 break; | |
| 82 } | |
| 83 } | |
| 84 | |
| 85 DCHECK(value == RENDERER_NOT_SPECIFIED || | |
| 86 value == RENDER_IN_HOST || | |
| 87 value == RENDER_IN_CHROME_FRAME) | |
| 88 << "invalid default renderer setting: " << value; | |
| 89 | |
| 90 if (value != RENDER_IN_HOST && value != RENDER_IN_CHROME_FRAME) { | |
| 91 DVLOG(1) << "default renderer not specified via policy"; | |
| 92 } else { | |
| 93 *default_renderer = static_cast<RendererForUrl>(value); | |
| 94 const char* exclusion_list_name = (*default_renderer == RENDER_IN_HOST) ? | |
| 95 policy::key::kRenderInChromeFrameList : | |
| 96 policy::key::kRenderInHostList; | |
| 97 | |
| 98 EnumerateKeyValues(config_key.Handle(), | |
| 99 base::ASCIIToWide(exclusion_list_name).c_str(), | |
| 100 renderer_exclusion_list); | |
| 101 | |
| 102 DVLOG(1) << "Default renderer as specified via policy: " | |
| 103 << *default_renderer | |
| 104 << " exclusion list size: " << renderer_exclusion_list->size(); | |
| 105 } | |
| 106 } | |
| 107 | |
| 108 // static | |
| 109 void PolicySettings::ReadMetadataCheckSettings( | |
| 110 SkipMetadataCheck* skip_metadata_check) { | |
| 111 DCHECK(skip_metadata_check); | |
| 112 | |
| 113 *skip_metadata_check = SKIP_METADATA_CHECK_NOT_SPECIFIED; | |
| 114 | |
| 115 base::win::RegKey config_key; | |
| 116 DWORD value = SKIP_METADATA_CHECK_NOT_SPECIFIED; | |
| 117 base::string16 settings_value( | |
| 118 base::ASCIIToWide(policy::key::kSkipMetadataCheck)); | |
| 119 for (int i = 0; i < arraysize(kRootKeys); ++i) { | |
| 120 if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey, | |
| 121 KEY_READ) == ERROR_SUCCESS) && | |
| 122 (config_key.ReadValueDW(settings_value.c_str(), | |
| 123 &value) == ERROR_SUCCESS)) { | |
| 124 break; | |
| 125 } | |
| 126 } | |
| 127 | |
| 128 DCHECK(value == SKIP_METADATA_CHECK_NOT_SPECIFIED || | |
| 129 value == SKIP_METADATA_CHECK_NO || | |
| 130 value == SKIP_METADATA_CHECK_YES) | |
| 131 << "invalid skip metadata check setting: " << value; | |
| 132 | |
| 133 if (value != SKIP_METADATA_CHECK_NO && value != SKIP_METADATA_CHECK_YES) { | |
| 134 DVLOG(1) << "metadata check not specified via policy"; | |
| 135 } else { | |
| 136 *skip_metadata_check = static_cast<SkipMetadataCheck>(value); | |
| 137 DVLOG(1) << "SkipMetadata check as specified via policy: " | |
| 138 << *skip_metadata_check; | |
| 139 } | |
| 140 } | |
| 141 | |
| 142 // static | |
| 143 void PolicySettings::ReadContentTypeSetting( | |
| 144 std::vector<std::wstring>* content_type_list) { | |
| 145 DCHECK(content_type_list); | |
| 146 | |
| 147 std::wstring sub_key(policy::kRegistryChromePolicyKey); | |
| 148 sub_key += L"\\"; | |
| 149 sub_key += base::ASCIIToWide(policy::key::kChromeFrameContentTypes); | |
| 150 | |
| 151 content_type_list->clear(); | |
| 152 for (int i = 0; i < arraysize(kRootKeys) && content_type_list->empty(); | |
| 153 ++i) { | |
| 154 EnumerateKeyValues(kRootKeys[i], sub_key.c_str(), content_type_list); | |
| 155 } | |
| 156 } | |
| 157 | |
| 158 // static | |
| 159 void PolicySettings::ReadStringSetting(const char* value_name, | |
| 160 std::wstring* value) { | |
| 161 DCHECK(value); | |
| 162 value->clear(); | |
| 163 base::win::RegKey config_key; | |
| 164 std::wstring value_name_str(base::ASCIIToWide(value_name)); | |
| 165 for (int i = 0; i < arraysize(kRootKeys); ++i) { | |
| 166 if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey, | |
| 167 KEY_READ) == ERROR_SUCCESS) && | |
| 168 (config_key.ReadValue(value_name_str.c_str(), | |
| 169 value) == ERROR_SUCCESS)) { | |
| 170 break; | |
| 171 } | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 // static | |
| 176 void PolicySettings::ReadBoolSetting(const char* value_name, bool* value) { | |
| 177 DCHECK(value); | |
| 178 base::win::RegKey config_key; | |
| 179 base::string16 value_name_str(base::ASCIIToWide(value_name)); | |
| 180 DWORD dword_value = 0; | |
| 181 for (int i = 0; i < arraysize(kRootKeys); ++i) { | |
| 182 if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey, | |
| 183 KEY_QUERY_VALUE) == ERROR_SUCCESS) && | |
| 184 (config_key.ReadValueDW(value_name_str.c_str(), | |
| 185 &dword_value) == ERROR_SUCCESS)) { | |
| 186 *value = (dword_value != 0); | |
| 187 break; | |
| 188 } | |
| 189 } | |
| 190 } | |
| 191 | |
| 192 void PolicySettings::RefreshFromRegistry() { | |
| 193 RendererForUrl default_renderer; | |
| 194 SkipMetadataCheck skip_metadata_check; | |
| 195 std::vector<std::wstring> renderer_exclusion_list; | |
| 196 std::vector<std::wstring> content_type_list; | |
| 197 std::wstring application_locale; | |
| 198 CommandLine additional_launch_parameters(CommandLine::NO_PROGRAM); | |
| 199 std::wstring additional_parameters_str; | |
| 200 bool suppress_turndown_prompt = false; | |
| 201 | |
| 202 // Read the latest settings from the registry | |
| 203 ReadUrlSettings(&default_renderer, &renderer_exclusion_list); | |
| 204 ReadMetadataCheckSettings(&skip_metadata_check); | |
| 205 ReadContentTypeSetting(&content_type_list); | |
| 206 ReadStringSetting(policy::key::kApplicationLocaleValue, &application_locale); | |
| 207 ReadStringSetting(policy::key::kAdditionalLaunchParameters, | |
| 208 &additional_parameters_str); | |
| 209 if (!additional_parameters_str.empty()) { | |
| 210 additional_parameters_str.insert(0, L"fake.exe "); | |
| 211 additional_launch_parameters.ParseFromString(additional_parameters_str); | |
| 212 } | |
| 213 ReadBoolSetting(policy::key::kSuppressChromeFrameTurndownPrompt, | |
| 214 &suppress_turndown_prompt); | |
| 215 | |
| 216 // Nofail swap in the new values. (Note: this is all that need be protected | |
| 217 // under a mutex if/when this becomes thread safe.) | |
| 218 using std::swap; | |
| 219 | |
| 220 swap(default_renderer_, default_renderer); | |
| 221 swap(skip_metadata_check_, skip_metadata_check); | |
| 222 swap(renderer_exclusion_list_, renderer_exclusion_list); | |
| 223 swap(content_type_list_, content_type_list); | |
| 224 swap(application_locale_, application_locale); | |
| 225 swap(additional_launch_parameters_, additional_launch_parameters); | |
| 226 swap(suppress_turndown_prompt_, suppress_turndown_prompt); | |
| 227 } | |
| 228 | |
| 229 // static | |
| 230 PolicySettings* PolicySettings::GetInstance() { | |
| 231 return Singleton<PolicySettings>::get(); | |
| 232 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src