Configure IE 10 for the various Chrome Frame tests.

chrome_frame/test/ie_configurator.cc

 // Copyright (c) 2012 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/test/ie_configurator.h"
 
 #include <windows.h>
 #include <objbase.h>
 
 #include <ios>
@@ skipping 24 matching lines @@
 const wchar_t kKeyIEBrowserEmulation[] =
     L"Software\\Microsoft\\Internet Explorer\\BrowserEmulation";
 const wchar_t kKeyPoliciesExt[] =
     L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Ext";
 const wchar_t kValueEnabledV9[] = L"EnabledV9";
 const wchar_t kValueFirstTime[] = L"FirstTime";
 const wchar_t kValueIE9Completed[] = L"IE9RunOncePerInstallCompleted";
 const wchar_t kValueIE9CompletionTime[] = L"IE9RunOnceCompletionTime";
 const wchar_t kValueIE9LastShown[] = L"IE9RunOnceLastShown";
 const wchar_t kValueIE9TourNoShow[] = L"IE9TourNoShow";
+const wchar_t kValueIE10Completed[] = L"IE10RunOncePerInstallCompleted";
+const wchar_t kValueIE10CompletionTime[] = L"IE10RunOnceCompletionTime";
 const wchar_t kValueIgnoreFrameApprovalCheck[] = L"IgnoreFrameApprovalCheck";
 const wchar_t kValueMSCompatibilityMode[] = L"MSCompatibilityMode";
 
 // A helper class that accumulate a set of registry mutations and corresponding
 // undo data via calls to its Add*() methods.  The mutations can be applied to
 // the registry (repeatedly, if desired) via a call to Apply().  Revert() can be
 // called to apply the accumulated undo data.
 class RegistrySetter {
  public:
   RegistrySetter();
@@ skipping 78 matching lines @@
   virtual void Initialize() OVERRIDE;
   virtual void ApplySettings() OVERRIDE;
   virtual void RevertSettings() OVERRIDE;
 
  private:
   RegistrySetter setter_;
 
   DISALLOW_COPY_AND_ASSIGN(IE7Configurator);
 };
 
-// A configurator for Internet Explorer 9.
-class IE9Configurator : public IEConfigurator {
+// A configurator for Internet Explorer 9 and 10.
+class ModernIEConfigurator : public IEConfigurator {
  public:
-  IE9Configurator();
-  virtual ~IE9Configurator();
+  explicit ModernIEConfigurator(IEVersion ie_version);
+  virtual ~ModernIEConfigurator();
 
   virtual void Initialize() OVERRIDE;
   virtual void ApplySettings() OVERRIDE;
   virtual void RevertSettings() OVERRIDE;
 
  private:
-  static bool IsPerUserSetupComplete();
+  // The names of the registry values used to determine if IE's one-time
+  // initialization has been completed.
+  struct RunOnceValueNames {
+    // This DWORD value is non-zero once initialization has been completed.
+    const wchar_t* completed;
+    // This 8-byte binary value is the FILETIME of completion.
+    const wchar_t* completion_time;
+  };
+
+  static RunOnceValueNames RunOnceNamesForVersion(IEVersion ie_version);
+  bool IsPerUserSetupComplete();
   static string16 GetChromeFrameBHOCLSID();
   static bool IsAddonPromptDisabledForChromeFrame();
 
+  const IEVersion ie_version_;
+  RunOnceValueNames run_once_value_names_;
   RegistrySetter setter_;
 
-  DISALLOW_COPY_AND_ASSIGN(IE9Configurator);
+  DISALLOW_COPY_AND_ASSIGN(ModernIEConfigurator);
 };
 
 // RegistrySetter implementation.
 
 RegistrySetter::RegistrySetter() {
 }
 
 RegistrySetter::~RegistrySetter() {
 }
 
@@ skipping 156 matching lines @@
 }
 
 void IE7Configurator::ApplySettings() {
   setter_.Apply();
 }
 
 void IE7Configurator::RevertSettings() {
   setter_.Revert();
 }
 
