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 static unsigned int get_ua_version(OmNavigator *navigator)
1166 {
1167     switch(dispex_compat_mode(&navigator->dispex)) {
1168     case COMPAT_MODE_QUIRKS:
1169     case COMPAT_MODE_IE5:
1170     case COMPAT_MODE_IE7:
1171         return 7;
1172     case COMPAT_MODE_IE8:
1173         return 8;
1174     case COMPAT_MODE_IE9:
1175         return 9;
1176     case COMPAT_MODE_IE10:
1177         return 10;
1178     case COMPAT_MODE_IE11:
1179         return 11;
1180     }
1181     assert(0);
1182     return 0;
1183 }
1184
1185 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
1186 {
1187     OmNavigator *This = impl_from_IOmNavigator(iface);
1188
1189     char user_agent[512];
1190     DWORD size;
1191     HRESULT hres;
1192     const unsigned skip_prefix = 8; /* strlen("Mozilla/") */
1193
1194     TRACE("(%p)->(%p)\n", This, p);
1195
1196     size = sizeof(user_agent);
1197     hres = ObtainUserAgentString(get_ua_version(This), user_agent, &size);
1198     if(FAILED(hres))
1199         return hres;
1200
1201     if(size <= skip_prefix) {
1202         *p = NULL;
1203         return S_OK;
1204     }
1205
1206     size = MultiByteToWideChar(CP_ACP, 0, user_agent + skip_prefix, -1, NULL, 0);
1207     *p = SysAllocStringLen(NULL, size-1);
1208     if(!*p)
1209         return E_OUTOFMEMORY;
1210
1211     MultiByteToWideChar(CP_ACP, 0, user_agent + skip_prefix, -1, *p, size);
1212     return S_OK;
1213 }
1214
1215 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
1216 {
1217     OmNavigator *This = impl_from_IOmNavigator(iface);
1218     char user_agent[512];
1219     DWORD size;
1220     HRESULT hres;
1221
1222     TRACE("(%p)->(%p)\n", This, p);
1223
1224     size = sizeof(user_agent);
1225     hres = ObtainUserAgentString(get_ua_version(This), user_agent, &size);
1226     if(FAILED(hres))
1227         return hres;
1228
1229     size = MultiByteToWideChar(CP_ACP, 0, user_agent, -1, NULL, 0);
1230     *p = SysAllocStringLen(NULL, size-1);
1231     if(!*p)
1232         return E_OUTOFMEMORY;
1233
1234     MultiByteToWideChar(CP_ACP, 0, user_agent, -1, *p, size);
1235     return S_OK;
1236 }
1237
1238 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1239 {
1240     OmNavigator *This = impl_from_IOmNavigator(iface);
1241
1242     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
1243
1244     *enabled = VARIANT_TRUE;
1245     return S_OK;
1246 }
1247
1248 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1249 {
1250     OmNavigator *This = impl_from_IOmNavigator(iface);
1251     FIXME("(%p)->(%p)\n", This, enabled);
1252     return E_NOTIMPL;
1253 }
1254
1255 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
1256 {
1257     OmNavigator *This = impl_from_IOmNavigator(iface);
1258
1259     TRACE("(%p)->(%p)\n", This, p);
1260
1261     if(!This->mime_types) {
1262         HRESULT hres;
1263
1264         hres = create_mime_types_collection(This, &This->mime_types);
1265         if(FAILED(hres))
1266             return hres;
1267     }else {
1268         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
1269     }
1270
1271     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
1272     return S_OK;
1273 }
1274
1275 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
1276 {
1277     OmNavigator *This = impl_from_IOmNavigator(iface);
1278
1279     TRACE("(%p)->(%p)\n", This, p);
1280
1281     if(!This->plugins) {
1282         HRESULT hres;
1283
1284         hres = create_plugins_collection(This, &This->plugins);
1285         if(FAILED(hres))
1286             return hres;
1287     }else {
1288         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
1289     }
1290
1291     *p = &This->plugins->IHTMLPluginsCollection_iface;
1292     return S_OK;
1293 }
1294
1295 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
1296 {
1297     OmNavigator *This = impl_from_IOmNavigator(iface);
1298
1299     WARN("(%p)->(%p) semi-stub\n", This, p);
1300
1301     *p = VARIANT_TRUE;
1302     return S_OK;
1303 }
1304
1305 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1306 {
1307     OmNavigator *This = impl_from_IOmNavigator(iface);
1308     FIXME("(%p)->(%p)\n", This, p);
1309     return E_NOTIMPL;
1310 }
1311
1312 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
1313 {
1314     OmNavigator *This = impl_from_IOmNavigator(iface);
1315
1316     TRACE("(%p)->(%p)\n", This, String);
1317
1318     return dispex_to_string(&This->dispex, String);
1319 }
1320
1321 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
1322 {
1323     OmNavigator *This = impl_from_IOmNavigator(iface);
1324
1325     TRACE("(%p)->(%p)\n", This, p);
1326
1327 #ifdef _WIN64
1328     *p = SysAllocString(L"x64");
1329 #else
1330     *p = SysAllocString(L"x86");
1331 #endif
1332     return *p ? S_OK : E_OUTOFMEMORY;
1333 }
1334
1335 static HRESULT get_language_string(LCID lcid, BSTR *p)
1336 {
1337     BSTR ret;
1338     int len;
1339
1340     len = LCIDToLocaleName(lcid, NULL, 0, 0);
1341     if(!len) {
1342         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1343         return E_FAIL;
1344     }
1345
1346     ret = SysAllocStringLen(NULL, len-1);
1347     if(!ret)
1348         return E_OUTOFMEMORY;
1349
1350     len = LCIDToLocaleName(lcid, ret, len, 0);
1351     if(!len) {
1352         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1353         SysFreeString(ret);
1354         return E_FAIL;
1355     }
1356
1357     *p = ret;
1358     return S_OK;
1359 }
1360
1361 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1362 {
1363     OmNavigator *This = impl_from_IOmNavigator(iface);
1364
1365     TRACE("(%p)->(%p)\n", This, p);
1366
1367     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1368 }
1369
1370 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1371 {
1372     OmNavigator *This = impl_from_IOmNavigator(iface);
1373
1374     TRACE("(%p)->(%p)\n", This, p);
1375
1376     return get_language_string(GetUserDefaultUILanguage(), p);
1377 }
1378
1379 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1380 {
1381     OmNavigator *This = impl_from_IOmNavigator(iface);
1382
1383     TRACE("(%p)->(%p)\n", This, p);
1384
1385     return get_language_string(LOCALE_USER_DEFAULT, p);
1386 }
1387
1388 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1389 {
1390     OmNavigator *This = impl_from_IOmNavigator(iface);
1391
1392     TRACE("(%p)->(%p)\n", This, p);
1393
1394 #ifdef _WIN64
1395     *p = SysAllocString(L"Win64");
1396 #else
1397     *p = SysAllocString(L"Win32");
1398 #endif
1399     return S_OK;
1400 }
1401
1402 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1403 {
1404     OmNavigator *This = impl_from_IOmNavigator(iface);
1405
1406     TRACE("(%p)->(%p)\n", This, p);
1407
1408     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1409     *p = SysAllocString(L"0");
1410     return S_OK;
1411 }
1412
1413 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1414 {
1415     OmNavigator *This = impl_from_IOmNavigator(iface);
1416     FIXME("(%p)->(%p)\n", This, p);
1417     return E_NOTIMPL;
1418 }
1419
1420 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1421 {
1422     OmNavigator *This = impl_from_IOmNavigator(iface);
1423
1424     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1425
1426     *p = VARIANT_TRUE;
1427     return S_OK;
1428 }
1429
1430 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1431 {
1432     OmNavigator *This = impl_from_IOmNavigator(iface);
1433     FIXME("(%p)->(%p)\n", This, p);
1434     return E_NOTIMPL;
1435 }
1436
1437 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1438     OmNavigator_QueryInterface,
1439     OmNavigator_AddRef,
1440     OmNavigator_Release,
1441     OmNavigator_GetTypeInfoCount,
1442     OmNavigator_GetTypeInfo,
1443     OmNavigator_GetIDsOfNames,
1444     OmNavigator_Invoke,
1445     OmNavigator_get_appCodeName,
1446     OmNavigator_get_appName,
1447     OmNavigator_get_appVersion,
1448     OmNavigator_get_userAgent,
1449     OmNavigator_javaEnabled,
1450     OmNavigator_taintEnabled,
1451     OmNavigator_get_mimeTypes,
1452     OmNavigator_get_plugins,
1453     OmNavigator_get_cookieEnabled,
1454     OmNavigator_get_opsProfile,
1455     OmNavigator_toString,
1456     OmNavigator_get_cpuClass,
1457     OmNavigator_get_systemLanguage,
1458     OmNavigator_get_browserLanguage,
1459     OmNavigator_get_userLanguage,
1460     OmNavigator_get_platform,
1461     OmNavigator_get_appMinorVersion,
1462     OmNavigator_get_connectionSpeed,
1463     OmNavigator_get_onLine,
1464     OmNavigator_get_userProfile
1465 };
1466
1467 static const tid_t OmNavigator_iface_tids[] = {
1468     IOmNavigator_tid,
1469     0
1470 };
1471 static dispex_static_data_t OmNavigator_dispex = {
1472     L"Navigator",
1473     NULL,
1474     DispHTMLNavigator_tid,
1475     OmNavigator_iface_tids
1476 };
1477
1478 HRESULT create_navigator(compat_mode_t compat_mode, IOmNavigator **navigator)
1479 {
1480     OmNavigator *ret;
1481
1482     ret = heap_alloc_zero(sizeof(*ret));
1483     if(!ret)
1484         return E_OUTOFMEMORY;
1485
1486     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1487     ret->ref = 1;
1488
1489     init_dispatch(&ret->dispex, (IUnknown*)&ret->IOmNavigator_iface, &OmNavigator_dispex, compat_mode);
1490
1491     *navigator = &ret->IOmNavigator_iface;
1492     return S_OK;
1493 }
1494
1495 typedef struct {
1496     DispatchEx dispex;
1497     IHTMLPerformanceTiming IHTMLPerformanceTiming_iface;
1498
1499     LONG ref;
1500 } HTMLPerformanceTiming;
1501
1502 static inline HTMLPerformanceTiming *impl_from_IHTMLPerformanceTiming(IHTMLPerformanceTiming *iface)
1503 {
1504     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, IHTMLPerformanceTiming_iface);
1505 }
1506
1507 static HRESULT WINAPI HTMLPerformanceTiming_QueryInterface(IHTMLPerformanceTiming *iface, REFIID riid, void **ppv)
1508 {
1509     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1510
1511     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1512
1513     if(IsEqualGUID(&IID_IUnknown, riid)) {
1514         *ppv = &This->IHTMLPerformanceTiming_iface;
1515     }else if(IsEqualGUID(&IID_IHTMLPerformanceTiming, riid)) {
1516         *ppv = &This->IHTMLPerformanceTiming_iface;
1517     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1518         return *ppv ? S_OK : E_NOINTERFACE;
1519     }else {
1520         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1521         *ppv = NULL;
1522         return E_NOINTERFACE;
1523     }
1524
1525     IUnknown_AddRef((IUnknown*)*ppv);
1526     return S_OK;
1527 }
1528
1529 static ULONG WINAPI HTMLPerformanceTiming_AddRef(IHTMLPerformanceTiming *iface)
1530 {
1531     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1532     LONG ref = InterlockedIncrement(&This->ref);
1533
1534     TRACE("(%p) ref=%ld\n", This, ref);
1535
1536     return ref;
1537 }
1538
1539 static ULONG WINAPI HTMLPerformanceTiming_Release(IHTMLPerformanceTiming *iface)
1540 {
1541     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1542     LONG ref = InterlockedDecrement(&This->ref);
1543
1544     TRACE("(%p) ref=%ld\n", This, ref);
1545
1546     if(!ref) {
1547         release_dispex(&This->dispex);
1548         heap_free(This);
1549     }
1550
1551     return ref;
1552 }
1553
1554 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfoCount(IHTMLPerformanceTiming *iface, UINT *pctinfo)
1555 {
1556     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1557     FIXME("(%p)->(%p)\n", This, pctinfo);
1558     return E_NOTIMPL;
1559 }
1560
1561 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfo(IHTMLPerformanceTiming *iface, UINT iTInfo,
1562                                               LCID lcid, ITypeInfo **ppTInfo)
1563 {
1564     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1565
1566     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1567 }
1568
1569 static HRESULT WINAPI HTMLPerformanceTiming_GetIDsOfNames(IHTMLPerformanceTiming *iface, REFIID riid,
1570                                                           LPOLESTR *rgszNames, UINT cNames,
1571                                                           LCID lcid, DISPID *rgDispId)
1572 {
1573     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1574
1575     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1576             lcid, rgDispId);
1577 }
1578
1579 static HRESULT WINAPI HTMLPerformanceTiming_Invoke(IHTMLPerformanceTiming *iface, DISPID dispIdMember,
1580                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1581                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1582 {
1583     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1584
1585     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1586             pDispParams, pVarResult, pExcepInfo, puArgErr);
1587 }
1588
1589 #define TIMING_FAKE_TIMESTAMP 0xdeadbeef
1590
1591 static HRESULT WINAPI HTMLPerformanceTiming_get_navigationStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1592 {
1593     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1594
1595     FIXME("(%p)->(%p) returning fake value\n", This, p);
1596
1597     *p = TIMING_FAKE_TIMESTAMP;
1598     return S_OK;
1599 }
1600
1601 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1602 {
1603     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1604
1605     FIXME("(%p)->(%p) returning fake value\n", This, p);
1606
1607     *p = TIMING_FAKE_TIMESTAMP;
1608     return S_OK;
1609 }
1610
1611 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1612 {
1613     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1614
1615     FIXME("(%p)->(%p) returning fake value\n", This, p);
1616
1617     *p = TIMING_FAKE_TIMESTAMP;
1618     return S_OK;
1619 }
1620
1621 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1622 {
1623     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1624
1625     FIXME("(%p)->(%p) returning fake value\n", This, p);
1626
1627     *p = TIMING_FAKE_TIMESTAMP;
1628     return S_OK;
1629 }
1630
1631 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1632 {
1633     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1634
1635     FIXME("(%p)->(%p) returning fake value\n", This, p);
1636
1637     *p = TIMING_FAKE_TIMESTAMP;
1638     return S_OK;
1639 }
1640
1641 static HRESULT WINAPI HTMLPerformanceTiming_get_fetchStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1642 {
1643     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1644
1645     FIXME("(%p)->(%p) returning fake value\n", This, p);
1646
1647     *p = TIMING_FAKE_TIMESTAMP;
1648     return S_OK;
1649 }
1650
1651 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1652 {
1653     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1654
1655     FIXME("(%p)->(%p) returning fake value\n", This, p);
1656
1657     *p = TIMING_FAKE_TIMESTAMP;
1658     return S_OK;
1659 }
1660
1661 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1662 {
1663     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1664
1665     FIXME("(%p)->(%p) returning fake value\n", This, p);
1666
1667     *p = TIMING_FAKE_TIMESTAMP;
1668     return S_OK;
1669 }
1670
1671 static HRESULT WINAPI HTMLPerformanceTiming_get_connectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1672 {
1673     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1674
1675     FIXME("(%p)->(%p) returning fake value\n", This, p);
1676
1677     *p = TIMING_FAKE_TIMESTAMP;
1678     return S_OK;
1679 }
1680
1681 static HRESULT WINAPI HTMLPerformanceTiming_get_connectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1682 {
1683     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1684
1685     FIXME("(%p)->(%p) returning fake value\n", This, p);
1686
1687     *p = TIMING_FAKE_TIMESTAMP;
1688     return S_OK;
1689 }
1690
1691 static HRESULT WINAPI HTMLPerformanceTiming_get_requestStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1692 {
1693     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1694
1695     FIXME("(%p)->(%p) returning fake value\n", This, p);
1696
1697     *p = TIMING_FAKE_TIMESTAMP;
1698     return S_OK;
1699 }
1700
1701 static HRESULT WINAPI HTMLPerformanceTiming_get_responseStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1702 {
1703     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1704
1705     FIXME("(%p)->(%p) returning fake value\n", This, p);
1706
1707     *p = TIMING_FAKE_TIMESTAMP;
1708     return S_OK;
1709 }
1710
1711 static HRESULT WINAPI HTMLPerformanceTiming_get_responseEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1712 {
1713     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1714
1715     FIXME("(%p)->(%p) returning fake value\n", This, p);
1716
1717     *p = TIMING_FAKE_TIMESTAMP;
1718     return S_OK;
1719 }
1720
1721 static HRESULT WINAPI HTMLPerformanceTiming_get_domLoading(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1722 {
1723     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1724
1725     FIXME("(%p)->(%p) returning fake value\n", This, p);
1726
1727     *p = TIMING_FAKE_TIMESTAMP;
1728     return S_OK;
1729 }
1730
1731 static HRESULT WINAPI HTMLPerformanceTiming_get_domInteractive(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1732 {
1733     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1734
1735     FIXME("(%p)->(%p) returning fake value\n", This, p);
1736
1737     *p = TIMING_FAKE_TIMESTAMP;
1738     return S_OK;
1739 }
1740
1741 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1742 {
1743     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1744
1745     FIXME("(%p)->(%p) returning fake value\n", This, p);
1746
1747     *p = TIMING_FAKE_TIMESTAMP;
1748     return S_OK;
1749 }
1750
1751 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1752 {
1753     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1754
1755     FIXME("(%p)->(%p) returning fake value\n", This, p);
1756
1757     *p = TIMING_FAKE_TIMESTAMP;
1758     return S_OK;
1759 }
1760
1761 static HRESULT WINAPI HTMLPerformanceTiming_get_domComplete(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1762 {
1763     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1764
1765     FIXME("(%p)->(%p) returning fake value\n", This, p);
1766
1767     *p = TIMING_FAKE_TIMESTAMP;
1768     return S_OK;
1769 }
1770
1771 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1772 {
1773     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1774
1775     FIXME("(%p)->(%p) returning fake value\n", This, p);
1776
1777     *p = TIMING_FAKE_TIMESTAMP;
1778     return S_OK;
1779 }
1780
1781 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1782 {
1783     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1784
1785     FIXME("(%p)->(%p) returning fake value\n", This, p);
1786
1787     *p = TIMING_FAKE_TIMESTAMP;
1788     return S_OK;
1789 }
1790
1791 static HRESULT WINAPI HTMLPerformanceTiming_get_msFirstPaint(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1792 {
1793     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1794
1795     FIXME("(%p)->(%p) returning fake value\n", This, p);
1796
1797     *p = TIMING_FAKE_TIMESTAMP;
1798     return S_OK;
1799 }
1800
1801 static HRESULT WINAPI HTMLPerformanceTiming_toString(IHTMLPerformanceTiming *iface, BSTR *string)
1802 {
1803     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1804
1805     TRACE("(%p)->(%p)\n", This, string);
1806
1807     return dispex_to_string(&This->dispex, string);
1808 }
1809
1810 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1811 {
1812     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1813     FIXME("(%p)->(%p)\n", This, p);
1814     return E_NOTIMPL;
1815 }
1816
1817 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1818     HTMLPerformanceTiming_QueryInterface,
1819     HTMLPerformanceTiming_AddRef,
1820     HTMLPerformanceTiming_Release,
1821     HTMLPerformanceTiming_GetTypeInfoCount,
1822     HTMLPerformanceTiming_GetTypeInfo,
1823     HTMLPerformanceTiming_GetIDsOfNames,
1824     HTMLPerformanceTiming_Invoke,
1825     HTMLPerformanceTiming_get_navigationStart,
1826     HTMLPerformanceTiming_get_unloadEventStart,
1827     HTMLPerformanceTiming_get_unloadEventEnd,
1828     HTMLPerformanceTiming_get_redirectStart,
1829     HTMLPerformanceTiming_get_redirectEnd,
1830     HTMLPerformanceTiming_get_fetchStart,
1831     HTMLPerformanceTiming_get_domainLookupStart,
1832     HTMLPerformanceTiming_get_domainLookupEnd,
1833     HTMLPerformanceTiming_get_connectStart,
1834     HTMLPerformanceTiming_get_connectEnd,
1835     HTMLPerformanceTiming_get_requestStart,
1836     HTMLPerformanceTiming_get_responseStart,
1837     HTMLPerformanceTiming_get_responseEnd,
1838     HTMLPerformanceTiming_get_domLoading,
1839     HTMLPerformanceTiming_get_domInteractive,
1840     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1841     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1842     HTMLPerformanceTiming_get_domComplete,
1843     HTMLPerformanceTiming_get_loadEventStart,
1844     HTMLPerformanceTiming_get_loadEventEnd,
1845     HTMLPerformanceTiming_get_msFirstPaint,
1846     HTMLPerformanceTiming_toString,
1847     HTMLPerformanceTiming_toJSON
1848 };
1849
1850 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1851     IHTMLPerformanceTiming_tid,
1852     0
1853 };
1854 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1855     L"PerformanceTiming",
1856     NULL,
1857     IHTMLPerformanceTiming_tid,
1858     HTMLPerformanceTiming_iface_tids
1859 };
1860
1861 typedef struct {
1862     DispatchEx dispex;
1863     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1864
1865     LONG ref;
1866 } HTMLPerformanceNavigation;
1867
1868 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1869 {
1870     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1871 }
1872
1873 static HRESULT WINAPI HTMLPerformanceNavigation_QueryInterface(IHTMLPerformanceNavigation *iface, REFIID riid, void **ppv)
1874 {
1875     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1876
1877     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1878
1879     if(IsEqualGUID(&IID_IUnknown, riid)) {
1880         *ppv = &This->IHTMLPerformanceNavigation_iface;
1881     }else if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid)) {
1882         *ppv = &This->IHTMLPerformanceNavigation_iface;
1883     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1884         return *ppv ? S_OK : E_NOINTERFACE;
1885     }else {
1886         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1887         *ppv = NULL;
1888         return E_NOINTERFACE;
1889     }
1890
1891     IUnknown_AddRef((IUnknown*)*ppv);
1892     return S_OK;
1893 }
1894
1895 static ULONG WINAPI HTMLPerformanceNavigation_AddRef(IHTMLPerformanceNavigation *iface)
1896 {
1897     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1898     LONG ref = InterlockedIncrement(&This->ref);
1899
1900     TRACE("(%p) ref=%ld\n", This, ref);
1901
1902     return ref;
1903 }
1904
1905 static ULONG WINAPI HTMLPerformanceNavigation_Release(IHTMLPerformanceNavigation *iface)
1906 {
1907     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1908     LONG ref = InterlockedDecrement(&This->ref);
1909
1910     TRACE("(%p) ref=%ld\n", This, ref);
1911
1912     if(!ref) {
1913         release_dispex(&This->dispex);
1914         heap_free(This);
1915     }
1916
1917     return ref;
1918 }
1919
1920 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfoCount(IHTMLPerformanceNavigation *iface, UINT *pctinfo)
1921 {
1922     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1923     FIXME("(%p)->(%p)\n", This, pctinfo);
1924     return E_NOTIMPL;
1925 }
1926
1927 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfo(IHTMLPerformanceNavigation *iface, UINT iTInfo,
1928                                               LCID lcid, ITypeInfo **ppTInfo)
1929 {
1930     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1931
1932     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1933 }
1934
1935 static HRESULT WINAPI HTMLPerformanceNavigation_GetIDsOfNames(IHTMLPerformanceNavigation *iface, REFIID riid,
1936                                                           LPOLESTR *rgszNames, UINT cNames,
1937                                                           LCID lcid, DISPID *rgDispId)
1938 {
1939     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1940
1941     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1942             lcid, rgDispId);
1943 }
1944
1945 static HRESULT WINAPI HTMLPerformanceNavigation_Invoke(IHTMLPerformanceNavigation *iface, DISPID dispIdMember,
1946                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1947                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1948 {
1949     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1950
1951     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1952             pDispParams, pVarResult, pExcepInfo, puArgErr);
1953 }
1954
1955 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
1956 {
1957     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1958
1959     FIXME("(%p)->(%p) returning TYPE_NAVIGATE\n", This, p);
1960
1961     *p = 0; /* TYPE_NAVIGATE */
1962     return S_OK;
1963 }
1964
1965 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
1966 {
1967     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1968     FIXME("(%p)->(%p)\n", This, p);
1969     return E_NOTIMPL;
1970 }
1971
1972 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
1973 {
1974     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1975
1976     TRACE("(%p)->(%p)\n", This, string);
1977
1978     return dispex_to_string(&This->dispex, string);
1979 }
1980
1981 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
1982 {
1983     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1984     FIXME("(%p)->(%p)\n", This, p);
1985     return E_NOTIMPL;
1986 }
1987
1988 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
1989     HTMLPerformanceNavigation_QueryInterface,
1990     HTMLPerformanceNavigation_AddRef,
1991     HTMLPerformanceNavigation_Release,
1992     HTMLPerformanceNavigation_GetTypeInfoCount,
1993     HTMLPerformanceNavigation_GetTypeInfo,
1994     HTMLPerformanceNavigation_GetIDsOfNames,
1995     HTMLPerformanceNavigation_Invoke,
1996     HTMLPerformanceNavigation_get_type,
1997     HTMLPerformanceNavigation_get_redirectCount,
1998     HTMLPerformanceNavigation_toString,
1999     HTMLPerformanceNavigation_toJSON
2000 };
2001
2002 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
2003     IHTMLPerformanceNavigation_tid,
2004     0
2005 };
2006 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
2007     L"PerformanceNavigation",
2008     NULL,
2009     IHTMLPerformanceNavigation_tid,
2010     HTMLPerformanceNavigation_iface_tids
2011 };
2012
2013 typedef struct {
2014     DispatchEx dispex;
2015     IHTMLPerformance IHTMLPerformance_iface;
2016
2017     LONG ref;
2018
2019     IHTMLPerformanceNavigation *navigation;
2020     IHTMLPerformanceTiming *timing;
2021 } HTMLPerformance;
2022
2023 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
2024 {
2025     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
2026 }
2027
2028 static HRESULT WINAPI HTMLPerformance_QueryInterface(IHTMLPerformance *iface, REFIID riid, void **ppv)
2029 {
2030     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2031
2032     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2033
2034     if(IsEqualGUID(&IID_IUnknown, riid)) {
2035         *ppv = &This->IHTMLPerformance_iface;
2036     }else if(IsEqualGUID(&IID_IHTMLPerformance, riid)) {
2037         *ppv = &This->IHTMLPerformance_iface;
2038     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2039         return *ppv ? S_OK : E_NOINTERFACE;
2040     }else {
2041         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2042         *ppv = NULL;
2043         return E_NOINTERFACE;
2044     }
2045
2046     IUnknown_AddRef((IUnknown*)*ppv);
2047     return S_OK;
2048 }
2049
2050 static ULONG WINAPI HTMLPerformance_AddRef(IHTMLPerformance *iface)
2051 {
2052     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2053     LONG ref = InterlockedIncrement(&This->ref);
2054
2055     TRACE("(%p) ref=%ld\n", This, ref);
2056
2057     return ref;
2058 }
2059
2060 static ULONG WINAPI HTMLPerformance_Release(IHTMLPerformance *iface)
2061 {
2062     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2063     LONG ref = InterlockedDecrement(&This->ref);
2064
2065     TRACE("(%p) ref=%ld\n", This, ref);
2066
2067     if(!ref) {
2068         if(This->timing)
2069             IHTMLPerformanceTiming_Release(This->timing);
2070         if(This->navigation)
2071             IHTMLPerformanceNavigation_Release(This->navigation);
2072         release_dispex(&This->dispex);
2073         heap_free(This);
2074     }
2075
2076     return ref;
2077 }
2078
2079 static HRESULT WINAPI HTMLPerformance_GetTypeInfoCount(IHTMLPerformance *iface, UINT *pctinfo)
2080 {
2081     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2082     FIXME("(%p)->(%p)\n", This, pctinfo);
2083     return E_NOTIMPL;
2084 }
2085
2086 static HRESULT WINAPI HTMLPerformance_GetTypeInfo(IHTMLPerformance *iface, UINT iTInfo,
2087                                                   LCID lcid, ITypeInfo **ppTInfo)
2088 {
2089     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2090
2091     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2092 }
2093
2094 static HRESULT WINAPI HTMLPerformance_GetIDsOfNames(IHTMLPerformance *iface, REFIID riid,
2095                                                     LPOLESTR *rgszNames, UINT cNames,
2096                                                     LCID lcid, DISPID *rgDispId)
2097 {
2098     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2099
2100     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2101             lcid, rgDispId);
2102 }
2103
2104 static HRESULT WINAPI HTMLPerformance_Invoke(IHTMLPerformance *iface, DISPID dispIdMember,
2105                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2106                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2107 {
2108     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2109
2110     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2111             pDispParams, pVarResult, pExcepInfo, puArgErr);
2112 }
2113
2114 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
2115                                                      IHTMLPerformanceNavigation **p)
2116 {
2117     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2118
2119     TRACE("(%p)->(%p)\n", This, p);
2120
2121     if(!This->navigation) {
2122         HTMLPerformanceNavigation *navigation;
2123
2124         navigation = heap_alloc_zero(sizeof(*navigation));
2125         if(!navigation)
2126             return E_OUTOFMEMORY;
2127
2128         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
2129         navigation->ref = 1;
2130         init_dispatch(&navigation->dispex, (IUnknown*)&navigation->IHTMLPerformanceNavigation_iface,
2131                       &HTMLPerformanceNavigation_dispex, dispex_compat_mode(&This->dispex));
2132
2133         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
2134     }
2135
2136     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
2137     return S_OK;
2138 }
2139
2140 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
2141 {
2142     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2143
2144     TRACE("(%p)->(%p)\n", This, p);
2145
2146     if(!This->timing) {
2147         HTMLPerformanceTiming *timing;
2148
2149         timing = heap_alloc_zero(sizeof(*timing));
2150         if(!timing)
2151             return E_OUTOFMEMORY;
2152
2153         timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
2154         timing->ref = 1;
2155         init_dispatch(&timing->dispex, (IUnknown*)&timing->IHTMLPerformanceTiming_iface,
2156                       &HTMLPerformanceTiming_dispex, dispex_compat_mode(&This->dispex));
2157
2158         This->timing = &timing->IHTMLPerformanceTiming_iface;
2159     }
2160
2161     IHTMLPerformanceTiming_AddRef(*p = This->timing);
2162     return S_OK;
2163 }
2164
2165 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
2166 {
2167     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2168
2169     TRACE("(%p)->(%p)\n", This, string);
2170
2171     return dispex_to_string(&This->dispex, string);
2172 }
2173
2174 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
2175 {
2176     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2177     FIXME("(%p)->(%p)\n", This, var);
2178     return E_NOTIMPL;
2179 }
2180
2181 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
2182     HTMLPerformance_QueryInterface,
2183     HTMLPerformance_AddRef,
2184     HTMLPerformance_Release,
2185     HTMLPerformance_GetTypeInfoCount,
2186     HTMLPerformance_GetTypeInfo,
2187     HTMLPerformance_GetIDsOfNames,
2188     HTMLPerformance_Invoke,
2189     HTMLPerformance_get_navigation,
2190     HTMLPerformance_get_timing,
2191     HTMLPerformance_toString,
2192     HTMLPerformance_toJSON
2193 };
2194
2195 static const tid_t HTMLPerformance_iface_tids[] = {
2196     IHTMLPerformance_tid,
2197     0
2198 };
2199 static dispex_static_data_t HTMLPerformance_dispex = {
2200     L"Performance",
2201     NULL,
2202     IHTMLPerformance_tid,
2203     HTMLPerformance_iface_tids
2204 };
2205
2206 HRESULT create_performance(compat_mode_t compat_mode, IHTMLPerformance **ret)
2207 {
2208     HTMLPerformance *performance;
2209
2210     performance = heap_alloc_zero(sizeof(*performance));
2211     if(!performance)
2212         return E_OUTOFMEMORY;
2213
2214     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
2215     performance->ref = 1;
2216
2217     init_dispatch(&performance->dispex, (IUnknown*)&performance->IHTMLPerformance_iface,
2218                   &HTMLPerformance_dispex, compat_mode);
2219
2220     *ret = &performance->IHTMLPerformance_iface;
2221     return S_OK;
2222 }
2223
2224 typedef struct {
2225     DispatchEx dispex;
2226     IHTMLNamespaceCollection IHTMLNamespaceCollection_iface;
2227
2228     LONG ref;
2229 } HTMLNamespaceCollection;
2230
2231 static inline HTMLNamespaceCollection *impl_from_IHTMLNamespaceCollection(IHTMLNamespaceCollection *iface)
2232 {
2233     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, IHTMLNamespaceCollection_iface);
2234 }
2235
2236 static HRESULT WINAPI HTMLNamespaceCollection_QueryInterface(IHTMLNamespaceCollection *iface, REFIID riid, void **ppv)
2237 {
2238     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2239
2240     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2241
2242     if(IsEqualGUID(&IID_IUnknown, riid)) {
2243         *ppv = &This->IHTMLNamespaceCollection_iface;
2244     }else if(IsEqualGUID(&IID_IHTMLNamespaceCollection, riid)) {
2245         *ppv = &This->IHTMLNamespaceCollection_iface;
2246     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2247         return *ppv ? S_OK : E_NOINTERFACE;
2248     }else {
2249         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2250         *ppv = NULL;
2251         return E_NOINTERFACE;
2252     }
2253
2254     IUnknown_AddRef((IUnknown*)*ppv);
2255     return S_OK;
2256 }
2257
2258 static ULONG WINAPI HTMLNamespaceCollection_AddRef(IHTMLNamespaceCollection *iface)
2259 {
2260     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2261     LONG ref = InterlockedIncrement(&This->ref);
2262
2263     TRACE("(%p) ref=%ld\n", This, ref);
2264
2265     return ref;
2266 }
2267
2268 static ULONG WINAPI HTMLNamespaceCollection_Release(IHTMLNamespaceCollection *iface)
2269 {
2270     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2271     LONG ref = InterlockedDecrement(&This->ref);
2272
2273     TRACE("(%p) ref=%ld\n", This, ref);
2274
2275     if(!ref) {
2276         release_dispex(&This->dispex);
2277         heap_free(This);
2278     }
2279
2280     return ref;
2281 }
2282
2283 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfoCount(IHTMLNamespaceCollection *iface, UINT *pctinfo)
2284 {
2285     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2286     FIXME("(%p)->(%p)\n", This, pctinfo);
2287     return E_NOTIMPL;
2288 }
2289
2290 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfo(IHTMLNamespaceCollection *iface, UINT iTInfo,
2291                                                   LCID lcid, ITypeInfo **ppTInfo)
2292 {
2293     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2294
2295     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2296 }
2297
2298 static HRESULT WINAPI HTMLNamespaceCollection_GetIDsOfNames(IHTMLNamespaceCollection *iface, REFIID riid,
2299                                                     LPOLESTR *rgszNames, UINT cNames,
2300                                                     LCID lcid, DISPID *rgDispId)
2301 {
2302     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2303
2304     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2305             lcid, rgDispId);
2306 }
2307
2308 static HRESULT WINAPI HTMLNamespaceCollection_Invoke(IHTMLNamespaceCollection *iface, DISPID dispIdMember,
2309                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2310                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2311 {
2312     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2313
2314     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2315             pDispParams, pVarResult, pExcepInfo, puArgErr);
2316 }
2317
2318 static HRESULT WINAPI HTMLNamespaceCollection_get_length(IHTMLNamespaceCollection *iface, LONG *p)
2319 {
2320     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2321     FIXME("(%p)->(%p) returning 0\n", This, p);
2322     *p = 0;
2323     return S_OK;
2324 }
2325
2326 static HRESULT WINAPI HTMLNamespaceCollection_item(IHTMLNamespaceCollection *iface, VARIANT index, IDispatch **p)
2327 {
2328     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2329     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(&index), p);
2330     return E_NOTIMPL;
2331 }
2332
2333 static HRESULT WINAPI HTMLNamespaceCollection_add(IHTMLNamespaceCollection *iface, BSTR namespace, BSTR urn,
2334                                                   VARIANT implementation_url, IDispatch **p)
2335 {
2336     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2337     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(namespace), debugstr_w(urn), debugstr_variant(&implementation_url), p);
2338     return E_NOTIMPL;
2339 }
2340
2341 static const IHTMLNamespaceCollectionVtbl HTMLNamespaceCollectionVtbl = {
2342     HTMLNamespaceCollection_QueryInterface,
2343     HTMLNamespaceCollection_AddRef,
2344     HTMLNamespaceCollection_Release,
2345     HTMLNamespaceCollection_GetTypeInfoCount,
2346     HTMLNamespaceCollection_GetTypeInfo,
2347     HTMLNamespaceCollection_GetIDsOfNames,
2348     HTMLNamespaceCollection_Invoke,
2349     HTMLNamespaceCollection_get_length,
2350     HTMLNamespaceCollection_item,
2351     HTMLNamespaceCollection_add
2352 };
2353
2354 static const tid_t HTMLNamespaceCollection_iface_tids[] = {
2355     IHTMLNamespaceCollection_tid,
2356     0
2357 };
2358 static dispex_static_data_t HTMLNamespaceCollection_dispex = {
2359     L"MSNamespaceInfoCollection",
2360     NULL,
2361     DispHTMLNamespaceCollection_tid,
2362     HTMLNamespaceCollection_iface_tids
2363 };
2364
2365 HRESULT create_namespace_collection(compat_mode_t compat_mode, IHTMLNamespaceCollection **ret)
2366 {
2367     HTMLNamespaceCollection *namespaces;
2368
2369     if (!(namespaces = heap_alloc_zero(sizeof(*namespaces))))
2370         return E_OUTOFMEMORY;
2371
2372     namespaces->IHTMLNamespaceCollection_iface.lpVtbl = &HTMLNamespaceCollectionVtbl;
2373     namespaces->ref = 1;
2374     init_dispatch(&namespaces->dispex, (IUnknown*)&namespaces->IHTMLNamespaceCollection_iface,
2375                   &HTMLNamespaceCollection_dispex, compat_mode);
2376     *ret = &namespaces->IHTMLNamespaceCollection_iface;
2377     return S_OK;
2378 }
2379
2380 struct console {
2381     DispatchEx dispex;
2382     IWineMSHTMLConsole IWineMSHTMLConsole_iface;
2383     LONG ref;
2384 };
2385
2386 static inline struct console *impl_from_IWineMSHTMLConsole(IWineMSHTMLConsole *iface)
2387 {
2388     return CONTAINING_RECORD(iface, struct console, IWineMSHTMLConsole_iface);
2389 }
2390
2391 static HRESULT WINAPI console_QueryInterface(IWineMSHTMLConsole *iface, REFIID riid, void **ppv)
2392 {
2393     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2394
2395     TRACE("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2396
2397     if(IsEqualGUID(&IID_IUnknown, riid)) {
2398         *ppv = &console->IWineMSHTMLConsole_iface;
2399     }else if(IsEqualGUID(&IID_IWineMSHTMLConsole, riid)) {
2400         *ppv = &console->IWineMSHTMLConsole_iface;
2401     }else if(dispex_query_interface(&console->dispex, riid, ppv)) {
2402         return *ppv ? S_OK : E_NOINTERFACE;
2403     }else {
2404         WARN("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2405         *ppv = NULL;
2406         return E_NOINTERFACE;
2407     }
2408
2409     IUnknown_AddRef((IUnknown*)*ppv);
2410     return S_OK;
2411 }
2412
2413 static ULONG WINAPI console_AddRef(IWineMSHTMLConsole *iface)
2414 {
2415     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2416     LONG ref = InterlockedIncrement(&console->ref);
2417
2418     TRACE("(%p) ref=%ld\n", console, ref);
2419
2420     return ref;
2421 }
2422
2423 static ULONG WINAPI console_Release(IWineMSHTMLConsole *iface)
2424 {
2425     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2426     LONG ref = InterlockedDecrement(&console->ref);
2427
2428     TRACE("(%p) ref=%ld\n", console, ref);
2429
2430     if(!ref) {
2431         release_dispex(&console->dispex);
2432         heap_free(console);
2433     }
2434
2435     return ref;
2436 }
2437
2438 static HRESULT WINAPI console_GetTypeInfoCount(IWineMSHTMLConsole *iface, UINT *pctinfo)
2439 {
2440     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2441     FIXME("(%p)->(%p)\n", console, pctinfo);
2442     return E_NOTIMPL;
2443 }
2444
2445 static HRESULT WINAPI console_GetTypeInfo(IWineMSHTMLConsole *iface, UINT iTInfo,
2446         LCID lcid, ITypeInfo **ppTInfo)
2447 {
2448     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2449
2450     return IDispatchEx_GetTypeInfo(&console->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2451 }
2452
2453 static HRESULT WINAPI console_GetIDsOfNames(IWineMSHTMLConsole *iface, REFIID riid,
2454         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2455 {
2456     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2457
2458     return IDispatchEx_GetIDsOfNames(&console->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2459             lcid, rgDispId);
2460 }
2461
2462 static HRESULT WINAPI console_Invoke(IWineMSHTMLConsole *iface, DISPID dispIdMember,
2463         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2464         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2465 {
2466     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2467
2468     return IDispatchEx_Invoke(&console->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2469             pDispParams, pVarResult, pExcepInfo, puArgErr);
2470 }
2471
2472 static HRESULT WINAPI console_assert(IWineMSHTMLConsole *iface, VARIANT_BOOL *assertion, VARIANT *vararg_start)
2473 {
2474     FIXME("iface %p, assertion %p, vararg_start %p stub.\n", iface, assertion, vararg_start);
2475
2476     return S_OK;
2477 }
2478
2479 static HRESULT WINAPI console_clear(IWineMSHTMLConsole *iface)
2480 {
2481     FIXME("iface %p stub.\n", iface);
2482
2483     return S_OK;
2484 }
2485
2486 static HRESULT WINAPI console_count(IWineMSHTMLConsole *iface, VARIANT *label)
2487 {
2488     FIXME("iface %p, label %p stub.\n", iface, label);
2489
2490     return S_OK;
2491 }
2492
2493 static HRESULT WINAPI console_debug(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2494 {
2495     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2496
2497     return S_OK;
2498 }
2499
2500 static HRESULT WINAPI console_dir(IWineMSHTMLConsole *iface, VARIANT *object)
2501 {
2502     FIXME("iface %p, object %p stub.\n", iface, object);
2503
2504     return S_OK;
2505 }
2506
2507 static HRESULT WINAPI console_dirxml(IWineMSHTMLConsole *iface, VARIANT *object)
2508 {
2509     FIXME("iface %p, object %p stub.\n", iface, object);
2510
2511     return S_OK;
2512 }
2513
2514 static HRESULT WINAPI console_error(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2515 {
2516     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2517
2518     return S_OK;
2519 }
2520
2521 static HRESULT WINAPI console_group(IWineMSHTMLConsole *iface, VARIANT *label)
2522 {
2523     FIXME("iface %p, label %p stub.\n", iface, label);
2524
2525     return S_OK;
2526 }
2527
2528 static HRESULT WINAPI console_group_collapsed(IWineMSHTMLConsole *iface, VARIANT *label)
2529 {
2530     FIXME("iface %p, label %p stub.\n", iface, label);
2531
2532     return S_OK;
2533 }
2534
2535 static HRESULT WINAPI console_group_end(IWineMSHTMLConsole *iface)
2536 {
2537     FIXME("iface %p, stub.\n", iface);
2538
2539     return S_OK;
2540 }
2541
2542 static HRESULT WINAPI console_info(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2543 {
2544     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2545
2546     return S_OK;
2547 }
2548
2549 static HRESULT WINAPI console_log(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2550 {
2551     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2552
2553     return S_OK;
2554 }
2555
2556 static HRESULT WINAPI console_time(IWineMSHTMLConsole *iface, VARIANT *label)
2557 {
2558     FIXME("iface %p, label %p stub.\n", iface, label);
2559
2560     return S_OK;
2561 }
2562
2563 static HRESULT WINAPI console_time_end(IWineMSHTMLConsole *iface, VARIANT *label)
2564 {
2565     FIXME("iface %p, label %p stub.\n", iface, label);
2566
2567     return S_OK;
2568 }
2569
2570 static HRESULT WINAPI console_trace(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2571 {
2572     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2573
2574     return S_OK;
2575 }
2576
2577 static HRESULT WINAPI console_warn(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2578 {
2579     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2580
2581     return S_OK;
2582 }
2583
2584 static const IWineMSHTMLConsoleVtbl WineMSHTMLConsoleVtbl = {
2585     console_QueryInterface,
2586     console_AddRef,
2587     console_Release,
2588     console_GetTypeInfoCount,
2589     console_GetTypeInfo,
2590     console_GetIDsOfNames,
2591     console_Invoke,
2592     console_assert,
2593     console_clear,
2594     console_count,
2595     console_debug,
2596     console_dir,
2597     console_dirxml,
2598     console_error,
2599     console_group,
2600     console_group_collapsed,
2601     console_group_end,
2602     console_info,
2603     console_log,
2604     console_time,
2605     console_time_end,
2606     console_trace,
2607     console_warn,
2608 };
2609
2610 static const tid_t console_iface_tids[] = {
2611     IWineMSHTMLConsole_tid,
2612     0
2613 };
2614 static dispex_static_data_t console_dispex = {
2615     L"Console",
2616     NULL,
2617     IWineMSHTMLConsole_tid,
2618     console_iface_tids
2619 };
2620
2621 void create_console(compat_mode_t compat_mode, IWineMSHTMLConsole **ret)
2622 {
2623     struct console *obj;
2624
2625     obj = heap_alloc_zero(sizeof(*obj));
2626     if(!obj)
2627     {
2628         ERR("No memory.\n");
2629         return;
2630     }
2631
2632     obj->IWineMSHTMLConsole_iface.lpVtbl = &WineMSHTMLConsoleVtbl;
2633     obj->ref = 1;
2634     init_dispatch(&obj->dispex, (IUnknown*)&obj->IWineMSHTMLConsole_iface, &console_dispex, compat_mode);
2635
2636     *ret = &obj->IWineMSHTMLConsole_iface;
2637 }