Cleanup and style guideline conformance for policy implementation

chrome/browser/policy/configuration_policy_provider_win_unittest.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 <gtest/gtest.h>
 
 #include <windows.h>
 
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
@@ skipping 11 matching lines @@
 using base::win::RegKey;
 
 namespace policy {
 
 const wchar_t kUnitTestRegistrySubKey[] = L"SOFTWARE\\Chromium Unit Tests";
 const wchar_t kUnitTestMachineOverrideSubKey[] =
     L"SOFTWARE\\Chromium Unit Tests\\HKLM Override";
 const wchar_t kUnitTestUserOverrideSubKey[] =
     L"SOFTWARE\\Chromium Unit Tests\\HKCU Override";
 
+namespace {
+
 // Holds policy type, corresponding policy name string and a valid value for use
 // in parametrized value tests.
 class PolicyTestParams {
  public:
   // Assumes ownership of |hklm_value| and |hkcu_value|.
-  PolicyTestParams(ConfigurationPolicyStore::PolicyType type,
-                  const char* policy_name,
-                  Value* hklm_value,
-                  Value* hkcu_value)
+  PolicyTestParams(ConfigurationPolicyType type,
+                   const char* policy_name,
+                   Value* hklm_value,
+                   Value* hkcu_value)
       : type_(type),
         policy_name_(policy_name),
         hklm_value_(hklm_value),
         hkcu_value_(hkcu_value) {}
 
   // testing::TestWithParam does copy the parameters, so provide copy
   // constructor and assignment operator.
   PolicyTestParams(const PolicyTestParams& other)
       : type_(other.type_),
         policy_name_(other.policy_name_),
         hklm_value_(other.hklm_value_->DeepCopy()),
         hkcu_value_(other.hkcu_value_->DeepCopy()) {}
 
   const PolicyTestParams& operator=(PolicyTestParams other) {
     swap(other);
     return *this;
   }
 
   void swap(PolicyTestParams& other) {
     std::swap(type_, other.type_);
     std::swap(policy_name_, other.policy_name_);
     hklm_value_.swap(other.hklm_value_);
     hkcu_value_.swap(other.hkcu_value_);
   }
 
-  ConfigurationPolicyStore::PolicyType type() const { return type_; }
+  ConfigurationPolicyType type() const { return type_; }
   const char* policy_name() const { return policy_name_; }
   const Value* hklm_value() const { return hklm_value_.get(); }
   const Value* hkcu_value() const { return hkcu_value_.get(); }
 
   // Factory methods for different value types.
   static PolicyTestParams ForStringPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     return PolicyTestParams(type,
                             policy_name,
                             Value::CreateStringValue("string_a"),
                             Value::CreateStringValue("string_b"));
   }
   static PolicyTestParams ForBooleanPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     return PolicyTestParams(type,
                             policy_name,
                             Value::CreateBooleanValue(true),
                             Value::CreateBooleanValue(false));
   }
   static PolicyTestParams ForIntegerPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     return PolicyTestParams(type,
                             policy_name,
                             Value::CreateIntegerValue(42),
                             Value::CreateIntegerValue(17));
   }
   static PolicyTestParams ForListPolicy(
-      ConfigurationPolicyStore::PolicyType type,
+      ConfigurationPolicyType type,
       const char* policy_name) {
     ListValue* hklm_value = new ListValue;
     hklm_value->Set(0U, Value::CreateStringValue("It's a plane!"));
     ListValue* hkcu_value = new ListValue;
     hkcu_value->Set(0U, Value::CreateStringValue("It's a bird!"));
     hkcu_value->Set(0U, Value::CreateStringValue("It's a flying carpet!"));
     return PolicyTestParams(type, policy_name, hklm_value, hkcu_value);
   }
 
  private:
-  ConfigurationPolicyStore::PolicyType type_;
+  ConfigurationPolicyType type_;
   const char* policy_name_;
   scoped_ptr<Value> hklm_value_;
   scoped_ptr<Value> hkcu_value_;
 };
 
