Adding policy support to Chrome Frame's launcher so that additional parameters can be passed to Chr…

chrome_frame/policy_settings.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome_frame/policy_settings.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 37 matching lines @@
   for (it = content_type_list_.begin();
        it != content_type_list_.end(); ++it) {
     if (lstrcmpiW(content_type, (*it).c_str()) == 0) {
       renderer = RENDER_IN_CHROME_FRAME;
       break;
     }
   }
   return renderer;
 }
 
+const CommandLine& PolicySettings::AdditionalLaunchParameters() const {
+  return additional_launch_parameters_;
+}
+
 // static
 void PolicySettings::ReadUrlSettings(
     RendererForUrl* default_renderer,
     std::vector<std::wstring>* renderer_exclusion_list) {
   DCHECK(default_renderer);
   DCHECK(renderer_exclusion_list);
 
   *default_renderer = RENDERER_NOT_SPECIFIED;
   renderer_exclusion_list->clear();
 
@@ skipping 42 matching lines @@
   sub_key += ASCIIToWide(policy::key::kChromeFrameContentTypes);
 
   content_type_list->clear();
   for (int i = 0; i < arraysize(kRootKeys) && content_type_list->empty();
        ++i) {
     EnumerateKeyValues(kRootKeys[i], sub_key.c_str(), content_type_list);
   }
 }
 
 // static
-void PolicySettings::ReadApplicationLocaleSetting(
-    std::wstring* application_locale) {
-  DCHECK(application_locale);
-
-  application_locale->clear();
+void PolicySettings::ReadStringSetting(
+    const char* value_name, std::wstring* value) {

[Mattias Nissler (ping if slow), 2012/03/26 11:04:41]

nit: each parameter on separate line, non need for the break after (

[tommi (sloooow) - chröme, 2012/03/26 11:24:37]

Done.

+  value->clear();
   base::win::RegKey config_key;
-  std::wstring application_locale_value(
-      ASCIIToWide(policy::key::kApplicationLocaleValue));
+  std::wstring value_name_str(ASCIIToWide(value_name));
   for (int i = 0; i < arraysize(kRootKeys); ++i) {
     if ((config_key.Open(kRootKeys[i], policy::kRegistryMandatorySubKey,
                          KEY_READ) == ERROR_SUCCESS) &&
-        (config_key.ReadValue(application_locale_value.c_str(),
-                              application_locale) == ERROR_SUCCESS)) {
-        break;
+        (config_key.ReadValue(value_name_str.c_str(),
+                              value) == ERROR_SUCCESS)) {
+      break;
     }
   }
 }
 
 void PolicySettings::RefreshFromRegistry() {
   RendererForUrl default_renderer;
   std::vector<std::wstring> renderer_exclusion_list;
   std::vector<std::wstring> content_type_list;
   std::wstring application_locale;
+  CommandLine additional_launch_parameters(CommandLine::NO_PROGRAM);
+  std::wstring additional_parameters_str;
 
   // Read the latest settings from the registry
   ReadUrlSettings(&default_renderer, &renderer_exclusion_list);
   ReadContentTypeSetting(&content_type_list);
-  ReadApplicationLocaleSetting(&application_locale);
+  ReadStringSetting(policy::key::kApplicationLocaleValue, &application_locale);
+  ReadStringSetting(policy::key::kAdditionalLaunchParameters,
+                    &additional_parameters_str);
+  if (!additional_parameters_str.empty()) {
+    additional_parameters_str.insert(0, L"fake.exe ");
+    additional_launch_parameters.ParseFromString(additional_parameters_str);
+  }
 
   // Nofail swap in the new values.  (Note: this is all that need be protected
   // under a mutex if/when this becomes thread safe.)
   using std::swap;
 
   swap(default_renderer_, default_renderer);
   swap(renderer_exclusion_list_, renderer_exclusion_list);
   swap(content_type_list_, content_type_list);
   swap(application_locale_, application_locale);
+  swap(additional_launch_parameters_, additional_launch_parameters);
 }
 
 // static
 PolicySettings* PolicySettings::GetInstance() {
   return Singleton<PolicySettings>::get();
 }