Windows Kernel

Development Platform:
Visual C++

winlist.cpp：Code Content
							//--------------------------------------------------------------------------
// Manage the windows list, such that we can get the IDispatch for each of
// the shell windows to be marshalled to different processes
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Includes...
#include "priv.h"
#include "sccls.h"
#include <shdguid.h>
#include "winlist.h"
#include "iedde.h"
#define DM_WINLIST  0
void IEInitializeClassFactoryObject(IUnknown* punkAuto);
void IERevokeClassFactoryObject(void);
class CShellWindowListCF : public IClassFactory
{
    // IUnKnown
    public:
    virtual STDMETHODIMP QueryInterface(REFIID,void **);
    virtual STDMETHODIMP_(ULONG) AddRef(void);
    virtual STDMETHODIMP_(ULONG) Release(void);
    // IClassFactory
    virtual STDMETHODIMP CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObject);
    virtual STDMETHODIMP LockServer(BOOL fLock);
    // constructor
    CShellWindowListCF();
    BOOL Init(void);
protected:
    ~CShellWindowListCF();
    // locals
    LONG            _cRef;
    IShellWindows    *_pswWinList;
};
DWORD g_dwWinListCFRegister = 0;
DWORD g_fWinListRegistered = FALSE;     // Only used in browser only mode...
IShellWindows *g_pswWinList = NULL;
// Function to get called by the tray to create the global window list and register
// it with the system
//=================================== Class Factory implemention ========================
CShellWindowListCF::CShellWindowListCF()
{
    _cRef = 1;
    DllAddRef();
}
BOOL CShellWindowListCF::Init()
{
    HRESULT hres = CSDWindows_CreateInstance(&_pswWinList);
    g_pswWinList = _pswWinList;
    // First see if there already is one defined...
    if (FAILED(hres))
    {
        TraceMsg(DM_WINLIST, "WinList_Init CoCreateInstance Failed: %x", hres);
        return FALSE;
    }
    // And register our class factory with the system...
    hres = CoRegisterClassObject(CLSID_ShellWindows, this,
                                 CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
                                 REGCLS_MULTIPLEUSE, &g_dwWinListCFRegister);
    ASSERT(SUCCEEDED(hres));
    //  this call governs when we will call CoRevoke on the CF
    if (SUCCEEDED(hres) && g_pswWinList)
        g_pswWinList->ProcessAttachDetach(TRUE);
    // Create an instance of the underlying window list class...
    TraceMsg(DM_WINLIST, "WinList_Init CoRegisterClass: %x", hres);
    return SUCCEEDED(hres);
}
CShellWindowListCF::~CShellWindowListCF()
{
    if (_pswWinList)
    {
        g_pswWinList = NULL;
        _pswWinList->Release();
    }
    DllRelease();
}
STDMETHODIMP CShellWindowListCF::QueryInterface(REFIID riid, void **ppvObj)
{
    static const QITAB qit[] = { 
        QITABENT(CShellWindowListCF, IClassFactory), // IID_IClassFactory
        { 0 }, 
    };
    return QISearch(this, qit, riid, ppvObj);
}
STDMETHODIMP_(ULONG) CShellWindowListCF::AddRef()
{
    return InterlockedIncrement(&_cRef);
}
STDMETHODIMP_(ULONG) CShellWindowListCF::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;
    delete this;
    return 0;
}
STDMETHODIMP CShellWindowListCF::CreateInstance(IUnknown *pUnkOuter, REFIID riid, void **ppvObj)
{
    // aggregation checking is done in class factory
    // For now simply use our QueryService to get the dispatch.
    // this will do all of the things to create it and the like.
    if (!_pswWinList) 
    {
        ASSERT(0);
        return E_FAIL;
    }
    return _pswWinList->QueryInterface(riid, ppvObj);
}
STDMETHODIMP CShellWindowListCF::LockServer(BOOL fLock)
{
    return S_OK;    // we don't do anything with this...
}
// As this is marshalled over to the main shell process hopefully this will take care of
// most of the serialization problems.  Probably still need a way to handle the case better
// where a window is coming up at the same time the last one is going down...
STDAPI CWinListShellProc_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
{
    *ppunk = NULL;
    if (g_dwWinListCFRegister)
        return CO_E_OBJISREG;
    CShellWindowListCF *pswWinList = new CShellWindowListCF;
    if (pswWinList)
    {
        pswWinList->Init(); // tell it to initialize
        *ppunk = SAFECAST(pswWinList, IUnknown *);
        return NOERROR;
    }
    return E_OUTOFMEMORY;
}
BOOL WinList_Init(void)
{
    // Create our clas factory to register out there...
    TraceMsg(DM_WINLIST, "WinList_Init called");
    //
    //  If this is not a browser-only install. Register the class factory
    // object now with no instance. Otherwise, do it when the first instance
    // is created (see shbrowse.cpp).
    //
    if (!g_fBrowserOnlyProcess)
    {
        //
        //  First, register the class factory object for CLSID_InternetExplorer.
        // Note that we pass NULL indicating that subsequent CreateInstance
        // should simply create a new instance.
        //
        IEInitializeClassFactoryObject(NULL);
        CShellWindowListCF *pswWinList = new CShellWindowListCF;
        if (pswWinList)
        {
            BOOL fRetVal = pswWinList->Init(); // tell it to initialize
            pswWinList->Release(); // Release our handle hopefully init registered
            //
            // Initialize IEDDE.
            //
            if (!IsBrowseNewProcessAndExplorer())
                IEDDE_Initialize();
            return fRetVal;
        }
    }
    else
    {
        //
        // Initialize IEDDE. - Done before cocreate below for timing issues
        //
        IEDDE_Initialize();
        // All of the main processing moved to first call to WinList_GetShellWindows
        // as the creating of OLE object across processes screwed up DDE timing.
        return TRUE;
    }
    return FALSE;
}
#ifdef UNIX
HRESULT CoCreateShellWindows(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext,
                 REFIID riid,  void **ppv)
{
    HRESULT hres;
    if (!g_pswWinList)
    {
        hres = CSDWindows_CreateInstance(&g_pswWinList);
        if (FAILED(hres))
        {
            return E_FAIL;
        }
    }
    hres = g_pswWinList->QueryInterface(riid, ppv);
    if (SUCCEEDED(hres))
    {
    g_dwWinListCFRegister = 1;
    }
    return hres;
}
#endif
// Helper function to get the ShellWindows Object
IShellWindows* WinList_GetShellWindows(BOOL fForceMarshalled)
{
    IShellWindows *psw;
    if (fForceMarshalled)
        psw = NULL;
    else
        psw = g_pswWinList;
    if (psw) 
    {
        // Optimize the inter-thread case by using the global WinList,
        // this makes opening folders much faster.
        psw->AddRef();
    } 
    else 
    {
        SHCheckRegistry();
#ifndef NO_RPCSS_ON_UNIX
        HRESULT hres = CoCreateInstance(CLSID_ShellWindows, NULL,
                         CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
                         IID_IShellWindows,  (void **)&psw);
#else
        HRESULT hres = CoCreateShellWindows(CLSID_ShellWindows, NULL,
                         CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
                         IID_IShellWindows,  (void **)&psw);
#endif
        if ( (g_fBrowserOnlyProcess || !IsInternetExplorerApp()) && !g_fWinListRegistered)
        {
            // If it failed and we are not funning in integrated mode, and this is the
            // first time for this process, we should then register the Window List with
            // the shell process.  We moved that from WinList_Init as that caused us to
            // do interprocess send/post messages to early which caused DDE to break...
            g_fWinListRegistered = TRUE;    // only call once
            if (FAILED(hres))
            {
                SHLoadInProc(CLSID_WinListShellProc);
                hres = CoCreateInstance(CLSID_ShellWindows, NULL,
                                 CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER,
                                 IID_IShellWindows,  (void **)&psw);
            }
            if (psw)
            {
                psw->ProcessAttachDetach(TRUE);
            }
        }
        // hr == REGDB_E_CLASSNOTREG when the shell process isn't running.
        // hr == RPC_E_CANTCALLOUT_ININPUTSYNCCALL happens durring DDE launch of IE.
        // should investigate, but removing assert for IE5 ship.
        AssertMsg(SUCCEEDED(hres) || hres == REGDB_E_CLASSNOTREG || hres == RPC_E_CANTCALLOUT_ININPUTSYNCCALL,
                  TEXT("WinList_GetShellWindows CoCreateInst(CLSID_ShellWindows) failed %x"), hres);
    }
    return psw;
}
// Function to terminate our use of the window list.
void WinList_Terminate(void)
{
    // Lets release everything in a thread safe way...
    TraceMsg(DM_WINLIST, "WinList_Terminate called");
    IEDDE_Uninitialize();
    // Release our usage of the object to allow the system to clean it up
    if (!g_fBrowserOnlyProcess)
    {
        //  this is the explorer process, and we control the vertical
        if (g_dwWinListCFRegister) {
            IShellWindows* psw = WinList_GetShellWindows(FALSE);
            ASSERT(psw);
#ifdef DEBUG
            long cwindow = -1;
            psw->get_Count(&cwindow);
            //ASSERT(cwindow==0);
            if (cwindow != 0)
                TraceMsg(DM_ERROR, "wl_t: cwindow=%d (!=0)", cwindow);
#endif
            psw->ProcessAttachDetach(FALSE);
            psw->Release();
            //  the processattachdetach() should kill the CF in our process
            if (g_dwWinListCFRegister != 0)
                TraceMsg(DM_ERROR, "wl_t: g_dwWinListCFRegister=%d (!=0)", g_dwWinListCFRegister);
        }
        IERevokeClassFactoryObject();
        CUrlHistory_CleanUp();
    }
    else
    {
        if (g_fWinListRegistered)
        {
            // only do this if we actually registered...
            IShellWindows* psw = WinList_GetShellWindows(TRUE);
            if (psw)
            {
                psw->ProcessAttachDetach(FALSE);    // Tell it we are going away...
                psw->Release();
            }
        }
    }
#ifdef UNIX
    if (g_pswWinList)
    {
        g_pswWinList->Release();
    }
#endif
}
//  BUGBUG chrisfra 10/17/96 - mike schmidt needs to look at why delayed
//  register causes death in OleUnitialize accessing freed vtable
//  in winlist, under ifdef, i've also made WinList_GetShellWindows ignore
//  BOOLEAN parameter
HRESULT WinList_Revoke(long dwRegister)
{
#ifndef DELAY_REGISTER
    IShellWindows* psw = WinList_GetShellWindows(TRUE);
#else
    IShellWindows* psw = WinList_GetShellWindows(FALSE);
#endif
    HRESULT hres = E_FAIL;
    TraceMsg(DM_WINLIST, "WinList_Reevoke called on %x", dwRegister);
    ASSERT(psw);
    if (psw)
    {
        hres = psw->Revoke((long)dwRegister);
        ASSERT(SUCCEEDED(hres));
        psw->Release();
    }
    return hres;
}
STDAPI NavigateToPIDL(IWebBrowser2* pwb, LPCITEMIDLIST pidl)
{
    HRESULT hr;
    VARIANT varThePidl;
    if (InitVariantFromIDList(&varThePidl, pidl))
    {
        hr = pwb->Navigate2(&varThePidl, PVAREMPTY, PVAREMPTY, PVAREMPTY, PVAREMPTY);
        VariantClear(&varThePidl);       // Needed to free the copy of the PIDL in varThePidl.
    }
    else
        hr = E_OUTOFMEMORY;
    return hr;
}
BOOL _InitVariantFromIDListLazy(IShellWindows* psw, VARIANT* pvar, LPCITEMIDLIST pidl)
{
    memset(pvar, 0, sizeof(*pvar));
    ASSERT(pvar->vt == VT_EMPTY);
    if (!pidl)
        return TRUE;    // Leave as empty!
    if (psw == g_pswWinList)
    {
        InitVariantFromIDListInProc(pvar, pidl);  // non-marshalled call
        return TRUE;
    }
    return InitVariantFromIDList(pvar, pidl);
}
HRESULT WinList_NotifyNewLocation(IShellWindows* psw, long dwRegister, LPCITEMIDLIST pidl)
{
    HRESULT hres = E_UNEXPECTED;
    if (pidl) {
        VARIANT var;
        if (_InitVariantFromIDListLazy(psw, &var, pidl)) {
            hres = psw->OnNavigate(dwRegister, &var);
            VariantClearLazy(&var);
        } else {
            hres = E_OUTOFMEMORY;
        }
    }
    return hres;
}
// Winlist_RegisterPending
STDAPI WinList_RegisterPending(DWORD dwThread, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlRoot, long *pdwRegister)
{
    // Register with the window list that we have a pidl that we are starting up.
    HRESULT hres = E_UNEXPECTED;
    ASSERT(!pidlRoot);
    if (pidl)
    {
        IShellWindows* psw = WinList_GetShellWindows(FALSE);
        if (psw)
        {
            VARIANT var;
            if (_InitVariantFromIDListLazy(psw, &var, pidl))
            {
                hres = psw->RegisterPending(dwThread, &var, PVAREMPTY, SWC_BROWSER, pdwRegister);
            }
            else
            {
                hres = E_OUTOFMEMORY;
            }
            VariantClearLazy(&var);
        }
    }
    return hres;
}
/*
 * WinList_FindFolderWindow
 *
 * PERFORMANCE note - getting back the automation object (ppauto) is really
 * expensive due to the marshalling overhead.  Don't query for it unless you
 * absolutely need it!
 */
