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 #include <assert.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28
  29 #include "wine/debug.h"
  30
  31 #include "mshtml_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  34
  35 typedef struct HTMLPluginsCollection HTMLPluginsCollection;
  36 typedef struct HTMLMimeTypesCollection HTMLMimeTypesCollection;
  37
  38 typedef struct {
  39     DispatchEx dispex;
  40     IOmNavigator IOmNavigator_iface;
  41
  42     LONG ref;
  43
  44     HTMLPluginsCollection *plugins;
  45     HTMLMimeTypesCollection *mime_types;
  46 } OmNavigator;
  47
  48 typedef struct {
  49     DispatchEx dispex;
  50     IHTMLDOMImplementation IHTMLDOMImplementation_iface;
  51     IHTMLDOMImplementation2 IHTMLDOMImplementation2_iface;
  52
  53     LONG ref;
  54
  55     nsIDOMDOMImplementation *implementation;
  56     GeckoBrowser *browser;
  57 } HTMLDOMImplementation;
  58
  59 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation(IHTMLDOMImplementation *iface)
  60 {
  61     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation_iface);
  62 }
  63
  64 static HRESULT WINAPI HTMLDOMImplementation_QueryInterface(IHTMLDOMImplementation *iface, REFIID riid, void **ppv)
  65 {
  66     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  67
  68     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  69
  70     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IHTMLDOMImplementation, riid)) {
  71         *ppv = &This->IHTMLDOMImplementation_iface;
  72     }else if(IsEqualGUID(&IID_IHTMLDOMImplementation2, riid)) {
  73         *ppv = &This->IHTMLDOMImplementation2_iface;
  74     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
  75         return *ppv ? S_OK : E_NOINTERFACE;
  76     }else {
  77         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
  78         *ppv = NULL;
  79         return E_NOINTERFACE;
  80     }
  81
  82     IUnknown_AddRef((IUnknown*)*ppv);
  83     return S_OK;
  84 }
  85
  86 static ULONG WINAPI HTMLDOMImplementation_AddRef(IHTMLDOMImplementation *iface)
  87 {
  88     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  89     LONG ref = InterlockedIncrement(&This->ref);
  90
  91     TRACE("(%p) ref=%d\n", This, ref);
  92
  93     return ref;
  94 }
  95
  96 static ULONG WINAPI HTMLDOMImplementation_Release(IHTMLDOMImplementation *iface)
  97 {
  98     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  99     LONG ref = InterlockedDecrement(&This->ref);
 100
 101     TRACE("(%p) ref=%d\n", This, ref);
 102
 103     if(!ref) {
 104         assert(!This->browser);
 105         if(This->implementation)
 106             nsIDOMDOMImplementation_Release(This->implementation);
 107         release_dispex(&This->dispex);
 108         heap_free(This);
 109     }
 110
 111     return ref;
 112 }
 113
 114 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfoCount(IHTMLDOMImplementation *iface, UINT *pctinfo)
 115 {
 116     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 117
 118     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 119 }
 120
 121 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfo(IHTMLDOMImplementation *iface, UINT iTInfo,
 122         LCID lcid, ITypeInfo **ppTInfo)
 123 {
 124     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 125
 126     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 127 }
 128
 129 static HRESULT WINAPI HTMLDOMImplementation_GetIDsOfNames(IHTMLDOMImplementation *iface, REFIID riid,
 130         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 131 {
 132     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 133
 134     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 135             cNames, lcid, rgDispId);
 136 }
 137
 138 static HRESULT WINAPI HTMLDOMImplementation_Invoke(IHTMLDOMImplementation *iface, DISPID dispIdMember,
 139         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 140         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 141 {
 142     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 143
 144     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 145             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 146 }
 147
 148 static HRESULT WINAPI HTMLDOMImplementation_hasFeature(IHTMLDOMImplementation *iface, BSTR feature,
 149         VARIANT version, VARIANT_BOOL *pfHasFeature)
 150 {
 151     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 152
 153     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 154
 155     *pfHasFeature = VARIANT_FALSE;
 156     return S_OK;
 157 }
 158
 159 static const IHTMLDOMImplementationVtbl HTMLDOMImplementationVtbl = {
 160     HTMLDOMImplementation_QueryInterface,
 161     HTMLDOMImplementation_AddRef,
 162     HTMLDOMImplementation_Release,
 163     HTMLDOMImplementation_GetTypeInfoCount,
 164     HTMLDOMImplementation_GetTypeInfo,
 165     HTMLDOMImplementation_GetIDsOfNames,
 166     HTMLDOMImplementation_Invoke,
 167     HTMLDOMImplementation_hasFeature
 168 };
 169
 170 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation2(IHTMLDOMImplementation2 *iface)
 171 {
 172     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation2_iface);
 173 }
 174
 175 static HRESULT WINAPI HTMLDOMImplementation2_QueryInterface(IHTMLDOMImplementation2 *iface, REFIID riid, void **ppv)
 176 {
 177     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 178     return IHTMLDOMImplementation_QueryInterface(&This->IHTMLDOMImplementation_iface, riid, ppv);
 179 }
 180
 181 static ULONG WINAPI HTMLDOMImplementation2_AddRef(IHTMLDOMImplementation2 *iface)
 182 {
 183     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 184     return IHTMLDOMImplementation_AddRef(&This->IHTMLDOMImplementation_iface);
 185 }
 186
 187 static ULONG WINAPI HTMLDOMImplementation2_Release(IHTMLDOMImplementation2 *iface)
 188 {
 189     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 190     return IHTMLDOMImplementation_Release(&This->IHTMLDOMImplementation_iface);
 191 }
 192
 193 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfoCount(IHTMLDOMImplementation2 *iface, UINT *pctinfo)
 194 {
 195     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 196     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 197 }
 198
 199 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfo(IHTMLDOMImplementation2 *iface, UINT iTInfo,
 200         LCID lcid, ITypeInfo **ppTInfo)
 201 {
 202     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 203     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 204 }
 205
 206 static HRESULT WINAPI HTMLDOMImplementation2_GetIDsOfNames(IHTMLDOMImplementation2 *iface, REFIID riid,
 207         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 208 {
 209     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 210     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 211             cNames, lcid, rgDispId);
 212 }
 213
 214 static HRESULT WINAPI HTMLDOMImplementation2_Invoke(IHTMLDOMImplementation2 *iface, DISPID dispIdMember,
 215         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 216         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 217 {
 218     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 219     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 220             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 221 }
 222
 223 static HRESULT WINAPI HTMLDOMImplementation2_createDocumentType(IHTMLDOMImplementation2 *iface, BSTR name,
 224         VARIANT *public_id, VARIANT *system_id, IDOMDocumentType **new_type)
 225 {
 226     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 227     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(name), debugstr_variant(public_id),
 228           debugstr_variant(system_id), new_type);
 229     return E_NOTIMPL;
 230 }
 231
 232 static HRESULT WINAPI HTMLDOMImplementation2_createDocument(IHTMLDOMImplementation2 *iface, VARIANT *ns,
 233         VARIANT *tag_name, IDOMDocumentType *document_type, IHTMLDocument7 **new_document)
 234 {
 235     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 236     FIXME("(%p)->(%s %s %p %p)\n", This, debugstr_variant(ns), debugstr_variant(tag_name),
 237           document_type, new_document);
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI HTMLDOMImplementation2_createHTMLDocument(IHTMLDOMImplementation2 *iface, BSTR title,
 242         IHTMLDocument7 **new_document)
 243 {
 244     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 245     HTMLDocumentNode *new_document_node;
 246     nsIDOMHTMLDocument *html_doc;
 247     nsIDOMDocument *doc;
 248     nsAString title_str;
 249     nsresult nsres;
 250     HRESULT hres;
 251
 252     FIXME("(%p)->(%s %p)\n", This, debugstr_w(title), new_document);
 253
 254     if(!This->browser)
 255         return E_UNEXPECTED;
 256
 257     nsAString_InitDepend(&title_str, title);
 258     nsres = nsIDOMDOMImplementation_CreateHTMLDocument(This->implementation, &title_str, &doc);
 259     nsAString_Finish(&title_str);
 260     if(NS_FAILED(nsres)) {
 261         ERR("CreateHTMLDocument failed: %08x\n", nsres);
 262         return E_FAIL;
 263     }
 264
 265     nsres = nsIDOMDocument_QueryInterface(doc, &IID_nsIDOMHTMLDocument, (void**)&html_doc);
 266     nsIDOMDocument_Release(doc);
 267     assert(nsres == NS_OK);
 268
 269     hres = create_document_node(html_doc, This->browser, NULL, dispex_compat_mode(&This->dispex), &new_document_node);
 270     nsIDOMHTMLDocument_Release(html_doc);
 271     if(FAILED(hres))
 272         return hres;
 273
 274     *new_document = &new_document_node->basedoc.IHTMLDocument7_iface;
 275     return S_OK;
 276 }
 277
 278 static HRESULT WINAPI HTMLDOMImplementation2_hasFeature(IHTMLDOMImplementation2 *iface, BSTR feature,
 279         VARIANT version, VARIANT_BOOL *pfHasFeature)
 280 {
 281     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 282
 283     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 284
 285     *pfHasFeature = VARIANT_FALSE;
 286     return S_OK;
 287 }
 288
 289 static const IHTMLDOMImplementation2Vtbl HTMLDOMImplementation2Vtbl = {
 290     HTMLDOMImplementation2_QueryInterface,
 291     HTMLDOMImplementation2_AddRef,
 292     HTMLDOMImplementation2_Release,
 293     HTMLDOMImplementation2_GetTypeInfoCount,
 294     HTMLDOMImplementation2_GetTypeInfo,
 295     HTMLDOMImplementation2_GetIDsOfNames,
 296     HTMLDOMImplementation2_Invoke,
 297     HTMLDOMImplementation2_createDocumentType,
 298     HTMLDOMImplementation2_createDocument,
 299     HTMLDOMImplementation2_createHTMLDocument,
 300     HTMLDOMImplementation2_hasFeature
 301 };
 302
 303 static const tid_t HTMLDOMImplementation_iface_tids[] = {
 304     IHTMLDOMImplementation_tid,
 305     0
 306 };
 307 static dispex_static_data_t HTMLDOMImplementation_dispex = {
 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: %08x\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=%d\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=%d\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)->(%d)\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)->(%d)\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     NULL,
 560     DispHTMLScreen_tid,
 561     HTMLScreen_iface_tids
 562 };
 563
 564 HRESULT create_html_screen(compat_mode_t compat_mode, IHTMLScreen **ret)
 565 {
 566     HTMLScreen *screen;
 567
 568     screen = heap_alloc_zero(sizeof(HTMLScreen));
 569     if(!screen)
 570         return E_OUTOFMEMORY;
 571
 572     screen->IHTMLScreen_iface.lpVtbl = &HTMLSreenVtbl;
 573     screen->ref = 1;
 574
 575     init_dispatch(&screen->dispex, (IUnknown*)&screen->IHTMLScreen_iface, &HTMLScreen_dispex, compat_mode);
 576
 577     *ret = &screen->IHTMLScreen_iface;
 578     return S_OK;
 579 }
 580
 581 static inline OmHistory *impl_from_IOmHistory(IOmHistory *iface)
 582 {
 583     return CONTAINING_RECORD(iface, OmHistory, IOmHistory_iface);
 584 }
 585
 586 static HRESULT WINAPI OmHistory_QueryInterface(IOmHistory *iface, REFIID riid, void **ppv)
 587 {
 588     OmHistory *This = impl_from_IOmHistory(iface);
 589
 590     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 591
 592     if(IsEqualGUID(&IID_IUnknown, riid)) {
 593         *ppv = &This->IOmHistory_iface;
 594     }else if(IsEqualGUID(&IID_IOmHistory, riid)) {
 595         *ppv = &This->IOmHistory_iface;
 596     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 597         return *ppv ? S_OK : E_NOINTERFACE;
 598     }else {
 599         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 600         *ppv = NULL;
 601         return E_NOINTERFACE;
 602     }
 603
 604     IUnknown_AddRef((IUnknown*)*ppv);
 605     return S_OK;
 606 }
 607
 608 static ULONG WINAPI OmHistory_AddRef(IOmHistory *iface)
 609 {
 610     OmHistory *This = impl_from_IOmHistory(iface);
 611     LONG ref = InterlockedIncrement(&This->ref);
 612
 613     TRACE("(%p) ref=%d\n", This, ref);
 614
 615     return ref;
 616 }
 617
 618 static ULONG WINAPI OmHistory_Release(IOmHistory *iface)
 619 {
 620     OmHistory *This = impl_from_IOmHistory(iface);
 621     LONG ref = InterlockedDecrement(&This->ref);
 622
 623     TRACE("(%p) ref=%d\n", This, ref);
 624
 625     if(!ref) {
 626         release_dispex(&This->dispex);
 627         heap_free(This);
 628     }
 629
 630     return ref;
 631 }
 632
 633 static HRESULT WINAPI OmHistory_GetTypeInfoCount(IOmHistory *iface, UINT *pctinfo)
 634 {
 635     OmHistory *This = impl_from_IOmHistory(iface);
 636     FIXME("(%p)->(%p)\n", This, pctinfo);
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI OmHistory_GetTypeInfo(IOmHistory *iface, UINT iTInfo,
 641         LCID lcid, ITypeInfo **ppTInfo)
 642 {
 643     OmHistory *This = impl_from_IOmHistory(iface);
 644
 645     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 646 }
 647
 648 static HRESULT WINAPI OmHistory_GetIDsOfNames(IOmHistory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 649         LCID lcid, DISPID *rgDispId)
 650 {
 651     OmHistory *This = impl_from_IOmHistory(iface);
 652
 653     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 654             lcid, rgDispId);
 655 }
 656
 657 static HRESULT WINAPI OmHistory_Invoke(IOmHistory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 658         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 659 {
 660     OmHistory *This = impl_from_IOmHistory(iface);
 661
 662     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 663             pDispParams, pVarResult, pExcepInfo, puArgErr);
 664 }
 665
 666 static HRESULT WINAPI OmHistory_get_length(IOmHistory *iface, short *p)
 667 {
 668     OmHistory *This = impl_from_IOmHistory(iface);
 669     GeckoBrowser *browser = NULL;
 670
 671     TRACE("(%p)->(%p)\n", This, p);
 672
 673     if(This->window && This->window->base.outer_window)
 674         browser = This->window->base.outer_window->browser;
 675
 676     *p = browser->doc->travel_log
 677         ? ITravelLog_CountEntries(browser->doc->travel_log, browser->doc->browser_service)
 678         : 0;
 679     return S_OK;
 680 }
 681
 682 static HRESULT WINAPI OmHistory_back(IOmHistory *iface, VARIANT *pvargdistance)
 683 {
 684     OmHistory *This = impl_from_IOmHistory(iface);
 685     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI OmHistory_forward(IOmHistory *iface, VARIANT *pvargdistance)
 690 {
 691     OmHistory *This = impl_from_IOmHistory(iface);
 692     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 693     return E_NOTIMPL;
 694 }
 695
 696 static HRESULT WINAPI OmHistory_go(IOmHistory *iface, VARIANT *pvargdistance)
 697 {
 698     OmHistory *This = impl_from_IOmHistory(iface);
 699     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 700     return E_NOTIMPL;
 701 }
 702
 703 static const IOmHistoryVtbl OmHistoryVtbl = {
 704     OmHistory_QueryInterface,
 705     OmHistory_AddRef,
 706     OmHistory_Release,
 707     OmHistory_GetTypeInfoCount,
 708     OmHistory_GetTypeInfo,
 709     OmHistory_GetIDsOfNames,
 710     OmHistory_Invoke,
 711     OmHistory_get_length,
 712     OmHistory_back,
 713     OmHistory_forward,
 714     OmHistory_go
 715 };
 716
 717 static const tid_t OmHistory_iface_tids[] = {
 718     IOmHistory_tid,
 719     0
 720 };
 721 static dispex_static_data_t OmHistory_dispex = {
 722     NULL,
 723     DispHTMLHistory_tid,
 724     OmHistory_iface_tids
 725 };
 726
 727
 728 HRESULT create_history(HTMLInnerWindow *window, OmHistory **ret)
 729 {
 730     OmHistory *history;
 731
 732     history = heap_alloc_zero(sizeof(*history));
 733     if(!history)
 734         return E_OUTOFMEMORY;
 735
 736     init_dispatch(&history->dispex, (IUnknown*)&history->IOmHistory_iface, &OmHistory_dispex,
 737                   dispex_compat_mode(&window->event_target.dispex));
 738     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 739     history->ref = 1;
 740
 741     history->window = window;
 742
 743     *ret = history;
 744     return S_OK;
 745 }
 746
 747 struct HTMLPluginsCollection {
 748     DispatchEx dispex;
 749     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 750
 751     LONG ref;
 752
 753     OmNavigator *navigator;
 754 };
 755
 756 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 757 {
 758     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 759 }
 760
 761 static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollection *iface, REFIID riid, void **ppv)
 762 {
 763     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 764
 765     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 766
 767     if(IsEqualGUID(&IID_IUnknown, riid)) {
 768         *ppv = &This->IHTMLPluginsCollection_iface;
 769     }else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
 770         *ppv = &This->IHTMLPluginsCollection_iface;
 771     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 772         return *ppv ? S_OK : E_NOINTERFACE;
 773     }else {
 774         *ppv = NULL;
 775         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 776         return E_NOINTERFACE;
 777     }
 778
 779     IUnknown_AddRef((IUnknown*)*ppv);
 780     return S_OK;
 781 }
 782
 783 static ULONG WINAPI HTMLPluginsCollection_AddRef(IHTMLPluginsCollection *iface)
 784 {
 785     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 786     LONG ref = InterlockedIncrement(&This->ref);
 787
 788     TRACE("(%p) ref=%d\n", This, ref);
 789
 790     return ref;
 791 }
 792
 793 static ULONG WINAPI HTMLPluginsCollection_Release(IHTMLPluginsCollection *iface)
 794 {
 795     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 796     LONG ref = InterlockedDecrement(&This->ref);
 797
 798     TRACE("(%p) ref=%d\n", This, ref);
 799
 800     if(!ref) {
 801         if(This->navigator)
 802             This->navigator->plugins = NULL;
 803         release_dispex(&This->dispex);
 804         heap_free(This);
 805     }
 806
 807     return ref;
 808 }
 809
 810 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfoCount(IHTMLPluginsCollection *iface, UINT *pctinfo)
 811 {
 812     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 813     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 814 }
 815
 816 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfo(IHTMLPluginsCollection *iface, UINT iTInfo,
 817                                               LCID lcid, ITypeInfo **ppTInfo)
 818 {
 819     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 820     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 821 }
 822
 823 static HRESULT WINAPI HTMLPluginsCollection_GetIDsOfNames(IHTMLPluginsCollection *iface, REFIID riid,
 824         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 825 {
 826     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 827     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 828             lcid, rgDispId);
 829 }
 830
 831 static HRESULT WINAPI HTMLPluginsCollection_Invoke(IHTMLPluginsCollection *iface, DISPID dispIdMember,
 832         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 833         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 834 {
 835     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 836     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 837             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 838 }
 839
 840 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 841 {
 842     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 843
 844     TRACE("(%p)->(%p)\n", This, p);
 845
 846     /* IE always returns 0 here */
 847     *p = 0;
 848     return S_OK;
 849 }
 850
 851 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 852 {
 853     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 854
 855     TRACE("(%p)->(%x)\n", This, reload);
 856
 857     /* Nothing to do here. */
 858     return S_OK;
 859 }
 860
 861 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 862     HTMLPluginsCollection_QueryInterface,
 863     HTMLPluginsCollection_AddRef,
 864     HTMLPluginsCollection_Release,
 865     HTMLPluginsCollection_GetTypeInfoCount,
 866     HTMLPluginsCollection_GetTypeInfo,
 867     HTMLPluginsCollection_GetIDsOfNames,
 868     HTMLPluginsCollection_Invoke,
 869     HTMLPluginsCollection_get_length,
 870     HTMLPluginsCollection_refresh
 871 };
 872
 873 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 874     IHTMLPluginsCollection_tid,
 875     0
 876 };
 877 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 878     NULL,
 879     DispCPlugins_tid,
 880     HTMLPluginsCollection_iface_tids
 881 };
 882
 883 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 884 {
 885     HTMLPluginsCollection *col;
 886
 887     col = heap_alloc_zero(sizeof(*col));
 888     if(!col)
 889         return E_OUTOFMEMORY;
 890
 891     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 892     col->ref = 1;
 893     col->navigator = navigator;
 894
 895     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLPluginsCollection_iface,
 896                   &HTMLPluginsCollection_dispex, dispex_compat_mode(&navigator->dispex));
 897
 898     *ret = col;
 899     return S_OK;
 900 }
 901
 902 struct HTMLMimeTypesCollection {
 903     DispatchEx dispex;
 904     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 905
 906     LONG ref;
 907
 908     OmNavigator *navigator;
 909 };
 910
 911 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 912 {
 913     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 914 }
 915
 916 static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesCollection *iface, REFIID riid, void **ppv)
 917 {
 918     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 919
 920     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 921
 922     if(IsEqualGUID(&IID_IUnknown, riid)) {
 923         *ppv = &This->IHTMLMimeTypesCollection_iface;
 924     }else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
 925         *ppv = &This->IHTMLMimeTypesCollection_iface;
 926     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 927         return *ppv ? S_OK : E_NOINTERFACE;
 928     }else {
 929         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 930         *ppv = NULL;
 931         return E_NOINTERFACE;
 932     }
 933
 934     IUnknown_AddRef((IUnknown*)*ppv);
 935     return S_OK;
 936 }
 937
 938 static ULONG WINAPI HTMLMimeTypesCollection_AddRef(IHTMLMimeTypesCollection *iface)
 939 {
 940     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 941     LONG ref = InterlockedIncrement(&This->ref);
 942
 943     TRACE("(%p) ref=%d\n", This, ref);
 944
 945     return ref;
 946 }
 947
 948 static ULONG WINAPI HTMLMimeTypesCollection_Release(IHTMLMimeTypesCollection *iface)
 949 {
 950     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 951     LONG ref = InterlockedDecrement(&This->ref);
 952
 953     TRACE("(%p) ref=%d\n", This, ref);
 954
 955     if(!ref) {
 956         if(This->navigator)
 957             This->navigator->mime_types = NULL;
 958         release_dispex(&This->dispex);
 959         heap_free(This);
 960     }
 961
 962     return ref;
 963 }
 964
 965 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfoCount(IHTMLMimeTypesCollection *iface, UINT *pctinfo)
 966 {
 967     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 968     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 969 }
 970
 971 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfo(IHTMLMimeTypesCollection *iface, UINT iTInfo,
 972                                               LCID lcid, ITypeInfo **ppTInfo)
 973 {
 974     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 975     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 976 }
 977
 978 static HRESULT WINAPI HTMLMimeTypesCollection_GetIDsOfNames(IHTMLMimeTypesCollection *iface, REFIID riid,
 979         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 980 {
 981     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 982     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 983             lcid, rgDispId);
 984 }
 985
 986 static HRESULT WINAPI HTMLMimeTypesCollection_Invoke(IHTMLMimeTypesCollection *iface, DISPID dispIdMember,
 987         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 988         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 989 {
 990     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 991     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 992             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 993 }
 994
 995 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
 996 {
 997     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 998
 999     TRACE("(%p)->(%p)\n", This, p);
1000
1001     /* This is just a stub for compatibility with other browser in IE */
1002     *p = 0;
1003     return S_OK;
1004 }
1005
1006 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
1007     HTMLMimeTypesCollection_QueryInterface,
1008     HTMLMimeTypesCollection_AddRef,
1009     HTMLMimeTypesCollection_Release,
1010     HTMLMimeTypesCollection_GetTypeInfoCount,
1011     HTMLMimeTypesCollection_GetTypeInfo,
1012     HTMLMimeTypesCollection_GetIDsOfNames,
1013     HTMLMimeTypesCollection_Invoke,
1014     HTMLMimeTypesCollection_get_length
1015 };
1016
1017 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
1018     IHTMLMimeTypesCollection_tid,
1019     0
1020 };
1021 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
1022     NULL,
1023     IHTMLMimeTypesCollection_tid,
1024     HTMLMimeTypesCollection_iface_tids
1025 };
1026
1027 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
1028 {
1029     HTMLMimeTypesCollection *col;
1030
1031     col = heap_alloc_zero(sizeof(*col));
1032     if(!col)
1033         return E_OUTOFMEMORY;
1034
1035     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
1036     col->ref = 1;
1037     col->navigator = navigator;
1038
1039     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLMimeTypesCollection_iface,
1040                   &HTMLMimeTypesCollection_dispex, dispex_compat_mode(&navigator->dispex));
1041
1042     *ret = col;
1043     return S_OK;
1044 }
1045
1046 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
1047 {
1048     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
1049 }
1050
1051 static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID riid, void **ppv)
1052 {
1053     OmNavigator *This = impl_from_IOmNavigator(iface);
1054
1055     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1056
1057     if(IsEqualGUID(&IID_IUnknown, riid)) {
1058         *ppv = &This->IOmNavigator_iface;
1059     }else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
1060         *ppv = &This->IOmNavigator_iface;
1061     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1062         return *ppv ? S_OK : E_NOINTERFACE;
1063     }else {
1064         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1065         *ppv = NULL;
1066         return E_NOINTERFACE;
1067     }
1068
1069     IUnknown_AddRef((IUnknown*)*ppv);
1070     return S_OK;
1071 }
1072
1073 static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)
1074 {
1075     OmNavigator *This = impl_from_IOmNavigator(iface);
1076     LONG ref = InterlockedIncrement(&This->ref);
1077
1078     TRACE("(%p) ref=%d\n", This, ref);
1079
1080     return ref;
1081 }
1082
1083 static ULONG WINAPI OmNavigator_Release(IOmNavigator *iface)
1084 {
1085     OmNavigator *This = impl_from_IOmNavigator(iface);
1086     LONG ref = InterlockedDecrement(&This->ref);
1087
1088     TRACE("(%p) ref=%d\n", This, ref);
1089
1090     if(!ref) {
1091         if(This->plugins)
1092             This->plugins->navigator = NULL;
1093         if(This->mime_types)
1094             This->mime_types->navigator = NULL;
1095         release_dispex(&This->dispex);
1096         heap_free(This);
1097     }
1098
1099     return ref;
1100 }
1101
1102 static HRESULT WINAPI OmNavigator_GetTypeInfoCount(IOmNavigator *iface, UINT *pctinfo)
1103 {
1104     OmNavigator *This = impl_from_IOmNavigator(iface);
1105     FIXME("(%p)->(%p)\n", This, pctinfo);
1106     return E_NOTIMPL;
1107 }
1108
1109 static HRESULT WINAPI OmNavigator_GetTypeInfo(IOmNavigator *iface, UINT iTInfo,
1110                                               LCID lcid, ITypeInfo **ppTInfo)
1111 {
1112     OmNavigator *This = impl_from_IOmNavigator(iface);
1113
1114     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1115 }
1116
1117 static HRESULT WINAPI OmNavigator_GetIDsOfNames(IOmNavigator *iface, REFIID riid,
1118                                                 LPOLESTR *rgszNames, UINT cNames,
1119                                                 LCID lcid, DISPID *rgDispId)
1120 {
1121     OmNavigator *This = impl_from_IOmNavigator(iface);
1122
1123     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1124             lcid, rgDispId);
1125 }
1126
1127 static HRESULT WINAPI OmNavigator_Invoke(IOmNavigator *iface, DISPID dispIdMember,
1128                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1129                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1130 {
1131     OmNavigator *This = impl_from_IOmNavigator(iface);
1132
1133     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1134             pDispParams, pVarResult, pExcepInfo, puArgErr);
1135 }
1136
1137 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
1138 {
1139     OmNavigator *This = impl_from_IOmNavigator(iface);
1140
1141     TRACE("(%p)->(%p)\n", This, p);
1142
1143     *p = SysAllocString(L"Mozilla");
1144     return S_OK;
1145 }
1146
1147 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
1148 {
1149     OmNavigator *This = impl_from_IOmNavigator(iface);
1150
1151     TRACE("(%p)->(%p)\n", This, p);
1152
1153     *p = SysAllocString(dispex_compat_mode(&This->dispex) == COMPAT_MODE_IE11
1154                         ? L"Netscape" : L"Microsoft Internet Explorer");
1155     if(!*p)
1156         return E_OUTOFMEMORY;
1157
1158     return S_OK;
1159 }
1160
1161 static unsigned int get_ua_version(OmNavigator *navigator)
1162 {
1163     switch(dispex_compat_mode(&navigator->dispex)) {
1164     case COMPAT_MODE_QUIRKS:
1165     case COMPAT_MODE_IE5:
1166     case COMPAT_MODE_IE7:
1167         return 7;
1168     case COMPAT_MODE_IE8:
1169         return 8;
1170     case COMPAT_MODE_IE9:
1171         return 9;
1172     case COMPAT_MODE_IE10:
1173         return 10;
1174     case COMPAT_MODE_IE11:
1175         return 11;
1176     }
1177     assert(0);
1178     return 0;
1179 }
1180
1181 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
1182 {
1183     OmNavigator *This = impl_from_IOmNavigator(iface);
1184
1185     char user_agent[512];
1186     DWORD size;
1187     HRESULT hres;
1188     const unsigned skip_prefix = 8; /* strlen("Mozilla/") */
1189
1190     TRACE("(%p)->(%p)\n", This, p);
1191
1192     size = sizeof(user_agent);
1193     hres = ObtainUserAgentString(get_ua_version(This), user_agent, &size);
1194     if(FAILED(hres))
1195         return hres;
1196
1197     if(size <= skip_prefix) {
1198         *p = NULL;
1199         return S_OK;
1200     }
1201
1202     size = MultiByteToWideChar(CP_ACP, 0, user_agent + skip_prefix, -1, NULL, 0);
1203     *p = SysAllocStringLen(NULL, size-1);
1204     if(!*p)
1205         return E_OUTOFMEMORY;
1206
1207     MultiByteToWideChar(CP_ACP, 0, user_agent + skip_prefix, -1, *p, size);
1208     return S_OK;
1209 }
1210
1211 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
1212 {
1213     OmNavigator *This = impl_from_IOmNavigator(iface);
1214     char user_agent[512];
1215     DWORD size;
1216     HRESULT hres;
1217
1218     TRACE("(%p)->(%p)\n", This, p);
1219
1220     size = sizeof(user_agent);
1221     hres = ObtainUserAgentString(get_ua_version(This), user_agent, &size);
1222     if(FAILED(hres))
1223         return hres;
1224
1225     size = MultiByteToWideChar(CP_ACP, 0, user_agent, -1, NULL, 0);
1226     *p = SysAllocStringLen(NULL, size-1);
1227     if(!*p)
1228         return E_OUTOFMEMORY;
1229
1230     MultiByteToWideChar(CP_ACP, 0, user_agent, -1, *p, size);
1231     return S_OK;
1232 }
1233
1234 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1235 {
1236     OmNavigator *This = impl_from_IOmNavigator(iface);
1237
1238     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
1239
1240     *enabled = VARIANT_TRUE;
1241     return S_OK;
1242 }
1243
1244 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1245 {
1246     OmNavigator *This = impl_from_IOmNavigator(iface);
1247     FIXME("(%p)->(%p)\n", This, enabled);
1248     return E_NOTIMPL;
1249 }
1250
1251 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
1252 {
1253     OmNavigator *This = impl_from_IOmNavigator(iface);
1254
1255     TRACE("(%p)->(%p)\n", This, p);
1256
1257     if(!This->mime_types) {
1258         HRESULT hres;
1259
1260         hres = create_mime_types_collection(This, &This->mime_types);
1261         if(FAILED(hres))
1262             return hres;
1263     }else {
1264         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
1265     }
1266
1267     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
1268     return S_OK;
1269 }
1270
1271 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
1272 {
1273     OmNavigator *This = impl_from_IOmNavigator(iface);
1274
1275     TRACE("(%p)->(%p)\n", This, p);
1276
1277     if(!This->plugins) {
1278         HRESULT hres;
1279
1280         hres = create_plugins_collection(This, &This->plugins);
1281         if(FAILED(hres))
1282             return hres;
1283     }else {
1284         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
1285     }
1286
1287     *p = &This->plugins->IHTMLPluginsCollection_iface;
1288     return S_OK;
1289 }
1290
1291 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
1292 {
1293     OmNavigator *This = impl_from_IOmNavigator(iface);
1294
1295     WARN("(%p)->(%p) semi-stub\n", This, p);
1296
1297     *p = VARIANT_TRUE;
1298     return S_OK;
1299 }
1300
1301 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1302 {
1303     OmNavigator *This = impl_from_IOmNavigator(iface);
1304     FIXME("(%p)->(%p)\n", This, p);
1305     return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
1309 {
1310     OmNavigator *This = impl_from_IOmNavigator(iface);
1311
1312     TRACE("(%p)->(%p)\n", This, String);
1313
1314     if(!String)
1315         return E_INVALIDARG;
1316
1317     *String = SysAllocString(dispex_compat_mode(&This->dispex) < COMPAT_MODE_IE9
1318                              ? L"[object]" : L"[object Navigator]");
1319     return *String ? S_OK : E_OUTOFMEMORY;
1320 }
1321
1322 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
1323 {
1324     OmNavigator *This = impl_from_IOmNavigator(iface);
1325
1326     TRACE("(%p)->(%p)\n", This, p);
1327
1328 #ifdef _WIN64
1329     *p = SysAllocString(L"x64");
1330 #else
1331     *p = SysAllocString(L"x86");
1332 #endif
1333     return *p ? S_OK : E_OUTOFMEMORY;
1334 }
1335
1336 static HRESULT get_language_string(LCID lcid, BSTR *p)
1337 {
1338     BSTR ret;
1339     int len;
1340
1341     len = LCIDToLocaleName(lcid, NULL, 0, 0);
1342     if(!len) {
1343         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
1344         return E_FAIL;
1345     }
1346
1347     ret = SysAllocStringLen(NULL, len-1);
1348     if(!ret)
1349         return E_OUTOFMEMORY;
1350
1351     len = LCIDToLocaleName(lcid, ret, len, 0);
1352     if(!len) {
1353         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
1354         SysFreeString(ret);
1355         return E_FAIL;
1356     }
1357
1358     *p = ret;
1359     return S_OK;
1360 }
1361
1362 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1363 {
1364     OmNavigator *This = impl_from_IOmNavigator(iface);
1365
1366     TRACE("(%p)->(%p)\n", This, p);
1367
1368     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1369 }
1370
1371 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1372 {
1373     OmNavigator *This = impl_from_IOmNavigator(iface);
1374
1375     TRACE("(%p)->(%p)\n", This, p);
1376
1377     return get_language_string(GetUserDefaultUILanguage(), p);
1378 }
1379
1380 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1381 {
1382     OmNavigator *This = impl_from_IOmNavigator(iface);
1383
1384     TRACE("(%p)->(%p)\n", This, p);
1385
1386     return get_language_string(LOCALE_USER_DEFAULT, p);
1387 }
1388
1389 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1390 {
1391     OmNavigator *This = impl_from_IOmNavigator(iface);
1392
1393     TRACE("(%p)->(%p)\n", This, p);
1394
1395 #ifdef _WIN64
1396     *p = SysAllocString(L"Win64");
1397 #else
1398     *p = SysAllocString(L"Win32");
1399 #endif
1400     return S_OK;
1401 }
1402
1403 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1404 {
1405     OmNavigator *This = impl_from_IOmNavigator(iface);
1406
1407     TRACE("(%p)->(%p)\n", This, p);
1408
1409     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1410     *p = SysAllocString(L"0");
1411     return S_OK;
1412 }
1413
1414 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1415 {
1416     OmNavigator *This = impl_from_IOmNavigator(iface);
1417     FIXME("(%p)->(%p)\n", This, p);
1418     return E_NOTIMPL;
1419 }
1420
1421 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1422 {
1423     OmNavigator *This = impl_from_IOmNavigator(iface);
1424
1425     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1426
1427     *p = VARIANT_TRUE;
1428     return S_OK;
1429 }
1430
1431 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1432 {
1433     OmNavigator *This = impl_from_IOmNavigator(iface);
1434     FIXME("(%p)->(%p)\n", This, p);
1435     return E_NOTIMPL;
1436 }
1437
1438 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1439     OmNavigator_QueryInterface,
1440     OmNavigator_AddRef,
1441     OmNavigator_Release,
1442     OmNavigator_GetTypeInfoCount,
1443     OmNavigator_GetTypeInfo,
1444     OmNavigator_GetIDsOfNames,
1445     OmNavigator_Invoke,
1446     OmNavigator_get_appCodeName,
1447     OmNavigator_get_appName,
1448     OmNavigator_get_appVersion,
1449     OmNavigator_get_userAgent,
1450     OmNavigator_javaEnabled,
1451     OmNavigator_taintEnabled,
1452     OmNavigator_get_mimeTypes,
1453     OmNavigator_get_plugins,
1454     OmNavigator_get_cookieEnabled,
1455     OmNavigator_get_opsProfile,
1456     OmNavigator_toString,
1457     OmNavigator_get_cpuClass,
1458     OmNavigator_get_systemLanguage,
1459     OmNavigator_get_browserLanguage,
1460     OmNavigator_get_userLanguage,
1461     OmNavigator_get_platform,
1462     OmNavigator_get_appMinorVersion,
1463     OmNavigator_get_connectionSpeed,
1464     OmNavigator_get_onLine,
1465     OmNavigator_get_userProfile
1466 };
1467
1468 static const tid_t OmNavigator_iface_tids[] = {
1469     IOmNavigator_tid,
1470     0
1471 };
1472 static dispex_static_data_t OmNavigator_dispex = {
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=%d\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=%d\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     FIXME("(%p)->(%p)\n", This, string);
1805     return E_NOTIMPL;
1806 }
1807
1808 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1809 {
1810     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1811     FIXME("(%p)->(%p)\n", This, p);
1812     return E_NOTIMPL;
1813 }
1814
1815 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1816     HTMLPerformanceTiming_QueryInterface,
1817     HTMLPerformanceTiming_AddRef,
1818     HTMLPerformanceTiming_Release,
1819     HTMLPerformanceTiming_GetTypeInfoCount,
1820     HTMLPerformanceTiming_GetTypeInfo,
1821     HTMLPerformanceTiming_GetIDsOfNames,
1822     HTMLPerformanceTiming_Invoke,
1823     HTMLPerformanceTiming_get_navigationStart,
1824     HTMLPerformanceTiming_get_unloadEventStart,
1825     HTMLPerformanceTiming_get_unloadEventEnd,
1826     HTMLPerformanceTiming_get_redirectStart,
1827     HTMLPerformanceTiming_get_redirectEnd,
1828     HTMLPerformanceTiming_get_fetchStart,
1829     HTMLPerformanceTiming_get_domainLookupStart,
1830     HTMLPerformanceTiming_get_domainLookupEnd,
1831     HTMLPerformanceTiming_get_connectStart,
1832     HTMLPerformanceTiming_get_connectEnd,
1833     HTMLPerformanceTiming_get_requestStart,
1834     HTMLPerformanceTiming_get_responseStart,
1835     HTMLPerformanceTiming_get_responseEnd,
1836     HTMLPerformanceTiming_get_domLoading,
1837     HTMLPerformanceTiming_get_domInteractive,
1838     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1839     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1840     HTMLPerformanceTiming_get_domComplete,
1841     HTMLPerformanceTiming_get_loadEventStart,
1842     HTMLPerformanceTiming_get_loadEventEnd,
1843     HTMLPerformanceTiming_get_msFirstPaint,
1844     HTMLPerformanceTiming_toString,
1845     HTMLPerformanceTiming_toJSON
1846 };
1847
1848 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1849     IHTMLPerformanceTiming_tid,
1850     0
1851 };
1852 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1853     NULL,
1854     IHTMLPerformanceTiming_tid,
1855     HTMLPerformanceTiming_iface_tids
1856 };
1857
1858 typedef struct {
1859     DispatchEx dispex;
1860     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1861
1862     LONG ref;
1863 } HTMLPerformanceNavigation;
1864
1865 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1866 {
1867     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1868 }
1869
1870 static HRESULT WINAPI HTMLPerformanceNavigation_QueryInterface(IHTMLPerformanceNavigation *iface, REFIID riid, void **ppv)
1871 {
1872     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1873
1874     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1875
1876     if(IsEqualGUID(&IID_IUnknown, riid)) {
1877         *ppv = &This->IHTMLPerformanceNavigation_iface;
1878     }else if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid)) {
1879         *ppv = &This->IHTMLPerformanceNavigation_iface;
1880     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1881         return *ppv ? S_OK : E_NOINTERFACE;
1882     }else {
1883         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1884         *ppv = NULL;
1885         return E_NOINTERFACE;
1886     }
1887
1888     IUnknown_AddRef((IUnknown*)*ppv);
1889     return S_OK;
1890 }
1891
1892 static ULONG WINAPI HTMLPerformanceNavigation_AddRef(IHTMLPerformanceNavigation *iface)
1893 {
1894     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1895     LONG ref = InterlockedIncrement(&This->ref);
1896
1897     TRACE("(%p) ref=%d\n", This, ref);
1898
1899     return ref;
1900 }
1901
1902 static ULONG WINAPI HTMLPerformanceNavigation_Release(IHTMLPerformanceNavigation *iface)
1903 {
1904     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1905     LONG ref = InterlockedDecrement(&This->ref);
1906
1907     TRACE("(%p) ref=%d\n", This, ref);
1908
1909     if(!ref) {
1910         release_dispex(&This->dispex);
1911         heap_free(This);
1912     }
1913
1914     return ref;
1915 }
1916
1917 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfoCount(IHTMLPerformanceNavigation *iface, UINT *pctinfo)
1918 {
1919     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1920     FIXME("(%p)->(%p)\n", This, pctinfo);
1921     return E_NOTIMPL;
1922 }
1923
1924 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfo(IHTMLPerformanceNavigation *iface, UINT iTInfo,
1925                                               LCID lcid, ITypeInfo **ppTInfo)
1926 {
1927     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1928
1929     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1930 }
1931
1932 static HRESULT WINAPI HTMLPerformanceNavigation_GetIDsOfNames(IHTMLPerformanceNavigation *iface, REFIID riid,
1933                                                           LPOLESTR *rgszNames, UINT cNames,
1934                                                           LCID lcid, DISPID *rgDispId)
1935 {
1936     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1937
1938     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1939             lcid, rgDispId);
1940 }
1941
1942 static HRESULT WINAPI HTMLPerformanceNavigation_Invoke(IHTMLPerformanceNavigation *iface, DISPID dispIdMember,
1943                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1944                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1945 {
1946     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1947
1948     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1949             pDispParams, pVarResult, pExcepInfo, puArgErr);
1950 }
1951
1952 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
1953 {
1954     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1955
1956     FIXME("(%p)->(%p) returning TYPE_NAVIGATE\n", This, p);
1957
1958     *p = 0; /* TYPE_NAVIGATE */
1959     return S_OK;
1960 }
1961
1962 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
1963 {
1964     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1965     FIXME("(%p)->(%p)\n", This, p);
1966     return E_NOTIMPL;
1967 }
1968
1969 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
1970 {
1971     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1972     FIXME("(%p)->(%p)\n", This, string);
1973     return E_NOTIMPL;
1974 }
1975
1976 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
1977 {
1978     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1979     FIXME("(%p)->(%p)\n", This, p);
1980     return E_NOTIMPL;
1981 }
1982
1983 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
1984     HTMLPerformanceNavigation_QueryInterface,
1985     HTMLPerformanceNavigation_AddRef,
1986     HTMLPerformanceNavigation_Release,
1987     HTMLPerformanceNavigation_GetTypeInfoCount,
1988     HTMLPerformanceNavigation_GetTypeInfo,
1989     HTMLPerformanceNavigation_GetIDsOfNames,
1990     HTMLPerformanceNavigation_Invoke,
1991     HTMLPerformanceNavigation_get_type,
1992     HTMLPerformanceNavigation_get_redirectCount,
1993     HTMLPerformanceNavigation_toString,
1994     HTMLPerformanceNavigation_toJSON
1995 };
1996
1997 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
1998     IHTMLPerformanceNavigation_tid,
1999     0
2000 };
2001 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
2002     NULL,
2003     IHTMLPerformanceNavigation_tid,
2004     HTMLPerformanceNavigation_iface_tids
2005 };
2006
2007 typedef struct {
2008     DispatchEx dispex;
2009     IHTMLPerformance IHTMLPerformance_iface;
2010
2011     LONG ref;
2012
2013     IHTMLPerformanceNavigation *navigation;
2014     IHTMLPerformanceTiming *timing;
2015 } HTMLPerformance;
2016
2017 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
2018 {
2019     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
2020 }
2021
2022 static HRESULT WINAPI HTMLPerformance_QueryInterface(IHTMLPerformance *iface, REFIID riid, void **ppv)
2023 {
2024     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2025
2026     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2027
2028     if(IsEqualGUID(&IID_IUnknown, riid)) {
2029         *ppv = &This->IHTMLPerformance_iface;
2030     }else if(IsEqualGUID(&IID_IHTMLPerformance, riid)) {
2031         *ppv = &This->IHTMLPerformance_iface;
2032     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2033         return *ppv ? S_OK : E_NOINTERFACE;
2034     }else {
2035         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2036         *ppv = NULL;
2037         return E_NOINTERFACE;
2038     }
2039
2040     IUnknown_AddRef((IUnknown*)*ppv);
2041     return S_OK;
2042 }
2043
2044 static ULONG WINAPI HTMLPerformance_AddRef(IHTMLPerformance *iface)
2045 {
2046     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2047     LONG ref = InterlockedIncrement(&This->ref);
2048
2049     TRACE("(%p) ref=%d\n", This, ref);
2050
2051     return ref;
2052 }
2053
2054 static ULONG WINAPI HTMLPerformance_Release(IHTMLPerformance *iface)
2055 {
2056     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2057     LONG ref = InterlockedDecrement(&This->ref);
2058
2059     TRACE("(%p) ref=%d\n", This, ref);
2060
2061     if(!ref) {
2062         if(This->timing)
2063             IHTMLPerformanceTiming_Release(This->timing);
2064         if(This->navigation)
2065             IHTMLPerformanceNavigation_Release(This->navigation);
2066         release_dispex(&This->dispex);
2067         heap_free(This);
2068     }
2069
2070     return ref;
2071 }
2072
2073 static HRESULT WINAPI HTMLPerformance_GetTypeInfoCount(IHTMLPerformance *iface, UINT *pctinfo)
2074 {
2075     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2076     FIXME("(%p)->(%p)\n", This, pctinfo);
2077     return E_NOTIMPL;
2078 }
2079
2080 static HRESULT WINAPI HTMLPerformance_GetTypeInfo(IHTMLPerformance *iface, UINT iTInfo,
2081                                                   LCID lcid, ITypeInfo **ppTInfo)
2082 {
2083     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2084
2085     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2086 }
2087
2088 static HRESULT WINAPI HTMLPerformance_GetIDsOfNames(IHTMLPerformance *iface, REFIID riid,
2089                                                     LPOLESTR *rgszNames, UINT cNames,
2090                                                     LCID lcid, DISPID *rgDispId)
2091 {
2092     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2093
2094     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2095             lcid, rgDispId);
2096 }
2097
2098 static HRESULT WINAPI HTMLPerformance_Invoke(IHTMLPerformance *iface, DISPID dispIdMember,
2099                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2100                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2101 {
2102     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2103
2104     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2105             pDispParams, pVarResult, pExcepInfo, puArgErr);
2106 }
2107
2108 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
2109                                                      IHTMLPerformanceNavigation **p)
2110 {
2111     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2112
2113     TRACE("(%p)->(%p)\n", This, p);
2114
2115     if(!This->navigation) {
2116         HTMLPerformanceNavigation *navigation;
2117
2118         navigation = heap_alloc_zero(sizeof(*navigation));
2119         if(!navigation)
2120             return E_OUTOFMEMORY;
2121
2122         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
2123         navigation->ref = 1;
2124         init_dispatch(&navigation->dispex, (IUnknown*)&navigation->IHTMLPerformanceNavigation_iface,
2125                       &HTMLPerformanceNavigation_dispex, dispex_compat_mode(&This->dispex));
2126
2127         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
2128     }
2129
2130     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
2131     return S_OK;
2132 }
2133
2134 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
2135 {
2136     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2137
2138     TRACE("(%p)->(%p)\n", This, p);
2139
2140     if(!This->timing) {
2141         HTMLPerformanceTiming *timing;
2142
2143         timing = heap_alloc_zero(sizeof(*timing));
2144         if(!timing)
2145             return E_OUTOFMEMORY;
2146
2147         timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
2148         timing->ref = 1;
2149         init_dispatch(&timing->dispex, (IUnknown*)&timing->IHTMLPerformanceTiming_iface,
2150                       &HTMLPerformanceTiming_dispex, dispex_compat_mode(&This->dispex));
2151
2152         This->timing = &timing->IHTMLPerformanceTiming_iface;
2153     }
2154
2155     IHTMLPerformanceTiming_AddRef(*p = This->timing);
2156     return S_OK;
2157 }
2158
2159 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
2160 {
2161     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2162     FIXME("(%p)->(%p)\n", This, string);
2163     return E_NOTIMPL;
2164 }
2165
2166 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
2167 {
2168     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2169     FIXME("(%p)->(%p)\n", This, var);
2170     return E_NOTIMPL;
2171 }
2172
2173 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
2174     HTMLPerformance_QueryInterface,
2175     HTMLPerformance_AddRef,
2176     HTMLPerformance_Release,
2177     HTMLPerformance_GetTypeInfoCount,
2178     HTMLPerformance_GetTypeInfo,
2179     HTMLPerformance_GetIDsOfNames,
2180     HTMLPerformance_Invoke,
2181     HTMLPerformance_get_navigation,
2182     HTMLPerformance_get_timing,
2183     HTMLPerformance_toString,
2184     HTMLPerformance_toJSON
2185 };
2186
2187 static const tid_t HTMLPerformance_iface_tids[] = {
2188     IHTMLPerformance_tid,
2189     0
2190 };
2191 static dispex_static_data_t HTMLPerformance_dispex = {
2192     NULL,
2193     IHTMLPerformance_tid,
2194     HTMLPerformance_iface_tids
2195 };
2196
2197 HRESULT create_performance(compat_mode_t compat_mode, IHTMLPerformance **ret)
2198 {
2199     HTMLPerformance *performance;
2200
2201     performance = heap_alloc_zero(sizeof(*performance));
2202     if(!performance)
2203         return E_OUTOFMEMORY;
2204
2205     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
2206     performance->ref = 1;
2207
2208     init_dispatch(&performance->dispex, (IUnknown*)&performance->IHTMLPerformance_iface,
2209                   &HTMLPerformance_dispex, compat_mode);
2210
2211     *ret = &performance->IHTMLPerformance_iface;
2212     return S_OK;
2213 }
2214
2215 typedef struct {
2216     DispatchEx dispex;
2217     IHTMLNamespaceCollection IHTMLNamespaceCollection_iface;
2218
2219     LONG ref;
2220 } HTMLNamespaceCollection;
2221
2222 static inline HTMLNamespaceCollection *impl_from_IHTMLNamespaceCollection(IHTMLNamespaceCollection *iface)
2223 {
2224     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, IHTMLNamespaceCollection_iface);
2225 }
2226
2227 static HRESULT WINAPI HTMLNamespaceCollection_QueryInterface(IHTMLNamespaceCollection *iface, REFIID riid, void **ppv)
2228 {
2229     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2230
2231     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2232
2233     if(IsEqualGUID(&IID_IUnknown, riid)) {
2234         *ppv = &This->IHTMLNamespaceCollection_iface;
2235     }else if(IsEqualGUID(&IID_IHTMLNamespaceCollection, riid)) {
2236         *ppv = &This->IHTMLNamespaceCollection_iface;
2237     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2238         return *ppv ? S_OK : E_NOINTERFACE;
2239     }else {
2240         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2241         *ppv = NULL;
2242         return E_NOINTERFACE;
2243     }
2244
2245     IUnknown_AddRef((IUnknown*)*ppv);
2246     return S_OK;
2247 }
2248
2249 static ULONG WINAPI HTMLNamespaceCollection_AddRef(IHTMLNamespaceCollection *iface)
2250 {
2251     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2252     LONG ref = InterlockedIncrement(&This->ref);
2253
2254     TRACE("(%p) ref=%d\n", This, ref);
2255
2256     return ref;
2257 }
2258
2259 static ULONG WINAPI HTMLNamespaceCollection_Release(IHTMLNamespaceCollection *iface)
2260 {
2261     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2262     LONG ref = InterlockedDecrement(&This->ref);
2263
2264     TRACE("(%p) ref=%d\n", This, ref);
2265
2266     if(!ref) {
2267         release_dispex(&This->dispex);
2268         heap_free(This);
2269     }
2270
2271     return ref;
2272 }
2273
2274 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfoCount(IHTMLNamespaceCollection *iface, UINT *pctinfo)
2275 {
2276     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2277     FIXME("(%p)->(%p)\n", This, pctinfo);
2278     return E_NOTIMPL;
2279 }
2280
2281 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfo(IHTMLNamespaceCollection *iface, UINT iTInfo,
2282                                                   LCID lcid, ITypeInfo **ppTInfo)
2283 {
2284     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2285
2286     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2287 }
2288
2289 static HRESULT WINAPI HTMLNamespaceCollection_GetIDsOfNames(IHTMLNamespaceCollection *iface, REFIID riid,
2290                                                     LPOLESTR *rgszNames, UINT cNames,
2291                                                     LCID lcid, DISPID *rgDispId)
2292 {
2293     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2294
2295     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2296             lcid, rgDispId);
2297 }
2298
2299 static HRESULT WINAPI HTMLNamespaceCollection_Invoke(IHTMLNamespaceCollection *iface, DISPID dispIdMember,
2300                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2301                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2302 {
2303     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2304
2305     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2306             pDispParams, pVarResult, pExcepInfo, puArgErr);
2307 }
2308
2309 static HRESULT WINAPI HTMLNamespaceCollection_get_length(IHTMLNamespaceCollection *iface, LONG *p)
2310 {
2311     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2312     FIXME("(%p)->(%p) returning 0\n", This, p);
2313     *p = 0;
2314     return S_OK;
2315 }
2316
2317 static HRESULT WINAPI HTMLNamespaceCollection_item(IHTMLNamespaceCollection *iface, VARIANT index, IDispatch **p)
2318 {
2319     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2320     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(&index), p);
2321     return E_NOTIMPL;
2322 }
2323
2324 static HRESULT WINAPI HTMLNamespaceCollection_add(IHTMLNamespaceCollection *iface, BSTR namespace, BSTR urn,
2325                                                   VARIANT implementation_url, IDispatch **p)
2326 {
2327     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2328     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(namespace), debugstr_w(urn), debugstr_variant(&implementation_url), p);
2329     return E_NOTIMPL;
2330 }
2331
2332 static const IHTMLNamespaceCollectionVtbl HTMLNamespaceCollectionVtbl = {
2333     HTMLNamespaceCollection_QueryInterface,
2334     HTMLNamespaceCollection_AddRef,
2335     HTMLNamespaceCollection_Release,
2336     HTMLNamespaceCollection_GetTypeInfoCount,
2337     HTMLNamespaceCollection_GetTypeInfo,
2338     HTMLNamespaceCollection_GetIDsOfNames,
2339     HTMLNamespaceCollection_Invoke,
2340     HTMLNamespaceCollection_get_length,
2341     HTMLNamespaceCollection_item,
2342     HTMLNamespaceCollection_add
2343 };
2344
2345 static const tid_t HTMLNamespaceCollection_iface_tids[] = {
2346     IHTMLNamespaceCollection_tid,
2347     0
2348 };
2349 static dispex_static_data_t HTMLNamespaceCollection_dispex = {
2350     NULL,
2351     DispHTMLNamespaceCollection_tid,
2352     HTMLNamespaceCollection_iface_tids
2353 };
2354
2355 HRESULT create_namespace_collection(compat_mode_t compat_mode, IHTMLNamespaceCollection **ret)
2356 {
2357     HTMLNamespaceCollection *namespaces;
2358
2359     if (!(namespaces = heap_alloc_zero(sizeof(*namespaces))))
2360         return E_OUTOFMEMORY;
2361
2362     namespaces->IHTMLNamespaceCollection_iface.lpVtbl = &HTMLNamespaceCollectionVtbl;
2363     namespaces->ref = 1;
2364     init_dispatch(&namespaces->dispex, (IUnknown*)&namespaces->IHTMLNamespaceCollection_iface,
2365                   &HTMLNamespaceCollection_dispex, compat_mode);
2366     *ret = &namespaces->IHTMLNamespaceCollection_iface;
2367     return S_OK;
2368 }