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

chrome_frame/test/policy_settings_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.

[robertshield, 2012/03/26 13:36:42]

2012

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

Done.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/at_exit.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "chrome_frame/policy_settings.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
+#include "content/public/common/content_switches.h"
 #include "policy/policy_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::RegKey;
 using chrome_frame_test::ScopedVirtualizeHklmAndHkcu;
 
 namespace {
 
 // A best effort way to zap CF policy entries that may be in the registry.
 void DeleteChromeFramePolicyEntries(HKEY root) {
   RegKey key;
   if (key.Open(root, policy::kRegistryMandatorySubKey,
                KEY_ALL_ACCESS) == ERROR_SUCCESS) {
     key.DeleteValue(
         ASCIIToWide(policy::key::kChromeFrameRendererSettings).c_str());
     key.DeleteKey(ASCIIToWide(policy::key::kRenderInChromeFrameList).c_str());
     key.DeleteKey(ASCIIToWide(policy::key::kRenderInHostList).c_str());
     key.DeleteKey(ASCIIToWide(policy::key::kChromeFrameContentTypes).c_str());
     key.DeleteKey(ASCIIToWide(policy::key::kApplicationLocaleValue).c_str());
   }
 }
 
 bool InitializePolicyKey(HKEY policy_root, RegKey* policy_key) {
   EXPECT_EQ(ERROR_SUCCESS, policy_key->Create(policy_root,
       policy::kRegistryMandatorySubKey, KEY_ALL_ACCESS));
   return policy_key->Valid();
 }
 
-void WritePolicyList(RegKey* policy_key, const wchar_t* list_name,
+void WritePolicyList(RegKey* policy_key,
+                     const wchar_t* list_name,
                      const wchar_t* values[], int count) {
   DCHECK(policy_key);
   // Remove any previous settings
   policy_key->DeleteKey(list_name);
 
   RegKey list_key;
   EXPECT_EQ(ERROR_SUCCESS, list_key.Create(policy_key->Handle(), list_name,
                                            KEY_ALL_ACCESS));
   for (int i = 0; i < count; ++i) {
     EXPECT_EQ(ERROR_SUCCESS,
@@ skipping 16 matching lines @@
   std::wstring in_cf(ASCIIToWide(policy::key::kRenderInChromeFrameList));
   std::wstring in_host(ASCIIToWide(policy::key::kRenderInHostList));
   std::wstring exclusion_list(
       renderer == PolicySettings::RENDER_IN_CHROME_FRAME ? in_host : in_cf);
   WritePolicyList(&policy_key, exclusion_list.c_str(), exclusions,
                   exclusion_count);
 
   return true;
 }
 
-bool SetCFContentTypes(HKEY policy_root, const wchar_t* content_types[],
+bool SetCFContentTypes(HKEY policy_root,
+                       const wchar_t* content_types[],
                        int count) {
   RegKey policy_key;
   if (!InitializePolicyKey(policy_root, &policy_key))
     return false;
 
   std::wstring type_list(ASCIIToWide(policy::key::kChromeFrameContentTypes));
   WritePolicyList(&policy_key, type_list.c_str(), content_types, count);
 
   return true;
 }
 
-bool SetChromeApplicationLocale(HKEY policy_root, const wchar_t* locale) {
+bool SetCFPolicyString(HKEY policy_root,
+                       const char* policy_name,
+                       const wchar_t* value) {
   RegKey policy_key;
   if (!InitializePolicyKey(policy_root, &policy_key))
     return false;
 
-  std::wstring application_locale_value(
-      ASCIIToWide(policy::key::kApplicationLocaleValue));
+  std::wstring policy_name_str(ASCIIToWide(policy_name));
   EXPECT_EQ(ERROR_SUCCESS,
-      policy_key.WriteValue(application_locale_value.c_str(), locale));
+      policy_key.WriteValue(policy_name_str.c_str(), value));
   return true;
 }
 
 }  // end namespace
 
 class PolicySettingsTest : public testing::Test {
  protected:
   void SetUp() {
     ResetPolicySettings();
   }
@@ skipping 89 matching lines @@
   }
 }
 
 TEST_F(PolicySettingsTest, ApplicationLocale) {
   EXPECT_TRUE(PolicySettings::GetInstance()->ApplicationLocale().empty());
 
   static const wchar_t kTestApplicationLocale[] = L"fr-CA";
 
   HKEY root[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
   for (int i = 0; i < arraysize(root); ++i) {
-    SetChromeApplicationLocale(root[i], kTestApplicationLocale);
+    SetCFPolicyString(root[i], policy::key::kApplicationLocaleValue,
+                      kTestApplicationLocale);
     ResetPolicySettings();
     EXPECT_EQ(std::wstring(kTestApplicationLocale),
               PolicySettings::GetInstance()->ApplicationLocale());
 
     DeleteChromeFramePolicyEntries(root[i]);
   }
 }
+
+TEST_F(PolicySettingsTest, AdditionalLaunchParameters) {
+  EXPECT_TRUE(PolicySettings::GetInstance()->
+      AdditionalLaunchParameters().GetProgram().empty());
+
+  std::string test_switches("--");
+  test_switches += switches::kEnableMediaStream;
+  test_switches += " --";
+  test_switches += switches::kEnableMediaSource;
+
+  HKEY root[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
+  for (int i = 0; i < arraysize(root); ++i) {
+    SetCFPolicyString(root[i], policy::key::kAdditionalLaunchParameters,
+                      ASCIIToWide(test_switches).c_str());
+    ResetPolicySettings();
+    const CommandLine& additional_params =
+        PolicySettings::GetInstance()->AdditionalLaunchParameters();
+    EXPECT_TRUE(additional_params.HasSwitch(switches::kEnableMediaStream));
+    EXPECT_TRUE(additional_params.HasSwitch(switches::kEnableMediaSource));
+
+    FilePath program_path(FILE_PATH_LITERAL("my_chrome.exe"));
+    CommandLine new_cmd_line(program_path);
+    new_cmd_line.AppendArguments(additional_params, false);
+    EXPECT_NE(new_cmd_line.GetProgram(), additional_params.GetProgram());
+    EXPECT_TRUE(new_cmd_line.HasSwitch(switches::kEnableMediaStream));
+    EXPECT_TRUE(new_cmd_line.HasSwitch(switches::kEnableMediaSource));
+
+    DeleteChromeFramePolicyEntries(root[i]);
+  }
+}