+}  // namespace
+
 // This test class provides sandboxing and mocking for the parts of the
 // Windows Registry implementing Group Policy. The |SetUp| method prepares
 // two temporary sandbox keys in |kUnitTestRegistrySubKey|, one for HKLM and one
 // for HKCU. A test's calls to the registry are redirected by Windows to these
 // sandboxes, allowing the tests to manipulate and access policy as if it
 // were active, but without actually changing the parts of the Registry that
 // are managed by Group Policy.
 class ConfigurationPolicyProviderWinTest
     : public testing::TestWithParam<PolicyTestParams> {
  public:
@@ skipping 124 matching lines @@
     case Value::TYPE_STRING: {
       std::string v;
       ASSERT_TRUE(value->GetAsString(&v));
       WriteString(hive, name, UTF8ToUTF16(v).c_str());
       break;
     }
     case Value::TYPE_LIST: {
       const ListValue* list = static_cast<const ListValue*>(value);
       RegKey key(hive,
                  (string16(policy::kRegistrySubKey) + ASCIIToUTF16("\\") +
-                    UTF8ToUTF16(name)).c_str(),
+                  UTF8ToUTF16(name)).c_str(),
                  KEY_ALL_ACCESS);
       int index = 1;
       for (ListValue::const_iterator element(list->begin());
            element != list->end(); ++element) {
         ASSERT_TRUE((*element)->IsType(Value::TYPE_STRING));
         std::string element_value;
         ASSERT_TRUE((*element)->GetAsString(&element_value));
         key.WriteValue(base::IntToString16(index++).c_str(),
                        UTF8ToUTF16(element_value).c_str());
       }
@@ skipping 62 matching lines @@
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->Equals(GetParam().hklm_value()));
 }
 
 // Instantiate the test case for all supported policies.
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyProviderWinTestInstance,
     ConfigurationPolicyProviderWinTest,
     testing::Values(
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyHomePage,
+            kPolicyHomePage,
             key::kHomepageLocation),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyHomepageIsNewTabPage,
+            kPolicyHomepageIsNewTabPage,
             key::kHomepageIsNewTabPage),
         PolicyTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyRestoreOnStartup,
+            kPolicyRestoreOnStartup,
             key::kRestoreOnStartup),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyURLsToRestoreOnStartup,
+            kPolicyURLsToRestoreOnStartup,
             key::kURLsToRestoreOnStartup),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEnabled,
+            kPolicyDefaultSearchProviderEnabled,
             key::kDefaultSearchProviderEnabled),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderName,
+            kPolicyDefaultSearchProviderName,
             key::kDefaultSearchProviderName),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderKeyword,
+            kPolicyDefaultSearchProviderKeyword,
             key::kDefaultSearchProviderKeyword),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSearchURL,
+            kPolicyDefaultSearchProviderSearchURL,
             key::kDefaultSearchProviderSearchURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderSuggestURL,
+            kPolicyDefaultSearchProviderSuggestURL,
             key::kDefaultSearchProviderSuggestURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderIconURL,
+            kPolicyDefaultSearchProviderIconURL,
             key::kDefaultSearchProviderIconURL),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyDefaultSearchProviderEncodings,
+            kPolicyDefaultSearchProviderEncodings,
             key::kDefaultSearchProviderEncodings),
         PolicyTestParams::ForIntegerPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServerMode,
+            kPolicyProxyServerMode,
             key::kProxyServerMode),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyServer,
+            kPolicyProxyServer,
             key::kProxyServer),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyPacUrl,
+            kPolicyProxyPacUrl,
             key::kProxyPacUrl),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyProxyBypassList,
+            kPolicyProxyBypassList,
             key::kProxyBypassList),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAlternateErrorPagesEnabled,
+            kPolicyAlternateErrorPagesEnabled,
             key::kAlternateErrorPagesEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySearchSuggestEnabled,
+            kPolicySearchSuggestEnabled,
             key::kSearchSuggestEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyDnsPrefetchingEnabled,
+            kPolicyDnsPrefetchingEnabled,
             key::kDnsPrefetchingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySafeBrowsingEnabled,
+            kPolicySafeBrowsingEnabled,
             key::kSafeBrowsingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyMetricsReportingEnabled,
+            kPolicyMetricsReportingEnabled,
             key::kMetricsReportingEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPasswordManagerEnabled,
+            kPolicyPasswordManagerEnabled,
             key::kPasswordManagerEnabled),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyDisabledPlugins,
+            kPolicyDisabledPlugins,
             key::kDisabledPlugins),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyAutoFillEnabled,
+            kPolicyAutoFillEnabled,
             key::kAutoFillEnabled),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicySyncDisabled,
+            kPolicySyncDisabled,
             key::kSyncDisabled),
         PolicyTestParams::ForStringPolicy(
-            ConfigurationPolicyStore::kPolicyApplicationLocale,
+            kPolicyApplicationLocale,
             key::kApplicationLocaleValue),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallAllowList,
+            kPolicyExtensionInstallAllowList,
             key::kExtensionInstallAllowList),
         PolicyTestParams::ForListPolicy(
-            ConfigurationPolicyStore::kPolicyExtensionInstallDenyList,
+            kPolicyExtensionInstallDenyList,
             key::kExtensionInstallDenyList),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyShowHomeButton,
+            kPolicyShowHomeButton,
             key::kShowHomeButton),
         PolicyTestParams::ForBooleanPolicy(
-            ConfigurationPolicyStore::kPolicyPrintingEnabled,
+            kPolicyPrintingEnabled,
             key::kPrintingEnabled)));
 
 }  // namespace policy