HRESULT WinList_FindFolderWindow(LPCITEMIDLIST pidl, LPCITEMIDLIST pidlRoot, HWND *phwnd, IWebBrowserApp **ppauto)
{
    HRESULT hres = E_UNEXPECTED;
    ASSERT(!pidlRoot);
    if (ppauto)
        *ppauto = NULL;
    if (phwnd)
        *phwnd = NULL;
    if (pidl) 
    {
        // Try a cached psw if we don't need ppauto
        IShellWindows* psw = WinList_GetShellWindows(ppauto != NULL);
        if (psw)
        {
            VARIANT var;
            if (_InitVariantFromIDListLazy(psw, &var, pidl)) 
            {
                IDispatch* pdisp = NULL;
                hres = psw->FindWindow(&var, PVAREMPTY, SWC_BROWSER, (long *)phwnd,
                        ppauto ? (SWFO_NEEDDISPATCH | SWFO_INCLUDEPENDING) : SWFO_INCLUDEPENDING,
                        &pdisp);
                if (pdisp) 
                {
                    // if this fails it's because we are inside SendMessage loop and ole doesn't like it
                    if (ppauto)
                        hres = pdisp->QueryInterface(IID_IWebBrowserApp, (void **)ppauto);
                    pdisp->Release();
                }
            }
            VariantClearLazy(&var);
            psw->Release();
        }
    }
    return hres;
}
#if 0
HRESULT WinList_OnActivate(IShellWindows* psw, long dwRegister, BOOL fActivate, LPCITEMIDLIST pidl)
{
    HRESULT hres;
    hres = psw->OnActivated(dwRegister, fActivate);
    if (!fActivate) {
        hres = WinList_NotifyNewLocation(psw, dwRegister, pidl);
    }
    return hres;
}
#endif
//===============================================================================
// Support for Being able to open a folder and get it's idispatch...
//
class CGIDFWait
{
public:
    ULONG AddRef(void) ;
    ULONG Release(void);
    BOOL Init(IShellWindows *psw, LPCITEMIDLIST pidl, DWORD dwPending);
    void CleanUp(void);
    HRESULT WaitForWindowToOpen(DWORD dwTimeout);
    CGIDFWait(void);
    protected:
    ~CGIDFWait(void);
        // internal class to watch for events...
        class CGIDFEvents : public DShellWindowsEvents
        {
            public:
            // IUnknown methods
            //
            virtual STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObj);
            virtual STDMETHODIMP_(ULONG) AddRef(void) ;
            virtual STDMETHODIMP_(ULONG) Release(void);
            // IDispatch methods
            //
            STDMETHOD(GetTypeInfoCount)(THIS_ UINT * pctinfo);
            STDMETHOD(GetTypeInfo)(THIS_ UINT itinfo, LCID lcid, ITypeInfo * * pptinfo);
            STDMETHOD(GetIDsOfNames)(THIS_ REFIID riid, OLECHAR * * rgszNames,
                UINT cNames, LCID lcid, DISPID * rgdispid);
            STDMETHOD(Invoke)(THIS_ DISPID dispidMember, REFIID riid,
                LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult,
                EXCEPINFO * pexcepinfo, UINT * puArgErr);
        } m_EventHandler;
        friend class CGIDFEvents;
        DWORD m_dwCookie;
        IShellWindows *m_psw;
        IConnectionPoint *m_picp;
        DWORD m_dwPending;
        LPITEMIDLIST m_pidl;
        HANDLE m_hevent;
        BOOL  m_fAdvised;
        int m_cRef;
};
ULONG CGIDFWait::AddRef(void)
{
    m_cRef++;
    return m_cRef;
}
ULONG CGIDFWait::Release(void)
{
    m_cRef--;
    if (m_cRef != 0)
        return m_cRef;
    delete this;
    return 0;
}
CGIDFWait::CGIDFWait(void)
{
    ASSERT(m_psw == NULL);
    ASSERT(m_picp == NULL);
    ASSERT(m_hevent == NULL);
    ASSERT(m_dwCookie == 0);
    ASSERT(m_fAdvised == FALSE);
    m_cRef = 1;
    return;
}
CGIDFWait::~CGIDFWait(void)
{
    ATOMICRELEASE(m_psw);
    CleanUp();
    if (m_hevent)
        CloseHandle(m_hevent);
    if (m_pidl)
        ILFree(m_pidl);
}
BOOL CGIDFWait::Init(IShellWindows *psw, LPCITEMIDLIST pidl, DWORD dwPending)
{
    // First try to create an event object
    m_hevent = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (!m_hevent)
        return FALSE;
    // We do not have a window or it is pending...
    // first lets setup that we want to be notified of new windows.
    if (FAILED(ConnectToConnectionPoint(SAFECAST(&m_EventHandler, IDispatch*), DIID_DShellWindowsEvents, TRUE, psw, &m_dwCookie, &m_picp)))
        return FALSE;
    // Save away passed in stuff that we care about.
    m_psw = psw;
    psw->AddRef();
    m_pidl = ILClone(pidl);
    m_dwPending = dwPending;
    return TRUE;
}
void CGIDFWait::CleanUp(void)
{
    // Don't need to listen anmore.
    if (m_dwCookie)
    {
        m_picp->Unadvise(m_dwCookie);
        m_dwCookie = 0;
    }
    ATOMICRELEASE(m_picp);
}
HRESULT CGIDFWait::WaitForWindowToOpen(DWORD dwTimeOut)
{
    if (!m_hevent || !m_dwCookie)
        return E_FAIL;
    ENTERCRITICAL;
    if (!m_fAdvised)
        ResetEvent(m_hevent);
    LEAVECRITICAL;
    DWORD dwStart = GetTickCount();
    DWORD dwWait = dwTimeOut;
    DWORD dwWaitResult;
    do
    {
        dwWaitResult= MsgWaitForMultipleObjects(1, &m_hevent,
                                                FALSE, // fWaitAll, wait for any one
                                                dwWait, QS_ALLINPUT);
        // Check if we are signaled for a send message.
        if (dwWaitResult != WAIT_OBJECT_0 + 1)
        {
            // No. Break out of the loop.
            break;
        }
        // We may need to dispatch stuff here.
        MSG msg;
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        // than MSEC_MAXWAIT if we wait more than that.
        //
        dwWait = dwStart+dwTimeOut - GetTickCount();
    } while (dwWait <= dwTimeOut);
    BOOL fAdvised;
    
    {
    ENTERCRITICAL;
    
    fAdvised = m_fAdvised;
    m_fAdvised = FALSE;
    
    LEAVECRITICAL;
    }
    return fAdvised ? NOERROR : E_FAIL;
}
STDMETHODIMP CGIDFWait::CGIDFEvents::QueryInterface(REFIID riid, void **ppvOut)
{
    if (IsEqualIID(riid, IID_IDispatch) ||
        IsEqualIID(riid, IID_IUnknown))
    {
        *ppvOut = SAFECAST(this, IDispatch *);
    }
    else if (IsEqualIID(riid, DIID_DShellWindowsEvents))
    {
        *ppvOut = SAFECAST(this, DShellWindowsEvents *);
    }
    else
    {
        *ppvOut = NULL;
        return E_NOINTERFACE;
    }
    AddRef();
    return S_OK;
}
ULONG CGIDFWait::CGIDFEvents::AddRef(void)
{
    CGIDFWait* pdfwait = IToClass(CGIDFWait, m_EventHandler, this);
    return pdfwait->AddRef();
}
ULONG CGIDFWait::CGIDFEvents::Release(void)
{
    CGIDFWait* pdfwait = IToClass(CGIDFWait, m_EventHandler, this);
    return pdfwait->Release();
}
HRESULT CGIDFWait::CGIDFEvents::GetTypeInfoCount(UINT *pctinfo)
{
    return E_NOTIMPL;
}
HRESULT CGIDFWait::CGIDFEvents::GetTypeInfo(UINT itinfo, LCID lcid,
                                             ITypeInfo **pptinfo)
{
    return E_NOTIMPL;
}
HRESULT CGIDFWait::CGIDFEvents::GetIDsOfNames(REFIID riid, OLECHAR **rgszNames,
                                              UINT cNames, LCID lcid, DISPID *rgdispid)
{
    return E_NOTIMPL;
}
HRESULT CGIDFWait::CGIDFEvents::Invoke(DISPID dispid, REFIID riid,
    LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult,
    EXCEPINFO * pexcepinfo, UINT * puArgErr)
{
    CGIDFWait* pdfwait = IToClass(CGIDFWait, m_EventHandler, this);
    if (dispid == DISPID_WINDOWREGISTERED)
    {
        ENTERCRITICAL;
        
        // Signal the event
        pdfwait->m_fAdvised = TRUE;
        ::SetEvent(pdfwait->m_hevent);
        
        LEAVECRITICAL;
    }
    return S_OK;
}
// BugBug:: this assumes not rooted
STDAPI SHGetIDispatchForFolder(LPCITEMIDLIST pidl, IWebBrowserApp **ppauto)
{
    HRESULT hres = E_UNEXPECTED;
    if (ppauto)
        *ppauto = NULL;
    if (!pidl)
        return E_POINTER;
    // Try a cached psw if we don't need ppauto
    IShellWindows* psw = WinList_GetShellWindows(ppauto != NULL);
    if (psw)
    {
        VARIANT var;
        LONG lhwnd;
        if (InitVariantFromIDList(&var, pidl)) 
        {
            IDispatch* pdisp;
            hres = psw->FindWindow(&var, PVAREMPTY, SWC_BROWSER, &lhwnd,
                    ppauto ? (SWFO_NEEDDISPATCH | SWFO_INCLUDEPENDING) : SWFO_INCLUDEPENDING,
                    &pdisp);
            if ((hres == E_PENDING) || (hres == S_FALSE))
            {
                HRESULT hresOld = hres;
                hres = E_FAIL;
                CGIDFWait *pdfwait = new CGIDFWait();   // Setup a wait object...
                if (pdfwait)
                {
                    if (pdfwait->Init(psw, pidl, 0))
                    {
                        if (hresOld == S_FALSE)
                        {
                            // Startup opening a new window
                            SHELLEXECUTEINFO sei = {sizeof(SHELLEXECUTEINFO)};
                            sei.lpIDList = (void *)pidl;
                            //
                            //  WARNING - old versions of ShellExec() didnt pay attention - ZekeL - 30-DEC-98
                            //  to whether the hwnd is in the same process or not, 
                            //  and so could fault in TryDDEShortcut().
                            //  only pass the hwnd if the shell window shares 
                            //  the same process.
                            //
                            sei.hwnd = GetShellWindow();
                            DWORD idProcess;
                            GetWindowThreadProcessId(sei.hwnd, &idProcess);
                            if (idProcess != GetCurrentProcessId())
                                sei.hwnd = NULL;
                            // Everything should have been initialize to NULL(0)
                            sei.fMask = SEE_MASK_IDLIST | SEE_MASK_FLAG_DDEWAIT;
                            sei.nShow = SW_SHOWNORMAL;
                            hres = ShellExecuteEx(&sei) ? NOERROR : S_FALSE;
                        }
                        while ((hres = psw->FindWindow(&var, PVAREMPTY, SWC_BROWSER, &lhwnd,
                                ppauto ? (SWFO_NEEDDISPATCH | SWFO_INCLUDEPENDING) : SWFO_INCLUDEPENDING,
                                &pdisp)) != S_OK)
                        {
                            if (FAILED(pdfwait->WaitForWindowToOpen(20 * 1000)))
                            {
                                hres = E_ABORT;
                                break;
                            }
                        }
                    }
                    pdfwait->CleanUp();   // No need to watch things any more...
                    pdfwait->Release(); // release our use of this object...
                }
            }
            if (hres == S_OK && ppauto) 
            {
                // if this fails this is because we are inside SendMessage loop
                hres = pdisp->QueryInterface(IID_IWebBrowserApp, (void **)ppauto);
            }
            if (pdisp)
                pdisp->Release();
            VariantClear(&var);
        }
        psw->Release();
    }
    return hres;
}
#ifdef POSTPOSTSPLIT
// at this point, this code should be loaded from browseui.dll
#else
#undef VariantCopy
WINOLEAUTAPI VariantCopyLazy(VARIANTARG * pvargDest, VARIANTARG * pvargSrc)
{
    VariantClearLazy(pvargDest);
    switch(pvargSrc->vt) {
    case VT_I4:
    case VT_UI4:
    case VT_BOOL:
        // we can add more
        *pvargDest = *pvargSrc;
        return S_OK;
    case VT_UNKNOWN:
        if (pvargDest) {
            *pvargDest = *pvargSrc;
            pvargDest->punkVal->AddRef();
            return S_OK;
        }
        ASSERT(0);
        return E_INVALIDARG;
    }
    return VariantCopy(pvargDest, pvargSrc);
}
//
// WARNING: This function must be placed at the end because we #undef
// VariantClear
//
#undef VariantClear
HRESULT VariantClearLazy(VARIANTARG *pvarg)
{
    switch(pvarg->vt) 
    {
        case VT_I4:
        case VT_UI4:
        case VT_EMPTY:
        case VT_BOOL:
            // No operation
            break;
        case VT_UNKNOWN:
            if(V_UNKNOWN(pvarg) != NULL)
              V_UNKNOWN(pvarg)->Release();
            break;
        case VT_DISPATCH:
            if(V_DISPATCH(pvarg) != NULL)
              V_DISPATCH(pvarg)->Release();
            break;
        case VT_SAFEARRAY:
            THR(SafeArrayDestroy(V_ARRAY(pvarg)));
            break;
        default:
            return VariantClear(pvarg);
    }
    V_VT(pvarg) = VT_EMPTY;
    return S_OK;
}
#endif

						