-// IE9Configurator implementation
+// ModernIEConfigurator implementation
 
-IE9Configurator::IE9Configurator() {
+ModernIEConfigurator::ModernIEConfigurator(IEVersion ie_version)
+    : ie_version_(ie_version),
+      run_once_value_names_(RunOnceNamesForVersion(ie_version)) {
 }
 
-IE9Configurator::~IE9Configurator() {
+ModernIEConfigurator::~ModernIEConfigurator() {
+}
+
+// static
+ModernIEConfigurator::RunOnceValueNames

[robertshield, 2012/10/14 01:30:34]

how do you feel about sticking this in a constructor for RunOnceValueNames?

[grt (UTC plus 2), 2012/10/15 14:16:17]

Not so great.  The names struct is a super-lightweight aggregate that I don't
think needs version-checking logic.  I've rejiggered things a little bit to get
rid of constructing RunOnceValueNames instances dynamically (the compiler/linker
can put them in .rdata).  Please let me know what you think.

+    ModernIEConfigurator::RunOnceNamesForVersion(
+        IEVersion ie_version) {
+  RunOnceValueNames names = {};
+  switch (ie_version) {
+    case IE_9:
+      names.completed = kValueIE9Completed;
+      names.completion_time = kValueIE9CompletionTime;
+      break;
+    case IE_10:
+      names.completed = kValueIE10Completed;
+      names.completion_time = kValueIE10CompletionTime;
+      break;
+    default:
+      NOTREACHED();
+  }
+  return names;
 }
 
 // Returns true if the per-user setup is complete.
-// static
-bool IE9Configurator::IsPerUserSetupComplete() {
+bool ModernIEConfigurator::IsPerUserSetupComplete() {
   bool is_complete = false;
   base::win::RegKey key_main;
 
   if (key_main.Open(HKEY_CURRENT_USER, kKeyIEMain,
                     KEY_QUERY_VALUE) == ERROR_SUCCESS) {
     DWORD completed = 0;
     FILETIME completion_time = {};
     DWORD size = sizeof(completion_time);
 
-    if (key_main.ReadValueDW(kValueIE9Completed,
+    if (key_main.ReadValueDW(run_once_value_names_.completed,
                              &completed) == ERROR_SUCCESS &&
         completed != 0 &&
-        key_main.ReadValue(kValueIE9CompletionTime, &completion_time,
-                           &size, NULL) == ERROR_SUCCESS &&
+        key_main.ReadValue(run_once_value_names_.completion_time,
+                           &completion_time, &size, NULL) == ERROR_SUCCESS &&
         size == sizeof(completion_time)) {
       is_complete = true;
     }
   }
 
   return is_complete;
 }
 
 // Returns the path to the IE9 Approved Extensions key for Chrome Frame.
 // static
-string16 IE9Configurator::GetChromeFrameBHOCLSID() {
+string16 ModernIEConfigurator::GetChromeFrameBHOCLSID() {
   string16 bho_guid(39, L'\0');
   int guid_len = StringFromGUID2(CLSID_ChromeFrameBHO, &bho_guid[0],
                                  bho_guid.size());
   DCHECK_EQ(guid_len, static_cast<int>(bho_guid.size()));
   bho_guid.resize(guid_len - 1);
   return bho_guid;
 }
 
 // Returns true if the add-on enablement prompt is disabled by Group Policy.
 // static
-bool IE9Configurator::IsAddonPromptDisabledForChromeFrame() {
+bool ModernIEConfigurator::IsAddonPromptDisabledForChromeFrame() {
   bool is_disabled = false;
   base::win::RegKey key;
 
   // See if the prompt is disabled for this user of IE.
   if (key.Open(HKEY_CURRENT_USER, kKeyIEApprovedExtensions,
                KEY_QUERY_VALUE) == ERROR_SUCCESS) {
     DWORD type = REG_NONE;
     DWORD size = 0;
     if (key.ReadValue(GetChromeFrameBHOCLSID().c_str(), NULL, &size,
                       &type) == ERROR_SUCCESS &&
@@ skipping 10 matching lines @@
     if (key.ReadValueDW(kValueIgnoreFrameApprovalCheck,
                         &ignore) == ERROR_SUCCESS &&
         ignore != 0) {
       is_disabled = true;
     }
   }
 
   return is_disabled;
 }
 
-void IE9Configurator::Initialize() {
+void ModernIEConfigurator::Initialize() {
   // Check for per-user IE setup.
   if (!IsPerUserSetupComplete()) {
     const HKEY root = HKEY_CURRENT_USER;
     // Suppress the "Set up Internet Explorer 9" dialog.

[robertshield, 2012/10/14 01:30:34]

nit: no 9

[grt (UTC plus 2), 2012/10/15 14:16:17]

Done.

-    setter_.AddDWORDValue(root, kKeyIEMain, kValueIE9Completed, 1);
-    setter_.AddFILETIMEValue(root, kKeyIEMain, kValueIE9CompletionTime,
+    setter_.AddDWORDValue(root, kKeyIEMain, run_once_value_names_.completed, 1);
+    setter_.AddFILETIMEValue(root, kKeyIEMain,
+                             run_once_value_names_.completion_time,
                              base::Time::Now().ToFileTime());
-    setter_.AddDWORDValue(root, kKeyIEMain, kValueIE9LastShown, 1);
-    // Don't show a tour of IE 9.
-    setter_.AddDWORDValue(root, kKeyIEMain, kValueIE9TourNoShow, 1);
+    if (ie_version_ == IE_9) {
+      setter_.AddDWORDValue(root, kKeyIEMain, kValueIE9LastShown, 1);
+      // Don't show a tour of IE 9.
+      setter_.AddDWORDValue(root, kKeyIEMain, kValueIE9TourNoShow, 1);
+    }
     // Turn off the phishing filter.
     setter_.AddDWORDValue(root, kKeyIEPhishingFilter, kValueEnabledV9, 0);
     // Don't download compatibility view lists.
     setter_.AddDWORDValue(root, kKeyIEBrowserEmulation,
                           kValueMSCompatibilityMode, 0);
   }
 
   // Turn off the "'Foo' add-on from 'Bar' is ready for use." prompt via Group
   // Policy.
   if (!IsAddonPromptDisabledForChromeFrame()) {
     setter_.AddDWORDValue(HKEY_LOCAL_MACHINE, kKeyPoliciesExt,
                           kValueIgnoreFrameApprovalCheck, 1);
   }
 }
 
-void IE9Configurator::ApplySettings() {
+void ModernIEConfigurator::ApplySettings() {
   setter_.Apply();
 }
 
-void IE9Configurator::RevertSettings() {
+void ModernIEConfigurator::RevertSettings() {
   setter_.Revert();
 }
 
 }  // namespace
 
 // Configurator implementation.
 
 IEConfigurator::IEConfigurator() {
 }
 
 IEConfigurator::~IEConfigurator() {
 }
 
 IEConfigurator* CreateConfigurator() {
   IEConfigurator* configurator = NULL;
 
-  switch (GetInstalledIEVersion()) {
+  IEVersion ie_version = GetInstalledIEVersion();
+  switch (ie_version) {
     case IE_7:
       configurator = new IE7Configurator();
       break;
     case IE_9:
-      configurator = new IE9Configurator();
+    case IE_10:
+      configurator = new ModernIEConfigurator(ie_version);
       break;
     default:
       break;
   }
 
   return configurator;
 }
 
 void InstallIEConfigurator() {
   IEConfigurator* configurator = CreateConfigurator();
 
   if (configurator != NULL) {
     testing::UnitTest::GetInstance()->listeners().Append(
         new ConfiguratorDriver(configurator));
   }
 }
 
 }  // namespace chrome_frame_test