Temporary workaround to get tests that reference singletons either directly o...

chrome_frame/test/policy_settings_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 "base/basictypes.h"
 #include "base/at_exit.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "chrome/common/policy_constants.h"
 #include "chrome_frame/policy_settings.h"
+#include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::RegKey;
+using chrome_frame_test::ScopedVirtualizeHklmAndHkcu;
+using chrome_frame_test::TempRegKeyOverride;
 
 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::kRegistrySubKey, KEY_ALL_ACCESS)) {
     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());
   }
 }
 
-class TempRegKeyOverride {
- public:
-  static const wchar_t kTempTestKeyPath[];
-
-  TempRegKeyOverride(HKEY override, const wchar_t* temp_name)
-      : override_(override), temp_name_(temp_name) {
-    DCHECK(temp_name && lstrlenW(temp_name));
-    std::wstring key_path(kTempTestKeyPath);
-    key_path += L"\\" + temp_name_;
-    EXPECT_TRUE(temp_key_.Create(HKEY_CURRENT_USER, key_path.c_str(),
-                                 KEY_ALL_ACCESS));
-    EXPECT_EQ(ERROR_SUCCESS,
-              ::RegOverridePredefKey(override_, temp_key_.Handle()));
-  }
-
-  ~TempRegKeyOverride() {
-    ::RegOverridePredefKey(override_, NULL);
-    // The temp key will be deleted via a call to DeleteAllTempKeys().
-  }
-
-  static void DeleteAllTempKeys() {
-    RegKey key;
-    if (key.Open(HKEY_CURRENT_USER, L"", KEY_ALL_ACCESS)) {
-      key.DeleteKey(kTempTestKeyPath);
-    }
-  }
-
- protected:
-  HKEY override_;
-  RegKey temp_key_;
-  std::wstring temp_name_;
-};
-
-const wchar_t TempRegKeyOverride::kTempTestKeyPath[] =
-    L"Software\\Chromium\\TempTestKeys";
-
 bool InitializePolicyKey(HKEY policy_root, RegKey* policy_key) {
   EXPECT_TRUE(policy_key->Create(policy_root, policy::kRegistrySubKey,
                                  KEY_ALL_ACCESS));
   return policy_key->Valid();
 }
 
 void WritePolicyList(RegKey* policy_key, const wchar_t* list_name,
                      const wchar_t* values[], int count) {
   DCHECK(policy_key);
   // Remove any previous settings
@@ skipping 50 matching lines @@
       ASCIIToWide(policy::key::kApplicationLocaleValue));
   EXPECT_TRUE(policy_key.WriteValue(application_locale_value.c_str(), locale));
   return true;
 }
 
 }  // end namespace
 
 class PolicySettingsTest : public testing::Test {
  protected:
   void SetUp() {
-    TempRegKeyOverride::DeleteAllTempKeys();
-
-    hklm_pol_.reset(new TempRegKeyOverride(HKEY_LOCAL_MACHINE, L"hklm_pol"));
-    hkcu_pol_.reset(new TempRegKeyOverride(HKEY_CURRENT_USER, L"hkcu_pol"));
-
     ResetPolicySettings();
   }
 
   void TearDown() {
-    hkcu_pol_.reset(NULL);
-    hklm_pol_.reset(NULL);
-    TempRegKeyOverride::DeleteAllTempKeys();
   }
 
   void ResetPolicySettings() {
-    at_exit_manager_.ProcessCallbacksNow();
+    //at_exit_manager_.ProcessCallbacksNow();
+    DeleteAllSingletons();
   }
 
   // This is used to manage life cycle of PolicySettings singleton.
-  base::ShadowingAtExitManager at_exit_manager_;
-  scoped_ptr<TempRegKeyOverride> hklm_pol_;
-  scoped_ptr<TempRegKeyOverride> hkcu_pol_;
+  // base::ShadowingAtExitManager at_exit_manager_;
+
+  ScopedVirtualizeHklmAndHkcu registry_virtualization_;
 };
 
 TEST_F(PolicySettingsTest, RendererForUrl) {
   const wchar_t* kTestUrls[] = {
     L"http://www.example.com",
     L"http://www.pattern.com",
     L"http://www.test.com"
   };
   const wchar_t* kTestFilters[] = {
     L"*.example.com",
@@ skipping 74 matching lines @@
   HKEY root[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
   for (int i = 0; i < arraysize(root); ++i) {
     SetChromeApplicationLocale(root[i], kTestApplicationLocale);
     ResetPolicySettings();
     EXPECT_EQ(std::wstring(kTestApplicationLocale),
               PolicySettings::GetInstance()->ApplicationLocale());
 
     DeleteChromeFramePolicyEntries(root[i]);
   }
 }