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