rostests/winetests/mshtml/htmldoc.c

   1 /*
   2  * Copyright 2005-2009 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 <initguid.h>
  29 //#include "ole2.h"
  30 #include <mshtml.h>
  31 //#include "docobj.h"
  32 #include <docobjectservice.h>
  33 #include <wininet.h>
  34 #include <mshtmhst.h>
  35 #include <mshtmdid.h>
  36 #include <mshtmcid.h>
  37 //#include "hlink.h"
  38 //#include "dispex.h"
  39 #include <idispids.h>
  40 #include <shlguid.h>
  41 #include <shdeprecated.h>
  42 #include <perhist.h>
  43 //#include "shobjidl.h"
  44 #include <htiface.h>
  45 #include <tlogstg.h>
  46 #include <exdispid.h>
  47 #include "mshtml_test.h"
  48
  49 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  50 DEFINE_GUID(IID_IProxyManager,0x00000008,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
  51 DEFINE_OLEGUID(CGID_DocHostCmdPriv, 0x000214D4L, 0, 0);
  52 DEFINE_GUID(SID_SContainerDispatch,0xb722be00,0x4e68,0x101b,0xa2,0xbc,0x00,0xaa,0x00,0x40,0x47,0x70);
  53
  54 #define DEFINE_EXPECT(func) \
  55     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  56
  57 #define SET_EXPECT(func) \
  58     expect_ ## func = TRUE
  59
  60 #define SET_CALLED(func) \
  61     called_ ## func = TRUE
  62
  63 #define CHECK_EXPECT2(func) \
  64     do { \
  65         ok(expect_ ##func, "unexpected call " #func "\n"); \
  66         called_ ## func = TRUE; \
  67     }while(0)
  68
  69 #define CHECK_EXPECT(func) \
  70     do { \
  71         CHECK_EXPECT2(func); \
  72         expect_ ## func = FALSE; \
  73     }while(0)
  74
  75 #define CHECK_CALLED(func) \
  76     do { \
  77         ok(called_ ## func, "expected " #func "\n"); \
  78         expect_ ## func = called_ ## func = FALSE; \
  79     }while(0)
  80
  81 #define CHECK_NOT_CALLED(func) \
  82     do { \
  83         ok(!called_ ## func, "unexpected " #func "\n"); \
  84         expect_ ## func = called_ ## func = FALSE; \
  85     }while(0)
  86
  87 #define CHECK_CALLED_BROKEN(func) \
  88     do { \
  89         ok(called_ ## func || broken(!called_ ## func), "expected " #func "\n"); \
  90         expect_ ## func = called_ ## func = FALSE; \
  91     }while(0)
  92
  93 #define CLEAR_CALLED(func) \
  94     expect_ ## func = called_ ## func = FALSE
  95
  96
  97 static IOleDocumentView *view = NULL;
  98 static HWND container_hwnd = NULL, doc_hwnd = NULL, last_hwnd = NULL;
  99
 100 DEFINE_EXPECT(LockContainer);
 101 DEFINE_EXPECT(SetActiveObject);
 102 DEFINE_EXPECT(SetActiveObject_null);
 103 DEFINE_EXPECT(GetWindow);
 104 DEFINE_EXPECT(CanInPlaceActivate);
 105 DEFINE_EXPECT(OnInPlaceActivate);
 106 DEFINE_EXPECT(OnInPlaceActivateEx);
 107 DEFINE_EXPECT(OnUIActivate);
 108 DEFINE_EXPECT(GetWindowContext);
 109 DEFINE_EXPECT(OnUIDeactivate);
 110 DEFINE_EXPECT(OnInPlaceDeactivate);
 111 DEFINE_EXPECT(OnInPlaceDeactivateEx);
 112 DEFINE_EXPECT(GetContainer);
 113 DEFINE_EXPECT(ShowUI);
 114 DEFINE_EXPECT(ActivateMe);
 115 DEFINE_EXPECT(GetHostInfo);
 116 DEFINE_EXPECT(HideUI);
 117 DEFINE_EXPECT(GetOptionKeyPath);
 118 DEFINE_EXPECT(GetOverrideKeyPath);
 119 DEFINE_EXPECT(SetStatusText);
 120 DEFINE_EXPECT(QueryStatus_SETPROGRESSTEXT);
 121 DEFINE_EXPECT(QueryStatus_OPEN);
 122 DEFINE_EXPECT(QueryStatus_NEW);
 123 DEFINE_EXPECT(Exec_SETPROGRESSMAX);
 124 DEFINE_EXPECT(Exec_SETPROGRESSPOS);
 125 DEFINE_EXPECT(Exec_HTTPEQUIV_DONE);
 126 DEFINE_EXPECT(Exec_SETDOWNLOADSTATE_0);
 127 DEFINE_EXPECT(Exec_SETDOWNLOADSTATE_1);
 128 DEFINE_EXPECT(Exec_ShellDocView_37);
 129 DEFINE_EXPECT(Exec_ShellDocView_63);
 130 DEFINE_EXPECT(Exec_ShellDocView_67);
 131 DEFINE_EXPECT(Exec_ShellDocView_84);
 132 DEFINE_EXPECT(Exec_ShellDocView_103);
 133 DEFINE_EXPECT(Exec_ShellDocView_105);
 134 DEFINE_EXPECT(Exec_ShellDocView_138);
 135 DEFINE_EXPECT(Exec_ShellDocView_140);
 136 DEFINE_EXPECT(Exec_DocHostCommandHandler_2300);
 137 DEFINE_EXPECT(Exec_UPDATECOMMANDS);
 138 DEFINE_EXPECT(Exec_SETTITLE);
 139 DEFINE_EXPECT(Exec_HTTPEQUIV);
 140 DEFINE_EXPECT(Exec_MSHTML_PARSECOMPLETE);
 141 DEFINE_EXPECT(Exec_Explorer_38);
 142 DEFINE_EXPECT(Exec_Explorer_69);
 143 DEFINE_EXPECT(Exec_DOCCANNAVIGATE);
 144 DEFINE_EXPECT(Invoke_AMBIENT_USERMODE);
 145 DEFINE_EXPECT(Invoke_AMBIENT_DLCONTROL);
 146 DEFINE_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
 147 DEFINE_EXPECT(Invoke_AMBIENT_SILENT);
 148 DEFINE_EXPECT(Invoke_AMBIENT_USERAGENT);
 149 DEFINE_EXPECT(Invoke_AMBIENT_PALETTE);
 150 DEFINE_EXPECT(Invoke_OnReadyStateChange_Interactive);
 151 DEFINE_EXPECT(Invoke_OnReadyStateChange_Loading);
 152 DEFINE_EXPECT(Invoke_OnReadyStateChange_Complete);
 153 DEFINE_EXPECT(GetDropTarget);
 154 DEFINE_EXPECT(UpdateUI);
 155 DEFINE_EXPECT(Navigate);
 156 DEFINE_EXPECT(OnFrameWindowActivate);
 157 DEFINE_EXPECT(OnChanged_READYSTATE);
 158 DEFINE_EXPECT(OnChanged_1005);
 159 DEFINE_EXPECT(OnChanged_1012);
 160 DEFINE_EXPECT(OnChanged_1014);
 161 DEFINE_EXPECT(GetDisplayName);
 162 DEFINE_EXPECT(BindToStorage);
 163 DEFINE_EXPECT(IsSystemMoniker);
 164 DEFINE_EXPECT(GetBindResult);
 165 DEFINE_EXPECT(GetClassID);
 166 DEFINE_EXPECT(Abort);
 167 DEFINE_EXPECT(Read);
 168 DEFINE_EXPECT(CreateInstance);
 169 DEFINE_EXPECT(Start);
 170 DEFINE_EXPECT(Terminate);
 171 DEFINE_EXPECT(Protocol_Read);
 172 DEFINE_EXPECT(LockRequest);
 173 DEFINE_EXPECT(UnlockRequest);
 174 DEFINE_EXPECT(OnFocus_TRUE);
 175 DEFINE_EXPECT(OnFocus_FALSE);
 176 DEFINE_EXPECT(RequestUIActivate);
 177 DEFINE_EXPECT(InPlaceFrame_SetBorderSpace);
 178 DEFINE_EXPECT(InPlaceUIWindow_SetActiveObject);
 179 DEFINE_EXPECT(GetExternal);
 180 DEFINE_EXPECT(EnableModeless_TRUE);
 181 DEFINE_EXPECT(EnableModeless_FALSE);
 182 DEFINE_EXPECT(Frame_EnableModeless_TRUE);
 183 DEFINE_EXPECT(Frame_EnableModeless_FALSE);
 184 DEFINE_EXPECT(Frame_GetWindow);
 185 DEFINE_EXPECT(TranslateUrl);
 186 DEFINE_EXPECT(Advise_Close);
 187 DEFINE_EXPECT(OnViewChange);
 188 DEFINE_EXPECT(EvaluateNewWindow);
 189 DEFINE_EXPECT(GetTravelLog);
 190 DEFINE_EXPECT(UpdateBackForwardState);
 191 DEFINE_EXPECT(FireBeforeNavigate2);
 192 DEFINE_EXPECT(FireNavigateComplete2);
 193 DEFINE_EXPECT(FireDocumentComplete);
 194 DEFINE_EXPECT(GetPendingUrl);
 195 DEFINE_EXPECT(ActiveElementChanged);
 196 DEFINE_EXPECT(IsErrorUrl);
 197 DEFINE_EXPECT(get_LocationURL);
 198 DEFINE_EXPECT(CountEntries);
 199 DEFINE_EXPECT(FindConnectionPoint);
 200 DEFINE_EXPECT(EnumConnections);
 201 DEFINE_EXPECT(EnumConnections_Next);
 202 DEFINE_EXPECT(WindowClosing);
 203
 204 static IUnknown *doc_unk;
 205 static IMoniker *doc_mon;
 206 static BOOL expect_LockContainer_fLock;
 207 static BOOL expect_InPlaceUIWindow_SetActiveObject_active = TRUE;
 208 static BOOL ipsex, ipsw;
 209 static BOOL set_clientsite, container_locked;
 210 static BOOL readystate_set_loading = FALSE, readystate_set_interactive = FALSE, load_from_stream;
 211 static BOOL editmode = FALSE, ignore_external_qi;
 212 static BOOL inplace_deactivated, open_call;
 213 static BOOL complete, loading_js, loading_hash, is_refresh;
 214 static DWORD status_code = HTTP_STATUS_OK;
 215 static BOOL asynchronous_binding = FALSE;
 216 static BOOL support_wbapp, allow_new_window;
 217 static BOOL report_mime;
 218 static int stream_read, protocol_read;
 219 static IStream *history_stream;
 220 static enum load_state_t {
 221     LD_DOLOAD,
 222     LD_LOADING,
 223     LD_LOADED,
 224     LD_INTERACTIVE,
 225     LD_COMPLETE,
 226     LD_NO
 227 } load_state;
 228
 229 static LPCOLESTR expect_status_text = NULL;
 230 static const char *nav_url, *nav_serv_url, *prev_url;
 231
 232 static const char html_page[] =
 233 "<html>"
 234 "<head><link rel=\"stylesheet\" type=\"text/css\" href=\"test.css\"></head>"
 235 "<body><div>test</div></body>"
 236 "</html>";
 237
 238 static const char css_data[] = "body {color: red; margin: 0}";
 239
 240 static const WCHAR http_urlW[] =
 241     {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/','t','e','s','t','s','/','w','i','n','e','h','q','_','s','n','a','p','s','h','o','t','/',0};
 242
 243 static const WCHAR doc_url[] = {'w','i','n','e','t','e','s','t',':','d','o','c',0};
 244
 245 #define DOCHOST_DOCCANNAVIGATE 0
 246 #define WM_CONTINUE_BINDING (WM_APP+1)
 247
 248 static HRESULT QueryInterface(REFIID riid, void **ppv);
 249 static void test_MSHTML_QueryStatus(IHTMLDocument2*,DWORD);
 250
 251 #define test_readyState(u) _test_readyState(__LINE__,u)
 252 static void _test_readyState(unsigned,IUnknown*);
 253
 254 static const WCHAR wszTimesNewRoman[] =
 255     {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n',0};
 256 static const WCHAR wszArial[] =
 257     {'A','r','i','a','l',0};
 258
 259 static const char *debugstr_guid(REFIID riid)
 260 {
 261     static char buf[50];
 262
 263     if(!riid)
 264         return "(null)";
 265
 266     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 267             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 268             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 269             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 270
 271     return buf;
 272 }
 273
 274 static int strcmp_wa(LPCWSTR strw, const char *stra)
 275 {
 276     CHAR buf[512];
 277     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 278     return lstrcmpA(stra, buf);
 279 }
 280
 281 static const WCHAR *strstrW( const WCHAR *str, const WCHAR *sub )
 282 {
 283     while (*str)
 284     {
 285         const WCHAR *p1 = str, *p2 = sub;
 286         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
 287         if (!*p2) return str;
 288         str++;
 289     }
 290     return NULL;
 291 }
 292
 293 static BSTR a2bstr(const char *str)
 294 {
 295     BSTR ret;
 296     int len;
 297
 298     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 299     ret = SysAllocStringLen(NULL, len);
 300     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 301
 302     return ret;
 303 }
 304
 305 /* Returns true if the user interface is in English. Note that this does not
 306  * presume of the formatting of dates, numbers, etc.
 307  */
 308 static BOOL is_lang_english(void)
 309 {
 310     static HMODULE hkernel32 = NULL;
 311     static LANGID (WINAPI *pGetThreadUILanguage)(void) = NULL;
 312     static LANGID (WINAPI *pGetUserDefaultUILanguage)(void) = NULL;
 313
 314     if (!hkernel32)
 315     {
 316         hkernel32 = GetModuleHandleA("kernel32.dll");
 317         pGetThreadUILanguage = (void*)GetProcAddress(hkernel32, "GetThreadUILanguage");
 318         pGetUserDefaultUILanguage = (void*)GetProcAddress(hkernel32, "GetUserDefaultUILanguage");
 319     }
 320     if (pGetThreadUILanguage)
 321         return PRIMARYLANGID(pGetThreadUILanguage()) == LANG_ENGLISH;
 322     if (pGetUserDefaultUILanguage)
 323         return PRIMARYLANGID(pGetUserDefaultUILanguage()) == LANG_ENGLISH;
 324
 325     return PRIMARYLANGID(GetUserDefaultLangID()) == LANG_ENGLISH;
 326 }
 327
 328 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 329 {
 330     IUnknown *unk1, *unk2;
 331
 332     if(iface1 == iface2)
 333         return TRUE;
 334
 335     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 336     IUnknown_Release(unk1);
 337     IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
 338     IUnknown_Release(unk2);
 339
 340     return unk1 == unk2;
 341 }
 342
 343 #define EXPECT_UPDATEUI  1
 344 #define EXPECT_SETTITLE  2
 345
 346 static void test_timer(DWORD flags)
 347 {
 348     BOOL *b = &called_Exec_SETTITLE;
 349     MSG msg;
 350
 351     if(flags & EXPECT_UPDATEUI) {
 352         SET_EXPECT(UpdateUI);
 353         SET_EXPECT(Exec_UPDATECOMMANDS);
 354         b = &called_UpdateUI;
 355     }
 356     if(flags & EXPECT_SETTITLE)
 357         SET_EXPECT(Exec_SETTITLE);
 358
 359     while(!*b && GetMessage(&msg, doc_hwnd, 0, 0)) {
 360         TranslateMessage(&msg);
 361         DispatchMessage(&msg);
 362     }
 363
 364     if(flags & EXPECT_UPDATEUI) {
 365         CHECK_CALLED(UpdateUI);
 366         CHECK_CALLED(Exec_UPDATECOMMANDS);
 367     }
 368     if(flags & EXPECT_SETTITLE)
 369         CHECK_CALLED(Exec_SETTITLE);
 370 }
 371
 372 static IMoniker Moniker;
 373
 374 #define test_GetCurMoniker(u,m,v) _test_GetCurMoniker(__LINE__,u,m,v)
 375 static void _test_GetCurMoniker(unsigned line, IUnknown *unk, IMoniker *exmon, const char *exurl)
 376 {
 377     IHTMLDocument2 *doc;
 378     IPersistMoniker *permon;
 379     IMoniker *mon = (void*)0xdeadbeef;
 380     BSTR doc_url = (void*)0xdeadbeef;
 381     const WCHAR *ptr;
 382     HRESULT hres;
 383
 384     if(open_call)
 385         return; /* FIXME */
 386
 387     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&permon);
 388     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08x\n", hres);
 389     if(FAILED(hres))
 390         return;
 391
 392     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument2, (void**)&doc);
 393     ok(hres == S_OK, "QueryInterface(IID_IHTMLDocument2) failed: %08x\n", hres);
 394
 395     hres = IHTMLDocument2_get_URL(doc, &doc_url);
 396     ok(hres == S_OK, "get_URL failed: %08x\n", hres);
 397     for(ptr = doc_url; *ptr && *ptr != '#'; ptr++);
 398
 399     hres = IPersistMoniker_GetCurMoniker(permon, &mon);
 400     IPersistMoniker_Release(permon);
 401
 402     if(exmon) {
 403         LPOLESTR url;
 404         BOOL exb = expect_GetDisplayName;
 405         BOOL clb = called_GetDisplayName;
 406
 407         ok_(__FILE__,line)(hres == S_OK, "GetCurrentMoniker failed: %08x\n", hres);
 408         ok_(__FILE__,line)(mon == exmon, "mon(%p) != exmon(%p)\n", mon, exmon);
 409
 410         if(mon == &Moniker)
 411             SET_EXPECT(GetDisplayName);
 412         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
 413         ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
 414         if(mon == &Moniker)
 415             CHECK_CALLED(GetDisplayName);
 416         expect_GetDisplayName = exb;
 417         called_GetDisplayName = clb;
 418
 419         if(!*ptr)
 420             ok(!lstrcmpW(url, doc_url), "url %s != doc_url %s\n", wine_dbgstr_w(url), wine_dbgstr_w(doc_url));
 421         else
 422             ok(!strcmp_wa(url, nav_serv_url), "url = %s, expected %s\n", wine_dbgstr_w(url), nav_serv_url);
 423         CoTaskMemFree(url);
 424     }else if(exurl) {
 425         LPOLESTR url;
 426
 427         ok_(__FILE__,line)(hres == S_OK, "GetCurrentMoniker failed: %08x\n", hres);
 428
 429         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
 430         ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
 431
 432         ok_(__FILE__,line)(!strcmp_wa(url, exurl), "unexpected url %s\n", wine_dbgstr_w(url));
 433         if(!*ptr)
 434             ok_(__FILE__,line)(!lstrcmpW(url, doc_url), "url %s != doc_url %s\n", wine_dbgstr_w(url), wine_dbgstr_w(doc_url));
 435
 436         CoTaskMemFree(url);
 437     }else {
 438         ok_(__FILE__,line)(hres == E_UNEXPECTED,
 439            "GetCurrentMoniker failed: %08x, expected E_UNEXPECTED\n", hres);
 440         ok_(__FILE__,line)(mon == (IMoniker*)0xdeadbeef, "mon=%p\n", mon);
 441         ok_(__FILE__,line)(!strcmp_wa(doc_url, "about:blank"), "doc_url is not about:blank\n");
 442     }
 443
 444     SysFreeString(doc_url);
 445     IHTMLDocument2_Release(doc);
 446     if(mon && mon != (void*)0xdeadbeef)
 447         IMoniker_Release(mon);
 448 }
 449
 450 #define test_current_url(a,b) _test_current_url(__LINE__,a,b)
 451 static void _test_current_url(unsigned line, IUnknown *unk, const char *exurl)
 452 {
 453     IHTMLDocument2 *doc;
 454     BSTR url;
 455     HRESULT hres;
 456
 457     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument2, (void**)&doc);
 458     ok_(__FILE__,line)(hres == S_OK, "QueryInterface(IID_IHTMLDocument2) failed: %08x\n", hres);
 459
 460     hres = IHTMLDocument2_get_URL(doc, &url);
 461     ok_(__FILE__,line)(hres == S_OK, "get_URL failed: %08x\n", hres);
 462     ok_(__FILE__,line)(!strcmp_wa(url, exurl), "Unexpected URL %s, expected %s\n", wine_dbgstr_w(url), exurl);
 463     SysFreeString(url);
 464
 465     IHTMLDocument2_Release(doc);
 466 }
 467
 468 DEFINE_GUID(IID_External_unk,0x30510406,0x98B5,0x11CF,0xBB,0x82,0x00,0xAA,0x00,0xBD,0xCE,0x0B);
 469
 470 static HRESULT WINAPI External_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 471 {
 472     *ppv = NULL;
 473
 474     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
 475         *ppv = iface;
 476         return S_OK;
 477     }
 478
 479     if(IsEqualGUID(&IID_IProxyManager, riid))
 480         return E_NOINTERFACE; /* TODO */
 481     if(IsEqualGUID(&IID_IDispatchEx, riid))
 482         return E_NOINTERFACE; /* TODO */
 483     if(IsEqualGUID(&IID_External_unk, riid))
 484         return E_NOINTERFACE; /* TODO */
 485
 486     if(!ignore_external_qi)
 487         ok(0, "unexpected riid: %s\n", debugstr_guid(riid));
 488     return E_NOINTERFACE;
 489 }
 490
 491 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 492 {
 493     return 2;
 494 }
 495
 496 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 497 {
 498     return 1;
 499 }
 500
 501 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 502 {
 503     ok(0, "unexpected call\n");
 504     return E_NOTIMPL;
 505 }
 506
 507 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 508         ITypeInfo **ppTInfo)
 509 {
 510     ok(0, "unexpected call\n");
 511     return E_NOTIMPL;
 512 }
 513
 514 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 515         UINT cNames, LCID lcid, DISPID *rgDispId)
 516 {
 517     ok(0, "unexpected call\n");
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI External_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 522         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 523         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 524 {
 525     ok(0, "unexpected call\n");
 526     return E_NOTIMPL;
 527 }
 528
 529 static const IDispatchVtbl ExternalVtbl = {
 530     External_QueryInterface,
 531     Dispatch_AddRef,
 532     Dispatch_Release,
 533     Dispatch_GetTypeInfoCount,
 534     Dispatch_GetTypeInfo,
 535     Dispatch_GetIDsOfNames,
 536     External_Invoke
 537 };
 538
 539 static IDispatch External = { &ExternalVtbl };
 540
 541 static HRESULT WINAPI Protocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 542 {
 543     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
 544         *ppv = iface;
 545         return S_OK;
 546     }
 547
 548     *ppv = NULL;
 549     return E_NOINTERFACE;
 550 }
 551
 552 static ULONG WINAPI Protocol_AddRef(IInternetProtocol *iface)
 553 {
 554     return 2;
 555 }
 556
 557 static ULONG WINAPI Protocol_Release(IInternetProtocol *iface)
 558 {
 559     return 1;
 560 }
 561
 562 static HRESULT WINAPI Protocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 563         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 564         DWORD grfPI, HANDLE_PTR dwReserved)
 565 {
 566     BINDINFO bindinfo;
 567     DWORD bindf = 0;
 568     HRESULT hres;
 569
 570     static const WCHAR wszTextCss[] = {'t','e','x','t','/','c','s','s',0};
 571     static const WCHAR empty_str = {0};
 572
 573     CHECK_EXPECT(Start);
 574
 575     ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
 576     ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
 577     ok(!grfPI, "grfPI = %x\n", grfPI);
 578     ok(!dwReserved, "dwReserved = %lx\n", dwReserved);
 579
 580     memset(&bindinfo, 0, sizeof(bindinfo));
 581     bindinfo.cbSize = sizeof(bindinfo);
 582     hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
 583     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
 584     ok(bindf == (BINDF_FROMURLMON|BINDF_PULLDATA|BINDF_NEEDFILE|BINDF_ASYNCSTORAGE|BINDF_ASYNCHRONOUS),
 585        "bindf = %x\n", bindf);
 586
 587     ok(bindinfo.cbSize == sizeof(bindinfo), "bindinfo.cbSize=%d\n", bindinfo.cbSize);
 588     ok(bindinfo.szExtraInfo == NULL, "bindinfo.szExtraInfo=%p\n", bindinfo.szExtraInfo);
 589     /* TODO: test stgmedData */
 590     ok(bindinfo.grfBindInfoF == 0, "bindinfo.grfBinfInfoF=%08x\n", bindinfo.grfBindInfoF);
 591     ok(bindinfo.dwBindVerb == 0, "bindinfo.dwBindVerb=%d\n", bindinfo.dwBindVerb);
 592     ok(bindinfo.szCustomVerb == 0, "bindinfo.szCustomVerb=%p\n", bindinfo.szCustomVerb);
 593     ok(bindinfo.cbstgmedData == 0, "bindinfo.cbstgmedData=%d\n", bindinfo.cbstgmedData);
 594     ok(bindinfo.dwOptions == 0x80000 ||
 595        bindinfo.dwOptions == 0x4080000, /* win2k3 */
 596        "bindinfo.dwOptions=%x\n", bindinfo.dwOptions);
 597     ok(bindinfo.dwOptionsFlags == 0, "bindinfo.dwOptionsFlags=%d\n", bindinfo.dwOptionsFlags);
 598     /* TODO: test dwCodePage */
 599     /* TODO: test securityAttributes */
 600     ok(IsEqualGUID(&IID_NULL, &bindinfo.iid), "unexpected bindinfo.iid\n");
 601     ok(bindinfo.pUnk == NULL, "bindinfo.pUnk=%p\n", bindinfo.pUnk);
 602     ok(bindinfo.dwReserved == 0, "bindinfo.dwReserved=%d\n", bindinfo.dwReserved);
 603
 604     hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 605             BINDSTATUS_CACHEFILENAMEAVAILABLE, &empty_str);
 606     ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
 607
 608     if(report_mime) {
 609         hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
 610                 BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, wszTextCss);
 611         ok(hres == S_OK,
 612                 "ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE) failed: %08x\n", hres);
 613     }
 614
 615     hres = IInternetProtocolSink_ReportData(pOIProtSink,
 616             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION, 13, 13);
 617     ok(hres == S_OK, "ReportData failed: %08x\n", hres);
 618
 619     hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
 620     ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
 621
 622     return S_OK;
 623 }
 624
 625 static HRESULT WINAPI Protocol_Continue(IInternetProtocol *iface,
 626         PROTOCOLDATA *pProtocolData)
 627 {
 628     ok(0, "unexpected call\n");
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI Protocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 633         DWORD dwOptions)
 634 {
 635     ok(0, "unexpected call\n");
 636     return E_NOTIMPL;
 637 }
 638
 639 static HRESULT WINAPI Protocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 640 {
 641     CHECK_EXPECT(Terminate);
 642     return S_OK;
 643 }
 644
 645 static HRESULT WINAPI Protocol_Suspend(IInternetProtocol *iface)
 646 {
 647     ok(0, "unexpected call\n");
 648     return E_NOTIMPL;
 649 }
 650
 651 static HRESULT WINAPI Protocol_Resume(IInternetProtocol *iface)
 652 {
 653     ok(0, "unexpected call\n");
 654     return E_NOTIMPL;
 655 }
 656
 657 static HRESULT WINAPI Protocol_Read(IInternetProtocol *iface, void *pv,
 658         ULONG cb, ULONG *pcbRead)
 659 {
 660     CHECK_EXPECT2(Protocol_Read);
 661
 662     ok(pv != NULL, "pv == NULL\n");
 663     ok(cb > sizeof(css_data), "cb < sizeof(css_data)\n");
 664     ok(pcbRead != NULL, "pcbRead == NULL\n");
 665     ok(!*pcbRead || *pcbRead==sizeof(css_data)-1, "*pcbRead=%d\n", *pcbRead);
 666
 667     if(protocol_read)
 668         return S_FALSE;
 669
 670     protocol_read += *pcbRead = sizeof(css_data)-1;
 671     memcpy(pv, css_data, sizeof(css_data)-1);
 672     return S_OK;
 673 }
 674
 675 static HRESULT WINAPI Protocol_Seek(IInternetProtocol *iface,
 676         LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 677 {
 678     ok(0, "unexpected call\n");
 679     return E_NOTIMPL;
 680 }
 681
 682 static HRESULT WINAPI Protocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 683 {
 684     CHECK_EXPECT(LockRequest);
 685     return S_OK;
 686 }
 687
 688 static HRESULT WINAPI Protocol_UnlockRequest(IInternetProtocol *iface)
 689 {
 690     CHECK_EXPECT(UnlockRequest);
 691     return S_OK;
 692 }
 693
 694 static const IInternetProtocolVtbl ProtocolVtbl = {
 695     Protocol_QueryInterface,
 696     Protocol_AddRef,
 697     Protocol_Release,
 698     Protocol_Start,
 699     Protocol_Continue,
 700     Protocol_Abort,
 701     Protocol_Terminate,
 702     Protocol_Suspend,
 703     Protocol_Resume,
 704     Protocol_Read,
 705     Protocol_Seek,
 706     Protocol_LockRequest,
 707     Protocol_UnlockRequest
 708 };
 709
 710 static IInternetProtocol Protocol = { &ProtocolVtbl };
 711
 712 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 713 {
 714     if(!IsEqualGUID(&IID_IInternetProtocolInfo, riid))
 715         ok(0, "unexpected call\n");
 716     return E_NOINTERFACE;
 717 }
 718
 719 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 720 {
 721     return 2;
 722 }
 723
 724 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 725 {
 726     return 1;
 727 }
 728
 729 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
 730                                         REFIID riid, void **ppv)
 731 {
 732     if(IsEqualGUID(&IID_IInternetProtocolInfo, riid))
 733         return E_NOINTERFACE;
 734
 735     CHECK_EXPECT(CreateInstance);
 736     ok(ppv != NULL, "ppv == NULL\n");
 737
 738     *ppv = &Protocol;
 739     return S_OK;
 740 }
 741
 742 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 743 {
 744     ok(0, "unexpected call\n");
 745     return S_OK;
 746 }
 747
 748 static const IClassFactoryVtbl ClassFactoryVtbl = {
 749     ClassFactory_QueryInterface,
 750     ClassFactory_AddRef,
 751     ClassFactory_Release,
 752     ClassFactory_CreateInstance,
 753     ClassFactory_LockServer
 754 };
 755
 756 static IClassFactory ClassFactory = { &ClassFactoryVtbl };
 757
 758 static HRESULT WINAPI HlinkFrame_QueryInterface(IHlinkFrame *iface, REFIID riid, void **ppv)
 759 {
 760     ok(0, "unexpected call\n");
 761     return E_NOTIMPL;
 762 }
 763
 764 static ULONG WINAPI HlinkFrame_AddRef(IHlinkFrame *iface)
 765 {
 766     return 2;
 767 }
 768
 769 static ULONG WINAPI HlinkFrame_Release(IHlinkFrame *iface)
 770 {
 771     return 1;
 772 }
 773
 774 static HRESULT WINAPI HlinkFrame_SetBrowseContext(IHlinkFrame *iface,
 775                                                   IHlinkBrowseContext *pihlbc)
 776 {
 777     ok(0, "unexpected call\n");
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI HlinkFrame_GetBrowseContext(IHlinkFrame *iface,
 782                                                   IHlinkBrowseContext **ppihlbc)
 783 {
 784     ok(0, "unexpected call\n");
 785     return E_NOTIMPL;
 786 }
 787
 788 static HRESULT WINAPI HlinkFrame_Navigate(IHlinkFrame *iface, DWORD grfHLNF, LPBC pbc,
 789                                           IBindStatusCallback *pibsc, IHlink *pihlNavigate)
 790 {
 791     HRESULT hres;
 792
 793     CHECK_EXPECT(Navigate);
 794
 795     ok(grfHLNF == 0, "grfHLNF=%d, expected 0\n", grfHLNF);
 796     ok(pbc != NULL, "pbc == NULL\n");
 797     ok(pibsc != NULL, "pubsc == NULL\n");
 798     ok(pihlNavigate != NULL, "puhlNavigate == NULL\n");
 799
 800     if(pihlNavigate) {
 801         LPWSTR frame_name = (LPWSTR)0xdeadbeef;
 802         LPWSTR location = (LPWSTR)0xdeadbeef;
 803         IHlinkSite *site;
 804         IMoniker *mon = NULL;
 805         DWORD site_data = 0xdeadbeef;
 806
 807         hres = IHlink_GetTargetFrameName(pihlNavigate, &frame_name);
 808         ok(hres == S_FALSE, "GetTargetFrameName failed: %08x\n", hres);
 809         ok(frame_name == NULL, "frame_name = %p\n", frame_name);
 810
 811         hres = IHlink_GetMonikerReference(pihlNavigate, 1, &mon, &location);
 812         ok(hres == S_OK, "GetMonikerReference failed: %08x\n", hres);
 813         ok(location == NULL, "location = %p\n", location);
 814         ok(mon != NULL, "mon == NULL\n");
 815
 816         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &location);
 817         ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
 818         ok(!strcmp_wa(location, nav_url), "unexpected display name %s, expected %s\n", wine_dbgstr_w(location), nav_url);
 819         CoTaskMemFree(location);
 820         IMoniker_Release(mon);
 821
 822         hres = IHlink_GetHlinkSite(pihlNavigate, &site, &site_data);
 823         ok(hres == S_OK, "GetHlinkSite failed: %08x\n", hres);
 824         ok(site == NULL, "site = %p\n, expected NULL\n", site);
 825         ok(site_data == 0xdeadbeef, "site_data = %x\n", site_data);
 826     }
 827
 828     return S_OK;
 829 }
 830
 831 static HRESULT WINAPI HlinkFrame_OnNavigate(IHlinkFrame *iface, DWORD grfHLNF,
 832         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName, DWORD dwreserved)
 833 {
 834     ok(0, "unexpected call\n");
 835     return E_NOTIMPL;
 836 }
 837
 838 static HRESULT WINAPI HlinkFrame_UpdateHlink(IHlinkFrame *iface, ULONG uHLID,
 839         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName)
 840 {
 841     ok(0, "unexpected call\n");
 842     return E_NOTIMPL;
 843 }
 844
 845 static const IHlinkFrameVtbl HlinkFrameVtbl = {
 846     HlinkFrame_QueryInterface,
 847     HlinkFrame_AddRef,
 848     HlinkFrame_Release,
 849     HlinkFrame_SetBrowseContext,
 850     HlinkFrame_GetBrowseContext,
 851     HlinkFrame_Navigate,
 852     HlinkFrame_OnNavigate,
 853     HlinkFrame_UpdateHlink
 854 };
 855
 856 static IHlinkFrame HlinkFrame = { &HlinkFrameVtbl };
 857
 858 static HRESULT WINAPI NewWindowManager_QueryInterface(INewWindowManager *iface, REFIID riid, void **ppv)
 859 {
 860     ok(0, "unexpected call\n");
 861     return E_NOINTERFACE;
 862 }
 863
 864 static ULONG WINAPI NewWindowManager_AddRef(INewWindowManager *iface)
 865 {
 866     return 2;
 867 }
 868
 869 static ULONG WINAPI NewWindowManager_Release(INewWindowManager *iface)
 870 {
 871     return 1;
 872 }
 873
 874 static HRESULT WINAPI NewWindowManager_EvaluateNewWindow(INewWindowManager *iface, LPCWSTR pszUrl,
 875         LPCWSTR pszName, LPCWSTR pszUrlContext, LPCWSTR pszFeatures, BOOL fReplace, DWORD dwFlags,
 876         DWORD dwUserActionTime)
 877 {
 878     CHECK_EXPECT(EvaluateNewWindow);
 879
 880     ok(!strcmp_wa(pszUrl, "about:blank"), "pszUrl = %s\n", wine_dbgstr_w(pszUrl));
 881     ok(!strcmp_wa(pszName, "test"), "pszName = %s\n", wine_dbgstr_w(pszName));
 882     ok(!strcmp_wa(pszUrlContext, prev_url), "pszUrlContext = %s\n", wine_dbgstr_w(pszUrlContext));
 883     ok(!pszFeatures, "pszFeatures = %s\n", wine_dbgstr_w(pszFeatures));
 884     ok(!fReplace, "fReplace = %x\n", fReplace);
 885     ok(dwFlags == (allow_new_window ? 0 : NWMF_FIRST), "dwFlags = %x\n", dwFlags);
 886     ok(!dwUserActionTime, "dwUserActionime = %d\n", dwUserActionTime);
 887
 888     return allow_new_window ? S_OK : E_FAIL;
 889 }
 890
 891 static const INewWindowManagerVtbl NewWindowManagerVtbl = {
 892     NewWindowManager_QueryInterface,
 893     NewWindowManager_AddRef,
 894     NewWindowManager_Release,
 895     NewWindowManager_EvaluateNewWindow
 896 };
 897
 898 static INewWindowManager NewWindowManager = { &NewWindowManagerVtbl };
 899
 900 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 901         REFIID riid, void**ppv)
 902 {
 903     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 904         *ppv = iface;
 905         return S_OK;
 906     }
 907
 908     ok(0, "unexpected call\n");
 909     return E_NOINTERFACE;
 910 }
 911
 912 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 913 {
 914     return 2;
 915 }
 916
 917 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 918 {
 919     return 1;
 920 }
 921
 922 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 923 {
 924     switch(dispID) {
 925     case DISPID_READYSTATE:
 926         CHECK_EXPECT2(OnChanged_READYSTATE);
 927
 928         if(!readystate_set_interactive)
 929             test_MSHTML_QueryStatus(NULL, OLECMDF_SUPPORTED
 930                 | (editmode && (load_state == LD_INTERACTIVE || load_state == LD_COMPLETE)
 931                    ? OLECMDF_ENABLED : 0));
 932
 933         if(readystate_set_loading) {
 934             readystate_set_loading = FALSE;
 935             load_state = LD_LOADING;
 936         }
 937         if(!editmode || load_state != LD_LOADING || !called_Exec_Explorer_69)
 938             test_readyState(NULL);
 939         return S_OK;
 940     case 1005:
 941         CHECK_EXPECT2(OnChanged_1005);
 942         if(!editmode)
 943             test_readyState(NULL);
 944         readystate_set_interactive = (load_state != LD_INTERACTIVE);
 945         return S_OK;
 946     case 1012:
 947         CHECK_EXPECT2(OnChanged_1012);
 948         return S_OK;
 949     case 1014:
 950         CHECK_EXPECT2(OnChanged_1014);
 951         return S_OK;
 952     case 1030:
 953     case 3000022:
 954     case 3000023:
 955     case 3000024:
 956     case 3000025:
 957     case 3000026:
 958     case 3000027:
 959     case 3000028:
 960     case 3000029:
 961     case 3000030:
 962     case 3000031:
 963         /* TODO */
 964         return S_OK;
 965     }
 966
 967     ok(0, "unexpected id %d\n", dispID);
 968     return E_NOTIMPL;
 969 }
 970
 971 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 972 {
 973     ok(0, "unexpected call\n");
 974     return E_NOTIMPL;
 975 }
 976
 977 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 978     PropertyNotifySink_QueryInterface,
 979     PropertyNotifySink_AddRef,
 980     PropertyNotifySink_Release,
 981     PropertyNotifySink_OnChanged,
 982     PropertyNotifySink_OnRequestEdit
 983 };
 984
 985 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 986
 987 static HRESULT WINAPI Stream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
 988 {
 989     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_ISequentialStream, riid) || IsEqualGUID(&IID_IStream, riid)) {
 990         *ppv = iface;
 991         return S_OK;
 992     }
 993
 994     ok(0, "unexpected call %s\n", debugstr_guid(riid));
 995     *ppv = NULL;
 996     return E_NOINTERFACE;
 997 }
 998
 999 static ULONG WINAPI Stream_AddRef(IStream *iface)
1000 {
1001     return 2;
1002 }
1003
1004 static ULONG WINAPI Stream_Release(IStream *iface)
1005 {
1006     return 1;
1007 }
1008
1009 static HRESULT WINAPI Stream_Read(IStream *iface, void *pv,
1010                                   ULONG cb, ULONG *pcbRead)
1011 {
1012     CHECK_EXPECT2(Read);
1013     ok(pv != NULL, "pv == NULL\n");
1014     ok(cb > sizeof(html_page), "cb = %d\n", cb);
1015     ok(pcbRead != NULL, "pcbRead == NULL\n");
1016     ok(!*pcbRead, "*pcbRead = %d\n", *pcbRead);
1017
1018     if(stream_read)
1019         return S_FALSE;
1020
1021     memcpy(pv, html_page, sizeof(html_page)-1);
1022     stream_read += *pcbRead = sizeof(html_page)-1;
1023     return S_OK;
1024 }
1025
1026 static HRESULT WINAPI Stream_Write(IStream *iface, const void *pv,
1027                                           ULONG cb, ULONG *pcbWritten)
1028 {
1029     ok(0, "unexpected call\n");
1030     return E_NOTIMPL;
1031 }
1032
1033 static HRESULT WINAPI Stream_Seek(IStream *iface, LARGE_INTEGER dlibMove,
1034                                          DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
1035 {
1036     ok(0, "unexpected call\n");
1037     return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI Stream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
1041 {
1042     ok(0, "unexpected call\n");
1043     return E_NOTIMPL;
1044 }
1045
1046 static HRESULT WINAPI Stream_CopyTo(IStream *iface, IStream *pstm,
1047         ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
1048 {
1049     ok(0, "unexpected call\n");
1050     return E_NOTIMPL;
1051 }
1052
1053 static HRESULT WINAPI Stream_Commit(IStream *iface, DWORD grfCommitFlags)
1054 {
1055     ok(0, "unexpected call\n");
1056     return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI Stream_Revert(IStream *iface)
1060 {
1061     ok(0, "unexpected call\n");
1062     return E_NOTIMPL;
1063 }
1064
1065 static HRESULT WINAPI Stream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
1066                                                ULARGE_INTEGER cb, DWORD dwLockType)
1067 {
1068     ok(0, "unexpected call\n");
1069     return E_NOTIMPL;
1070 }
1071
1072 static HRESULT WINAPI Stream_UnlockRegion(IStream *iface,
1073         ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
1074 {
1075     ok(0, "unexpected call\n");
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI Stream_Stat(IStream *iface, STATSTG *pstatstg,
1080                                          DWORD dwStatFlag)
1081 {
1082     ok(0, "unexpected call\n");
1083     return E_NOTIMPL;
1084 }
1085
1086 static HRESULT WINAPI Stream_Clone(IStream *iface, IStream **ppstm)
1087 {
1088     ok(0, "unexpected call\n");
1089     return E_NOTIMPL;
1090 }
1091
1092 static const IStreamVtbl StreamVtbl = {
1093     Stream_QueryInterface,
1094     Stream_AddRef,
1095     Stream_Release,
1096     Stream_Read,
1097     Stream_Write,
1098     Stream_Seek,
1099     Stream_SetSize,
1100     Stream_CopyTo,
1101     Stream_Commit,
1102     Stream_Revert,
1103     Stream_LockRegion,
1104     Stream_UnlockRegion,
1105     Stream_Stat,
1106     Stream_Clone
1107 };
1108
1109 static IStream Stream = { &StreamVtbl };
1110
1111 static HRESULT WINAPI WinInetHttpInfo_QueryInterface(
1112         IWinInetHttpInfo* This,
1113         REFIID riid,
1114         void **ppvObject)
1115 {
1116     *ppvObject = NULL;
1117
1118     if(IsEqualGUID(&IID_IGetBindHandle, riid))
1119         return E_NOINTERFACE;
1120
1121     ok(0, "unexpected call %s\n", debugstr_guid(riid));
1122     return E_NOINTERFACE;
1123 }
1124
1125 static ULONG WINAPI WinInetHttpInfo_AddRef(
1126         IWinInetHttpInfo* This)
1127 {
1128     return 2;
1129 }
1130
1131 static ULONG WINAPI WinInetHttpInfo_Release(
1132         IWinInetHttpInfo* This)
1133 {
1134     return 1;
1135 }
1136
1137 static HRESULT WINAPI WinInetHttpInfo_QueryOption(
1138         IWinInetHttpInfo* This,
1139         DWORD dwOption,
1140         LPVOID pBuffer,
1141         DWORD *pcbBuf)
1142 {
1143     return E_NOTIMPL; /* TODO */
1144 }
1145
1146 static HRESULT WINAPI WinInetHttpInfo_QueryInfo(
1147         IWinInetHttpInfo* This,
1148         DWORD dwOption,
1149         LPVOID pBuffer,
1150         DWORD *pcbBuf,
1151         DWORD *pdwFlags,
1152         DWORD *pdwReserved)
1153 {
1154     ok(pdwReserved == NULL, "pdwReserved != NULL\n");
1155
1156     if(dwOption == (HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER)) {
1157         ok(pBuffer != NULL, "pBuffer == NULL\n");
1158         ok(*pcbBuf == sizeof(DWORD), "*pcbBuf = %d\n", *pcbBuf);
1159         ok(pdwFlags == NULL, "*pdwFlags != NULL\n");
1160         *((DWORD*)pBuffer) = status_code;
1161         return S_OK;
1162     }
1163
1164     return E_NOTIMPL; /* TODO */
1165 }
1166
1167 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
1168     WinInetHttpInfo_QueryInterface,
1169     WinInetHttpInfo_AddRef,
1170     WinInetHttpInfo_Release,
1171     WinInetHttpInfo_QueryOption,
1172     WinInetHttpInfo_QueryInfo
1173 };
1174
1175 static IWinInetHttpInfo WinInetHttpInfo = { &WinInetHttpInfoVtbl };
1176
1177 DEFINE_GUID(IID_unk_binding, 0xf3d8f080,0xa5eb,0x476f,0x9d,0x19,0xa5,0xef,0x24,0xe5,0xc2,0xe6);
1178
1179 static HRESULT WINAPI Binding_QueryInterface(IBinding *iface, REFIID riid, void **ppv)
1180 {
1181     if(IsEqualGUID(&IID_IUnknown, riid)) {
1182         *ppv = iface;
1183         return S_OK;
1184     }
1185
1186     if(IsEqualGUID(&IID_IWinInetInfo, riid) || IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
1187         *ppv = &WinInetHttpInfo;
1188         return S_OK;
1189     }
1190
1191     if(IsEqualGUID(&IID_unk_binding, riid)) {
1192         *ppv = NULL;
1193         return E_NOINTERFACE;
1194     }
1195
1196     ok(0, "unexpected call %s\n", debugstr_guid(riid));
1197     return E_NOINTERFACE;
1198 }
1199
1200 static ULONG WINAPI Binding_AddRef(IBinding *iface)
1201 {
1202     return 2;
1203 }
1204
1205 static ULONG WINAPI Binding_Release(IBinding *iface)
1206 {
1207     return 1;
1208 }
1209
1210 static HRESULT WINAPI Binding_Abort(IBinding *iface)
1211 {
1212     CHECK_EXPECT(Abort);
1213     if(asynchronous_binding)
1214         PeekMessage(NULL, container_hwnd, WM_CONTINUE_BINDING, WM_CONTINUE_BINDING, PM_REMOVE);
1215     return S_OK;
1216 }
1217
1218 static HRESULT WINAPI Binding_Suspend(IBinding *iface)
1219 {
1220     ok(0, "unexpected call\n");
1221     return E_NOTIMPL;
1222 }
1223
1224 static HRESULT WINAPI Binding_Resume(IBinding *iface)
1225 {
1226     ok(0, "unexpected call\n");
1227     return E_NOTIMPL;
1228 }
1229
1230 static HRESULT WINAPI Binding_SetPriority(IBinding *iface, LONG nPriority)
1231 {
1232     ok(0, "unexpected call\n");
1233     return E_NOTIMPL;
1234 }
1235
1236 static HRESULT WINAPI Binding_GetPriority(IBinding *iface, LONG *pnPriority)
1237 {
1238     ok(0, "unexpected call\n");
1239     return E_NOTIMPL;
1240 }
1241
1242 static HRESULT WINAPI Binding_GetBindResult(IBinding *iface, CLSID *pclsidProtocol,
1243         DWORD *pdwResult, LPOLESTR *pszResult, DWORD *pdwReserved)
1244 {
1245     CHECK_EXPECT(GetBindResult);
1246     return E_NOTIMPL;
1247 }
1248
1249 static const IBindingVtbl BindingVtbl = {
1250     Binding_QueryInterface,
1251     Binding_AddRef,
1252     Binding_Release,
1253     Binding_Abort,
1254     Binding_Suspend,
1255     Binding_Resume,
1256     Binding_SetPriority,
1257     Binding_GetPriority,
1258     Binding_GetBindResult
1259 };
1260
1261 static IBinding Binding = { &BindingVtbl };
1262
1263 DEFINE_GUID(IID_IMoniker_unk,0xA158A630,0xED6F,0x45FB,0xB9,0x87,0xF6,0x86,0x76,0xF5,0x77,0x52);
1264 DEFINE_GUID(IID_IMoniker_unk2, 0x79EAC9D3,0xBAF9,0x11CE,0x8C,0x82,0x00,0xAA,0x00,0x4B,0xA9,0x0B);
1265
1266 static HRESULT WINAPI Moniker_QueryInterface(IMoniker *iface, REFIID riid, void **ppv)
1267 {
1268     *ppv = NULL;
1269
1270     if(IsEqualGUID(&IID_IMoniker_unk, riid))
1271         return E_NOINTERFACE; /* TODO */
1272     if(IsEqualGUID(&IID_IMoniker_unk2, riid))
1273         return E_NOINTERFACE; /* TODO */
1274
1275     ok(0, "unexpected riid: %s\n", debugstr_guid(riid));
1276     return E_NOINTERFACE;
1277 }
1278
1279 static ULONG WINAPI Moniker_AddRef(IMoniker *iface)
1280 {
1281     return 2;
1282 }
1283
1284 static ULONG WINAPI Moniker_Release(IMoniker *iface)
1285 {
1286     return 1;
1287 }
1288
1289 static HRESULT WINAPI Moniker_GetClassID(IMoniker *iface, CLSID *pClassID)
1290 {
1291     CHECK_EXPECT(GetClassID);
1292     ok(IsEqualGUID(pClassID, &IID_NULL), "pClassID = %s\n", debugstr_guid(pClassID));
1293     return E_FAIL;
1294 }
1295
1296 static HRESULT WINAPI Moniker_IsDirty(IMoniker *iface)
1297 {
1298     ok(0, "unexpected call\n");
1299     return E_NOTIMPL;
1300 }
1301
1302 static HRESULT WINAPI Moniker_Load(IMoniker *iface, IStream *pStm)
1303 {
1304     ok(0, "unexpected call\n");
1305     return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI Moniker_Save(IMoniker *iface, IStream *pStm, BOOL fClearDirty)
1309 {
1310     ok(0, "unexpected call\n");
1311     return E_NOTIMPL;
1312 }
1313
1314 static HRESULT WINAPI Moniker_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *pcbSize)
1315 {
1316     ok(0, "unexpected call\n");
1317     return E_NOTIMPL;
1318 }
1319
1320 static HRESULT WINAPI Moniker_BindToObject(IMoniker *iface, IBindCtx *pcb, IMoniker *pmkToLeft,
1321         REFIID riidResult, void **ppvResult)
1322 {
1323     ok(0, "unexpected call\n");
1324     return E_NOTIMPL;
1325 }
1326
1327 static void test_binding_ui(IUnknown *unk)
1328 {
1329     IWindowForBindingUI *binding_ui;
1330     IServiceProvider *serv_prov;
1331     HWND binding_hwnd;
1332     HRESULT hres;
1333
1334     hres = IUnknown_QueryInterface(unk, &IID_IServiceProvider, (void**)&serv_prov);
1335     ok(hres == S_OK, "Could not get IServiceProvider: %08x\n", hres);
1336
1337     hres = IServiceProvider_QueryService(serv_prov, &IID_IWindowForBindingUI, &IID_IWindowForBindingUI,
1338             (void**)&binding_ui);
1339     ok(hres == S_OK, "Could not get IWindowForBindingUI: %08x\n", hres);
1340
1341     hres = IWindowForBindingUI_GetWindow(binding_ui, &IID_IHttpSecurity, &binding_hwnd);
1342     ok(hres == S_OK, "GetWindow(IID_IHttpSecurity) failed: %08x\n", hres);
1343     if(doc_hwnd)
1344         ok(binding_hwnd == doc_hwnd, "binding_hwnd != doc_hwnd\n");
1345     else
1346         todo_wine ok(binding_hwnd != NULL, "binding_hwnd == NULL\n");
1347
1348     hres = IWindowForBindingUI_GetWindow(binding_ui, &IID_IAuthenticate, &binding_hwnd);
1349     ok(hres == S_OK, "GetWindow(IID_IHttpSecurity) failed: %08x\n", hres);
1350     if(doc_hwnd)
1351         ok(binding_hwnd == doc_hwnd, "binding_hwnd != doc_hwnd\n");
1352     else
1353         todo_wine ok(binding_hwnd != NULL, "binding_hwnd == NULL\n");
1354
1355     hres = IWindowForBindingUI_GetWindow(binding_ui, &IID_IWindowForBindingUI, &binding_hwnd);
1356     ok(hres == S_OK, "GetWindow(IID_IHttpSecurity) failed: %08x\n", hres);
1357     if(doc_hwnd)
1358         ok(binding_hwnd == doc_hwnd, "binding_hwnd != doc_hwnd\n");
1359     else
1360         todo_wine ok(binding_hwnd != NULL, "binding_hwnd == NULL\n");
1361
1362     IWindowForBindingUI_Release(binding_ui);
1363     IServiceProvider_Release(serv_prov);
1364 }
1365
1366 static void continue_binding(IBindStatusCallback *callback)
1367 {
1368     FORMATETC formatetc = {0xc02d, NULL, 1, -1, TYMED_ISTREAM};
1369     STGMEDIUM stgmedium;
1370     HRESULT hres;
1371
1372     static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
1373
1374     test_binding_ui((IUnknown*)callback);
1375
1376     if(report_mime) {
1377         hres = IBindStatusCallback_OnProgress(callback, 0, 0, BINDSTATUS_MIMETYPEAVAILABLE,
1378                 wszTextHtml);
1379         ok(hres == S_OK, "OnProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
1380     }
1381
1382     hres = IBindStatusCallback_OnProgress(callback, sizeof(html_page)-1, sizeof(html_page)-1,
1383             BINDSTATUS_BEGINDOWNLOADDATA, doc_url);
1384     ok(hres == S_OK, "OnProgress(BINDSTATUS_BEGINDOWNLOADDATA) failed: %08x\n", hres);
1385     if(status_code != HTTP_STATUS_OK) {
1386         CHECK_CALLED_BROKEN(IsErrorUrl);
1387         SET_EXPECT(IsErrorUrl);
1388     }
1389
1390     SET_EXPECT(Read);
1391     stgmedium.tymed = TYMED_ISTREAM;
1392     U(stgmedium).pstm = &Stream;
1393     stgmedium.pUnkForRelease = (IUnknown*)&Moniker;
1394     hres = IBindStatusCallback_OnDataAvailable(callback,
1395             BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION,
1396             sizeof(html_page)-1, &formatetc, &stgmedium);
1397     ok(hres == S_OK, "OnDataAvailable failed: %08x\n", hres);
1398     CHECK_CALLED(Read);
1399
1400     hres = IBindStatusCallback_OnProgress(callback, sizeof(html_page)-1, sizeof(html_page)-1,
1401             BINDSTATUS_ENDDOWNLOADDATA, NULL);
1402     ok(hres == S_OK, "OnProgress(BINDSTATUS_ENDDOWNLOADDATA) failed: %08x\n", hres);
1403
1404     SET_EXPECT(GetBindResult);
1405     hres = IBindStatusCallback_OnStopBinding(callback, S_OK, NULL);
1406     ok(hres == S_OK, "OnStopBinding failed: %08x\n", hres);
1407     CLEAR_CALLED(GetBindResult); /* IE7 */
1408
1409     IBindStatusCallback_Release(callback);
1410 }
1411
1412 static HRESULT WINAPI Moniker_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
1413         REFIID riid, void **ppv)
1414 {
1415     IBindStatusCallback *callback = NULL;
1416     BINDINFO bindinfo;
1417     DWORD bindf;
1418     HRESULT hres;
1419
1420     static OLECHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
1421
1422     CHECK_EXPECT(BindToStorage);
1423
1424     load_state = LD_LOADING;
1425
1426     ok(pbc != NULL, "pbc == NULL\n");
1427     ok(pmkToLeft == NULL, "pmkToLeft=%p\n", pmkToLeft);
1428     ok(IsEqualGUID(&IID_IStream, riid), "unexpected riid\n");
1429     ok(ppv != NULL, "ppv == NULL\n");
1430     ok(*ppv == NULL, "*ppv=%p\n", *ppv);
1431
1432     hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, (IUnknown**)&callback);
1433     ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
1434     ok(callback != NULL, "callback == NULL\n");
1435
1436     memset(&bindinfo, 0xf0, sizeof(bindinfo));
1437     bindinfo.cbSize = sizeof(bindinfo);
1438
1439     hres = IBindStatusCallback_GetBindInfo(callback, &bindf, &bindinfo);
1440     ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
1441     ok((bindf & ~BINDF_HYPERLINK /* IE9 */) == (BINDF_PULLDATA|BINDF_ASYNCSTORAGE|BINDF_ASYNCHRONOUS), "bindf = %08x\n", bindf);
1442     ok(bindinfo.cbSize == sizeof(bindinfo), "bindinfo.cbSize=%d\n", bindinfo.cbSize);
1443     ok(bindinfo.szExtraInfo == NULL, "bindinfo.szExtraInfo=%p\n", bindinfo.szExtraInfo);
1444     /* TODO: test stgmedData */
1445     ok(bindinfo.grfBindInfoF == 0, "bindinfo.grfBinfInfoF=%08x\n", bindinfo.grfBindInfoF);
1446     ok(bindinfo.dwBindVerb == 0, "bindinfo.dwBindVerb=%d\n", bindinfo.dwBindVerb);
1447     ok(bindinfo.szCustomVerb == 0, "bindinfo.szCustomVerb=%p\n", bindinfo.szCustomVerb);
1448     ok(bindinfo.cbstgmedData == 0, "bindinfo.cbstgmedData=%d\n", bindinfo.cbstgmedData);
1449     ok(bindinfo.dwOptions == 0x80000 || bindinfo.dwOptions == 0x4080000,
1450        "bindinfo.dwOptions=%x\n", bindinfo.dwOptions);
1451     ok(bindinfo.dwOptionsFlags == 0, "bindinfo.dwOptionsFlags=%d\n", bindinfo.dwOptionsFlags);
1452     /* TODO: test dwCodePage */
1453     /* TODO: test securityAttributes */
1454     ok(IsEqualGUID(&IID_NULL, &bindinfo.iid), "unexpected bindinfo.iid\n");
1455     ok(bindinfo.pUnk == NULL, "bindinfo.pUnk=%p\n", bindinfo.pUnk);
1456     ok(bindinfo.dwReserved == 0, "bindinfo.dwReserved=%d\n", bindinfo.dwReserved);
1457
1458     hres = IBindStatusCallback_OnStartBinding(callback, 0, &Binding);
1459     ok(hres == S_OK, "OnStartBinding failed: %08x\n", hres);
1460
1461     if(asynchronous_binding) {
1462         PostMessageW(container_hwnd, WM_CONTINUE_BINDING, (WPARAM)callback, 0);
1463         return MK_S_ASYNCHRONOUS;
1464     }
1465
1466     continue_binding(callback);
1467     return S_OK;
1468 }
1469
1470 static HRESULT WINAPI Moniker_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD dwReduceHowFar,
1471         IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
1472 {
1473     ok(0, "unexpected call\n");
1474     return E_NOTIMPL;
1475 }
1476
1477 static HRESULT WINAPI Moniker_ComposeWith(IMoniker *iface, IMoniker *pmkRight,
1478         BOOL fOnlyIfNotGeneric, IMoniker **ppnkComposite)
1479 {
1480     ok(0, "unexpected call\n");
1481     return E_NOTIMPL;
1482 }
1483
1484 static HRESULT WINAPI Moniker_Enum(IMoniker *iface, BOOL fForwrd, IEnumMoniker **ppenumMoniker)
1485 {
1486     ok(0, "unexpected call\n");
1487     return E_NOTIMPL;
1488 }
1489
1490 static HRESULT WINAPI Moniker_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
1491 {
1492     ok(0, "unexpected call\n");
1493     return E_NOTIMPL;
1494 }
1495
1496 static HRESULT WINAPI Moniker_Hash(IMoniker *iface, DWORD *pdwHash)
1497 {
1498     ok(0, "unexpected call\n");
1499     return E_NOTIMPL;
1500 }
1501
1502 static HRESULT WINAPI Moniker_IsRunning(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
1503         IMoniker *pmkNewlyRunning)
1504 {
1505     ok(0, "unexpected call\n");
1506     return E_NOTIMPL;
1507 }
1508
1509 static HRESULT WINAPI Moniker_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc,
1510         IMoniker *pmkToLeft, FILETIME *pFileTime)
1511 {
1512     ok(0, "unexpected call\n");
1513     return E_NOTIMPL;
1514 }
1515
1516 static HRESULT WINAPI Moniker_Inverse(IMoniker *iface, IMoniker **ppmk)
1517 {
1518     ok(0, "unexpected call\n");
1519     return E_NOTIMPL;
1520 }
1521
1522 static HRESULT WINAPI Moniker_CommonPrefixWith(IMoniker *iface, IMoniker *pmkOther,
1523         IMoniker **ppmkPrefix)
1524 {
1525     ok(0, "unexpected call\n");
1526     return E_NOTIMPL;
1527 }
1528
1529 static HRESULT WINAPI Moniker_RelativePathTo(IMoniker *iface, IMoniker *pmkOther,
1530         IMoniker **pmkRelPath)
1531 {
1532     ok(0, "unexpected call\n");
1533     return E_NOTIMPL;
1534 }
1535
1536 static HRESULT WINAPI Moniker_GetDisplayName(IMoniker *iface, IBindCtx *pbc,
1537         IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
1538 {
1539     CHECK_EXPECT2(GetDisplayName);
1540
1541     /* ok(pbc != NULL, "pbc == NULL\n"); */
1542     ok(pmkToLeft == NULL, "pmkToLeft=%p\n", pmkToLeft);
1543     ok(ppszDisplayName != NULL, "ppszDisplayName == NULL\n");
1544
1545     *ppszDisplayName = CoTaskMemAlloc(sizeof(doc_url));
1546     memcpy(*ppszDisplayName, doc_url, sizeof(doc_url));
1547
1548     return S_OK;
1549 }
1550
1551 static HRESULT WINAPI Moniker_ParseDisplayName(IMoniker *iface, IBindCtx *pbc,
1552         IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
1553 {
1554     ok(0, "unexpected call\n");
1555     return E_NOTIMPL;
1556 }
1557
1558 static HRESULT WINAPI Moniker_IsSystemMoniker(IMoniker *iface, DWORD *pdwMksys)
1559 {
1560     CHECK_EXPECT(IsSystemMoniker);
1561     return E_NOTIMPL;
1562 }
1563
1564 static const IMonikerVtbl MonikerVtbl = {
1565     Moniker_QueryInterface,
1566     Moniker_AddRef,
1567     Moniker_Release,
1568     Moniker_GetClassID,
1569     Moniker_IsDirty,
1570     Moniker_Load,
1571     Moniker_Save,
1572     Moniker_GetSizeMax,
1573     Moniker_BindToObject,
1574     Moniker_BindToStorage,
1575     Moniker_Reduce,
1576     Moniker_ComposeWith,
1577     Moniker_Enum,
1578     Moniker_IsEqual,
1579     Moniker_Hash,
1580     Moniker_IsRunning,
1581     Moniker_GetTimeOfLastChange,
1582     Moniker_Inverse,
1583     Moniker_CommonPrefixWith,
1584     Moniker_RelativePathTo,
1585     Moniker_GetDisplayName,
1586     Moniker_ParseDisplayName,
1587     Moniker_IsSystemMoniker
1588 };
1589
1590 static IMoniker Moniker = { &MonikerVtbl };
1591
1592 static HRESULT WINAPI OleContainer_QueryInterface(IOleContainer *iface, REFIID riid, void **ppv)
1593 {
1594     return QueryInterface(riid, ppv);
1595 }
1596
1597 static ULONG WINAPI OleContainer_AddRef(IOleContainer *iface)
1598 {
1599     return 2;
1600 }
1601
1602 static ULONG WINAPI OleContainer_Release(IOleContainer *iface)
1603 {
1604     return 1;
1605 }
1606
1607 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer *iface, IBindCtx *pbc,
1608         LPOLESTR pszDiaplayName, ULONG *pchEaten, IMoniker **ppmkOut)
1609 {
1610     ok(0, "unexpected call\n");
1611     return E_NOTIMPL;
1612 }
1613
1614 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer *iface, DWORD grfFlags,
1615         IEnumUnknown **ppenum)
1616 {
1617     ok(0, "unexpected call\n");
1618     return E_NOTIMPL;
1619 }
1620
1621 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer *iface, BOOL fLock)
1622 {
1623     CHECK_EXPECT(LockContainer);
1624     ok(expect_LockContainer_fLock == fLock, "fLock=%x, expected %x\n", fLock, expect_LockContainer_fLock);
1625     return S_OK;
1626 }
1627
1628 static const IOleContainerVtbl OleContainerVtbl = {
1629     OleContainer_QueryInterface,
1630     OleContainer_AddRef,
1631     OleContainer_Release,
1632     OleContainer_ParseDisplayName,
1633     OleContainer_EnumObjects,
1634     OleContainer_LockContainer
1635 };
1636
1637 static IOleContainer OleContainer = { &OleContainerVtbl };
1638
1639 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1640 {
1641     return QueryInterface(riid, ppv);
1642 }
1643
1644 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1645 {
1646     return 2;
1647 }
1648
1649 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1650 {
1651     return 1;
1652 }
1653
1654 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1655 {
1656     ok(0, "unexpected call\n");
1657     return E_NOTIMPL;
1658 }
1659
1660 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1661         IMoniker **ppmon)
1662 {
1663     ok(0, "unexpected call\n");
1664     return E_NOTIMPL;
1665 }
1666
1667 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1668 {
1669     CHECK_EXPECT(GetContainer);
1670     ok(ppContainer != NULL, "ppContainer = NULL\n");
1671     *ppContainer = &OleContainer;
1672     return S_OK;
1673 }
1674
1675 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1676 {
1677     ok(0, "unexpected call\n");
1678     return E_NOTIMPL;
1679 }
1680
1681 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1682 {
1683     ok(0, "unexpected call\n");
1684     return E_NOTIMPL;
1685 }
1686
1687 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1688 {
1689     ok(0, "unexpected call\n");
1690     return E_NOTIMPL;
1691 }
1692
1693 static const IOleClientSiteVtbl ClientSiteVtbl = {
1694     ClientSite_QueryInterface,
1695     ClientSite_AddRef,
1696     ClientSite_Release,
1697     ClientSite_SaveObject,
1698     ClientSite_GetMoniker,
1699     ClientSite_GetContainer,
1700     ClientSite_ShowObject,
1701     ClientSite_OnShowWindow,
1702     ClientSite_RequestNewObjectLayout
1703 };
1704
1705 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1706
1707 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1708 {
1709     static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
1710
1711     if(!IsEqualGUID(&undocumented_frame_iid, riid))
1712         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1713
1714     *ppv = NULL;
1715     return E_NOINTERFACE;
1716 }
1717
1718 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1719 {
1720     return 2;
1721 }
1722
1723 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1724 {
1725     return 1;
1726 }
1727
1728 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1729 {
1730     CHECK_EXPECT(Frame_GetWindow);
1731     return E_NOTIMPL;
1732 }
1733
1734 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1735 {
1736     ok(0, "unexpected call\n");
1737     return E_NOTIMPL;
1738 }
1739
1740 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1741 {
1742     ok(0, "unexpected call\n");
1743     return E_NOTIMPL;
1744 }
1745
1746 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1747         LPCBORDERWIDTHS pborderwidths)
1748 {
1749     ok(0, "unexpected call\n");
1750     return E_NOTIMPL;
1751 }
1752
1753 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1754         LPCBORDERWIDTHS pborderwidths)
1755 {
1756     CHECK_EXPECT(InPlaceFrame_SetBorderSpace);
1757     return S_OK;
1758 }
1759
1760 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1761         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1762 {
1763     static const WCHAR wszHTML_Document[] =
1764         {'H','T','M','L',' ','D','o','c','u','m','e','n','t',0};
1765
1766     CHECK_EXPECT2(InPlaceUIWindow_SetActiveObject);
1767
1768     if(expect_InPlaceUIWindow_SetActiveObject_active) {
1769         ok(pActiveObject != NULL, "pActiveObject = NULL\n");
1770         if(pActiveObject && is_lang_english())
1771             ok(!lstrcmpW(wszHTML_Document, pszObjName), "%s != \"HTML Document\"\n", wine_dbgstr_w(pszObjName));
1772     }
1773     else {
1774         ok(pActiveObject == NULL, "pActiveObject=%p, expected NULL\n", pActiveObject);
1775         ok(pszObjName == NULL, "pszObjName=%p, expected NULL\n", pszObjName);
1776     }
1777     expect_InPlaceUIWindow_SetActiveObject_active = !expect_InPlaceUIWindow_SetActiveObject_active;
1778     return S_OK;
1779 }
1780
1781 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1782         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1783 {
1784     static const WCHAR wszHTML_Document[] =
1785         {'H','T','M','L',' ','D','o','c','u','m','e','n','t',0};
1786
1787     if(pActiveObject) {
1788         CHECK_EXPECT2(SetActiveObject);
1789
1790         if(pActiveObject && is_lang_english())
1791             ok(!lstrcmpW(wszHTML_Document, pszObjName), "%s != \"HTML Document\"\n", wine_dbgstr_w(pszObjName));
1792     }else {
1793         CHECK_EXPECT(SetActiveObject_null);
1794
1795         ok(pActiveObject == NULL, "pActiveObject=%p, expected NULL\n", pActiveObject);
1796         ok(pszObjName == NULL, "pszObjName=%p, expected NULL\n", pszObjName);
1797     }
1798
1799     return S_OK;
1800 }
1801
1802 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1803         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1804 {
1805     ok(0, "unexpected call\n");
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1810         HOLEMENU holemenu, HWND hwndActiveObject)
1811 {
1812     ok(0, "unexpected call\n");
1813     return E_NOTIMPL;
1814 }
1815
1816 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1817 {
1818     ok(0, "unexpected call\n");
1819     return E_NOTIMPL;
1820 }
1821
1822 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1823 {
1824     CHECK_EXPECT2(SetStatusText);
1825     if(!expect_status_text)
1826         ok(pszStatusText == NULL, "pszStatusText=%p, expected NULL\n", pszStatusText);
1827     return S_OK;
1828 }
1829
1830 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1831 {
1832     if(fEnable)
1833         CHECK_EXPECT2(Frame_EnableModeless_TRUE);
1834     else
1835         CHECK_EXPECT2(Frame_EnableModeless_FALSE);
1836     return E_NOTIMPL;
1837 }
1838
1839 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1840 {
1841     ok(0, "unexpected call\n");
1842     return E_NOTIMPL;
1843 }
1844
1845 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1846     InPlaceFrame_QueryInterface,
1847     InPlaceFrame_AddRef,
1848     InPlaceFrame_Release,
1849     InPlaceFrame_GetWindow,
1850     InPlaceFrame_ContextSensitiveHelp,
1851     InPlaceFrame_GetBorder,
1852     InPlaceFrame_RequestBorderSpace,
1853     InPlaceFrame_SetBorderSpace,
1854     InPlaceFrame_SetActiveObject,
1855     InPlaceFrame_InsertMenus,
1856     InPlaceFrame_SetMenu,
1857     InPlaceFrame_RemoveMenus,
1858     InPlaceFrame_SetStatusText,
1859     InPlaceFrame_EnableModeless,
1860     InPlaceFrame_TranslateAccelerator
1861 };
1862
1863 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1864
1865 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1866     InPlaceFrame_QueryInterface,
1867     InPlaceFrame_AddRef,
1868     InPlaceFrame_Release,
1869     InPlaceFrame_GetWindow,
1870     InPlaceFrame_ContextSensitiveHelp,
1871     InPlaceFrame_GetBorder,
1872     InPlaceFrame_RequestBorderSpace,
1873     InPlaceFrame_SetBorderSpace,
1874     InPlaceUIWindow_SetActiveObject,
1875 };
1876
1877 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1878
1879 static HRESULT WINAPI InPlaceSiteWindowless_QueryInterface(IOleInPlaceSiteWindowless *iface, REFIID riid, void **ppv)
1880 {
1881     return QueryInterface(riid, ppv);
1882 }
1883
1884 static ULONG WINAPI InPlaceSiteWindowless_AddRef(IOleInPlaceSiteWindowless *iface)
1885 {
1886     return 2;
1887 }
1888
1889 static ULONG WINAPI InPlaceSiteWindowless_Release(IOleInPlaceSiteWindowless *iface)
1890 {
1891     return 1;
1892 }
1893
1894 static HRESULT WINAPI InPlaceSiteWindowless_GetWindow(
1895         IOleInPlaceSiteWindowless *iface, HWND *phwnd)
1896 {
1897     IOleClientSite *client_site;
1898     IOleObject *ole_obj;
1899     HRESULT hres;
1900
1901     CHECK_EXPECT2(GetWindow);
1902     ok(phwnd != NULL, "phwnd = NULL\n");
1903     *phwnd = container_hwnd;
1904
1905     hres = IUnknown_QueryInterface(doc_unk, &IID_IOleObject, (void**)&ole_obj);
1906     ok(hres == S_OK, "Could not get IOleObject: %08x\n", hres);
1907
1908     hres = IOleObject_GetClientSite(ole_obj, &client_site);
1909     IOleObject_Release(ole_obj);
1910     ok(hres == S_OK, "GetClientSite failed: %08x\n", hres);
1911     ok(client_site == &ClientSite, "client_site != ClientSite\n");
1912     IOleClientSite_Release(client_site);
1913
1914     return S_OK;
1915 }
1916
1917 static HRESULT WINAPI InPlaceSiteWindowless_ContextSensitiveHelp(
1918         IOleInPlaceSiteWindowless *iface, BOOL fEnterMode)
1919 {
1920     ok(0, "unexpected call\n");
1921     return E_NOTIMPL;
1922 }
1923
1924 static HRESULT WINAPI InPlaceSiteWindowless_CanInPlaceActivate(
1925         IOleInPlaceSiteWindowless *iface)
1926 {
1927     CHECK_EXPECT(CanInPlaceActivate);
1928     return S_OK;
1929 }
1930
1931 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceActivate(
1932         IOleInPlaceSiteWindowless *iface)
1933 {
1934     CHECK_EXPECT(OnInPlaceActivate);
1935     inplace_deactivated = FALSE;
1936     return S_OK;
1937 }
1938
1939 static HRESULT WINAPI InPlaceSiteWindowless_OnUIActivate(
1940         IOleInPlaceSiteWindowless *iface)
1941 {
1942     CHECK_EXPECT(OnUIActivate);
1943     return S_OK;
1944 }
1945
1946 static HRESULT WINAPI InPlaceSiteWindowless_GetWindowContext(
1947         IOleInPlaceSiteWindowless *iface, IOleInPlaceFrame **ppFrame,
1948         IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1949         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1950 {
1951     static const RECT rect = {0,0,500,500};
1952
1953     CHECK_EXPECT(GetWindowContext);
1954
1955     ok(ppFrame != NULL, "ppFrame = NULL\n");
1956     if(ppFrame)
1957         *ppFrame = &InPlaceFrame;
1958     ok(ppDoc != NULL, "ppDoc = NULL\n");
1959     if(ppDoc)
1960         *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1961     ok(lprcPosRect != NULL, "lprcPosRect = NULL\n");
1962     if(lprcPosRect)
1963         memcpy(lprcPosRect, &rect, sizeof(RECT));
1964     ok(lprcClipRect != NULL, "lprcClipRect = NULL\n");
1965     if(lprcClipRect)
1966         memcpy(lprcClipRect, &rect, sizeof(RECT));
1967     ok(lpFrameInfo != NULL, "lpFrameInfo = NULL\n");
1968     if(lpFrameInfo) {
1969         ok(lpFrameInfo->cb == sizeof(*lpFrameInfo), "lpFrameInfo->cb = %u, expected %u\n", lpFrameInfo->cb, (unsigned)sizeof(*lpFrameInfo));
1970         lpFrameInfo->fMDIApp = FALSE;
1971         lpFrameInfo->hwndFrame = container_hwnd;
1972         lpFrameInfo->haccel = NULL;
1973         lpFrameInfo->cAccelEntries = 0;
1974     }
1975
1976     return S_OK;
1977 }
1978
1979 static HRESULT WINAPI InPlaceSiteWindowless_Scroll(
1980         IOleInPlaceSiteWindowless *iface, SIZE scrollExtent)
1981 {
1982     ok(0, "unexpected call\n");
1983     return E_NOTIMPL;
1984 }
1985
1986 static HRESULT WINAPI InPlaceSiteWindowless_OnUIDeactivate(
1987         IOleInPlaceSiteWindowless *iface, BOOL fUndoable)
1988 {
1989     CHECK_EXPECT(OnUIDeactivate);
1990     ok(!fUndoable, "fUndoable = TRUE\n");
1991     return S_OK;
1992 }
1993
1994 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceDeactivate(
1995         IOleInPlaceSiteWindowless *iface)
1996 {
1997     CHECK_EXPECT(OnInPlaceDeactivate);
1998     inplace_deactivated = TRUE;
1999     return S_OK;
2000 }
2001
2002 static HRESULT WINAPI InPlaceSiteWindowless_DiscardUndoState(
2003         IOleInPlaceSiteWindowless *iface)
2004 {
2005     ok(0, "unexpected call\n");
2006     return E_NOTIMPL;
2007 }
2008
2009 static HRESULT WINAPI InPlaceSiteWindowless_DeactivateAndUndo(
2010         IOleInPlaceSiteWindowless *iface)
2011 {
2012     ok(0, "unexpected call\n");
2013     return E_NOTIMPL;
2014 }
2015
2016 static HRESULT WINAPI InPlaceSiteWindowless_OnPosRectChange(
2017         IOleInPlaceSiteWindowless *iface, LPCRECT lprcPosRect)
2018 {
2019     ok(0, "unexpected call\n");
2020     return E_NOTIMPL;
2021 }
2022
2023 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceActivateEx(
2024         IOleInPlaceSiteWindowless *iface, BOOL *pfNoRedraw, DWORD dwFlags)
2025 {
2026     CHECK_EXPECT(OnInPlaceActivateEx);
2027
2028     ok(pfNoRedraw != NULL, "pfNoRedraw == NULL\n");
2029     ok(!*pfNoRedraw, "*pfNoRedraw == TRUE\n");
2030     ok(dwFlags == 0, "dwFlags = %08x\n", dwFlags);
2031
2032     return S_OK;
2033 }
2034
2035 static HRESULT WINAPI InPlaceSiteWindowless_OnInPlaceDeactivateEx(
2036         IOleInPlaceSiteWindowless *iface, BOOL fNoRedraw)
2037 {
2038     CHECK_EXPECT(OnInPlaceDeactivateEx);
2039
2040     ok(fNoRedraw, "fNoRedraw == FALSE\n");
2041
2042     return S_OK;
2043 }
2044
2045 static HRESULT WINAPI InPlaceSiteWindowless_RequestUIActivate(
2046         IOleInPlaceSiteWindowless *iface)
2047 {
2048     CHECK_EXPECT2(RequestUIActivate);
2049     return S_OK;
2050 }
2051
2052 static HRESULT WINAPI InPlaceSiteWindowless_CanWindowlessActivate(
2053         IOleInPlaceSiteWindowless *iface)
2054 {
2055     ok(0, "unexpected call\n");
2056     return E_NOTIMPL;
2057 }
2058
2059 static HRESULT WINAPI InPlaceSiteWindowless_GetCapture(
2060         IOleInPlaceSiteWindowless *iface)
2061 {
2062     ok(0, "unexpected call\n");
2063     return E_NOTIMPL;
2064 }
2065
2066 static HRESULT WINAPI InPlaceSiteWindowless_SetCapture(
2067         IOleInPlaceSiteWindowless *iface, BOOL fCapture)
2068 {
2069     ok(0, "unexpected call\n");
2070     return E_NOTIMPL;
2071 }
2072
2073 static HRESULT WINAPI InPlaceSiteWindowless_GetFocus(
2074         IOleInPlaceSiteWindowless *iface)
2075 {
2076     ok(0, "unexpected call\n");
2077     return E_NOTIMPL;
2078 }
2079
2080 static HRESULT WINAPI InPlaceSiteWindowless_SetFocus(
2081         IOleInPlaceSiteWindowless *iface, BOOL fFocus)
2082 {
2083     ok(0, "unexpected call\n");
2084     return E_NOTIMPL;
2085 }
2086
2087 static HRESULT WINAPI InPlaceSiteWindowless_GetDC(
2088         IOleInPlaceSiteWindowless *iface, LPCRECT pRect,
2089         DWORD grfFlags, HDC *phDC)
2090 {
2091     ok(0, "unexpected call\n");
2092     return E_NOTIMPL;
2093 }
2094
2095 static HRESULT WINAPI InPlaceSiteWindowless_ReleaseDC(
2096         IOleInPlaceSiteWindowless *iface, HDC hDC)
2097 {
2098     ok(0, "unexpected call\n");
2099     return E_NOTIMPL;
2100 }
2101
2102 static HRESULT WINAPI InPlaceSiteWindowless_InvalidateRect(
2103         IOleInPlaceSiteWindowless *iface, LPCRECT pRect, BOOL fErase)
2104 {
2105     ok(0, "unexpected call\n");
2106     return E_NOTIMPL;
2107 }
2108
2109 static HRESULT WINAPI InPlaceSiteWindowless_InvalidateRgn(
2110         IOleInPlaceSiteWindowless *iface, HRGN hRGN, BOOL fErase)
2111 {
2112     ok(0, "unexpected call\n");
2113     return E_NOTIMPL;
2114 }
2115
2116 static HRESULT WINAPI InPlaceSiteWindowless_ScrollRect(
2117         IOleInPlaceSiteWindowless *iface, INT dx, INT dy,
2118         LPCRECT pRectScroll, LPCRECT pRectClip)
2119 {
2120     ok(0, "unexpected call\n");
2121     return E_NOTIMPL;
2122 }
2123
2124 static HRESULT WINAPI InPlaceSiteWindowless_AdjustRect(
2125         IOleInPlaceSiteWindowless *iface, LPRECT prc)
2126 {
2127     ok(0, "unexpected call\n");
2128     return E_NOTIMPL;
2129 }
2130
2131 static HRESULT WINAPI InPlaceSiteWindowless_OnDefWindowMessage(
2132         IOleInPlaceSiteWindowless *iface, UINT msg,
2133         WPARAM wParam, LPARAM lParam, LRESULT *plResult)
2134 {
2135     ok(0, "unexpected call\n");
2136     return E_NOTIMPL;
2137 }
2138
2139 static const IOleInPlaceSiteWindowlessVtbl InPlaceSiteWindowlessVtbl = {
2140     InPlaceSiteWindowless_QueryInterface,
2141     InPlaceSiteWindowless_AddRef,
2142     InPlaceSiteWindowless_Release,
2143     InPlaceSiteWindowless_GetWindow,
2144     InPlaceSiteWindowless_ContextSensitiveHelp,
2145     InPlaceSiteWindowless_CanInPlaceActivate,
2146     InPlaceSiteWindowless_OnInPlaceActivate,
2147     InPlaceSiteWindowless_OnUIActivate,
2148     InPlaceSiteWindowless_GetWindowContext,
2149     InPlaceSiteWindowless_Scroll,
2150     InPlaceSiteWindowless_OnUIDeactivate,
2151     InPlaceSiteWindowless_OnInPlaceDeactivate,
2152     InPlaceSiteWindowless_DiscardUndoState,
2153     InPlaceSiteWindowless_DeactivateAndUndo,
2154     InPlaceSiteWindowless_OnPosRectChange,
2155     InPlaceSiteWindowless_OnInPlaceActivateEx,
2156     InPlaceSiteWindowless_OnInPlaceDeactivateEx,
2157     InPlaceSiteWindowless_RequestUIActivate,
2158     InPlaceSiteWindowless_CanWindowlessActivate,
2159     InPlaceSiteWindowless_GetCapture,
2160     InPlaceSiteWindowless_SetCapture,
2161     InPlaceSiteWindowless_GetFocus,
2162     InPlaceSiteWindowless_SetFocus,
2163     InPlaceSiteWindowless_GetDC,
2164     InPlaceSiteWindowless_ReleaseDC,
2165     InPlaceSiteWindowless_InvalidateRect,
2166     InPlaceSiteWindowless_InvalidateRgn,
2167     InPlaceSiteWindowless_ScrollRect,
2168     InPlaceSiteWindowless_AdjustRect,
2169     InPlaceSiteWindowless_OnDefWindowMessage
2170 };
2171
2172 static IOleInPlaceSiteWindowless InPlaceSiteWindowless = { &InPlaceSiteWindowlessVtbl };
2173
2174 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
2175 {
2176     return QueryInterface(riid, ppv);
2177 }
2178
2179 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
2180 {
2181     return 2;
2182 }
2183
2184 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
2185 {
2186     return 1;
2187 }
2188
2189 typedef enum
2190 {
2191     CallUIActivate_None,
2192     CallUIActivate_ActivateMe,
2193     CallUIActivate_AfterShow,
2194 } CallUIActivate;
2195
2196 static BOOL call_UIActivate = CallUIActivate_ActivateMe;
2197 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
2198 {
2199     IOleDocument *document;
2200     HRESULT hres;
2201
2202     CHECK_EXPECT(ActivateMe);
2203     ok(pViewToActivate != NULL, "pViewToActivate = NULL\n");
2204
2205     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
2206     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
2207
2208     if(SUCCEEDED(hres)) {
2209         hres = IOleDocument_CreateView(document, (IOleInPlaceSite*)&InPlaceSiteWindowless, NULL, 0, &view);
2210         ok(hres == S_OK, "CreateView failed: %08x\n", hres);
2211
2212         if(SUCCEEDED(hres)) {
2213             IOleInPlaceActiveObject *activeobj = NULL;
2214             IOleInPlaceSite *inplacesite = NULL;
2215             HWND tmp_hwnd = NULL;
2216             static RECT rect = {0,0,400,500};
2217
2218             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
2219             ok(hres == S_OK, "GetInPlaceSite failed: %08x\n", hres);
2220             ok(inplacesite == (IOleInPlaceSite*)&InPlaceSiteWindowless, "inplacesite=%p, expected %p\n",
2221                     inplacesite, &InPlaceSiteWindowless);
2222
2223             hres = IOleDocumentView_SetInPlaceSite(view, (IOleInPlaceSite*)&InPlaceSiteWindowless);
2224             ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
2225
2226             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
2227             ok(hres == S_OK, "GetInPlaceSite failed: %08x\n", hres);
2228             ok(inplacesite == (IOleInPlaceSite*)&InPlaceSiteWindowless, "inplacesite=%p, expected %p\n",
2229                     inplacesite, &InPlaceSiteWindowless);
2230
2231             hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobj);
2232             ok(hres == S_OK, "Could not get IOleInPlaceActiveObject: %08x\n", hres);
2233
2234             if(activeobj) {
2235                 HWND hwnd = (void*)0xdeadbeef;
2236                 hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
2237                 ok(hres == E_FAIL, "GetWindow returned %08x, expected E_FAIL\n", hres);
2238                 ok(hwnd == NULL, "hwnd=%p, expected NULL\n", hwnd);
2239             }
2240
2241             if(call_UIActivate == CallUIActivate_ActivateMe) {
2242                 SET_EXPECT(CanInPlaceActivate);
2243                 SET_EXPECT(GetWindowContext);
2244                 SET_EXPECT(GetWindow);
2245                 if(ipsex)
2246                     SET_EXPECT(OnInPlaceActivateEx);
2247                 else
2248                     SET_EXPECT(OnInPlaceActivate);
2249                 SET_EXPECT(SetStatusText);
2250                 SET_EXPECT(Exec_SETPROGRESSMAX);
2251                 SET_EXPECT(Exec_SETPROGRESSPOS);
2252                 SET_EXPECT(OnUIActivate);
2253                 SET_EXPECT(SetActiveObject);
2254                 SET_EXPECT(ShowUI);
2255                 expect_status_text = NULL;
2256
2257                 hres = IOleDocumentView_UIActivate(view, TRUE);
2258                 ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
2259
2260                 CHECK_CALLED(CanInPlaceActivate);
2261                 CHECK_CALLED(GetWindowContext);
2262                 CHECK_CALLED(GetWindow);
2263                 if(ipsex)
2264                     CHECK_CALLED(OnInPlaceActivateEx);
2265                 else
2266                     CHECK_CALLED(OnInPlaceActivate);
2267                 CHECK_CALLED(SetStatusText);
2268                 CHECK_CALLED(Exec_SETPROGRESSMAX);
2269                 CHECK_CALLED(Exec_SETPROGRESSPOS);
2270                 CHECK_CALLED(OnUIActivate);
2271                 CHECK_CALLED(SetActiveObject);
2272                 CHECK_CALLED(ShowUI);
2273
2274                 if(activeobj) {
2275                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &doc_hwnd);
2276                     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
2277                     ok(doc_hwnd != NULL, "hwnd == NULL\n");
2278                     if(last_hwnd)
2279                         ok(doc_hwnd == last_hwnd, "hwnd != last_hwnd\n");
2280                 }
2281
2282                 hres = IOleDocumentView_UIActivate(view, TRUE);
2283                 ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
2284
2285                 if(activeobj) {
2286                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &tmp_hwnd);
2287                     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
2288                     ok(tmp_hwnd == doc_hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, doc_hwnd);
2289                 }
2290             }
2291
2292             hres = IOleDocumentView_SetRect(view, &rect);
2293             ok(hres == S_OK, "SetRect failed: %08x\n", hres);
2294
2295             if(call_UIActivate == CallUIActivate_ActivateMe) {
2296                 hres = IOleDocumentView_Show(view, TRUE);
2297                 ok(hres == S_OK, "Show failed: %08x\n", hres);
2298             }else {
2299                 SET_EXPECT(CanInPlaceActivate);
2300                 SET_EXPECT(GetWindowContext);
2301                 SET_EXPECT(GetWindow);
2302                 if(ipsex)
2303                     SET_EXPECT(OnInPlaceActivateEx);
2304                 else
2305                     SET_EXPECT(OnInPlaceActivate);
2306                 SET_EXPECT(SetStatusText);
2307                 SET_EXPECT(Exec_SETPROGRESSMAX);
2308                 SET_EXPECT(Exec_SETPROGRESSPOS);
2309                 SET_EXPECT(OnUIActivate);
2310                 expect_status_text = (load_state == LD_COMPLETE ? (LPCOLESTR)0xdeadbeef : NULL);
2311
2312                 hres = IOleDocumentView_Show(view, TRUE);
2313                 ok(hres == S_OK, "Show failed: %08x\n", hres);
2314
2315                 CHECK_CALLED(CanInPlaceActivate);
2316                 CHECK_CALLED(GetWindowContext);
2317                 CHECK_CALLED(GetWindow);
2318                 if(ipsex)
2319                     CHECK_CALLED(OnInPlaceActivateEx);
2320                 else
2321                     CHECK_CALLED(OnInPlaceActivate);
2322                 CHECK_CALLED(SetStatusText);
2323                 CHECK_CALLED(Exec_SETPROGRESSMAX);
2324                 CHECK_CALLED(Exec_SETPROGRESSPOS);
2325
2326                 if(activeobj) {
2327                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &doc_hwnd);
2328                     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
2329                     ok(doc_hwnd != NULL, "doc_hwnd == NULL\n");
2330                     if(last_hwnd)
2331                         ok(doc_hwnd == last_hwnd, "doc_hwnd != last_hwnd\n");
2332                 }
2333             }
2334
2335             test_timer(EXPECT_UPDATEUI | ((load_state == LD_LOADING) ? EXPECT_SETTITLE : 0));
2336
2337             if(activeobj)
2338                 IOleInPlaceActiveObject_Release(activeobj);
2339         }
2340
2341         IOleDocument_Release(document);
2342     }
2343
2344     return S_OK;
2345 }
2346
2347 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
2348     DocumentSite_QueryInterface,
2349     DocumentSite_AddRef,
2350     DocumentSite_Release,
2351     DocumentSite_ActivateMe
2352 };
2353
2354 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
2355
2356 static HRESULT WINAPI OleControlSite_QueryInterface(IOleControlSite *iface, REFIID riid, void **ppv)
2357 {
2358     return QueryInterface(riid, ppv);
2359 }
2360
2361 static ULONG WINAPI OleControlSite_AddRef(IOleControlSite *iface)
2362 {
2363     return 2;
2364 }
2365
2366 static ULONG WINAPI OleControlSite_Release(IOleControlSite *iface)
2367 {
2368     return 1;
2369 }
2370
2371 static HRESULT WINAPI OleControlSite_OnControlInfoChanged(IOleControlSite *iface)
2372 {
2373     ok(0, "unexpected call\n");
2374     return E_NOTIMPL;
2375 }
2376
2377 static HRESULT WINAPI OleControlSite_LockInPlaceActive(IOleControlSite *iface, BOOL fLock)
2378 {
2379     ok(0, "unexpected call\n");
2380     return E_NOTIMPL;
2381 }
2382
2383 static HRESULT WINAPI OleControlSite_GetExtendedControl(IOleControlSite *iface, IDispatch **ppDisp)
2384 {
2385     ok(0, "unexpected call\n");
2386     return E_NOTIMPL;
2387 }
2388
2389 static HRESULT WINAPI OleControlSite_TransformCoords(IOleControlSite *iface, POINTL *pPtHimetric,
2390         POINTF *pPtfContainer, DWORD dwFlags)
2391 {
2392     ok(0, "unexpected call\n");
2393     return E_NOTIMPL;
2394 }
2395
2396 static HRESULT WINAPI OleControlSite_TranslateAccelerator(IOleControlSite *iface,
2397         MSG *pMsg, DWORD grfModifiers)
2398 {
2399     ok(0, "unexpected call\n");
2400     return E_NOTIMPL;
2401 }
2402
2403 static HRESULT WINAPI OleControlSite_OnFocus(IOleControlSite *iface, BOOL fGotFocus)
2404 {
2405     if(fGotFocus)
2406         CHECK_EXPECT(OnFocus_TRUE);
2407     else
2408         CHECK_EXPECT2(OnFocus_FALSE);
2409     return S_OK;
2410 }
2411
2412 static HRESULT WINAPI OleControlSite_ShowPropertyFrame(IOleControlSite *iface)
2413 {
2414     ok(0, "unexpected call\n");
2415     return E_NOTIMPL;
2416 }
2417
2418 static const IOleControlSiteVtbl OleControlSiteVtbl = {
2419     OleControlSite_QueryInterface,
2420     OleControlSite_AddRef,
2421     OleControlSite_Release,
2422     OleControlSite_OnControlInfoChanged,
2423     OleControlSite_LockInPlaceActive,
2424     OleControlSite_GetExtendedControl,
2425     OleControlSite_TransformCoords,
2426     OleControlSite_TranslateAccelerator,
2427     OleControlSite_OnFocus,
2428     OleControlSite_ShowPropertyFrame
2429 };
2430
2431 static IOleControlSite OleControlSite = { &OleControlSiteVtbl };
2432
2433 static IDocHostUIHandler2 *expect_uihandler_iface;
2434
2435 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
2436 {
2437     return QueryInterface(riid, ppv);
2438 }
2439
2440 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
2441 {
2442     return 2;
2443 }
2444
2445 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
2446 {
2447     return 1;
2448 }
2449
2450 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
2451         IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
2452 {
2453     ok(0, "unexpected call\n");
2454     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2455     return E_NOTIMPL;
2456 }
2457
2458 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
2459 {
2460     CHECK_EXPECT(GetHostInfo);
2461     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2462     ok(pInfo != NULL, "pInfo=NULL\n");
2463     if(pInfo) {
2464         ok(pInfo->cbSize == sizeof(DOCHOSTUIINFO), "pInfo->cbSize=%u\n", pInfo->cbSize);
2465         ok(!pInfo->dwFlags, "pInfo->dwFlags=%08x, expected 0\n", pInfo->dwFlags);
2466         pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE
2467             | DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION
2468             | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION;
2469         ok(!pInfo->dwDoubleClick, "pInfo->dwDoubleClick=%08x, expected 0\n", pInfo->dwDoubleClick);
2470         ok(!pInfo->pchHostCss, "pInfo->pchHostCss=%p, expected NULL\n", pInfo->pchHostCss);
2471         ok(!pInfo->pchHostNS, "pInfo->pchhostNS=%p, expected NULL\n", pInfo->pchHostNS);
2472     }
2473     return S_OK;
2474 }
2475
2476 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
2477         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
2478         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
2479 {
2480     CHECK_EXPECT(ShowUI);
2481     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2482
2483     if (editmode)
2484         ok(dwID == DOCHOSTUITYPE_AUTHOR, "dwID=%d, expected DOCHOSTUITYPE_AUTHOR\n", dwID);
2485     else
2486         ok(dwID == DOCHOSTUITYPE_BROWSE, "dwID=%d, expected DOCHOSTUITYPE_BROWSE\n", dwID);
2487     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
2488     ok(pCommandTarget != NULL, "pCommandTarget = NULL\n");
2489     ok(pFrame == &InPlaceFrame, "pFrame=%p, expected %p\n", pFrame, &InPlaceFrame);
2490     if (expect_InPlaceUIWindow_SetActiveObject_active)
2491         ok(pDoc == (IOleInPlaceUIWindow *)&InPlaceUIWindow, "pDoc=%p, expected %p\n", pDoc, &InPlaceUIWindow);
2492     else
2493         ok(pDoc == NULL, "pDoc=%p, expected NULL\n", pDoc);
2494
2495     return S_OK;
2496 }
2497
2498 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
2499 {
2500     CHECK_EXPECT(HideUI);
2501     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2502     return S_OK;
2503 }
2504
2505 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
2506 {
2507     CHECK_EXPECT(UpdateUI);
2508     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2509     return S_OK;
2510 }
2511
2512 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
2513 {
2514     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2515     if(fEnable)
2516         CHECK_EXPECT2(EnableModeless_TRUE);
2517     else
2518         CHECK_EXPECT2(EnableModeless_FALSE);
2519     return E_NOTIMPL;
2520 }
2521
2522 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
2523 {
2524     ok(0, "unexpected call\n");
2525     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2526     return E_NOTIMPL;
2527 }
2528
2529 static BOOL expect_OnFrameWindowActivate_fActivate;
2530 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
2531 {
2532     CHECK_EXPECT2(OnFrameWindowActivate);
2533     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2534     ok(fActivate == expect_OnFrameWindowActivate_fActivate, "fActivate=%x\n", fActivate);
2535     return S_OK;
2536 }
2537
2538 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
2539         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
2540 {
2541     ok(0, "unexpected call\n");
2542     return E_NOTIMPL;
2543 }
2544
2545 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
2546         const GUID *pguidCmdGroup, DWORD nCmdID)
2547 {
2548     ok(0, "unexpected call\n");
2549     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2550     return E_NOTIMPL;
2551 }
2552
2553 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
2554         LPOLESTR *pchKey, DWORD dw)
2555 {
2556     CHECK_EXPECT(GetOptionKeyPath);
2557     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2558     ok(pchKey != NULL, "pchKey = NULL\n");
2559     ok(!dw, "dw=%d, expected 0\n", dw);
2560     if(pchKey)
2561         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
2562     return S_OK;
2563 }
2564
2565 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
2566         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
2567 {
2568     CHECK_EXPECT(GetDropTarget);
2569     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2570     /* TODO */
2571     return E_NOTIMPL;
2572 }
2573
2574 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
2575 {
2576     CHECK_EXPECT(GetExternal);
2577     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2578     *ppDispatch = &External;
2579     return S_FALSE;
2580 }
2581
2582 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
2583         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
2584 {
2585     CHECK_EXPECT(TranslateUrl);
2586     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2587     ok(!dwTranslate, "dwTranslate = %x\n", dwTranslate);
2588     if(!loading_hash)
2589         ok(!strcmp_wa(pchURLIn, nav_serv_url), "pchURLIn = %s, expected %s\n", wine_dbgstr_w(pchURLIn), nav_serv_url);
2590     else
2591         todo_wine ok(!strcmp_wa(pchURLIn, nav_serv_url), "pchURLIn = %s, expected %s\n", wine_dbgstr_w(pchURLIn), nav_serv_url);
2592     ok(ppchURLOut != NULL, "ppchURLOut == NULL\n");
2593     ok(!*ppchURLOut, "*ppchURLOut = %p\n", *ppchURLOut);
2594
2595     return S_FALSE;
2596 }
2597
2598 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
2599         IDataObject **ppPORet)
2600 {
2601     ok(0, "unexpected call\n");
2602     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2603     return E_NOTIMPL;
2604 }
2605
2606 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
2607         LPOLESTR *pchKey, DWORD dw)
2608 {
2609     CHECK_EXPECT(GetOverrideKeyPath);
2610     ok(iface == expect_uihandler_iface, "called on unexpected iface\n");
2611     ok(pchKey != NULL, "pchKey = NULL\n");
2612     if(pchKey)
2613         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
2614     ok(!dw, "dw=%d, xepected 0\n", dw);
2615     return S_OK;
2616 }
2617
2618 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
2619     DocHostUIHandler_QueryInterface,
2620     DocHostUIHandler_AddRef,
2621     DocHostUIHandler_Release,
2622     DocHostUIHandler_ShowContextMenu,
2623     DocHostUIHandler_GetHostInfo,
2624     DocHostUIHandler_ShowUI,
2625     DocHostUIHandler_HideUI,
2626     DocHostUIHandler_UpdateUI,
2627     DocHostUIHandler_EnableModeless,
2628     DocHostUIHandler_OnDocWindowActivate,
2629     DocHostUIHandler_OnFrameWindowActivate,
2630     DocHostUIHandler_ResizeBorder,
2631     DocHostUIHandler_TranslateAccelerator,
2632     DocHostUIHandler_GetOptionKeyPath,
2633     DocHostUIHandler_GetDropTarget,
2634     DocHostUIHandler_GetExternal,
2635     DocHostUIHandler_TranslateUrl,
2636     DocHostUIHandler_FilterDataObject,
2637     DocHostUIHandler_GetOverrideKeyPath
2638 };
2639
2640 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
2641
2642 static HRESULT WINAPI CustomDocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
2643 {
2644     if(IsEqualGUID(&IID_IDocHostUIHandler2, riid)) {
2645         *ppv = iface;
2646         return S_OK;
2647     }
2648
2649     if(IsEqualGUID(&IID_IOleCommandTarget, riid))
2650         return E_NOINTERFACE;
2651
2652     else if(IsEqualGUID(&IID_IDocHostShowUI, riid))
2653         return E_NOINTERFACE; /* TODO */
2654
2655     ok(0, "unexpected call %s\n", debugstr_guid(riid));
2656     return E_NOINTERFACE;
2657 }
2658
2659 static const IDocHostUIHandler2Vtbl CustomDocHostUIHandlerVtbl = {
2660     CustomDocHostUIHandler_QueryInterface,
2661     DocHostUIHandler_AddRef,
2662     DocHostUIHandler_Release,
2663     DocHostUIHandler_ShowContextMenu,
2664     DocHostUIHandler_GetHostInfo,
2665     DocHostUIHandler_ShowUI,
2666     DocHostUIHandler_HideUI,
2667     DocHostUIHandler_UpdateUI,
2668     DocHostUIHandler_EnableModeless,
2669     DocHostUIHandler_OnDocWindowActivate,
2670     DocHostUIHandler_OnFrameWindowActivate,
2671     DocHostUIHandler_ResizeBorder,
2672     DocHostUIHandler_TranslateAccelerator,
2673     DocHostUIHandler_GetOptionKeyPath,
2674     DocHostUIHandler_GetDropTarget,
2675     DocHostUIHandler_GetExternal,
2676     DocHostUIHandler_TranslateUrl,
2677     DocHostUIHandler_FilterDataObject,
2678     DocHostUIHandler_GetOverrideKeyPath
2679 };
2680
2681 static IDocHostUIHandler2 CustomDocHostUIHandler = { &CustomDocHostUIHandlerVtbl };
2682
2683 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface,
2684         REFIID riid, void **ppv)
2685 {
2686     return QueryInterface(riid, ppv);
2687 }
2688
2689 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
2690 {
2691     return 2;
2692 }
2693
2694 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
2695 {
2696     return 1;
2697 }
2698
2699 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
2700         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
2701 {
2702     ok(!pguidCmdGroup, "pguidCmdGroup != MULL\n");
2703     ok(cCmds == 1, "cCmds=%d, expected 1\n", cCmds);
2704     ok(!pCmdText, "pCmdText != NULL\n");
2705
2706     switch(prgCmds[0].cmdID) {
2707     case OLECMDID_SETPROGRESSTEXT:
2708         CHECK_EXPECT(QueryStatus_SETPROGRESSTEXT);
2709         prgCmds[0].cmdf = OLECMDF_ENABLED;
2710         return S_OK;
2711     case OLECMDID_OPEN:
2712         CHECK_EXPECT(QueryStatus_OPEN);
2713         prgCmds[0].cmdf = 0;
2714         return S_OK;
2715     case OLECMDID_NEW:
2716         CHECK_EXPECT(QueryStatus_NEW);
2717         prgCmds[0].cmdf = 0;
2718         return S_OK;
2719     default:
2720         ok(0, "unexpected command %d\n", prgCmds[0].cmdID);
2721     };
2722
2723     return E_FAIL;
2724 }
2725
2726 static void test_save_history(IUnknown *unk)
2727 {
2728     IPersistHistory *per_hist;
2729     LARGE_INTEGER li;
2730     IStream *stream;
2731     HRESULT hres;
2732
2733     hres = IUnknown_QueryInterface(unk, &IID_IPersistHistory, (void**)&per_hist);
2734     ok(hres == S_OK, "Could not get IPersistHistory iface: %08x\n", hres);
2735
2736     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2737     ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
2738
2739     hres = IPersistHistory_SaveHistory(per_hist, stream);
2740     ok(hres == S_OK, "SaveHistory failed: %08x\n", hres);
2741     IPersistHistory_Release(per_hist);
2742
2743     li.QuadPart = 0;
2744     hres = IStream_Seek(stream, li, STREAM_SEEK_SET, NULL);
2745     ok(hres == S_OK, "Stat failed: %08x\n", hres);
2746     history_stream = stream;
2747 }
2748
2749 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
2750         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
2751 {
2752     if(!pguidCmdGroup) {
2753         test_readyState(NULL);
2754
2755         switch(nCmdID) {
2756         case OLECMDID_SETPROGRESSMAX:
2757             CHECK_EXPECT2(Exec_SETPROGRESSMAX);
2758             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2759             ok(pvaIn != NULL, "pvaIn == NULL\n");
2760             if(pvaIn) {
2761                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
2762                 if(load_state == LD_NO)
2763                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%d, expected 0\n", V_I4(pvaIn));
2764             }
2765             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
2766             return S_OK;
2767         case OLECMDID_SETPROGRESSPOS:
2768             CHECK_EXPECT2(Exec_SETPROGRESSPOS);
2769             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2770             ok(pvaIn != NULL, "pvaIn == NULL\n");
2771             if(pvaIn) {
2772                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
2773                 if(load_state == LD_NO)
2774                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%d, expected 0\n", V_I4(pvaIn));
2775             }
2776             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
2777             return S_OK;
2778         case OLECMDID_HTTPEQUIV_DONE:
2779             CHECK_EXPECT(Exec_HTTPEQUIV_DONE);
2780             ok(nCmdexecopt == 0, "nCmdexecopts=%08x\n", nCmdexecopt);
2781             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2782             ok(pvaIn == NULL, "pvaIn=%p\n", pvaIn);
2783             readystate_set_loading = FALSE;
2784             readystate_set_interactive = FALSE;
2785             load_state = LD_COMPLETE;
2786             return S_OK;
2787         case OLECMDID_SETDOWNLOADSTATE:
2788             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2789             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2790             ok(pvaIn != NULL, "pvaIn == NULL\n");
2791             ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d\n", V_VT(pvaIn));
2792
2793             switch(V_I4(pvaIn)) {
2794             case 0:
2795                 CHECK_EXPECT(Exec_SETDOWNLOADSTATE_0);
2796                 if(!loading_js)
2797                     load_state = LD_INTERACTIVE;
2798                 break;
2799             case 1:
2800                 CHECK_EXPECT(Exec_SETDOWNLOADSTATE_1);
2801                 readystate_set_interactive = (load_state != LD_INTERACTIVE);
2802                 break;
2803             default:
2804                 ok(0, "unexpevted V_I4(pvaIn)=%d\n", V_I4(pvaIn));
2805             }
2806
2807             return S_OK;
2808         case OLECMDID_UPDATECOMMANDS:
2809             CHECK_EXPECT(Exec_UPDATECOMMANDS);
2810             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2811             ok(pvaIn == NULL, "pvaIn=%p\n", pvaIn);
2812             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2813             return S_OK;
2814         case OLECMDID_SETTITLE:
2815             CHECK_EXPECT2(Exec_SETTITLE);
2816             ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08x\n", nCmdexecopt);
2817             ok(pvaIn != NULL, "pvaIn == NULL\n");
2818             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2819             ok(V_VT(pvaIn) == VT_BSTR, "V_VT(pvaIn)=%d\n", V_VT(pvaIn));
2820             ok(V_BSTR(pvaIn) != NULL, "V_BSTR(pvaIn) == NULL\n"); /* TODO */
2821             return S_OK;
2822         case OLECMDID_HTTPEQUIV:
2823             CHECK_EXPECT2(Exec_HTTPEQUIV);
2824             ok(!nCmdexecopt, "nCmdexecopts=%08x\n", nCmdexecopt);
2825             ok(pvaIn != NULL, "pvaIn == NULL\n");
2826             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
2827             ok(V_VT(pvaIn) == VT_BSTR, "V_VT(pvaIn)=%d\n", V_VT(pvaIn));
2828             ok(V_BSTR(pvaIn) != NULL, "V_BSTR(pvaIn) = NULL\n");
2829             test_readyState(NULL);
2830             return S_OK;
2831         case OLECMDID_UPDATETRAVELENTRY_DATARECOVERY:
2832         case 6058:
2833             return E_FAIL; /* FIXME */
2834         default:
2835             ok(0, "unexpected command %d\n", nCmdID);
2836             return E_FAIL;
2837         };
2838     }
2839
2840     if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
2841         if(nCmdID != 63 && (!is_refresh || nCmdID != 37))
2842             test_readyState(NULL);
2843         ok(nCmdexecopt == 0, "nCmdexecopts=%08x\n", nCmdexecopt);
2844
2845         switch(nCmdID) {
2846         case 37:
2847             CHECK_EXPECT2(Exec_ShellDocView_37);
2848
2849             if(is_refresh && load_state == LD_COMPLETE) {
2850                 load_state = LD_DOLOAD;
2851                 test_readyState(NULL);
2852             }else if(is_refresh && load_state == LD_DOLOAD) {
2853                 test_readyState(NULL);
2854                 load_state = LD_LOADING;
2855             }else {
2856                 if(nav_url)
2857                     test_GetCurMoniker(doc_unk, NULL, nav_serv_url);
2858                 else if(load_from_stream)
2859                     test_GetCurMoniker(doc_unk, NULL, "about:blank");
2860                 else if(!editmode)
2861                     test_GetCurMoniker(doc_unk, doc_mon, NULL);
2862             }
2863
2864             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
2865             ok(pvaIn != NULL, "pvaIn == NULL\n");
2866             if(pvaIn) {
2867                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
2868                 ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%d, expected 0\n", V_I4(pvaIn));
2869             }
2870             return S_OK;
2871
2872         case 63: {
2873             IHTMLPrivateWindow *priv_window;
2874             HRESULT hres;
2875
2876             CHECK_EXPECT(Exec_ShellDocView_63);
2877             ok(pvaIn != NULL, "pvaIn == NULL\n");
2878             ok(V_VT(pvaIn) == VT_UNKNOWN, "V_VT(pvaIn) = %d\n", V_VT(pvaIn));
2879             ok(V_UNKNOWN(pvaIn) != NULL, "VPUNKNOWN(pvaIn) = NULL\n");
2880             ok(pvaOut != NULL, "pvaOut == NULL\n");
2881             ok(V_VT(pvaOut) == VT_EMPTY, "V_VT(pvaOut) = %d\n", V_VT(pvaOut));
2882
2883             hres = IUnknown_QueryInterface(V_UNKNOWN(pvaIn), &IID_IHTMLPrivateWindow, (void**)&priv_window);
2884             ok(hres == S_OK, "Could not get IHTMLPrivateWindow: %08x\n", hres);
2885             if(SUCCEEDED(hres))
2886                 IHTMLPrivateWindow_Release(priv_window);
2887
2888             load_state = loading_js ? LD_COMPLETE : LD_LOADING;
2889             return S_OK; /* TODO */
2890         }
2891
2892         case 67:
2893             CHECK_EXPECT(Exec_ShellDocView_67);
2894             ok(pvaIn != NULL, "pvaIn == NULL\n");
2895             ok(V_VT(pvaIn) == VT_BSTR, "V_VT(pvaIn) = %d\n", V_VT(pvaIn));
2896             ok(!strcmp_wa(V_BSTR(pvaIn), nav_serv_url), "V_BSTR(pvaIn) = %s, expected \"%s\"\n",
2897                wine_dbgstr_w(V_BSTR(pvaIn)), nav_serv_url);
2898             ok(pvaOut != NULL, "pvaOut == NULL\n");
2899             ok(V_VT(pvaOut) == VT_BOOL, "V_VT(pvaOut) = %d\n", V_VT(pvaOut));
2900             ok(V_BOOL(pvaOut) == VARIANT_TRUE, "V_BOOL(pvaOut) = %x\n", V_BOOL(pvaOut));
2901             if(!loading_hash)
2902                 load_state = LD_DOLOAD;
2903             return S_OK;
2904
2905         case 84:
2906             CHECK_EXPECT2(Exec_ShellDocView_84);
2907
2908             ok(pvaIn == NULL, "pvaIn != NULL\n");
2909             ok(pvaOut != NULL, "pvaOut == NULL\n");
2910             if(pvaIn)
2911                 ok(V_VT(pvaOut) == VT_EMPTY, "V_VT(pvaOut)=%d\n", V_VT(pvaOut));
2912
2913             return E_NOTIMPL;
2914
2915         case 103:
2916             CHECK_EXPECT2(Exec_ShellDocView_103);
2917
2918             ok(pvaIn == NULL, "pvaIn != NULL\n");
2919             ok(pvaOut == NULL, "pvaOut != NULL\n");
2920
2921             return E_NOTIMPL;
2922
2923         case 105:
2924             CHECK_EXPECT2(Exec_ShellDocView_105);
2925
2926             ok(pvaIn != NULL, "pvaIn == NULL\n");
2927             ok(pvaOut == NULL, "pvaOut != NULL\n");
2928
2929             return E_NOTIMPL;
2930
2931         case 138:
2932             CHECK_EXPECT2(Exec_ShellDocView_138);
2933             ok(!pvaIn, "pvaIn != NULL\n");
2934             ok(!pvaOut, "pvaOut != NULL\n");
2935             return S_OK;
2936
2937         case 140:
2938             CHECK_EXPECT2(Exec_ShellDocView_140);
2939
2940             ok(pvaIn == NULL, "pvaIn != NULL\n");
2941             ok(pvaOut == NULL, "pvaOut != NULL\n");
2942
2943             return E_NOTIMPL;
2944
2945         case 134: /* TODO */
2946         case 136: /* TODO */
2947         case 139: /* TODO */
2948         case 143: /* TODO */
2949         case 144: /* TODO */
2950             return E_NOTIMPL;
2951
2952         default:
2953             ok(0, "unexpected command %d\n", nCmdID);
2954             return E_FAIL;
2955         };
2956     }
2957
2958     if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
2959         test_readyState(NULL);
2960         ok(nCmdexecopt == 0, "nCmdexecopts=%08x\n", nCmdexecopt);
2961
2962         switch(nCmdID) {
2963         case IDM_PARSECOMPLETE:
2964             CHECK_EXPECT(Exec_MSHTML_PARSECOMPLETE);
2965             ok(pvaIn == NULL, "pvaIn != NULL\n");
2966             ok(pvaOut == NULL, "pvaOut != NULL\n");
2967             return S_OK;
2968         default:
2969             ok(0, "unexpected command %d\n", nCmdID);
2970         };
2971     }
2972
2973     if(IsEqualGUID(&CGID_DocHostCmdPriv, pguidCmdGroup)) {
2974         switch(nCmdID) {
2975         case DOCHOST_DOCCANNAVIGATE:
2976             CHECK_EXPECT(Exec_DOCCANNAVIGATE);
2977
2978             test_readyState(NULL);
2979
2980             ok(pvaIn != NULL, "pvaIn == NULL\n");
2981             ok(pvaOut == NULL, "pvaOut != NULL\n");
2982             ok(V_VT(pvaIn) == VT_UNKNOWN, "V_VT(pvaIn) != VT_UNKNOWN\n");
2983             /* FIXME: test V_UNKNOWN(pvaIn) == window */
2984             return S_OK;
2985         case 1: {
2986             SAFEARRAY *sa;
2987             UINT dim;
2988             LONG ind=0;
2989             VARIANT var;
2990             HRESULT hres;
2991
2992             test_readyState(NULL);
2993
2994             ok(pvaIn != NULL, "pvaIn == NULL\n");
2995             ok(pvaOut != NULL || broken(!pvaOut), "pvaOut != NULL\n");
2996             ok(V_VT(pvaIn) == VT_ARRAY, "V_VT(pvaIn) = %d\n", V_VT(pvaIn));
2997             if(pvaOut)
2998                 ok(V_VT(pvaOut) == VT_BOOL, "V_VT(pvaOut) = %d\n", V_VT(pvaOut));
2999             sa = V_ARRAY(pvaIn);
3000
3001             dim = SafeArrayGetDim(sa);
3002             ok(dim == 1, "dim = %d\n", dim);
3003             hres = SafeArrayGetLBound(sa, 1, &ind);
3004             ok(hres == S_OK, "SafeArrayGetLBound failed: %x\n", hres);
3005             ok(ind == 0, "Lower bound = %d\n", ind);
3006             hres = SafeArrayGetUBound(sa, 1, &ind);
3007             ok(hres == S_OK, "SafeArrayGetUBound failed: %x\n", hres);
3008             ok(ind == 7 || broken(ind == 5), "Upper bound = %d\n", ind);
3009
3010             ind = 0;
3011             SafeArrayGetElement(sa, &ind, &var);
3012             ok(V_VT(&var) == VT_I4, "Incorrect data type: %d\n", V_VT(&var));
3013             ok(V_I4(&var) == status_code, "Incorrect error code: %d\n", V_I4(&var));
3014             VariantClear(&var);
3015             ind = 1;
3016             SafeArrayGetElement(sa, &ind, &var);
3017             ok(V_VT(&var) == VT_BSTR, "Incorrect data type: %d\n", V_VT(&var));
3018             ok(!strcmp_wa(V_BSTR(&var), "winetest:doc"), "Page address: %s\n", wine_dbgstr_w(V_BSTR(&var)));
3019             VariantClear(&var);
3020             ind = 2;
3021             SafeArrayGetElement(sa, &ind, &var);
3022             ok(V_VT(&var) == VT_UNKNOWN, "Incorrect data type: %d\n", V_VT(&var));
3023             VariantClear(&var);
3024             ind = 3;
3025             SafeArrayGetElement(sa, &ind, &var);
3026             ok(V_VT(&var) == VT_UNKNOWN, "Incorrect data type: %d\n", V_VT(&var));
3027             VariantClear(&var);
3028             ind = 4;
3029             SafeArrayGetElement(sa, &ind, &var);
3030             ok(V_VT(&var) == VT_BOOL, "Incorrect data type: %d\n", V_VT(&var));
3031             ok(!V_BOOL(&var), "Unknown value is incorrect\n");
3032             VariantClear(&var);
3033             ind = 5;
3034             SafeArrayGetElement(sa, &ind, &var);
3035             ok(V_VT(&var) == VT_BOOL, "Incorrect data type: %d\n", V_VT(&var));
3036             ok(!V_BOOL(&var), "Unknown value is incorrect\n");
3037             VariantClear(&var);
3038         }
3039         default:
3040             return E_FAIL; /* TODO */
3041         }
3042     }
3043
3044     if(IsEqualGUID(&CGID_Explorer, pguidCmdGroup)) {
3045         test_readyState(NULL);
3046         ok(nCmdexecopt == 0, "nCmdexecopts=%08x\n", nCmdexecopt);
3047
3048         switch(nCmdID) {
3049         case 38:
3050             CHECK_EXPECT2(Exec_Explorer_38);
3051             ok(pvaIn != NULL, "pvaIn == NULL\n");
3052             ok(V_VT(pvaIn) == VT_I4 , "V_VT(pvaIn) = %d\n", V_VT(pvaIn));
3053             ok(!V_I4(pvaIn), "V_I4(pvaIn) = %d\n", V_I4(pvaIn));
3054             ok(!pvaOut, "pvaOut != NULL\n");
3055
3056             test_current_url(doc_unk, prev_url);
3057             if(!history_stream)
3058                 test_save_history(doc_unk);
3059
3060             return S_OK;
3061         case 69:
3062             CHECK_EXPECT2(Exec_Explorer_69);
3063             ok(pvaIn == NULL, "pvaIn != NULL\n");
3064             ok(pvaOut != NULL, "pvaOut == NULL\n");
3065             return E_NOTIMPL;
3066         case 109: /* TODO */
3067             return E_NOTIMPL;
3068         default:
3069             ok(0, "unexpected cmd %d of CGID_Explorer\n", nCmdID);
3070         }
3071         return E_NOTIMPL;
3072     }
3073
3074     if(IsEqualGUID(&CGID_DocHostCommandHandler, pguidCmdGroup)) {
3075         test_readyState(NULL);
3076
3077         switch (nCmdID) {
3078         case OLECMDID_PAGEACTIONBLOCKED: /* win2k3 */
3079             SET_EXPECT(SetStatusText);
3080             ok(pvaIn == NULL, "pvaIn != NULL\n");
3081             ok(pvaOut == NULL, "pvaOut != NULL\n");
3082             return S_OK;
3083         case OLECMDID_SHOWSCRIPTERROR:
3084             /* TODO */
3085             return S_OK;
3086         case 2300:
3087             CHECK_EXPECT(Exec_DocHostCommandHandler_2300);
3088             return E_NOTIMPL;
3089         default:
3090             ok(0, "unexpected command %d\n", nCmdID);
3091             return E_FAIL;
3092         }
3093     }
3094
3095     ok(0, "unexpected pguidCmdGroup: %s\n", debugstr_guid(pguidCmdGroup));
3096     return E_NOTIMPL;
3097 }
3098
3099 static IOleCommandTargetVtbl OleCommandTargetVtbl = {
3100     OleCommandTarget_QueryInterface,
3101     OleCommandTarget_AddRef,
3102     OleCommandTarget_Release,
3103     OleCommandTarget_QueryStatus,
3104     OleCommandTarget_Exec
3105 };
3106
3107 static IOleCommandTarget OleCommandTarget = { &OleCommandTargetVtbl };
3108
3109 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
3110 {
3111     return QueryInterface(riid, ppv);
3112 }
3113
3114 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
3115         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
3116         EXCEPINFO *pExcepInfo, UINT *puArgErr)
3117 {
3118     ok(IsEqualGUID(&IID_NULL, riid), "riid != IID_NULL\n");
3119     ok(pDispParams != NULL, "pDispParams == NULL\n");
3120     ok(pExcepInfo == NULL, "pExcepInfo=%p, expected NULL\n", pExcepInfo);
3121     ok(puArgErr != NULL, "puArgErr == NULL\n");
3122     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult)=%d, expected 0\n", V_VT(pVarResult));
3123     ok(wFlags == DISPATCH_PROPERTYGET, "wFlags=%08x, expected DISPATCH_PROPERTYGET\n", wFlags);
3124     test_readyState(NULL);
3125
3126     switch(dispIdMember) {
3127     case DISPID_AMBIENT_USERMODE:
3128         CHECK_EXPECT2(Invoke_AMBIENT_USERMODE);
3129         V_VT(pVarResult) = VT_BOOL;
3130         V_BOOL(pVarResult) = VARIANT_TRUE;
3131         return S_OK;
3132     case DISPID_AMBIENT_DLCONTROL:
3133         CHECK_EXPECT2(Invoke_AMBIENT_DLCONTROL);
3134         return E_FAIL;
3135     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
3136         CHECK_EXPECT2(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
3137         return E_FAIL;
3138     case DISPID_AMBIENT_SILENT:
3139         CHECK_EXPECT2(Invoke_AMBIENT_SILENT);
3140         V_VT(pVarResult) = VT_BOOL;
3141         V_BOOL(pVarResult) = VARIANT_FALSE;
3142         return S_OK;
3143     case DISPID_AMBIENT_USERAGENT:
3144         CHECK_EXPECT(Invoke_AMBIENT_USERAGENT);
3145         return E_FAIL;
3146     case DISPID_AMBIENT_PALETTE:
3147         CHECK_EXPECT(Invoke_AMBIENT_PALETTE);
3148         return E_FAIL;
3149     };
3150
3151     ok(0, "unexpected dispid %d\n", dispIdMember);
3152     return E_FAIL;
3153 }
3154
3155 static const IDispatchVtbl DispatchVtbl = {
3156     Dispatch_QueryInterface,
3157     Dispatch_AddRef,
3158     Dispatch_Release,
3159     Dispatch_GetTypeInfoCount,
3160     Dispatch_GetTypeInfo,
3161     Dispatch_GetIDsOfNames,
3162     Dispatch_Invoke
3163 };
3164
3165 static IDispatch Dispatch = { &DispatchVtbl };
3166
3167 static HRESULT WINAPI EventDispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
3168 {
3169     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
3170         *ppv = iface;
3171         return S_OK;
3172     }
3173
3174     ok(0, "Unexpected call\n");
3175     return E_NOINTERFACE;
3176 }
3177
3178 static HRESULT WINAPI EventDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
3179         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
3180         EXCEPINFO *pExcepInfo, UINT *puArgErr)
3181 {
3182     HRESULT hres;
3183     IHTMLDocument2 *doc;
3184     BSTR state;
3185
3186     ok(IsEqualGUID(&IID_NULL, riid), "riid = %s\n", debugstr_guid(riid));
3187     ok(pDispParams != NULL, "pDispParams == NULL\n");
3188     ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
3189     ok(puArgErr != NULL, "puArgErr == NULL\n");
3190     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult) = %d\n", V_VT(pVarResult));
3191     ok(wFlags == DISPATCH_METHOD, "wFlags = %d, expected DISPATCH_METHOD\n", wFlags);
3192
3193     hres = IUnknown_QueryInterface(doc_unk, &IID_IHTMLDocument2, (void**)&doc);
3194     ok(hres == S_OK, "QueryInterface(IID_IHTMLDocument2) failed: %08x\n", hres);
3195
3196     switch(dispIdMember) {
3197     case DISPID_HTMLDOCUMENTEVENTS2_ONREADYSTATECHANGE:
3198         hres = IHTMLDocument2_get_readyState(doc, &state);
3199         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
3200
3201         if(!strcmp_wa(state, "interactive"))
3202             CHECK_EXPECT(Invoke_OnReadyStateChange_Interactive);
3203         else if(!strcmp_wa(state, "loading"))
3204             CHECK_EXPECT(Invoke_OnReadyStateChange_Loading);
3205         else if(!strcmp_wa(state, "complete")) {
3206             CHECK_EXPECT(Invoke_OnReadyStateChange_Complete);
3207             complete = TRUE;
3208         } else
3209             ok(0, "Unexpected readyState: %s\n", wine_dbgstr_w(state));
3210
3211         SysFreeString(state);
3212         break;
3213     case DISPID_HTMLDOCUMENTEVENTS2_ONPROPERTYCHANGE:
3214     case 1026:
3215     case 1027:
3216     case 1034:
3217     case 1035:
3218     case 1037:
3219     case 1047:
3220     case 1045:
3221     case 1044:
3222     case 1048:
3223     case 1049:
3224         break; /* FIXME: Handle these events. */
3225     default:
3226         ok(0, "Unexpected DISPID: %d\n", dispIdMember);
3227     }
3228
3229     IHTMLDocument2_Release(doc);
3230     return S_OK;
3231 }
3232
3233 static const IDispatchVtbl EventDispatchVtbl = {
3234     EventDispatch_QueryInterface,
3235     Dispatch_AddRef,
3236     Dispatch_Release,
3237     Dispatch_GetTypeInfoCount,
3238     Dispatch_GetTypeInfo,
3239     Dispatch_GetIDsOfNames,
3240     EventDispatch_Invoke
3241 };
3242
3243 static IDispatch EventDispatch = { &EventDispatchVtbl };
3244
3245 static HRESULT WINAPI TravelLog_QueryInterface(ITravelLog *iface, REFIID riid, void **ppv)
3246 {
3247     static const IID IID_IIETravelLog2 = {0xb67cefd2,0xe3f1,0x478a,{0x9b,0xfa,0xd8,0x93,0x70,0x37,0x5e,0x94}};
3248     static const IID IID_unk_travellog = {0x6afc8b7f,0xbc17,0x4a95,{0x90,0x2f,0x6f,0x5c,0xb5,0x54,0xc3,0xd8}};
3249
3250     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_ITravelLog, riid)) {
3251         *ppv = iface;
3252         return S_OK;
3253     }
3254
3255     if(!IsEqualGUID(&IID_IIETravelLog2, riid) && !IsEqualGUID(&IID_unk_travellog, riid))
3256         ok(0, "unexpected call %s\n", debugstr_guid(riid));
3257
3258     *ppv = NULL;
3259     return E_NOINTERFACE;
3260 }
3261
3262 static ULONG WINAPI TravelLog_AddRef(ITravelLog *iface)
3263 {
3264     return 2;
3265 }
3266
3267 static ULONG WINAPI TravelLog_Release(ITravelLog *iface)
3268 {
3269     return 1;
3270 }
3271
3272 static HRESULT WINAPI TravelLog_AddEntry(ITravelLog *iface, IUnknown *punk, BOOL fIsLocalAnchor)
3273 {
3274     ok(0, "unexpected call\n");
3275     return E_NOTIMPL;
3276 }
3277
3278 static HRESULT WINAPI TravelLog_UpdateEntry(ITravelLog *iface, IUnknown *punk, BOOL fIsLocalAnchor)
3279 {
3280     ok(0, "unexpected call\n");
3281     return E_NOTIMPL;
3282 }
3283
3284 static HRESULT WINAPI TravelLog_UpdateExternal(ITravelLog *iface, IUnknown *punk, IUnknown *punkHLBrowseContext)
3285 {
3286     ok(0, "unexpected call\n");
3287     return E_NOTIMPL;
3288 }
3289
3290 static HRESULT WINAPI TravelLog_Travel(ITravelLog *iface, IUnknown *punk, int iOffset)
3291 {
3292     ok(0, "unexpected call\n");
3293     return E_NOTIMPL;
3294 }
3295
3296 static HRESULT WINAPI TravelLog_GetTravelEntry(ITravelLog *iface, IUnknown *punk, int iOffset, ITravelEntry **ppte)
3297 {
3298     ok(0, "unexpected call\n");
3299     return E_NOTIMPL;
3300 }
3301
3302 static HRESULT WINAPI TravelLog_FindTravelEntry(ITravelLog *iface, IUnknown *punk, LPCITEMIDLIST pidl, ITravelEntry **ppte)
3303 {
3304     ok(0, "unexpected call\n");
3305     return E_NOTIMPL;
3306 }
3307
3308 static HRESULT WINAPI TravelLog_GetTooltipText(ITravelLog *iface, IUnknown *punk, int iOffset, int idsTemplate,
3309         LPWSTR pwzText, DWORD cchText)
3310 {
3311     ok(0, "unexpected call\n");
3312     return E_NOTIMPL;
3313 }
3314
3315 static HRESULT WINAPI TravelLog_InsertMenuEntries(ITravelLog *iface, IUnknown *punk, HMENU hmenu, int nPos,
3316         int idFirst, int idLast, DWORD dwFlags)
3317 {
3318     ok(0, "unexpected call\n");
3319     return E_NOTIMPL;
3320 }
3321
3322 static HRESULT WINAPI TravelLog_Clone(ITravelLog *iface, ITravelLog **pptl)
3323 {
3324     ok(0, "unexpected call\n");
3325     return E_NOTIMPL;
3326 }
3327
3328 static IBrowserService BrowserService;
3329 static DWORD WINAPI TravelLog_CountEntries(ITravelLog *iface, IUnknown *punk)
3330 {
3331     CHECK_EXPECT(CountEntries);
3332
3333     ok(punk == (IUnknown*)&BrowserService, "punk != &BrowserService (%p)\n", punk);
3334     return 0;
3335 }
3336
3337 static HRESULT WINAPI TravelLog_Revert(ITravelLog *iface)
3338 {
3339     ok(0, "unexpected call\n");
3340     return E_NOTIMPL;
3341 }
3342
3343 static const ITravelLogVtbl TravelLogVtbl = {
3344     TravelLog_QueryInterface,
3345     TravelLog_AddRef,
3346     TravelLog_Release,
3347     TravelLog_AddEntry,
3348     TravelLog_UpdateEntry,
3349     TravelLog_UpdateExternal,
3350     TravelLog_Travel,
3351     TravelLog_GetTravelEntry,
3352     TravelLog_FindTravelEntry,
3353     TravelLog_GetTooltipText,
3354     TravelLog_InsertMenuEntries,
3355     TravelLog_Clone,
3356     TravelLog_CountEntries,
3357     TravelLog_Revert
3358 };
3359
3360 static ITravelLog TravelLog = { &TravelLogVtbl };
3361
3362 static HRESULT browserservice_qi(REFIID,void**);
3363
3364 static HRESULT  WINAPI DocObjectService_QueryInterface(IDocObjectService* This, REFIID riid, void **ppv)
3365 {
3366     return browserservice_qi(riid, ppv);
3367 }
3368
3369 static ULONG  WINAPI DocObjectService_AddRef(
3370         IDocObjectService* This)
3371 {
3372     return 2;
3373 }
3374
3375 static ULONG  WINAPI DocObjectService_Release(
3376         IDocObjectService* This)
3377 {
3378     return 1;
3379 }
3380
3381 static HRESULT  WINAPI DocObjectService_FireBeforeNavigate2(IDocObjectService *iface, IDispatch *pDispatch,
3382         LPCWSTR lpszUrl, DWORD dwFlags, LPCWSTR lpszFrameName, BYTE *pPostData, DWORD cbPostData,
3383         LPCWSTR lpszHeaders, BOOL fPlayNavSound, BOOL *pfCancel)
3384 {
3385     CHECK_EXPECT(FireBeforeNavigate2);
3386
3387     ok(!pDispatch, "pDispatch = %p\n", pDispatch);
3388     ok(!strcmp_wa(lpszUrl, nav_url), "lpszUrl = %s, expected %s\n", wine_dbgstr_w(lpszUrl), nav_url);
3389     ok(dwFlags == 0x40 || !dwFlags || dwFlags == 0x50, "dwFlags = %x\n", dwFlags);
3390     ok(!lpszFrameName, "lpszFrameName = %s\n", wine_dbgstr_w(lpszFrameName));
3391     ok(!pPostData, "pPostData = %p\n", pPostData);
3392     ok(!cbPostData, "cbPostData = %d\n", cbPostData);
3393     ok(!lpszHeaders, "lpszHeaders = %s\n", wine_dbgstr_w(lpszHeaders));
3394     ok(fPlayNavSound, "fPlayNavSound = %x\n", fPlayNavSound);
3395     ok(pfCancel != NULL, "pfCancel = NULL\n");
3396     ok(!*pfCancel, "*pfCancel = %x\n", *pfCancel);
3397
3398     return S_OK;
3399 }
3400
3401 static HRESULT  WINAPI DocObjectService_FireNavigateComplete2(
3402         IDocObjectService* This,
3403         IHTMLWindow2 *pHTMLWindow2,
3404         DWORD dwFlags)
3405 {
3406     CHECK_EXPECT(FireNavigateComplete2);
3407     test_readyState(NULL);
3408
3409     if(loading_hash)
3410         ok(dwFlags == 0x10 || broken(!dwFlags), "dwFlags = %x, expected 0x10\n", dwFlags);
3411     else
3412         ok(!(dwFlags &~1), "dwFlags = %x\n", dwFlags);
3413
3414     ok(pHTMLWindow2 != NULL, "pHTMLWindow2 = NULL\n");
3415
3416     return S_OK;
3417 }
3418
3419 static HRESULT  WINAPI DocObjectService_FireDownloadBegin(
3420         IDocObjectService* This)
3421 {
3422     ok(0, "unexpected call\n");
3423     return E_NOTIMPL;
3424 }
3425
3426 static HRESULT  WINAPI DocObjectService_FireDownloadComplete(
3427         IDocObjectService* This)
3428 {
3429     ok(0, "unexpected call\n");
3430     return E_NOTIMPL;
3431 }
3432
3433 static HRESULT  WINAPI DocObjectService_FireDocumentComplete(
3434         IDocObjectService* This,
3435         IHTMLWindow2 *pHTMLWindow,
3436         DWORD dwFlags)
3437 {
3438     CHECK_EXPECT(FireDocumentComplete);
3439
3440     ok(pHTMLWindow != NULL, "pHTMLWindow == NULL\n");
3441     ok(!dwFlags, "dwFlags = %x\n", dwFlags);
3442
3443     return S_OK;
3444 }
3445
3446 static HRESULT  WINAPI DocObjectService_UpdateDesktopComponent(
3447         IDocObjectService* This,
3448         IHTMLWindow2 *pHTMLWindow)
3449 {
3450     ok(0, "unexpected call\n");
3451     return E_NOTIMPL;
3452 }
3453
3454 static HRESULT  WINAPI DocObjectService_GetPendingUrl(
3455         IDocObjectService* This,
3456         BSTR *pbstrPendingUrl)
3457 {
3458     CHECK_EXPECT(GetPendingUrl);
3459     return E_NOTIMPL;
3460 }
3461
3462 static HRESULT  WINAPI DocObjectService_ActiveElementChanged(
3463         IDocObjectService* This,
3464         IHTMLElement *pHTMLElement)
3465 {
3466     CHECK_EXPECT2(ActiveElementChanged);
3467     return E_NOTIMPL;
3468 }
3469
3470 static HRESULT  WINAPI DocObjectService_GetUrlSearchComponent(
3471         IDocObjectService* This,
3472         BSTR *pbstrSearch)
3473 {
3474     ok(0, "unexpected call\n");
3475     return E_NOTIMPL;
3476 }
3477
3478 static HRESULT  WINAPI DocObjectService_IsErrorUrl(
3479         IDocObjectService* This,
3480         LPCWSTR lpszUrl,
3481         BOOL *pfIsError)
3482 {
3483     CHECK_EXPECT(IsErrorUrl);
3484     *pfIsError = FALSE;
3485     return S_OK;
3486 }
3487
3488 static IDocObjectServiceVtbl DocObjectServiceVtbl = {
3489     DocObjectService_QueryInterface,
3490     DocObjectService_AddRef,
3491     DocObjectService_Release,
3492     DocObjectService_FireBeforeNavigate2,
3493     DocObjectService_FireNavigateComplete2,
3494     DocObjectService_FireDownloadBegin,
3495     DocObjectService_FireDownloadComplete,
3496     DocObjectService_FireDocumentComplete,
3497     DocObjectService_UpdateDesktopComponent,
3498     DocObjectService_GetPendingUrl,
3499     DocObjectService_ActiveElementChanged,
3500     DocObjectService_GetUrlSearchComponent,
3501     DocObjectService_IsErrorUrl
3502 };
3503
3504 static IDocObjectService DocObjectService = { &DocObjectServiceVtbl };
3505
3506 static HRESULT WINAPI ShellBrowser_QueryInterface(IShellBrowser *iface, REFIID riid, void **ppv)
3507 {
3508     return browserservice_qi(riid, ppv);
3509 }
3510
3511 static ULONG WINAPI ShellBrowser_AddRef(IShellBrowser *iface)
3512 {
3513     return 2;
3514 }
3515
3516 static ULONG WINAPI ShellBrowser_Release(IShellBrowser *iface)
3517 {
3518     return 1;
3519 }
3520
3521 static HRESULT WINAPI ShellBrowser_GetWindow(IShellBrowser *iface, HWND *phwnd)
3522 {
3523     ok(0, "unexpected call\n");
3524     return E_NOTIMPL;
3525 }
3526
3527 static HRESULT WINAPI ShellBrowser_ContextSensitiveHelp(IShellBrowser *iface, BOOL fEnterMode)
3528 {
3529     ok(0, "unexpected call\n");
3530     return E_NOTIMPL;
3531 }
3532
3533 static HRESULT WINAPI ShellBrowser_InsertMenusSB(IShellBrowser *iface, HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
3534 {
3535     ok(0, "unexpected call\n");
3536     return E_NOTIMPL;
3537 }
3538
3539 static HRESULT WINAPI ShellBrowser_SetMenuSB(IShellBrowser *iface, HMENU hmenuShared, HOLEMENU holemenuReserved,
3540         HWND hwndActiveObject)
3541 {
3542     ok(0, "unexpected call\n");
3543     return E_NOTIMPL;
3544 }
3545
3546 static HRESULT WINAPI ShellBrowser_RemoveMenusSB(IShellBrowser *iface, HMENU hmenuShared)
3547 {
3548     ok(0, "unexpected call\n");
3549     return E_NOTIMPL;
3550 }
3551
3552 static HRESULT WINAPI ShellBrowser_SetStatusTextSB(IShellBrowser *iface, LPCOLESTR pszStatusText)
3553 {
3554     ok(0, "unexpected call\n");
3555     return E_NOTIMPL;
3556 }
3557
3558 static HRESULT WINAPI ShellBrowser_EnableModelessSB(IShellBrowser *iface, BOOL fEnable)
3559 {
3560     ok(0, "unexpected call\n");
3561     return E_NOTIMPL;
3562 }
3563
3564 static HRESULT WINAPI ShellBrowser_TranslateAcceleratorSB(IShellBrowser *iface, MSG *pmsg, WORD wID)
3565 {
3566     ok(0, "unexpected call\n");
3567     return E_NOTIMPL;
3568 }
3569
3570 static HRESULT WINAPI ShellBrowser_BrowseObject(IShellBrowser *iface, LPCITEMIDLIST pidl, UINT wFlags)
3571 {
3572     ok(0, "unexpected call\n");
3573     return E_NOTIMPL;
3574 }
3575
3576 static HRESULT WINAPI ShellBrowser_GetViewStateStream(IShellBrowser *iface, DWORD grfMode, IStream **ppStrm)
3577 {
3578     ok(0, "unexpected call\n");
3579     return E_NOTIMPL;
3580 }
3581
3582 static HRESULT WINAPI ShellBrowser_GetControlWindow(IShellBrowser *iface, UINT id, HWND *phwnd)
3583 {
3584     ok(0, "unexpected call\n");
3585     return E_NOTIMPL;
3586 }
3587
3588 static HRESULT WINAPI ShellBrowser_SendControlMsg(IShellBrowser *iface, UINT id, UINT uMsg, WPARAM wParam,
3589         LPARAM lParam, LRESULT *pret)
3590 {
3591     ok(0, "unexpected call\n");
3592     return E_NOTIMPL;
3593 }
3594
3595 static HRESULT WINAPI ShellBrowser_QueryActiveShellView(IShellBrowser *iface, IShellView **ppshv)
3596 {
3597     ok(0, "unexpected call\n");
3598     return E_NOTIMPL;
3599 }
3600
3601 static HRESULT WINAPI ShellBrowser_OnViewWindowActive(IShellBrowser* iface, IShellView *pshv)
3602 {
3603     ok(0, "unexpected call\n");
3604     return E_NOTIMPL;
3605 }
3606
3607 static HRESULT WINAPI ShellBrowser_SetToolbarItems(IShellBrowser *iface, LPTBBUTTONSB lpButtons,
3608         UINT nButtons, UINT uFlags)
3609 {
3610     ok(0, "unexpected call\n");
3611     return E_NOTIMPL;
3612 }
3613
3614 static const IShellBrowserVtbl ShellBrowserVtbl = {
3615     ShellBrowser_QueryInterface,
3616     ShellBrowser_AddRef,
3617     ShellBrowser_Release,
3618     ShellBrowser_GetWindow,
3619     ShellBrowser_ContextSensitiveHelp,
3620     ShellBrowser_InsertMenusSB,
3621     ShellBrowser_SetMenuSB,
3622     ShellBrowser_RemoveMenusSB,
3623     ShellBrowser_SetStatusTextSB,
3624     ShellBrowser_EnableModelessSB,
3625     ShellBrowser_TranslateAcceleratorSB,
3626     ShellBrowser_BrowseObject,
3627     ShellBrowser_GetViewStateStream,
3628     ShellBrowser_GetControlWindow,
3629     ShellBrowser_SendControlMsg,
3630     ShellBrowser_QueryActiveShellView,
3631     ShellBrowser_OnViewWindowActive,
3632     ShellBrowser_SetToolbarItems
3633 };
3634
3635 static IShellBrowser ShellBrowser = { &ShellBrowserVtbl };
3636
3637 static HRESULT  WINAPI BrowserService_QueryInterface(IBrowserService *iface, REFIID riid, void **ppv)
3638 {
3639     return browserservice_qi(riid, ppv);
3640 }
3641
3642 static ULONG  WINAPI BrowserService_AddRef(
3643         IBrowserService* This)
3644 {
3645     return 2;
3646 }
3647
3648 static ULONG  WINAPI BrowserService_Release(
3649         IBrowserService* This)
3650 {
3651     return 1;
3652 }
3653
3654 static HRESULT  WINAPI BrowserService_GetParentSite(
3655         IBrowserService* This,
3656         IOleInPlaceSite **ppipsite)
3657 {
3658     ok(0, "unexpected call\n");
3659     return E_NOTIMPL;
3660 }
3661
3662 static HRESULT  WINAPI BrowserService_SetTitle(
3663         IBrowserService* This,
3664         IShellView *psv,
3665         LPCWSTR pszName)
3666 {
3667     ok(0, "unexpected call\n");
3668     return E_NOTIMPL;
3669 }
3670
3671 static HRESULT  WINAPI BrowserService_GetTitle(
3672         IBrowserService* This,
3673         IShellView *psv,
3674         LPWSTR pszName,
3675         DWORD cchName)
3676 {
3677     ok(0, "unexpected call\n");
3678     return E_NOTIMPL;
3679 }
3680
3681 static HRESULT  WINAPI BrowserService_GetOleObject(
3682         IBrowserService* This,
3683         IOleObject **ppobjv)
3684 {
3685     ok(0, "unexpected call\n");
3686     return E_NOTIMPL;
3687 }
3688
3689 static HRESULT  WINAPI BrowserService_GetTravelLog(IBrowserService* This, ITravelLog **pptl)
3690 {
3691     CHECK_EXPECT(GetTravelLog);
3692
3693     ok(pptl != NULL, "pptl = NULL\n");
3694
3695     if(!support_wbapp)
3696         return E_NOTIMPL;
3697
3698     *pptl = &TravelLog;
3699     return S_OK;
3700 }
3701
3702 static HRESULT  WINAPI BrowserService_ShowControlWindow(
3703         IBrowserService* This,
3704         UINT id,
3705         BOOL fShow)
3706 {
3707     ok(0, "unexpected call\n");
3708     return E_NOTIMPL;
3709 }
3710
3711 static HRESULT  WINAPI BrowserService_IsControlWindowShown(
3712         IBrowserService* This,
3713         UINT id,
3714         BOOL *pfShown)
3715 {
3716     ok(0, "unexpected call\n");
3717     return E_NOTIMPL;
3718 }
3719
3720 static HRESULT  WINAPI BrowserService_IEGetDisplayName(
3721         IBrowserService* This,
3722         PCIDLIST_ABSOLUTE pidl,
3723         LPWSTR pwszName,
3724         UINT uFlags)
3725 {
3726     ok(0, "unexpected call\n");
3727     return E_NOTIMPL;
3728 }
3729
3730 static HRESULT  WINAPI BrowserService_IEParseDisplayName(
3731         IBrowserService* This,
3732         UINT uiCP,
3733         LPCWSTR pwszPath,
3734         PIDLIST_ABSOLUTE *ppidlOut)
3735 {
3736     ok(0, "unexpected call\n");
3737     return E_NOTIMPL;
3738 }
3739
3740 static HRESULT  WINAPI BrowserService_DisplayParseError(
3741         IBrowserService* This,
3742         HRESULT hres,
3743         LPCWSTR pwszPath)
3744 {
3745     ok(0, "unexpected call\n");
3746     return E_NOTIMPL;
3747 }
3748
3749 static HRESULT  WINAPI BrowserService_NavigateToPidl(
3750         IBrowserService* This,
3751         PCIDLIST_ABSOLUTE pidl,
3752         DWORD grfHLNF)
3753 {
3754     ok(0, "unexpected call\n");
3755     return E_NOTIMPL;
3756 }
3757
3758 static HRESULT  WINAPI BrowserService_SetNavigateState(
3759         IBrowserService* This,
3760         BNSTATE bnstate)
3761 {
3762     ok(0, "unexpected call\n");
3763     return E_NOTIMPL;
3764 }
3765
3766 static HRESULT  WINAPI BrowserService_GetNavigateState(
3767         IBrowserService* This,
3768         BNSTATE *pbnstate)
3769 {
3770     ok(0, "unexpected call\n");
3771     return E_NOTIMPL;
3772 }
3773
3774 static HRESULT  WINAPI BrowserService_NotifyRedirect(
3775         IBrowserService* This,
3776         IShellView *psv,
3777         PCIDLIST_ABSOLUTE pidl,
3778         BOOL *pfDidBrowse)
3779 {
3780     ok(0, "unexpected call\n");
3781     return E_NOTIMPL;
3782 }
3783
3784 static HRESULT  WINAPI BrowserService_UpdateWindowList(
3785         IBrowserService* This)
3786 {
3787     ok(0, "unexpected call\n");
3788     return E_NOTIMPL;
3789 }
3790
3791 static HRESULT  WINAPI BrowserService_UpdateBackForwardState(
3792         IBrowserService* This)
3793 {
3794     CHECK_EXPECT(UpdateBackForwardState);
3795     return S_OK;
3796 }
3797
3798 static HRESULT  WINAPI BrowserService_SetFlags(
3799         IBrowserService* This,
3800         DWORD dwFlags,
3801         DWORD dwFlagMask)
3802 {
3803     ok(0, "unexpected call\n");
3804     return E_NOTIMPL;
3805 }
3806
3807 static HRESULT  WINAPI BrowserService_GetFlags(
3808         IBrowserService* This,
3809         DWORD *pdwFlags)
3810 {
3811     ok(0, "unexpected call\n");
3812     return E_NOTIMPL;
3813 }
3814
3815 static HRESULT  WINAPI BrowserService_CanNavigateNow(
3816         IBrowserService* This)
3817 {
3818     ok(0, "unexpected call\n");
3819     return E_NOTIMPL;
3820 }
3821
3822 static HRESULT  WINAPI BrowserService_GetPidl(
3823         IBrowserService* This,
3824         PIDLIST_ABSOLUTE *ppidl)
3825 {
3826     ok(0, "unexpected call\n");
3827     return E_NOTIMPL;
3828 }
3829
3830 static HRESULT  WINAPI BrowserService_SetReferrer(
3831         IBrowserService* This,
3832         PCIDLIST_ABSOLUTE pidl)
3833 {
3834     ok(0, "unexpected call\n");
3835     return E_NOTIMPL;
3836 }
3837
3838 static DWORD  WINAPI BrowserService_GetBrowserIndex(
3839         IBrowserService* This)
3840 {
3841     ok(0, "unexpected call\n");
3842     return E_NOTIMPL;
3843 }
3844
3845 static HRESULT  WINAPI BrowserService_GetBrowserByIndex(
3846         IBrowserService* This,
3847         DWORD dwID,
3848         IUnknown **ppunk)
3849 {
3850     ok(0, "unexpected call\n");
3851     return E_NOTIMPL;
3852 }
3853
3854 static HRESULT  WINAPI BrowserService_GetHistoryObject(
3855         IBrowserService* This,
3856         IOleObject **ppole,
3857         IStream **pstm,
3858         IBindCtx **ppbc)
3859 {
3860     ok(0, "unexpected call\n");
3861     return E_NOTIMPL;
3862 }
3863
3864 static HRESULT  WINAPI BrowserService_SetHistoryObject(
3865         IBrowserService* This,
3866         IOleObject *pole,
3867         BOOL fIsLocalAnchor)
3868 {
3869     ok(0, "unexpected call\n");
3870     return E_NOTIMPL;
3871 }
3872
3873 static HRESULT  WINAPI BrowserService_CacheOLEServer(
3874         IBrowserService* This,
3875         IOleObject *pole)
3876 {
3877     ok(0, "unexpected call\n");
3878     return E_NOTIMPL;
3879 }
3880
3881 static HRESULT  WINAPI BrowserService_GetSetCodePage(
3882         IBrowserService* This,
3883         VARIANT *pvarIn,
3884         VARIANT *pvarOut)
3885 {
3886     ok(0, "unexpected call\n");
3887     return E_NOTIMPL;
3888 }
3889
3890 static HRESULT  WINAPI BrowserService_OnHttpEquiv(
3891         IBrowserService* This,
3892         IShellView *psv,
3893         BOOL fDone,
3894         VARIANT *pvarargIn,
3895         VARIANT *pvarargOut)
3896 {
3897     ok(0, "unexpected call\n");
3898     return E_NOTIMPL;
3899 }
3900
3901 static HRESULT  WINAPI BrowserService_GetPalette(
3902         IBrowserService* This,
3903         HPALETTE *hpal)
3904 {
3905     ok(0, "unexpected call\n");
3906     return E_NOTIMPL;
3907 }
3908
3909 static HRESULT  WINAPI BrowserService_RegisterWindow(
3910         IBrowserService* This,
3911         BOOL fForceRegister,
3912         int swc)
3913 {
3914     ok(0, "unexpected call\n");
3915     return E_NOTIMPL;
3916 }
3917
3918 static IBrowserServiceVtbl BrowserServiceVtbl = {
3919     BrowserService_QueryInterface,
3920     BrowserService_AddRef,
3921     BrowserService_Release,
3922     BrowserService_GetParentSite,
3923     BrowserService_SetTitle,
3924     BrowserService_GetTitle,
3925     BrowserService_GetOleObject,
3926     BrowserService_GetTravelLog,
3927     BrowserService_ShowControlWindow,
3928     BrowserService_IsControlWindowShown,
3929     BrowserService_IEGetDisplayName,
3930     BrowserService_IEParseDisplayName,
3931     BrowserService_DisplayParseError,
3932     BrowserService_NavigateToPidl,
3933     BrowserService_SetNavigateState,
3934     BrowserService_GetNavigateState,
3935     BrowserService_NotifyRedirect,
3936     BrowserService_UpdateWindowList,
3937     BrowserService_UpdateBackForwardState,
3938     BrowserService_SetFlags,
3939     BrowserService_GetFlags,
3940     BrowserService_CanNavigateNow,
3941     BrowserService_GetPidl,
3942     BrowserService_SetReferrer,
3943     BrowserService_GetBrowserIndex,
3944     BrowserService_GetBrowserByIndex,
3945     BrowserService_GetHistoryObject,
3946     BrowserService_SetHistoryObject,
3947     BrowserService_CacheOLEServer,
3948     BrowserService_GetSetCodePage,
3949     BrowserService_OnHttpEquiv,
3950     BrowserService_GetPalette,
3951     BrowserService_RegisterWindow
3952 };
3953
3954 static IBrowserService BrowserService = { &BrowserServiceVtbl };
3955
3956 DEFINE_GUID(IID_ITabBrowserService, 0x5E8FA523,0x83D4,0x4DBE,0x81,0x99,0x4C,0x18,0xE4,0x85,0x87,0x25);
3957
3958 static HRESULT browserservice_qi(REFIID riid, void **ppv)
3959 {
3960     if(IsEqualGUID(&IID_IShellBrowser, riid)) {
3961         *ppv = &ShellBrowser;
3962         return S_OK;
3963     }
3964
3965     if(IsEqualGUID(&IID_IDocObjectService, riid)) {
3966         *ppv = &DocObjectService;
3967         return S_OK;
3968     }
3969
3970     if(IsEqualGUID(&IID_IBrowserService, riid)) {
3971         *ppv = &BrowserService;
3972         return S_OK;
3973     }
3974
3975     *ppv = NULL;
3976     return E_NOINTERFACE;
3977 }
3978
3979 static HRESULT WINAPI WBE2Sink_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
3980 {
3981     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IDispatch, riid)) {
3982         *ppv = iface;
3983         return S_OK;
3984     }
3985
3986     *ppv = NULL;
3987     ok(0, "unexpected riid: %s\n", debugstr_guid(riid));
3988     return E_NOINTERFACE;
3989 }
3990
3991 static HRESULT WINAPI WBE2Sink_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
3992         LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pVarResult,
3993         EXCEPINFO *pExcepInfo, UINT *puArgErr)
3994 {
3995     ok(IsEqualGUID(&IID_NULL, riid), "riid != IID_NULL\n");
3996     ok(pdp != NULL, "pDispParams == NULL\n");
3997     ok(pExcepInfo == NULL, "pExcepInfo=%p, expected NULL\n", pExcepInfo);
3998     ok(puArgErr == NULL, "puArgErr != NULL\n");
3999     ok(pVarResult == NULL, "pVarResult != NULL\n");
4000     ok(wFlags == DISPATCH_METHOD, "wFlags=%08x, expected DISPATCH_METHOD\n", wFlags);
4001     ok(!pdp->cNamedArgs, "pdp->cNamedArgs = %d\n", pdp->cNamedArgs);
4002     ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs = %p\n", pdp->rgdispidNamedArgs);
4003
4004     switch(dispIdMember) {
4005     case DISPID_WINDOWCLOSING: {
4006         VARIANT *is_child = pdp->rgvarg+1, *cancel = pdp->rgvarg;
4007
4008         CHECK_EXPECT(WindowClosing);
4009
4010         ok(pdp->cArgs == 2, "pdp->cArgs = %d\n", pdp->cArgs);
4011         ok(V_VT(is_child) == VT_BOOL, "V_VT(is_child) = %d\n", V_VT(is_child));
4012         ok(!V_BOOL(is_child), "V_BOOL(is_child) = %x\n", V_BOOL(is_child));
4013         ok(V_VT(cancel) == (VT_BYREF|VT_BOOL), "V_VT(cancel) = %d\n", V_VT(cancel));
4014         ok(!*V_BOOLREF(cancel), "*V_BOOLREF(cancel) = %x\n", *V_BOOLREF(cancel));
4015
4016         *V_BOOLREF(cancel) = VARIANT_TRUE;
4017         return S_OK;
4018     }
4019     default:
4020         ok(0, "unexpected id %d\n", dispIdMember);
4021     }
4022
4023     return E_NOTIMPL;
4024 }
4025
4026 static const IDispatchVtbl WBE2SinkVtbl = {
4027     WBE2Sink_QueryInterface,
4028     Dispatch_AddRef,
4029     Dispatch_Release,
4030     Dispatch_GetTypeInfoCount,
4031     Dispatch_GetTypeInfo,
4032     Dispatch_GetIDsOfNames,
4033     WBE2Sink_Invoke
4034 };
4035
4036 static IDispatch WBE2Sink = { &WBE2SinkVtbl };
4037
4038 static HRESULT WINAPI EnumConnections_QueryInterface(IEnumConnections *iface, REFIID riid, LPVOID *ppv)
4039 {
4040     ok(0, "unexpected call\n");
4041     return E_NOINTERFACE;
4042 }
4043
4044 static ULONG WINAPI EnumConnections_AddRef(IEnumConnections *iface)
4045 {
4046     return 2;
4047 }
4048
4049 static ULONG WINAPI EnumConnections_Release(IEnumConnections *iface)
4050 {
4051     return 1;
4052 }
4053
4054 static BOOL next_called;
4055
4056 static HRESULT WINAPI EnumConnections_Next(IEnumConnections *iface, ULONG cConnections, CONNECTDATA *rgcd, ULONG *pcFetched)
4057 {
4058     CHECK_EXPECT2(EnumConnections_Next);
4059
4060     ok(cConnections == 1, "cConnections = %d\n", cConnections);
4061     ok(pcFetched != NULL, "pcFetched == NULL\n");
4062
4063     if(next_called) {
4064         *pcFetched = 0;
4065         return S_FALSE;
4066     }
4067
4068     next_called = TRUE;
4069     rgcd->pUnk = (IUnknown*)&WBE2Sink;
4070     rgcd->dwCookie = 0xdeadbeef;
4071     *pcFetched = 1;
4072     return S_OK;
4073 }
4074
4075 static HRESULT WINAPI EnumConnections_Skip(IEnumConnections *iface, ULONG ulConnections)
4076 {
4077     ok(0, "unexpected call\n");
4078     return E_NOINTERFACE;
4079 }
4080
4081 static HRESULT WINAPI EnumConnections_Reset(IEnumConnections *iface)
4082 {
4083     ok(0, "unexpected call\n");
4084     return E_NOINTERFACE;
4085 }
4086
4087 static HRESULT WINAPI EnumConnections_Clone(IEnumConnections *iface, IEnumConnections **ppEnum)
4088 {
4089     ok(0, "unexpected call\n");
4090     return E_NOINTERFACE;
4091 }
4092
4093 static const IEnumConnectionsVtbl EnumConnectionsVtbl = {
4094     EnumConnections_QueryInterface,
4095     EnumConnections_AddRef,
4096     EnumConnections_Release,
4097     EnumConnections_Next,
4098     EnumConnections_Skip,
4099     EnumConnections_Reset,
4100     EnumConnections_Clone
4101 };
4102
4103 static IEnumConnections EnumConnections = { &EnumConnectionsVtbl };
4104
4105 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface, REFIID riid, LPVOID *ppv)
4106 {
4107     ok(0, "unexpected call\n");
4108     return E_NOINTERFACE;
4109 }
4110
4111 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
4112 {
4113     return 2;
4114 }
4115
4116 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
4117 {
4118     return 1;
4119 }
4120
4121 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
4122 {
4123     ok(0, "unexpected call\n");
4124     return E_NOTIMPL;
4125 }
4126
4127 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
4128         IConnectionPointContainer **ppCPC)
4129 {
4130     ok(0, "unexpected call\n");
4131     return E_NOTIMPL;
4132 }
4133
4134 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink, DWORD *pdwCookie)
4135 {
4136     ok(0, "unexpected call\n");
4137     return E_NOTIMPL;
4138 }
4139
4140 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
4141 {
4142     ok(0, "unexpected call\n");
4143     return E_NOTIMPL;
4144 }
4145
4146 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface, IEnumConnections **ppEnum)
4147 {
4148     CHECK_EXPECT(EnumConnections);
4149
4150     *ppEnum = &EnumConnections;
4151     next_called = FALSE;
4152     return S_OK;
4153 }
4154
4155 static const IConnectionPointVtbl ConnectionPointVtbl =
4156 {
4157     ConnectionPoint_QueryInterface,
4158     ConnectionPoint_AddRef,
4159     ConnectionPoint_Release,
4160     ConnectionPoint_GetConnectionInterface,
4161     ConnectionPoint_GetConnectionPointContainer,
4162     ConnectionPoint_Advise,
4163     ConnectionPoint_Unadvise,
4164     ConnectionPoint_EnumConnections
4165 };
4166
4167 static IConnectionPoint ConnectionPointWBE2 = { &ConnectionPointVtbl };
4168
4169 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
4170                                                               REFIID riid, void **ppv)
4171 {
4172     ok(0, "unexpected call\n");
4173     return E_NOINTERFACE;
4174 }
4175
4176 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
4177 {
4178     return 2;
4179 }
4180
4181 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
4182 {
4183     return 1;
4184 }
4185
4186 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
4187         IEnumConnectionPoints **ppEnum)
4188 {
4189     ok(0, "unexpected call\n");
4190     return E_NOTIMPL;
4191 }
4192
4193 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
4194         REFIID riid, IConnectionPoint **ppCP)
4195 {
4196     CHECK_EXPECT(FindConnectionPoint);
4197
4198     if(IsEqualGUID(riid, &DIID_DWebBrowserEvents2)) {
4199         *ppCP = &ConnectionPointWBE2;
4200         return S_OK;
4201     }
4202
4203     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
4204     return E_NOTIMPL;
4205 }
4206
4207 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
4208     ConnectionPointContainer_QueryInterface,
4209     ConnectionPointContainer_AddRef,
4210     ConnectionPointContainer_Release,
4211     ConnectionPointContainer_EnumConnectionPoints,
4212     ConnectionPointContainer_FindConnectionPoint
4213 };
4214
4215 static IConnectionPointContainer ConnectionPointContainer = { &ConnectionPointContainerVtbl };
4216
4217 static HRESULT WINAPI WebBrowser_QueryInterface(IWebBrowser2 *iface, REFIID riid, void **ppv)
4218 {
4219     *ppv = NULL;
4220
4221     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IWebBrowser, riid)
4222             || IsEqualGUID(&IID_IWebBrowserApp, riid) || IsEqualGUID(&IID_IWebBrowser2, riid)) {
4223         *ppv = iface;
4224         return S_OK;
4225     }
4226
4227     if(IsEqualGUID(riid, &IID_IOleObject))
4228         return E_NOINTERFACE; /* TODO */
4229
4230     if(IsEqualGUID(riid, &IID_IConnectionPointContainer)) {
4231         *ppv = &ConnectionPointContainer;
4232         return S_OK;
4233     }
4234
4235     ok(0, "unexpected call %s\n", debugstr_guid(riid));
4236     return E_NOINTERFACE;
4237 }
4238
4239 static ULONG WINAPI WebBrowser_AddRef(IWebBrowser2 *iface)
4240 {
4241     return 2;
4242 }
4243
4244 static ULONG WINAPI WebBrowser_Release(IWebBrowser2 *iface)
4245 {
4246     return 1;
4247 }
4248
4249 static HRESULT WINAPI WebBrowser_GetTypeInfoCount(IWebBrowser2 *iface, UINT *pctinfo)
4250 {
4251     ok(0, "unexpected call\n");
4252     return E_NOTIMPL;
4253 }
4254
4255 static HRESULT WINAPI WebBrowser_GetTypeInfo(IWebBrowser2 *iface, UINT iTInfo, LCID lcid,
4256         LPTYPEINFO *ppTInfo)
4257 {
4258     ok(0, "unexpected call\n");
4259     return E_NOTIMPL;
4260 }
4261
4262 static HRESULT WINAPI WebBrowser_GetIDsOfNames(IWebBrowser2 *iface, REFIID riid,
4263         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4264 {
4265     ok(0, "unexpected call\n");
4266     return E_NOTIMPL;
4267 }
4268
4269 static HRESULT WINAPI WebBrowser_Invoke(IWebBrowser2 *iface, DISPID dispIdMember,
4270         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
4271         EXCEPINFO *pExepInfo, UINT *puArgErr)
4272 {
4273     ok(0, "unexpected call\n");
4274     return E_NOTIMPL;
4275 }
4276
4277 static HRESULT WINAPI WebBrowser_GoBack(IWebBrowser2 *iface)
4278 {
4279     ok(0, "unexpected call\n");
4280     return E_NOTIMPL;
4281 }
4282
4283 static HRESULT WINAPI WebBrowser_GoForward(IWebBrowser2 *iface)
4284 {
4285     ok(0, "unexpected call\n");
4286     return E_NOTIMPL;
4287 }
4288
4289 static HRESULT WINAPI WebBrowser_GoHome(IWebBrowser2 *iface)
4290 {
4291     ok(0, "unexpected call\n");
4292     return E_NOTIMPL;
4293 }
4294
4295 static HRESULT WINAPI WebBrowser_GoSearch(IWebBrowser2 *iface)
4296 {
4297     ok(0, "unexpected call\n");
4298     return E_NOTIMPL;
4299 }
4300
4301 static HRESULT WINAPI WebBrowser_Navigate(IWebBrowser2 *iface, BSTR szUrl,
4302         VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
4303 {
4304     ok(0, "unexpected call\n");
4305     return E_NOTIMPL;
4306 }
4307
4308 static HRESULT WINAPI WebBrowser_Refresh(IWebBrowser2 *iface)
4309 {
4310     ok(0, "unexpected call\n");
4311     return E_NOTIMPL;
4312 }
4313
4314 static HRESULT WINAPI WebBrowser_Refresh2(IWebBrowser2 *iface, VARIANT *Level)
4315 {
4316     ok(0, "unexpected call\n");
4317     return E_NOTIMPL;
4318 }
4319
4320 static HRESULT WINAPI WebBrowser_Stop(IWebBrowser2 *iface)
4321 {
4322     ok(0, "unexpected call\n");
4323     return E_NOTIMPL;
4324 }
4325
4326 static HRESULT WINAPI WebBrowser_get_Application(IWebBrowser2 *iface, IDispatch **ppDisp)
4327 {
4328     ok(0, "unexpected call\n");
4329     return E_NOTIMPL;
4330 }
4331
4332 static HRESULT WINAPI WebBrowser_get_Parent(IWebBrowser2 *iface, IDispatch **ppDisp)
4333 {
4334     ok(0, "unexpected call\n");
4335     return E_NOTIMPL;
4336 }
4337
4338 static HRESULT WINAPI WebBrowser_get_Container(IWebBrowser2 *iface, IDispatch **ppDisp)
4339 {
4340     ok(0, "unexpected call\n");
4341     return E_NOTIMPL;
4342 }
4343
4344 static HRESULT WINAPI WebBrowser_get_Document(IWebBrowser2 *iface, IDispatch **ppDisp)
4345 {
4346     ok(0, "unexpected call\n");
4347     return E_NOTIMPL;
4348 }
4349
4350 static HRESULT WINAPI WebBrowser_get_TopLevelContainer(IWebBrowser2 *iface, VARIANT_BOOL *pBool)
4351 {
4352     ok(0, "unexpected call\n");
4353     return E_NOTIMPL;
4354 }
4355
4356 static HRESULT WINAPI WebBrowser_get_Type(IWebBrowser2 *iface, BSTR *Type)
4357 {
4358     ok(0, "unexpected call\n");
4359     return E_NOTIMPL;
4360 }
4361
4362 static HRESULT WINAPI WebBrowser_get_Left(IWebBrowser2 *iface, LONG *pl)
4363 {
4364     ok(0, "unexpected call\n");
4365     return E_NOTIMPL;
4366 }
4367
4368 static HRESULT WINAPI WebBrowser_put_Left(IWebBrowser2 *iface, LONG Left)
4369 {
4370     ok(0, "unexpected call\n");
4371     return E_NOTIMPL;
4372 }
4373
4374 static HRESULT WINAPI WebBrowser_get_Top(IWebBrowser2 *iface, LONG *pl)
4375 {
4376     ok(0, "unexpected call\n");
4377     return E_NOTIMPL;
4378 }
4379
4380 static HRESULT WINAPI WebBrowser_put_Top(IWebBrowser2 *iface, LONG Top)
4381 {
4382     ok(0, "unexpected call\n");
4383     return E_NOTIMPL;
4384 }
4385
4386 static HRESULT WINAPI WebBrowser_get_Width(IWebBrowser2 *iface, LONG *pl)
4387 {
4388     ok(0, "unexpected call\n");
4389     return E_NOTIMPL;
4390 }
4391
4392 static HRESULT WINAPI WebBrowser_put_Width(IWebBrowser2 *iface, LONG Width)
4393 {
4394     ok(0, "unexpected call\n");
4395     return E_NOTIMPL;
4396 }
4397
4398 static HRESULT WINAPI WebBrowser_get_Height(IWebBrowser2 *iface, LONG *pl)
4399 {
4400     ok(0, "unexpected call\n");
4401     return E_NOTIMPL;
4402 }
4403
4404 static HRESULT WINAPI WebBrowser_put_Height(IWebBrowser2 *iface, LONG Height)
4405 {
4406     ok(0, "unexpected call\n");
4407     return E_NOTIMPL;
4408 }
4409
4410 static HRESULT WINAPI WebBrowser_get_LocationName(IWebBrowser2 *iface, BSTR *LocationName)
4411 {
4412     ok(0, "unexpected call\n");
4413     return E_NOTIMPL;
4414 }
4415
4416 static HRESULT WINAPI WebBrowser_get_LocationURL(IWebBrowser2 *iface, BSTR *LocationURL)
4417 {
4418     CHECK_EXPECT(get_LocationURL);
4419     return E_NOTIMPL;
4420 }
4421
4422 static HRESULT WINAPI WebBrowser_get_Busy(IWebBrowser2 *iface, VARIANT_BOOL *pBool)
4423 {
4424     ok(0, "unexpected call\n");
4425     return E_NOTIMPL;
4426 }
4427
4428 static HRESULT WINAPI WebBrowser_Quit(IWebBrowser2 *iface)
4429 {
4430     ok(0, "unexpected call\n");
4431     return E_NOTIMPL;
4432 }
4433
4434 static HRESULT WINAPI WebBrowser_ClientToWindow(IWebBrowser2 *iface, int *pcx, int *pcy)
4435 {
4436     ok(0, "unexpected call\n");
4437     return E_NOTIMPL;
4438 }
4439
4440 static HRESULT WINAPI WebBrowser_PutProperty(IWebBrowser2 *iface, BSTR szProperty, VARIANT vtValue)
4441 {
4442     ok(0, "unexpected call\n");
4443     return E_NOTIMPL;
4444 }
4445
4446 static HRESULT WINAPI WebBrowser_GetProperty(IWebBrowser2 *iface, BSTR szProperty, VARIANT *pvtValue)
4447 {
4448     ok(0, "unexpected call\n");
4449     return E_NOTIMPL;
4450 }
4451
4452 static HRESULT WINAPI WebBrowser_get_Name(IWebBrowser2 *iface, BSTR *Name)
4453 {
4454     ok(0, "unexpected call\n");
4455     return E_NOTIMPL;
4456 }
4457
4458 static HRESULT WINAPI WebBrowser_get_HWND(IWebBrowser2 *iface, SHANDLE_PTR *pHWND)
4459 {
4460     ok(0, "unexpected call\n");
4461     return E_NOTIMPL;
4462 }
4463
4464 static HRESULT WINAPI WebBrowser_get_FullName(IWebBrowser2 *iface, BSTR *FullName)
4465 {
4466     ok(0, "unexpected call\n");
4467     return E_NOTIMPL;
4468 }
4469
4470 static HRESULT WINAPI WebBrowser_get_Path(IWebBrowser2 *iface, BSTR *Path)
4471 {
4472     ok(0, "unexpected call\n");
4473     return E_NOTIMPL;
4474 }
4475
4476 static HRESULT WINAPI WebBrowser_get_Visible(IWebBrowser2 *iface, VARIANT_BOOL *pBool)
4477 {
4478     ok(0, "unexpected call\n");
4479     return E_NOTIMPL;
4480 }
4481
4482 static HRESULT WINAPI WebBrowser_put_Visible(IWebBrowser2 *iface, VARIANT_BOOL Value)
4483 {
4484     ok(0, "unexpected call\n");
4485     return E_NOTIMPL;
4486 }
4487
4488 static HRESULT WINAPI WebBrowser_get_StatusBar(IWebBrowser2 *iface, VARIANT_BOOL *pBool)
4489 {
4490     ok(0, "unexpected call\n");
4491     return E_NOTIMPL;
4492 }
4493
4494 static HRESULT WINAPI WebBrowser_put_StatusBar(IWebBrowser2 *iface, VARIANT_BOOL Value)
4495 {
4496     ok(0, "unexpected call\n");
4497     return E_NOTIMPL;
4498 }
4499
4500 static HRESULT WINAPI WebBrowser_get_StatusText(IWebBrowser2 *iface, BSTR *StatusText)
4501 {
4502     ok(0, "unexpected call\n");
4503     return E_NOTIMPL;
4504 }
4505
4506 static HRESULT WINAPI WebBrowser_put_StatusText(IWebBrowser2 *iface, BSTR StatusText)
4507 {
4508     ok(0, "unexpected call\n");
4509     return E_NOTIMPL;
4510 }
4511
4512 static HRESULT WINAPI WebBrowser_get_ToolBar(IWebBrowser2 *iface, int *Value)
4513 {
4514     ok(0, "unexpected call\n");
4515     return E_NOTIMPL;
4516 }
4517
4518 static HRESULT WINAPI WebBrowser_put_ToolBar(IWebBrowser2 *iface, int Value)
4519 {
4520     ok(0, "unexpected call\n");
4521     return E_NOTIMPL;
4522 }
4523
4524 static HRESULT WINAPI WebBrowser_get_MenuBar(IWebBrowser2 *iface, VARIANT_BOOL *Value)
4525 {
4526     ok(0, "unexpected call\n");
4527     return E_NOTIMPL;
4528 }
4529
4530 static HRESULT WINAPI WebBrowser_put_MenuBar(IWebBrowser2 *iface, VARIANT_BOOL Value)
4531 {
4532     ok(0, "unexpected call\n");
4533     return E_NOTIMPL;
4534 }
4535
4536 static HRESULT WINAPI WebBrowser_get_FullScreen(IWebBrowser2 *iface, VARIANT_BOOL *pbFullScreen)
4537 {
4538     ok(0, "unexpected call\n");
4539     return E_NOTIMPL;
4540 }
4541
4542 static HRESULT WINAPI WebBrowser_put_FullScreen(IWebBrowser2 *iface, VARIANT_BOOL bFullScreen)
4543 {
4544     ok(0, "unexpected call\n");
4545     return E_NOTIMPL;
4546 }
4547
4548 static HRESULT WINAPI WebBrowser_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VARIANT *Flags,
4549         VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers)
4550 {
4551     ok(0, "unexpected call\n");
4552     return E_NOTIMPL;
4553 }
4554
4555 static HRESULT WINAPI WebBrowser_QueryStatusWB(IWebBrowser2 *iface, OLECMDID cmdID, OLECMDF *pcmdf)
4556 {
4557     ok(0, "unexpected call\n");
4558     return E_NOTIMPL;
4559 }
4560
4561 static HRESULT WINAPI WebBrowser_ExecWB(IWebBrowser2 *iface, OLECMDID cmdID,
4562         OLECMDEXECOPT cmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
4563 {
4564     ok(0, "unexpected call\n");
4565     return E_NOTIMPL;
4566 }
4567
4568 static HRESULT WINAPI WebBrowser_ShowBrowserBar(IWebBrowser2 *iface, VARIANT *pvaClsid,
4569         VARIANT *pvarShow, VARIANT *pvarSize)
4570 {
4571     ok(0, "unexpected call\n");
4572     return E_NOTIMPL;
4573 }
4574
4575 static HRESULT WINAPI WebBrowser_get_ReadyState(IWebBrowser2 *iface, READYSTATE *lpReadyState)
4576 {
4577     ok(0, "unexpected call\n");
4578     return E_NOTIMPL;
4579 }
4580
4581 static HRESULT WINAPI WebBrowser_get_Offline(IWebBrowser2 *iface, VARIANT_BOOL *pbOffline)
4582 {
4583     ok(0, "unexpected call\n");
4584     return E_NOTIMPL;
4585 }
4586
4587 static HRESULT WINAPI WebBrowser_put_Offline(IWebBrowser2 *iface, VARIANT_BOOL bOffline)
4588 {
4589     ok(0, "unexpected call\n");
4590     return E_NOTIMPL;
4591 }
4592
4593 static HRESULT WINAPI WebBrowser_get_Silent(IWebBrowser2 *iface, VARIANT_BOOL *pbSilent)
4594 {
4595     ok(0, "unexpected call\n");
4596     return E_NOTIMPL;
4597 }
4598
4599 static HRESULT WINAPI WebBrowser_put_Silent(IWebBrowser2 *iface, VARIANT_BOOL bSilent)
4600 {
4601     ok(0, "unexpected call\n");
4602     return E_NOTIMPL;
4603 }
4604
4605 static HRESULT WINAPI WebBrowser_get_RegisterAsBrowser(IWebBrowser2 *iface,
4606         VARIANT_BOOL *pbRegister)
4607 {
4608     ok(0, "unexpected call\n");
4609     return E_NOTIMPL;
4610 }
4611
4612 static HRESULT WINAPI WebBrowser_put_RegisterAsBrowser(IWebBrowser2 *iface,
4613         VARIANT_BOOL bRegister)
4614 {
4615     ok(0, "unexpected call\n");
4616     return E_NOTIMPL;
4617 }
4618
4619 static HRESULT WINAPI WebBrowser_get_RegisterAsDropTarget(IWebBrowser2 *iface,
4620         VARIANT_BOOL *pbRegister)
4621 {
4622     ok(0, "unexpected call\n");
4623     return E_NOTIMPL;
4624 }
4625
4626 static HRESULT WINAPI WebBrowser_put_RegisterAsDropTarget(IWebBrowser2 *iface,
4627         VARIANT_BOOL bRegister)
4628 {
4629     ok(0, "unexpected call\n");
4630     return E_NOTIMPL;
4631 }
4632
4633 static HRESULT WINAPI WebBrowser_get_TheaterMode(IWebBrowser2 *iface, VARIANT_BOOL *pbRegister)
4634 {
4635     ok(0, "unexpected call\n");
4636     return E_NOTIMPL;
4637 }
4638
4639 static HRESULT WINAPI WebBrowser_put_TheaterMode(IWebBrowser2 *iface, VARIANT_BOOL bRegister)
4640 {
4641     ok(0, "unexpected call\n");
4642     return E_NOTIMPL;
4643 }
4644
4645 static HRESULT WINAPI WebBrowser_get_AddressBar(IWebBrowser2 *iface, VARIANT_BOOL *Value)
4646 {
4647     ok(0, "unexpected call\n");
4648     return E_NOTIMPL;
4649 }
4650
4651 static HRESULT WINAPI WebBrowser_put_AddressBar(IWebBrowser2 *iface, VARIANT_BOOL Value)
4652 {
4653     ok(0, "unexpected call\n");
4654     return E_NOTIMPL;
4655 }
4656
4657 static HRESULT WINAPI WebBrowser_get_Resizable(IWebBrowser2 *iface, VARIANT_BOOL *Value)
4658 {
4659     ok(0, "unexpected call\n");
4660     return E_NOTIMPL;
4661 }
4662
4663 static HRESULT WINAPI WebBrowser_put_Resizable(IWebBrowser2 *iface, VARIANT_BOOL Value)
4664 {
4665     ok(0, "unexpected call\n");
4666     return E_NOTIMPL;
4667 }
4668
4669 static const IWebBrowser2Vtbl WebBrowser2Vtbl =
4670 {
4671     WebBrowser_QueryInterface,
4672     WebBrowser_AddRef,
4673     WebBrowser_Release,
4674     WebBrowser_GetTypeInfoCount,
4675     WebBrowser_GetTypeInfo,
4676     WebBrowser_GetIDsOfNames,
4677     WebBrowser_Invoke,
4678     WebBrowser_GoBack,
4679     WebBrowser_GoForward,
4680     WebBrowser_GoHome,
4681     WebBrowser_GoSearch,
4682     WebBrowser_Navigate,
4683     WebBrowser_Refresh,
4684     WebBrowser_Refresh2,
4685     WebBrowser_Stop,
4686     WebBrowser_get_Application,
4687     WebBrowser_get_Parent,
4688     WebBrowser_get_Container,
4689     WebBrowser_get_Document,
4690     WebBrowser_get_TopLevelContainer,
4691     WebBrowser_get_Type,
4692     WebBrowser_get_Left,
4693     WebBrowser_put_Left,
4694     WebBrowser_get_Top,
4695     WebBrowser_put_Top,
4696     WebBrowser_get_Width,
4697     WebBrowser_put_Width,
4698     WebBrowser_get_Height,
4699     WebBrowser_put_Height,
4700     WebBrowser_get_LocationName,
4701     WebBrowser_get_LocationURL,
4702     WebBrowser_get_Busy,
4703     WebBrowser_Quit,
4704     WebBrowser_ClientToWindow,
4705     WebBrowser_PutProperty,
4706     WebBrowser_GetProperty,
4707     WebBrowser_get_Name,
4708     WebBrowser_get_HWND,
4709     WebBrowser_get_FullName,
4710     WebBrowser_get_Path,
4711     WebBrowser_get_Visible,
4712     WebBrowser_put_Visible,
4713     WebBrowser_get_StatusBar,
4714     WebBrowser_put_StatusBar,
4715     WebBrowser_get_StatusText,
4716     WebBrowser_put_StatusText,
4717     WebBrowser_get_ToolBar,
4718     WebBrowser_put_ToolBar,
4719     WebBrowser_get_MenuBar,
4720     WebBrowser_put_MenuBar,
4721     WebBrowser_get_FullScreen,
4722     WebBrowser_put_FullScreen,
4723     WebBrowser_Navigate2,
4724     WebBrowser_QueryStatusWB,
4725     WebBrowser_ExecWB,
4726     WebBrowser_ShowBrowserBar,
4727     WebBrowser_get_ReadyState,
4728     WebBrowser_get_Offline,
4729     WebBrowser_put_Offline,
4730     WebBrowser_get_Silent,
4731     WebBrowser_put_Silent,
4732     WebBrowser_get_RegisterAsBrowser,
4733     WebBrowser_put_RegisterAsBrowser,
4734     WebBrowser_get_RegisterAsDropTarget,
4735     WebBrowser_put_RegisterAsDropTarget,
4736     WebBrowser_get_TheaterMode,
4737     WebBrowser_put_TheaterMode,
4738     WebBrowser_get_AddressBar,
4739     WebBrowser_put_AddressBar,
4740     WebBrowser_get_Resizable,
4741     WebBrowser_put_Resizable
4742 };
4743
4744 static IWebBrowser2 WebBrowser2 = { &WebBrowser2Vtbl };
4745
4746 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
4747                                                      REFIID riid, void **ppv)
4748 {
4749     return QueryInterface(riid, ppv);
4750 }
4751
4752 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
4753 {
4754     return 2;
4755 }
4756
4757 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
4758 {
4759     return 1;
4760 }
4761
4762 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
4763                                     REFIID riid, void **ppv)
4764 {
4765     /*
4766      * Services used by HTMLDocument:
4767      *
4768      * IOleUndoManager
4769      * IInternetSecurityManager
4770      * ITargetFrame
4771      * {D5F78C80-5252-11CF-90FA-00AA0042106E}
4772      * HTMLFrameBase
4773      * IShellObject
4774      * {3050F312-98B5-11CF-BB82-00AA00BDCE0B}
4775      * {53A2D5B1-D2FC-11D0-84E0-006097C9987D}
4776      * {AD7F6C62-F6BD-11D2-959B-006097C553C8}
4777      * DefView (?)
4778      * {6D12FE80-7911-11CF-9534-0000C05BAE0B}
4779      * IElementBehaviorFactory
4780      * {3050F429-98B5-11CF-BB82-00AA00BDCE0B}
4781      * STopLevelBrowser
4782      * IHTMLWindow2
4783      * IInternetProtocol
4784      * UrlHostory
4785      * IHTMLEditHost
4786      * IHlinkFrame
4787      */
4788
4789     if(IsEqualGUID(&IID_IHlinkFrame, guidService)) {
4790         ok(IsEqualGUID(&IID_IHlinkFrame, riid), "unexpected riid\n");
4791         *ppv = &HlinkFrame;
4792         return S_OK;
4793     }
4794
4795     if(IsEqualGUID(&SID_SNewWindowManager, guidService)) {
4796         ok(IsEqualGUID(&IID_INewWindowManager, riid), "unexpected riid\n");
4797         *ppv = &NewWindowManager;
4798         return S_OK;
4799     }
4800
4801     if(IsEqualGUID(&IID_IShellBrowser, guidService)) {
4802         ok(IsEqualGUID(&IID_IBrowserService, riid), "unexpected riid\n");
4803         *ppv = &BrowserService;
4804         return S_OK;
4805     }
4806
4807     if(support_wbapp && IsEqualGUID(&IID_IWebBrowserApp, guidService)) {
4808         if(IsEqualGUID(riid, &IID_IWebBrowser2)) {
4809             *ppv = &WebBrowser2;
4810             return S_OK;
4811         }
4812         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
4813     }
4814
4815     return E_NOINTERFACE;
4816 }
4817
4818 static const IServiceProviderVtbl ServiceProviderVtbl = {
4819     ServiceProvider_QueryInterface,
4820     ServiceProvider_AddRef,
4821     ServiceProvider_Release,
4822     ServiceProvider_QueryService
4823 };
4824
4825 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
4826
4827 static HRESULT WINAPI AdviseSink_QueryInterface(IAdviseSinkEx *iface,
4828         REFIID riid, void **ppv)
4829 {
4830     return QueryInterface(riid, ppv);
4831 }
4832
4833 static ULONG WINAPI AdviseSink_AddRef(IAdviseSinkEx *iface)
4834 {
4835     return 2;
4836 }
4837
4838 static ULONG WINAPI AdviseSink_Release(IAdviseSinkEx *iface)
4839 {
4840     return 1;
4841 }
4842
4843 static void WINAPI AdviseSink_OnDataChange(IAdviseSinkEx *iface,
4844         FORMATETC *pFormatetc, STGMEDIUM *pStgmed)
4845 {
4846     ok(0, "unexpected call\n");
4847 }
4848
4849 static void WINAPI AdviseSink_OnViewChange(IAdviseSinkEx *iface,
4850         DWORD dwAspect, LONG lindex)
4851 {
4852     ok(0, "unexpected call\n");
4853 }
4854
4855 static void WINAPI AdviseSink_OnRename(IAdviseSinkEx *iface, IMoniker *pmk)
4856 {
4857     ok(0, "unexpected call\n");
4858 }
4859
4860 static void WINAPI AdviseSink_OnSave(IAdviseSinkEx *iface)
4861 {
4862     ok(0, "unexpected call\n");
4863 }
4864
4865 static void WINAPI AdviseSink_OnClose(IAdviseSinkEx *iface)
4866 {
4867     ok(0, "unexpected call\n");
4868 }
4869
4870 static void WINAPI AdviseSinkEx_OnViewStatusChange(IAdviseSinkEx *iface, DWORD dwViewStatus)
4871 {
4872     ok(0, "unexpected call\n");
4873 }
4874
4875 static void WINAPI ObjectAdviseSink_OnClose(IAdviseSinkEx *iface)
4876 {
4877     CHECK_EXPECT(Advise_Close);
4878 }
4879
4880 static const IAdviseSinkExVtbl AdviseSinkVtbl = {
4881     AdviseSink_QueryInterface,
4882     AdviseSink_AddRef,
4883     AdviseSink_Release,
4884     AdviseSink_OnDataChange,
4885     AdviseSink_OnViewChange,
4886     AdviseSink_OnRename,
4887     AdviseSink_OnSave,
4888     ObjectAdviseSink_OnClose,
4889     AdviseSinkEx_OnViewStatusChange
4890 };
4891
4892 static IAdviseSinkEx AdviseSink = { &AdviseSinkVtbl };
4893
4894 static HRESULT WINAPI ViewAdviseSink_QueryInterface(IAdviseSinkEx *iface,
4895         REFIID riid, void **ppv)
4896 {
4897     if(IsEqualGUID(&IID_IAdviseSinkEx, riid)) {
4898         *ppv = iface;
4899         return S_OK;
4900     }
4901
4902     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
4903     *ppv = NULL;
4904     return E_NOINTERFACE;
4905 }
4906
4907 static void WINAPI ViewAdviseSink_OnViewChange(IAdviseSinkEx *iface,
4908         DWORD dwAspect, LONG lindex)
4909 {
4910     CHECK_EXPECT2(OnViewChange);
4911
4912     ok(dwAspect == DVASPECT_CONTENT, "dwAspect = %d\n", dwAspect);
4913     ok(lindex == -1, "lindex = %d\n", lindex);
4914 }
4915
4916 static const IAdviseSinkExVtbl ViewAdviseSinkVtbl = {
4917     ViewAdviseSink_QueryInterface,
4918     AdviseSink_AddRef,
4919     AdviseSink_Release,
4920     AdviseSink_OnDataChange,
4921     ViewAdviseSink_OnViewChange,
4922     AdviseSink_OnRename,
4923     AdviseSink_OnSave,
4924     AdviseSink_OnClose,
4925     AdviseSinkEx_OnViewStatusChange
4926 };
4927
4928 static IAdviseSinkEx ViewAdviseSink = { &ViewAdviseSinkVtbl };
4929
4930 DEFINE_GUID(IID_unk1, 0xD48A6EC6,0x6A4A,0x11CF,0x94,0xA7,0x44,0x45,0x53,0x54,0x00,0x00); /* HTMLWindow2 ? */
4931 DEFINE_GUID(IID_IThumbnailView, 0x7BB0B520,0xB1A7,0x11D2,0xBB,0x23,0x00,0xC0,0x4F,0x79,0xAB,0xCD);
4932 DEFINE_GUID(IID_IRenMailEditor, 0x000670BA,0x0000,0x0000,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
4933 DEFINE_GUID(IID_unk4, 0x305104a6,0x98b5,0x11cf,0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b);
4934 DEFINE_GUID(IID_IDocHostUIHandlerPriv, 0xf0d241d1,0x5d0e,0x4e85,0xbc,0xb4,0xfa,0xd7,0xf7,0xc5,0x52,0x8c);
4935 DEFINE_GUID(IID_unk5, 0x5f95accc,0xd7a1,0x4574,0xbc,0xcb,0x69,0x71,0x35,0xbc,0x41,0xde);
4936
4937 static HRESULT QueryInterface(REFIID riid, void **ppv)
4938 {
4939     *ppv = NULL;
4940
4941     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
4942         *ppv = &ClientSite;
4943     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
4944         *ppv = &DocumentSite;
4945     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
4946         *ppv = &DocHostUIHandler;
4947     else if(IsEqualGUID(&IID_IOleContainer, riid))
4948         *ppv = &OleContainer;
4949     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
4950         *ppv = &InPlaceSiteWindowless;
4951     else if(IsEqualGUID(&IID_IOleCommandTarget , riid))
4952         *ppv = &OleCommandTarget;
4953     else if(IsEqualGUID(&IID_IDispatch, riid))
4954         *ppv = &Dispatch;
4955     else if(IsEqualGUID(&IID_IServiceProvider, riid))
4956         *ppv = &ServiceProvider;
4957     else if(IsEqualGUID(&IID_IOleInPlaceSiteEx, riid))
4958         *ppv = ipsex ? &InPlaceSiteWindowless : NULL;
4959     else if(IsEqualGUID(&IID_IOleInPlaceSiteWindowless, riid))
4960         *ppv = ipsw ? &InPlaceSiteWindowless : NULL;
4961     else if(IsEqualGUID(&IID_IOleControlSite, riid))
4962         *ppv = &OleControlSite;
4963     else if(IsEqualGUID(&IID_IDocHostShowUI, riid))
4964         return E_NOINTERFACE; /* TODO */
4965     else if(IsEqualGUID(&IID_IProxyManager, riid))
4966         return E_NOINTERFACE; /* ? */
4967     else if(IsEqualGUID(&IID_unk1, riid))
4968         return E_NOINTERFACE; /* HTMLWindow2 ? */
4969     else if(IsEqualGUID(&IID_IThumbnailView, riid))
4970         return E_NOINTERFACE; /* ? */
4971     else if(IsEqualGUID(&IID_IRenMailEditor, riid))
4972         return E_NOINTERFACE; /* ? */
4973     else if(IsEqualGUID(&IID_unk4, riid))
4974         return E_NOINTERFACE; /* ? */
4975     else if(IsEqualGUID(&IID_unk5, riid))
4976         return E_NOINTERFACE; /* IE10 */
4977     else if(IsEqualGUID(&IID_IDocHostUIHandlerPriv, riid))
4978         return E_NOINTERFACE; /* ? */
4979     else
4980         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
4981
4982     if(*ppv)
4983         return S_OK;
4984     return E_NOINTERFACE;
4985 }
4986
4987 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
4988 {
4989     if(msg == WM_CONTINUE_BINDING) {
4990         IBindStatusCallback *callback = (IBindStatusCallback*)wParam;
4991         continue_binding(callback);
4992     }
4993
4994     return DefWindowProc(hwnd, msg, wParam, lParam);
4995 }
4996
4997 static void test_doscroll(IUnknown *unk)
4998 {
4999     IHTMLDocument3 *doc;
5000     IHTMLElement2 *elem2;
5001     IHTMLElement *elem;
5002     VARIANT v;
5003     HRESULT hres;
5004
5005     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument3, (void**)&doc);
5006     ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
5007     if(FAILED(hres))
5008         return;
5009
5010     hres = IHTMLDocument3_get_documentElement(doc, &elem);
5011     IHTMLDocument3_Release(doc);
5012     ok(hres == S_OK, "get_documentElement failed: %08x\n", hres);
5013     switch(load_state) {
5014     case LD_DOLOAD:
5015     case LD_NO:
5016         if(!nav_url)
5017             ok(!elem, "elem != NULL\n");
5018     default:
5019         break;
5020     case LD_INTERACTIVE:
5021     case LD_COMPLETE:
5022         ok(elem != NULL, "elem == NULL\n");
5023     }
5024     if(!elem)
5025         return;
5026
5027     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLElement2, (void**)&elem2);
5028     IHTMLElement_Release(elem);
5029     ok(hres == S_OK, "Could not get IHTMLElement2 iface: %08x\n", hres);
5030
5031     V_VT(&v) = VT_BSTR;
5032     V_BSTR(&v) = a2bstr("left");
5033     hres = IHTMLElement2_doScroll(elem2, v);
5034     SysFreeString(V_BSTR(&v));
5035     IHTMLElement2_Release(elem2);
5036
5037     if(inplace_deactivated)
5038         ok(hres == E_PENDING, "doScroll failed: %08x\n", hres);
5039     else if(load_state == LD_COMPLETE)
5040         ok(hres == S_OK, "doScroll failed: %08x\n", hres);
5041     else
5042         ok(hres == E_PENDING || hres == S_OK, "doScroll failed: %08x\n", hres);
5043 }
5044
5045 static void _test_readyState(unsigned line, IUnknown *unk)
5046 {
5047     IHTMLDocument2 *htmldoc;
5048     DISPPARAMS dispparams;
5049     IHTMLElement *elem;
5050     BSTR state;
5051     VARIANT out;
5052     HRESULT hres;
5053
5054     static const LPCSTR expected_state[] = {
5055         "uninitialized",
5056         "loading",
5057         NULL,
5058         "interactive",
5059         "complete",
5060         "uninitialized"
5061     };
5062
5063     if(open_call)
5064         return; /* FIXME */
5065
5066     if(!unk)
5067         unk = doc_unk;
5068
5069     hres = IUnknown_QueryInterface(unk, &IID_IHTMLDocument2, (void**)&htmldoc);
5070     ok(hres == S_OK, "QueryInterface(IID_IHTMLDocument2) failed: %08x\n", hres);
5071     if(FAILED(hres))
5072         return;
5073
5074     hres = IHTMLDocument2_get_readyState(htmldoc, NULL);
5075     ok(hres == E_POINTER, "get_readyState failed: %08x, expected\n", hres);
5076
5077     hres = IHTMLDocument2_get_readyState(htmldoc, &state);
5078     ok(hres == S_OK, "get_ReadyState failed: %08x\n", hres);
5079
5080     if(!strcmp_wa(state, "interactive") && load_state == LD_LOADING)
5081         load_state = LD_INTERACTIVE;
5082
5083     ok_(__FILE__, line)
5084         (!strcmp_wa(state, expected_state[load_state]), "unexpected state %s, expected %d\n",
5085          wine_dbgstr_w(state), load_state);
5086     SysFreeString(state);
5087
5088     hres = IHTMLDocument2_get_body(htmldoc, &elem);
5089     ok_(__FILE__,line)(hres == S_OK, "get_body failed: %08x\n", hres);
5090     if(elem) {
5091         IHTMLElement2 *elem2;
5092         VARIANT var;
5093
5094         hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLElement2, (void**)&elem2);
5095         IHTMLElement_Release(elem);
5096         ok(hres == S_OK, "Could not get IHTMLElement2 iface: %08x\n", hres);
5097
5098         hres = IHTMLElement2_get_readyState(elem2, &var);
5099         IHTMLElement2_Release(elem2);
5100         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
5101         ok(V_VT(&var) == VT_BSTR, "V_VT(state) = %d\n", V_VT(&var));
5102         ok(!strcmp_wa(V_BSTR(&var), "complete"), "unexpected body state %s\n", wine_dbgstr_w(V_BSTR(&var)));
5103         VariantClear(&var);
5104     }else {
5105         ok_(__FILE__,line)(load_state != LD_COMPLETE, "body is NULL in complete state\n");
5106     }
5107
5108     dispparams.cArgs = 0;
5109     dispparams.cNamedArgs = 0;
5110     dispparams.rgdispidNamedArgs = NULL;
5111     dispparams.rgvarg = NULL;
5112
5113     VariantInit(&out);
5114
5115     hres = IHTMLDocument2_Invoke(htmldoc, DISPID_READYSTATE, &IID_NULL, 0, DISPATCH_PROPERTYGET,
5116                                  &dispparams, &out, NULL, NULL);
5117     ok(hres == S_OK, "Invoke(DISPID_READYSTATE) failed: %08x\n", hres);
5118
5119     ok_(__FILE__,line) (V_VT(&out) == VT_I4, "V_VT(out)=%d\n", V_VT(&out));
5120     ok_(__FILE__,line) (V_I4(&out) == load_state%5, "VT_I4(out)=%d, expected %d\n", V_I4(&out), load_state%5);
5121
5122     test_doscroll((IUnknown*)htmldoc);
5123
5124     IHTMLDocument2_Release(htmldoc);
5125 }
5126
5127 static void test_ViewAdviseSink(IHTMLDocument2 *doc)
5128 {
5129     IViewObject *view;
5130     HRESULT hres;
5131
5132     hres = IHTMLDocument2_QueryInterface(doc, &IID_IViewObject, (void**)&view);
5133     ok(hres == S_OK, "QueryInterface(IID_IViewObject) failed: %08x\n", hres);
5134
5135     hres = IViewObject_SetAdvise(view, DVASPECT_CONTENT, ADVF_PRIMEFIRST, (IAdviseSink*)&ViewAdviseSink);
5136     ok(hres == S_OK, "SetAdvise failed: %08x\n", hres);
5137
5138     IViewObject_Release(view);
5139 }
5140
5141 static void test_ConnectionPoint(IConnectionPointContainer *container, REFIID riid)
5142 {
5143     IConnectionPointContainer *tmp_container = NULL;
5144     IConnectionPoint *cp;
5145     IID iid;
5146     HRESULT hres;
5147     DWORD cookie;
5148
5149     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
5150     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
5151     if(FAILED(hres))
5152         return;
5153
5154     hres = IConnectionPoint_GetConnectionInterface(cp, &iid);
5155     ok(hres == S_OK, "GetConnectionInterface failed: %08x\n", hres);
5156     ok(IsEqualGUID(riid, &iid), "wrong iid\n");
5157
5158     hres = IConnectionPoint_GetConnectionInterface(cp, NULL);
5159     ok(hres == E_POINTER, "GetConnectionInterface failed: %08x, expected E_POINTER\n", hres);
5160
5161     hres = IConnectionPoint_GetConnectionPointContainer(cp, &tmp_container);
5162     ok(hres == S_OK, "GetConnectionPointContainer failed: %08x\n", hres);
5163     ok(tmp_container == container, "container != tmp_container\n");
5164     if(SUCCEEDED(hres))
5165         IConnectionPointContainer_Release(tmp_container);
5166
5167     hres = IConnectionPoint_GetConnectionPointContainer(cp, NULL);
5168     ok(hres == E_POINTER, "GetConnectionPointContainer failed: %08x, expected E_POINTER\n", hres);
5169
5170     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
5171         hres = IConnectionPoint_Advise(cp, (IUnknown*)&PropertyNotifySink, &cookie);
5172         ok(hres == S_OK, "Advise failed: %08x\n", hres);
5173         hres = IConnectionPoint_Unadvise(cp, cookie);
5174         ok(hres == S_OK, "Unadvise failed: %08x\n", hres);
5175         hres = IConnectionPoint_Advise(cp, (IUnknown*)&PropertyNotifySink, NULL);
5176         ok(hres == S_OK, "Advise failed: %08x\n", hres);
5177     } else if(IsEqualGUID(&IID_IDispatch, riid)) {
5178         hres = IConnectionPoint_Advise(cp, (IUnknown*)&EventDispatch, &cookie);
5179         ok(hres == S_OK, "Advise failed: %08x\n", hres);
5180     }
5181
5182     IConnectionPoint_Release(cp);
5183 }
5184
5185 static void test_ConnectionPointContainer(IHTMLDocument2 *doc)
5186 {
5187     IConnectionPointContainer *container;
5188     HRESULT hres;
5189
5190     hres = IHTMLDocument2_QueryInterface(doc, &IID_IConnectionPointContainer, (void**)&container);
5191     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
5192     if(FAILED(hres))
5193         return;
5194
5195     test_ConnectionPoint(container, &IID_IDispatch);
5196     test_ConnectionPoint(container, &IID_IPropertyNotifySink);
5197     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents);
5198     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents2);
5199
5200     IConnectionPointContainer_Release(container);
5201 }
5202
5203 static void set_custom_uihandler(IHTMLDocument2 *doc, IDocHostUIHandler2 *uihandler)
5204 {
5205     ICustomDoc *custom_doc;
5206     HRESULT hres;
5207
5208     hres = IHTMLDocument2_QueryInterface(doc, &IID_ICustomDoc, (void**)&custom_doc);
5209     ok(hres == S_OK, "Could not get ICustomDoc iface: %08x\n", hres);
5210
5211     expect_uihandler_iface = uihandler;
5212
5213     hres = ICustomDoc_SetUIHandler(custom_doc, (IDocHostUIHandler*)uihandler);
5214     ICustomDoc_Release(custom_doc);
5215     ok(hres == S_OK, "SetUIHandler failed: %08x\n", hres);
5216 }
5217
5218 static void test_Load(IPersistMoniker *persist, IMoniker *mon)
5219 {
5220     IBindCtx *bind;
5221     HRESULT hres;
5222     WCHAR sz_html_clientsite_objectparam[MAX_PATH];
5223
5224     lstrcpyW(sz_html_clientsite_objectparam, SZ_HTML_CLIENTSITE_OBJECTPARAM);
5225
5226     test_readyState((IUnknown*)persist);
5227
5228     doc_mon = mon;
5229
5230     CreateBindCtx(0, &bind);
5231     IBindCtx_RegisterObjectParam(bind, sz_html_clientsite_objectparam,
5232                                  (IUnknown*)&ClientSite);
5233
5234     if(mon == &Moniker)
5235         SET_EXPECT(GetDisplayName);
5236     if(!set_clientsite) {
5237         SET_EXPECT(Invoke_AMBIENT_USERMODE);
5238         SET_EXPECT(GetHostInfo);
5239         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
5240         SET_EXPECT(Invoke_AMBIENT_SILENT);
5241         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5242         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
5243         SET_EXPECT(Invoke_AMBIENT_PALETTE);
5244         SET_EXPECT(GetOptionKeyPath);
5245         SET_EXPECT(GetOverrideKeyPath);
5246         SET_EXPECT(GetWindow);
5247         SET_EXPECT(Exec_DOCCANNAVIGATE);
5248         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
5249         SET_EXPECT(Exec_SETPROGRESSMAX);
5250         SET_EXPECT(Exec_SETPROGRESSPOS);
5251         SET_EXPECT(Exec_ShellDocView_37);
5252     }
5253     if(!container_locked) {
5254         SET_EXPECT(GetContainer);
5255         SET_EXPECT(LockContainer);
5256     }
5257     SET_EXPECT(OnChanged_READYSTATE);
5258     SET_EXPECT(Invoke_OnReadyStateChange_Loading);
5259     SET_EXPECT(IsSystemMoniker);
5260     if(mon == &Moniker)
5261         SET_EXPECT(BindToStorage);
5262     SET_EXPECT(SetActiveObject);
5263     if(set_clientsite) {
5264         SET_EXPECT(Invoke_AMBIENT_SILENT);
5265         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5266         SET_EXPECT(Exec_ShellDocView_37);
5267         SET_EXPECT(IsErrorUrl);
5268     }else {
5269         SET_EXPECT(GetTravelLog);
5270     }
5271     SET_EXPECT(Exec_ShellDocView_84);
5272     SET_EXPECT(GetPendingUrl);
5273     load_state = LD_DOLOAD;
5274     expect_LockContainer_fLock = TRUE;
5275     readystate_set_loading = TRUE;
5276
5277     hres = IPersistMoniker_Load(persist, FALSE, mon, bind, 0x12);
5278     ok(hres == S_OK, "Load failed: %08x\n", hres);
5279
5280     if(mon == &Moniker)
5281         CHECK_CALLED(GetDisplayName);
5282     if(!set_clientsite) {
5283         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
5284         CHECK_CALLED(GetHostInfo);
5285         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
5286         CHECK_CALLED(Invoke_AMBIENT_SILENT);
5287         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5288         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
5289         CLEAR_CALLED(Invoke_AMBIENT_PALETTE); /* not called on IE9 */
5290         CLEAR_CALLED(GetOptionKeyPath); /* not called on some IE9 */
5291         CHECK_CALLED(GetOverrideKeyPath);
5292         CHECK_CALLED(GetWindow);
5293         CHECK_CALLED(Exec_DOCCANNAVIGATE);
5294         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
5295         CHECK_CALLED(Exec_SETPROGRESSMAX);
5296         CHECK_CALLED(Exec_SETPROGRESSPOS);
5297         CHECK_CALLED(Exec_ShellDocView_37);
5298     }
5299     if(!container_locked) {
5300         CHECK_CALLED(GetContainer);
5301         CHECK_CALLED(LockContainer);
5302         container_locked = TRUE;
5303     }
5304     CHECK_CALLED(OnChanged_READYSTATE);
5305     CHECK_CALLED(Invoke_OnReadyStateChange_Loading);
5306     CLEAR_CALLED(IsSystemMoniker); /* IE7 */
5307     if(mon == &Moniker)
5308         CHECK_CALLED(BindToStorage);
5309     CLEAR_CALLED(SetActiveObject); /* FIXME */
5310     if(set_clientsite) {
5311         CHECK_CALLED(Invoke_AMBIENT_SILENT);
5312         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5313         CHECK_CALLED(Exec_ShellDocView_37);
5314         todo_wine CHECK_CALLED_BROKEN(IsErrorUrl);
5315     }else {
5316         CHECK_CALLED(GetTravelLog);
5317     }
5318     CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
5319     todo_wine CHECK_CALLED(GetPendingUrl);
5320
5321     set_clientsite = container_locked = TRUE;
5322
5323     test_GetCurMoniker((IUnknown*)persist, mon, NULL);
5324
5325     IBindCtx_Release(bind);
5326
5327     test_readyState((IUnknown*)persist);
5328 }
5329
5330 #define DWL_VERBDONE           0x0001
5331 #define DWL_CSS                0x0002
5332 #define DWL_TRYCSS             0x0004
5333 #define DWL_HTTP               0x0008
5334 #define DWL_EMPTY              0x0010
5335 #define DWL_JAVASCRIPT         0x0020
5336 #define DWL_ONREADY_LOADING    0x0040
5337 #define DWL_EXPECT_HISTUPDATE  0x0080
5338 #define DWL_FROM_HISTORY       0x0100
5339 #define DWL_REFRESH            0x0200
5340 #define DWL_EX_GETHOSTINFO     0x0400
5341
5342 static void test_download(DWORD flags)
5343 {
5344     const BOOL is_js = (flags & DWL_JAVASCRIPT) != 0;
5345     HWND hwnd;
5346     BOOL *b;
5347     MSG msg;
5348
5349     b = is_js ? &called_Exec_SETDOWNLOADSTATE_0 : &called_Exec_HTTPEQUIV_DONE;
5350     is_refresh = (flags & DWL_REFRESH) != 0;
5351
5352     hwnd = FindWindowA("Internet Explorer_Hidden", NULL);
5353     ok(hwnd != NULL, "Could not find hidden window\n");
5354
5355     test_readyState(NULL);
5356
5357     if(flags & DWL_REFRESH) {
5358         SET_EXPECT(Invoke_AMBIENT_SILENT);
5359         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5360     }
5361     if(flags & (DWL_VERBDONE|DWL_HTTP))
5362         SET_EXPECT(Exec_SETPROGRESSMAX);
5363     if(flags & DWL_EX_GETHOSTINFO)
5364         SET_EXPECT(GetHostInfo);
5365     SET_EXPECT(SetStatusText);
5366     if(!(flags & DWL_EMPTY))
5367         SET_EXPECT(Exec_SETDOWNLOADSTATE_1);
5368     if(is_js)
5369         SET_EXPECT(GetExternal);
5370     SET_EXPECT(OnViewChange);
5371     SET_EXPECT(GetDropTarget);
5372     if((flags & DWL_TRYCSS) && !(flags & DWL_EMPTY))
5373         SET_EXPECT(Exec_ShellDocView_84);
5374     if(flags & DWL_CSS) {
5375         SET_EXPECT(CreateInstance);
5376         SET_EXPECT(Start);
5377         SET_EXPECT(LockRequest);
5378         SET_EXPECT(Terminate);
5379         SET_EXPECT(Protocol_Read);
5380         SET_EXPECT(UnlockRequest);
5381     }
5382     if(flags & DWL_ONREADY_LOADING)
5383         SET_EXPECT(Invoke_OnReadyStateChange_Loading);
5384     if(!(flags & (DWL_EMPTY|DWL_JAVASCRIPT)))
5385         SET_EXPECT(Invoke_OnReadyStateChange_Interactive);
5386     if(!is_js)
5387         SET_EXPECT(Invoke_OnReadyStateChange_Complete);
5388     SET_EXPECT(Exec_Explorer_69);
5389     SET_EXPECT(EnableModeless_TRUE); /* IE7 */
5390     SET_EXPECT(Frame_EnableModeless_TRUE); /* IE7 */
5391     SET_EXPECT(EnableModeless_FALSE); /* IE7 */
5392     SET_EXPECT(Frame_EnableModeless_FALSE); /* IE7 */
5393     if((nav_url && !is_js) || (flags & (DWL_CSS|DWL_HTTP)))
5394         SET_EXPECT(Exec_ShellDocView_37);
5395     if(flags & DWL_HTTP) {
5396         if(!(flags & DWL_FROM_HISTORY))
5397             SET_EXPECT(OnChanged_1012);
5398         SET_EXPECT(Exec_HTTPEQUIV);
5399         SET_EXPECT(Exec_SETTITLE);
5400     }
5401     if(!is_js)
5402         SET_EXPECT(OnChanged_1005);
5403     SET_EXPECT(OnChanged_READYSTATE);
5404     SET_EXPECT(Exec_SETPROGRESSPOS);
5405     if(!(flags & DWL_EMPTY))
5406         SET_EXPECT(Exec_SETDOWNLOADSTATE_0);
5407     SET_EXPECT(Exec_ShellDocView_103);
5408     SET_EXPECT(Exec_ShellDocView_105);
5409     SET_EXPECT(Exec_ShellDocView_140);
5410     if(!is_js) {
5411         SET_EXPECT(Exec_MSHTML_PARSECOMPLETE);
5412         if(support_wbapp) /* Called on some Vista installations */
5413             SET_EXPECT(CountEntries);
5414         SET_EXPECT(Exec_HTTPEQUIV_DONE);
5415     }
5416     SET_EXPECT(SetStatusText);
5417     if(nav_url || support_wbapp) {
5418         SET_EXPECT(UpdateUI);
5419         SET_EXPECT(Exec_UPDATECOMMANDS);
5420         SET_EXPECT(Exec_SETTITLE);
5421         if(flags & DWL_EXPECT_HISTUPDATE)
5422             SET_EXPECT(Exec_Explorer_38);
5423         SET_EXPECT(UpdateBackForwardState);
5424     }
5425     if(!is_js) {
5426         if(!editmode && !(flags & DWL_REFRESH)) {
5427             if(!(flags & DWL_EMPTY))
5428                 SET_EXPECT(FireNavigateComplete2);
5429             SET_EXPECT(FireDocumentComplete);
5430         }
5431         SET_EXPECT(ActiveElementChanged);
5432     }
5433     SET_EXPECT(IsErrorUrl);
5434     expect_status_text = (LPWSTR)0xdeadbeef; /* TODO */
5435
5436     while(!*b && GetMessage(&msg, NULL, 0, 0)) {
5437         TranslateMessage(&msg);
5438         DispatchMessage(&msg);
5439     }
5440
5441     if(flags & DWL_REFRESH) {
5442         CHECK_CALLED(Invoke_AMBIENT_SILENT);
5443         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5444     }
5445     if(flags & DWL_VERBDONE)
5446         CHECK_CALLED(Exec_SETPROGRESSMAX);
5447     if(flags & DWL_HTTP)
5448         SET_CALLED(Exec_SETPROGRESSMAX);
5449     if(flags &  DWL_EX_GETHOSTINFO) {
5450         if(nav_url)
5451             todo_wine CHECK_CALLED(GetHostInfo);
5452         else
5453             CHECK_CALLED(GetHostInfo);
5454     }
5455     CHECK_CALLED(SetStatusText);
5456     if(!(flags & DWL_EMPTY))
5457         CHECK_CALLED(Exec_SETDOWNLOADSTATE_1);
5458     if(is_js)
5459         CHECK_CALLED(GetExternal);
5460     CHECK_CALLED(OnViewChange);
5461     CLEAR_CALLED(GetDropTarget);
5462     if((flags & DWL_TRYCSS) && !(flags & DWL_EMPTY))
5463         todo_wine CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
5464     if(flags & DWL_CSS) {
5465         CHECK_CALLED(CreateInstance);
5466         CHECK_CALLED(Start);
5467         CHECK_CALLED(LockRequest);
5468         CHECK_CALLED(Terminate);
5469         CHECK_CALLED(Protocol_Read);
5470         CHECK_CALLED(UnlockRequest);
5471     }
5472     if(flags & DWL_ONREADY_LOADING)
5473         CHECK_CALLED(Invoke_OnReadyStateChange_Loading);
5474     if(!(flags & (DWL_EMPTY|DWL_JAVASCRIPT)))
5475         CHECK_CALLED(Invoke_OnReadyStateChange_Interactive);
5476     if(!is_js)
5477         CHECK_CALLED(Invoke_OnReadyStateChange_Complete);
5478     SET_CALLED(Exec_Explorer_69);
5479     SET_CALLED(EnableModeless_TRUE); /* IE7 */
5480     SET_CALLED(Frame_EnableModeless_TRUE); /* IE7 */
5481     SET_CALLED(EnableModeless_FALSE); /* IE7 */
5482     SET_CALLED(Frame_EnableModeless_FALSE); /* IE7 */
5483     if(nav_url && !is_js && !(flags & DWL_REFRESH))
5484         todo_wine CHECK_CALLED(Exec_ShellDocView_37);
5485     else if(flags & (DWL_CSS|DWL_HTTP))
5486         CLEAR_CALLED(Exec_ShellDocView_37); /* Called by IE9 */
5487     if(flags & DWL_HTTP)  {
5488         if(!(flags & DWL_FROM_HISTORY))
5489             todo_wine CHECK_CALLED(OnChanged_1012);
5490         todo_wine CHECK_CALLED(Exec_HTTPEQUIV);
5491         if(!(flags & DWL_REFRESH))
5492             todo_wine CHECK_CALLED(Exec_SETTITLE);
5493         else
5494             CHECK_CALLED(Exec_SETTITLE);
5495     }
5496     if(!is_js) {
5497         CHECK_CALLED(OnChanged_1005);
5498         CHECK_CALLED(OnChanged_READYSTATE);
5499         CHECK_CALLED(Exec_SETPROGRESSPOS);
5500     }else {
5501         CLEAR_CALLED(OnChanged_READYSTATE); /* sometimes called */
5502         todo_wine CHECK_CALLED(Exec_SETPROGRESSPOS);
5503     }
5504     if(!(flags & DWL_EMPTY))
5505         CHECK_CALLED(Exec_SETDOWNLOADSTATE_0);
5506     CLEAR_CALLED(Exec_ShellDocView_103);
5507     CLEAR_CALLED(Exec_ShellDocView_105);
5508     CLEAR_CALLED(Exec_ShellDocView_140);
5509     if(!is_js) {
5510         CHECK_CALLED(Exec_MSHTML_PARSECOMPLETE);
5511         if(support_wbapp) /* Called on some Vista installations */
5512             CLEAR_CALLED(CountEntries);
5513         CHECK_CALLED(Exec_HTTPEQUIV_DONE);
5514     }
5515     SET_CALLED(SetStatusText);
5516     if(nav_url || support_wbapp) { /* avoiding race, FIXME: find better way */
5517         CLEAR_CALLED(UpdateUI);
5518         CLEAR_CALLED(Exec_UPDATECOMMANDS);
5519         CLEAR_CALLED(Exec_SETTITLE);
5520         if(flags & DWL_EXPECT_HISTUPDATE)
5521             CHECK_CALLED(Exec_Explorer_38);
5522         todo_wine CHECK_CALLED_BROKEN(UpdateBackForwardState);
5523     }
5524     if(!is_js) {
5525         if(!editmode && !(flags & DWL_REFRESH)) {
5526             if(!(flags & DWL_EMPTY)) {
5527                 if(support_wbapp)
5528                     CHECK_CALLED(FireNavigateComplete2);
5529                 else
5530                     todo_wine CHECK_CALLED(FireNavigateComplete2);
5531             }
5532             CHECK_CALLED(FireDocumentComplete);
5533         }
5534         todo_wine CHECK_CALLED(ActiveElementChanged);
5535     }
5536     todo_wine CHECK_CALLED_BROKEN(IsErrorUrl);
5537
5538     load_state = LD_COMPLETE;
5539
5540     test_readyState(NULL);
5541 }
5542
5543 static void test_Persist(IHTMLDocument2 *doc, IMoniker *mon)
5544 {
5545     IPersistMoniker *persist_mon;
5546     IPersistFile *persist_file;
5547     GUID guid;
5548     HRESULT hres;
5549
5550     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistFile, (void**)&persist_file);
5551     ok(hres == S_OK, "QueryInterface(IID_IPersist) failed: %08x\n", hres);
5552     if(SUCCEEDED(hres)) {
5553         hres = IPersistFile_GetClassID(persist_file, NULL);
5554         ok(hres == E_INVALIDARG, "GetClassID returned: %08x, expected E_INVALIDARG\n", hres);
5555
5556         hres = IPersistFile_GetClassID(persist_file, &guid);
5557         ok(hres == S_OK, "GetClassID failed: %08x\n", hres);
5558         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
5559
5560         IPersistFile_Release(persist_file);
5561     }
5562
5563     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistMoniker, (void**)&persist_mon);
5564     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08x\n", hres);
5565     if(SUCCEEDED(hres)) {
5566         hres = IPersistMoniker_GetClassID(persist_mon, NULL);
5567         ok(hres == E_INVALIDARG, "GetClassID returned: %08x, expected E_INVALIDARG\n", hres);
5568
5569         hres = IPersistMoniker_GetClassID(persist_mon, &guid);
5570         ok(hres == S_OK, "GetClassID failed: %08x\n", hres);
5571         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
5572
5573         if(load_state == LD_DOLOAD)
5574             test_Load(persist_mon, mon);
5575
5576         test_readyState((IUnknown*)doc);
5577
5578         IPersistMoniker_Release(persist_mon);
5579     }
5580 }
5581
5582 static void test_put_href(IHTMLDocument2 *doc, BOOL use_replace, const char *href, const char *new_nav_url, BOOL is_js,
5583         BOOL is_hash, DWORD dwl_flags)
5584 {
5585     const char *prev_nav_url = NULL;
5586     IHTMLPrivateWindow *priv_window;
5587     IHTMLLocation *location;
5588     IHTMLWindow2 *window;
5589     BSTR str, str2;
5590     HRESULT hres;
5591
5592     trace("put_href %s...\n", new_nav_url);
5593
5594     loading_js = is_js;
5595     loading_hash = is_hash;
5596
5597     location = NULL;
5598     hres = IHTMLDocument2_get_location(doc, &location);
5599     ok(hres == S_OK, "get_location failed: %08x\n", hres);
5600     ok(location != NULL, "location == NULL\n");
5601
5602     prev_url = prev_nav_url = nav_url;
5603     nav_url = new_nav_url;
5604     if(!loading_hash)
5605         nav_serv_url = new_nav_url;
5606     if(!href)
5607         href = new_nav_url;
5608
5609     str = a2bstr(href);
5610     SET_EXPECT(TranslateUrl);
5611     if(support_wbapp) {
5612         SET_EXPECT(FireBeforeNavigate2);
5613         SET_EXPECT(Exec_ShellDocView_67);
5614         if(!is_hash) {
5615             SET_EXPECT(Invoke_AMBIENT_SILENT);
5616             SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5617             SET_EXPECT(Exec_ShellDocView_63);
5618             SET_EXPECT(Exec_ShellDocView_84);
5619         }else {
5620             SET_EXPECT(FireNavigateComplete2);
5621             SET_EXPECT(FireDocumentComplete);
5622         }
5623     }else {
5624         SET_EXPECT(Navigate);
5625     }
5626     if(use_replace) {
5627         hres = IHTMLLocation_replace(location, str);
5628         ok(hres == S_OK, "put_href failed: %08x\n", hres);
5629     }else {
5630         hres = IHTMLLocation_put_href(location, str);
5631         if(is_js && hres == E_ACCESSDENIED)
5632             win_skip("put_href: got E_ACCESSDENIED\n");
5633         else
5634             ok(hres == S_OK, "put_href failed: %08x\n", hres);
5635     }
5636     SysFreeString(str);
5637     if(hres == S_OK) {
5638         CHECK_CALLED(TranslateUrl);
5639         if(support_wbapp) {
5640             CHECK_CALLED(FireBeforeNavigate2);
5641             CHECK_CALLED(Exec_ShellDocView_67);
5642             if(!is_hash) {
5643                 CHECK_CALLED(Invoke_AMBIENT_SILENT);
5644                 CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5645                 CHECK_CALLED(Exec_ShellDocView_63);
5646                 CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
5647             }else {
5648                 CHECK_CALLED(FireNavigateComplete2);
5649                 CHECK_CALLED(FireDocumentComplete);
5650             }
5651         }else {
5652             CHECK_CALLED(Navigate);
5653         }
5654     }else {
5655         CLEAR_CALLED(TranslateUrl);
5656         if(support_wbapp) {
5657             CLEAR_CALLED(FireBeforeNavigate2);
5658             SET_CALLED(Exec_ShellDocView_67);
5659             if(!is_hash) {
5660                 CLEAR_CALLED(Invoke_AMBIENT_SILENT);
5661                 CLEAR_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5662                 CLEAR_CALLED(Exec_ShellDocView_63);
5663                 todo_wine CLEAR_CALLED(Exec_ShellDocView_84);
5664             }else {
5665                 CLEAR_CALLED(FireNavigateComplete2);
5666                 CLEAR_CALLED(FireDocumentComplete);
5667             }
5668         }else {
5669             CLEAR_CALLED(Navigate);
5670         }
5671     }
5672
5673     IHTMLLocation_Release(location);
5674
5675     if(is_js && hres == E_ACCESSDENIED) {
5676         nav_url = prev_nav_url;
5677         return;
5678     }
5679
5680     hres = IHTMLDocument2_get_parentWindow(doc, &window);
5681     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
5682
5683     hres = IHTMLWindow2_QueryInterface(window, &IID_IHTMLPrivateWindow, (void**)&priv_window);
5684     IHTMLWindow2_Release(window);
5685     ok(hres == S_OK, "QueryInterface(IID_IHTMLPrivateWindow) failed: %08x\n", hres);
5686
5687     if(!support_wbapp) {
5688         VARIANT vempty;
5689
5690         readystate_set_loading = TRUE;
5691         SET_EXPECT(TranslateUrl);
5692         SET_EXPECT(Exec_ShellDocView_67);
5693         SET_EXPECT(Invoke_AMBIENT_SILENT);
5694         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5695         SET_EXPECT(Exec_ShellDocView_63);
5696         SET_EXPECT(Exec_ShellDocView_84);
5697
5698         str = a2bstr(nav_url);
5699         str2 = a2bstr("");
5700         V_VT(&vempty) = VT_EMPTY;
5701         hres = IHTMLPrivateWindow_SuperNavigate(priv_window, str, str2, NULL, NULL, &vempty, &vempty, 0);
5702         SysFreeString(str);
5703         SysFreeString(str2);
5704         ok(hres == S_OK, "SuperNavigate failed: %08x\n", hres);
5705
5706         CHECK_CALLED(TranslateUrl);
5707         CHECK_CALLED(Exec_ShellDocView_67);
5708         CHECK_CALLED(Invoke_AMBIENT_SILENT);
5709         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5710         CHECK_CALLED(Exec_ShellDocView_63);
5711         CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
5712     }
5713
5714     if(doc_mon) {
5715         test_GetCurMoniker(doc_unk, doc_mon, NULL);
5716         doc_mon = NULL;
5717     }
5718
5719     if(!is_hash) {
5720         hres = IHTMLPrivateWindow_GetAddressBarUrl(priv_window, &str2);
5721         ok(hres == S_OK, "GetAddressBarUrl failed: %08x\n", hres);
5722         ok(!strcmp_wa(str2, prev_nav_url), "unexpected address bar url:  %s, expected %s\n", wine_dbgstr_w(str2), prev_nav_url);
5723         SysFreeString(str2);
5724
5725         if(is_js)
5726             ignore_external_qi = TRUE;
5727         test_download(DWL_VERBDONE | (is_js ? DWL_JAVASCRIPT : DWL_ONREADY_LOADING|DWL_EX_GETHOSTINFO) | dwl_flags);
5728         if(is_js)
5729             ignore_external_qi = FALSE;
5730
5731     }
5732
5733     hres = IHTMLPrivateWindow_GetAddressBarUrl(priv_window, &str2);
5734     ok(hres == S_OK, "GetAddressBarUrl failed: %08x\n", hres);
5735     if(is_js)
5736         ok(!strcmp_wa(str2, prev_nav_url), "unexpected address bar url:  %s\n", wine_dbgstr_w(str2));
5737     else
5738         ok(!strcmp_wa(str2, nav_url), "unexpected address bar url:  %s\n", wine_dbgstr_w(str2));
5739     SysFreeString(str2);
5740     IHTMLPrivateWindow_Release(priv_window);
5741
5742     loading_js = FALSE;
5743     if(is_js)
5744         nav_url = prev_nav_url;
5745 }
5746
5747 static void test_load_history(IHTMLDocument2 *doc)
5748 {
5749     IPersistHistory *per_hist;
5750     HRESULT hres;
5751
5752     trace("LoadHistory...\n");
5753
5754     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistHistory, (void**)&per_hist);
5755     ok(hres == S_OK, "Could not get IPersistHistory iface: %08x\n", hres);
5756
5757     prev_url = nav_url;
5758     nav_url = "http://test.winehq.org/tests/winehq_snapshot/#test";
5759     nav_serv_url = "http://test.winehq.org/tests/winehq_snapshot/";
5760
5761     SET_EXPECT(Exec_ShellDocView_138);
5762     SET_EXPECT(Exec_ShellDocView_67);
5763     SET_EXPECT(FireBeforeNavigate2);
5764     SET_EXPECT(Invoke_AMBIENT_SILENT);
5765     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5766
5767     hres = IPersistHistory_LoadHistory(per_hist, history_stream, NULL);
5768     ok(hres == S_OK, "LoadHistory failed: %08x\n", hres);
5769
5770     CHECK_CALLED_BROKEN(Exec_ShellDocView_138);
5771     CHECK_CALLED(Exec_ShellDocView_67);
5772     CHECK_CALLED(FireBeforeNavigate2);
5773     CHECK_CALLED(Invoke_AMBIENT_SILENT);
5774     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
5775
5776     load_state = LD_LOADING;
5777     test_timer(EXPECT_UPDATEUI|EXPECT_SETTITLE);
5778
5779     test_download(DWL_VERBDONE|DWL_HTTP|DWL_EXPECT_HISTUPDATE|DWL_ONREADY_LOADING|DWL_FROM_HISTORY|DWL_EX_GETHOSTINFO);
5780
5781     IPersistHistory_Release(per_hist);
5782     IStream_Release(history_stream);
5783     history_stream = NULL;
5784 }
5785
5786 static void test_OmHistory(IHTMLDocument2 *doc)
5787 {
5788     IHTMLWindow2 *win;
5789     IOmHistory *hist;
5790     short len;
5791     HRESULT hres;
5792
5793     hres = IHTMLDocument2_get_parentWindow(doc, &win);
5794     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
5795
5796     hres = IHTMLWindow2_get_history(win, &hist);
5797     ok(hres == S_OK, "get_history failed: %08x\n", hres);
5798     IHTMLWindow2_Release(win);
5799
5800     SET_EXPECT(CountEntries);
5801     hres = IOmHistory_get_length(hist, &len);
5802     CHECK_CALLED(CountEntries);
5803     ok(hres == S_OK, "get_length failed: %08x\n", hres);
5804     ok(len == 0, "len = %d\n", len);
5805
5806     IOmHistory_Release(hist);
5807 }
5808
5809 static void test_refresh(IHTMLDocument2 *doc)
5810 {
5811     IOleCommandTarget *cmdtrg;
5812     VARIANT vin, vout;
5813     HRESULT hres;
5814
5815     trace("Refresh...\n");
5816
5817     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleCommandTarget, (void**)&cmdtrg);
5818     ok(hres == S_OK, "Could not get IOleCommandTarget iface: %08x\n", hres);
5819
5820     V_VT(&vin) = VT_EMPTY;
5821     V_VT(&vout) = VT_EMPTY;
5822     SET_EXPECT(Exec_DocHostCommandHandler_2300);
5823     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_REFRESH, OLECMDEXECOPT_PROMPTUSER, &vin, &vout);
5824     ok(hres == S_OK, "Exec failed: %08x\n", hres);
5825     ok(V_VT(&vout) == VT_EMPTY, "V_VT(vout) = %d\n", V_VT(&vout));
5826     CHECK_CALLED(Exec_DocHostCommandHandler_2300);
5827
5828     IOleCommandTarget_Release(cmdtrg);
5829
5830     test_download(DWL_VERBDONE|DWL_HTTP|DWL_ONREADY_LOADING|DWL_REFRESH|DWL_EX_GETHOSTINFO);
5831 }
5832
5833 static void test_open_window(IHTMLDocument2 *doc, BOOL do_block)
5834 {
5835     IHTMLWindow2 *window, *new_window;
5836     BSTR name, url;
5837     HRESULT hres;
5838
5839     allow_new_window = !do_block;
5840
5841     hres = IHTMLDocument2_get_parentWindow(doc, &window);
5842     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
5843
5844     url = a2bstr(nav_serv_url = nav_url = "about:blank");
5845     name = a2bstr("test");
5846     new_window = (void*)0xdeadbeef;
5847
5848     trace("open...\n");
5849     open_call = TRUE;
5850
5851     if(support_wbapp)
5852         SET_EXPECT(get_LocationURL);
5853     SET_EXPECT(TranslateUrl);
5854     SET_EXPECT(EvaluateNewWindow);
5855
5856     hres = IHTMLWindow2_open(window, url, name, NULL, VARIANT_FALSE, &new_window);
5857     open_call = FALSE;
5858     SysFreeString(url);
5859     SysFreeString(name);
5860
5861     if(support_wbapp)
5862         todo_wine CHECK_CALLED_BROKEN(get_LocationURL);
5863     todo_wine
5864     CHECK_CALLED(TranslateUrl);
5865
5866     if(!called_EvaluateNewWindow) {
5867         win_skip("INewWindowManager not supported\n");
5868         if(SUCCEEDED(hres) && new_window)
5869             IHTMLWindow2_Release(new_window);
5870         IHTMLWindow2_Release(window);
5871         return;
5872     }
5873     CHECK_CALLED(EvaluateNewWindow);
5874
5875     ok(hres == S_OK, "open failed: %08x\n", hres);
5876
5877     if(do_block) {
5878         ok(!new_window, "new_window != NULL\n");
5879     }else {
5880         ok(new_window != NULL, "new_window == NULL\n");
5881
5882         hres = IHTMLWindow2_close(new_window);
5883         ok(hres == S_OK, "close failed: %08x\n", hres);
5884         IHTMLWindow2_Release(new_window);
5885     }
5886
5887     IHTMLWindow2_Release(window);
5888 }
5889
5890 static void test_window_close(IHTMLDocument2 *doc)
5891 {
5892     IHTMLWindow2 *window;
5893     HRESULT hres;
5894
5895     hres = IHTMLDocument2_get_parentWindow(doc, &window);
5896     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
5897
5898     SET_EXPECT(FindConnectionPoint);
5899     SET_EXPECT(EnumConnections);
5900     SET_EXPECT(EnumConnections_Next);
5901     SET_EXPECT(WindowClosing);
5902
5903     hres = IHTMLWindow2_close(window);
5904     ok(hres == S_OK, "close failed: %08x\n", hres);
5905
5906     CHECK_CALLED(FindConnectionPoint);
5907     CHECK_CALLED(EnumConnections);
5908     CHECK_CALLED(EnumConnections_Next);
5909     CHECK_CALLED(WindowClosing);
5910
5911     IHTMLWindow2_Release(window);
5912 }
5913
5914 static void test_elem_from_point(IHTMLDocument2 *doc)
5915 {
5916     IHTMLElement *elem;
5917     BSTR tag;
5918     HRESULT hres;
5919
5920     elem = NULL;
5921     hres = IHTMLDocument2_elementFromPoint(doc, 3, 3, &elem);
5922     ok(hres == S_OK, "elementFromPoint failed: %08x\n", hres);
5923     ok(elem != NULL, "elem == NULL\n");
5924
5925     hres = IHTMLElement_get_tagName(elem, &tag);
5926     IHTMLElement_Release(elem);
5927     ok(hres == S_OK, "get_tagName failed: %08x\n", hres);
5928     ok(!strcmp_wa(tag, "DIV"), "tag = %s\n", wine_dbgstr_w(tag));
5929 }
5930
5931 static void test_clear(IHTMLDocument2 *doc)
5932 {
5933     HRESULT hres;
5934
5935     hres = IHTMLDocument2_clear(doc);
5936     ok(hres == S_OK, "clear failed: %08x\n", hres);
5937 }
5938
5939 static const OLECMDF expect_cmds[OLECMDID_GETPRINTTEMPLATE+1] = {
5940     0,
5941     OLECMDF_SUPPORTED,                  /* OLECMDID_OPEN */
5942     OLECMDF_SUPPORTED,                  /* OLECMDID_NEW */
5943     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVE */
5944     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SAVEAS */
5945     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVECOPYAS */
5946     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINT */
5947     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINTPREVIEW */
5948     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PAGESETUP */
5949     OLECMDF_SUPPORTED,                  /* OLECMDID_SPELL */
5950     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PROPERTIES */
5951     OLECMDF_SUPPORTED,                  /* OLECMDID_CUT */
5952     OLECMDF_SUPPORTED,                  /* OLECMDID_COPY */
5953     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTE */
5954     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTESPECIAL */
5955     OLECMDF_SUPPORTED,                  /* OLECMDID_UNDO */
5956     OLECMDF_SUPPORTED,                  /* OLECMDID_REDO */
5957     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SELECTALL */
5958     OLECMDF_SUPPORTED,                  /* OLECMDID_CLEARSELECTION */
5959     OLECMDF_SUPPORTED,                  /* OLECMDID_ZOOM */
5960     OLECMDF_SUPPORTED,                  /* OLECMDID_GETZOOMRANGE */
5961     0,
5962     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_REFRESH */
5963     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_STOP */
5964     0,0,0,0,0,0,
5965     OLECMDF_SUPPORTED,                  /* OLECMDID_STOPDOWNLOAD */
5966     0,0,
5967     OLECMDF_SUPPORTED,                  /* OLECMDID_DELETE */
5968     0,0,
5969     OLECMDF_SUPPORTED,                  /* OLECMDID_ENABLE_INTERACTION */
5970     OLECMDF_SUPPORTED,                  /* OLECMDID_ONUNLOAD */
5971     0,0,0,0,0,
5972     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPAGESETUP */
5973     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPRINT */
5974     0,0,
5975     OLECMDF_SUPPORTED,                  /* OLECMDID_CLOSE */
5976     0,0,0,
5977     OLECMDF_SUPPORTED,                  /* OLECMDID_SETPRINTTEMPLATE */
5978     OLECMDF_SUPPORTED                   /* OLECMDID_GETPRINTTEMPLATE */
5979 };
5980
5981 #define test_QueryStatus(u,cgid,cmdid,cmdf) _test_QueryStatus(__LINE__,u,cgid,cmdid,cmdf)
5982 static void _test_QueryStatus(unsigned line, IUnknown *unk, REFIID cgid, ULONG cmdid, DWORD cmdf)
5983 {
5984     IOleCommandTarget *cmdtrg;
5985     OLECMD olecmd = {cmdid, 0};
5986     HRESULT hres;
5987
5988     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
5989     ok_(__FILE__,line) (hres == S_OK, "QueryInterface(IID_IOleCommandTarget failed: %08x\n", hres);
5990     if(FAILED(hres))
5991         return;
5992
5993     hres = IOleCommandTarget_QueryStatus(cmdtrg, cgid, 1, &olecmd, NULL);
5994     ok(hres == S_OK, "QueryStatus(%u) failed: %08x\n", cmdid, hres);
5995
5996     IOleCommandTarget_Release(cmdtrg);
5997
5998     ok_(__FILE__,line) (olecmd.cmdID == cmdid, "cmdID changed\n");
5999     ok_(__FILE__,line) (olecmd.cmdf == cmdf, "(%u) cmdf=%08x, expected %08x\n", cmdid, olecmd.cmdf, cmdf);
6000 }
6001
6002 static void test_MSHTML_QueryStatus(IHTMLDocument2 *doc, DWORD cmdf)
6003 {
6004     IUnknown *unk = doc ? (IUnknown*)doc : doc_unk;
6005
6006     test_QueryStatus(unk, &CGID_MSHTML, IDM_FONTNAME, cmdf);
6007     test_QueryStatus(unk, &CGID_MSHTML, IDM_FONTSIZE, cmdf);
6008     test_QueryStatus(unk, &CGID_MSHTML, IDM_SELECTALL, cmdf|OLECMDF_ENABLED);
6009     test_QueryStatus(unk, &CGID_MSHTML, IDM_BOLD, cmdf);
6010     test_QueryStatus(unk, &CGID_MSHTML, IDM_FORECOLOR, cmdf);
6011     test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYCENTER, cmdf);
6012     test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYLEFT, cmdf);
6013     test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYRIGHT, cmdf);
6014     test_QueryStatus(unk, &CGID_MSHTML, IDM_ITALIC, cmdf);
6015     test_QueryStatus(unk, &CGID_MSHTML, IDM_UNDERLINE, cmdf);
6016     test_QueryStatus(unk, &CGID_MSHTML, IDM_HORIZONTALLINE, cmdf);
6017     test_QueryStatus(unk, &CGID_MSHTML, IDM_ORDERLIST, cmdf);
6018     test_QueryStatus(unk, &CGID_MSHTML, IDM_UNORDERLIST, cmdf);
6019     test_QueryStatus(unk, &CGID_MSHTML, IDM_INDENT, cmdf);
6020     test_QueryStatus(unk, &CGID_MSHTML, IDM_OUTDENT, cmdf);
6021     test_QueryStatus(unk, &CGID_MSHTML, IDM_DELETE, cmdf);
6022 }
6023
6024 static void test_OleCommandTarget(IHTMLDocument2 *doc)
6025 {
6026     IOleCommandTarget *cmdtrg;
6027     OLECMD cmds[OLECMDID_GETPRINTTEMPLATE];
6028     int i;
6029     HRESULT hres;
6030
6031     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleCommandTarget, (void**)&cmdtrg);
6032     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget failed: %08x\n", hres);
6033     if(FAILED(hres))
6034         return;
6035
6036     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
6037         cmds[i].cmdID = i+1;
6038         cmds[i].cmdf = 0xf0f0;
6039     }
6040
6041     SET_EXPECT(QueryStatus_OPEN);
6042     SET_EXPECT(QueryStatus_NEW);
6043     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, sizeof(cmds)/sizeof(cmds[0]), cmds, NULL);
6044     ok(hres == S_OK, "QueryStatus failed: %08x\n", hres);
6045     CHECK_CALLED(QueryStatus_OPEN);
6046     CHECK_CALLED(QueryStatus_NEW);
6047
6048     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
6049         ok(cmds[i].cmdID == i+1, "cmds[%d].cmdID canged to %x\n", i, cmds[i].cmdID);
6050         if(i+1 == OLECMDID_FIND)
6051             continue;
6052         ok(cmds[i].cmdf == expect_cmds[i+1], "cmds[%d].cmdf=%x, expected %x\n",
6053                 i+1, cmds[i].cmdf, expect_cmds[i+1]);
6054     }
6055
6056     ok(!cmds[OLECMDID_FIND-1].cmdf || cmds[OLECMDID_FIND-1].cmdf == (OLECMDF_SUPPORTED|OLECMDF_ENABLED),
6057        "cmds[OLECMDID_FIND].cmdf=%x\n", cmds[OLECMDID_FIND-1].cmdf);
6058
6059     IOleCommandTarget_Release(cmdtrg);
6060 }
6061
6062 static void test_OleCommandTarget_fail(IHTMLDocument2 *doc)
6063 {
6064     IOleCommandTarget *cmdtrg;
6065     int i;
6066     HRESULT hres;
6067
6068     OLECMD cmd[2] = {
6069         {OLECMDID_OPEN, 0xf0f0},
6070         {OLECMDID_GETPRINTTEMPLATE+1, 0xf0f0}
6071     };
6072
6073     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleCommandTarget, (void**)&cmdtrg);
6074     ok(hres == S_OK, "QueryInterface(IIDIOleCommandTarget failed: %08x\n", hres);
6075     if(FAILED(hres))
6076         return;
6077
6078     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 0, NULL, NULL);
6079     ok(hres == S_OK, "QueryStatus failed: %08x\n", hres);
6080
6081     SET_EXPECT(QueryStatus_OPEN);
6082     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 2, cmd, NULL);
6083     CHECK_CALLED(QueryStatus_OPEN);
6084
6085     ok(hres == OLECMDERR_E_NOTSUPPORTED,
6086             "QueryStatus failed: %08x, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
6087     ok(cmd[1].cmdID == OLECMDID_GETPRINTTEMPLATE+1,
6088             "cmd[0].cmdID=%d, expected OLECMDID_GETPRINTTEMPLATE+1\n", cmd[0].cmdID);
6089     ok(cmd[1].cmdf == 0, "cmd[0].cmdf=%x, expected 0\n", cmd[0].cmdf);
6090     ok(cmd[0].cmdf == OLECMDF_SUPPORTED,
6091             "cmd[1].cmdf=%x, expected OLECMDF_SUPPORTED\n", cmd[1].cmdf);
6092
6093     hres = IOleCommandTarget_QueryStatus(cmdtrg, &IID_IHTMLDocument2, 2, cmd, NULL);
6094     ok(hres == OLECMDERR_E_UNKNOWNGROUP,
6095             "QueryStatus failed: %08x, expected OLECMDERR_E_UNKNOWNGROUP\n", hres);
6096
6097     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
6098         if(!expect_cmds[i]) {
6099             hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_UPDATECOMMANDS,
6100                     OLECMDEXECOPT_DODEFAULT, NULL, NULL);
6101             ok(hres == OLECMDERR_E_NOTSUPPORTED,
6102                     "Exec failed: %08x, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
6103         }
6104     }
6105
6106     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_GETPRINTTEMPLATE+1,
6107             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
6108     ok(hres == OLECMDERR_E_NOTSUPPORTED,
6109             "Exec failed: %08x, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
6110
6111     IOleCommandTarget_Release(cmdtrg);
6112 }
6113
6114 static void test_exec_onunload(IHTMLDocument2 *doc)
6115 {
6116     IOleCommandTarget *cmdtrg;
6117     VARIANT var;
6118     HRESULT hres;
6119
6120     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleCommandTarget, (void**)&cmdtrg);
6121     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08x\n", hres);
6122     if(FAILED(hres))
6123         return;
6124
6125     memset(&var, 0x0a, sizeof(var));
6126     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
6127             OLECMDEXECOPT_DODEFAULT, NULL, &var);
6128     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08x\n", hres);
6129     ok(V_VT(&var) == VT_BOOL, "V_VT(var)=%d, expected VT_BOOL\n", V_VT(&var));
6130     ok(V_BOOL(&var) == VARIANT_TRUE, "V_BOOL(var)=%x, expected VARIANT_TRUE\n", V_BOOL(&var));
6131
6132     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
6133             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
6134     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08x\n", hres);
6135
6136     IOleCommandTarget_Release(cmdtrg);
6137 }
6138
6139 static void test_exec_editmode(IUnknown *unk, BOOL loaded)
6140 {
6141     IOleCommandTarget *cmdtrg;
6142     HRESULT hres;
6143
6144     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
6145     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08x\n", hres);
6146     if(FAILED(hres))
6147         return;
6148
6149     editmode = TRUE;
6150
6151     if(loaded)
6152         load_state = LD_DOLOAD;
6153
6154     if(loaded)
6155         SET_EXPECT(GetClassID);
6156     SET_EXPECT(SetStatusText);
6157     SET_EXPECT(Exec_ShellDocView_37);
6158     SET_EXPECT(GetHostInfo);
6159     if(loaded)
6160         SET_EXPECT(GetDisplayName);
6161     SET_EXPECT(Invoke_AMBIENT_SILENT);
6162     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6163     SET_EXPECT(OnChanged_READYSTATE);
6164     SET_EXPECT(Invoke_OnReadyStateChange_Loading);
6165     SET_EXPECT(IsSystemMoniker);
6166     SET_EXPECT(Exec_ShellDocView_84);
6167     if(loaded)
6168         SET_EXPECT(BindToStorage);
6169     SET_EXPECT(InPlaceUIWindow_SetActiveObject);
6170     SET_EXPECT(HideUI);
6171     SET_EXPECT(ShowUI);
6172     SET_EXPECT(InPlaceFrame_SetBorderSpace);
6173
6174     expect_status_text = NULL;
6175     readystate_set_loading = TRUE;
6176
6177     hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, IDM_EDITMODE,
6178             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
6179     ok(hres == S_OK, "Exec failed: %08x\n", hres);
6180
6181     if(loaded)
6182         CHECK_CALLED(GetClassID);
6183     CHECK_CALLED(SetStatusText);
6184     CHECK_CALLED(Exec_ShellDocView_37);
6185     CHECK_CALLED(GetHostInfo);
6186     if(loaded)
6187         CHECK_CALLED(GetDisplayName);
6188     CHECK_CALLED(Invoke_AMBIENT_SILENT);
6189     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6190     CHECK_CALLED(OnChanged_READYSTATE);
6191     CHECK_CALLED(Invoke_OnReadyStateChange_Loading);
6192     CLEAR_CALLED(IsSystemMoniker); /* IE7 */
6193     CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
6194     if(loaded)
6195         CHECK_CALLED(BindToStorage);
6196     CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
6197     CHECK_CALLED(HideUI);
6198     CHECK_CALLED(ShowUI);
6199     CHECK_CALLED(InPlaceFrame_SetBorderSpace);
6200
6201     test_timer(EXPECT_UPDATEUI|EXPECT_SETTITLE);
6202
6203     IOleCommandTarget_Release(cmdtrg);
6204
6205     hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, IDM_EDITMODE,
6206             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
6207     ok(hres == S_OK, "Exec failed: %08x\n", hres);
6208 }
6209
6210 static void test_exec_fontname(IUnknown *unk, LPCWSTR name, LPCWSTR exname)
6211 {
6212    IOleCommandTarget *cmdtrg;
6213    VARIANT *in = NULL, _in, *out = NULL, _out;
6214    HRESULT hres;
6215
6216    hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
6217    ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08x\n", hres);
6218    if(FAILED(hres))
6219        return;
6220
6221    if(name) {
6222        in = &_in;
6223        V_VT(in) = VT_BSTR;
6224        V_BSTR(in) = SysAllocString(name);
6225    }
6226
6227    if(exname) {
6228        out = &_out;
6229        V_VT(out) = VT_I4;
6230        V_I4(out) = 0xdeadbeef;
6231    }
6232
6233    hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, IDM_FONTNAME, 0, in, out);
6234    ok(hres == S_OK, "Exec(IDM_FONTNAME) failed: %08x\n", hres);
6235
6236    if(in)
6237        VariantClear(in);
6238
6239    if(out) {
6240        ok(V_VT(out) == VT_BSTR, "V_VT(out) = %x\n", V_VT(out));
6241        if(V_VT(out) == VT_BSTR) {
6242            if(exname)
6243                ok(!lstrcmpW(V_BSTR(out), name ? name : exname),
6244                   "unexpected fontname %s\n", wine_dbgstr_w(name));
6245            else
6246                ok(V_BSTR(out) == NULL, "V_BSTR(out) != NULL\n");
6247        }
6248        VariantClear(out);
6249    }
6250
6251    IOleCommandTarget_Release(cmdtrg);
6252 }
6253
6254 static void test_exec_noargs(IUnknown *unk, DWORD cmdid)
6255 {
6256     IOleCommandTarget *cmdtrg;
6257     HRESULT hres;
6258
6259     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
6260     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08x\n", hres);
6261     if(FAILED(hres))
6262         return;
6263
6264     hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, cmdid,
6265             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
6266     ok(hres == S_OK, "Exec failed: %08x\n", hres);
6267
6268     IOleCommandTarget_Release(cmdtrg);
6269 }
6270
6271 static void test_IsDirty(IHTMLDocument2 *doc, HRESULT exhres)
6272 {
6273     IPersistStreamInit *perinit;
6274     IPersistMoniker *permon;
6275     IPersistFile *perfile;
6276     HRESULT hres;
6277
6278     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&perinit);
6279     ok(hres == S_OK, "QueryInterface(IID_IPersistStreamInit failed: %08x\n", hres);
6280     if(SUCCEEDED(hres)) {
6281         hres = IPersistStreamInit_IsDirty(perinit);
6282         ok(hres == exhres, "IsDirty() = %08x, expected %08x\n", hres, exhres);
6283         IPersistStreamInit_Release(perinit);
6284     }
6285
6286     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistMoniker, (void**)&permon);
6287     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker failed: %08x\n", hres);
6288     if(SUCCEEDED(hres)) {
6289         hres = IPersistMoniker_IsDirty(permon);
6290         ok(hres == exhres, "IsDirty() = %08x, expected %08x\n", hres, exhres);
6291         IPersistMoniker_Release(permon);
6292     }
6293
6294     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistFile, (void**)&perfile);
6295     ok(hres == S_OK, "QueryInterface(IID_IPersistFile failed: %08x\n", hres);
6296     if(SUCCEEDED(hres)) {
6297         hres = IPersistFile_IsDirty(perfile);
6298         ok(hres == exhres, "IsDirty() = %08x, expected %08x\n", hres, exhres);
6299         IPersistFile_Release(perfile);
6300     }
6301 }
6302
6303 static HWND create_container_window(void)
6304 {
6305     static const WCHAR wszHTMLDocumentTest[] =
6306         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
6307     static WNDCLASSEXW wndclass = {
6308         sizeof(WNDCLASSEXW),
6309         0,
6310         wnd_proc,
6311         0, 0, NULL, NULL, NULL, NULL, NULL,
6312         wszHTMLDocumentTest,
6313         NULL
6314     };
6315
6316     RegisterClassExW(&wndclass);
6317     return CreateWindowW(wszHTMLDocumentTest, wszHTMLDocumentTest,
6318             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
6319             515, 530, NULL, NULL, NULL, NULL);
6320 }
6321
6322 static void test_DoVerb(IOleObject *oleobj)
6323 {
6324     RECT rect = {0,0,500,500};
6325     HRESULT hres;
6326
6327     if(!container_locked) {
6328         SET_EXPECT(GetContainer);
6329         SET_EXPECT(LockContainer);
6330     }
6331     SET_EXPECT(ActivateMe);
6332     expect_LockContainer_fLock = TRUE;
6333
6334     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite, -1, container_hwnd, &rect);
6335     ok(hres == S_OK, "DoVerb failed: %08x\n", hres);
6336
6337     if(!container_locked) {
6338         CHECK_CALLED(GetContainer);
6339         CHECK_CALLED(LockContainer);
6340         container_locked = TRUE;
6341     }
6342     CHECK_CALLED(ActivateMe);
6343 }
6344
6345 #define CLIENTSITE_EXPECTPATH 0x00000001
6346 #define CLIENTSITE_SETNULL    0x00000002
6347 #define CLIENTSITE_DONTSET    0x00000004
6348
6349 static void test_ClientSite(IOleObject *oleobj, DWORD flags)
6350 {
6351     IOleClientSite *clientsite;
6352     HRESULT hres;
6353
6354     if(flags & CLIENTSITE_SETNULL) {
6355         hres = IOleObject_GetClientSite(oleobj, &clientsite);
6356         ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
6357         if(set_clientsite)
6358             ok(clientsite == &ClientSite, "clientsite=%p, expected %p\n", clientsite, &ClientSite);
6359         else
6360             ok(!clientsite, "clientsite != NULL\n");
6361
6362         SET_EXPECT(GetOverrideKeyPath);
6363         hres = IOleObject_SetClientSite(oleobj, NULL);
6364         ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
6365         CLEAR_CALLED(GetOverrideKeyPath); /* IE9 sometimes calls it */
6366
6367         set_clientsite = FALSE;
6368     }
6369
6370     if(flags & CLIENTSITE_DONTSET)
6371         return;
6372
6373     if(!expect_uihandler_iface)
6374         expect_uihandler_iface = &DocHostUIHandler;
6375
6376     hres = IOleObject_GetClientSite(oleobj, &clientsite);
6377     ok(hres == S_OK, "GetClientSite failed: %08x\n", hres);
6378     ok(clientsite == (set_clientsite ? &ClientSite : NULL), "GetClientSite() = %p, expected %p\n",
6379             clientsite, set_clientsite ? &ClientSite : NULL);
6380
6381     if(!set_clientsite) {
6382         if(expect_uihandler_iface)
6383             SET_EXPECT(GetHostInfo);
6384         if(flags & CLIENTSITE_EXPECTPATH) {
6385             SET_EXPECT(GetOptionKeyPath);
6386             SET_EXPECT(GetOverrideKeyPath);
6387         }
6388         SET_EXPECT(GetWindow);
6389         if(flags & CLIENTSITE_EXPECTPATH)
6390             SET_EXPECT(Exec_DOCCANNAVIGATE);
6391         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
6392         SET_EXPECT(Exec_SETPROGRESSMAX);
6393         SET_EXPECT(Exec_SETPROGRESSPOS);
6394         SET_EXPECT(Invoke_AMBIENT_USERMODE);
6395         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
6396         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6397         SET_EXPECT(Invoke_AMBIENT_SILENT);
6398         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
6399         SET_EXPECT(Invoke_AMBIENT_PALETTE);
6400         SET_EXPECT(GetOverrideKeyPath);
6401         SET_EXPECT(GetTravelLog);
6402         SET_EXPECT(Exec_ShellDocView_84);
6403
6404         hres = IOleObject_SetClientSite(oleobj, &ClientSite);
6405         ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
6406
6407         if(expect_uihandler_iface)
6408             CHECK_CALLED(GetHostInfo);
6409         if(flags & CLIENTSITE_EXPECTPATH) {
6410             CLEAR_CALLED(GetOptionKeyPath); /* not called on some IE9 */
6411             CHECK_CALLED(GetOverrideKeyPath);
6412         }
6413         CHECK_CALLED(GetWindow);
6414         if(flags & CLIENTSITE_EXPECTPATH)
6415             CHECK_CALLED(Exec_DOCCANNAVIGATE);
6416         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
6417         CHECK_CALLED(Exec_SETPROGRESSMAX);
6418         CHECK_CALLED(Exec_SETPROGRESSPOS);
6419         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
6420         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
6421         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6422         CHECK_CALLED(Invoke_AMBIENT_SILENT);
6423         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
6424         CLEAR_CALLED(Invoke_AMBIENT_PALETTE); /* not called on IE9 */
6425         CLEAR_CALLED(GetOverrideKeyPath); /* Called by IE9 */
6426         CHECK_CALLED(GetTravelLog);
6427         CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
6428
6429         set_clientsite = TRUE;
6430     }
6431
6432     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
6433     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
6434
6435     hres = IOleObject_GetClientSite(oleobj, &clientsite);
6436     ok(hres == S_OK, "GetClientSite failed: %08x\n", hres);
6437     ok(clientsite == &ClientSite, "GetClientSite() = %p, expected %p\n", clientsite, &ClientSite);
6438 }
6439
6440 static void test_OnAmbientPropertyChange(IHTMLDocument2 *doc)
6441 {
6442     IOleControl *control = NULL;
6443     HRESULT hres;
6444
6445     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleControl, (void**)&control);
6446     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08x\n", hres);
6447     if(FAILED(hres))
6448         return;
6449
6450     SET_EXPECT(Invoke_AMBIENT_USERMODE);
6451     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERMODE);
6452     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
6453     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
6454
6455     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
6456     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_DLCONTROL);
6457     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
6458     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
6459
6460     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
6461     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6462     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
6463     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
6464     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
6465     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6466
6467     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
6468     SET_EXPECT(Invoke_AMBIENT_SILENT);
6469     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_SILENT);
6470     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
6471     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
6472     CHECK_CALLED(Invoke_AMBIENT_SILENT);
6473
6474     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
6475     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERAGENT);
6476     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
6477     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
6478
6479     SET_EXPECT(Invoke_AMBIENT_PALETTE);
6480     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
6481     ok(hres == S_OK, "OnAmbientChange failed: %08x\n", hres);
6482     CLEAR_CALLED(Invoke_AMBIENT_PALETTE); /* not called on IE9 */
6483
6484     IOleControl_Release(control);
6485 }
6486
6487
6488
6489 static void test_OnAmbientPropertyChange2(IHTMLDocument2 *doc)
6490 {
6491     IOleControl *control = NULL;
6492     HRESULT hres;
6493
6494     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleControl, (void**)&control);
6495     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08x\n", hres);
6496     if(FAILED(hres))
6497         return;
6498
6499     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
6500     ok(hres == S_OK, "OnAmbientPropertyChange failed: %08x\n", hres);
6501
6502     IOleControl_Release(control);
6503 }
6504
6505 static void test_Close(IHTMLDocument2 *doc, BOOL set_client)
6506 {
6507     IOleObject *oleobj = NULL;
6508     HRESULT hres;
6509
6510     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
6511     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08x\n", hres);
6512     if(FAILED(hres))
6513         return;
6514
6515     SET_EXPECT(GetContainer);
6516     SET_EXPECT(LockContainer);
6517     expect_LockContainer_fLock = FALSE;
6518     hres = IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
6519     ok(hres == S_OK, "Close failed: %08x\n", hres);
6520     CHECK_CALLED(GetContainer);
6521     CHECK_CALLED(LockContainer);
6522     container_locked = FALSE;
6523
6524     if(set_client)
6525         test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
6526
6527     IOleObject_Release(oleobj);
6528 }
6529
6530 static void test_Advise(IHTMLDocument2 *doc)
6531 {
6532     IOleObject *oleobj = NULL;
6533     IEnumSTATDATA *enum_advise = (void*)0xdeadbeef;
6534     DWORD conn;
6535     HRESULT hres;
6536
6537     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
6538     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08x\n", hres);
6539     if(FAILED(hres))
6540         return;
6541
6542     hres = IOleObject_Unadvise(oleobj, 0);
6543     ok(hres == OLE_E_NOCONNECTION, "Unadvise returned: %08x\n", hres);
6544
6545     hres = IOleObject_EnumAdvise(oleobj, &enum_advise);
6546     ok(hres == S_OK, "EnumAdvise returned: %08x\n", hres);
6547     ok(enum_advise == NULL, "enum_advise != NULL\n");
6548
6549     conn = -1;
6550     hres = IOleObject_Advise(oleobj, NULL, &conn);
6551     /* Old IE returns S_OK and sets conn to 1 */
6552     ok(hres == E_INVALIDARG || hres == S_OK, "Advise returned: %08x\n", hres);
6553     ok(conn == 0 || conn == 1, "conn = %d\n", conn);
6554
6555     hres = IOleObject_Advise(oleobj, (IAdviseSink*)&AdviseSink, NULL);
6556     ok(hres == E_INVALIDARG, "Advise returned: %08x\n", hres);
6557
6558     hres = IOleObject_Advise(oleobj, (IAdviseSink*)&AdviseSink, &conn);
6559     ok(hres == S_OK, "Advise returned: %08x\n", hres);
6560     ok(conn == 1, "conn = %d\n", conn);
6561
6562     hres = IOleObject_Advise(oleobj, (IAdviseSink*)&AdviseSink, &conn);
6563     ok(hres == S_OK, "Advise returned: %08x\n", hres);
6564     ok(conn == 2, "conn = %d\n", conn);
6565
6566     hres = IOleObject_Unadvise(oleobj, 1);
6567     ok(hres == S_OK, "Unadvise returned: %08x\n", hres);
6568
6569     hres = IOleObject_Unadvise(oleobj, 1);
6570     ok(hres == OLE_E_NOCONNECTION, "Unadvise returned: %08x\n", hres);
6571
6572     hres = IOleObject_Unadvise(oleobj, 2);
6573     ok(hres == S_OK, "Unadvise returned: %08x\n", hres);
6574
6575     IOleObject_Release(oleobj);
6576 }
6577
6578 static void test_OnFrameWindowActivate(IUnknown *unk)
6579 {
6580     IOleInPlaceActiveObject *inplaceact;
6581     HRESULT hres;
6582
6583     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceActiveObject, (void**)&inplaceact);
6584     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceActiveObject) failed: %08x\n", hres);
6585     if(FAILED(hres))
6586         return;
6587
6588     if(set_clientsite) {
6589         expect_OnFrameWindowActivate_fActivate = TRUE;
6590         SET_EXPECT(OnFrameWindowActivate);
6591         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
6592         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
6593         CHECK_CALLED(OnFrameWindowActivate);
6594
6595         SET_EXPECT(OnFrameWindowActivate);
6596         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
6597         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
6598         CHECK_CALLED(OnFrameWindowActivate);
6599
6600         expect_OnFrameWindowActivate_fActivate = FALSE;
6601         SET_EXPECT(OnFrameWindowActivate);
6602         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, FALSE);
6603         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
6604         CHECK_CALLED(OnFrameWindowActivate);
6605
6606         expect_OnFrameWindowActivate_fActivate = TRUE;
6607         SET_EXPECT(OnFrameWindowActivate);
6608         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
6609         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
6610         CHECK_CALLED(OnFrameWindowActivate);
6611     }else {
6612         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, FALSE);
6613         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
6614
6615         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
6616         ok(hres == S_OK, "OnFrameWindowActivate failed: %08x\n", hres);
6617     }
6618
6619     IOleInPlaceActiveObject_Release(inplaceact);
6620 }
6621
6622 static void test_InPlaceDeactivate(IHTMLDocument2 *doc, BOOL expect_call)
6623 {
6624     IOleInPlaceObjectWindowless *windowlessobj = NULL;
6625     HRESULT hres;
6626
6627     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleInPlaceObjectWindowless,
6628             (void**)&windowlessobj);
6629     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceObjectWindowless) failed: %08x\n", hres);
6630     if(FAILED(hres))
6631         return;
6632
6633     if(expect_call) {
6634         SET_EXPECT(SetStatusText);
6635         SET_EXPECT(OnFocus_FALSE);
6636         if(ipsex)
6637             SET_EXPECT(OnInPlaceDeactivateEx);
6638         else
6639             SET_EXPECT(OnInPlaceDeactivate);
6640     }
6641     hres = IOleInPlaceObjectWindowless_InPlaceDeactivate(windowlessobj);
6642     ok(hres == S_OK, "InPlaceDeactivate failed: %08x\n", hres);
6643     if(expect_call) {
6644         CLEAR_CALLED(SetStatusText); /* Called by IE9 */
6645         CHECK_CALLED(OnFocus_FALSE);
6646         if(ipsex)
6647             CHECK_CALLED(OnInPlaceDeactivateEx);
6648         else
6649             CHECK_CALLED(OnInPlaceDeactivate);
6650     }
6651
6652     IOleInPlaceObjectWindowless_Release(windowlessobj);
6653 }
6654
6655 static void test_Activate(IHTMLDocument2 *doc, DWORD flags)
6656 {
6657     IOleObject *oleobj = NULL;
6658     IOleDocumentView *docview;
6659     GUID guid;
6660     HRESULT hres;
6661
6662     last_hwnd = doc_hwnd;
6663
6664     if(view)
6665         IOleDocumentView_Release(view);
6666     view = NULL;
6667
6668     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
6669     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08x\n", hres);
6670
6671     hres = IOleObject_GetUserClassID(oleobj, NULL);
6672     ok(hres == E_INVALIDARG, "GetUserClassID returned: %08x, expected E_INVALIDARG\n", hres);
6673
6674     hres = IOleObject_GetUserClassID(oleobj, &guid);
6675     ok(hres == S_OK, "GetUserClassID failed: %08x\n", hres);
6676     ok(IsEqualGUID(&guid, &CLSID_HTMLDocument), "guid != CLSID_HTMLDocument\n");
6677
6678     test_OnFrameWindowActivate((IUnknown*)doc);
6679
6680     test_ClientSite(oleobj, flags);
6681     test_InPlaceDeactivate(doc, FALSE);
6682     test_DoVerb(oleobj);
6683
6684     if(call_UIActivate == CallUIActivate_AfterShow) {
6685         hres = IOleObject_QueryInterface(oleobj, &IID_IOleDocumentView, (void **)&docview);
6686         ok(hres == S_OK, "IOleObject_QueryInterface failed with error 0x%08x\n", hres);
6687
6688         SET_EXPECT(OnFocus_TRUE);
6689         SET_EXPECT(SetActiveObject);
6690         SET_EXPECT(ShowUI);
6691         SET_EXPECT(InPlaceUIWindow_SetActiveObject);
6692         SET_EXPECT(InPlaceFrame_SetBorderSpace);
6693         expect_status_text = NULL;
6694
6695         hres = IOleDocumentView_UIActivate(docview, TRUE);
6696         ok(hres == S_OK, "IOleDocumentView_UIActivate failed with error 0x%08x\n", hres);
6697
6698         CHECK_CALLED(OnFocus_TRUE);
6699         CHECK_CALLED(SetActiveObject);
6700         CHECK_CALLED(ShowUI);
6701         CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
6702         CHECK_CALLED(InPlaceFrame_SetBorderSpace);
6703
6704         IOleDocumentView_Release(docview);
6705     }
6706
6707     IOleObject_Release(oleobj);
6708
6709     test_OnFrameWindowActivate((IUnknown*)doc);
6710 }
6711
6712 static void test_Window(IHTMLDocument2 *doc, BOOL expect_success)
6713 {
6714     IOleInPlaceActiveObject *activeobject = NULL;
6715     HWND tmp_hwnd;
6716     HRESULT hres;
6717
6718     hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobject);
6719     ok(hres == S_OK, "Could not get IOleInPlaceActiveObject interface: %08x\n", hres);
6720     if(FAILED(hres))
6721         return;
6722
6723     hres = IOleInPlaceActiveObject_GetWindow(activeobject, &tmp_hwnd);
6724
6725     if(expect_success) {
6726         ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
6727         ok(tmp_hwnd == doc_hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, doc_hwnd);
6728     }else {
6729         ok(hres == E_FAIL, "GetWindow returned %08x, expected E_FAIL\n", hres);
6730         ok(IsWindow(doc_hwnd), "hwnd is destroyed\n");
6731     }
6732
6733     IOleInPlaceActiveObject_Release(activeobject);
6734 }
6735
6736 static void test_CloseView(void)
6737 {
6738     IOleInPlaceSite *inplacesite = (IOleInPlaceSite*)0xff00ff00;
6739     HRESULT hres;
6740
6741     if(!view)
6742         return;
6743
6744     hres = IOleDocumentView_Show(view, FALSE);
6745     ok(hres == S_OK, "Show failed: %08x\n", hres);
6746
6747     hres = IOleDocumentView_CloseView(view, 0);
6748     ok(hres == S_OK, "CloseView failed: %08x\n", hres);
6749
6750     hres = IOleDocumentView_SetInPlaceSite(view, NULL);
6751     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
6752
6753     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
6754     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
6755     ok(inplacesite == NULL, "inplacesite=%p, expected NULL\n", inplacesite);
6756 }
6757
6758 static void test_UIDeactivate(void)
6759 {
6760     HRESULT hres;
6761
6762     if(call_UIActivate == CallUIActivate_AfterShow) {
6763         SET_EXPECT(InPlaceUIWindow_SetActiveObject);
6764     }
6765     if(call_UIActivate != CallUIActivate_None) {
6766         SET_EXPECT(SetActiveObject_null);
6767         SET_EXPECT(HideUI);
6768         SET_EXPECT(OnUIDeactivate);
6769     }
6770
6771     hres = IOleDocumentView_UIActivate(view, FALSE);
6772     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
6773
6774     if(call_UIActivate != CallUIActivate_None) {
6775         CHECK_CALLED(SetActiveObject_null);
6776         CHECK_CALLED(HideUI);
6777         CHECK_CALLED(OnUIDeactivate);
6778     }
6779     if(call_UIActivate == CallUIActivate_AfterShow) {
6780         CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
6781     }
6782 }
6783
6784 static void test_Hide(void)
6785 {
6786     HRESULT hres;
6787
6788     if(!view)
6789         return;
6790
6791     hres = IOleDocumentView_Show(view, FALSE);
6792     ok(hres == S_OK, "Show failed: %08x\n", hres);
6793 }
6794
6795 static IHTMLDocument2 *create_document(void)
6796 {
6797     IHTMLDocument2 *doc;
6798     HRESULT hres;
6799
6800     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
6801             &IID_IHTMLDocument2, (void**)&doc);
6802     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
6803     if(FAILED(hres))
6804         return NULL;
6805
6806     return doc;
6807 }
6808
6809 static void release_document(IHTMLDocument2 *doc)
6810 {
6811     IUnknown *unk;
6812     ULONG ref;
6813     HRESULT hres;
6814
6815     /* Some broken IEs don't like if the last released reference is IHTMLDocument2 iface.
6816      * To workaround it, we release it via IUnknown iface */
6817     hres = IHTMLDocument2_QueryInterface(doc, &IID_IUnknown, (void**)&unk);
6818     ok(hres == S_OK, "Could not get IUnknown iface: %08x\n", hres);
6819
6820     IHTMLDocument2_Release(doc);
6821     ref = IUnknown_Release(unk);
6822     ok(!ref, "ref = %d\n", ref);
6823 }
6824
6825 static void test_Navigate(IHTMLDocument2 *doc)
6826 {
6827     IHlinkTarget *hlink;
6828     HRESULT hres;
6829
6830     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHlinkTarget, (void**)&hlink);
6831     ok(hres == S_OK, "QueryInterface(IID_IHlinkTarget) failed: %08x\n", hres);
6832
6833     SET_EXPECT(ActivateMe);
6834     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
6835     ok(hres == S_OK, "Navigate failed: %08x\n", hres);
6836     CHECK_CALLED(ActivateMe);
6837
6838     IHlinkTarget_Release(hlink);
6839 }
6840
6841 static void test_external(IHTMLDocument2 *doc, BOOL initialized)
6842 {
6843     IDispatch *external;
6844     IHTMLWindow2 *htmlwin;
6845     HRESULT hres;
6846
6847     hres = IHTMLDocument2_get_parentWindow(doc, &htmlwin);
6848     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
6849
6850     if(initialized)
6851         SET_EXPECT(GetExternal);
6852     external = (void*)0xdeadbeef;
6853     hres = IHTMLWindow2_get_external(htmlwin, &external);
6854     if(initialized) {
6855         ok(hres == S_FALSE || hres == S_OK, "get_external failed: %08x\n", hres);
6856         CHECK_CALLED(GetExternal);
6857         ok(external != NULL, "external == NULL\n");
6858     }else {
6859         ok(hres == S_OK, "get_external failed: %08x\n", hres);
6860         ok(external == NULL, "external != NULL\n");
6861     }
6862
6863     IHTMLWindow2_Release(htmlwin);
6864 }
6865
6866 static void test_enum_objects(IOleContainer *container)
6867 {
6868     IEnumUnknown *enum_unknown;
6869     IUnknown *buf[100] = {(void*)0xdeadbeef};
6870     ULONG fetched;
6871     HRESULT hres;
6872
6873     enum_unknown = NULL;
6874     hres = IOleContainer_EnumObjects(container, OLECONTF_EMBEDDINGS, &enum_unknown);
6875     ok(hres == S_OK, "EnumObjects failed: %08x\n", hres);
6876     ok(enum_unknown != NULL, "enum_unknown == NULL\n");
6877
6878     fetched = 0xdeadbeef;
6879     hres = IEnumUnknown_Next(enum_unknown, sizeof(buf)/sizeof(*buf), buf, &fetched);
6880     ok(hres == S_FALSE, "Next returned %08x\n", hres);
6881     ok(!fetched, "fetched = %d\n", fetched);
6882     ok(buf[0] == (void*)0xdeadbeef, "buf[0] = %p\n", buf[0]);
6883
6884     fetched = 0xdeadbeef;
6885     hres = IEnumUnknown_Next(enum_unknown, 1, buf, &fetched);
6886     ok(hres == S_FALSE, "Next returned %08x\n", hres);
6887     ok(!fetched, "fetched = %d\n", fetched);
6888
6889     hres = IEnumUnknown_Next(enum_unknown, 1, buf, NULL);
6890     ok(hres == S_FALSE, "Next returned %08x\n", hres);
6891
6892     IEnumUnknown_Release(enum_unknown);
6893 }
6894
6895 static void test_target_container(IHTMLDocument2 *doc)
6896 {
6897     IOleContainer *ole_container, *doc_ole_container;
6898     ITargetContainer *target_container;
6899     HRESULT hres;
6900
6901     hres = IHTMLDocument2_QueryInterface(doc, &IID_ITargetContainer, (void**)&target_container);
6902     ok(hres == S_OK, "Could not get ITargetContainer iface: %08x\n", hres);
6903
6904     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleContainer, (void**)&doc_ole_container);
6905     ok(hres == S_OK, "Could not get ITargetContainer iface: %08x\n", hres);
6906
6907     ole_container = (void*)0xdeadbeef;
6908     hres = ITargetContainer_GetFramesContainer(target_container, &ole_container);
6909     ok(hres == S_OK, "GetFramesContainer failed: %08x\n", hres);
6910     ok(ole_container != NULL, "ole_container == NULL\n");
6911     ok(iface_cmp((IUnknown*)ole_container, (IUnknown*)doc_ole_container), "ole_container != doc_ole_container\n");
6912     test_enum_objects(ole_container);
6913     IOleContainer_Release(ole_container);
6914
6915     ITargetContainer_Release(target_container);
6916     IOleContainer_Release(doc_ole_container);
6917 }
6918
6919 static void test_travellog(IHTMLDocument2 *doc)
6920 {
6921     ITravelLogClient *travellog_client;
6922     IHTMLWindow2 *window, *top_window;
6923     IUnknown *unk;
6924     HRESULT hres;
6925
6926     window = NULL;
6927     hres = IHTMLDocument2_get_parentWindow(doc, &window);
6928     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
6929     ok(window != NULL, "window = NULL\n");
6930
6931     hres = IHTMLWindow2_get_top(window, &top_window);
6932     IHTMLWindow2_Release(window);
6933     ok(hres == S_OK, "get_top failed: %08x\n", hres);
6934
6935     hres = IHTMLWindow2_QueryInterface(top_window, &IID_ITravelLogClient, (void**)&travellog_client);
6936     IHTMLWindow2_Release(top_window);
6937     if(hres == E_NOINTERFACE) {
6938         win_skip("ITravelLogClient not supported\n");
6939         return;
6940     }
6941     ok(hres == S_OK, "Could not get ITraveLogClient iface: %08x\n", hres);
6942
6943     unk = (void*)0xdeadbeef;
6944     hres = ITravelLogClient_FindWindowByIndex(travellog_client, 0, &unk);
6945     ok(hres == E_FAIL, "FindWindowByIndex failed: %08x\n", hres);
6946     ok(!unk, "unk != NULL\n");
6947
6948     ITravelLogClient_Release(travellog_client);
6949 }
6950
6951 static void test_StreamLoad(IHTMLDocument2 *doc)
6952 {
6953     IPersistStreamInit *init;
6954     HRESULT hres;
6955
6956     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
6957     ok(hres == S_OK, "QueryInterface(IID_IPersistStreamInit) failed: %08x\n", hres);
6958     if(FAILED(hres))
6959         return;
6960
6961     SET_EXPECT(Invoke_AMBIENT_SILENT);
6962     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6963     SET_EXPECT(Exec_ShellDocView_37);
6964     SET_EXPECT(OnChanged_READYSTATE);
6965     SET_EXPECT(Invoke_OnReadyStateChange_Loading);
6966     SET_EXPECT(Read);
6967     SET_EXPECT(GetPendingUrl);
6968     readystate_set_loading = TRUE;
6969
6970     hres = IPersistStreamInit_Load(init, &Stream);
6971     ok(hres == S_OK, "Load failed: %08x\n", hres);
6972
6973     CHECK_CALLED(Invoke_AMBIENT_SILENT);
6974     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6975     CHECK_CALLED(Exec_ShellDocView_37);
6976     CHECK_CALLED(OnChanged_READYSTATE);
6977     CHECK_CALLED(Invoke_OnReadyStateChange_Loading);
6978     CHECK_CALLED(Read);
6979     todo_wine CHECK_CALLED(GetPendingUrl);
6980
6981     test_timer(EXPECT_SETTITLE);
6982     test_GetCurMoniker((IUnknown*)doc, NULL, "about:blank");
6983
6984     IPersistStreamInit_Release(init);
6985 }
6986
6987 static void test_StreamInitNew(IHTMLDocument2 *doc)
6988 {
6989     IPersistStreamInit *init;
6990     HRESULT hres;
6991
6992     hres = IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
6993     ok(hres == S_OK, "QueryInterface(IID_IPersistStreamInit) failed: %08x\n", hres);
6994     if(FAILED(hres))
6995         return;
6996
6997     SET_EXPECT(Invoke_AMBIENT_SILENT);
6998     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
6999     SET_EXPECT(Exec_ShellDocView_37);
7000     SET_EXPECT(OnChanged_READYSTATE);
7001     SET_EXPECT(Invoke_OnReadyStateChange_Loading);
7002     SET_EXPECT(GetPendingUrl);
7003     readystate_set_loading = TRUE;
7004
7005     hres = IPersistStreamInit_InitNew(init);
7006     ok(hres == S_OK, "Load failed: %08x\n", hres);
7007
7008     CHECK_CALLED(Invoke_AMBIENT_SILENT);
7009     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
7010     CHECK_CALLED(Exec_ShellDocView_37);
7011     CHECK_CALLED(OnChanged_READYSTATE);
7012     CHECK_CALLED(Invoke_OnReadyStateChange_Loading);
7013     todo_wine CHECK_CALLED(GetPendingUrl);
7014
7015     test_timer(EXPECT_SETTITLE);
7016     test_GetCurMoniker((IUnknown*)doc, NULL, "about:blank");
7017
7018     IPersistStreamInit_Release(init);
7019 }
7020
7021 static void test_QueryInterface(IHTMLDocument2 *htmldoc)
7022 {
7023     IUnknown *qi, *doc = (IUnknown*)htmldoc;
7024     HRESULT hres;
7025
7026     static const IID IID_UndocumentedScriptIface =
7027         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0}};
7028
7029     qi = (void*)0xdeadbeef;
7030     hres = IUnknown_QueryInterface(doc, &IID_IRunnableObject, (void**)&qi);
7031     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7032     ok(qi == NULL, "qirunnable=%p, expected NULL\n", qi);
7033
7034     qi = (void*)0xdeadbeef;
7035     hres = IUnknown_QueryInterface(doc, &IID_IHTMLDOMNode, (void**)&qi);
7036     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7037     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7038
7039     qi = (void*)0xdeadbeef;
7040     hres = IUnknown_QueryInterface(doc, &IID_IHTMLDOMNode2, (void**)&qi);
7041     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7042     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7043
7044     qi = (void*)0xdeadbeef;
7045     hres = IUnknown_QueryInterface(doc, &IID_IPersistPropertyBag, (void**)&qi);
7046     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7047     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7048
7049     qi = (void*)0xdeadbeef;
7050     hres = IUnknown_QueryInterface(doc, &IID_UndocumentedScriptIface, (void**)&qi);
7051     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7052     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7053
7054     qi = (void*)0xdeadbeef;
7055     hres = IUnknown_QueryInterface(doc, &IID_IMarshal, (void**)&qi);
7056     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7057     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7058
7059     qi = (void*)0xdeadbeef;
7060     hres = IUnknown_QueryInterface(doc, &IID_IExternalConnection, (void**)&qi);
7061     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7062     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7063
7064     qi = (void*)0xdeadbeef;
7065     hres = IUnknown_QueryInterface(doc, &IID_IStdMarshalInfo, (void**)&qi);
7066     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7067     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7068
7069     qi = (void*)0xdeadbeef;
7070     hres = IUnknown_QueryInterface(doc, &IID_ITargetFrame, (void**)&qi);
7071     ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
7072     ok(qi == NULL, "qi=%p, expected NULL\n", qi);
7073
7074     hres = IUnknown_QueryInterface(doc, &IID_IDispatch, (void**)&qi);
7075     ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
7076     ok(qi != (IUnknown*)doc, "disp == doc\n");
7077     IUnknown_Release(qi);
7078 }
7079
7080 static void init_test(enum load_state_t ls) {
7081     doc_unk = NULL;
7082     doc_hwnd = last_hwnd = NULL;
7083     set_clientsite = FALSE;
7084     load_from_stream = FALSE;
7085     call_UIActivate = CallUIActivate_None;
7086     load_state = ls;
7087     editmode = FALSE;
7088     stream_read = 0;
7089     protocol_read = 0;
7090     nav_url = NULL;
7091     ipsex = FALSE;
7092     inplace_deactivated = FALSE;
7093     complete = FALSE;
7094     expect_uihandler_iface = &DocHostUIHandler;
7095 }
7096
7097 static void test_HTMLDocument(BOOL do_load, BOOL mime)
7098 {
7099     IHTMLDocument2 *doc;
7100
7101     trace("Testing HTMLDocument (%s, %s)...\n", (do_load ? "load" : "no load"),
7102             (report_mime ? "mime" : "no mime"));
7103
7104     init_test(do_load ? LD_DOLOAD : LD_NO);
7105     report_mime = mime;
7106
7107     doc = create_document();
7108     doc_unk = (IUnknown*)doc;
7109
7110     test_QueryInterface(doc);
7111     test_Advise(doc);
7112     test_IsDirty(doc, S_FALSE);
7113     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7114     test_external(doc, FALSE);
7115     test_ViewAdviseSink(doc);
7116     test_ConnectionPointContainer(doc);
7117     test_GetCurMoniker((IUnknown*)doc, NULL, NULL);
7118     test_Persist(doc, &Moniker);
7119     if(!do_load)
7120         test_OnAmbientPropertyChange2(doc);
7121
7122     test_Activate(doc, CLIENTSITE_EXPECTPATH);
7123
7124     if(do_load) {
7125         set_custom_uihandler(doc, &CustomDocHostUIHandler);
7126         test_download(DWL_CSS|DWL_TRYCSS);
7127         test_GetCurMoniker((IUnknown*)doc, &Moniker, NULL);
7128         test_elem_from_point(doc);
7129     }
7130
7131     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7132     test_OleCommandTarget_fail(doc);
7133     test_OleCommandTarget(doc);
7134     test_OnAmbientPropertyChange(doc);
7135     test_Window(doc, TRUE);
7136     test_external(doc, TRUE);
7137     test_target_container(doc);
7138
7139     test_UIDeactivate();
7140     test_OleCommandTarget(doc);
7141     test_Window(doc, TRUE);
7142     test_InPlaceDeactivate(doc, TRUE);
7143
7144     /* Calling test_OleCommandTarget here causes Segmentation Fault with native
7145      * MSHTML. It doesn't with Wine. */
7146
7147     test_Window(doc, FALSE);
7148     test_Hide();
7149     test_InPlaceDeactivate(doc, FALSE);
7150     test_CloseView();
7151     test_Close(doc, FALSE);
7152
7153     /* Activate HTMLDocument again */
7154     test_Activate(doc, CLIENTSITE_SETNULL);
7155     test_Window(doc, TRUE);
7156     test_OleCommandTarget(doc);
7157     test_UIDeactivate();
7158     test_InPlaceDeactivate(doc, TRUE);
7159     test_Close(doc, FALSE);
7160
7161     /* Activate HTMLDocument again, this time without UIActivate */
7162     call_UIActivate = CallUIActivate_None;
7163     test_Activate(doc, CLIENTSITE_SETNULL);
7164     test_Window(doc, TRUE);
7165
7166     test_external(doc, TRUE);
7167     set_custom_uihandler(doc, NULL);
7168     test_external(doc, FALSE);
7169
7170     test_UIDeactivate();
7171     test_InPlaceDeactivate(doc, TRUE);
7172     test_CloseView();
7173     test_CloseView();
7174     test_Close(doc, TRUE);
7175     test_OnAmbientPropertyChange2(doc);
7176     test_GetCurMoniker((IUnknown*)doc, do_load ? &Moniker : NULL, NULL);
7177
7178     if(!do_load) {
7179         /* Activate HTMLDocument again, calling UIActivate after showing the window */
7180         call_UIActivate = CallUIActivate_AfterShow;
7181         test_Activate(doc, 0);
7182         test_Window(doc, TRUE);
7183         test_OleCommandTarget(doc);
7184         test_UIDeactivate();
7185         test_InPlaceDeactivate(doc, TRUE);
7186         test_Close(doc, FALSE);
7187         call_UIActivate = CallUIActivate_None;
7188     }
7189
7190     if(view)
7191         IOleDocumentView_Release(view);
7192     view = NULL;
7193
7194     ok(IsWindow(doc_hwnd), "hwnd is destroyed\n");
7195     release_document(doc);
7196     ok(!IsWindow(doc_hwnd), "hwnd is not destroyed\n");
7197 }
7198
7199 static void test_HTMLDocument_hlink(DWORD status)
7200 {
7201     IHTMLDocument2 *doc;
7202
7203     trace("Testing HTMLDocument (hlink)...\n");
7204
7205     init_test(LD_DOLOAD);
7206     ipsex = TRUE;
7207
7208     doc = create_document();
7209     doc_unk = (IUnknown*)doc;
7210
7211     set_custom_uihandler(doc, &CustomDocHostUIHandler);
7212     test_ViewAdviseSink(doc);
7213     test_ConnectionPointContainer(doc);
7214     test_GetCurMoniker((IUnknown*)doc, NULL, NULL);
7215     test_Persist(doc, &Moniker);
7216     test_Navigate(doc);
7217
7218     status_code = status;
7219     test_download(DWL_CSS|DWL_TRYCSS);
7220     status_code = HTTP_STATUS_OK;
7221
7222     test_IsDirty(doc, S_FALSE);
7223     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7224
7225     test_exec_onunload(doc);
7226     test_Window(doc, TRUE);
7227     test_InPlaceDeactivate(doc, TRUE);
7228     test_Close(doc, FALSE);
7229     test_IsDirty(doc, S_FALSE);
7230     test_GetCurMoniker((IUnknown*)doc, &Moniker, NULL);
7231     test_clear(doc);
7232     test_GetCurMoniker((IUnknown*)doc, &Moniker, NULL);
7233
7234     if(view)
7235         IOleDocumentView_Release(view);
7236     view = NULL;
7237
7238     release_document(doc);
7239 }
7240
7241 static void test_cookies(IHTMLDocument2 *doc)
7242 {
7243     WCHAR buf[1024];
7244     DWORD size;
7245     BSTR str, str2;
7246     BOOL b;
7247     HRESULT hres;
7248
7249     hres = IHTMLDocument2_get_cookie(doc, &str);
7250     ok(hres == S_OK, "get_cookie failed: %08x\n", hres);
7251     if(str) {
7252         size = sizeof(buf)/sizeof(WCHAR);
7253         b = InternetGetCookieW(http_urlW, NULL, buf, &size);
7254         ok(b, "InternetGetCookieW failed: %08x\n", GetLastError());
7255         ok(!lstrcmpW(buf, str), "cookie = %s, expected %s\n", wine_dbgstr_w(str), wine_dbgstr_w(buf));
7256         SysFreeString(str);
7257     }
7258
7259     str = a2bstr("test=testval");
7260     hres = IHTMLDocument2_put_cookie(doc, str);
7261     ok(hres == S_OK, "put_cookie failed: %08x\n", hres);
7262
7263     str2 = NULL;
7264     hres = IHTMLDocument2_get_cookie(doc, &str2);
7265     ok(hres == S_OK, "get_cookie failed: %08x\n", hres);
7266     ok(str2 != NULL, "cookie = NULL\n");
7267     size = sizeof(buf)/sizeof(WCHAR);
7268     b = InternetGetCookieW(http_urlW, NULL, buf, &size);
7269     ok(b, "InternetGetCookieW failed: %08x\n", GetLastError());
7270     ok(!lstrcmpW(buf, str2), "cookie = %s, expected %s\n", wine_dbgstr_w(str2), wine_dbgstr_w(buf));
7271     ok(strstrW(str2, str) != NULL, "could not find %s in %s\n", wine_dbgstr_w(str), wine_dbgstr_w(str2));
7272     SysFreeString(str);
7273     SysFreeString(str2);
7274
7275     str = a2bstr("test=testval2");
7276     hres = IHTMLDocument2_put_cookie(doc, str);
7277     ok(hres == S_OK, "put_cookie failed: %08x\n", hres);
7278
7279     str2 = NULL;
7280     hres = IHTMLDocument2_get_cookie(doc, &str2);
7281     ok(hres == S_OK, "get_cookie failed: %08x\n", hres);
7282     ok(str2 != NULL, "cookie = NULL\n");
7283     size = sizeof(buf)/sizeof(WCHAR);
7284     b = InternetGetCookieW(http_urlW, NULL, buf, &size);
7285     ok(b, "InternetGetCookieW failed: %08x\n", GetLastError());
7286     ok(!lstrcmpW(buf, str2), "cookie = %s, expected %s\n", wine_dbgstr_w(str2), wine_dbgstr_w(buf));
7287     ok(strstrW(str2, str) != NULL, "could not find %s in %s\n", wine_dbgstr_w(str), wine_dbgstr_w(str2));
7288     SysFreeString(str);
7289     SysFreeString(str2);
7290 }
7291
7292 static void test_HTMLDocument_http(BOOL with_wbapp)
7293 {
7294     IMoniker *http_mon;
7295     IHTMLDocument2 *doc;
7296     ULONG ref;
7297     HRESULT hres;
7298
7299     trace("Testing HTMLDocument (http%s)...\n", with_wbapp ? " with IWebBrowserApp" : "");
7300
7301     support_wbapp = with_wbapp;
7302
7303     if(!winetest_interactive && is_ie_hardened()) {
7304         win_skip("IE running in Enhanced Security Configuration\n");
7305         return;
7306     }
7307
7308     init_test(LD_DOLOAD);
7309     ipsex = TRUE;
7310
7311     doc = create_document();
7312     doc_unk = (IUnknown*)doc;
7313
7314     hres = CreateURLMoniker(NULL, http_urlW, &http_mon);
7315     ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
7316
7317     test_ViewAdviseSink(doc);
7318     test_ConnectionPointContainer(doc);
7319     test_GetCurMoniker((IUnknown*)doc, NULL, NULL);
7320     test_Persist(doc, http_mon);
7321     test_Navigate(doc);
7322     test_download(DWL_HTTP);
7323     test_cookies(doc);
7324     test_IsDirty(doc, S_FALSE);
7325     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7326     test_GetCurMoniker((IUnknown*)doc, http_mon, NULL);
7327     test_travellog(doc);
7328     test_binding_ui((IUnknown*)doc);
7329
7330     nav_url = nav_serv_url = "http://test.winehq.org/tests/winehq_snapshot/"; /* for valid prev nav_url */
7331     if(support_wbapp) {
7332         test_put_href(doc, FALSE, "#test", "http://test.winehq.org/tests/winehq_snapshot/#test", FALSE, TRUE, 0);
7333         test_travellog(doc);
7334         test_refresh(doc);
7335     }
7336     test_put_href(doc, FALSE, NULL, "javascript:external%20&&undefined", TRUE, FALSE, 0);
7337     test_put_href(doc, FALSE, NULL, "about:blank", FALSE, FALSE, support_wbapp ? DWL_EXPECT_HISTUPDATE : 0);
7338     test_put_href(doc, TRUE, NULL, "about:replace", FALSE, FALSE, 0);
7339     if(support_wbapp) {
7340         test_load_history(doc);
7341         test_OmHistory(doc);
7342         test_put_href(doc, FALSE, NULL, "about:blank", FALSE, FALSE, support_wbapp ? DWL_EXPECT_HISTUPDATE : 0);
7343     }
7344
7345     prev_url = nav_serv_url;
7346     test_open_window(doc, TRUE);
7347     if(!support_wbapp) /* FIXME */
7348         test_open_window(doc, FALSE);
7349     if(support_wbapp)
7350         test_window_close(doc);
7351
7352     test_InPlaceDeactivate(doc, TRUE);
7353     test_Close(doc, FALSE);
7354     test_IsDirty(doc, S_FALSE);
7355     test_GetCurMoniker((IUnknown*)doc, NULL, prev_url);
7356
7357     if(view)
7358         IOleDocumentView_Release(view);
7359     view = NULL;
7360
7361     release_document(doc);
7362
7363     ref = IMoniker_Release(http_mon);
7364     ok(!ref, "ref=%d, expected 0\n", ref);
7365 }
7366
7367 static void test_QueryService(IHTMLDocument2 *doc, BOOL success)
7368 {
7369     IHTMLWindow2 *window, *sp_window;
7370     IServiceProvider *sp;
7371     IHlinkFrame *hf;
7372     HRESULT hres;
7373
7374     hres = IHTMLDocument2_QueryInterface(doc, &IID_IServiceProvider, (void**)&sp);
7375     ok(hres == S_OK, "QueryService returned %08x\n", hres);
7376
7377     hres = IServiceProvider_QueryService(sp, &IID_IHlinkFrame, &IID_IHlinkFrame, (void**)&hf);
7378     if(!success) {
7379         ok(hres == E_NOINTERFACE, "QueryService returned %08x, expected E_NOINTERFACE\n", hres);
7380         IServiceProvider_Release(sp);
7381         return;
7382     }
7383
7384     ok(hres == S_OK, "QueryService(IID_IHlinkFrame) failed: %08x\n", hres);
7385     ok(hf == &HlinkFrame, "hf != HlinkFrame\n");
7386     IHlinkFrame_Release(hf);
7387
7388     IServiceProvider_Release(sp);
7389
7390     hres = IHTMLDocument2_get_parentWindow(doc, &window);
7391     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
7392
7393     hres = IHTMLWindow2_QueryInterface(window, &IID_IServiceProvider, (void**)&sp);
7394     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
7395
7396     hres = IServiceProvider_QueryService(sp, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&sp_window);
7397     ok(hres == S_OK, "QueryService(IID_IHTMLWindow2) failed: %08x\n", hres);
7398     /* FIXME: test returned window */
7399     IHTMLWindow2_Release(sp_window);
7400
7401     hres = IServiceProvider_QueryService(sp, &IID_IHlinkFrame, &IID_IHlinkFrame, (void**)&hf);
7402     ok(hres == S_OK, "QueryService(IID_IHlinkFrame) failed: %08x\n", hres);
7403     ok(hf == &HlinkFrame, "hf != HlinkFrame\n");
7404     IHlinkFrame_Release(hf);
7405
7406     IServiceProvider_Release(sp);
7407     IHTMLWindow2_Release(window);
7408 }
7409
7410 static void test_HTMLDocument_StreamLoad(void)
7411 {
7412     IHTMLDocument2 *doc;
7413     IOleObject *oleobj;
7414     DWORD conn;
7415     HRESULT hres;
7416
7417     trace("Testing HTMLDocument (IPersistStreamInit)...\n");
7418
7419     init_test(LD_DOLOAD);
7420     load_from_stream = TRUE;
7421
7422     doc = create_document();
7423     doc_unk = (IUnknown*)doc;
7424
7425     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
7426     ok(hres == S_OK, "Could not get IOleObject: %08x\n", hres);
7427
7428     hres = IOleObject_Advise(oleobj, (IAdviseSink*)&AdviseSink, &conn);
7429     ok(hres == S_OK, "Advise failed: %08x\n", hres);
7430
7431     test_readyState((IUnknown*)doc);
7432     test_IsDirty(doc, S_FALSE);
7433     test_ViewAdviseSink(doc);
7434     test_ConnectionPointContainer(doc);
7435     test_QueryService(doc, FALSE);
7436     test_ClientSite(oleobj, CLIENTSITE_EXPECTPATH);
7437     test_QueryService(doc, TRUE);
7438     test_DoVerb(oleobj);
7439     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7440
7441     test_GetCurMoniker((IUnknown*)doc, NULL, NULL);
7442     test_StreamLoad(doc);
7443     test_download(DWL_VERBDONE|DWL_TRYCSS);
7444     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7445
7446     test_UIDeactivate();
7447     test_InPlaceDeactivate(doc, TRUE);
7448     SET_EXPECT(Advise_Close);
7449     test_Close(doc, TRUE);
7450     CHECK_CALLED(Advise_Close);
7451     test_external(doc, FALSE);
7452     test_IsDirty(doc, S_FALSE);
7453
7454     set_custom_uihandler(doc, &CustomDocHostUIHandler);
7455     test_ClientSite(oleobj, CLIENTSITE_SETNULL);
7456     test_external(doc, TRUE);
7457     test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
7458     test_external(doc, TRUE);
7459     set_custom_uihandler(doc, NULL);
7460     test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
7461
7462     IOleObject_Release(oleobj);
7463     if(view) {
7464         IOleDocumentView_Release(view);
7465         view = NULL;
7466     }
7467
7468     release_document(doc);
7469 }
7470
7471 static void test_HTMLDocument_StreamInitNew(void)
7472 {
7473     IHTMLDocument2 *doc;
7474     IOleObject *oleobj;
7475     DWORD conn;
7476     HRESULT hres;
7477
7478     trace("Testing HTMLDocument (IPersistStreamInit::InitNew)...\n");
7479
7480     init_test(LD_DOLOAD);
7481     load_from_stream = TRUE;
7482
7483     doc = create_document();
7484     doc_unk = (IUnknown*)doc;
7485
7486     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
7487     ok(hres == S_OK, "Could not get IOleObject: %08x\n", hres);
7488
7489     hres = IOleObject_Advise(oleobj, (IAdviseSink*)&AdviseSink, &conn);
7490     ok(hres == S_OK, "Advise failed: %08x\n", hres);
7491
7492     test_readyState((IUnknown*)doc);
7493     test_IsDirty(doc, S_FALSE);
7494     test_ViewAdviseSink(doc);
7495     test_ConnectionPointContainer(doc);
7496     test_ClientSite(oleobj, CLIENTSITE_EXPECTPATH);
7497     test_DoVerb(oleobj);
7498     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7499
7500     IOleObject_Release(oleobj);
7501
7502     test_GetCurMoniker((IUnknown*)doc, NULL, NULL);
7503     test_StreamInitNew(doc);
7504
7505     SET_EXPECT(Invoke_OnReadyStateChange_Interactive);
7506     test_download(DWL_VERBDONE|DWL_TRYCSS|DWL_EMPTY);
7507     todo_wine CHECK_NOT_CALLED(Invoke_OnReadyStateChange_Interactive);
7508
7509     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7510
7511     test_UIDeactivate();
7512     test_InPlaceDeactivate(doc, TRUE);
7513     SET_EXPECT(Advise_Close);
7514     test_Close(doc, FALSE);
7515     CHECK_CALLED(Advise_Close);
7516     test_IsDirty(doc, S_FALSE);
7517
7518     if(view) {
7519         IOleDocumentView_Release(view);
7520         view = NULL;
7521     }
7522
7523     release_document(doc);
7524 }
7525
7526 static void test_edit_uiactivate(IOleObject *oleobj)
7527 {
7528     IOleDocumentView *docview;
7529     HRESULT hres;
7530
7531     hres = IOleObject_QueryInterface(oleobj, &IID_IOleDocumentView, (void **)&docview);
7532     ok(hres == S_OK, "IOleObject_QueryInterface failed with error 0x%08x\n", hres);
7533
7534     SET_EXPECT(OnFocus_TRUE);
7535     SET_EXPECT(SetActiveObject);
7536     SET_EXPECT(ShowUI);
7537     SET_EXPECT(InPlaceUIWindow_SetActiveObject);
7538     SET_EXPECT(InPlaceFrame_SetBorderSpace);
7539     expect_status_text = NULL;
7540
7541     hres = IOleDocumentView_UIActivate(docview, TRUE);
7542     ok(hres == S_OK, "IOleDocumentView_UIActivate failed with error 0x%08x\n", hres);
7543
7544     CHECK_CALLED(OnFocus_TRUE);
7545     CHECK_CALLED(SetActiveObject);
7546     CHECK_CALLED(ShowUI);
7547     CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
7548     CHECK_CALLED(InPlaceFrame_SetBorderSpace);
7549
7550     IOleDocumentView_Release(docview);
7551 }
7552
7553 static void test_editing_mode(BOOL do_load, BOOL use_design_mode)
7554 {
7555     IHTMLDocument2 *doc;
7556     IUnknown *unk;
7557     IOleObject *oleobj;
7558     DWORD conn;
7559     HRESULT hres;
7560
7561     trace("Testing HTMLDocument (edit%s%s)...\n", do_load ? " load" : "", use_design_mode ? " using designMode" : "");
7562
7563     init_test(do_load ? LD_DOLOAD : LD_NO);
7564     call_UIActivate = CallUIActivate_AfterShow;
7565
7566     doc = create_document();
7567     unk = doc_unk = (IUnknown*)doc;
7568
7569     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
7570     ok(hres == S_OK, "Could not get IOleObject: %08x\n", hres);
7571
7572     hres = IOleObject_Advise(oleobj, (IAdviseSink*)&AdviseSink, &conn);
7573     ok(hres == S_OK, "Advise failed: %08x\n", hres);
7574
7575     test_readyState((IUnknown*)doc);
7576     test_ViewAdviseSink(doc);
7577     test_ConnectionPointContainer(doc);
7578     test_ClientSite(oleobj, CLIENTSITE_EXPECTPATH);
7579     test_DoVerb(oleobj);
7580     test_edit_uiactivate(oleobj);
7581
7582     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7583     if(do_load)
7584         test_Persist(doc, &Moniker);
7585     stream_read = protocol_read = 0;
7586
7587     if(!use_design_mode) {
7588         test_exec_editmode(unk, do_load);
7589         test_UIDeactivate();
7590         call_UIActivate = CallUIActivate_None;
7591     }else {
7592         BSTR on;
7593
7594         SET_EXPECT(Exec_SETTITLE);
7595         test_download(DWL_VERBDONE|DWL_CSS|DWL_TRYCSS);
7596         CLEAR_CALLED(Exec_SETTITLE);
7597
7598         editmode = TRUE;
7599         load_state = LD_DOLOAD;
7600         readystate_set_loading = TRUE;
7601
7602         SET_EXPECT(OnChanged_1005);
7603         SET_EXPECT(ActiveElementChanged);
7604         SET_EXPECT(GetClassID);
7605         SET_EXPECT(SetStatusText);
7606         SET_EXPECT(Exec_ShellDocView_37);
7607         SET_EXPECT(GetHostInfo);
7608         SET_EXPECT(GetDisplayName);
7609         SET_EXPECT(Invoke_AMBIENT_SILENT);
7610         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
7611         SET_EXPECT(OnChanged_READYSTATE);
7612         SET_EXPECT(Invoke_OnReadyStateChange_Loading);
7613         SET_EXPECT(IsSystemMoniker);
7614         SET_EXPECT(Exec_ShellDocView_84);
7615         SET_EXPECT(BindToStorage);
7616         SET_EXPECT(InPlaceUIWindow_SetActiveObject);
7617         SET_EXPECT(HideUI);
7618         SET_EXPECT(ShowUI);
7619         SET_EXPECT(InPlaceFrame_SetBorderSpace);
7620         SET_EXPECT(OnChanged_1014);
7621
7622         on = a2bstr("On");
7623         hres = IHTMLDocument2_put_designMode(doc, on);
7624         SysFreeString(on);
7625         ok(hres == S_OK, "put_designMode failed: %08x\n", hres);
7626
7627         todo_wine CHECK_CALLED(OnChanged_1005);
7628         todo_wine CHECK_CALLED(ActiveElementChanged);
7629         CHECK_CALLED(GetClassID);
7630         CHECK_CALLED(SetStatusText);
7631         CHECK_CALLED(Exec_ShellDocView_37);
7632         CHECK_CALLED(GetHostInfo);
7633         CHECK_CALLED(GetDisplayName);
7634         CHECK_CALLED(Invoke_AMBIENT_SILENT);
7635         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
7636         CHECK_CALLED(OnChanged_READYSTATE);
7637         CHECK_CALLED(Invoke_OnReadyStateChange_Loading);
7638         CLEAR_CALLED(IsSystemMoniker); /* IE7 */
7639         CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
7640         CHECK_CALLED(BindToStorage);
7641         CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
7642         CHECK_CALLED(HideUI);
7643         CHECK_CALLED(ShowUI);
7644         CHECK_CALLED(InPlaceFrame_SetBorderSpace);
7645         CHECK_CALLED(OnChanged_1014);
7646
7647         test_timer(EXPECT_UPDATEUI|EXPECT_SETTITLE);
7648     }
7649
7650     IOleObject_Release(oleobj);
7651
7652     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED);
7653     test_download(DWL_VERBDONE | DWL_EX_GETHOSTINFO | (do_load ? DWL_CSS|DWL_TRYCSS : 0));
7654
7655     SET_EXPECT(SetStatusText); /* ignore race in native mshtml */
7656     test_timer(EXPECT_UPDATEUI);
7657     CLEAR_CALLED(SetStatusText);
7658
7659     test_MSHTML_QueryStatus(doc, OLECMDF_SUPPORTED|OLECMDF_ENABLED);
7660
7661     if(!do_load) {
7662         test_exec_fontname(unk, wszArial, wszTimesNewRoman);
7663         test_timer(EXPECT_UPDATEUI);
7664         test_exec_fontname(unk, NULL, wszArial);
7665
7666         test_exec_noargs(unk, IDM_JUSTIFYRIGHT);
7667         test_timer(EXPECT_UPDATEUI);
7668         test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYRIGHT,
7669                          OLECMDF_SUPPORTED|OLECMDF_ENABLED|OLECMDF_LATCHED);
7670
7671         test_exec_noargs(unk, IDM_JUSTIFYCENTER);
7672         test_timer(EXPECT_UPDATEUI);
7673         test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYRIGHT,
7674                          OLECMDF_SUPPORTED|OLECMDF_ENABLED);
7675         test_QueryStatus(unk, &CGID_MSHTML, IDM_JUSTIFYCENTER,
7676                          OLECMDF_SUPPORTED|OLECMDF_ENABLED|OLECMDF_LATCHED);
7677
7678         test_exec_noargs(unk, IDM_HORIZONTALLINE);
7679         test_timer(EXPECT_UPDATEUI);
7680         test_QueryStatus(unk, &CGID_MSHTML, IDM_HORIZONTALLINE,
7681                          OLECMDF_SUPPORTED|OLECMDF_ENABLED);
7682     }
7683
7684     test_UIDeactivate();
7685     test_InPlaceDeactivate(doc, TRUE);
7686     SET_EXPECT(Advise_Close);
7687     test_Close(doc, FALSE);
7688     CHECK_CALLED(Advise_Close);
7689
7690     if(view) {
7691         IOleDocumentView_Release(view);
7692         view = NULL;
7693     }
7694
7695     release_document(doc);
7696 }
7697
7698 static void test_UIActivate(BOOL do_load, BOOL use_ipsex, BOOL use_ipsw)
7699 {
7700     IHTMLDocument2 *doc;
7701     IOleObject *oleobj;
7702     IOleInPlaceSite *inplacesite;
7703     HRESULT hres;
7704
7705     trace("Running OleDocumentView_UIActivate tests (%d %d %d)\n", do_load, use_ipsex, use_ipsw);
7706
7707     init_test(do_load ? LD_DOLOAD : LD_NO);
7708
7709     doc = create_document();
7710     doc_unk = (IUnknown*)doc;
7711
7712     ipsex = use_ipsex;
7713     ipsw = use_ipsw;
7714
7715     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
7716     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08x\n", hres);
7717
7718     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleDocumentView, (void**)&view);
7719     ok(hres == S_OK, "QueryInterface(IID_IOleDocumentView) failed: %08x\n", hres);
7720
7721     SET_EXPECT(Invoke_AMBIENT_USERMODE);
7722     SET_EXPECT(GetHostInfo);
7723     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
7724     SET_EXPECT(Invoke_AMBIENT_SILENT);
7725     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
7726     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
7727     SET_EXPECT(Invoke_AMBIENT_PALETTE);
7728     SET_EXPECT(GetOptionKeyPath);
7729     SET_EXPECT(GetOverrideKeyPath);
7730     SET_EXPECT(GetWindow);
7731     SET_EXPECT(Exec_DOCCANNAVIGATE);
7732     SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
7733     SET_EXPECT(Exec_SETPROGRESSMAX);
7734     SET_EXPECT(Exec_SETPROGRESSPOS);
7735     SET_EXPECT(GetTravelLog);
7736     SET_EXPECT(Exec_ShellDocView_84);
7737
7738     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
7739     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
7740     set_clientsite = TRUE;
7741
7742     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
7743     CHECK_CALLED(GetHostInfo);
7744     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
7745     CHECK_CALLED(Invoke_AMBIENT_SILENT);
7746     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
7747     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
7748     CLEAR_CALLED(Invoke_AMBIENT_PALETTE); /* not called on IE9 */
7749     CLEAR_CALLED(GetOptionKeyPath); /* not called on some IE9 */
7750     CHECK_CALLED(GetOverrideKeyPath);
7751     CHECK_CALLED(GetWindow);
7752     CHECK_CALLED(Exec_DOCCANNAVIGATE);
7753     CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
7754     CHECK_CALLED(Exec_SETPROGRESSMAX);
7755     CHECK_CALLED(Exec_SETPROGRESSPOS);
7756     CHECK_CALLED(GetTravelLog);
7757     CHECK_CALLED_BROKEN(Exec_ShellDocView_84);
7758
7759     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
7760     ok(hres == S_OK, "GetInPlaceSite failed: %08x\n", hres);
7761     ok(inplacesite == NULL, "inplacesite = %p, expected NULL\n", inplacesite);
7762
7763     SET_EXPECT(GetContainer);
7764     SET_EXPECT(LockContainer);
7765     SET_EXPECT(CanInPlaceActivate);
7766     SET_EXPECT(GetWindowContext);
7767     SET_EXPECT(GetWindow);
7768     if(use_ipsex) {
7769         SET_EXPECT(OnInPlaceActivateEx);
7770         SET_EXPECT(RequestUIActivate);
7771     }
7772     else
7773         SET_EXPECT(OnInPlaceActivate);
7774     SET_EXPECT(OnUIActivate);
7775     SET_EXPECT(SetStatusText);
7776     SET_EXPECT(Exec_SETPROGRESSMAX);
7777     SET_EXPECT(Exec_SETPROGRESSPOS);
7778     SET_EXPECT(ShowUI);
7779     SET_EXPECT(InPlaceUIWindow_SetActiveObject);
7780     SET_EXPECT(InPlaceFrame_SetBorderSpace);
7781     SET_EXPECT(OnFocus_TRUE);
7782     SET_EXPECT(SetActiveObject);
7783     expect_LockContainer_fLock = TRUE;
7784
7785     hres = IOleDocumentView_UIActivate(view, TRUE);
7786     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
7787
7788     CHECK_CALLED(GetContainer);
7789     CHECK_CALLED(LockContainer);
7790     CHECK_CALLED(CanInPlaceActivate);
7791     CHECK_CALLED(GetWindowContext);
7792     CHECK_CALLED(GetWindow);
7793     if(use_ipsex) {
7794         CHECK_CALLED(OnInPlaceActivateEx);
7795         SET_EXPECT(RequestUIActivate);
7796     }
7797     else
7798         CHECK_CALLED(OnInPlaceActivate);
7799     CHECK_CALLED(OnUIActivate);
7800     CHECK_CALLED(SetStatusText);
7801     CHECK_CALLED(Exec_SETPROGRESSMAX);
7802     CHECK_CALLED(Exec_SETPROGRESSPOS);
7803     CHECK_CALLED(ShowUI);
7804     CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
7805     CHECK_CALLED(InPlaceFrame_SetBorderSpace);
7806     CHECK_CALLED(OnFocus_TRUE);
7807     CHECK_CALLED(SetActiveObject);
7808     container_locked = TRUE;
7809
7810     SET_EXPECT(SetActiveObject_null);
7811     SET_EXPECT(InPlaceUIWindow_SetActiveObject);
7812     SET_EXPECT(HideUI);
7813     SET_EXPECT(OnUIDeactivate);
7814
7815     hres = IOleDocumentView_UIActivate(view, FALSE);
7816     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
7817
7818     CHECK_CALLED(SetActiveObject_null);
7819     CHECK_CALLED(InPlaceUIWindow_SetActiveObject);
7820     CHECK_CALLED(HideUI);
7821     CHECK_CALLED(OnUIDeactivate);
7822
7823     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
7824     ok(hres == S_OK, "GetInPlaceSite failed: %08x\n", hres);
7825     ok(inplacesite != NULL, "inplacesite = NULL\n");
7826     IOleInPlaceSite_Release(inplacesite);
7827
7828     SET_EXPECT(SetStatusText);
7829     SET_EXPECT(OnFocus_FALSE);
7830     if(use_ipsex)
7831         SET_EXPECT(OnInPlaceDeactivateEx);
7832     else
7833         SET_EXPECT(OnInPlaceDeactivate);
7834
7835     test_CloseView();
7836
7837     CLEAR_CALLED(SetStatusText); /* Called by IE9 */
7838     CHECK_CALLED(OnFocus_FALSE);
7839     if(use_ipsex)
7840         CHECK_CALLED(OnInPlaceDeactivateEx);
7841     else
7842         CHECK_CALLED(OnInPlaceDeactivate);
7843
7844     test_Close(doc, TRUE);
7845
7846     IOleObject_Release(oleobj);
7847     IOleDocumentView_Release(view);
7848     view = NULL;
7849
7850     release_document(doc);
7851 }
7852
7853 static void register_protocol(void)
7854 {
7855     IInternetSession *session;
7856     HRESULT hres;
7857
7858     static const WCHAR wsz_winetest[] = {'w','i','n','e','t','e','s','t',0};
7859
7860     hres = CoInternetGetSession(0, &session, 0);
7861     ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
7862
7863     hres = IInternetSession_RegisterNameSpace(session, &ClassFactory, &IID_NULL,
7864             wsz_winetest, 0, NULL, 0);
7865     ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
7866
7867     IInternetSession_Release(session);
7868 }
7869
7870 static void test_HTMLDoc_ISupportErrorInfo(void)
7871 {
7872     IHTMLDocument2 *doc;
7873     HRESULT hres;
7874     ISupportErrorInfo *sinfo;
7875
7876     doc = create_document();
7877
7878     hres = IHTMLDocument2_QueryInterface(doc, &IID_ISupportErrorInfo, (void**)&sinfo);
7879     ok(hres == S_OK, "got %x\n", hres);
7880     ok(sinfo != NULL, "got %p\n", sinfo);
7881     if(sinfo)
7882     {
7883         hres = ISupportErrorInfo_InterfaceSupportsErrorInfo(sinfo, &IID_IErrorInfo);
7884         ok(hres == S_FALSE, "Expected S_OK, got %x\n", hres);
7885         ISupportErrorInfo_Release(sinfo);
7886     }
7887
7888     release_document(doc);
7889 }
7890
7891 static BOOL check_ie(void)
7892 {
7893     IHTMLDocument2 *doc;
7894     IHTMLDocument5 *doc5;
7895     HRESULT hres;
7896
7897     doc = create_document();
7898     if(!doc)
7899         return FALSE;
7900
7901     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument5, (void**)&doc5);
7902     if(SUCCEEDED(hres))
7903         IHTMLDocument5_Release(doc5);
7904
7905     release_document(doc);
7906     return SUCCEEDED(hres);
7907 }
7908
7909 static void test_ServiceProvider(void)
7910 {
7911     IHTMLDocument3 *doc3, *doc3_2;
7912     IServiceProvider *provider;
7913     IHTMLDocument2 *doc, *doc2;
7914     IUnknown *unk;
7915     HRESULT hres;
7916
7917     doc = create_document();
7918     if(!doc)
7919         return;
7920
7921     hres = IHTMLDocument2_QueryInterface(doc, &IID_IServiceProvider, (void**)&provider);
7922     ok(hres == S_OK, "got 0x%08x\n", hres);
7923
7924     hres = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IHTMLDocument2, (void**)&doc2);
7925     ok(hres == S_OK, "got 0x%08x\n", hres);
7926     ok(iface_cmp((IUnknown*)doc2, (IUnknown*)doc), "got wrong pointer\n");
7927     IHTMLDocument2_Release(doc2);
7928
7929     hres = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IHTMLDocument3, (void**)&doc3);
7930     ok(hres == S_OK, "got 0x%08x\n", hres);
7931     ok(iface_cmp((IUnknown*)doc3, (IUnknown*)doc), "got wrong pointer\n");
7932
7933     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3_2);
7934     ok(hres == S_OK, "got 0x%08x\n", hres);
7935     ok(iface_cmp((IUnknown*)doc3_2, (IUnknown*)doc), "got wrong pointer\n");
7936     ok(iface_cmp((IUnknown*)doc3_2, (IUnknown*)doc3), "got wrong pointer\n");
7937     IHTMLDocument3_Release(doc3);
7938     IHTMLDocument3_Release(doc3_2);
7939
7940     hres = IServiceProvider_QueryService(provider, &SID_SContainerDispatch, &IID_IUnknown, (void**)&unk);
7941     ok(hres == S_OK, "got 0x%08x\n", hres);
7942     ok(iface_cmp((IUnknown*)doc, unk), "got wrong pointer\n");
7943
7944     IUnknown_Release(unk);
7945     IServiceProvider_Release(provider);
7946     release_document(doc);
7947 }
7948
7949 START_TEST(htmldoc)
7950 {
7951     CoInitialize(NULL);
7952
7953     if(!check_ie()) {
7954         CoUninitialize();
7955         win_skip("Too old IE\n");
7956         return;
7957     }
7958
7959     container_hwnd = create_container_window();
7960     register_protocol();
7961
7962     asynchronous_binding = TRUE;
7963     test_HTMLDocument_hlink(HTTP_STATUS_NOT_FOUND);
7964
7965     asynchronous_binding = FALSE;
7966     test_HTMLDocument_hlink(HTTP_STATUS_OK);
7967     test_HTMLDocument(FALSE, TRUE);
7968     test_HTMLDocument(TRUE, FALSE);
7969     test_HTMLDocument(TRUE, TRUE);
7970     test_HTMLDocument_StreamLoad();
7971     test_HTMLDocument_StreamInitNew();
7972     if (winetest_interactive)
7973         test_editing_mode(FALSE, FALSE);
7974     else
7975         skip("Skipping test_editing_mode(FALSE, FALSE). ROSTESTS-113.\n");
7976     test_editing_mode(TRUE, FALSE);
7977     test_editing_mode(TRUE, TRUE);
7978     if (winetest_interactive)
7979     {
7980         test_HTMLDocument_http(FALSE);
7981         test_HTMLDocument_http(TRUE);
7982     }
7983     else
7984     {
7985         skip("Skipping test_HTMLDocument_http(FALSE). ROSTESTS-113.\n");
7986         skip("Skipping test_HTMLDocument_http(TRUE). ROSTESTS-113.\n");
7987     }
7988
7989     test_UIActivate(FALSE, FALSE, FALSE);
7990     test_UIActivate(FALSE, TRUE, FALSE);
7991     test_UIActivate(FALSE, TRUE, TRUE);
7992     test_UIActivate(TRUE, FALSE, FALSE);
7993     test_UIActivate(TRUE, TRUE, FALSE);
7994     test_UIActivate(TRUE, TRUE, TRUE);
7995     test_HTMLDoc_ISupportErrorInfo();
7996     test_ServiceProvider();
7997
7998     DestroyWindow(container_hwnd);
7999     CoUninitialize();
8000 }