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