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