chrome_frame/policy_settings.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_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       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         ASCIIToWide(exclusion_list_name).c_str(), renderer_exclusion_list);
 100
 101     DVLOG(1) << "Default renderer as specified via policy: "
 102              << *default_renderer
 103              << " exclusion list size: " << renderer_exclusion_list->size();
 104   }
 105 }
 106
 107 // static
 108 void PolicySettings::ReadMetadataCheckSettings(
 109     SkipMetadataCheck* skip_metadata_check) {
 110   DCHECK(skip_metadata_check);
 111
 112   *skip_metadata_check = SKIP_METADATA_CHECK_NOT_SPECIFIED;
 113
 114   base::win::RegKey config_key;
 115   DWORD value = SKIP_METADATA_CHECK_NOT_SPECIFIED;
 116   string16 settings_value(
 117       ASCIIToWide(policy::key::kSkipMetadataCheck));
 118   for (int i = 0; i < arraysize(kRootKeys); ++i) {
 119     if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey,
 120                          KEY_READ) == ERROR_SUCCESS) &&
 121         (config_key.ReadValueDW(settings_value.c_str(),
 122                                 &value) == ERROR_SUCCESS)) {
 123       break;
 124     }
 125   }
 126
 127   DCHECK(value == SKIP_METADATA_CHECK_NOT_SPECIFIED ||
 128          value == SKIP_METADATA_CHECK_NO ||
 129          value == SKIP_METADATA_CHECK_YES)
 130       << "invalid skip metadata check setting: " << value;
 131
 132   if (value != SKIP_METADATA_CHECK_NO && value != SKIP_METADATA_CHECK_YES) {
 133     DVLOG(1) << "metadata check not specified via policy";
 134   } else {
 135     *skip_metadata_check = static_cast<SkipMetadataCheck>(value);
 136     DVLOG(1) << "SkipMetadata check as specified via policy: "
 137              << *skip_metadata_check;
 138   }
 139 }
 140
 141 // static
 142 void PolicySettings::ReadContentTypeSetting(
 143     std::vector<std::wstring>* content_type_list) {
 144   DCHECK(content_type_list);
 145
 146   std::wstring sub_key(policy::kRegistryChromePolicyKey);
 147   sub_key += L"\\";
 148   sub_key += ASCIIToWide(policy::key::kChromeFrameContentTypes);
 149
 150   content_type_list->clear();
 151   for (int i = 0; i < arraysize(kRootKeys) && content_type_list->empty();
 152        ++i) {
 153     EnumerateKeyValues(kRootKeys[i], sub_key.c_str(), content_type_list);
 154   }
 155 }
 156
 157 // static
 158 void PolicySettings::ReadStringSetting(const char* value_name,
 159                                        std::wstring* value) {
 160   DCHECK(value);
 161   value->clear();
 162   base::win::RegKey config_key;
 163   std::wstring value_name_str(ASCIIToWide(value_name));
 164   for (int i = 0; i < arraysize(kRootKeys); ++i) {
 165     if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey,
 166                          KEY_READ) == ERROR_SUCCESS) &&
 167         (config_key.ReadValue(value_name_str.c_str(),
 168                               value) == ERROR_SUCCESS)) {
 169       break;
 170     }
 171   }
 172 }
 173
 174 // static
 175 void PolicySettings::ReadBoolSetting(const char* value_name, bool* value) {
 176   DCHECK(value);
 177   base::win::RegKey config_key;
 178   string16 value_name_str(ASCIIToWide(value_name));
 179   DWORD dword_value = 0;
 180   for (int i = 0; i < arraysize(kRootKeys); ++i) {
 181     if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey,
 182                          KEY_QUERY_VALUE) == ERROR_SUCCESS) &&
 183         (config_key.ReadValueDW(value_name_str.c_str(),
 184                                 &dword_value) == ERROR_SUCCESS)) {
 185       *value = (dword_value != 0);
 186       break;
 187     }
 188   }
 189 }
 190
 191 void PolicySettings::RefreshFromRegistry() {
 192   RendererForUrl default_renderer;
 193   SkipMetadataCheck skip_metadata_check;
 194   std::vector<std::wstring> renderer_exclusion_list;
 195   std::vector<std::wstring> content_type_list;
 196   std::wstring application_locale;
 197   CommandLine additional_launch_parameters(CommandLine::NO_PROGRAM);
 198   std::wstring additional_parameters_str;
 199   bool suppress_turndown_prompt = false;
 200
 201   // Read the latest settings from the registry
 202   ReadUrlSettings(&default_renderer, &renderer_exclusion_list);
 203   ReadMetadataCheckSettings(&skip_metadata_check);
 204   ReadContentTypeSetting(&content_type_list);
 205   ReadStringSetting(policy::key::kApplicationLocaleValue, &application_locale);
 206   ReadStringSetting(policy::key::kAdditionalLaunchParameters,
 207                     &additional_parameters_str);
 208   if (!additional_parameters_str.empty()) {
 209     additional_parameters_str.insert(0, L"fake.exe ");
 210     additional_launch_parameters.ParseFromString(additional_parameters_str);
 211   }
 212   ReadBoolSetting(policy::key::kSuppressChromeFrameTurndownPrompt,
 213                   &suppress_turndown_prompt);
 214
 215   // Nofail swap in the new values.  (Note: this is all that need be protected
 216   // under a mutex if/when this becomes thread safe.)
 217   using std::swap;
 218
 219   swap(default_renderer_, default_renderer);
 220   swap(skip_metadata_check_, skip_metadata_check);
 221   swap(renderer_exclusion_list_, renderer_exclusion_list);
 222   swap(content_type_list_, content_type_list);
 223   swap(application_locale_, application_locale);
 224   swap(additional_launch_parameters_, additional_launch_parameters);
 225   swap(suppress_turndown_prompt_, suppress_turndown_prompt);
 226 }
 227
 228 // static
 229 PolicySettings* PolicySettings::GetInstance() {
 230   return Singleton<PolicySettings>::get();
 231 }