Automatic Win8 default browser registration for the ash unittests.

Win8 default browser registration code is extracted into a fairly minimal .rgs script with a helper app that is then invoked by the ash unittests.

A full ICommandExecuteImpl implementation turns out to not be needed as the ash tests activate the registered default browser directly by AppUserModelId which avoids the need for
ICommandExecuteImpl and the other stuff in the production delegate_execute.exe.

BUG=154081
TEST=ash_unittests, eventually.

Review URL: https://chromiumcodereview.appspot.com/12096064

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@182258 0039d316-1c4b-4281-b951-d872f2087c98

ash/DEPS

@@ -11,4 +11,5 @@ include_rules = [
   "+third_party/skia",
   "+net",
   "+ui",
+  "+win8",
 ]

ash/ash.gyp

@@ -517,6 +517,8 @@
           'dependencies': [
             '../ipc/ipc.gyp:ipc',
             '../ui/metro_viewer/metro_viewer.gyp:metro_viewer',
+            '../win8/win8.gyp:test_registrar',
+            '../win8/win8.gyp:test_support_win8',
           ],
           'sources': [
             'test/test_metro_viewer_process_host.cc',

ash/test/ash_test_base.cc

@@ -35,6 +35,7 @@
 #include "base/win/windows_version.h"
 #include "ui/aura/remote_root_window_host_win.h"
 #include "ui/aura/root_window_host_win.h"
+#include "win8/test/test_registrar_constants.h"
 #endif
 
 namespace ash {
@@ -106,7 +107,8 @@ void AshTestBase::SetUp() {
   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
     metro_viewer_host_.reset(new TestMetroViewerProcessHost("viewer"));
     ASSERT_TRUE(
-        metro_viewer_host_->LaunchImmersiveChromeAndWaitForConnection());
+        metro_viewer_host_->LaunchViewerAndWaitForConnection(
+            win8::test::kDefaultTestAppUserModelId));
     aura::RemoteRootWindowHostWin* root_window_host =
         aura::RemoteRootWindowHostWin::Instance();
     ASSERT_TRUE(root_window_host != NULL);

ash/test/test_metro_viewer_process_host.cc

@@ -61,39 +61,20 @@ void TestMetroViewerProcessHost::NotifyChannelConnected() {
   channel_connected_event_.Signal();
 }
 
-bool TestMetroViewerProcessHost::LaunchImmersiveChromeAndWaitForConnection() {
-  // Activate metro chrome. NOTE: This assumes a few things:
-  // 1) That we are using the per-user AppModelId. This is safe for tests.
-  //
-  // 2) That Chrome is registered as the default browser using a test AppModelId
-  // suffix.
-  // TODO(robertshield,grt): Automate 2). Note that at current, The Way to
-  // register chrome.exe is to run
-  //
-  // setup.exe --register-dev-chrome --register-dev-chrome-suffix=.test
-  //
-  // 3) That chrome.exe/delegate_execute.exe are at all suitable for using as
-  //    a metro viewer process for tests.
-  // TODO(robertshield): Investigate having a minimal non-chrome viewer process.
-  //                     http://crbug.com/170425
-#if defined(GOOGLE_CHROME_BUILD)
-  const wchar_t kAppUserModelId[] = L"Chrome";
-#else  // GOOGLE_CHROME_BUILD
-  const wchar_t kAppUserModelId[] = L"Chromium";
-#endif  // GOOGLE_CHROME_BUILD
+bool TestMetroViewerProcessHost::LaunchViewerAndWaitForConnection(
+    const string16& app_user_model_id) {
+  // Activate the viewer process. NOTE: This assumes that the viewer process is
+  // registered as the default browser using the provided |app_user_model_id|.
 
   // TODO(robertshield): Initialize COM at test suite startup.
   base::win::ScopedCOMInitializer com_initializer;
 
-  string16 app_model_id(kAppUserModelId);
-  app_model_id.append(L".test");
-
   base::win::ScopedComPtr<IApplicationActivationManager> activator;
   HRESULT hr = activator.CreateInstance(CLSID_ApplicationActivationManager);
   if (SUCCEEDED(hr)) {
     DWORD pid = 0;
     hr = activator->ActivateApplication(
-        app_model_id.c_str(), L"open", AO_NONE, &pid);
+        app_user_model_id.c_str(), L"open", AO_NONE, &pid);
   }
 
   LOG_IF(ERROR, FAILED(hr)) << "Tried and failed to launch Metro Chrome. "

ash/test/test_metro_viewer_process_host.h

@@ -28,15 +28,11 @@ class TestMetroViewerProcessHost : public IPC::Listener,
   explicit TestMetroViewerProcessHost(const std::string& ipc_channel_name);
   virtual ~TestMetroViewerProcessHost();
 
-  // Launches the Chrome viewer process and blocks until that viewer process
-  // connects or until a timeout is reached. Returns true if the viewer process
-  // connects before the timeout is reached.
-  // TODO(robertshield): This creates a run-time dependency on chrome.exe as the
-  // viewer process and, indirectly, setup.exe as the only thing that can
-  // correctly register a program as the default browser on metro. Investigate
-  // extracting the registration code and the metro init code and building them
-  // into a standalone viewer process.
-  bool LaunchImmersiveChromeAndWaitForConnection();
+  // Launches the viewer process associated with the given |app_user_model_id|
+  // and blocks until that viewer process connects or until a timeout is
+  // reached. Returns true if the viewer process connects before the timeout is
+  // reached.
+  bool LaunchViewerAndWaitForConnection(const string16& app_user_model_id);
 
   // IPC::Sender implementation:
   virtual bool Send(IPC::Message* msg) OVERRIDE;

ash/test/test_suite.cc

@@ -7,6 +7,7 @@
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/compositor/compositor_setup.h"
@@ -19,6 +20,10 @@
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
+#include "ui/base/win/atl_module.h"
+#include "win8/test/metro_registration_helper.h"
+#include "win8/test/open_with_dialog_controller.h"
+#include "win8/test/test_registrar_constants.h"
 #endif
 
 namespace ash {
@@ -30,6 +35,21 @@ AuraShellTestSuite::AuraShellTestSuite(int argc, char** argv)
 void AuraShellTestSuite::Initialize() {
   base::TestSuite::Initialize();
 
+#if defined(OS_WIN)
+  if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
+    ASSERT_TRUE(win8::RegisterTestDefaultBrowser(
+        win8::test::kDefaultTestAppUserModelId,
+        win8::test::kDefaultTestExeName));
+
+    ui::win::CreateATLModuleIfNeeded();
+
+    std::vector<string16> choices;
+    win8::OpenWithDialogController controller;
+    controller.RunSynchronously(NULL, L"http", win8::test::kDefaultTestExeName,
+                                &choices);
+  }
+#endif
+
   gfx::RegisterPathProvider();
   ui::RegisterPathProvider();
 

win8/delegate_execute/delegate_execute.cc

@@ -18,7 +18,7 @@
 #include "base/win/scoped_handle.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/common/chrome_switches.h"
-#include "command_execute_impl.h"
+#include "win8/delegate_execute/command_execute_impl.h"
 #include "win8/delegate_execute/crash_server_init.h"
 #include "win8/delegate_execute/delegate_execute_operation.h"
 #include "win8/delegate_execute/resource.h"

win8/test/metro_registration_helper.cc

+// Copyright (c) 2013 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 "win8/test/metro_registration_helper.h"
+
+#include "base/command_line.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/path_service.h"
+#include "base/process.h"
+#include "base/process_util.h"
+#include "base/win/scoped_handle.h"
+#include "win8/test/test_registrar_constants.h"
+
+namespace {
+
+const int kRegistrationTimeoutSeconds = 30;
+
+// Copied from util_constants.cc to avoid taking a dependency on installer_util.
+const wchar_t kChromeExe[] = L"chrome.exe";
+const wchar_t kRegistrar[] = L"test_registrar.exe";
+
+}
+
+namespace win8 {
+
+bool RegisterTestDefaultBrowser(const string16& app_user_model_id,
+                                const string16& viewer_process_name) {
+  FilePath dir;
+  if (!PathService::Get(base::DIR_EXE, &dir))
+    return false;
+
+  FilePath chrome_exe(dir.Append(kChromeExe));
+  FilePath registrar(dir.Append(kRegistrar));
+
+  if (!file_util::PathExists(chrome_exe) || !file_util::PathExists(registrar)) {
+    LOG(ERROR) << "Could not locate " << kChromeExe << " or " << kRegistrar;
+    return false;
+  }
+
+  // Perform the registration by invoking test_registrar.exe with the
+  // necessary flags:
+  //     test_registrar.exe /RegServer --appid=<appid> --exe-name=<name>
+  CommandLine register_command(registrar);
+  register_command.AppendArg("/RegServer");
+  register_command.AppendSwitchNative(win8::test::kTestAppUserModelId,
+                                      app_user_model_id);
+  register_command.AppendSwitchNative(win8::test::kTestExeName,
+                                      viewer_process_name);
+
+  base::win::ScopedHandle register_handle;
+  if (base::LaunchProcess(register_command, base::LaunchOptions(),
+                          register_handle.Receive())) {
+    int ret = 0;
+    if (base::WaitForExitCodeWithTimeout(
+            register_handle, &ret,
+            base::TimeDelta::FromSeconds(kRegistrationTimeoutSeconds))) {
+      if (ret == 0) {
+        return true;
+      } else {
+        LOG(ERROR) << "Win8 registration using "
+                   << register_command.GetCommandLineString()
+                   << " failed with error code " << ret;
+      }
+    } else {
+      LOG(ERROR) << "Win8 registration using "
+                 << register_command.GetCommandLineString() << " timed out.";
+    }
+  }
+
+  PLOG(ERROR) << "Failed to launch Win8 registration utility using "
+              << register_command.GetCommandLineString();
+  return false;
+}
+
+}  // namespace win8

win8/test/metro_registration_helper.h

+// Copyright (c) 2013 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.
+
+#ifndef WIN8_TEST_METRO_REGISTRATION_HELPER_H_
+#define WIN8_TEST_METRO_REGISTRATION_HELPER_H_
+
+#include "base/string16.h"
+
+namespace win8 {
+
+// Registers a viewer process as a potential Win8 default browser. Intended to
+// be used by a test binary in the build output directory and assumes the
+// presence of test_registrar.exe, a viewer process and all needed DLLs in the
+// same directory as the calling module. The viewer process is then subsequently
+// set as THE default Win8 browser, is activatable using the AppUserModelId in
+// |app_user_model_id| and will show up in the default browser selection dialog
+// as |viewer_process_name|.
+//
+// See also open_with_dialog_controller.h for a mechanism for setting THE
+// default Win8 browser.
+bool RegisterTestDefaultBrowser(const string16& app_user_model_id,
+                                const string16& viewer_process_name);
+
+}  // namespace win8
+
+#endif  // WIN8_TEST_METRO_REGISTRATION_HELPER_H_

win8/test/test_registrar.cc

+// Copyright (c) 2013 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.
+
+// Win8 default browser registration utility.
+//
+// This tool can register and unregister a given exe as a potential default
+// metro browser on Win8. It does not make the exe become THE default browser,
+// for a mechnism to do this please see open_with_dialog_controller.h.
+//
+// TODO(robertshield): By default, this creates a run-time dependency on
+// chrome.exe since it's the only thing we have right now that works as a
+// default viewer process. Investigate extracting the metro init code and
+// building them into a standalone viewer process.
+
+#include <atlbase.h>
+#include <atlcom.h>
+#include <atlctl.h>
+#include <shellapi.h>
+
+#include "base/at_exit.h"
+#include "base/command_line.h"
+#include "base/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/path_service.h"
+#include "base/stringprintf.h"
+#include "win8/test/test_registrar_constants.h"
+#include "win8/test/test_registrar_resource.h"
+
+namespace {
+
+const wchar_t kDelegateExecuteCLSID[] =
+    L"{FC0064A6-D1DE-4A83-92D2-5BB4EEBB70B5}";
+
+void InitializeCommandLineDefaultValues() {
+  CommandLine& command_line = *CommandLine::ForCurrentProcess();
+
+  if (!command_line.HasSwitch(win8::test::kTestAppUserModelId))
+    command_line.AppendSwitchNative(win8::test::kTestAppUserModelId,
+                                    win8::test::kDefaultTestAppUserModelId);
+
+  if (!command_line.HasSwitch(win8::test::kTestExeName))
+    command_line.AppendSwitchNative(win8::test::kTestExeName,
+                                    win8::test::kDefaultTestExeName);
+
+  if (!command_line.HasSwitch(win8::test::kTestExePath)) {
+    base::FilePath exe_path;
+    PathService::Get(base::DIR_EXE, &exe_path);
+    exe_path = exe_path.Append(win8::test::kDefaultTestExePath);
+
+    command_line.AppendSwitchNative(win8::test::kTestExePath,
+                                    exe_path.value());
+  }
+
+  if (!command_line.HasSwitch(win8::test::kTestProgId))
+    command_line.AppendSwitchNative(win8::test::kTestProgId,
+                                    win8::test::kDefaultTestProgId);
+}
+
+}  // namespace
+
+// Implementation of an ATL module that provides the necessary replacement
+// values for the default browser .rgs script.
+class TestDelegateExecuteModule
+    : public ATL::CAtlExeModuleT< TestDelegateExecuteModule > {
+ public :
+  typedef ATL::CAtlExeModuleT<TestDelegateExecuteModule> ParentClass;
+
+  DECLARE_REGISTRY_RESOURCEID(IDR_TESTDELEGATEEXECUTE);
+
+  HRESULT RegisterServer(BOOL reg_type_lib) {
+    return ParentClass::RegisterServer(FALSE);
+  }
+
+  virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* registrar) throw() {
+    AtlTrace(L"In %hs\n", __FUNCTION__);
+    HRESULT hr = ParentClass::AddCommonRGSReplacements(registrar);
+    if (FAILED(hr))
+      return hr;
+
+    registrar->AddReplacement(L"DELEGATE_EXECUTE_CLSID", kDelegateExecuteCLSID);
+
+    CommandLine& command_line = *CommandLine::ForCurrentProcess();
+
+    registrar->AddReplacement(L"APP_USER_MODEL_ID",
+                              command_line.GetSwitchValueNative(
+                                  win8::test::kTestAppUserModelId).c_str());
+    registrar->AddReplacement(L"EXE_NAME",
+                              command_line.GetSwitchValueNative(
+                                  win8::test::kTestExeName).c_str());
+    registrar->AddReplacement(L"PROG_ID",
+                              command_line.GetSwitchValueNative(
+                                  win8::test::kTestProgId).c_str());
+
+    string16 exe_path(
+        command_line.GetSwitchValueNative(win8::test::kTestExePath));
+
+    string16 exe_open_command(base::StringPrintf(L"\"%ls\" -- %%*",
+                                                 exe_path.c_str()));
+    registrar->AddReplacement(L"EXE_OPEN_COMMAND", exe_open_command.c_str());
+
+    string16 exe_icon(base::StringPrintf(L"%ls,0", exe_path.c_str()));
+    registrar->AddReplacement(L"EXE_ICON", exe_icon.c_str());
+
+    string16 prog_id_open_command(base::StringPrintf(L"\"%ls\" -- \"%%1\"",
+                                                     exe_path.c_str()));
+    registrar->AddReplacement(L"PROG_ID_OPEN_COMMAND",
+                              prog_id_open_command.c_str());
+
+    ATLASSERT(SUCCEEDED(hr));
+    return hr;
+  }
+};
+
+TestDelegateExecuteModule _AtlModule;
+
+EXTERN_C const GUID CLSID_TestDefaultBrowserRegistrar;
+class ATL_NO_VTABLE DECLSPEC_UUID("FC0064A6-D1DE-4A83-92D2-5BB4EEBB70B5")
+    TestDefaultBrowserRegistrar
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public CComCoClass<TestDefaultBrowserRegistrar,
+                         &CLSID_TestDefaultBrowserRegistrar> {
+ public:
+  DECLARE_REGISTRY_RESOURCEID(IDR_TESTDELEGATEEXECUTE);
+
+  BEGIN_COM_MAP(TestDefaultBrowserRegistrar)
+  END_COM_MAP()
+};
+
+extern "C" int WINAPI _tWinMain(HINSTANCE, HINSTANCE, LPTSTR, int nShowCmd) {
+  base::AtExitManager exit_manager;
+  CommandLine::Init(0, NULL);
+  InitializeCommandLineDefaultValues();
+
+  HRESULT ret_code = _AtlModule.WinMain(nShowCmd);
+
+  return ret_code;
+}
+
+OBJECT_ENTRY_AUTO(__uuidof(TestDefaultBrowserRegistrar),
+                  TestDefaultBrowserRegistrar);

win8/test/test_registrar.rc

+// Resource script for test_registrar.exe.
+//
+#include "test_registrar_resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+#include "verrsrc.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (United States) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE
+BEGIN
+    "#include ""winres.h""\r\n"
+    "#include ""verrsrc.h""\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// REGISTRY
+//
+
+IDR_TESTDELEGATEEXECUTE     REGISTRY                "test_registrar.rgs"
+
+#endif    // English (United States) resources
+/////////////////////////////////////////////////////////////////////////////

win8/test/test_registrar.rgs

+HKCU {
+  NoRemove Software {
+    NoRemove Classes {
+      ForceRemove '%APP_USER_MODEL_ID%' {
+        ForceRemove .exe {
+          ForceRemove shell = s 'open' {
+            ForceRemove open {
+              command = s '%EXE_OPEN_COMMAND%' {
+                val DelegateExecute = s '%DELEGATE_EXECUTE_CLSID%'
+              }
+              val CommandId = s 'Browser.Launch'
+            }
+            ForceRemove opennewwindow = s 'New Window' {
+              command = s '%EXE_OPEN_COMMAND%' {
+                val DelegateExecute = s '%DELEGATE_EXECUTE_CLSID%'
+              }
+              val CommandId = s 'Browser.Launch'
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+HKCU {
+  NoRemove Software {
+    NoRemove Classes {
+      ForceRemove '%PROG_ID%' = s 'Test Delegate Execute ProgId' {
+        val AppUserModelId = s '%APP_USER_MODEL_ID%'
+        val 'URL Protocol' = s ''
+        ForceRemove Application {
+          val ApplicationName = s '%EXE_NAME%'
+          val ApplicationCompany = s 'Google Inc.'
+          val ApplicationDescription = s 'Test Description'
+          val ApplicationIcon = s '%EXE_ICON%'
+          val AppUserModelId = s '%APP_USER_MODEL_ID%'
+        }
+        ForceRemove DefaultIcon = s '%EXE_ICON%' {
+        }
+        ForceRemove shell {
+          ForceRemove open {
+            ForceRemove command = s '%PROG_ID_OPEN_COMMAND%' {
+              val DelegateExecute = s '%DELEGATE_EXECUTE_CLSID%'
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+HKCU {
+  NoRemove Software {
+    NoRemove Classes {
+      NoRemove CLSID {
+        ForceRemove '%DELEGATE_EXECUTE_CLSID%' = s 'Test CommandExecuteImpl Class' {
+          ForceRemove Programmable
+          LocalServer32 = s '%MODULE%' {
+            val ServerExecutable = s '%MODULE_RAW%'
+          }
+        }
+      }
+    }
+  }
+}
+
+HKCU {
+  NoRemove Software {
+    NoRemove Clients {
+      NoRemove StartMenuInternet {
+        ForceRemove '%APP_USER_MODEL_ID%' = s '%EXE_NAME%' {
+          ForceRemove Capabilities {
+            val ApplicationDescription = s 'Test Description'
+            val ApplicationIcon = s '%EXE_ICON%'
+            val ApplicationName = s '%EXE_NAME%'
+            ForceRemove Startmenu {
+              val StartMenuInternet = s '%APP_USER_MODEL_ID%'
+            }
+            ForceRemove URLAssociations {
+              val http = s '%PROG_ID%'
+              val https = s '%PROG_ID%'
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+HKCU {
+  NoRemove Software {
+    NoRemove RegisteredApplications {
+      val '%APP_USER_MODEL_ID%' = s 'Software\Clients\StartMenuInternet\%APP_USER_MODEL_ID%\Capabilities'
+    }
+  }
+}
+
+

win8/test/test_registrar_constants.cc

+// Copyright (c) 2013 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 "win8/test/test_registrar_constants.h"
+
+namespace win8 {
+namespace test {
+
+// The AppUserModelId value to use during default browser registration.
+const char kTestAppUserModelId[] = "appid";
+
+// Allows the caller to override the visible name given to the exe being
+// registered as the default browser.
+const char kTestExeName[] = "exe-name";
+
+// Specifies the path to the executable being registered as the default
+// browser.
+const char kTestExePath[] = "exe-path";
+
+// The AppUserModelId value to use during default browser registration.
+const char kTestProgId[] = "progid";
+
+// Default values for the above flags.
+const wchar_t kDefaultTestAppUserModelId[] = L"Chrome.test";
+const wchar_t kDefaultTestExeName[] = L"Test Runner";
+const wchar_t kDefaultTestExePath[] = L"chrome.exe";
+const wchar_t kDefaultTestProgId[] = L"ChromeTestProgId";
+
+}  // namespace test
+}  // namespace win8

win8/test/test_registrar_constants.h

+// Copyright (c) 2013 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.
+
+#ifndef WIN8_TEST_TEST_REGISTRAR_CONSTANTS_H__
+#define WIN8_TEST_TEST_REGISTRAR_CONSTANTS_H__
+
+namespace win8 {
+namespace test {
+
+extern const char kTestAppUserModelId[];
+extern const char kTestExeName[];
+extern const char kTestExePath[];
+extern const char kTestProgId[];
+
+extern const wchar_t kDefaultTestAppUserModelId[];
+extern const wchar_t kDefaultTestExeName[];
+extern const wchar_t kDefaultTestExePath[];
+extern const wchar_t kDefaultTestProgId[];
+
+}  // namespace test
+}  // namespace win8
+
+#endif  // WIN8_TEST_TEST_REGISTRAR_CONSTANTS_H__

win8/test/test_registrar_resource.h

+// Copyright (c) 2013 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.
+
+#define IDR_TESTDELEGATEEXECUTE             101
+
+

win8/win8.gyp

@@ -51,8 +51,11 @@
       'type': 'static_library',
       'dependencies': [
         '../base/base.gyp:base',
+        'test_registrar_constants',
       ],
       'sources': [
+        'test/metro_registration_helper.cc',
+        'test/metro_registration_helper.h',
         'test/open_with_dialog_async.cc',
         'test/open_with_dialog_async.h',
         'test/open_with_dialog_controller.cc',
@@ -61,5 +64,39 @@
         'test/ui_automation_client.h',
       ],
     },
+    {
+      'target_name': 'test_registrar',
+      'type': 'executable',
+      'dependencies': [
+        '../base/base.gyp:base',
+        # Chrome is the default viewer process currently used by the tests.
+        # TODO(robertshield): Investigate building a standalone metro viewer
+        # process.
+        '../chrome/chrome.gyp:chrome',
+        'test_registrar_constants',
+      ],
+      'sources': [
+        'test/test_registrar.cc',
+        'test/test_registrar.rc',
+        'test/test_registrar.rgs',
+        'test/test_registrar_resource.h',
+      ],
+      'msvs_settings': {
+        'VCLinkerTool': {
+          'SubSystem': '2',  # Set /SUBSYSTEM:WINDOWS
+        },
+      },
+    },
+    {
+      'target_name': 'test_registrar_constants',
+      'type': 'static_library',
+      'include_dirs': [
+        '..',
+      ],
+      'sources': [
+        'test/test_registrar_constants.cc',
+        'test/test_registrar_constants.h',
+      ],
+    },
   ],
 }