dlls/mshtml/omnavigator.c

   1 /*
   2  * Copyright 2008,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 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct HTMLPluginsCollection HTMLPluginsCollection;
  35 typedef struct HTMLMimeTypesCollection HTMLMimeTypesCollection;
  36
  37 typedef struct {
  38     DispatchEx dispex;
  39     IOmNavigator IOmNavigator_iface;
  40
  41     LONG ref;
  42
  43     HTMLPluginsCollection *plugins;
  44     HTMLMimeTypesCollection *mime_types;
  45 } OmNavigator;
  46
  47 typedef struct {
  48     DispatchEx dispex;
  49     IHTMLDOMImplementation IHTMLDOMImplementation_iface;
  50     IHTMLDOMImplementation2 IHTMLDOMImplementation2_iface;
  51
  52     LONG ref;
  53
  54     nsIDOMDOMImplementation *implementation;
  55     GeckoBrowser *browser;
  56 } HTMLDOMImplementation;
  57
  58 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation(IHTMLDOMImplementation *iface)
  59 {
  60     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation_iface);
  61 }
  62
  63 static HRESULT WINAPI HTMLDOMImplementation_QueryInterface(IHTMLDOMImplementation *iface, REFIID riid, void **ppv)
  64 {
  65     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  66
  67     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  68
  69     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IHTMLDOMImplementation, riid)) {
  70         *ppv = &This->IHTMLDOMImplementation_iface;
  71     }else if(IsEqualGUID(&IID_IHTMLDOMImplementation2, riid)) {
  72         *ppv = &This->IHTMLDOMImplementation2_iface;
  73     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
  74         return *ppv ? S_OK : E_NOINTERFACE;
  75     }else {
  76         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
  77         *ppv = NULL;
  78         return E_NOINTERFACE;
  79     }
  80
  81     IUnknown_AddRef((IUnknown*)*ppv);
  82     return S_OK;
  83 }
  84
  85 static ULONG WINAPI HTMLDOMImplementation_AddRef(IHTMLDOMImplementation *iface)
  86 {
  87     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  88     LONG ref = InterlockedIncrement(&This->ref);
  89
  90     TRACE("(%p) ref=%ld\n", This, ref);
  91
  92     return ref;
  93 }
  94
  95 static ULONG WINAPI HTMLDOMImplementation_Release(IHTMLDOMImplementation *iface)
  96 {
  97     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  98     LONG ref = InterlockedDecrement(&This->ref);
  99
 100     TRACE("(%p) ref=%ld\n", This, ref);
 101
 102     if(!ref) {
 103         assert(!This->browser);
 104         if(This->implementation)
 105             nsIDOMDOMImplementation_Release(This->implementation);
 106         release_dispex(&This->dispex);
 107         heap_free(This);
 108     }
 109
 110     return ref;
 111 }
 112
 113 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfoCount(IHTMLDOMImplementation *iface, UINT *pctinfo)
 114 {
 115     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 116
 117     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 118 }
 119
 120 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfo(IHTMLDOMImplementation *iface, UINT iTInfo,
 121         LCID lcid, ITypeInfo **ppTInfo)
 122 {
 123     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 124
 125     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 126 }
 127
 128 static HRESULT WINAPI HTMLDOMImplementation_GetIDsOfNames(IHTMLDOMImplementation *iface, REFIID riid,
 129         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 130 {
 131     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 132
 133     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 134             cNames, lcid, rgDispId);
 135 }
 136
 137 static HRESULT WINAPI HTMLDOMImplementation_Invoke(IHTMLDOMImplementation *iface, DISPID dispIdMember,
 138         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 139         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 140 {
 141     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 142
 143     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 144             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 145 }
 146
 147 static HRESULT WINAPI HTMLDOMImplementation_hasFeature(IHTMLDOMImplementation *iface, BSTR feature,
 148         VARIANT version, VARIANT_BOOL *pfHasFeature)
 149 {
 150     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 151
 152     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 153
 154     *pfHasFeature = VARIANT_FALSE;
 155     return S_OK;
 156 }
 157
 158 static const IHTMLDOMImplementationVtbl HTMLDOMImplementationVtbl = {
 159     HTMLDOMImplementation_QueryInterface,
 160     HTMLDOMImplementation_AddRef,
 161     HTMLDOMImplementation_Release,
 162     HTMLDOMImplementation_GetTypeInfoCount,
 163     HTMLDOMImplementation_GetTypeInfo,
 164     HTMLDOMImplementation_GetIDsOfNames,
 165     HTMLDOMImplementation_Invoke,
 166     HTMLDOMImplementation_hasFeature
 167 };
 168
 169 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation2(IHTMLDOMImplementation2 *iface)
 170 {
 171     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation2_iface);
 172 }
 173
 174 static HRESULT WINAPI HTMLDOMImplementation2_QueryInterface(IHTMLDOMImplementation2 *iface, REFIID riid, void **ppv)
 175 {
 176     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 177     return IHTMLDOMImplementation_QueryInterface(&This->IHTMLDOMImplementation_iface, riid, ppv);
 178 }
 179
 180 static ULONG WINAPI HTMLDOMImplementation2_AddRef(IHTMLDOMImplementation2 *iface)
 181 {
 182     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 183     return IHTMLDOMImplementation_AddRef(&This->IHTMLDOMImplementation_iface);
 184 }
 185
 186 static ULONG WINAPI HTMLDOMImplementation2_Release(IHTMLDOMImplementation2 *iface)
 187 {
 188     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 189     return IHTMLDOMImplementation_Release(&This->IHTMLDOMImplementation_iface);
 190 }
 191
 192 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfoCount(IHTMLDOMImplementation2 *iface, UINT *pctinfo)
 193 {
 194     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 195     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 196 }
 197
 198 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfo(IHTMLDOMImplementation2 *iface, UINT iTInfo,
 199         LCID lcid, ITypeInfo **ppTInfo)
 200 {
 201     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 202     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 203 }
 204
 205 static HRESULT WINAPI HTMLDOMImplementation2_GetIDsOfNames(IHTMLDOMImplementation2 *iface, REFIID riid,
 206         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 207 {
 208     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 209     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 210             cNames, lcid, rgDispId);
 211 }
 212
 213 static HRESULT WINAPI HTMLDOMImplementation2_Invoke(IHTMLDOMImplementation2 *iface, DISPID dispIdMember,
 214         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 215         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 216 {
 217     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 218     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 219             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 220 }
 221
 222 static HRESULT WINAPI HTMLDOMImplementation2_createDocumentType(IHTMLDOMImplementation2 *iface, BSTR name,
 223         VARIANT *public_id, VARIANT *system_id, IDOMDocumentType **new_type)
 224 {
 225     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 226     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(name), debugstr_variant(public_id),
 227           debugstr_variant(system_id), new_type);
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI HTMLDOMImplementation2_createDocument(IHTMLDOMImplementation2 *iface, VARIANT *ns,
 232         VARIANT *tag_name, IDOMDocumentType *document_type, IHTMLDocument7 **new_document)
 233 {
 234     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 235     FIXME("(%p)->(%s %s %p %p)\n", This, debugstr_variant(ns), debugstr_variant(tag_name),
 236           document_type, new_document);
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI HTMLDOMImplementation2_createHTMLDocument(IHTMLDOMImplementation2 *iface, BSTR title,
 241         IHTMLDocument7 **new_document)
 242 {
 243     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 244     HTMLDocumentNode *new_document_node;
 245     nsIDOMHTMLDocument *html_doc;
 246     nsIDOMDocument *doc;
 247     nsAString title_str;
 248     nsresult nsres;
 249     HRESULT hres;
 250
 251     FIXME("(%p)->(%s %p)\n", This, debugstr_w(title), new_document);
 252
 253     if(!This->browser)
 254         return E_UNEXPECTED;
 255
 256     nsAString_InitDepend(&title_str, title);
 257     nsres = nsIDOMDOMImplementation_CreateHTMLDocument(This->implementation, &title_str, &doc);
 258     nsAString_Finish(&title_str);
 259     if(NS_FAILED(nsres)) {
 260         ERR("CreateHTMLDocument failed: %08lx\n", nsres);
 261         return E_FAIL;
 262     }
 263
 264     nsres = nsIDOMDocument_QueryInterface(doc, &IID_nsIDOMHTMLDocument, (void**)&html_doc);
 265     nsIDOMDocument_Release(doc);
 266     assert(nsres == NS_OK);
 267
 268     hres = create_document_node(html_doc, This->browser, NULL, dispex_compat_mode(&This->dispex), &new_document_node);
 269     nsIDOMHTMLDocument_Release(html_doc);
 270     if(FAILED(hres))
 271         return hres;
 272
 273     *new_document = &new_document_node->basedoc.IHTMLDocument7_iface;
 274     return S_OK;
 275 }
 276
 277 static HRESULT WINAPI HTMLDOMImplementation2_hasFeature(IHTMLDOMImplementation2 *iface, BSTR feature,
 278         VARIANT version, VARIANT_BOOL *pfHasFeature)
 279 {
 280     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 281
 282     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 283
 284     *pfHasFeature = VARIANT_FALSE;
 285     return S_OK;
 286 }
 287
 288 static const IHTMLDOMImplementation2Vtbl HTMLDOMImplementation2Vtbl = {
 289     HTMLDOMImplementation2_QueryInterface,
 290     HTMLDOMImplementation2_AddRef,
 291     HTMLDOMImplementation2_Release,
 292     HTMLDOMImplementation2_GetTypeInfoCount,
 293     HTMLDOMImplementation2_GetTypeInfo,
 294     HTMLDOMImplementation2_GetIDsOfNames,
 295     HTMLDOMImplementation2_Invoke,
 296     HTMLDOMImplementation2_createDocumentType,
 297     HTMLDOMImplementation2_createDocument,
 298     HTMLDOMImplementation2_createHTMLDocument,
 299     HTMLDOMImplementation2_hasFeature
 300 };
 301
 302 static const tid_t HTMLDOMImplementation_iface_tids[] = {
 303     IHTMLDOMImplementation_tid,
 304     0
 305 };
 306 static dispex_static_data_t HTMLDOMImplementation_dispex = {
 307     L"DOMImplementation",
 308     NULL,
 309     DispHTMLDOMImplementation_tid,
 310     HTMLDOMImplementation_iface_tids
 311 };
 312
 313 HRESULT create_dom_implementation(HTMLDocumentNode *doc_node, IHTMLDOMImplementation **ret)
 314 {
 315     HTMLDOMImplementation *dom_implementation;
 316     nsresult nsres;
 317
 318     if(!doc_node->browser)
 319         return E_UNEXPECTED;
 320
 321     dom_implementation = heap_alloc_zero(sizeof(*dom_implementation));
 322     if(!dom_implementation)
 323         return E_OUTOFMEMORY;
 324
 325     dom_implementation->IHTMLDOMImplementation_iface.lpVtbl = &HTMLDOMImplementationVtbl;
 326     dom_implementation->IHTMLDOMImplementation2_iface.lpVtbl = &HTMLDOMImplementation2Vtbl;
 327     dom_implementation->ref = 1;
 328     dom_implementation->browser = doc_node->browser;
 329
 330     init_dispatch(&dom_implementation->dispex, (IUnknown*)&dom_implementation->IHTMLDOMImplementation_iface,
 331                   &HTMLDOMImplementation_dispex, doc_node->document_mode);
 332
 333     nsres = nsIDOMHTMLDocument_GetImplementation(doc_node->nsdoc, &dom_implementation->implementation);
 334     if(NS_FAILED(nsres)) {
 335         ERR("GetDOMImplementation failed: %08lx\n", nsres);
 336         IHTMLDOMImplementation_Release(&dom_implementation->IHTMLDOMImplementation_iface);
 337         return E_FAIL;
 338     }
 339
 340     *ret = &dom_implementation->IHTMLDOMImplementation_iface;
 341     return S_OK;
 342 }
 343
 344 void detach_dom_implementation(IHTMLDOMImplementation *iface)
 345 {
 346     HTMLDOMImplementation *dom_implementation = impl_from_IHTMLDOMImplementation(iface);
 347     dom_implementation->browser = NULL;
 348 }
 349
 350 typedef struct {
 351     DispatchEx dispex;
 352     IHTMLScreen IHTMLScreen_iface;
 353
 354     LONG ref;
 355 } HTMLScreen;
 356
 357 static inline HTMLScreen *impl_from_IHTMLScreen(IHTMLScreen *iface)
 358 {
 359     return CONTAINING_RECORD(iface, HTMLScreen, IHTMLScreen_iface);
 360 }
 361
 362 static HRESULT WINAPI HTMLScreen_QueryInterface(IHTMLScreen *iface, REFIID riid, void **ppv)
 363 {
 364     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 365
 366     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 367
 368     if(IsEqualGUID(&IID_IUnknown, riid)) {
 369         *ppv = &This->IHTMLScreen_iface;
 370     }else if(IsEqualGUID(&IID_IHTMLScreen, riid)) {
 371         *ppv = &This->IHTMLScreen_iface;
 372     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 373         return *ppv ? S_OK : E_NOINTERFACE;
 374     }else {
 375         *ppv = NULL;
 376         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 377         return E_NOINTERFACE;
 378     }
 379
 380     IUnknown_AddRef((IUnknown*)*ppv);
 381     return S_OK;
 382 }
 383
 384 static ULONG WINAPI HTMLScreen_AddRef(IHTMLScreen *iface)
 385 {
 386     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 387     LONG ref = InterlockedIncrement(&This->ref);
 388
 389     TRACE("(%p) ref=%ld\n", This, ref);
 390
 391     return ref;
 392 }
 393
 394 static ULONG WINAPI HTMLScreen_Release(IHTMLScreen *iface)
 395 {
 396     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 397     LONG ref = InterlockedDecrement(&This->ref);
 398
 399     TRACE("(%p) ref=%ld\n", This, ref);
 400
 401     if(!ref) {
 402         release_dispex(&This->dispex);
 403         heap_free(This);
 404     }
 405
 406     return ref;
 407 }
 408
 409 static HRESULT WINAPI HTMLScreen_GetTypeInfoCount(IHTMLScreen *iface, UINT *pctinfo)
 410 {
 411     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 412     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 413 }
 414
 415 static HRESULT WINAPI HTMLScreen_GetTypeInfo(IHTMLScreen *iface, UINT iTInfo,
 416         LCID lcid, ITypeInfo **ppTInfo)
 417 {
 418     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 419     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 420 }
 421
 422 static HRESULT WINAPI HTMLScreen_GetIDsOfNames(IHTMLScreen *iface, REFIID riid,
 423         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 424 {
 425     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 426     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 427             lcid, rgDispId);
 428 }
 429
 430 static HRESULT WINAPI HTMLScreen_Invoke(IHTMLScreen *iface, DISPID dispIdMember,
 431         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 432         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 433 {
 434     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 435     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 436             pDispParams, pVarResult, pExcepInfo, puArgErr);
 437 }
 438
 439 static HRESULT WINAPI HTMLScreen_get_colorDepth(IHTMLScreen *iface, LONG *p)
 440 {
 441     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 442     HDC hdc = GetDC(0);
 443
 444     TRACE("(%p)->(%p)\n", This, p);
 445
 446     *p = GetDeviceCaps(hdc, BITSPIXEL);
 447     ReleaseDC(0, hdc);
 448     return S_OK;
 449 }
 450
 451 static HRESULT WINAPI HTMLScreen_put_bufferDepth(IHTMLScreen *iface, LONG v)
 452 {
 453     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 454     FIXME("(%p)->(%ld)\n", This, v);
 455     return E_NOTIMPL;
 456 }
 457
 458 static HRESULT WINAPI HTMLScreen_get_bufferDepth(IHTMLScreen *iface, LONG *p)
 459 {
 460     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 461     FIXME("(%p)->(%p)\n", This, p);
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI HTMLScreen_get_width(IHTMLScreen *iface, LONG *p)
 466 {
 467     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 468
 469     TRACE("(%p)->(%p)\n", This, p);
 470
 471     *p = GetSystemMetrics(SM_CXSCREEN);
 472     return S_OK;
 473 }
 474
 475 static HRESULT WINAPI HTMLScreen_get_height(IHTMLScreen *iface, LONG *p)
 476 {
 477     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 478
 479     TRACE("(%p)->(%p)\n", This, p);
 480
 481     *p = GetSystemMetrics(SM_CYSCREEN);
 482     return S_OK;
 483 }
 484
 485 static HRESULT WINAPI HTMLScreen_put_updateInterval(IHTMLScreen *iface, LONG v)
 486 {
 487     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 488     FIXME("(%p)->(%ld)\n", This, v);
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI HTMLScreen_get_updateInterval(IHTMLScreen *iface, LONG *p)
 493 {
 494     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 495     FIXME("(%p)->(%p)\n", This, p);
 496     return E_NOTIMPL;
 497 }
 498
 499 static HRESULT WINAPI HTMLScreen_get_availHeight(IHTMLScreen *iface, LONG *p)
 500 {
 501     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 502     RECT work_area;
 503
 504     TRACE("(%p)->(%p)\n", This, p);
 505
 506     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 507         return E_FAIL;
 508
 509     *p = work_area.bottom-work_area.top;
 510     return S_OK;
 511 }
 512
 513 static HRESULT WINAPI HTMLScreen_get_availWidth(IHTMLScreen *iface, LONG *p)
 514 {
 515     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 516     RECT work_area;
 517
 518     TRACE("(%p)->(%p)\n", This, p);
 519
 520     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 521         return E_FAIL;
 522
 523     *p = work_area.right-work_area.left;
 524     return S_OK;
 525 }
 526
 527 static HRESULT WINAPI HTMLScreen_get_fontSmoothingEnabled(IHTMLScreen *iface, VARIANT_BOOL *p)
 528 {
 529     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 530     FIXME("(%p)->(%p)\n", This, p);
 531     return E_NOTIMPL;
 532 }
 533
 534 static const IHTMLScreenVtbl HTMLSreenVtbl = {
 535     HTMLScreen_QueryInterface,
 536     HTMLScreen_AddRef,
 537     HTMLScreen_Release,
 538     HTMLScreen_GetTypeInfoCount,
 539     HTMLScreen_GetTypeInfo,
 540     HTMLScreen_GetIDsOfNames,
 541     HTMLScreen_Invoke,
 542     HTMLScreen_get_colorDepth,
 543     HTMLScreen_put_bufferDepth,
 544     HTMLScreen_get_bufferDepth,
 545     HTMLScreen_get_width,
 546     HTMLScreen_get_height,
 547     HTMLScreen_put_updateInterval,
 548     HTMLScreen_get_updateInterval,
 549     HTMLScreen_get_availHeight,
 550     HTMLScreen_get_availWidth,
 551     HTMLScreen_get_fontSmoothingEnabled
 552 };
 553
 554 static const tid_t HTMLScreen_iface_tids[] = {
 555     IHTMLScreen_tid,
 556     0
 557 };
 558 static dispex_static_data_t HTMLScreen_dispex = {
 559     L"Screen",
 560     NULL,
 561     DispHTMLScreen_tid,
 562     HTMLScreen_iface_tids
 563 };
 564
 565 HRESULT create_html_screen(compat_mode_t compat_mode, IHTMLScreen **ret)
 566 {
 567     HTMLScreen *screen;
 568
 569     screen = heap_alloc_zero(sizeof(HTMLScreen));
 570     if(!screen)
 571         return E_OUTOFMEMORY;
 572
 573     screen->IHTMLScreen_iface.lpVtbl = &HTMLSreenVtbl;
 574     screen->ref = 1;
 575
 576     init_dispatch(&screen->dispex, (IUnknown*)&screen->IHTMLScreen_iface, &HTMLScreen_dispex, compat_mode);
 577
 578     *ret = &screen->IHTMLScreen_iface;
 579     return S_OK;
 580 }
 581
 582 static inline OmHistory *impl_from_IOmHistory(IOmHistory *iface)
 583 {
 584     return CONTAINING_RECORD(iface, OmHistory, IOmHistory_iface);
 585 }
 586
 587 static HRESULT WINAPI OmHistory_QueryInterface(IOmHistory *iface, REFIID riid, void **ppv)
 588 {
 589     OmHistory *This = impl_from_IOmHistory(iface);
 590
 591     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 592
 593     if(IsEqualGUID(&IID_IUnknown, riid)) {
 594         *ppv = &This->IOmHistory_iface;
 595     }else if(IsEqualGUID(&IID_IOmHistory, riid)) {
 596         *ppv = &This->IOmHistory_iface;
 597     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 598         return *ppv ? S_OK : E_NOINTERFACE;
 599     }else {
 600         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 601         *ppv = NULL;
 602         return E_NOINTERFACE;
 603     }
 604
 605     IUnknown_AddRef((IUnknown*)*ppv);
 606     return S_OK;
 607 }
 608
 609 static ULONG WINAPI OmHistory_AddRef(IOmHistory *iface)
 610 {
 611     OmHistory *This = impl_from_IOmHistory(iface);
 612     LONG ref = InterlockedIncrement(&This->ref);
 613
 614     TRACE("(%p) ref=%ld\n", This, ref);
 615
 616     return ref;
 617 }
 618
 619 static ULONG WINAPI OmHistory_Release(IOmHistory *iface)
 620 {
 621     OmHistory *This = impl_from_IOmHistory(iface);
 622     LONG ref = InterlockedDecrement(&This->ref);
 623
 624     TRACE("(%p) ref=%ld\n", This, ref);
 625
 626     if(!ref) {
 627         release_dispex(&This->dispex);
 628         heap_free(This);
 629     }
 630
 631     return ref;
 632 }
 633
 634 static HRESULT WINAPI OmHistory_GetTypeInfoCount(IOmHistory *iface, UINT *pctinfo)
 635 {
 636     OmHistory *This = impl_from_IOmHistory(iface);
 637     FIXME("(%p)->(%p)\n", This, pctinfo);
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI OmHistory_GetTypeInfo(IOmHistory *iface, UINT iTInfo,
 642         LCID lcid, ITypeInfo **ppTInfo)
 643 {
 644     OmHistory *This = impl_from_IOmHistory(iface);
 645
 646     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 647 }
 648
 649 static HRESULT WINAPI OmHistory_GetIDsOfNames(IOmHistory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 650         LCID lcid, DISPID *rgDispId)
 651 {
 652     OmHistory *This = impl_from_IOmHistory(iface);
 653
 654     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 655             lcid, rgDispId);
 656 }
 657
 658 static HRESULT WINAPI OmHistory_Invoke(IOmHistory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 659         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 660 {
 661     OmHistory *This = impl_from_IOmHistory(iface);
 662
 663     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 664             pDispParams, pVarResult, pExcepInfo, puArgErr);
 665 }
 666
 667 static HRESULT WINAPI OmHistory_get_length(IOmHistory *iface, short *p)
 668 {
 669     OmHistory *This = impl_from_IOmHistory(iface);
 670     GeckoBrowser *browser = NULL;
 671
 672     TRACE("(%p)->(%p)\n", This, p);
 673
 674     if(This->window && This->window->base.outer_window)
 675         browser = This->window->base.outer_window->browser;
 676
 677     *p = browser && browser->doc->travel_log
 678         ? ITravelLog_CountEntries(browser->doc->travel_log, browser->doc->browser_service)
 679         : 0;
 680     return S_OK;
 681 }
 682
 683 static HRESULT WINAPI OmHistory_back(IOmHistory *iface, VARIANT *pvargdistance)
 684 {
 685     OmHistory *This = impl_from_IOmHistory(iface);
 686     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 687     return E_NOTIMPL;
 688 }
 689
 690 static HRESULT WINAPI OmHistory_forward(IOmHistory *iface, VARIANT *pvargdistance)
 691 {
 692     OmHistory *This = impl_from_IOmHistory(iface);
 693     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI OmHistory_go(IOmHistory *iface, VARIANT *pvargdistance)
 698 {
 699     OmHistory *This = impl_from_IOmHistory(iface);
 700     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 701     return E_NOTIMPL;
 702 }
 703
 704 static const IOmHistoryVtbl OmHistoryVtbl = {
 705     OmHistory_QueryInterface,
 706     OmHistory_AddRef,
 707     OmHistory_Release,
 708     OmHistory_GetTypeInfoCount,
 709     OmHistory_GetTypeInfo,
 710     OmHistory_GetIDsOfNames,
 711     OmHistory_Invoke,
 712     OmHistory_get_length,
 713     OmHistory_back,
 714     OmHistory_forward,
 715     OmHistory_go
 716 };
 717
 718 static const tid_t OmHistory_iface_tids[] = {
 719     IOmHistory_tid,
 720     0
 721 };
 722 static dispex_static_data_t OmHistory_dispex = {
 723     L"History",
 724     NULL,
 725     DispHTMLHistory_tid,
 726     OmHistory_iface_tids
 727 };
 728
 729
 730 HRESULT create_history(HTMLInnerWindow *window, OmHistory **ret)
 731 {
 732     OmHistory *history;
 733
 734     history = heap_alloc_zero(sizeof(*history));
 735     if(!history)
 736         return E_OUTOFMEMORY;
 737
 738     init_dispatch(&history->dispex, (IUnknown*)&history->IOmHistory_iface, &OmHistory_dispex,
 739                   dispex_compat_mode(&window->event_target.dispex));
 740     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 741     history->ref = 1;
 742
 743     history->window = window;
 744
 745     *ret = history;
 746     return S_OK;
 747 }
 748
 749 struct HTMLPluginsCollection {
 750     DispatchEx dispex;
 751     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 752
 753     LONG ref;
 754
 755     OmNavigator *navigator;
 756 };
 757
 758 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 759 {
 760     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 761 }
 762
 763 static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollection *iface, REFIID riid, void **ppv)
 764 {
 765     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 766
 767     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 768
 769     if(IsEqualGUID(&IID_IUnknown, riid)) {
 770         *ppv = &This->IHTMLPluginsCollection_iface;
 771     }else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
 772         *ppv = &This->IHTMLPluginsCollection_iface;
 773     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 774         return *ppv ? S_OK : E_NOINTERFACE;
 775     }else {
 776         *ppv = NULL;
 777         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 778         return E_NOINTERFACE;
 779     }
 780
 781     IUnknown_AddRef((IUnknown*)*ppv);
 782     return S_OK;
 783 }
 784
 785 static ULONG WINAPI HTMLPluginsCollection_AddRef(IHTMLPluginsCollection *iface)
 786 {
 787     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 788     LONG ref = InterlockedIncrement(&This->ref);
 789
 790     TRACE("(%p) ref=%ld\n", This, ref);
 791
 792     return ref;
 793 }
 794
 795 static ULONG WINAPI HTMLPluginsCollection_Release(IHTMLPluginsCollection *iface)
 796 {
 797     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 798     LONG ref = InterlockedDecrement(&This->ref);
 799
 800     TRACE("(%p) ref=%ld\n", This, ref);
 801
 802     if(!ref) {
 803         if(This->navigator)
 804             This->navigator->plugins = NULL;
 805         release_dispex(&This->dispex);
 806         heap_free(This);
 807     }
 808
 809     return ref;
 810 }
 811
 812 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfoCount(IHTMLPluginsCollection *iface, UINT *pctinfo)
 813 {
 814     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 815     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 816 }
 817
 818 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfo(IHTMLPluginsCollection *iface, UINT iTInfo,
 819                                               LCID lcid, ITypeInfo **ppTInfo)
 820 {
 821     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 822     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 823 }
 824
 825 static HRESULT WINAPI HTMLPluginsCollection_GetIDsOfNames(IHTMLPluginsCollection *iface, REFIID riid,
 826         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 827 {
 828     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 829     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 830             lcid, rgDispId);
 831 }
 832
 833 static HRESULT WINAPI HTMLPluginsCollection_Invoke(IHTMLPluginsCollection *iface, DISPID dispIdMember,
 834         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 835         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 836 {
 837     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 838     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 839             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 840 }
 841
 842 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 843 {
 844     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 845
 846     TRACE("(%p)->(%p)\n", This, p);
 847
 848     /* IE always returns 0 here */
 849     *p = 0;
 850     return S_OK;
 851 }
 852
 853 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 854 {
 855     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 856
 857     TRACE("(%p)->(%x)\n", This, reload);
 858
 859     /* Nothing to do here. */
 860     return S_OK;
 861 }
 862
 863 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 864     HTMLPluginsCollection_QueryInterface,
 865     HTMLPluginsCollection_AddRef,
 866     HTMLPluginsCollection_Release,
 867     HTMLPluginsCollection_GetTypeInfoCount,
 868     HTMLPluginsCollection_GetTypeInfo,
 869     HTMLPluginsCollection_GetIDsOfNames,
 870     HTMLPluginsCollection_Invoke,
 871     HTMLPluginsCollection_get_length,
 872     HTMLPluginsCollection_refresh
 873 };
 874
 875 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 876     IHTMLPluginsCollection_tid,
 877     0
 878 };
 879 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 880     L"PluginArray",
 881     NULL,
 882     DispCPlugins_tid,
 883     HTMLPluginsCollection_iface_tids
 884 };
 885
 886 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 887 {
 888     HTMLPluginsCollection *col;
 889
 890     col = heap_alloc_zero(sizeof(*col));
 891     if(!col)
 892         return E_OUTOFMEMORY;
 893
 894     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 895     col->ref = 1;
 896     col->navigator = navigator;
 897
 898     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLPluginsCollection_iface,
 899                   &HTMLPluginsCollection_dispex, dispex_compat_mode(&navigator->dispex));
 900
 901     *ret = col;
 902     return S_OK;
 903 }
 904
 905 struct HTMLMimeTypesCollection {
 906     DispatchEx dispex;
 907     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 908
 909     LONG ref;
 910
 911     OmNavigator *navigator;
 912 };
 913
 914 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 915 {
 916     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 917 }
 918
 919 static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesCollection *iface, REFIID riid, void **ppv)
 920 {
 921     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 922
 923     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 924
 925     if(IsEqualGUID(&IID_IUnknown, riid)) {
 926         *ppv = &This->IHTMLMimeTypesCollection_iface;
 927     }else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
 928         *ppv = &This->IHTMLMimeTypesCollection_iface;
 929     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 930         return *ppv ? S_OK : E_NOINTERFACE;
 931     }else {
 932         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 933         *ppv = NULL;
 934         return E_NOINTERFACE;
 935     }
 936
 937     IUnknown_AddRef((IUnknown*)*ppv);
 938     return S_OK;
 939 }
 940
 941 static ULONG WINAPI HTMLMimeTypesCollection_AddRef(IHTMLMimeTypesCollection *iface)
 942 {
 943     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 944     LONG ref = InterlockedIncrement(&This->ref);
 945
 946     TRACE("(%p) ref=%ld\n", This, ref);
 947
 948     return ref;
 949 }
 950
 951 static ULONG WINAPI HTMLMimeTypesCollection_Release(IHTMLMimeTypesCollection *iface)
 952 {
 953     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 954     LONG ref = InterlockedDecrement(&This->ref);
 955
 956     TRACE("(%p) ref=%ld\n", This, ref);
 957
 958     if(!ref) {
 959         if(This->navigator)
 960             This->navigator->mime_types = NULL;
 961         release_dispex(&This->dispex);
 962         heap_free(This);
 963     }
 964
 965     return ref;
 966 }
 967
 968 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfoCount(IHTMLMimeTypesCollection *iface, UINT *pctinfo)
 969 {
 970     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 971     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 972 }
 973
 974 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfo(IHTMLMimeTypesCollection *iface, UINT iTInfo,
 975                                               LCID lcid, ITypeInfo **ppTInfo)
 976 {
 977     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 978     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 979 }
 980
 981 static HRESULT WINAPI HTMLMimeTypesCollection_GetIDsOfNames(IHTMLMimeTypesCollection *iface, REFIID riid,
 982         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 983 {
 984     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 985     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 986             lcid, rgDispId);
 987 }
 988
 989 static HRESULT WINAPI HTMLMimeTypesCollection_Invoke(IHTMLMimeTypesCollection *iface, DISPID dispIdMember,
 990         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 991         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 992 {
 993     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 994     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 995             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 996 }
 997
 998 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
 999 {
1000     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1001
1002     TRACE("(%p)->(%p)\n", This, p);
1003
1004     /* This is just a stub for compatibility with other browser in IE */
1005     *p = 0;
1006     return S_OK;
1007 }
1008
1009 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
1010     HTMLMimeTypesCollection_QueryInterface,
1011     HTMLMimeTypesCollection_AddRef,
1012     HTMLMimeTypesCollection_Release,
1013     HTMLMimeTypesCollection_GetTypeInfoCount,
1014     HTMLMimeTypesCollection_GetTypeInfo,
1015     HTMLMimeTypesCollection_GetIDsOfNames,
1016     HTMLMimeTypesCollection_Invoke,
1017     HTMLMimeTypesCollection_get_length
1018 };
1019
1020 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
1021     IHTMLMimeTypesCollection_tid,
1022     0
1023 };
1024 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
1025     L"MimeTypeArray",
1026     NULL,
1027     IHTMLMimeTypesCollection_tid,
1028     HTMLMimeTypesCollection_iface_tids
1029 };
1030
1031 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
1032 {
1033     HTMLMimeTypesCollection *col;
1034
1035     col = heap_alloc_zero(sizeof(*col));
1036     if(!col)
1037         return E_OUTOFMEMORY;
1038
1039     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
1040     col->ref = 1;
1041     col->navigator = navigator;
1042
1043     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLMimeTypesCollection_iface,
1044                   &HTMLMimeTypesCollection_dispex, dispex_compat_mode(&navigator->dispex));
1045
1046     *ret = col;
1047     return S_OK;
1048 }
1049
1050 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
1051 {
1052     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
1053 }
1054
1055 static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID riid, void **ppv)
1056 {
1057     OmNavigator *This = impl_from_IOmNavigator(iface);
1058
1059     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1060
1061     if(IsEqualGUID(&IID_IUnknown, riid)) {
1062         *ppv = &This->IOmNavigator_iface;
1063     }else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
1064         *ppv = &This->IOmNavigator_iface;
1065     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1066         return *ppv ? S_OK : E_NOINTERFACE;
1067     }else {
1068         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1069         *ppv = NULL;
1070         return E_NOINTERFACE;
1071     }
1072
1073     IUnknown_AddRef((IUnknown*)*ppv);
1074     return S_OK;
1075 }
1076
1077 static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)
1078 {
1079     OmNavigator *This = impl_from_IOmNavigator(iface);
1080     LONG ref = InterlockedIncrement(&This->ref);
1081
1082     TRACE("(%p) ref=%ld\n", This, ref);
1083
1084     return ref;
1085 }
1086
1087 static ULONG WINAPI OmNavigator_Release(IOmNavigator *iface)
1088 {
1089     OmNavigator *This = impl_from_IOmNavigator(iface);
1090     LONG ref = InterlockedDecrement(&This->ref);
1091
1092     TRACE("(%p) ref=%ld\n", This, ref);
1093
1094     if(!ref) {
1095         if(This->plugins)
1096             This->plugins->navigator = NULL;
1097         if(This->mime_types)
1098             This->mime_types->navigator = NULL;
1099         release_dispex(&This->dispex);
1100         heap_free(This);
1101     }
1102
1103     return ref;
1104 }
1105
1106 static HRESULT WINAPI OmNavigator_GetTypeInfoCount(IOmNavigator *iface, UINT *pctinfo)
1107 {
1108     OmNavigator *This = impl_from_IOmNavigator(iface);
1109     FIXME("(%p)->(%p)\n", This, pctinfo);
1110     return E_NOTIMPL;
1111 }
1112
1113 static HRESULT WINAPI OmNavigator_GetTypeInfo(IOmNavigator *iface, UINT iTInfo,
1114                                               LCID lcid, ITypeInfo **ppTInfo)
1115 {
1116     OmNavigator *This = impl_from_IOmNavigator(iface);
1117
1118     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1119 }
1120
1121 static HRESULT WINAPI OmNavigator_GetIDsOfNames(IOmNavigator *iface, REFIID riid,
1122                                                 LPOLESTR *rgszNames, UINT cNames,
1123                                                 LCID lcid, DISPID *rgDispId)
1124 {
1125     OmNavigator *This = impl_from_IOmNavigator(iface);
1126
1127     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1128             lcid, rgDispId);
1129 }
1130
1131 static HRESULT WINAPI OmNavigator_Invoke(IOmNavigator *iface, DISPID dispIdMember,
1132                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1133                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1134 {
1135     OmNavigator *This = impl_from_IOmNavigator(iface);
1136
1137     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1138             pDispParams, pVarResult, pExcepInfo, puArgErr);
1139 }
1140
1141 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
1142 {
1143     OmNavigator *This = impl_from_IOmNavigator(iface);
1144
1145     TRACE("(%p)->(%p)\n", This, p);
1146
1147     *p = SysAllocString(L"Mozilla");
1148     return S_OK;
1149 }
1150
1151 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
1152 {
1153     OmNavigator *This = impl_from_IOmNavigator(iface);
1154
1155     TRACE("(%p)->(%p)\n", This, p);
1156
1157     *p = SysAllocString(dispex_compat_mode(&This->dispex) == COMPAT_MODE_IE11
1158                         ? L"Netscape" : L"Microsoft Internet Explorer");
1159     if(!*p)
1160         return E_OUTOFMEMORY;
1161
1162     return S_OK;
1163 }
1164
1165 /* undocumented, added in IE8 */
1166 extern HRESULT WINAPI MapBrowserEmulationModeToUserAgent(const void*,WCHAR**);
1167
1168 /* Retrieves allocated user agent via CoTaskMemAlloc */
1169 static HRESULT get_user_agent(OmNavigator *navigator, WCHAR **user_agent)
1170 {
1171     DWORD version;
1172
1173     switch(dispex_compat_mode(&navigator->dispex)) {
1174     case COMPAT_MODE_QUIRKS:
1175     case COMPAT_MODE_IE5:
1176     case COMPAT_MODE_IE7:
1177         version = 7;
1178         break;
1179     case COMPAT_MODE_IE8:
1180         version = 8;
1181         break;
1182     case COMPAT_MODE_IE9:
1183         version = 9;
1184         break;
1185     case COMPAT_MODE_IE10:
1186         version = 10;
1187         break;
1188     case COMPAT_MODE_IE11:
1189         version = 11;
1190         break;
1191     default:
1192         assert(0);
1193         return E_FAIL;
1194     }
1195     return MapBrowserEmulationModeToUserAgent(&version, user_agent);
1196 }
1197
1198 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
1199 {
1200     OmNavigator *This = impl_from_IOmNavigator(iface);
1201     WCHAR *user_agent;
1202     unsigned len;
1203     HRESULT hres;
1204     const unsigned skip_prefix = 8; /* strlen("Mozilla/") */
1205
1206     TRACE("(%p)->(%p)\n", This, p);
1207
1208     hres = get_user_agent(This, &user_agent);
1209     if(FAILED(hres))
1210         return hres;
1211     len = wcslen(user_agent);
1212
1213     if(len < skip_prefix) {
1214         CoTaskMemFree(user_agent);
1215         *p = NULL;
1216         return S_OK;
1217     }
1218
1219     *p = SysAllocStringLen(user_agent + skip_prefix, len - skip_prefix);
1220     CoTaskMemFree(user_agent);
1221     return *p ? S_OK : E_OUTOFMEMORY;
1222 }
1223
1224 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
1225 {
1226     OmNavigator *This = impl_from_IOmNavigator(iface);
1227     WCHAR *user_agent;
1228     HRESULT hres;
1229
1230     TRACE("(%p)->(%p)\n", This, p);
1231
1232     hres = get_user_agent(This, &user_agent);
1233     if(FAILED(hres))
1234         return hres;
1235
1236     *p = SysAllocString(user_agent);
1237     CoTaskMemFree(user_agent);
1238     return *p ? S_OK : E_OUTOFMEMORY;
1239 }
1240
1241 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1242 {
1243     OmNavigator *This = impl_from_IOmNavigator(iface);
1244
1245     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
1246
1247     *enabled = VARIANT_TRUE;
1248     return S_OK;
1249 }
1250
1251 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1252 {
1253     OmNavigator *This = impl_from_IOmNavigator(iface);
1254     FIXME("(%p)->(%p)\n", This, enabled);
1255     return E_NOTIMPL;
1256 }
1257
1258 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
1259 {
1260     OmNavigator *This = impl_from_IOmNavigator(iface);
1261
1262     TRACE("(%p)->(%p)\n", This, p);
1263
1264     if(!This->mime_types) {
1265         HRESULT hres;
1266
1267         hres = create_mime_types_collection(This, &This->mime_types);
1268         if(FAILED(hres))
1269             return hres;
1270     }else {
1271         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
1272     }
1273
1274     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
1275     return S_OK;
1276 }
1277
1278 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
1279 {
1280     OmNavigator *This = impl_from_IOmNavigator(iface);
1281
1282     TRACE("(%p)->(%p)\n", This, p);
1283
1284     if(!This->plugins) {
1285         HRESULT hres;
1286
1287         hres = create_plugins_collection(This, &This->plugins);
1288         if(FAILED(hres))
1289             return hres;
1290     }else {
1291         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
1292     }
1293
1294     *p = &This->plugins->IHTMLPluginsCollection_iface;
1295     return S_OK;
1296 }
1297
1298 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
1299 {
1300     OmNavigator *This = impl_from_IOmNavigator(iface);
1301
1302     WARN("(%p)->(%p) semi-stub\n", This, p);
1303
1304     *p = VARIANT_TRUE;
1305     return S_OK;
1306 }
1307
1308 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1309 {
1310     OmNavigator *This = impl_from_IOmNavigator(iface);
1311     FIXME("(%p)->(%p)\n", This, p);
1312     return E_NOTIMPL;
1313 }
1314
1315 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
1316 {
1317     OmNavigator *This = impl_from_IOmNavigator(iface);
1318
1319     TRACE("(%p)->(%p)\n", This, String);
1320
1321     return dispex_to_string(&This->dispex, String);
1322 }
1323
1324 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
1325 {
1326     OmNavigator *This = impl_from_IOmNavigator(iface);
1327
1328     TRACE("(%p)->(%p)\n", This, p);
1329
1330 #ifdef _WIN64
1331     *p = SysAllocString(L"x64");
1332 #else
1333     *p = SysAllocString(L"x86");
1334 #endif
1335     return *p ? S_OK : E_OUTOFMEMORY;
1336 }
1337
1338 static HRESULT get_language_string(LCID lcid, BSTR *p)
1339 {
1340     BSTR ret;
1341     int len;
1342
1343     len = LCIDToLocaleName(lcid, NULL, 0, 0);
1344     if(!len) {
1345         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1346         return E_FAIL;
1347     }
1348
1349     ret = SysAllocStringLen(NULL, len-1);
1350     if(!ret)
1351         return E_OUTOFMEMORY;
1352
1353     len = LCIDToLocaleName(lcid, ret, len, 0);
1354     if(!len) {
1355         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1356         SysFreeString(ret);
1357         return E_FAIL;
1358     }
1359
1360     *p = ret;
1361     return S_OK;
1362 }
1363
1364 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1365 {
1366     OmNavigator *This = impl_from_IOmNavigator(iface);
1367
1368     TRACE("(%p)->(%p)\n", This, p);
1369
1370     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1371 }
1372
1373 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1374 {
1375     OmNavigator *This = impl_from_IOmNavigator(iface);
1376
1377     TRACE("(%p)->(%p)\n", This, p);
1378
1379     return get_language_string(GetUserDefaultUILanguage(), p);
1380 }
1381
1382 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1383 {
1384     OmNavigator *This = impl_from_IOmNavigator(iface);
1385
1386     TRACE("(%p)->(%p)\n", This, p);
1387
1388     return get_language_string(LOCALE_USER_DEFAULT, p);
1389 }
1390
1391 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1392 {
1393     OmNavigator *This = impl_from_IOmNavigator(iface);
1394
1395     TRACE("(%p)->(%p)\n", This, p);
1396
1397 #ifdef _WIN64
1398     *p = SysAllocString(L"Win64");
1399 #else
1400     *p = SysAllocString(L"Win32");
1401 #endif
1402     return S_OK;
1403 }
1404
1405 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1406 {
1407     OmNavigator *This = impl_from_IOmNavigator(iface);
1408
1409     TRACE("(%p)->(%p)\n", This, p);
1410
1411     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1412     *p = SysAllocString(L"0");
1413     return S_OK;
1414 }
1415
1416 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1417 {
1418     OmNavigator *This = impl_from_IOmNavigator(iface);
1419     FIXME("(%p)->(%p)\n", This, p);
1420     return E_NOTIMPL;
1421 }
1422
1423 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1424 {
1425     OmNavigator *This = impl_from_IOmNavigator(iface);
1426
1427     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1428
1429     *p = VARIANT_TRUE;
1430     return S_OK;
1431 }
1432
1433 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1434 {
1435     OmNavigator *This = impl_from_IOmNavigator(iface);
1436     FIXME("(%p)->(%p)\n", This, p);
1437     return E_NOTIMPL;
1438 }
1439
1440 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1441     OmNavigator_QueryInterface,
1442     OmNavigator_AddRef,
1443     OmNavigator_Release,
1444     OmNavigator_GetTypeInfoCount,
1445     OmNavigator_GetTypeInfo,
1446     OmNavigator_GetIDsOfNames,
1447     OmNavigator_Invoke,
1448     OmNavigator_get_appCodeName,
1449     OmNavigator_get_appName,
1450     OmNavigator_get_appVersion,
1451     OmNavigator_get_userAgent,
1452     OmNavigator_javaEnabled,
1453     OmNavigator_taintEnabled,
1454     OmNavigator_get_mimeTypes,
1455     OmNavigator_get_plugins,
1456     OmNavigator_get_cookieEnabled,
1457     OmNavigator_get_opsProfile,
1458     OmNavigator_toString,
1459     OmNavigator_get_cpuClass,
1460     OmNavigator_get_systemLanguage,
1461     OmNavigator_get_browserLanguage,
1462     OmNavigator_get_userLanguage,
1463     OmNavigator_get_platform,
1464     OmNavigator_get_appMinorVersion,
1465     OmNavigator_get_connectionSpeed,
1466     OmNavigator_get_onLine,
1467     OmNavigator_get_userProfile
1468 };
1469
1470 static const tid_t OmNavigator_iface_tids[] = {
1471     IOmNavigator_tid,
1472     0
1473 };
1474 static dispex_static_data_t OmNavigator_dispex = {
1475     L"Navigator",
1476     NULL,
1477     DispHTMLNavigator_tid,
1478     OmNavigator_iface_tids
1479 };
1480
1481 HRESULT create_navigator(compat_mode_t compat_mode, IOmNavigator **navigator)
1482 {
1483     OmNavigator *ret;
1484
1485     ret = heap_alloc_zero(sizeof(*ret));
1486     if(!ret)
1487         return E_OUTOFMEMORY;
1488
1489     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1490     ret->ref = 1;
1491
1492     init_dispatch(&ret->dispex, (IUnknown*)&ret->IOmNavigator_iface, &OmNavigator_dispex, compat_mode);
1493
1494     *navigator = &ret->IOmNavigator_iface;
1495     return S_OK;
1496 }
1497
1498 typedef struct {
1499     DispatchEx dispex;
1500     IHTMLPerformanceTiming IHTMLPerformanceTiming_iface;
1501
1502     LONG ref;
1503 } HTMLPerformanceTiming;
1504
1505 static inline HTMLPerformanceTiming *impl_from_IHTMLPerformanceTiming(IHTMLPerformanceTiming *iface)
1506 {
1507     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, IHTMLPerformanceTiming_iface);
1508 }
1509
1510 static HRESULT WINAPI HTMLPerformanceTiming_QueryInterface(IHTMLPerformanceTiming *iface, REFIID riid, void **ppv)
1511 {
1512     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1513
1514     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1515
1516     if(IsEqualGUID(&IID_IUnknown, riid)) {
1517         *ppv = &This->IHTMLPerformanceTiming_iface;
1518     }else if(IsEqualGUID(&IID_IHTMLPerformanceTiming, riid)) {
1519         *ppv = &This->IHTMLPerformanceTiming_iface;
1520     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1521         return *ppv ? S_OK : E_NOINTERFACE;
1522     }else {
1523         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1524         *ppv = NULL;
1525         return E_NOINTERFACE;
1526     }
1527
1528     IUnknown_AddRef((IUnknown*)*ppv);
1529     return S_OK;
1530 }
1531
1532 static ULONG WINAPI HTMLPerformanceTiming_AddRef(IHTMLPerformanceTiming *iface)
1533 {
1534     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1535     LONG ref = InterlockedIncrement(&This->ref);
1536
1537     TRACE("(%p) ref=%ld\n", This, ref);
1538
1539     return ref;
1540 }
1541
1542 static ULONG WINAPI HTMLPerformanceTiming_Release(IHTMLPerformanceTiming *iface)
1543 {
1544     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1545     LONG ref = InterlockedDecrement(&This->ref);
1546
1547     TRACE("(%p) ref=%ld\n", This, ref);
1548
1549     if(!ref) {
1550         release_dispex(&This->dispex);
1551         heap_free(This);
1552     }
1553
1554     return ref;
1555 }
1556
1557 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfoCount(IHTMLPerformanceTiming *iface, UINT *pctinfo)
1558 {
1559     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1560     FIXME("(%p)->(%p)\n", This, pctinfo);
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfo(IHTMLPerformanceTiming *iface, UINT iTInfo,
1565                                               LCID lcid, ITypeInfo **ppTInfo)
1566 {
1567     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1568
1569     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1570 }
1571
1572 static HRESULT WINAPI HTMLPerformanceTiming_GetIDsOfNames(IHTMLPerformanceTiming *iface, REFIID riid,
1573                                                           LPOLESTR *rgszNames, UINT cNames,
1574                                                           LCID lcid, DISPID *rgDispId)
1575 {
1576     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1577
1578     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1579             lcid, rgDispId);
1580 }
1581
1582 static HRESULT WINAPI HTMLPerformanceTiming_Invoke(IHTMLPerformanceTiming *iface, DISPID dispIdMember,
1583                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1584                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1585 {
1586     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1587
1588     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1589             pDispParams, pVarResult, pExcepInfo, puArgErr);
1590 }
1591
1592 #define TIMING_FAKE_TIMESTAMP 0xdeadbeef
1593
1594 static HRESULT WINAPI HTMLPerformanceTiming_get_navigationStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1595 {
1596     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1597
1598     FIXME("(%p)->(%p) returning fake value\n", This, p);
1599
1600     *p = TIMING_FAKE_TIMESTAMP;
1601     return S_OK;
1602 }
1603
1604 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1605 {
1606     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1607
1608     FIXME("(%p)->(%p) returning fake value\n", This, p);
1609
1610     *p = TIMING_FAKE_TIMESTAMP;
1611     return S_OK;
1612 }
1613
1614 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1615 {
1616     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1617
1618     FIXME("(%p)->(%p) returning fake value\n", This, p);
1619
1620     *p = TIMING_FAKE_TIMESTAMP;
1621     return S_OK;
1622 }
1623
1624 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1625 {
1626     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1627
1628     FIXME("(%p)->(%p) returning fake value\n", This, p);
1629
1630     *p = TIMING_FAKE_TIMESTAMP;
1631     return S_OK;
1632 }
1633
1634 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1635 {
1636     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1637
1638     FIXME("(%p)->(%p) returning fake value\n", This, p);
1639
1640     *p = TIMING_FAKE_TIMESTAMP;
1641     return S_OK;
1642 }
1643
1644 static HRESULT WINAPI HTMLPerformanceTiming_get_fetchStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1645 {
1646     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1647
1648     FIXME("(%p)->(%p) returning fake value\n", This, p);
1649
1650     *p = TIMING_FAKE_TIMESTAMP;
1651     return S_OK;
1652 }
1653
1654 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1655 {
1656     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1657
1658     FIXME("(%p)->(%p) returning fake value\n", This, p);
1659
1660     *p = TIMING_FAKE_TIMESTAMP;
1661     return S_OK;
1662 }
1663
1664 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1665 {
1666     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1667
1668     FIXME("(%p)->(%p) returning fake value\n", This, p);
1669
1670     *p = TIMING_FAKE_TIMESTAMP;
1671     return S_OK;
1672 }
1673
1674 static HRESULT WINAPI HTMLPerformanceTiming_get_connectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1675 {
1676     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1677
1678     FIXME("(%p)->(%p) returning fake value\n", This, p);
1679
1680     *p = TIMING_FAKE_TIMESTAMP;
1681     return S_OK;
1682 }
1683
1684 static HRESULT WINAPI HTMLPerformanceTiming_get_connectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1685 {
1686     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1687
1688     FIXME("(%p)->(%p) returning fake value\n", This, p);
1689
1690     *p = TIMING_FAKE_TIMESTAMP;
1691     return S_OK;
1692 }
1693
1694 static HRESULT WINAPI HTMLPerformanceTiming_get_requestStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1695 {
1696     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1697
1698     FIXME("(%p)->(%p) returning fake value\n", This, p);
1699
1700     *p = TIMING_FAKE_TIMESTAMP;
1701     return S_OK;
1702 }
1703
1704 static HRESULT WINAPI HTMLPerformanceTiming_get_responseStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1705 {
1706     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1707
1708     FIXME("(%p)->(%p) returning fake value\n", This, p);
1709
1710     *p = TIMING_FAKE_TIMESTAMP;
1711     return S_OK;
1712 }
1713
1714 static HRESULT WINAPI HTMLPerformanceTiming_get_responseEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1715 {
1716     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1717
1718     FIXME("(%p)->(%p) returning fake value\n", This, p);
1719
1720     *p = TIMING_FAKE_TIMESTAMP;
1721     return S_OK;
1722 }
1723
1724 static HRESULT WINAPI HTMLPerformanceTiming_get_domLoading(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1725 {
1726     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1727
1728     FIXME("(%p)->(%p) returning fake value\n", This, p);
1729
1730     *p = TIMING_FAKE_TIMESTAMP;
1731     return S_OK;
1732 }
1733
1734 static HRESULT WINAPI HTMLPerformanceTiming_get_domInteractive(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1735 {
1736     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1737
1738     FIXME("(%p)->(%p) returning fake value\n", This, p);
1739
1740     *p = TIMING_FAKE_TIMESTAMP;
1741     return S_OK;
1742 }
1743
1744 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1745 {
1746     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1747
1748     FIXME("(%p)->(%p) returning fake value\n", This, p);
1749
1750     *p = TIMING_FAKE_TIMESTAMP;
1751     return S_OK;
1752 }
1753
1754 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1755 {
1756     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1757
1758     FIXME("(%p)->(%p) returning fake value\n", This, p);
1759
1760     *p = TIMING_FAKE_TIMESTAMP;
1761     return S_OK;
1762 }
1763
1764 static HRESULT WINAPI HTMLPerformanceTiming_get_domComplete(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1765 {
1766     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1767
1768     FIXME("(%p)->(%p) returning fake value\n", This, p);
1769
1770     *p = TIMING_FAKE_TIMESTAMP;
1771     return S_OK;
1772 }
1773
1774 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1775 {
1776     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1777
1778     FIXME("(%p)->(%p) returning fake value\n", This, p);
1779
1780     *p = TIMING_FAKE_TIMESTAMP;
1781     return S_OK;
1782 }
1783
1784 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1785 {
1786     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1787
1788     FIXME("(%p)->(%p) returning fake value\n", This, p);
1789
1790     *p = TIMING_FAKE_TIMESTAMP;
1791     return S_OK;
1792 }
1793
1794 static HRESULT WINAPI HTMLPerformanceTiming_get_msFirstPaint(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1795 {
1796     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1797
1798     FIXME("(%p)->(%p) returning fake value\n", This, p);
1799
1800     *p = TIMING_FAKE_TIMESTAMP;
1801     return S_OK;
1802 }
1803
1804 static HRESULT WINAPI HTMLPerformanceTiming_toString(IHTMLPerformanceTiming *iface, BSTR *string)
1805 {
1806     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1807
1808     TRACE("(%p)->(%p)\n", This, string);
1809
1810     return dispex_to_string(&This->dispex, string);
1811 }
1812
1813 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1814 {
1815     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1816     FIXME("(%p)->(%p)\n", This, p);
1817     return E_NOTIMPL;
1818 }
1819
1820 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1821     HTMLPerformanceTiming_QueryInterface,
1822     HTMLPerformanceTiming_AddRef,
1823     HTMLPerformanceTiming_Release,
1824     HTMLPerformanceTiming_GetTypeInfoCount,
1825     HTMLPerformanceTiming_GetTypeInfo,
1826     HTMLPerformanceTiming_GetIDsOfNames,
1827     HTMLPerformanceTiming_Invoke,
1828     HTMLPerformanceTiming_get_navigationStart,
1829     HTMLPerformanceTiming_get_unloadEventStart,
1830     HTMLPerformanceTiming_get_unloadEventEnd,
1831     HTMLPerformanceTiming_get_redirectStart,
1832     HTMLPerformanceTiming_get_redirectEnd,
1833     HTMLPerformanceTiming_get_fetchStart,
1834     HTMLPerformanceTiming_get_domainLookupStart,
1835     HTMLPerformanceTiming_get_domainLookupEnd,
1836     HTMLPerformanceTiming_get_connectStart,
1837     HTMLPerformanceTiming_get_connectEnd,
1838     HTMLPerformanceTiming_get_requestStart,
1839     HTMLPerformanceTiming_get_responseStart,
1840     HTMLPerformanceTiming_get_responseEnd,
1841     HTMLPerformanceTiming_get_domLoading,
1842     HTMLPerformanceTiming_get_domInteractive,
1843     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1844     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1845     HTMLPerformanceTiming_get_domComplete,
1846     HTMLPerformanceTiming_get_loadEventStart,
1847     HTMLPerformanceTiming_get_loadEventEnd,
1848     HTMLPerformanceTiming_get_msFirstPaint,
1849     HTMLPerformanceTiming_toString,
1850     HTMLPerformanceTiming_toJSON
1851 };
1852
1853 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1854     IHTMLPerformanceTiming_tid,
1855     0
1856 };
1857 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1858     L"PerformanceTiming",
1859     NULL,
1860     IHTMLPerformanceTiming_tid,
1861     HTMLPerformanceTiming_iface_tids
1862 };
1863
1864 typedef struct {
1865     DispatchEx dispex;
1866     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1867
1868     LONG ref;
1869 } HTMLPerformanceNavigation;
1870
1871 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1872 {
1873     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1874 }
1875
1876 static HRESULT WINAPI HTMLPerformanceNavigation_QueryInterface(IHTMLPerformanceNavigation *iface, REFIID riid, void **ppv)
1877 {
1878     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1879
1880     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1881
1882     if(IsEqualGUID(&IID_IUnknown, riid)) {
1883         *ppv = &This->IHTMLPerformanceNavigation_iface;
1884     }else if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid)) {
1885         *ppv = &This->IHTMLPerformanceNavigation_iface;
1886     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1887         return *ppv ? S_OK : E_NOINTERFACE;
1888     }else {
1889         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1890         *ppv = NULL;
1891         return E_NOINTERFACE;
1892     }
1893
1894     IUnknown_AddRef((IUnknown*)*ppv);
1895     return S_OK;
1896 }
1897
1898 static ULONG WINAPI HTMLPerformanceNavigation_AddRef(IHTMLPerformanceNavigation *iface)
1899 {
1900     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1901     LONG ref = InterlockedIncrement(&This->ref);
1902
1903     TRACE("(%p) ref=%ld\n", This, ref);
1904
1905     return ref;
1906 }
1907
1908 static ULONG WINAPI HTMLPerformanceNavigation_Release(IHTMLPerformanceNavigation *iface)
1909 {
1910     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1911     LONG ref = InterlockedDecrement(&This->ref);
1912
1913     TRACE("(%p) ref=%ld\n", This, ref);
1914
1915     if(!ref) {
1916         release_dispex(&This->dispex);
1917         heap_free(This);
1918     }
1919
1920     return ref;
1921 }
1922
1923 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfoCount(IHTMLPerformanceNavigation *iface, UINT *pctinfo)
1924 {
1925     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1926     FIXME("(%p)->(%p)\n", This, pctinfo);
1927     return E_NOTIMPL;
1928 }
1929
1930 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfo(IHTMLPerformanceNavigation *iface, UINT iTInfo,
1931                                               LCID lcid, ITypeInfo **ppTInfo)
1932 {
1933     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1934
1935     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1936 }
1937
1938 static HRESULT WINAPI HTMLPerformanceNavigation_GetIDsOfNames(IHTMLPerformanceNavigation *iface, REFIID riid,
1939                                                           LPOLESTR *rgszNames, UINT cNames,
1940                                                           LCID lcid, DISPID *rgDispId)
1941 {
1942     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1943
1944     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1945             lcid, rgDispId);
1946 }
1947
1948 static HRESULT WINAPI HTMLPerformanceNavigation_Invoke(IHTMLPerformanceNavigation *iface, DISPID dispIdMember,
1949                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1950                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1951 {
1952     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1953
1954     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1955             pDispParams, pVarResult, pExcepInfo, puArgErr);
1956 }
1957
1958 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
1959 {
1960     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1961
1962     FIXME("(%p)->(%p) returning TYPE_NAVIGATE\n", This, p);
1963
1964     *p = 0; /* TYPE_NAVIGATE */
1965     return S_OK;
1966 }
1967
1968 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
1969 {
1970     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1971     FIXME("(%p)->(%p)\n", This, p);
1972     return E_NOTIMPL;
1973 }
1974
1975 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
1976 {
1977     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1978
1979     TRACE("(%p)->(%p)\n", This, string);
1980
1981     return dispex_to_string(&This->dispex, string);
1982 }
1983
1984 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
1985 {
1986     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1987     FIXME("(%p)->(%p)\n", This, p);
1988     return E_NOTIMPL;
1989 }
1990
1991 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
1992     HTMLPerformanceNavigation_QueryInterface,
1993     HTMLPerformanceNavigation_AddRef,
1994     HTMLPerformanceNavigation_Release,
1995     HTMLPerformanceNavigation_GetTypeInfoCount,
1996     HTMLPerformanceNavigation_GetTypeInfo,
1997     HTMLPerformanceNavigation_GetIDsOfNames,
1998     HTMLPerformanceNavigation_Invoke,
1999     HTMLPerformanceNavigation_get_type,
2000     HTMLPerformanceNavigation_get_redirectCount,
2001     HTMLPerformanceNavigation_toString,
2002     HTMLPerformanceNavigation_toJSON
2003 };
2004
2005 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
2006     IHTMLPerformanceNavigation_tid,
2007     0
2008 };
2009 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
2010     L"PerformanceNavigation",
2011     NULL,
2012     IHTMLPerformanceNavigation_tid,
2013     HTMLPerformanceNavigation_iface_tids
2014 };
2015
2016 typedef struct {
2017     DispatchEx dispex;
2018     IHTMLPerformance IHTMLPerformance_iface;
2019
2020     LONG ref;
2021
2022     IHTMLPerformanceNavigation *navigation;
2023     IHTMLPerformanceTiming *timing;
2024 } HTMLPerformance;
2025
2026 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
2027 {
2028     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
2029 }
2030
2031 static HRESULT WINAPI HTMLPerformance_QueryInterface(IHTMLPerformance *iface, REFIID riid, void **ppv)
2032 {
2033     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2034
2035     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2036
2037     if(IsEqualGUID(&IID_IUnknown, riid)) {
2038         *ppv = &This->IHTMLPerformance_iface;
2039     }else if(IsEqualGUID(&IID_IHTMLPerformance, riid)) {
2040         *ppv = &This->IHTMLPerformance_iface;
2041     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2042         return *ppv ? S_OK : E_NOINTERFACE;
2043     }else {
2044         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2045         *ppv = NULL;
2046         return E_NOINTERFACE;
2047     }
2048
2049     IUnknown_AddRef((IUnknown*)*ppv);
2050     return S_OK;
2051 }
2052
2053 static ULONG WINAPI HTMLPerformance_AddRef(IHTMLPerformance *iface)
2054 {
2055     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2056     LONG ref = InterlockedIncrement(&This->ref);
2057
2058     TRACE("(%p) ref=%ld\n", This, ref);
2059
2060     return ref;
2061 }
2062
2063 static ULONG WINAPI HTMLPerformance_Release(IHTMLPerformance *iface)
2064 {
2065     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2066     LONG ref = InterlockedDecrement(&This->ref);
2067
2068     TRACE("(%p) ref=%ld\n", This, ref);
2069
2070     if(!ref) {
2071         if(This->timing)
2072             IHTMLPerformanceTiming_Release(This->timing);
2073         if(This->navigation)
2074             IHTMLPerformanceNavigation_Release(This->navigation);
2075         release_dispex(&This->dispex);
2076         heap_free(This);
2077     }
2078
2079     return ref;
2080 }
2081
2082 static HRESULT WINAPI HTMLPerformance_GetTypeInfoCount(IHTMLPerformance *iface, UINT *pctinfo)
2083 {
2084     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2085     FIXME("(%p)->(%p)\n", This, pctinfo);
2086     return E_NOTIMPL;
2087 }
2088
2089 static HRESULT WINAPI HTMLPerformance_GetTypeInfo(IHTMLPerformance *iface, UINT iTInfo,
2090                                                   LCID lcid, ITypeInfo **ppTInfo)
2091 {
2092     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2093
2094     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2095 }
2096
2097 static HRESULT WINAPI HTMLPerformance_GetIDsOfNames(IHTMLPerformance *iface, REFIID riid,
2098                                                     LPOLESTR *rgszNames, UINT cNames,
2099                                                     LCID lcid, DISPID *rgDispId)
2100 {
2101     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2102
2103     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2104             lcid, rgDispId);
2105 }
2106
2107 static HRESULT WINAPI HTMLPerformance_Invoke(IHTMLPerformance *iface, DISPID dispIdMember,
2108                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2109                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2110 {
2111     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2112
2113     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2114             pDispParams, pVarResult, pExcepInfo, puArgErr);
2115 }
2116
2117 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
2118                                                      IHTMLPerformanceNavigation **p)
2119 {
2120     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2121
2122     TRACE("(%p)->(%p)\n", This, p);
2123
2124     if(!This->navigation) {
2125         HTMLPerformanceNavigation *navigation;
2126
2127         navigation = heap_alloc_zero(sizeof(*navigation));
2128         if(!navigation)
2129             return E_OUTOFMEMORY;
2130
2131         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
2132         navigation->ref = 1;
2133         init_dispatch(&navigation->dispex, (IUnknown*)&navigation->IHTMLPerformanceNavigation_iface,
2134                       &HTMLPerformanceNavigation_dispex, dispex_compat_mode(&This->dispex));
2135
2136         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
2137     }
2138
2139     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
2140     return S_OK;
2141 }
2142
2143 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
2144 {
2145     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2146
2147     TRACE("(%p)->(%p)\n", This, p);
2148
2149     if(!This->timing) {
2150         HTMLPerformanceTiming *timing;
2151
2152         timing = heap_alloc_zero(sizeof(*timing));
2153         if(!timing)
2154             return E_OUTOFMEMORY;
2155
2156         timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
2157         timing->ref = 1;
2158         init_dispatch(&timing->dispex, (IUnknown*)&timing->IHTMLPerformanceTiming_iface,
2159                       &HTMLPerformanceTiming_dispex, dispex_compat_mode(&This->dispex));
2160
2161         This->timing = &timing->IHTMLPerformanceTiming_iface;
2162     }
2163
2164     IHTMLPerformanceTiming_AddRef(*p = This->timing);
2165     return S_OK;
2166 }
2167
2168 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
2169 {
2170     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2171
2172     TRACE("(%p)->(%p)\n", This, string);
2173
2174     return dispex_to_string(&This->dispex, string);
2175 }
2176
2177 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
2178 {
2179     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2180     FIXME("(%p)->(%p)\n", This, var);
2181     return E_NOTIMPL;
2182 }
2183
2184 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
2185     HTMLPerformance_QueryInterface,
2186     HTMLPerformance_AddRef,
2187     HTMLPerformance_Release,
2188     HTMLPerformance_GetTypeInfoCount,
2189     HTMLPerformance_GetTypeInfo,
2190     HTMLPerformance_GetIDsOfNames,
2191     HTMLPerformance_Invoke,
2192     HTMLPerformance_get_navigation,
2193     HTMLPerformance_get_timing,
2194     HTMLPerformance_toString,
2195     HTMLPerformance_toJSON
2196 };
2197
2198 static const tid_t HTMLPerformance_iface_tids[] = {
2199     IHTMLPerformance_tid,
2200     0
2201 };
2202 static dispex_static_data_t HTMLPerformance_dispex = {
2203     L"Performance",
2204     NULL,
2205     IHTMLPerformance_tid,
2206     HTMLPerformance_iface_tids
2207 };
2208
2209 HRESULT create_performance(compat_mode_t compat_mode, IHTMLPerformance **ret)
2210 {
2211     HTMLPerformance *performance;
2212
2213     performance = heap_alloc_zero(sizeof(*performance));
2214     if(!performance)
2215         return E_OUTOFMEMORY;
2216
2217     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
2218     performance->ref = 1;
2219
2220     init_dispatch(&performance->dispex, (IUnknown*)&performance->IHTMLPerformance_iface,
2221                   &HTMLPerformance_dispex, compat_mode);
2222
2223     *ret = &performance->IHTMLPerformance_iface;
2224     return S_OK;
2225 }
2226
2227 typedef struct {
2228     DispatchEx dispex;
2229     IHTMLNamespaceCollection IHTMLNamespaceCollection_iface;
2230
2231     LONG ref;
2232 } HTMLNamespaceCollection;
2233
2234 static inline HTMLNamespaceCollection *impl_from_IHTMLNamespaceCollection(IHTMLNamespaceCollection *iface)
2235 {
2236     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, IHTMLNamespaceCollection_iface);
2237 }
2238
2239 static HRESULT WINAPI HTMLNamespaceCollection_QueryInterface(IHTMLNamespaceCollection *iface, REFIID riid, void **ppv)
2240 {
2241     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2242
2243     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2244
2245     if(IsEqualGUID(&IID_IUnknown, riid)) {
2246         *ppv = &This->IHTMLNamespaceCollection_iface;
2247     }else if(IsEqualGUID(&IID_IHTMLNamespaceCollection, riid)) {
2248         *ppv = &This->IHTMLNamespaceCollection_iface;
2249     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2250         return *ppv ? S_OK : E_NOINTERFACE;
2251     }else {
2252         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2253         *ppv = NULL;
2254         return E_NOINTERFACE;
2255     }
2256
2257     IUnknown_AddRef((IUnknown*)*ppv);
2258     return S_OK;
2259 }
2260
2261 static ULONG WINAPI HTMLNamespaceCollection_AddRef(IHTMLNamespaceCollection *iface)
2262 {
2263     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2264     LONG ref = InterlockedIncrement(&This->ref);
2265
2266     TRACE("(%p) ref=%ld\n", This, ref);
2267
2268     return ref;
2269 }
2270
2271 static ULONG WINAPI HTMLNamespaceCollection_Release(IHTMLNamespaceCollection *iface)
2272 {
2273     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2274     LONG ref = InterlockedDecrement(&This->ref);
2275
2276     TRACE("(%p) ref=%ld\n", This, ref);
2277
2278     if(!ref) {
2279         release_dispex(&This->dispex);
2280         heap_free(This);
2281     }
2282
2283     return ref;
2284 }
2285
2286 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfoCount(IHTMLNamespaceCollection *iface, UINT *pctinfo)
2287 {
2288     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2289     FIXME("(%p)->(%p)\n", This, pctinfo);
2290     return E_NOTIMPL;
2291 }
2292
2293 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfo(IHTMLNamespaceCollection *iface, UINT iTInfo,
2294                                                   LCID lcid, ITypeInfo **ppTInfo)
2295 {
2296     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2297
2298     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2299 }
2300
2301 static HRESULT WINAPI HTMLNamespaceCollection_GetIDsOfNames(IHTMLNamespaceCollection *iface, REFIID riid,
2302                                                     LPOLESTR *rgszNames, UINT cNames,
2303                                                     LCID lcid, DISPID *rgDispId)
2304 {
2305     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2306
2307     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2308             lcid, rgDispId);
2309 }
2310
2311 static HRESULT WINAPI HTMLNamespaceCollection_Invoke(IHTMLNamespaceCollection *iface, DISPID dispIdMember,
2312                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2313                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2314 {
2315     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2316
2317     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2318             pDispParams, pVarResult, pExcepInfo, puArgErr);
2319 }
2320
2321 static HRESULT WINAPI HTMLNamespaceCollection_get_length(IHTMLNamespaceCollection *iface, LONG *p)
2322 {
2323     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2324     FIXME("(%p)->(%p) returning 0\n", This, p);
2325     *p = 0;
2326     return S_OK;
2327 }
2328
2329 static HRESULT WINAPI HTMLNamespaceCollection_item(IHTMLNamespaceCollection *iface, VARIANT index, IDispatch **p)
2330 {
2331     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2332     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(&index), p);
2333     return E_NOTIMPL;
2334 }
2335
2336 static HRESULT WINAPI HTMLNamespaceCollection_add(IHTMLNamespaceCollection *iface, BSTR namespace, BSTR urn,
2337                                                   VARIANT implementation_url, IDispatch **p)
2338 {
2339     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2340     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(namespace), debugstr_w(urn), debugstr_variant(&implementation_url), p);
2341     return E_NOTIMPL;
2342 }
2343
2344 static const IHTMLNamespaceCollectionVtbl HTMLNamespaceCollectionVtbl = {
2345     HTMLNamespaceCollection_QueryInterface,
2346     HTMLNamespaceCollection_AddRef,
2347     HTMLNamespaceCollection_Release,
2348     HTMLNamespaceCollection_GetTypeInfoCount,
2349     HTMLNamespaceCollection_GetTypeInfo,
2350     HTMLNamespaceCollection_GetIDsOfNames,
2351     HTMLNamespaceCollection_Invoke,
2352     HTMLNamespaceCollection_get_length,
2353     HTMLNamespaceCollection_item,
2354     HTMLNamespaceCollection_add
2355 };
2356
2357 static const tid_t HTMLNamespaceCollection_iface_tids[] = {
2358     IHTMLNamespaceCollection_tid,
2359     0
2360 };
2361 static dispex_static_data_t HTMLNamespaceCollection_dispex = {
2362     L"MSNamespaceInfoCollection",
2363     NULL,
2364     DispHTMLNamespaceCollection_tid,
2365     HTMLNamespaceCollection_iface_tids
2366 };
2367
2368 HRESULT create_namespace_collection(compat_mode_t compat_mode, IHTMLNamespaceCollection **ret)
2369 {
2370     HTMLNamespaceCollection *namespaces;
2371
2372     if (!(namespaces = heap_alloc_zero(sizeof(*namespaces))))
2373         return E_OUTOFMEMORY;
2374
2375     namespaces->IHTMLNamespaceCollection_iface.lpVtbl = &HTMLNamespaceCollectionVtbl;
2376     namespaces->ref = 1;
2377     init_dispatch(&namespaces->dispex, (IUnknown*)&namespaces->IHTMLNamespaceCollection_iface,
2378                   &HTMLNamespaceCollection_dispex, compat_mode);
2379     *ret = &namespaces->IHTMLNamespaceCollection_iface;
2380     return S_OK;
2381 }
2382
2383 struct console {
2384     DispatchEx dispex;
2385     IWineMSHTMLConsole IWineMSHTMLConsole_iface;
2386     LONG ref;
2387 };
2388
2389 static inline struct console *impl_from_IWineMSHTMLConsole(IWineMSHTMLConsole *iface)
2390 {
2391     return CONTAINING_RECORD(iface, struct console, IWineMSHTMLConsole_iface);
2392 }
2393
2394 static HRESULT WINAPI console_QueryInterface(IWineMSHTMLConsole *iface, REFIID riid, void **ppv)
2395 {
2396     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2397
2398     TRACE("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2399
2400     if(IsEqualGUID(&IID_IUnknown, riid)) {
2401         *ppv = &console->IWineMSHTMLConsole_iface;
2402     }else if(IsEqualGUID(&IID_IWineMSHTMLConsole, riid)) {
2403         *ppv = &console->IWineMSHTMLConsole_iface;
2404     }else if(dispex_query_interface(&console->dispex, riid, ppv)) {
2405         return *ppv ? S_OK : E_NOINTERFACE;
2406     }else {
2407         WARN("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2408         *ppv = NULL;
2409         return E_NOINTERFACE;
2410     }
2411
2412     IUnknown_AddRef((IUnknown*)*ppv);
2413     return S_OK;
2414 }
2415
2416 static ULONG WINAPI console_AddRef(IWineMSHTMLConsole *iface)
2417 {
2418     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2419     LONG ref = InterlockedIncrement(&console->ref);
2420
2421     TRACE("(%p) ref=%ld\n", console, ref);
2422
2423     return ref;
2424 }
2425
2426 static ULONG WINAPI console_Release(IWineMSHTMLConsole *iface)
2427 {
2428     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2429     LONG ref = InterlockedDecrement(&console->ref);
2430
2431     TRACE("(%p) ref=%ld\n", console, ref);
2432
2433     if(!ref) {
2434         release_dispex(&console->dispex);
2435         heap_free(console);
2436     }
2437
2438     return ref;
2439 }
2440
2441 static HRESULT WINAPI console_GetTypeInfoCount(IWineMSHTMLConsole *iface, UINT *pctinfo)
2442 {
2443     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2444     FIXME("(%p)->(%p)\n", console, pctinfo);
2445     return E_NOTIMPL;
2446 }
2447
2448 static HRESULT WINAPI console_GetTypeInfo(IWineMSHTMLConsole *iface, UINT iTInfo,
2449         LCID lcid, ITypeInfo **ppTInfo)
2450 {
2451     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2452
2453     return IDispatchEx_GetTypeInfo(&console->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2454 }
2455
2456 static HRESULT WINAPI console_GetIDsOfNames(IWineMSHTMLConsole *iface, REFIID riid,
2457         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2458 {
2459     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2460
2461     return IDispatchEx_GetIDsOfNames(&console->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2462             lcid, rgDispId);
2463 }
2464
2465 static HRESULT WINAPI console_Invoke(IWineMSHTMLConsole *iface, DISPID dispIdMember,
2466         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2467         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2468 {
2469     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2470
2471     return IDispatchEx_Invoke(&console->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2472             pDispParams, pVarResult, pExcepInfo, puArgErr);
2473 }
2474
2475 static HRESULT WINAPI console_assert(IWineMSHTMLConsole *iface, VARIANT_BOOL *assertion, VARIANT *vararg_start)
2476 {
2477     FIXME("iface %p, assertion %p, vararg_start %p stub.\n", iface, assertion, vararg_start);
2478
2479     return S_OK;
2480 }
2481
2482 static HRESULT WINAPI console_clear(IWineMSHTMLConsole *iface)
2483 {
2484     FIXME("iface %p stub.\n", iface);
2485
2486     return S_OK;
2487 }
2488
2489 static HRESULT WINAPI console_count(IWineMSHTMLConsole *iface, VARIANT *label)
2490 {
2491     FIXME("iface %p, label %p stub.\n", iface, label);
2492
2493     return S_OK;
2494 }
2495
2496 static HRESULT WINAPI console_debug(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2497 {
2498     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2499
2500     return S_OK;
2501 }
2502
2503 static HRESULT WINAPI console_dir(IWineMSHTMLConsole *iface, VARIANT *object)
2504 {
2505     FIXME("iface %p, object %p stub.\n", iface, object);
2506
2507     return S_OK;
2508 }
2509
2510 static HRESULT WINAPI console_dirxml(IWineMSHTMLConsole *iface, VARIANT *object)
2511 {
2512     FIXME("iface %p, object %p stub.\n", iface, object);
2513
2514     return S_OK;
2515 }
2516
2517 static HRESULT WINAPI console_error(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2518 {
2519     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2520
2521     return S_OK;
2522 }
2523
2524 static HRESULT WINAPI console_group(IWineMSHTMLConsole *iface, VARIANT *label)
2525 {
2526     FIXME("iface %p, label %p stub.\n", iface, label);
2527
2528     return S_OK;
2529 }
2530
2531 static HRESULT WINAPI console_group_collapsed(IWineMSHTMLConsole *iface, VARIANT *label)
2532 {
2533     FIXME("iface %p, label %p stub.\n", iface, label);
2534
2535     return S_OK;
2536 }
2537
2538 static HRESULT WINAPI console_group_end(IWineMSHTMLConsole *iface)
2539 {
2540     FIXME("iface %p, stub.\n", iface);
2541
2542     return S_OK;
2543 }
2544
2545 static HRESULT WINAPI console_info(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2546 {
2547     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2548
2549     return S_OK;
2550 }
2551
2552 static HRESULT WINAPI console_log(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2553 {
2554     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2555
2556     return S_OK;
2557 }
2558
2559 static HRESULT WINAPI console_time(IWineMSHTMLConsole *iface, VARIANT *label)
2560 {
2561     FIXME("iface %p, label %p stub.\n", iface, label);
2562
2563     return S_OK;
2564 }
2565
2566 static HRESULT WINAPI console_time_end(IWineMSHTMLConsole *iface, VARIANT *label)
2567 {
2568     FIXME("iface %p, label %p stub.\n", iface, label);
2569
2570     return S_OK;
2571 }
2572
2573 static HRESULT WINAPI console_trace(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2574 {
2575     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2576
2577     return S_OK;
2578 }
2579
2580 static HRESULT WINAPI console_warn(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2581 {
2582     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2583
2584     return S_OK;
2585 }
2586
2587 static const IWineMSHTMLConsoleVtbl WineMSHTMLConsoleVtbl = {
2588     console_QueryInterface,
2589     console_AddRef,
2590     console_Release,
2591     console_GetTypeInfoCount,
2592     console_GetTypeInfo,
2593     console_GetIDsOfNames,
2594     console_Invoke,
2595     console_assert,
2596     console_clear,
2597     console_count,
2598     console_debug,
2599     console_dir,
2600     console_dirxml,
2601     console_error,
2602     console_group,
2603     console_group_collapsed,
2604     console_group_end,
2605     console_info,
2606     console_log,
2607     console_time,
2608     console_time_end,
2609     console_trace,
2610     console_warn,
2611 };
2612
2613 static const tid_t console_iface_tids[] = {
2614     IWineMSHTMLConsole_tid,
2615     0
2616 };
2617 static dispex_static_data_t console_dispex = {
2618     L"Console",
2619     NULL,
2620     IWineMSHTMLConsole_tid,
2621     console_iface_tids
2622 };
2623
2624 void create_console(compat_mode_t compat_mode, IWineMSHTMLConsole **ret)
2625 {
2626     struct console *obj;
2627
2628     obj = heap_alloc_zero(sizeof(*obj));
2629     if(!obj)
2630     {
2631         ERR("No memory.\n");
2632         return;
2633     }
2634
2635     obj->IWineMSHTMLConsole_iface.lpVtbl = &WineMSHTMLConsoleVtbl;
2636     obj->ref = 1;
2637     init_dispatch(&obj->dispex, (IUnknown*)&obj->IWineMSHTMLConsole_iface, &console_dispex, compat_mode);
2638
2639     *ret = &obj->IWineMSHTMLConsole_iface;
2640 }