Give SxS distribution its own registration GUIDs.

win8/delegate_execute/delegate_execute.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 "build/intsafe_workaround.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <atlctl.h>
 #include <initguid.h>
 #include <shellapi.h>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process/kill.h"
 #include "base/strings/string16.h"
 #include "base/win/scoped_com_initializer.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/installer/util/browser_distribution.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"
 
 using namespace ATL;
 
+// Usually classes derived from CAtlExeModuleT, or other types of ATL
+// COM module classes statically define their CLSID at compile time through
+// the use of various macros, and ATL internals takes care of creating the
+// class objects and registering them.  However, we need to register the same
+// object with different CLSIDs depending on a runtime setting, so we handle
+// that logic here, before the main ATL message loop runs.
 class DelegateExecuteModule
     : public ATL::CAtlExeModuleT< DelegateExecuteModule > {
  public :
   typedef ATL::CAtlExeModuleT<DelegateExecuteModule> ParentClass;
+  typedef CComObject<CommandExecuteImpl> ImplType;
 
-  HRESULT RegisterServer(BOOL reg_type_lib) {
-    return ParentClass::RegisterServer(FALSE);
+  DelegateExecuteModule()
+      : registration_token_(0) {
   }
 
-  virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* registrar) throw() {
-    AtlTrace(L"In %hs\n", __FUNCTION__);
-    HRESULT hr = ParentClass::AddCommonRGSReplacements(registrar);
+  HRESULT PreMessageLoop(int nShowCmd) {
+    HRESULT hr = S_OK;
+    string16 clsid_string;
+    GUID clsid;
+    BrowserDistribution* dist = BrowserDistribution::GetDistribution();
+    if (!dist->GetCommandExecuteImplClsidString(&clsid_string))
+      return E_FAIL;
+    if (FAILED(hr = ::CLSIDFromString(clsid_string.c_str(), &clsid)))

[grt (UTC plus 2), 2013/09/09 18:39:15]

please do the assignment in its own statement

+      return hr;
+
+    // We use the same class creation logic as ATL itself.  See
+    // _ATL_OBJMAP_ENTRY::RegisterClassObject() in atlbase.h
+    hr = ImplType::_ClassFactoryCreatorClass::CreateInstance(
+        ImplType::_CreatorClass::CreateInstance, IID_IUnknown,
+        instance_.ReceiveVoid());
+    if (FAILED(hr))
+      return hr;
+    hr = ::CoRegisterClassObject(clsid, instance_, CLSCTX_LOCAL_SERVER,
+        REGCLS_MULTIPLEUSE | REGCLS_SUSPENDED, &registration_token_);
     if (FAILED(hr))
       return hr;
 
-    wchar_t delegate_execute_clsid[MAX_PATH] = {0};
-    if (!StringFromGUID2(__uuidof(CommandExecuteImpl), delegate_execute_clsid,
-                         ARRAYSIZE(delegate_execute_clsid))) {
-      ATLASSERT(false);
-      return E_FAIL;
+    return ParentClass::PreMessageLoop(nShowCmd);
+  }
+
+  HRESULT PostMessageLoop() {
+    if (registration_token_ != 0) {
+      ::CoRevokeClassObject(registration_token_);
+      registration_token_ = 0;
     }
 
-    hr = registrar->AddReplacement(L"DELEGATE_EXECUTE_CLSID",
-                                   delegate_execute_clsid);
-    ATLASSERT(SUCCEEDED(hr));
-    return hr;
+    instance_.Release();
+
+    return ParentClass::PostMessageLoop();
   }
+
+ private:
+  base::win::ScopedComPtr<IUnknown> instance_;
+  DWORD registration_token_;
 };
 
 DelegateExecuteModule _AtlModule;
 
 using delegate_execute::DelegateExecuteOperation;
 using base::win::ScopedHandle;
 
 int RelaunchChrome(const DelegateExecuteOperation& operation) {
   AtlTrace("Relaunching [%ls] with flags [%s]\n",
            operation.mutex().c_str(), operation.relaunch_flags());
@@ skipping 58 matching lines @@
       case DelegateExecuteOperation::RELAUNCH_CHROME:
         ret_code = RelaunchChrome(operation);
         break;
       default:
         NOTREACHED();
     }
   }
   AtlTrace("delegate_execute exit, code = %d\n", ret_code);
   return ret_code;
 }