git.oblomov.eu Git - wine/blob - dlls/mshtml/tests/activex.c

   1 /*
   2  * Copyright 2010 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "mshtml.h"
  30 #include "docobj.h"
  31 #include "hlink.h"
  32 #include "dispex.h"
  33 #include "mshtmhst.h"
  34 #include "activscp.h"
  35 #include "objsafe.h"
  36 #include "mshtmdid.h"
  37 #include "mshtml_test.h"
  38
  39 #define DEFINE_EXPECT(func) \
  40     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  41
  42 #define SET_EXPECT(func) \
  43     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  44
  45 #define CHECK_EXPECT2(func) \
  46     do { \
  47         ok(expect_ ##func, "unexpected call " #func "\n"); \
  48         called_ ## func = TRUE; \
  49     }while(0)
  50
  51 #define CHECK_EXPECT(func) \
  52     do { \
  53         CHECK_EXPECT2(func); \
  54         expect_ ## func = FALSE; \
  55     }while(0)
  56
  57 #define CHECK_CALLED(func) \
  58     do { \
  59         ok(called_ ## func, "expected " #func "\n"); \
  60         expect_ ## func = called_ ## func = FALSE; \
  61     }while(0)
  62
  63 DEFINE_EXPECT(CreateInstance);
  64 DEFINE_EXPECT(FreezeEvents_TRUE);
  65 DEFINE_EXPECT(FreezeEvents_FALSE);
  66 DEFINE_EXPECT(QuickActivate);
  67 DEFINE_EXPECT(IPersistPropertyBag_InitNew);
  68 DEFINE_EXPECT(IPersistPropertyBag_Load);
  69 DEFINE_EXPECT(Invoke_READYSTATE);
  70 DEFINE_EXPECT(Invoke_ENABLED);
  71 DEFINE_EXPECT(Invoke_VALID);
  72 DEFINE_EXPECT(Invoke_SECURITYCTX);
  73 DEFINE_EXPECT(Invoke_SCRIPTPROP);
  74 DEFINE_EXPECT(GetIDsOfNames_scriptprop);
  75 DEFINE_EXPECT(DoVerb);
  76 DEFINE_EXPECT(SetExtent);
  77 DEFINE_EXPECT(GetExtent);
  78 DEFINE_EXPECT(SetClientSite);
  79 DEFINE_EXPECT(SetClientSite_NULL);
  80 DEFINE_EXPECT(Close);
  81 DEFINE_EXPECT(InPlaceObject_GetWindow);
  82 DEFINE_EXPECT(SetObjectRects);
  83 DEFINE_EXPECT(InPlaceDeactivate);
  84 DEFINE_EXPECT(UIDeactivate);
  85 DEFINE_EXPECT(QueryService_TestActiveX);
  86 DEFINE_EXPECT(GetMiscStatus);
  87 DEFINE_EXPECT(SetAdvise);
  88 DEFINE_EXPECT(GetViewStatus);
  89 DEFINE_EXPECT(QI_ITestActiveX);
  90 DEFINE_EXPECT(wrapped_AddRef);
  91 DEFINE_EXPECT(wrapped_Release);
  92 DEFINE_EXPECT(wrapped_func);
  93 DEFINE_EXPECT(OnAmbientPropertyChange_UNKNOWN);
  94
  95 #define DISPID_SCRIPTPROP 1000
  96
  97 enum {
  98     TEST_FLASH,
  99     TEST_NOQUICKACT,
 100     TEST_DISPONLY
 101 };
 102
 103 static HWND container_hwnd, plugin_hwnd;
 104 static int plugin_behavior;
 105 static BOOL no_quickact;
 106
 107 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7f6680746}"
 108
 109 static const GUID CLSID_TestActiveX =
 110     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
 111
 112 static const GUID IID_ITestActiveX =
 113     {0x178fc663,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
 114
 115 static const char object_ax_str[] =
 116     "<html><head></head><body>"
 117     "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
 118     "<param name=\"param_name\" value=\"param_value\">"
 119     "<param name=\"num_param\" value=\"3\">"
 120     "</object>"
 121     "</body></html>";
 122
 123 static REFIID pluginhost_iids[] = {
 124     &IID_IOleClientSite,
 125     &IID_IAdviseSink,
 126     &IID_IAdviseSinkEx,
 127     &IID_IPropertyNotifySink,
 128     &IID_IDispatch,
 129     &IID_IOleWindow,
 130     &IID_IOleInPlaceSite,
 131     &IID_IOleInPlaceSiteEx,
 132     &IID_IOleControlSite,
 133     &IID_IBindHost,
 134     &IID_IServiceProvider,
 135     NULL
 136 };
 137
 138 static const char *debugstr_guid(REFIID riid)
 139 {
 140     static char buf[50];
 141
 142     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 143             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 144             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 145             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 146
 147     return buf;
 148 }
 149
 150 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 151 {
 152     IUnknown *unk1, *unk2;
 153
 154     if(iface1 == iface2)
 155         return TRUE;
 156
 157     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 158     IUnknown_Release(unk1);
 159     IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
 160     IUnknown_Release(unk2);
 161
 162     return unk1 == unk2;
 163 }
 164
 165 #define test_ifaces(i,ids) _test_ifaces(__LINE__,i,ids)
 166 static void _test_ifaces(unsigned line, IUnknown *iface, REFIID *iids)
 167 {
 168     const IID * const *piid;
 169     IUnknown *unk;
 170     HRESULT hres;
 171
 172      for(piid = iids; *piid; piid++) {
 173         hres = IUnknown_QueryInterface(iface, *piid, (void**)&unk);
 174         ok_(__FILE__,line) (hres == S_OK, "Could not get %s interface: %08x\n", debugstr_guid(*piid), hres);
 175         if(SUCCEEDED(hres))
 176             IUnknown_Release(unk);
 177     }
 178 }
 179
 180 static int strcmp_wa(LPCWSTR strw, const char *stra)
 181 {
 182     CHAR buf[512];
 183     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 184     return lstrcmpA(stra, buf);
 185 }
 186
 187 static BSTR a2bstr(const char *str)
 188 {
 189     BSTR ret;
 190     int len;
 191
 192     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 193     ret = SysAllocStringLen(NULL, len);
 194     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 195
 196     return ret;
 197 }
 198
 199 static IOleClientSite *client_site;
 200 static READYSTATE plugin_readystate = READYSTATE_UNINITIALIZED;
 201
 202 static void set_plugin_readystate(READYSTATE state)
 203 {
 204     IPropertyNotifySink *prop_notif;
 205     HRESULT hres;
 206
 207     plugin_readystate = state;
 208
 209     hres = IOleClientSite_QueryInterface(client_site, &IID_IPropertyNotifySink, (void**)&prop_notif);
 210     ok(hres == S_OK, "Could not get IPropertyNotifySink iface: %08x\n", hres);
 211
 212     hres = IPropertyNotifySink_OnChanged(prop_notif, DISPID_READYSTATE);
 213     ok(hres == S_OK, "OnChanged(DISPID_READYSTATE) failed: %08x\n", hres);
 214
 215     IPropertyNotifySink_Release(prop_notif);
 216 }
 217
 218 static void test_mon_displayname(IMoniker *mon, const char *exname, const char *broken_name)
 219 {
 220     LPOLESTR display_name;
 221     DWORD mksys;
 222     HRESULT hres;
 223
 224     hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
 225     ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
 226     ok(!strcmp_wa(display_name, exname) || broken(broken_name && !strcmp_wa(display_name, broken_name)),
 227         "display_name = %s\n", wine_dbgstr_w(display_name));
 228     CoTaskMemFree(display_name);
 229
 230     hres = IMoniker_IsSystemMoniker(mon, &mksys);
 231     ok(hres == S_OK, "IsSystemMoniker failed: %08x\n", hres);
 232     ok(mksys == MKSYS_URLMONIKER, "mksys = %d\n", mksys);
 233 }
 234
 235 static LRESULT WINAPI plugin_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 236 {
 237     switch(msg) {
 238     case WM_PAINT: {
 239         PAINTSTRUCT ps;
 240         HBRUSH brush;
 241         RECT rect;
 242         HDC dc;
 243
 244         GetClientRect(hwnd, &rect);
 245
 246         dc = BeginPaint(hwnd, &ps);
 247         brush = CreateSolidBrush(RGB(255,0,0));
 248         SelectObject(dc, brush);
 249         Rectangle(dc, rect.left, rect.top, rect.right, rect.bottom);
 250         DeleteObject(brush);
 251         EndPaint(hwnd, &ps);
 252         break;
 253     }
 254     }
 255
 256     return DefWindowProc(hwnd, msg, wParam, lParam);
 257 }
 258
 259 static void create_plugin_window(HWND parent, const RECT *rect)
 260 {
 261     static const WCHAR plugin_testW[] =
 262         {'p','l','u','g','i','n',' ','t','e','s','t',0};
 263     static WNDCLASSEXW wndclass = {
 264         sizeof(WNDCLASSEXW),
 265         0,
 266         plugin_proc,
 267         0, 0, NULL, NULL, NULL, NULL, NULL,
 268         plugin_testW,
 269         NULL
 270     };
 271
 272     RegisterClassExW(&wndclass);
 273     plugin_hwnd = CreateWindowW(plugin_testW, plugin_testW,
 274             WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN, rect->left, rect->top,
 275             rect->right-rect->left, rect->bottom-rect->top, parent, NULL, NULL, NULL);
 276 }
 277
 278 static HRESULT ax_qi(REFIID,void**);
 279
 280 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 281 {
 282     return ax_qi(riid, ppv);
 283 }
 284
 285 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 286 {
 287     return 2;
 288 }
 289
 290 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 291 {
 292     return 1;
 293 }
 294
 295 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 296 {
 297     ok(0, "unexpected call\n");
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *mMsg)
 302 {
 303     ok(0, "unexpected call\n");
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 308 {
 309     switch(dispID) {
 310     case DISPID_UNKNOWN:
 311         CHECK_EXPECT(OnAmbientPropertyChange_UNKNOWN);
 312         break;
 313     default:
 314         ok(0, "unexpected call %d\n", dispID);
 315     }
 316
 317     return S_OK;
 318 }
 319
 320 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
 321 {
 322     if(bFreeze)
 323         CHECK_EXPECT2(FreezeEvents_TRUE);
 324     else
 325         CHECK_EXPECT2(FreezeEvents_FALSE);
 326     return S_OK;
 327 }
 328
 329 static const IOleControlVtbl OleControlVtbl = {
 330     OleControl_QueryInterface,
 331     OleControl_AddRef,
 332     OleControl_Release,
 333     OleControl_GetControlInfo,
 334     OleControl_OnMnemonic,
 335     OleControl_OnAmbientPropertyChange,
 336     OleControl_FreezeEvents
 337 };
 338
 339 static IOleControl OleControl = { &OleControlVtbl };
 340
 341 static HRESULT WINAPI QuickActivate_QueryInterface(IQuickActivate *iface, REFIID riid, void **ppv)
 342 {
 343     return ax_qi(riid, ppv);
 344 }
 345
 346 static ULONG WINAPI QuickActivate_AddRef(IQuickActivate *iface)
 347 {
 348     return 2;
 349 }
 350
 351 static ULONG WINAPI QuickActivate_Release(IQuickActivate *iface)
 352 {
 353     return 1;
 354 }
 355
 356 static HRESULT WINAPI QuickActivate_QuickActivate(IQuickActivate *iface, QACONTAINER *container, QACONTROL *control)
 357 {
 358     CHECK_EXPECT(QuickActivate);
 359
 360     ok(container != NULL, "container == NULL\n");
 361     ok(container->cbSize == sizeof(*container), "container->cbSize = %d\n", container->cbSize);
 362     ok(container->pClientSite != NULL, "container->pClientSite == NULL\n");
 363     ok(container->pAdviseSink != NULL, "container->pAdviseSink == NULL\n");
 364     ok(container->pPropertyNotifySink != NULL, "container->pPropertyNotifySink == NULL\n");
 365     ok(!container->pUnkEventSink, "container->pUnkEventSink != NULL\n");
 366     ok(container->dwAmbientFlags == (QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE),
 367        "container->dwAmbientFlags = %x\n", container->dwAmbientFlags);
 368     ok(!container->colorFore, "container->colorFore == 0\n"); /* FIXME */
 369     todo_wine
 370     ok(container->colorBack, "container->colorBack == 0\n"); /* FIXME */
 371     todo_wine
 372     ok(container->pFont != NULL, "container->pFont == NULL\n");
 373     todo_wine
 374     ok(container->pUndoMgr != NULL, "container->pUndoMgr == NULL\n");
 375     ok(!container->dwAppearance, "container->dwAppearance = %x\n", container->dwAppearance);
 376     ok(!container->lcid, "container->lcid = %x\n", container->lcid);
 377     ok(!container->hpal, "container->hpal = %p\n", container->hpal);
 378     ok(!container->pBindHost, "container->pBindHost != NULL\n");
 379     ok(!container->pOleControlSite, "container->pOleControlSite != NULL\n");
 380     ok(!container->pServiceProvider, "container->pServiceProvider != NULL\n");
 381
 382     ok(control->cbSize == sizeof(*control), "control->cbSize = %d\n", control->cbSize);
 383     ok(!control->dwMiscStatus, "control->dwMiscStatus = %x\n", control->dwMiscStatus);
 384     ok(!control->dwViewStatus, "control->dwViewStatus = %x\n", control->dwViewStatus);
 385     ok(!control->dwEventCookie, "control->dwEventCookie = %x\n", control->dwEventCookie);
 386     ok(!control->dwPropNotifyCookie, "control->dwPropNotifyCookie = %x\n", control->dwPropNotifyCookie);
 387     ok(!control->dwPointerActivationPolicy, "control->dwPointerActivationPolicy = %x\n", control->dwPointerActivationPolicy);
 388
 389     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pAdviseSink),
 390        "container->pClientSite != container->pAdviseSink\n");
 391     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pPropertyNotifySink),
 392        "container->pClientSite != container->pPropertyNotifySink\n");
 393     test_ifaces((IUnknown*)container->pClientSite, pluginhost_iids);
 394
 395     IOleClientSite_AddRef(container->pClientSite);
 396     client_site = container->pClientSite;
 397
 398     control->dwMiscStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 399         |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 400     control->dwViewStatus = 0x18;
 401     control->dwPropNotifyCookie = 1;
 402
 403     return S_OK;
 404 }
 405
 406 static HRESULT WINAPI QuickActivate_SetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 407 {
 408     ok(0, "unexpected call\n");
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI QuickActivate_GetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 413 {
 414     ok(0, "unexpected call\n");
 415     return E_NOTIMPL;
 416 }
 417
 418 static const IQuickActivateVtbl QuickActivateVtbl = {
 419     QuickActivate_QueryInterface,
 420     QuickActivate_AddRef,
 421     QuickActivate_Release,
 422     QuickActivate_QuickActivate,
 423     QuickActivate_GetContentExtent,
 424     QuickActivate_SetContentExtent
 425 };
 426
 427 static IQuickActivate QuickActivate = { &QuickActivateVtbl };
 428
 429 static HRESULT WINAPI PersistPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv)
 430 {
 431     return ax_qi(riid, ppv);
 432 }
 433
 434 static ULONG WINAPI PersistPropertyBag_AddRef(IPersistPropertyBag *iface)
 435 {
 436     return 2;
 437 }
 438
 439 static ULONG WINAPI PersistPropertyBag_Release(IPersistPropertyBag *iface)
 440 {
 441     return 1;
 442 }
 443
 444 static HRESULT WINAPI PersistPropertyBag_GetClassID(IPersistPropertyBag *face, CLSID *pClassID)
 445 {
 446     ok(0, "unexpected call\n");
 447     return E_NOTIMPL;
 448 }
 449
 450 static HRESULT WINAPI PersistPropertyBag_InitNew(IPersistPropertyBag *face)
 451 {
 452     CHECK_EXPECT(IPersistPropertyBag_InitNew);
 453     return S_OK;
 454 }
 455
 456 static HRESULT WINAPI PersistPropertyBag_Load(IPersistPropertyBag *face, IPropertyBag *pPropBag, IErrorLog *pErrorLog)
 457 {
 458     IBindHost *bind_host, *bind_host2;
 459     IServiceProvider *sp;
 460     IMoniker *mon;
 461     VARIANT v;
 462     HRESULT hres;
 463
 464     static const WCHAR param_nameW[] = {'p','a','r','a','m','_','n','a','m','e',0};
 465     static const WCHAR num_paramW[] = {'n','u','m','_','p','a','r','a','m',0};
 466     static const WCHAR no_paramW[] = {'n','o','_','p','a','r','a','m',0};
 467     static WCHAR test_swfW[] = {'t','e','s','t','.','s','w','f',0};
 468
 469     static const IID *propbag_ifaces[] = {
 470         &IID_IPropertyBag,
 471         &IID_IPropertyBag2,
 472         NULL
 473     };
 474
 475     CHECK_EXPECT(IPersistPropertyBag_Load);
 476
 477     ok(pPropBag != NULL, "pPropBag == NULL\n");
 478     ok(!pErrorLog, "pErrorLog != NULL\n");
 479
 480     test_ifaces((IUnknown*)pPropBag, propbag_ifaces);
 481
 482     V_VT(&v) = VT_BSTR;
 483     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 484     ok(hres == S_OK, "Read failed: %08x\n", hres);
 485     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 486     ok(!strcmp_wa(V_BSTR(&v), "param_value"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 487
 488     V_VT(&v) = VT_I4;
 489     V_I4(&v) = 0xdeadbeef;
 490     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 491     ok(hres == DISP_E_TYPEMISMATCH, "Read failed: %08x, expected DISP_E_TYPEMISMATCH\n", hres);
 492     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 493     ok(V_I4(&v) == 0xdeadbeef, "V_I4(v) = %x\n", V_I4(&v));
 494
 495     V_VT(&v) = VT_BSTR;
 496     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 497     ok(hres == S_OK, "Read failed: %08x\n", hres);
 498     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 499     ok(!strcmp_wa(V_BSTR(&v), "3"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 500     SysFreeString(V_BSTR(&v));
 501
 502     V_VT(&v) = VT_I4;
 503     V_I4(&v) = 0xdeadbeef;
 504     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 505     ok(hres == S_OK, "Read failed: %08x\n", hres);
 506     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 507     ok(V_I4(&v) == 3, "V_I4(v) = %x\n", V_I4(&v));
 508
 509     V_VT(&v) = VT_BSTR;
 510     V_BSTR(&v) = (BSTR)0xdeadbeef;
 511     hres = IPropertyBag_Read(pPropBag, no_paramW, &v, NULL);
 512     ok(hres == E_INVALIDARG, "Read failed: %08x\n", hres);
 513     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 514     ok(V_BSTR(&v) == (BSTR)0xdeadbeef, "V_BSTR(v) = %p\n", V_BSTR(&v));
 515
 516     set_plugin_readystate(READYSTATE_INTERACTIVE);
 517
 518     hres = IOleClientSite_QueryInterface(client_site, &IID_IBindHost, (void**)&bind_host);
 519     ok(hres == S_OK, "Could not get IBindHost iface: %08x\n", hres);
 520
 521     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&sp);
 522     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
 523
 524     hres = IServiceProvider_QueryService(sp, &SID_SBindHost, &IID_IBindHost, (void**)&bind_host2);
 525     ok(hres == S_OK, "QueryService(SID_SBindHost) failed: %08x\n", hres);
 526     IServiceProvider_Release(sp);
 527
 528     ok(iface_cmp((IUnknown*)bind_host, (IUnknown*)bind_host2), "bind_host != bind_host2\n");
 529     IBindHost_Release(bind_host2);
 530
 531     mon = NULL;
 532     hres = IBindHost_CreateMoniker(bind_host, test_swfW, NULL, &mon, 0);
 533     ok(hres == S_OK, "CreateMoniker failed: %08x\n", hres);
 534     ok(mon != NULL, "mon == NULL\n");
 535     test_mon_displayname(mon, "about:test.swf", "about:blanktest.swf");
 536     IMoniker_Release(mon);
 537
 538     IBindHost_Release(bind_host);
 539
 540     mon = NULL;
 541     hres = IOleClientSite_GetMoniker(client_site, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &mon);
 542     ok(hres == S_OK, "GetMoniker failed: %08x\n", hres);
 543     ok(mon != NULL, "mon == NULL\n");
 544     test_mon_displayname(mon, "about:blank", NULL);
 545     IMoniker_Release(mon);
 546
 547     set_plugin_readystate(READYSTATE_COMPLETE);
 548
 549     return S_OK;
 550 }
 551
 552 static HRESULT WINAPI PersistPropertyBag_Save(IPersistPropertyBag *face, IPropertyBag *pPropBag, BOOL fClearDisrty, BOOL fSaveAllProperties)
 553 {
 554     ok(0, "unexpected call\n");
 555     return E_NOTIMPL;
 556 }
 557
 558 static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = {
 559     PersistPropertyBag_QueryInterface,
 560     PersistPropertyBag_AddRef,
 561     PersistPropertyBag_Release,
 562     PersistPropertyBag_GetClassID,
 563     PersistPropertyBag_InitNew,
 564     PersistPropertyBag_Load,
 565     PersistPropertyBag_Save
 566
 567 };
 568
 569 static IPersistPropertyBag PersistPropertyBag = { &PersistPropertyBagVtbl };
 570
 571 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 572 {
 573     return ax_qi(riid, ppv);
 574 }
 575
 576 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 577 {
 578     return 2;
 579 }
 580
 581 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 582 {
 583     return 1;
 584 }
 585
 586 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 587 {
 588     ok(0, "unexpected call\n");
 589     return E_NOTIMPL;
 590 }
 591
 592 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 593         ITypeInfo **ppTInfo)
 594 {
 595     ok(0, "unexpected call\n");
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 600         UINT cNames, LCID lcid, DISPID *rgDispId)
 601 {
 602     CHECK_EXPECT(GetIDsOfNames_scriptprop);
 603     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", debugstr_guid(riid));
 604     ok(cNames == 1, "cNames = %d\n", cNames);
 605     ok(rgszNames != NULL, "rgszNames == NULL\n");
 606     ok(!strcmp_wa(rgszNames[0], "scriptprop"), "rgszNames[0] = %s\n", wine_dbgstr_w(rgszNames[0]));
 607     ok(rgDispId != NULL, "rgDispId == NULL\n");
 608
 609     *rgDispId = DISPID_SCRIPTPROP;
 610     return S_OK;
 611 }
 612
 613 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 614         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 615         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 616 {
 617     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", debugstr_guid(riid));
 618     ok(pDispParams != NULL, "pDispParams == NULL\n");
 619     ok(!pDispParams->cNamedArgs, "pDispParams->cNamedArgs = %d\n", pDispParams->cNamedArgs);
 620     ok(!pDispParams->rgdispidNamedArgs, "pDispParams->rgdispidNamedArgs != NULL\n");
 621     ok(pVarResult != NULL, "pVarResult == NULL\n");
 622
 623     switch(dispIdMember) {
 624     case DISPID_READYSTATE:
 625         CHECK_EXPECT2(Invoke_READYSTATE);
 626         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 627         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 628         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 629         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 630         ok(puArgErr != NULL, "puArgErr == NULL\n");
 631
 632         V_VT(pVarResult) = VT_I4;
 633         V_I4(pVarResult) = plugin_readystate;
 634         return S_OK;
 635      case DISPID_ENABLED:
 636         CHECK_EXPECT2(Invoke_ENABLED);
 637         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 638         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 639         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 640         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 641         ok(puArgErr != NULL, "puArgErr == NULL\n");
 642         return DISP_E_MEMBERNOTFOUND;
 643     case DISPID_VALID:
 644         CHECK_EXPECT(Invoke_VALID);
 645         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 646         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 647         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 648         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 649         ok(puArgErr != NULL, "puArgErr == NULL\n");
 650         return DISP_E_MEMBERNOTFOUND;
 651     case DISPID_SECURITYCTX:
 652         CHECK_EXPECT(Invoke_SECURITYCTX);
 653         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 654         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 655         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 656         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 657         ok(puArgErr != NULL, "puArgErr == NULL\n");
 658         return DISP_E_MEMBERNOTFOUND;
 659     case DISPID_SCRIPTPROP:
 660         CHECK_EXPECT(Invoke_SCRIPTPROP);
 661         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 662         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 663         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 664         ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
 665         ok(!puArgErr, "puArgErr != NULL\n");
 666
 667         V_VT(pVarResult) = VT_I4;
 668         V_I4(pVarResult) = 4;
 669         return S_OK;
 670     default:
 671         ok(0, "unexpected call %d\n", dispIdMember);
 672     }
 673
 674     return E_NOTIMPL;
 675 }
 676
 677 static const IDispatchVtbl DispatchVtbl = {
 678     Dispatch_QueryInterface,
 679     Dispatch_AddRef,
 680     Dispatch_Release,
 681     Dispatch_GetTypeInfoCount,
 682     Dispatch_GetTypeInfo,
 683     Dispatch_GetIDsOfNames,
 684     Dispatch_Invoke
 685 };
 686
 687 static IDispatch Dispatch = { &DispatchVtbl };
 688
 689 static HRESULT WINAPI ViewObjectEx_QueryInterface(IViewObjectEx *iface, REFIID riid, void **ppv)
 690 {
 691     return ax_qi(riid, ppv);
 692 }
 693
 694 static ULONG WINAPI ViewObjectEx_AddRef(IViewObjectEx *iface)
 695 {
 696     return 2;
 697 }
 698
 699 static ULONG WINAPI ViewObjectEx_Release(IViewObjectEx *iface)
 700 {
 701     return 1;
 702 }
 703
 704 static HRESULT WINAPI ViewObjectEx_Draw(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 705         HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBoungs, BOOL (WINAPI*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue)
 706 {
 707     ok(0, "unexpected call\n");
 708     return E_NOTIMPL;
 709 }
 710
 711 static HRESULT WINAPI ViewObjectEx_GetColorSet(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 712         HDC hicTargetDev, LOGPALETTE **ppColorSet)
 713 {
 714     ok(0, "unexpected call\n");
 715     return E_NOTIMPL;
 716 }
 717
 718 static HRESULT WINAPI ViewObjectEx_Freeze(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
 719 {
 720     ok(0, "unexpected call\n");
 721     return E_NOTIMPL;
 722 }
 723
 724 static HRESULT WINAPI ViewObjectEx_Unfreeze(IViewObjectEx *iface, DWORD dwFreeze)
 725 {
 726     ok(0, "unexpected call\n");
 727     return E_NOTIMPL;
 728 }
 729
 730 static HRESULT WINAPI ViewObjectEx_SetAdvise(IViewObjectEx *iface, DWORD aspects, DWORD advf, IAdviseSink *pAdvSink)
 731 {
 732     CHECK_EXPECT(SetAdvise);
 733
 734     ok(aspects == DVASPECT_CONTENT, "aspects = %x\n", aspects);
 735     ok(!advf, "advf = %x\n", advf);
 736     ok(pAdvSink != NULL, "pAdvSink = NULL\n");
 737
 738     return S_OK;
 739 }
 740
 741 static HRESULT WINAPI ViewObjectEx_GetAdvise(IViewObjectEx *iface, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
 742 {
 743     ok(0, "unexpected call\n");
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI ViewObjectEx_GetExtent(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel)
 748 {
 749     ok(0, "unexpected call\n");
 750     return E_NOTIMPL;
 751 }
 752
 753 static HRESULT WINAPI ViewObjectEx_GetRect(IViewObjectEx *iface, DWORD dwAspect, LPRECTL pRect)
 754 {
 755     ok(0, "unexpected call\n");
 756     return E_NOTIMPL;
 757 }
 758
 759 static HRESULT WINAPI ViewObjectEx_GetViewStatus(IViewObjectEx *iface, DWORD *pdwStatus)
 760 {
 761     CHECK_EXPECT(GetViewStatus);
 762
 763     *pdwStatus = VIEWSTATUS_OPAQUE|VIEWSTATUS_SOLIDBKGND;
 764     return S_OK;
 765 }
 766
 767 static HRESULT WINAPI ViewObjectEx_QueryHitPoint(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc,
 768         LONG lCloseHint, DWORD *pHitResult)
 769 {
 770     ok(0, "unexpected call\n");
 771     return E_NOTIMPL;
 772 }
 773
 774 static HRESULT WINAPI ViewObjectEx_QueryHitRect(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc,
 775         LONG lCloseHint, DWORD *pHitResult)
 776 {
 777     ok(0, "unexpected call\n");
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI ViewObjectEx_GetNaturalExtent(IViewObjectEx *iface, DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd,
 782         HDC hicTargetDev, DVEXTENTINFO *pExtentIngo, LPSIZEL pSizel)
 783 {
 784     ok(0, "unexpected call\n");
 785     return E_NOTIMPL;
 786 }
 787
 788 static const IViewObjectExVtbl ViewObjectExVtbl = {
 789     ViewObjectEx_QueryInterface,
 790     ViewObjectEx_AddRef,
 791     ViewObjectEx_Release,
 792     ViewObjectEx_Draw,
 793     ViewObjectEx_GetColorSet,
 794     ViewObjectEx_Freeze,
 795     ViewObjectEx_Unfreeze,
 796     ViewObjectEx_SetAdvise,
 797     ViewObjectEx_GetAdvise,
 798     ViewObjectEx_GetExtent,
 799     ViewObjectEx_GetRect,
 800     ViewObjectEx_GetViewStatus,
 801     ViewObjectEx_QueryHitPoint,
 802     ViewObjectEx_QueryHitRect,
 803     ViewObjectEx_GetNaturalExtent
 804 };
 805
 806 static IViewObjectEx ViewObjectEx = { &ViewObjectExVtbl };
 807
 808 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
 809 {
 810     return ax_qi(riid, ppv);
 811 }
 812
 813 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
 814 {
 815     return 2;
 816 }
 817
 818 static ULONG WINAPI OleObject_Release(IOleObject *iface)
 819 {
 820     return 1;
 821 }
 822
 823 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
 824 {
 825     if(!pClientSite) {
 826         CHECK_EXPECT(SetClientSite_NULL);
 827         return S_OK;
 828     }
 829
 830     CHECK_EXPECT(SetClientSite);
 831
 832     IOleClientSite_AddRef(pClientSite);
 833     client_site = pClientSite;
 834     return S_OK;
 835 }
 836
 837 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 838 {
 839     ok(0, "unexpected call\n");
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 844 {
 845     ok(0, "unexpected call\n");
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 850 {
 851     CHECK_EXPECT(Close);
 852
 853     ok(dwSaveOption == OLECLOSE_NOSAVE, "dwSaveOption = %d\n", dwSaveOption);
 854     return S_OK;
 855 }
 856
 857 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 858 {
 859     ok(0, "unexpected call\n");
 860     return E_NOTIMPL;
 861 }
 862
 863 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 864 {
 865     ok(0, "unexpected call\n");
 866     return E_NOTIMPL;
 867 }
 868
 869 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 870         DWORD dwReserved)
 871 {
 872     ok(0, "unexpected call\n");
 873     return E_NOTIMPL;
 874 }
 875
 876 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 877 {
 878     ok(0, "unexpected call\n");
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 883         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 884 {
 885     OLEINPLACEFRAMEINFO frame_info = {0xdeadbeef};
 886     IOleInPlaceUIWindow *ip_uiwindow;
 887     IOleInPlaceFrame *ip_frame;
 888     IOleInPlaceSiteEx *ip_site;
 889     RECT pos_rect, clip_rect;
 890     BOOL no_redraw;
 891     HWND hwnd;
 892     HRESULT hres;
 893
 894     CHECK_EXPECT(DoVerb);
 895
 896     ok(iVerb == OLEIVERB_INPLACEACTIVATE, "iVerb = %d\n", iVerb);
 897     ok(!lpmsg, "lpmsg != NULL\n");
 898     ok(pActiveSite != NULL, "pActiveSite == NULL\n");
 899     ok(!lindex, "lindex = %d\n", lindex);
 900     ok(hwndParent != NULL, "hwndParent == NULL\n");
 901     ok(lprcPosRect != NULL, "lprcPosRect == NULL\n");
 902
 903     hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleInPlaceSiteEx, (void**)&ip_site);
 904     ok(hres == S_OK, "Could not get IOleInPlaceSiteEx iface: %08x\n", hres);
 905
 906     SET_EXPECT(InPlaceObject_GetWindow);
 907     no_redraw = 0xdeadbeef;
 908     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
 909     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
 910     ok(!no_redraw, "no_redraw = %x\n", no_redraw);
 911     CHECK_CALLED(InPlaceObject_GetWindow);
 912
 913     no_redraw = 0xdeadbeef;
 914     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
 915     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
 916     ok(no_redraw == 0xdeadbeef, "no_redraw = %x\n", no_redraw);
 917
 918     hwnd = NULL;
 919     hres = IOleInPlaceSiteEx_GetWindow(ip_site, &hwnd);
 920     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
 921     ok(hwnd != NULL, "hwnd == NULL\n");
 922     ok(hwnd == hwndParent, "hwnd != hwndParent\n");
 923
 924     create_plugin_window(hwnd, lprcPosRect);
 925
 926     ip_frame = NULL;
 927     ip_uiwindow = NULL;
 928     frame_info.cb = sizeof(OLEINPLACEFRAMEINFO);
 929     hres = IOleInPlaceSiteEx_GetWindowContext(ip_site, &ip_frame, &ip_uiwindow, &pos_rect, &clip_rect, &frame_info);
 930     ok(hres == S_OK, "GetWindowContext failed: %08x\n", hres);
 931     ok(ip_frame != NULL, "ip_frame == NULL\n");
 932     ok(ip_uiwindow != NULL, "ip_uiwindow == NULL\n");
 933     ok((IOleInPlaceUIWindow*)ip_frame != ip_uiwindow, "ip_frame == ip_uiwindow\n");
 934     ok(!memcmp(&pos_rect, lprcPosRect, sizeof(RECT)), "pos_rect != lpecPosRect\n");
 935     ok(!memcmp(&clip_rect, lprcPosRect, sizeof(RECT)), "clip_rect != lpecPosRect\n");
 936     ok(frame_info.cb == sizeof(frame_info), "frame_info.cb = %d\n", frame_info.cb);
 937     ok(!frame_info.fMDIApp, "frame_info.fMDIApp = %x\n", frame_info.fMDIApp);
 938     ok(frame_info.hwndFrame != NULL, "frame_info.hwnd == NULL\n");
 939     ok(frame_info.hwndFrame == container_hwnd, "frame_info.hwnd != container_hwnd\n");
 940     ok(!frame_info.haccel, "frame_info.haccel != 0\n");
 941     ok(!frame_info.cAccelEntries, "frame_info.cAccelEntried != 0\n");
 942
 943     IOleInPlaceFrame_Release(ip_frame);
 944     IOleInPlaceUIWindow_Release(ip_uiwindow);
 945
 946
 947     IOleInPlaceSiteEx_Release(ip_site);
 948
 949     hres = IOleClientSite_ShowObject(client_site);
 950     ok(hres == S_OK, "ShowObject failed: %08x\n", hres);
 951
 952     SET_EXPECT(InPlaceObject_GetWindow);
 953     SET_EXPECT(SetObjectRects);
 954
 955     return S_OK;
 956 }
 957
 958 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 959 {
 960     ok(0, "unexpected call\n");
 961     return E_NOTIMPL;
 962 }
 963
 964 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 965 {
 966     ok(0, "unexpected call\n");
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 971 {
 972     ok(0, "unexpected call\n");
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 977 {
 978     ok(0, "unexpected call\n");
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 983 {
 984     ok(0, "unexpected call\n");
 985     return E_NOTIMPL;
 986 }
 987
 988 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 989 {
 990     CHECK_EXPECT(SetExtent);
 991     return E_NOTIMPL;
 992 }
 993
 994 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 995 {
 996     CHECK_EXPECT(GetExtent);
 997     return E_NOTIMPL;
 998 }
 999
1000 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
1001 {
1002     ok(0, "unexpected call\n");
1003     return E_NOTIMPL;
1004 }
1005
1006 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
1007 {
1008     ok(0, "unexpected call\n");
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
1013 {
1014     ok(0, "unexpected call\n");
1015     return E_NOTIMPL;
1016 }
1017
1018 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
1019 {
1020     CHECK_EXPECT(GetMiscStatus);
1021     ok(dwAspect == DVASPECT_CONTENT, "dwAspect = %d\n", dwAspect);
1022     ok(pdwStatus != NULL, "pdwStatus == NULL\n");
1023     *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE
1024         |OLEMISC_INSIDEOUT|OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
1025     return S_OK;
1026 }
1027
1028 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
1029 {
1030     ok(0, "unexpected call\n");
1031     return E_NOTIMPL;
1032 }
1033
1034 static const IOleObjectVtbl OleObjectVtbl = {
1035     OleObject_QueryInterface,
1036     OleObject_AddRef,
1037     OleObject_Release,
1038     OleObject_SetClientSite,
1039     OleObject_GetClientSite,
1040     OleObject_SetHostNames,
1041     OleObject_Close,
1042     OleObject_SetMoniker,
1043     OleObject_GetMoniker,
1044     OleObject_InitFromData,
1045     OleObject_GetClipboardData,
1046     OleObject_DoVerb,
1047     OleObject_EnumVerbs,
1048     OleObject_Update,
1049     OleObject_IsUpToDate,
1050     OleObject_GetUserClassID,
1051     OleObject_GetUserType,
1052     OleObject_SetExtent,
1053     OleObject_GetExtent,
1054     OleObject_Advise,
1055     OleObject_Unadvise,
1056     OleObject_EnumAdvise,
1057     OleObject_GetMiscStatus,
1058     OleObject_SetColorScheme
1059 };
1060
1061 static IOleObject OleObject = { &OleObjectVtbl };
1062
1063 static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObjectWindowless *iface,
1064         REFIID riid, void **ppv)
1065 {
1066     return ax_qi(riid, ppv);
1067 }
1068
1069 static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObjectWindowless *iface)
1070 {
1071     return 2;
1072 }
1073
1074 static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObjectWindowless *iface)
1075 {
1076     return 1;
1077 }
1078
1079 static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObjectWindowless *iface,
1080         HWND *phwnd)
1081 {
1082     CHECK_EXPECT2(InPlaceObject_GetWindow);
1083
1084     ok(phwnd != NULL, "phwnd == NULL\n");
1085
1086     *phwnd = plugin_hwnd;
1087     return *phwnd ? S_OK : E_UNEXPECTED;
1088 }
1089
1090 static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
1091         BOOL fEnterMode)
1092 {
1093     ok(0, "unexpected call\n");
1094     return E_NOTIMPL;
1095 }
1096
1097 static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
1098 {
1099     IOleInPlaceSite *ip_site;
1100     HRESULT hres;
1101
1102     CHECK_EXPECT(InPlaceDeactivate);
1103
1104     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1105     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1106
1107     hres = IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
1108     ok(hres == S_OK, "OnInPlaceDeactivate failed: %08x\n", hres);
1109
1110     IOleInPlaceSite_Release(ip_site);
1111     return S_OK;
1112 }
1113
1114 static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObjectWindowless *iface)
1115 {
1116     CHECK_EXPECT2(UIDeactivate);
1117     return S_OK;
1118 }
1119
1120 static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObjectWindowless *iface,
1121         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
1122 {
1123     CHECK_EXPECT(SetObjectRects);
1124     return S_OK;
1125 }
1126
1127 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
1128 {
1129     ok(0, "unexpected call\n");
1130     return E_NOTIMPL;
1131 }
1132
1133 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
1134         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
1135 {
1136     ok(0, "unexpected call\n");
1137     return E_NOTIMPL;
1138 }
1139
1140 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
1141         IDropTarget **ppDropTarget)
1142 {
1143     ok(0, "unexpected call\n");
1144     return E_NOTIMPL;
1145 }
1146
1147 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
1148     OleInPlaceObject_QueryInterface,
1149     OleInPlaceObject_AddRef,
1150     OleInPlaceObject_Release,
1151     OleInPlaceObject_GetWindow,
1152     OleInPlaceObject_ContextSensitiveHelp,
1153     OleInPlaceObject_InPlaceDeactivate,
1154     OleInPlaceObject_UIDeactivate,
1155     OleInPlaceObject_SetObjectRects,
1156     OleInPlaceObjectWindowless_ReactivateAndUndo,
1157     OleInPlaceObjectWindowless_OnWindowMessage,
1158     OleInPlaceObjectWindowless_GetDropTarget
1159 };
1160
1161 static IOleInPlaceObjectWindowless OleInPlaceObjectWindowless = { &OleInPlaceObjectWindowlessVtbl };
1162
1163 static void *wrapped_iface_vtbl[100];
1164 static IUnknown wrapped_iface = { (IUnknownVtbl*)wrapped_iface_vtbl };
1165
1166 static HRESULT WINAPI wrapped_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1167 {
1168     ok(0, "unexpected wrapped_QueryInterface call\n");
1169     *ppv = NULL;
1170     return E_NOINTERFACE;
1171 }
1172
1173 static ULONG WINAPI wrapped_AddRef(IUnknown *iface)
1174 {
1175     CHECK_EXPECT(wrapped_AddRef);
1176     return 2;
1177 }
1178
1179 static ULONG WINAPI wrapped_Release(IUnknown *iface)
1180 {
1181     CHECK_EXPECT(wrapped_Release);
1182     return 1;
1183 }
1184
1185 static HRESULT WINAPI wrapped_func_nocall(IUnknown *iface, int i, double d)
1186 {
1187     ok(0, "unexpected call\n");
1188     return E_FAIL;
1189 }
1190
1191 static HRESULT WINAPI wrapped_func(IUnknown *iface, int i, double d)
1192 {
1193     CHECK_EXPECT(wrapped_func);
1194     ok(iface == &wrapped_iface, "iface != wrapped_iface\n");
1195     ok(i == 10, "i = %d\n", i);
1196     ok(d == 32.0, "d = %lf\n", d);
1197     return S_OK;
1198 }
1199
1200 static void init_wrapped_iface(void)
1201 {
1202     unsigned i;
1203
1204     wrapped_iface_vtbl[0] = wrapped_QueryInterface;
1205     wrapped_iface_vtbl[1] = wrapped_AddRef;
1206     wrapped_iface_vtbl[2] = wrapped_Release;
1207
1208     for(i=3; i<100; i++)
1209         wrapped_iface_vtbl[i] = wrapped_func_nocall;
1210
1211     wrapped_iface_vtbl[63] = wrapped_func;
1212 }
1213
1214 static HRESULT ax_qi(REFIID riid, void **ppv)
1215 {
1216     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
1217         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleControl;
1218     }else if(IsEqualGUID(riid, &IID_IQuickActivate)) {
1219         *ppv = no_quickact ? NULL : &QuickActivate;
1220     }else if(IsEqualGUID(riid, &IID_IPersistPropertyBag)) {
1221         *ppv = no_quickact ? NULL : &PersistPropertyBag;
1222     }else if(IsEqualGUID(riid, &IID_IDispatch)) {
1223         *ppv = &Dispatch;
1224     }else if(IsEqualGUID(riid, &IID_IViewObject) || IsEqualGUID(riid, &IID_IViewObject2)
1225             || IsEqualGUID(riid, &IID_IViewObjectEx)) {
1226         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &ViewObjectEx;
1227     }else if(IsEqualGUID(riid, &IID_IOleObject)) {
1228         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleObject;
1229     }else if(IsEqualGUID(riid, &IID_ITestActiveX)) {
1230         CHECK_EXPECT(QI_ITestActiveX);
1231         *ppv = &wrapped_iface;
1232     }else  if(IsEqualGUID(riid, &IID_IOleWindow) || IsEqualGUID(riid, &IID_IOleInPlaceObject)
1233        || IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid)) {
1234         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleInPlaceObjectWindowless;
1235     }else {
1236         trace("QI %s\n", debugstr_guid(riid));
1237         *ppv = NULL;
1238     }
1239
1240     return *ppv ? S_OK : E_NOINTERFACE;
1241 }
1242
1243 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1244 {
1245     *ppv = NULL;
1246
1247     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1248         *ppv = iface;
1249         return S_OK;
1250     }
1251
1252     if(IsEqualGUID(&IID_IMarshal, riid))
1253         return E_NOINTERFACE;
1254     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1255         return E_NOINTERFACE;
1256     if(IsEqualGUID(&IID_IClassFactoryEx, riid))
1257         return E_NOINTERFACE; /* TODO */
1258
1259     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1260     return E_NOTIMPL;
1261 }
1262
1263 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1264 {
1265     return 2;
1266 }
1267
1268 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1269 {
1270     return 1;
1271 }
1272
1273 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1274 {
1275     CHECK_EXPECT(CreateInstance);
1276
1277     ok(!outer, "outer = %p\n", outer);
1278     ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", debugstr_guid(riid));
1279
1280     *ppv = &OleControl;
1281     return S_OK;
1282 }
1283
1284 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1285 {
1286     ok(0, "unexpected call\n");
1287     return S_OK;
1288 }
1289
1290 static const IClassFactoryVtbl ClassFactoryVtbl = {
1291     ClassFactory_QueryInterface,
1292     ClassFactory_AddRef,
1293     ClassFactory_Release,
1294     ClassFactory_CreateInstance,
1295     ClassFactory_LockServer
1296 };
1297
1298 static IClassFactory activex_cf = { &ClassFactoryVtbl };
1299
1300 static void test_elem_dispex(IDispatchEx *dispex)
1301 {
1302     DISPPARAMS dp;
1303     EXCEPINFO ei;
1304     VARIANT v;
1305     DISPID id;
1306     BSTR str;
1307     HRESULT hres;
1308
1309     str = a2bstr("scriptprop");
1310     SET_EXPECT(GetIDsOfNames_scriptprop);
1311     hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
1312     CHECK_CALLED(GetIDsOfNames_scriptprop);
1313     SysFreeString(str);
1314     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1315     todo_wine
1316     ok(id == DISPID_SCRIPTPROP, "id = %d\n", id);
1317
1318     SET_EXPECT(Invoke_SECURITYCTX);
1319     SET_EXPECT(Invoke_SCRIPTPROP);
1320     memset(&dp, 0, sizeof(dp));
1321     memset(&ei, 0, sizeof(ei));
1322     V_VT(&v) = VT_EMPTY;
1323     hres = IDispatchEx_InvokeEx(dispex, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
1324     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1325     ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
1326     ok(V_I4(&v) == 4, "V_I4(v) = %d\n", V_I4(&v));
1327     CHECK_CALLED(Invoke_SECURITYCTX);
1328     CHECK_CALLED(Invoke_SCRIPTPROP);
1329 }
1330
1331 static void test_iface_wrapping(IHTMLObjectElement *elem)
1332 {
1333     IHTMLObjectElement *elem2;
1334     IUnknown *unk, *unk2;
1335     ULONG ref;
1336     void **vtbl;
1337     HRESULT hres;
1338
1339     SET_EXPECT(QI_ITestActiveX);
1340     SET_EXPECT(wrapped_AddRef);
1341     SET_EXPECT(wrapped_Release);
1342     unk = (void*)0xdeadbeef;
1343     hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk);
1344     ok(hres == S_OK, "QueryInerface(IID_ITestActiveX failed: %08x\n", hres);
1345     CHECK_CALLED(QI_ITestActiveX);
1346     CHECK_CALLED(wrapped_AddRef);
1347     CHECK_CALLED(wrapped_Release);
1348
1349     /* See dlls/mshtml/ifacewrap.c */
1350     ok(unk != &wrapped_iface, "Unexpected unk %p, expected %p (%p, %p)\n", unk, &ViewObjectEx, unk->lpVtbl, &ViewObjectExVtbl);
1351     ok(unk->lpVtbl != wrapped_iface.lpVtbl, "unk->lpVtbl == wrapped_iface->lpVtbl\n");
1352     ok(unk->lpVtbl->QueryInterface != wrapped_QueryInterface, "QueryInterface not wrapped\n");
1353     ok(unk->lpVtbl->AddRef != wrapped_AddRef, "AddRef not wrapped\n");
1354     ok(unk->lpVtbl->Release != wrapped_Release, "Release not wrapped\n");
1355
1356     vtbl = (void**)unk->lpVtbl;
1357     ok(vtbl[4] != wrapped_func_nocall, "func not wrapped\n");
1358     ok(vtbl[63] != wrapped_func, "func not wrapped\n");
1359
1360     SET_EXPECT(wrapped_func);
1361     hres = ((HRESULT (WINAPI*)(IUnknown*,int,double))vtbl[63])(unk, 10, 32.0);
1362     ok(hres == S_OK, "wrapped_func returned %08x\n", hres);
1363     CHECK_CALLED(wrapped_func);
1364
1365     hres = IUnknown_QueryInterface(unk, &IID_IHTMLObjectElement, (void**)&elem2);
1366     ok(hres == S_OK, "Could not get IHTMLObjectElement from wrapped iface: %08x\n", hres);
1367     ok(iface_cmp((IUnknown*)elem2, (IUnknown*)elem), "elem2 != elem\n");
1368     IHTMLObjectElement_Release(elem2);
1369
1370     SET_EXPECT(wrapped_Release);
1371     ref = IUnknown_Release(unk);
1372     ok(!ref, "ref=%d\n", ref);
1373     CHECK_CALLED(wrapped_Release);
1374
1375     SET_EXPECT(QI_ITestActiveX);
1376     SET_EXPECT(wrapped_AddRef);
1377     SET_EXPECT(wrapped_Release);
1378     unk = (void*)0xdeadbeef;
1379     hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk2);
1380     ok(hres == S_OK, "QueryInerface(IID_ITestActiveX failed: %08x\n", hres);
1381     CHECK_CALLED(QI_ITestActiveX);
1382     CHECK_CALLED(wrapped_AddRef);
1383     CHECK_CALLED(wrapped_Release);
1384
1385     ok(unk != unk2, "unk == unk2\n");
1386
1387     SET_EXPECT(wrapped_Release);
1388     ref = IUnknown_Release(unk2);
1389     ok(!ref, "ref=%d\n", ref);
1390     CHECK_CALLED(wrapped_Release);
1391 }
1392
1393 static void test_object_elem(IHTMLDocument2 *doc)
1394 {
1395     IHTMLObjectElement *objelem;
1396     IHTMLDocument3 *doc3;
1397     IDispatchEx *dispex;
1398     IHTMLElement *elem;
1399     IDispatch *disp;
1400     VARIANT v;
1401     BSTR str;
1402     HRESULT hres;
1403
1404     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
1405     ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
1406
1407     str = a2bstr("objid");
1408     elem = (void*)0xdeadbeef;
1409     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
1410     IHTMLDocument3_Release(doc3);
1411     SysFreeString(str);
1412     ok(hres == S_OK, "getElementById failed: %08x\n", hres);
1413     ok(elem != NULL, "elem == NULL\n");
1414
1415     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLObjectElement, (void**)&objelem);
1416     IHTMLElement_Release(elem);
1417     ok(hres == S_OK, "Could not get IHTMLObjectElement iface: %08x\n", hres);
1418
1419     SET_EXPECT(Invoke_SECURITYCTX);
1420     hres = IHTMLObjectElement_get_object(objelem, &disp);
1421     ok(hres == S_OK, "get_object failed: %08x\n", hres);
1422     ok(disp == &Dispatch, "disp != Dispatch\n");
1423     CHECK_CALLED(Invoke_SECURITYCTX);
1424
1425     hres = IHTMLObjectElement_QueryInterface(objelem, &IID_IDispatchEx, (void**)&dispex);
1426     ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
1427     test_elem_dispex(dispex);
1428     IDispatchEx_Release(dispex);
1429
1430     test_iface_wrapping(objelem);
1431
1432     hres = IHTMLObjectElement_get_width(objelem, &v);
1433     ok(hres == S_OK, "get_width failed: %08x\n", hres);
1434     ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
1435     ok(!strcmp_wa(V_BSTR(&v), "300"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1436     VariantClear(&v);
1437
1438     hres = IHTMLObjectElement_get_height(objelem, &v);
1439     ok(hres == S_OK, "get_height failed: %08x\n", hres);
1440     ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
1441     ok(!strcmp_wa(V_BSTR(&v), "200"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1442     VariantClear(&v);
1443
1444     V_VT(&v) = VT_I4;
1445     V_I4(&v) = 400;
1446     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
1447     SET_EXPECT(Invoke_ENABLED);
1448     hres = IHTMLObjectElement_put_width(objelem, v);
1449     ok(hres == S_OK, "put_width failed: %08x\n", hres);
1450     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
1451     CHECK_CALLED(Invoke_ENABLED);
1452
1453     hres = IHTMLObjectElement_get_width(objelem, &v);
1454     ok(hres == S_OK, "get_width failed: %08x\n", hres);
1455     ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
1456     ok(!strcmp_wa(V_BSTR(&v), "400"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1457     VariantClear(&v);
1458
1459     V_VT(&v) = VT_I4;
1460     V_I4(&v) = 250;
1461     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
1462     SET_EXPECT(Invoke_ENABLED);
1463     hres = IHTMLObjectElement_put_height(objelem, v);
1464     ok(hres == S_OK, "put_height failed: %08x\n", hres);
1465     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
1466     CHECK_CALLED(Invoke_ENABLED);
1467
1468     hres = IHTMLObjectElement_get_height(objelem, &v);
1469     ok(hres == S_OK, "get_height failed: %08x\n", hres);
1470     ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
1471     ok(!strcmp_wa(V_BSTR(&v), "250"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1472     VariantClear(&v);
1473
1474     IHTMLObjectElement_Release(objelem);
1475 }
1476
1477 static void test_container(IHTMLDocument2 *doc_obj)
1478 {
1479     IHTMLWindow2 *parent_window, *html_window;
1480     IServiceProvider *serv_prov;
1481     IOleContainer *container;
1482     IHTMLDocument2 *doc;
1483     IUnknown *unk;
1484     HRESULT hres;
1485
1486     container = NULL;
1487     hres = IOleClientSite_GetContainer(client_site, &container);
1488     ok(hres == S_OK, "GetContainer failed: %08x\n", hres);
1489     ok(container != NULL, "container == NULL\n");
1490
1491     hres = IHTMLDocument2_get_parentWindow(doc_obj, &parent_window);
1492     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
1493     ok(parent_window != NULL, "parentWindow == NULL\n");
1494
1495     hres = IHTMLWindow2_get_document(parent_window, &doc);
1496     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1497     ok(doc != NULL, "doc == NULL\n");
1498     ok(iface_cmp((IUnknown*)doc, (IUnknown*)container), "container != doc\n");
1499     IHTMLDocument2_Release(doc);
1500
1501     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&serv_prov);
1502     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1503
1504     hres = IServiceProvider_QueryService(serv_prov, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&html_window);
1505     ok(hres == S_OK, "Could not get IHTMLWindow2 service: %08x\n", hres);
1506     todo_wine
1507     ok(!iface_cmp((IUnknown*)html_window, (IUnknown*)parent_window), "html_window != parent_window\n");
1508     IHTMLWindow2_Release(html_window);
1509
1510     SET_EXPECT(QueryService_TestActiveX);
1511     hres = IServiceProvider_QueryService(serv_prov, &CLSID_TestActiveX, &IID_IUnknown, (void**)&unk);
1512     ok(hres == S_OK, "QueryService(CLSID_TestActiveX) failed: %08x\n", hres);
1513     ok(unk == (IUnknown*)&OleObject, "unexpected unk %p\n", unk);
1514     CHECK_CALLED(QueryService_TestActiveX);
1515
1516     IServiceProvider_Release(serv_prov);
1517
1518     IHTMLWindow2_Release(parent_window);
1519     IOleContainer_Release(container);
1520 }
1521
1522 static void test_ui_activate(void)
1523 {
1524     IOleInPlaceSite *ip_site;
1525     HRESULT hres;
1526
1527     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1528     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1529
1530     SET_EXPECT(Invoke_ENABLED);
1531     hres = IOleInPlaceSite_OnUIActivate(ip_site);
1532     ok(hres == S_OK, "OnUIActivate failed: %08x\n", hres);
1533     CHECK_CALLED(Invoke_ENABLED);
1534
1535     IOleInPlaceSite_Release(ip_site);
1536 }
1537
1538 static HRESULT cs_qi(REFIID,void **);
1539 static IOleDocumentView *view;
1540
1541 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1542 {
1543     static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
1544
1545     if(!IsEqualGUID(&undocumented_frame_iid, riid))
1546         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1547
1548     *ppv = NULL;
1549     return E_NOINTERFACE;
1550 }
1551
1552 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1553 {
1554     return 2;
1555 }
1556
1557 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1558 {
1559     return 1;
1560 }
1561
1562 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1563 {
1564     return E_NOTIMPL;
1565 }
1566
1567 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1568 {
1569     return E_NOTIMPL;
1570 }
1571
1572 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1573 {
1574     return E_NOTIMPL;
1575 }
1576
1577 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1578         LPCBORDERWIDTHS pborderwidths)
1579 {
1580     return E_NOTIMPL;
1581 }
1582
1583 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1584         LPCBORDERWIDTHS pborderwidths)
1585 {
1586     return S_OK;
1587 }
1588
1589 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1590         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1591 {
1592     return S_OK;
1593 }
1594
1595 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1596         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1597 {
1598     return S_OK;
1599 }
1600
1601 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1602         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1603 {
1604     return E_NOTIMPL;
1605 }
1606
1607 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1608         HOLEMENU holemenu, HWND hwndActiveObject)
1609 {
1610     ok(0, "unexpected call\n");
1611     return E_NOTIMPL;
1612 }
1613
1614 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1615 {
1616     ok(0, "unexpected call\n");
1617     return E_NOTIMPL;
1618 }
1619
1620 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1621 {
1622     return S_OK;
1623 }
1624
1625 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1626 {
1627     return E_NOTIMPL;
1628 }
1629
1630 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1631 {
1632     ok(0, "unexpected call\n");
1633     return E_NOTIMPL;
1634 }
1635
1636 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1637     InPlaceFrame_QueryInterface,
1638     InPlaceFrame_AddRef,
1639     InPlaceFrame_Release,
1640     InPlaceFrame_GetWindow,
1641     InPlaceFrame_ContextSensitiveHelp,
1642     InPlaceFrame_GetBorder,
1643     InPlaceFrame_RequestBorderSpace,
1644     InPlaceFrame_SetBorderSpace,
1645     InPlaceFrame_SetActiveObject,
1646     InPlaceFrame_InsertMenus,
1647     InPlaceFrame_SetMenu,
1648     InPlaceFrame_RemoveMenus,
1649     InPlaceFrame_SetStatusText,
1650     InPlaceFrame_EnableModeless,
1651     InPlaceFrame_TranslateAccelerator
1652 };
1653
1654 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1655
1656 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1657     InPlaceFrame_QueryInterface,
1658     InPlaceFrame_AddRef,
1659     InPlaceFrame_Release,
1660     InPlaceFrame_GetWindow,
1661     InPlaceFrame_ContextSensitiveHelp,
1662     InPlaceFrame_GetBorder,
1663     InPlaceFrame_RequestBorderSpace,
1664     InPlaceFrame_SetBorderSpace,
1665     InPlaceUIWindow_SetActiveObject,
1666 };
1667
1668 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1669
1670 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1671 {
1672     return cs_qi(riid, ppv);
1673 }
1674
1675 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1676 {
1677     return 2;
1678 }
1679
1680 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1681 {
1682     return 1;
1683 }
1684
1685 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1686 {
1687     *phwnd = container_hwnd;
1688     return S_OK;
1689 }
1690
1691 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1692 {
1693     ok(0, "unexpected call\n");
1694     return E_NOTIMPL;
1695 }
1696
1697 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1698 {
1699     return S_OK;
1700 }
1701
1702 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1703 {
1704     return S_OK;
1705 }
1706
1707 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1708 {
1709     return S_OK;
1710 }
1711
1712 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1713         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1714         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1715 {
1716     static const RECT rect = {0,0,500,500};
1717
1718     *ppFrame = &InPlaceFrame;
1719     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1720     *lprcPosRect = rect;
1721     *lprcClipRect = rect;
1722
1723     lpFrameInfo->fMDIApp = FALSE;
1724     lpFrameInfo->hwndFrame = container_hwnd;
1725     lpFrameInfo->haccel = NULL;
1726     lpFrameInfo->cAccelEntries = 0;
1727
1728     return S_OK;
1729 }
1730
1731 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1732 {
1733     return E_NOTIMPL;
1734 }
1735
1736 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1737 {
1738     return S_OK;
1739 }
1740
1741 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1742 {
1743     return S_OK;
1744 }
1745
1746 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1747 {
1748     return E_NOTIMPL;
1749 }
1750
1751 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1752 {
1753     return E_NOTIMPL;
1754 }
1755
1756 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1757 {
1758     return E_NOTIMPL;
1759 }
1760
1761 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1762     InPlaceSite_QueryInterface,
1763     InPlaceSite_AddRef,
1764     InPlaceSite_Release,
1765     InPlaceSite_GetWindow,
1766     InPlaceSite_ContextSensitiveHelp,
1767     InPlaceSite_CanInPlaceActivate,
1768     InPlaceSite_OnInPlaceActivate,
1769     InPlaceSite_OnUIActivate,
1770     InPlaceSite_GetWindowContext,
1771     InPlaceSite_Scroll,
1772     InPlaceSite_OnUIDeactivate,
1773     InPlaceSite_OnInPlaceDeactivate,
1774     InPlaceSite_DiscardUndoState,
1775     InPlaceSite_DeactivateAndUndo,
1776     InPlaceSite_OnPosRectChange,
1777 };
1778
1779 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
1780
1781 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1782 {
1783     return cs_qi(riid, ppv);
1784 }
1785
1786 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1787 {
1788     return 2;
1789 }
1790
1791 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1792 {
1793     return 1;
1794 }
1795
1796 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1797 {
1798     ok(0, "unexpected call\n");
1799     return E_NOTIMPL;
1800 }
1801
1802 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1803         IMoniker **ppmon)
1804 {
1805     ok(0, "unexpected call\n");
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1810 {
1811     return E_NOTIMPL;
1812 }
1813
1814 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1815 {
1816     ok(0, "unexpected call\n");
1817     return E_NOTIMPL;
1818 }
1819
1820 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1821 {
1822     ok(0, "unexpected call\n");
1823     return E_NOTIMPL;
1824 }
1825
1826 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1827 {
1828     ok(0, "unexpected call\n");
1829     return E_NOTIMPL;
1830 }
1831
1832 static const IOleClientSiteVtbl ClientSiteVtbl = {
1833     ClientSite_QueryInterface,
1834     ClientSite_AddRef,
1835     ClientSite_Release,
1836     ClientSite_SaveObject,
1837     ClientSite_GetMoniker,
1838     ClientSite_GetContainer,
1839     ClientSite_ShowObject,
1840     ClientSite_OnShowWindow,
1841     ClientSite_RequestNewObjectLayout
1842 };
1843
1844 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1845
1846 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1847 {
1848     return cs_qi(riid, ppv);
1849 }
1850
1851 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1852 {
1853     return 2;
1854 }
1855
1856 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1857 {
1858     return 1;
1859 }
1860
1861 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1862 {
1863     RECT rect = {0,0,400,500};
1864     IOleDocument *document;
1865     HRESULT hres;
1866
1867     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1868     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1869
1870     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1871     IOleDocument_Release(document);
1872     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1873
1874     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1875     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1876
1877     hres = IOleDocumentView_UIActivate(view, TRUE);
1878     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1879
1880     hres = IOleDocumentView_SetRect(view, &rect);
1881     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1882
1883     hres = IOleDocumentView_Show(view, TRUE);
1884     ok(hres == S_OK, "Show failed: %08x\n", hres);
1885
1886     return S_OK;
1887 }
1888
1889 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1890     DocumentSite_QueryInterface,
1891     DocumentSite_AddRef,
1892     DocumentSite_Release,
1893     DocumentSite_ActivateMe
1894 };
1895
1896 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1897
1898 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1899                                                      REFIID riid, void **ppv)
1900 {
1901     return cs_qi(riid, ppv);
1902 }
1903
1904 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1905 {
1906     return 2;
1907 }
1908
1909 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1910 {
1911     return 1;
1912 }
1913
1914 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
1915         REFIID riid, void **ppv)
1916 {
1917     if(IsEqualGUID(&CLSID_TestActiveX, guidService)) {
1918         CHECK_EXPECT(QueryService_TestActiveX);
1919         ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
1920         *ppv = &OleObject;
1921         return S_OK;
1922     }
1923
1924     *ppv = NULL;
1925     return E_NOINTERFACE;
1926 }
1927
1928 static const IServiceProviderVtbl ServiceProviderVtbl = {
1929     ServiceProvider_QueryInterface,
1930     ServiceProvider_AddRef,
1931     ServiceProvider_Release,
1932     ServiceProvider_QueryService
1933 };
1934
1935 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1936
1937 static HRESULT cs_qi(REFIID riid, void **ppv)
1938 {
1939     *ppv = NULL;
1940
1941     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1942         *ppv = &ClientSite;
1943     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1944         *ppv = &DocumentSite;
1945     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1946         *ppv = &InPlaceSite;
1947     else if(IsEqualGUID(riid, &IID_IServiceProvider))
1948         *ppv = &ServiceProvider;
1949
1950     return *ppv ? S_OK : E_NOINTERFACE;
1951 }
1952
1953 static IHTMLDocument2 *notif_doc;
1954 static BOOL doc_complete;
1955
1956 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
1957         REFIID riid, void**ppv)
1958 {
1959     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
1960         *ppv = iface;
1961         return S_OK;
1962     }
1963
1964     ok(0, "unexpected call\n");
1965     return E_NOINTERFACE;
1966 }
1967
1968 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
1969 {
1970     return 2;
1971 }
1972
1973 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
1974 {
1975     return 1;
1976 }
1977
1978 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
1979 {
1980     if(dispID == DISPID_READYSTATE){
1981         BSTR state;
1982         HRESULT hres;
1983
1984         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
1985
1986         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
1987         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1988
1989         if(!lstrcmpW(state, completeW))
1990             doc_complete = TRUE;
1991
1992         SysFreeString(state);
1993     }
1994
1995     return S_OK;
1996 }
1997
1998 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
1999 {
2000     ok(0, "unexpected call\n");
2001     return E_NOTIMPL;
2002 }
2003
2004 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
2005     PropertyNotifySink_QueryInterface,
2006     PropertyNotifySink_AddRef,
2007     PropertyNotifySink_Release,
2008     PropertyNotifySink_OnChanged,
2009     PropertyNotifySink_OnRequestEdit
2010 };
2011
2012 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
2013
2014 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
2015 {
2016     IPersistStreamInit *init;
2017     IStream *stream;
2018     HGLOBAL mem;
2019     SIZE_T len;
2020
2021     notif_doc = doc;
2022
2023     doc_complete = FALSE;
2024     len = strlen(str);
2025     mem = GlobalAlloc(0, len);
2026     memcpy(mem, str, len);
2027     CreateStreamOnHGlobal(mem, TRUE, &stream);
2028
2029     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
2030
2031     IPersistStreamInit_Load(init, stream);
2032     IPersistStreamInit_Release(init);
2033     IStream_Release(stream);
2034 }
2035
2036 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
2037 {
2038     IConnectionPointContainer *container;
2039     IConnectionPoint *cp;
2040     DWORD cookie;
2041     HRESULT hres;
2042
2043     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
2044     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
2045
2046     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
2047     IConnectionPointContainer_Release(container);
2048     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
2049
2050     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
2051     IConnectionPoint_Release(cp);
2052     ok(hres == S_OK, "Advise failed: %08x\n", hres);
2053 }
2054
2055 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
2056 {
2057     IOleObject *oleobj;
2058     HRESULT hres;
2059
2060     if(!set && view) {
2061         IOleDocumentView_Show(view, FALSE);
2062         IOleDocumentView_CloseView(view, 0);
2063         IOleDocumentView_SetInPlaceSite(view, NULL);
2064         IOleDocumentView_Release(view);
2065         view = NULL;
2066     }
2067
2068     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
2069     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
2070
2071     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
2072     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
2073
2074     if(set) {
2075         IHlinkTarget *hlink;
2076
2077         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
2078         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
2079
2080         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
2081         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
2082
2083         IHlinkTarget_Release(hlink);
2084     }
2085
2086     IOleObject_Release(oleobj);
2087 }
2088 static IHTMLDocument2 *create_document(void)
2089 {
2090     IHTMLDocument2 *doc;
2091     HRESULT hres;
2092
2093     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2094             &IID_IHTMLDocument2, (void**)&doc);
2095     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2096
2097     return doc;
2098 }
2099
2100 static IHTMLDocument2 *create_doc(const char *str, BOOL *b)
2101 {
2102     IHTMLDocument2 *doc;
2103     MSG msg;
2104
2105     doc = create_document();
2106     set_client_site(doc, TRUE);
2107     doc_load_string(doc, str);
2108     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
2109
2110     while((!doc_complete || (b && !*b)) && GetMessage(&msg, NULL, 0, 0)) {
2111         TranslateMessage(&msg);
2112         DispatchMessage(&msg);
2113     }
2114
2115     return doc;
2116 }
2117
2118 static void release_doc(IHTMLDocument2 *doc)
2119 {
2120     ULONG ref;
2121
2122     set_client_site(doc, FALSE);
2123     ref = IHTMLDocument2_Release(doc);
2124     ok(!ref, "ref = %d\n", ref);
2125
2126     if(client_site) {
2127         IOleClientSite_Release(client_site);
2128         client_site = NULL;
2129     }
2130
2131     if(plugin_hwnd) {
2132         DestroyWindow(plugin_hwnd);
2133         plugin_hwnd = NULL;
2134     }
2135 }
2136
2137 static void init_test(int behavior)
2138 {
2139     plugin_behavior = behavior;
2140
2141     no_quickact = behavior == TEST_NOQUICKACT || behavior == TEST_DISPONLY;
2142 }
2143
2144 static void test_flash_ax(void)
2145 {
2146     IHTMLDocument2 *doc;
2147
2148     init_test(TEST_FLASH);
2149
2150     /*
2151      * We pump messages until both document is loaded and plugin instance is created.
2152      * Pumping until document is loaded should be enough, but Gecko loads plugins
2153      * asynchronously and until we'll work around it, we need this hack.
2154      */
2155     SET_EXPECT(CreateInstance);
2156     SET_EXPECT(FreezeEvents_TRUE);
2157     SET_EXPECT(QuickActivate);
2158     SET_EXPECT(FreezeEvents_FALSE);
2159     SET_EXPECT(IPersistPropertyBag_Load);
2160     SET_EXPECT(Invoke_READYSTATE);
2161     SET_EXPECT(SetExtent);
2162     SET_EXPECT(GetExtent);
2163     SET_EXPECT(DoVerb);
2164
2165     doc = create_doc(object_ax_str, &called_CreateInstance);
2166
2167     CHECK_CALLED(CreateInstance);
2168     todo_wine
2169     CHECK_CALLED(FreezeEvents_TRUE);
2170     CHECK_CALLED(QuickActivate);
2171     todo_wine
2172     CHECK_CALLED(FreezeEvents_FALSE);
2173     CHECK_CALLED(IPersistPropertyBag_Load);
2174     CHECK_CALLED(Invoke_READYSTATE);
2175     todo_wine
2176     CHECK_CALLED(SetExtent);
2177     todo_wine
2178     CHECK_CALLED(GetExtent);
2179     CHECK_CALLED(DoVerb);
2180
2181     /* Set in DoVerb */
2182     CHECK_CALLED(InPlaceObject_GetWindow);
2183     CHECK_CALLED(SetObjectRects);
2184
2185     test_ui_activate();
2186     test_container(notif_doc);
2187     test_object_elem(notif_doc);
2188
2189     SET_EXPECT(UIDeactivate);
2190     SET_EXPECT(Invoke_ENABLED);
2191     SET_EXPECT(Invoke_VALID);
2192     SET_EXPECT(InPlaceDeactivate);
2193     SET_EXPECT(Close);
2194     SET_EXPECT(SetClientSite_NULL);
2195     release_doc(doc);
2196     CHECK_CALLED(UIDeactivate);
2197     todo_wine
2198     CHECK_CALLED(Invoke_ENABLED);
2199     todo_wine
2200     CHECK_CALLED(Invoke_VALID);
2201     CHECK_CALLED(InPlaceDeactivate);
2202     CHECK_CALLED(Close);
2203     CHECK_CALLED(SetClientSite_NULL);
2204 }
2205
2206 static void test_noquickact_ax(void)
2207 {
2208     IHTMLDocument2 *doc;
2209
2210     init_test(TEST_NOQUICKACT);
2211
2212     SET_EXPECT(CreateInstance);
2213     SET_EXPECT(FreezeEvents_TRUE);
2214     SET_EXPECT(GetMiscStatus);
2215     SET_EXPECT(SetClientSite);
2216     SET_EXPECT(SetAdvise);
2217     SET_EXPECT(GetViewStatus);
2218     SET_EXPECT(FreezeEvents_FALSE);
2219     SET_EXPECT(Invoke_READYSTATE);
2220     SET_EXPECT(SetExtent);
2221     SET_EXPECT(GetExtent);
2222     SET_EXPECT(DoVerb);
2223
2224     doc = create_doc(object_ax_str, &called_CreateInstance);
2225
2226     CHECK_CALLED(CreateInstance);
2227     todo_wine CHECK_CALLED(FreezeEvents_TRUE);
2228     CHECK_CALLED(GetMiscStatus);
2229     CHECK_CALLED(SetClientSite);
2230     CHECK_CALLED(SetAdvise);
2231     CHECK_CALLED(GetViewStatus);
2232     todo_wine CHECK_CALLED(FreezeEvents_FALSE);
2233     CHECK_CALLED(Invoke_READYSTATE);
2234     todo_wine CHECK_CALLED(SetExtent);
2235     todo_wine CHECK_CALLED(GetExtent);
2236     CHECK_CALLED(DoVerb);
2237
2238     /* Set in DoVerb */
2239     CHECK_CALLED(InPlaceObject_GetWindow);
2240     CHECK_CALLED(SetObjectRects);
2241
2242     SET_EXPECT(InPlaceDeactivate);
2243     SET_EXPECT(Close);
2244     SET_EXPECT(SetClientSite_NULL);
2245     release_doc(doc);
2246     CHECK_CALLED(InPlaceDeactivate);
2247     CHECK_CALLED(Close);
2248     CHECK_CALLED(SetClientSite_NULL);
2249 }
2250
2251 static void test_nooleobj_ax(void)
2252 {
2253     IHTMLDocument2 *doc;
2254
2255     init_test(TEST_DISPONLY);
2256
2257     SET_EXPECT(CreateInstance);
2258     SET_EXPECT(Invoke_READYSTATE);
2259
2260     doc = create_doc(object_ax_str, &called_CreateInstance);
2261
2262     CHECK_CALLED(CreateInstance);
2263     CHECK_CALLED(Invoke_READYSTATE);
2264
2265     release_doc(doc);
2266 }
2267
2268 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2269 {
2270     return DefWindowProc(hwnd, msg, wParam, lParam);
2271 }
2272
2273 static HWND create_container_window(void)
2274 {
2275     static const WCHAR html_document_testW[] =
2276         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
2277     static WNDCLASSEXW wndclass = {
2278         sizeof(WNDCLASSEXW),
2279         0,
2280         wnd_proc,
2281         0, 0, NULL, NULL, NULL, NULL, NULL,
2282         html_document_testW,
2283         NULL
2284     };
2285
2286     RegisterClassExW(&wndclass);
2287     return CreateWindowW(html_document_testW, html_document_testW,
2288             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2289             515, 530, NULL, NULL, NULL, NULL);
2290 }
2291
2292 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
2293 {
2294     HKEY hkey;
2295     DWORD res;
2296
2297     if(!init) {
2298         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
2299         return TRUE;
2300     }
2301
2302     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
2303     if(res != ERROR_SUCCESS)
2304         return FALSE;
2305
2306     if(def_value)
2307         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
2308
2309     RegCloseKey(hkey);
2310
2311     return res == ERROR_SUCCESS;
2312 }
2313
2314 static BOOL init_registry(BOOL init)
2315 {
2316     return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
2317         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
2318                     NULL, init)
2319         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
2320                     NULL, init);
2321 }
2322
2323 static BOOL register_activex(void)
2324 {
2325     DWORD regid;
2326     HRESULT hres;
2327
2328     if(!init_registry(TRUE)) {
2329         init_registry(FALSE);
2330         return FALSE;
2331     }
2332
2333     hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
2334             CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2335     ok(hres == S_OK, "Could not register control: %08x\n", hres);
2336
2337     return TRUE;
2338 }
2339
2340 static BOOL check_ie(void)
2341 {
2342     IHTMLDocument5 *doc;
2343     HRESULT hres;
2344
2345     static const WCHAR xW[] = {'x',0};
2346     static const WCHAR yW[] = {'y',0};
2347
2348     if(!lstrcmpW(xW, yW))
2349         return FALSE;
2350
2351     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2352             &IID_IHTMLDocument5, (void**)&doc);
2353     if(FAILED(hres))
2354         return FALSE;
2355
2356     IHTMLDocument5_Release(doc);
2357     return TRUE;
2358 }
2359
2360 START_TEST(activex)
2361 {
2362     CoInitialize(NULL);
2363
2364     if(!check_ie()) {
2365         CoUninitialize();
2366         win_skip("Too old IE\n");
2367         return;
2368     }
2369
2370     if(is_ie_hardened()) {
2371         CoUninitialize();
2372         win_skip("IE running in Enhanced Security Configuration\n");
2373         return;
2374     }
2375
2376     init_wrapped_iface();
2377     container_hwnd = create_container_window();
2378     ShowWindow(container_hwnd, SW_SHOW);
2379
2380     if(register_activex()) {
2381         trace("Testing emulated flash embedding...\n");
2382         test_flash_ax();
2383         trace("Testing plugin without IQuickActivate iface...\n");
2384         test_noquickact_ax();
2385         trace("Testing plugin with IDispatch iface only...\n");
2386         test_nooleobj_ax();
2387         init_registry(FALSE);
2388     }else {
2389         skip("Could not register ActiveX\n");
2390     }
2391
2392     DestroyWindow(container_hwnd);
2393     CoUninitialize();
2394 }