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_dispex_with_compat_mode(&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 HTMLScreen_Create(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_dispex(&screen->dispex, (IUnknown*)&screen->IHTMLScreen_iface, &HTMLScreen_dispex);
 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_dispex(&history->dispex, (IUnknown*)&history->IOmHistory_iface, &OmHistory_dispex);
 737     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 738     history->ref = 1;
 739
 740     history->window = window;
 741
 742     *ret = history;
 743     return S_OK;
 744 }
 745
 746 struct HTMLPluginsCollection {
 747     DispatchEx dispex;
 748     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 749
 750     LONG ref;
 751
 752     OmNavigator *navigator;
 753 };
 754
 755 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 756 {
 757     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 758 }
 759
 760 static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollection *iface, REFIID riid, void **ppv)
 761 {
 762     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 763
 764     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 765
 766     if(IsEqualGUID(&IID_IUnknown, riid)) {
 767         *ppv = &This->IHTMLPluginsCollection_iface;
 768     }else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
 769         *ppv = &This->IHTMLPluginsCollection_iface;
 770     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 771         return *ppv ? S_OK : E_NOINTERFACE;
 772     }else {
 773         *ppv = NULL;
 774         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 775         return E_NOINTERFACE;
 776     }
 777
 778     IUnknown_AddRef((IUnknown*)*ppv);
 779     return S_OK;
 780 }
 781
 782 static ULONG WINAPI HTMLPluginsCollection_AddRef(IHTMLPluginsCollection *iface)
 783 {
 784     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 785     LONG ref = InterlockedIncrement(&This->ref);
 786
 787     TRACE("(%p) ref=%d\n", This, ref);
 788
 789     return ref;
 790 }
 791
 792 static ULONG WINAPI HTMLPluginsCollection_Release(IHTMLPluginsCollection *iface)
 793 {
 794     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 795     LONG ref = InterlockedDecrement(&This->ref);
 796
 797     TRACE("(%p) ref=%d\n", This, ref);
 798
 799     if(!ref) {
 800         if(This->navigator)
 801             This->navigator->plugins = NULL;
 802         release_dispex(&This->dispex);
 803         heap_free(This);
 804     }
 805
 806     return ref;
 807 }
 808
 809 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfoCount(IHTMLPluginsCollection *iface, UINT *pctinfo)
 810 {
 811     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 812     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 813 }
 814
 815 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfo(IHTMLPluginsCollection *iface, UINT iTInfo,
 816                                               LCID lcid, ITypeInfo **ppTInfo)
 817 {
 818     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 819     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 820 }
 821
 822 static HRESULT WINAPI HTMLPluginsCollection_GetIDsOfNames(IHTMLPluginsCollection *iface, REFIID riid,
 823         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 824 {
 825     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 826     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 827             lcid, rgDispId);
 828 }
 829
 830 static HRESULT WINAPI HTMLPluginsCollection_Invoke(IHTMLPluginsCollection *iface, DISPID dispIdMember,
 831         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 832         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 833 {
 834     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 835     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 836             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 837 }
 838
 839 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 840 {
 841     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 842
 843     TRACE("(%p)->(%p)\n", This, p);
 844
 845     /* IE always returns 0 here */
 846     *p = 0;
 847     return S_OK;
 848 }
 849
 850 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 851 {
 852     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 853
 854     TRACE("(%p)->(%x)\n", This, reload);
 855
 856     /* Nothing to do here. */
 857     return S_OK;
 858 }
 859
 860 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 861     HTMLPluginsCollection_QueryInterface,
 862     HTMLPluginsCollection_AddRef,
 863     HTMLPluginsCollection_Release,
 864     HTMLPluginsCollection_GetTypeInfoCount,
 865     HTMLPluginsCollection_GetTypeInfo,
 866     HTMLPluginsCollection_GetIDsOfNames,
 867     HTMLPluginsCollection_Invoke,
 868     HTMLPluginsCollection_get_length,
 869     HTMLPluginsCollection_refresh
 870 };
 871
 872 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 873     IHTMLPluginsCollection_tid,
 874     0
 875 };
 876 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 877     NULL,
 878     DispCPlugins_tid,
 879     HTMLPluginsCollection_iface_tids
 880 };
 881
 882 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 883 {
 884     HTMLPluginsCollection *col;
 885
 886     col = heap_alloc_zero(sizeof(*col));
 887     if(!col)
 888         return E_OUTOFMEMORY;
 889
 890     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 891     col->ref = 1;
 892     col->navigator = navigator;
 893
 894     init_dispex(&col->dispex, (IUnknown*)&col->IHTMLPluginsCollection_iface,
 895                 &HTMLPluginsCollection_dispex);
 896
 897     *ret = col;
 898     return S_OK;
 899 }
 900
 901 struct HTMLMimeTypesCollection {
 902     DispatchEx dispex;
 903     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 904
 905     LONG ref;
 906
 907     OmNavigator *navigator;
 908 };
 909
 910 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 911 {
 912     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 913 }
 914
 915 static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesCollection *iface, REFIID riid, void **ppv)
 916 {
 917     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 918
 919     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 920
 921     if(IsEqualGUID(&IID_IUnknown, riid)) {
 922         *ppv = &This->IHTMLMimeTypesCollection_iface;
 923     }else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
 924         *ppv = &This->IHTMLMimeTypesCollection_iface;
 925     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 926         return *ppv ? S_OK : E_NOINTERFACE;
 927     }else {
 928         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 929         *ppv = NULL;
 930         return E_NOINTERFACE;
 931     }
 932
 933     IUnknown_AddRef((IUnknown*)*ppv);
 934     return S_OK;
 935 }
 936
 937 static ULONG WINAPI HTMLMimeTypesCollection_AddRef(IHTMLMimeTypesCollection *iface)
 938 {
 939     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 940     LONG ref = InterlockedIncrement(&This->ref);
 941
 942     TRACE("(%p) ref=%d\n", This, ref);
 943
 944     return ref;
 945 }
 946
 947 static ULONG WINAPI HTMLMimeTypesCollection_Release(IHTMLMimeTypesCollection *iface)
 948 {
 949     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 950     LONG ref = InterlockedDecrement(&This->ref);
 951
 952     TRACE("(%p) ref=%d\n", This, ref);
 953
 954     if(!ref) {
 955         if(This->navigator)
 956             This->navigator->mime_types = NULL;
 957         release_dispex(&This->dispex);
 958         heap_free(This);
 959     }
 960
 961     return ref;
 962 }
 963
 964 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfoCount(IHTMLMimeTypesCollection *iface, UINT *pctinfo)
 965 {
 966     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 967     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 968 }
 969
 970 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfo(IHTMLMimeTypesCollection *iface, UINT iTInfo,
 971                                               LCID lcid, ITypeInfo **ppTInfo)
 972 {
 973     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 974     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 975 }
 976
 977 static HRESULT WINAPI HTMLMimeTypesCollection_GetIDsOfNames(IHTMLMimeTypesCollection *iface, REFIID riid,
 978         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 979 {
 980     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 981     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 982             lcid, rgDispId);
 983 }
 984
 985 static HRESULT WINAPI HTMLMimeTypesCollection_Invoke(IHTMLMimeTypesCollection *iface, DISPID dispIdMember,
 986         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 987         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 988 {
 989     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 990     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 991             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 992 }
 993
 994 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
 995 {
 996     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 997
 998     TRACE("(%p)->(%p)\n", This, p);
 999
1000     /* This is just a stub for compatibility with other browser in IE */
1001     *p = 0;
1002     return S_OK;
1003 }
1004
1005 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
1006     HTMLMimeTypesCollection_QueryInterface,
1007     HTMLMimeTypesCollection_AddRef,
1008     HTMLMimeTypesCollection_Release,
1009     HTMLMimeTypesCollection_GetTypeInfoCount,
1010     HTMLMimeTypesCollection_GetTypeInfo,
1011     HTMLMimeTypesCollection_GetIDsOfNames,
1012     HTMLMimeTypesCollection_Invoke,
1013     HTMLMimeTypesCollection_get_length
1014 };
1015
1016 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
1017     IHTMLMimeTypesCollection_tid,
1018     0
1019 };
1020 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
1021     NULL,
1022     IHTMLMimeTypesCollection_tid,
1023     HTMLMimeTypesCollection_iface_tids
1024 };
1025
1026 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
1027 {
1028     HTMLMimeTypesCollection *col;
1029
1030     col = heap_alloc_zero(sizeof(*col));
1031     if(!col)
1032         return E_OUTOFMEMORY;
1033
1034     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
1035     col->ref = 1;
1036     col->navigator = navigator;
1037
1038     init_dispex(&col->dispex, (IUnknown*)&col->IHTMLMimeTypesCollection_iface,
1039                 &HTMLMimeTypesCollection_dispex);
1040
1041     *ret = col;
1042     return S_OK;
1043 }
1044
1045 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
1046 {
1047     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
1048 }
1049
1050 static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID riid, void **ppv)
1051 {
1052     OmNavigator *This = impl_from_IOmNavigator(iface);
1053
1054     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1055
1056     if(IsEqualGUID(&IID_IUnknown, riid)) {
1057         *ppv = &This->IOmNavigator_iface;
1058     }else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
1059         *ppv = &This->IOmNavigator_iface;
1060     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1061         return *ppv ? S_OK : E_NOINTERFACE;
1062     }else {
1063         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1064         *ppv = NULL;
1065         return E_NOINTERFACE;
1066     }
1067
1068     IUnknown_AddRef((IUnknown*)*ppv);
1069     return S_OK;
1070 }
1071
1072 static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)
1073 {
1074     OmNavigator *This = impl_from_IOmNavigator(iface);
1075     LONG ref = InterlockedIncrement(&This->ref);
1076
1077     TRACE("(%p) ref=%d\n", This, ref);
1078
1079     return ref;
1080 }
1081
1082 static ULONG WINAPI OmNavigator_Release(IOmNavigator *iface)
1083 {
1084     OmNavigator *This = impl_from_IOmNavigator(iface);
1085     LONG ref = InterlockedDecrement(&This->ref);
1086
1087     TRACE("(%p) ref=%d\n", This, ref);
1088
1089     if(!ref) {
1090         if(This->plugins)
1091             This->plugins->navigator = NULL;
1092         if(This->mime_types)
1093             This->mime_types->navigator = NULL;
1094         release_dispex(&This->dispex);
1095         heap_free(This);
1096     }
1097
1098     return ref;
1099 }
1100
1101 static HRESULT WINAPI OmNavigator_GetTypeInfoCount(IOmNavigator *iface, UINT *pctinfo)
1102 {
1103     OmNavigator *This = impl_from_IOmNavigator(iface);
1104     FIXME("(%p)->(%p)\n", This, pctinfo);
1105     return E_NOTIMPL;
1106 }
1107
1108 static HRESULT WINAPI OmNavigator_GetTypeInfo(IOmNavigator *iface, UINT iTInfo,
1109                                               LCID lcid, ITypeInfo **ppTInfo)
1110 {
1111     OmNavigator *This = impl_from_IOmNavigator(iface);
1112
1113     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1114 }
1115
1116 static HRESULT WINAPI OmNavigator_GetIDsOfNames(IOmNavigator *iface, REFIID riid,
1117                                                 LPOLESTR *rgszNames, UINT cNames,
1118                                                 LCID lcid, DISPID *rgDispId)
1119 {
1120     OmNavigator *This = impl_from_IOmNavigator(iface);
1121
1122     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1123             lcid, rgDispId);
1124 }
1125
1126 static HRESULT WINAPI OmNavigator_Invoke(IOmNavigator *iface, DISPID dispIdMember,
1127                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1128                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1129 {
1130     OmNavigator *This = impl_from_IOmNavigator(iface);
1131
1132     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1133             pDispParams, pVarResult, pExcepInfo, puArgErr);
1134 }
1135
1136 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
1137 {
1138     OmNavigator *This = impl_from_IOmNavigator(iface);
1139
1140     static const WCHAR mozillaW[] = {'M','o','z','i','l','l','a',0};
1141
1142     TRACE("(%p)->(%p)\n", This, p);
1143
1144     *p = SysAllocString(mozillaW);
1145     return S_OK;
1146 }
1147
1148 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
1149 {
1150     OmNavigator *This = impl_from_IOmNavigator(iface);
1151
1152     static const WCHAR app_nameW[] =
1153         {'M','i','c','r','o','s','o','f','t',' ',
1154          'I','n','t','e','r','n','e','t',' ',
1155          'E','x','p','l','o','r','e','r',0};
1156
1157     TRACE("(%p)->(%p)\n", This, p);
1158
1159     *p = SysAllocString(app_nameW);
1160     if(!*p)
1161         return E_OUTOFMEMORY;
1162
1163     return S_OK;
1164 }
1165
1166 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
1167 {
1168     OmNavigator *This = impl_from_IOmNavigator(iface);
1169
1170     char user_agent[512];
1171     DWORD size;
1172     HRESULT hres;
1173     const unsigned skip_prefix = 8; /* strlen("Mozilla/") */
1174
1175     TRACE("(%p)->(%p)\n", This, p);
1176
1177     size = sizeof(user_agent);
1178     hres = ObtainUserAgentString(0, user_agent, &size);
1179     if(FAILED(hres))
1180         return hres;
1181
1182     if(size <= skip_prefix) {
1183         *p = NULL;
1184         return S_OK;
1185     }
1186
1187     size = MultiByteToWideChar(CP_ACP, 0, user_agent + skip_prefix, -1, NULL, 0);
1188     *p = SysAllocStringLen(NULL, size-1);
1189     if(!*p)
1190         return E_OUTOFMEMORY;
1191
1192     MultiByteToWideChar(CP_ACP, 0, user_agent + skip_prefix, -1, *p, size);
1193     return S_OK;
1194 }
1195
1196 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
1197 {
1198     OmNavigator *This = impl_from_IOmNavigator(iface);
1199     char user_agent[512];
1200     DWORD size;
1201     HRESULT hres;
1202
1203     TRACE("(%p)->(%p)\n", This, p);
1204
1205     size = sizeof(user_agent);
1206     hres = ObtainUserAgentString(0, user_agent, &size);
1207     if(FAILED(hres))
1208         return hres;
1209
1210     size = MultiByteToWideChar(CP_ACP, 0, user_agent, -1, NULL, 0);
1211     *p = SysAllocStringLen(NULL, size-1);
1212     if(!*p)
1213         return E_OUTOFMEMORY;
1214
1215     MultiByteToWideChar(CP_ACP, 0, user_agent, -1, *p, size);
1216     return S_OK;
1217 }
1218
1219 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1220 {
1221     OmNavigator *This = impl_from_IOmNavigator(iface);
1222
1223     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
1224
1225     *enabled = VARIANT_TRUE;
1226     return S_OK;
1227 }
1228
1229 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1230 {
1231     OmNavigator *This = impl_from_IOmNavigator(iface);
1232     FIXME("(%p)->(%p)\n", This, enabled);
1233     return E_NOTIMPL;
1234 }
1235
1236 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
1237 {
1238     OmNavigator *This = impl_from_IOmNavigator(iface);
1239
1240     TRACE("(%p)->(%p)\n", This, p);
1241
1242     if(!This->mime_types) {
1243         HRESULT hres;
1244
1245         hres = create_mime_types_collection(This, &This->mime_types);
1246         if(FAILED(hres))
1247             return hres;
1248     }else {
1249         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
1250     }
1251
1252     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
1253     return S_OK;
1254 }
1255
1256 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
1257 {
1258     OmNavigator *This = impl_from_IOmNavigator(iface);
1259
1260     TRACE("(%p)->(%p)\n", This, p);
1261
1262     if(!This->plugins) {
1263         HRESULT hres;
1264
1265         hres = create_plugins_collection(This, &This->plugins);
1266         if(FAILED(hres))
1267             return hres;
1268     }else {
1269         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
1270     }
1271
1272     *p = &This->plugins->IHTMLPluginsCollection_iface;
1273     return S_OK;
1274 }
1275
1276 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
1277 {
1278     OmNavigator *This = impl_from_IOmNavigator(iface);
1279
1280     WARN("(%p)->(%p) semi-stub\n", This, p);
1281
1282     *p = VARIANT_TRUE;
1283     return S_OK;
1284 }
1285
1286 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1287 {
1288     OmNavigator *This = impl_from_IOmNavigator(iface);
1289     FIXME("(%p)->(%p)\n", This, p);
1290     return E_NOTIMPL;
1291 }
1292
1293 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
1294 {
1295     OmNavigator *This = impl_from_IOmNavigator(iface);
1296
1297     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1298
1299     TRACE("(%p)->(%p)\n", This, String);
1300
1301     if(!String)
1302         return E_INVALIDARG;
1303
1304     *String = SysAllocString(objectW);
1305     return *String ? S_OK : E_OUTOFMEMORY;
1306 }
1307
1308 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
1309 {
1310     OmNavigator *This = impl_from_IOmNavigator(iface);
1311
1312     static const WCHAR cpu_classW[] =
1313 #ifdef _WIN64
1314         {'x','6','4',0};
1315 #else
1316         {'x','8','6',0};
1317 #endif
1318
1319     TRACE("(%p)->(%p)\n", This, p);
1320
1321     *p = SysAllocString(cpu_classW);
1322     return *p ? S_OK : E_OUTOFMEMORY;
1323 }
1324
1325 static HRESULT get_language_string(LCID lcid, BSTR *p)
1326 {
1327     BSTR ret;
1328     int len;
1329
1330     len = LCIDToLocaleName(lcid, NULL, 0, 0);
1331     if(!len) {
1332         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
1333         return E_FAIL;
1334     }
1335
1336     ret = SysAllocStringLen(NULL, len-1);
1337     if(!ret)
1338         return E_OUTOFMEMORY;
1339
1340     len = LCIDToLocaleName(lcid, ret, len, 0);
1341     if(!len) {
1342         WARN("LCIDToLocaleName failed: %u\n", GetLastError());
1343         SysFreeString(ret);
1344         return E_FAIL;
1345     }
1346
1347     *p = ret;
1348     return S_OK;
1349 }
1350
1351 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1352 {
1353     OmNavigator *This = impl_from_IOmNavigator(iface);
1354
1355     TRACE("(%p)->(%p)\n", This, p);
1356
1357     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1358 }
1359
1360 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1361 {
1362     OmNavigator *This = impl_from_IOmNavigator(iface);
1363
1364     TRACE("(%p)->(%p)\n", This, p);
1365
1366     return get_language_string(GetUserDefaultUILanguage(), p);
1367 }
1368
1369 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1370 {
1371     OmNavigator *This = impl_from_IOmNavigator(iface);
1372
1373     TRACE("(%p)->(%p)\n", This, p);
1374
1375     return get_language_string(LOCALE_USER_DEFAULT, p);
1376 }
1377
1378 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1379 {
1380     OmNavigator *This = impl_from_IOmNavigator(iface);
1381
1382 #ifdef _WIN64
1383     static const WCHAR platformW[] = {'W','i','n','6','4',0};
1384 #else
1385     static const WCHAR platformW[] = {'W','i','n','3','2',0};
1386 #endif
1387
1388     TRACE("(%p)->(%p)\n", This, p);
1389
1390     *p = SysAllocString(platformW);
1391     return S_OK;
1392 }
1393
1394 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1395 {
1396     OmNavigator *This = impl_from_IOmNavigator(iface);
1397
1398     static const WCHAR zeroW[] = {'0',0};
1399
1400     TRACE("(%p)->(%p)\n", This, p);
1401
1402     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1403     *p = SysAllocString(zeroW);
1404     return S_OK;
1405 }
1406
1407 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1408 {
1409     OmNavigator *This = impl_from_IOmNavigator(iface);
1410     FIXME("(%p)->(%p)\n", This, p);
1411     return E_NOTIMPL;
1412 }
1413
1414 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1415 {
1416     OmNavigator *This = impl_from_IOmNavigator(iface);
1417
1418     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1419
1420     *p = VARIANT_TRUE;
1421     return S_OK;
1422 }
1423
1424 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1425 {
1426     OmNavigator *This = impl_from_IOmNavigator(iface);
1427     FIXME("(%p)->(%p)\n", This, p);
1428     return E_NOTIMPL;
1429 }
1430
1431 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1432     OmNavigator_QueryInterface,
1433     OmNavigator_AddRef,
1434     OmNavigator_Release,
1435     OmNavigator_GetTypeInfoCount,
1436     OmNavigator_GetTypeInfo,
1437     OmNavigator_GetIDsOfNames,
1438     OmNavigator_Invoke,
1439     OmNavigator_get_appCodeName,
1440     OmNavigator_get_appName,
1441     OmNavigator_get_appVersion,
1442     OmNavigator_get_userAgent,
1443     OmNavigator_javaEnabled,
1444     OmNavigator_taintEnabled,
1445     OmNavigator_get_mimeTypes,
1446     OmNavigator_get_plugins,
1447     OmNavigator_get_cookieEnabled,
1448     OmNavigator_get_opsProfile,
1449     OmNavigator_toString,
1450     OmNavigator_get_cpuClass,
1451     OmNavigator_get_systemLanguage,
1452     OmNavigator_get_browserLanguage,
1453     OmNavigator_get_userLanguage,
1454     OmNavigator_get_platform,
1455     OmNavigator_get_appMinorVersion,
1456     OmNavigator_get_connectionSpeed,
1457     OmNavigator_get_onLine,
1458     OmNavigator_get_userProfile
1459 };
1460
1461 static const tid_t OmNavigator_iface_tids[] = {
1462     IOmNavigator_tid,
1463     0
1464 };
1465 static dispex_static_data_t OmNavigator_dispex = {
1466     NULL,
1467     DispHTMLNavigator_tid,
1468     OmNavigator_iface_tids
1469 };
1470
1471 IOmNavigator *OmNavigator_Create(void)
1472 {
1473     OmNavigator *ret;
1474
1475     ret = heap_alloc_zero(sizeof(*ret));
1476     if(!ret)
1477         return NULL;
1478
1479     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1480     ret->ref = 1;
1481
1482     init_dispex(&ret->dispex, (IUnknown*)&ret->IOmNavigator_iface, &OmNavigator_dispex);
1483
1484     return &ret->IOmNavigator_iface;
1485 }
1486
1487 typedef struct {
1488     DispatchEx dispex;
1489     IHTMLPerformanceTiming IHTMLPerformanceTiming_iface;
1490
1491     LONG ref;
1492 } HTMLPerformanceTiming;
1493
1494 static inline HTMLPerformanceTiming *impl_from_IHTMLPerformanceTiming(IHTMLPerformanceTiming *iface)
1495 {
1496     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, IHTMLPerformanceTiming_iface);
1497 }
1498
1499 static HRESULT WINAPI HTMLPerformanceTiming_QueryInterface(IHTMLPerformanceTiming *iface, REFIID riid, void **ppv)
1500 {
1501     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1502
1503     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1504
1505     if(IsEqualGUID(&IID_IUnknown, riid)) {
1506         *ppv = &This->IHTMLPerformanceTiming_iface;
1507     }else if(IsEqualGUID(&IID_IHTMLPerformanceTiming, riid)) {
1508         *ppv = &This->IHTMLPerformanceTiming_iface;
1509     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1510         return *ppv ? S_OK : E_NOINTERFACE;
1511     }else {
1512         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1513         *ppv = NULL;
1514         return E_NOINTERFACE;
1515     }
1516
1517     IUnknown_AddRef((IUnknown*)*ppv);
1518     return S_OK;
1519 }
1520
1521 static ULONG WINAPI HTMLPerformanceTiming_AddRef(IHTMLPerformanceTiming *iface)
1522 {
1523     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1524     LONG ref = InterlockedIncrement(&This->ref);
1525
1526     TRACE("(%p) ref=%d\n", This, ref);
1527
1528     return ref;
1529 }
1530
1531 static ULONG WINAPI HTMLPerformanceTiming_Release(IHTMLPerformanceTiming *iface)
1532 {
1533     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1534     LONG ref = InterlockedDecrement(&This->ref);
1535
1536     TRACE("(%p) ref=%d\n", This, ref);
1537
1538     if(!ref) {
1539         release_dispex(&This->dispex);
1540         heap_free(This);
1541     }
1542
1543     return ref;
1544 }
1545
1546 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfoCount(IHTMLPerformanceTiming *iface, UINT *pctinfo)
1547 {
1548     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1549     FIXME("(%p)->(%p)\n", This, pctinfo);
1550     return E_NOTIMPL;
1551 }
1552
1553 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfo(IHTMLPerformanceTiming *iface, UINT iTInfo,
1554                                               LCID lcid, ITypeInfo **ppTInfo)
1555 {
1556     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1557
1558     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1559 }
1560
1561 static HRESULT WINAPI HTMLPerformanceTiming_GetIDsOfNames(IHTMLPerformanceTiming *iface, REFIID riid,
1562                                                           LPOLESTR *rgszNames, UINT cNames,
1563                                                           LCID lcid, DISPID *rgDispId)
1564 {
1565     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1566
1567     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1568             lcid, rgDispId);
1569 }
1570
1571 static HRESULT WINAPI HTMLPerformanceTiming_Invoke(IHTMLPerformanceTiming *iface, DISPID dispIdMember,
1572                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1573                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1574 {
1575     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1576
1577     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1578             pDispParams, pVarResult, pExcepInfo, puArgErr);
1579 }
1580
1581 #define TIMING_FAKE_TIMESTAMP 0xdeadbeef
1582
1583 static HRESULT WINAPI HTMLPerformanceTiming_get_navigationStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1584 {
1585     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1586
1587     FIXME("(%p)->(%p) returning fake value\n", This, p);
1588
1589     *p = TIMING_FAKE_TIMESTAMP;
1590     return S_OK;
1591 }
1592
1593 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1594 {
1595     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1596
1597     FIXME("(%p)->(%p) returning fake value\n", This, p);
1598
1599     *p = TIMING_FAKE_TIMESTAMP;
1600     return S_OK;
1601 }
1602
1603 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1604 {
1605     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1606
1607     FIXME("(%p)->(%p) returning fake value\n", This, p);
1608
1609     *p = TIMING_FAKE_TIMESTAMP;
1610     return S_OK;
1611 }
1612
1613 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1614 {
1615     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1616
1617     FIXME("(%p)->(%p) returning fake value\n", This, p);
1618
1619     *p = TIMING_FAKE_TIMESTAMP;
1620     return S_OK;
1621 }
1622
1623 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1624 {
1625     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1626
1627     FIXME("(%p)->(%p) returning fake value\n", This, p);
1628
1629     *p = TIMING_FAKE_TIMESTAMP;
1630     return S_OK;
1631 }
1632
1633 static HRESULT WINAPI HTMLPerformanceTiming_get_fetchStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1634 {
1635     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1636
1637     FIXME("(%p)->(%p) returning fake value\n", This, p);
1638
1639     *p = TIMING_FAKE_TIMESTAMP;
1640     return S_OK;
1641 }
1642
1643 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1644 {
1645     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1646
1647     FIXME("(%p)->(%p) returning fake value\n", This, p);
1648
1649     *p = TIMING_FAKE_TIMESTAMP;
1650     return S_OK;
1651 }
1652
1653 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1654 {
1655     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1656
1657     FIXME("(%p)->(%p) returning fake value\n", This, p);
1658
1659     *p = TIMING_FAKE_TIMESTAMP;
1660     return S_OK;
1661 }
1662
1663 static HRESULT WINAPI HTMLPerformanceTiming_get_connectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1664 {
1665     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1666
1667     FIXME("(%p)->(%p) returning fake value\n", This, p);
1668
1669     *p = TIMING_FAKE_TIMESTAMP;
1670     return S_OK;
1671 }
1672
1673 static HRESULT WINAPI HTMLPerformanceTiming_get_connectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1674 {
1675     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1676
1677     FIXME("(%p)->(%p) returning fake value\n", This, p);
1678
1679     *p = TIMING_FAKE_TIMESTAMP;
1680     return S_OK;
1681 }
1682
1683 static HRESULT WINAPI HTMLPerformanceTiming_get_requestStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1684 {
1685     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1686
1687     FIXME("(%p)->(%p) returning fake value\n", This, p);
1688
1689     *p = TIMING_FAKE_TIMESTAMP;
1690     return S_OK;
1691 }
1692
1693 static HRESULT WINAPI HTMLPerformanceTiming_get_responseStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1694 {
1695     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1696
1697     FIXME("(%p)->(%p) returning fake value\n", This, p);
1698
1699     *p = TIMING_FAKE_TIMESTAMP;
1700     return S_OK;
1701 }
1702
1703 static HRESULT WINAPI HTMLPerformanceTiming_get_responseEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1704 {
1705     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1706
1707     FIXME("(%p)->(%p) returning fake value\n", This, p);
1708
1709     *p = TIMING_FAKE_TIMESTAMP;
1710     return S_OK;
1711 }
1712
1713 static HRESULT WINAPI HTMLPerformanceTiming_get_domLoading(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1714 {
1715     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1716
1717     FIXME("(%p)->(%p) returning fake value\n", This, p);
1718
1719     *p = TIMING_FAKE_TIMESTAMP;
1720     return S_OK;
1721 }
1722
1723 static HRESULT WINAPI HTMLPerformanceTiming_get_domInteractive(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1724 {
1725     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1726
1727     FIXME("(%p)->(%p) returning fake value\n", This, p);
1728
1729     *p = TIMING_FAKE_TIMESTAMP;
1730     return S_OK;
1731 }
1732
1733 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1734 {
1735     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1736
1737     FIXME("(%p)->(%p) returning fake value\n", This, p);
1738
1739     *p = TIMING_FAKE_TIMESTAMP;
1740     return S_OK;
1741 }
1742
1743 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1744 {
1745     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1746
1747     FIXME("(%p)->(%p) returning fake value\n", This, p);
1748
1749     *p = TIMING_FAKE_TIMESTAMP;
1750     return S_OK;
1751 }
1752
1753 static HRESULT WINAPI HTMLPerformanceTiming_get_domComplete(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1754 {
1755     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1756
1757     FIXME("(%p)->(%p) returning fake value\n", This, p);
1758
1759     *p = TIMING_FAKE_TIMESTAMP;
1760     return S_OK;
1761 }
1762
1763 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1764 {
1765     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1766
1767     FIXME("(%p)->(%p) returning fake value\n", This, p);
1768
1769     *p = TIMING_FAKE_TIMESTAMP;
1770     return S_OK;
1771 }
1772
1773 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1774 {
1775     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1776
1777     FIXME("(%p)->(%p) returning fake value\n", This, p);
1778
1779     *p = TIMING_FAKE_TIMESTAMP;
1780     return S_OK;
1781 }
1782
1783 static HRESULT WINAPI HTMLPerformanceTiming_get_msFirstPaint(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1784 {
1785     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1786
1787     FIXME("(%p)->(%p) returning fake value\n", This, p);
1788
1789     *p = TIMING_FAKE_TIMESTAMP;
1790     return S_OK;
1791 }
1792
1793 static HRESULT WINAPI HTMLPerformanceTiming_toString(IHTMLPerformanceTiming *iface, BSTR *string)
1794 {
1795     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1796     FIXME("(%p)->(%p)\n", This, string);
1797     return E_NOTIMPL;
1798 }
1799
1800 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1801 {
1802     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1803     FIXME("(%p)->(%p)\n", This, p);
1804     return E_NOTIMPL;
1805 }
1806
1807 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1808     HTMLPerformanceTiming_QueryInterface,
1809     HTMLPerformanceTiming_AddRef,
1810     HTMLPerformanceTiming_Release,
1811     HTMLPerformanceTiming_GetTypeInfoCount,
1812     HTMLPerformanceTiming_GetTypeInfo,
1813     HTMLPerformanceTiming_GetIDsOfNames,
1814     HTMLPerformanceTiming_Invoke,
1815     HTMLPerformanceTiming_get_navigationStart,
1816     HTMLPerformanceTiming_get_unloadEventStart,
1817     HTMLPerformanceTiming_get_unloadEventEnd,
1818     HTMLPerformanceTiming_get_redirectStart,
1819     HTMLPerformanceTiming_get_redirectEnd,
1820     HTMLPerformanceTiming_get_fetchStart,
1821     HTMLPerformanceTiming_get_domainLookupStart,
1822     HTMLPerformanceTiming_get_domainLookupEnd,
1823     HTMLPerformanceTiming_get_connectStart,
1824     HTMLPerformanceTiming_get_connectEnd,
1825     HTMLPerformanceTiming_get_requestStart,
1826     HTMLPerformanceTiming_get_responseStart,
1827     HTMLPerformanceTiming_get_responseEnd,
1828     HTMLPerformanceTiming_get_domLoading,
1829     HTMLPerformanceTiming_get_domInteractive,
1830     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1831     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1832     HTMLPerformanceTiming_get_domComplete,
1833     HTMLPerformanceTiming_get_loadEventStart,
1834     HTMLPerformanceTiming_get_loadEventEnd,
1835     HTMLPerformanceTiming_get_msFirstPaint,
1836     HTMLPerformanceTiming_toString,
1837     HTMLPerformanceTiming_toJSON
1838 };
1839
1840 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1841     IHTMLPerformanceTiming_tid,
1842     0
1843 };
1844 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1845     NULL,
1846     IHTMLPerformanceTiming_tid,
1847     HTMLPerformanceTiming_iface_tids
1848 };
1849
1850 typedef struct {
1851     DispatchEx dispex;
1852     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1853
1854     LONG ref;
1855 } HTMLPerformanceNavigation;
1856
1857 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1858 {
1859     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1860 }
1861
1862 static HRESULT WINAPI HTMLPerformanceNavigation_QueryInterface(IHTMLPerformanceNavigation *iface, REFIID riid, void **ppv)
1863 {
1864     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1865
1866     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1867
1868     if(IsEqualGUID(&IID_IUnknown, riid)) {
1869         *ppv = &This->IHTMLPerformanceNavigation_iface;
1870     }else if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid)) {
1871         *ppv = &This->IHTMLPerformanceNavigation_iface;
1872     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1873         return *ppv ? S_OK : E_NOINTERFACE;
1874     }else {
1875         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1876         *ppv = NULL;
1877         return E_NOINTERFACE;
1878     }
1879
1880     IUnknown_AddRef((IUnknown*)*ppv);
1881     return S_OK;
1882 }
1883
1884 static ULONG WINAPI HTMLPerformanceNavigation_AddRef(IHTMLPerformanceNavigation *iface)
1885 {
1886     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1887     LONG ref = InterlockedIncrement(&This->ref);
1888
1889     TRACE("(%p) ref=%d\n", This, ref);
1890
1891     return ref;
1892 }
1893
1894 static ULONG WINAPI HTMLPerformanceNavigation_Release(IHTMLPerformanceNavigation *iface)
1895 {
1896     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1897     LONG ref = InterlockedDecrement(&This->ref);
1898
1899     TRACE("(%p) ref=%d\n", This, ref);
1900
1901     if(!ref) {
1902         release_dispex(&This->dispex);
1903         heap_free(This);
1904     }
1905
1906     return ref;
1907 }
1908
1909 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfoCount(IHTMLPerformanceNavigation *iface, UINT *pctinfo)
1910 {
1911     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1912     FIXME("(%p)->(%p)\n", This, pctinfo);
1913     return E_NOTIMPL;
1914 }
1915
1916 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfo(IHTMLPerformanceNavigation *iface, UINT iTInfo,
1917                                               LCID lcid, ITypeInfo **ppTInfo)
1918 {
1919     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1920
1921     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1922 }
1923
1924 static HRESULT WINAPI HTMLPerformanceNavigation_GetIDsOfNames(IHTMLPerformanceNavigation *iface, REFIID riid,
1925                                                           LPOLESTR *rgszNames, UINT cNames,
1926                                                           LCID lcid, DISPID *rgDispId)
1927 {
1928     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1929
1930     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1931             lcid, rgDispId);
1932 }
1933
1934 static HRESULT WINAPI HTMLPerformanceNavigation_Invoke(IHTMLPerformanceNavigation *iface, DISPID dispIdMember,
1935                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1936                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1937 {
1938     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1939
1940     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1941             pDispParams, pVarResult, pExcepInfo, puArgErr);
1942 }
1943
1944 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
1945 {
1946     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1947
1948     FIXME("(%p)->(%p) returning TYPE_NAVIGATE\n", This, p);
1949
1950     *p = 0; /* TYPE_NAVIGATE */
1951     return S_OK;
1952 }
1953
1954 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
1955 {
1956     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1957     FIXME("(%p)->(%p)\n", This, p);
1958     return E_NOTIMPL;
1959 }
1960
1961 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
1962 {
1963     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1964     FIXME("(%p)->(%p)\n", This, string);
1965     return E_NOTIMPL;
1966 }
1967
1968 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
1969 {
1970     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1971     FIXME("(%p)->(%p)\n", This, p);
1972     return E_NOTIMPL;
1973 }
1974
1975 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
1976     HTMLPerformanceNavigation_QueryInterface,
1977     HTMLPerformanceNavigation_AddRef,
1978     HTMLPerformanceNavigation_Release,
1979     HTMLPerformanceNavigation_GetTypeInfoCount,
1980     HTMLPerformanceNavigation_GetTypeInfo,
1981     HTMLPerformanceNavigation_GetIDsOfNames,
1982     HTMLPerformanceNavigation_Invoke,
1983     HTMLPerformanceNavigation_get_type,
1984     HTMLPerformanceNavigation_get_redirectCount,
1985     HTMLPerformanceNavigation_toString,
1986     HTMLPerformanceNavigation_toJSON
1987 };
1988
1989 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
1990     IHTMLPerformanceNavigation_tid,
1991     0
1992 };
1993 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
1994     NULL,
1995     IHTMLPerformanceNavigation_tid,
1996     HTMLPerformanceNavigation_iface_tids
1997 };
1998
1999 typedef struct {
2000     DispatchEx dispex;
2001     IHTMLPerformance IHTMLPerformance_iface;
2002
2003     LONG ref;
2004
2005     IHTMLPerformanceNavigation *navigation;
2006     IHTMLPerformanceTiming *timing;
2007 } HTMLPerformance;
2008
2009 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
2010 {
2011     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
2012 }
2013
2014 static HRESULT WINAPI HTMLPerformance_QueryInterface(IHTMLPerformance *iface, REFIID riid, void **ppv)
2015 {
2016     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2017
2018     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2019
2020     if(IsEqualGUID(&IID_IUnknown, riid)) {
2021         *ppv = &This->IHTMLPerformance_iface;
2022     }else if(IsEqualGUID(&IID_IHTMLPerformance, riid)) {
2023         *ppv = &This->IHTMLPerformance_iface;
2024     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2025         return *ppv ? S_OK : E_NOINTERFACE;
2026     }else {
2027         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2028         *ppv = NULL;
2029         return E_NOINTERFACE;
2030     }
2031
2032     IUnknown_AddRef((IUnknown*)*ppv);
2033     return S_OK;
2034 }
2035
2036 static ULONG WINAPI HTMLPerformance_AddRef(IHTMLPerformance *iface)
2037 {
2038     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2039     LONG ref = InterlockedIncrement(&This->ref);
2040
2041     TRACE("(%p) ref=%d\n", This, ref);
2042
2043     return ref;
2044 }
2045
2046 static ULONG WINAPI HTMLPerformance_Release(IHTMLPerformance *iface)
2047 {
2048     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2049     LONG ref = InterlockedDecrement(&This->ref);
2050
2051     TRACE("(%p) ref=%d\n", This, ref);
2052
2053     if(!ref) {
2054         if(This->timing)
2055             IHTMLPerformanceTiming_Release(This->timing);
2056         if(This->navigation)
2057             IHTMLPerformanceNavigation_Release(This->navigation);
2058         release_dispex(&This->dispex);
2059         heap_free(This);
2060     }
2061
2062     return ref;
2063 }
2064
2065 static HRESULT WINAPI HTMLPerformance_GetTypeInfoCount(IHTMLPerformance *iface, UINT *pctinfo)
2066 {
2067     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2068     FIXME("(%p)->(%p)\n", This, pctinfo);
2069     return E_NOTIMPL;
2070 }
2071
2072 static HRESULT WINAPI HTMLPerformance_GetTypeInfo(IHTMLPerformance *iface, UINT iTInfo,
2073                                                   LCID lcid, ITypeInfo **ppTInfo)
2074 {
2075     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2076
2077     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2078 }
2079
2080 static HRESULT WINAPI HTMLPerformance_GetIDsOfNames(IHTMLPerformance *iface, REFIID riid,
2081                                                     LPOLESTR *rgszNames, UINT cNames,
2082                                                     LCID lcid, DISPID *rgDispId)
2083 {
2084     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2085
2086     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2087             lcid, rgDispId);
2088 }
2089
2090 static HRESULT WINAPI HTMLPerformance_Invoke(IHTMLPerformance *iface, DISPID dispIdMember,
2091                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2092                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2093 {
2094     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2095
2096     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2097             pDispParams, pVarResult, pExcepInfo, puArgErr);
2098 }
2099
2100 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
2101                                                      IHTMLPerformanceNavigation **p)
2102 {
2103     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2104
2105     TRACE("(%p)->(%p)\n", This, p);
2106
2107     if(!This->navigation) {
2108         HTMLPerformanceNavigation *navigation;
2109
2110         navigation = heap_alloc_zero(sizeof(*navigation));
2111         if(!navigation)
2112             return E_OUTOFMEMORY;
2113
2114         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
2115         navigation->ref = 1;
2116         init_dispex(&navigation->dispex, (IUnknown*)&navigation->IHTMLPerformanceNavigation_iface,
2117                     &HTMLPerformanceNavigation_dispex);
2118
2119         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
2120     }
2121
2122     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
2123     return S_OK;
2124 }
2125
2126 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
2127 {
2128     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2129
2130     TRACE("(%p)->(%p)\n", This, p);
2131
2132     if(!This->timing) {
2133         HTMLPerformanceTiming *timing;
2134
2135         timing = heap_alloc_zero(sizeof(*timing));
2136         if(!timing)
2137             return E_OUTOFMEMORY;
2138
2139         timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
2140         timing->ref = 1;
2141         init_dispex(&timing->dispex, (IUnknown*)&timing->IHTMLPerformanceTiming_iface,
2142                     &HTMLPerformanceTiming_dispex);
2143
2144         This->timing = &timing->IHTMLPerformanceTiming_iface;
2145     }
2146
2147     IHTMLPerformanceTiming_AddRef(*p = This->timing);
2148     return S_OK;
2149 }
2150
2151 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
2152 {
2153     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2154     FIXME("(%p)->(%p)\n", This, string);
2155     return E_NOTIMPL;
2156 }
2157
2158 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
2159 {
2160     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2161     FIXME("(%p)->(%p)\n", This, var);
2162     return E_NOTIMPL;
2163 }
2164
2165 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
2166     HTMLPerformance_QueryInterface,
2167     HTMLPerformance_AddRef,
2168     HTMLPerformance_Release,
2169     HTMLPerformance_GetTypeInfoCount,
2170     HTMLPerformance_GetTypeInfo,
2171     HTMLPerformance_GetIDsOfNames,
2172     HTMLPerformance_Invoke,
2173     HTMLPerformance_get_navigation,
2174     HTMLPerformance_get_timing,
2175     HTMLPerformance_toString,
2176     HTMLPerformance_toJSON
2177 };
2178
2179 static const tid_t HTMLPerformance_iface_tids[] = {
2180     IHTMLPerformance_tid,
2181     0
2182 };
2183 static dispex_static_data_t HTMLPerformance_dispex = {
2184     NULL,
2185     IHTMLPerformance_tid,
2186     HTMLPerformance_iface_tids
2187 };
2188
2189 HRESULT create_performance(IHTMLPerformance **ret)
2190 {
2191     HTMLPerformance *performance;
2192
2193     performance = heap_alloc_zero(sizeof(*performance));
2194     if(!performance)
2195         return E_OUTOFMEMORY;
2196
2197     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
2198     performance->ref = 1;
2199
2200     init_dispex(&performance->dispex, (IUnknown*)&performance->IHTMLPerformance_iface,
2201                 &HTMLPerformance_dispex);
2202
2203     *ret = &performance->IHTMLPerformance_iface;
2204     return S_OK;
2205 }
2206
2207 typedef struct {
2208     DispatchEx dispex;
2209     IHTMLNamespaceCollection IHTMLNamespaceCollection_iface;
2210
2211     LONG ref;
2212 } HTMLNamespaceCollection;
2213
2214 static inline HTMLNamespaceCollection *impl_from_IHTMLNamespaceCollection(IHTMLNamespaceCollection *iface)
2215 {
2216     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, IHTMLNamespaceCollection_iface);
2217 }
2218
2219 static HRESULT WINAPI HTMLNamespaceCollection_QueryInterface(IHTMLNamespaceCollection *iface, REFIID riid, void **ppv)
2220 {
2221     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2222
2223     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2224
2225     if(IsEqualGUID(&IID_IUnknown, riid)) {
2226         *ppv = &This->IHTMLNamespaceCollection_iface;
2227     }else if(IsEqualGUID(&IID_IHTMLNamespaceCollection, riid)) {
2228         *ppv = &This->IHTMLNamespaceCollection_iface;
2229     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2230         return *ppv ? S_OK : E_NOINTERFACE;
2231     }else {
2232         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2233         *ppv = NULL;
2234         return E_NOINTERFACE;
2235     }
2236
2237     IUnknown_AddRef((IUnknown*)*ppv);
2238     return S_OK;
2239 }
2240
2241 static ULONG WINAPI HTMLNamespaceCollection_AddRef(IHTMLNamespaceCollection *iface)
2242 {
2243     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2244     LONG ref = InterlockedIncrement(&This->ref);
2245
2246     TRACE("(%p) ref=%d\n", This, ref);
2247
2248     return ref;
2249 }
2250
2251 static ULONG WINAPI HTMLNamespaceCollection_Release(IHTMLNamespaceCollection *iface)
2252 {
2253     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2254     LONG ref = InterlockedDecrement(&This->ref);
2255
2256     TRACE("(%p) ref=%d\n", This, ref);
2257
2258     if(!ref) {
2259         release_dispex(&This->dispex);
2260         heap_free(This);
2261     }
2262
2263     return ref;
2264 }
2265
2266 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfoCount(IHTMLNamespaceCollection *iface, UINT *pctinfo)
2267 {
2268     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2269     FIXME("(%p)->(%p)\n", This, pctinfo);
2270     return E_NOTIMPL;
2271 }
2272
2273 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfo(IHTMLNamespaceCollection *iface, UINT iTInfo,
2274                                                   LCID lcid, ITypeInfo **ppTInfo)
2275 {
2276     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2277
2278     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2279 }
2280
2281 static HRESULT WINAPI HTMLNamespaceCollection_GetIDsOfNames(IHTMLNamespaceCollection *iface, REFIID riid,
2282                                                     LPOLESTR *rgszNames, UINT cNames,
2283                                                     LCID lcid, DISPID *rgDispId)
2284 {
2285     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2286
2287     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2288             lcid, rgDispId);
2289 }
2290
2291 static HRESULT WINAPI HTMLNamespaceCollection_Invoke(IHTMLNamespaceCollection *iface, DISPID dispIdMember,
2292                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2293                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2294 {
2295     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2296
2297     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2298             pDispParams, pVarResult, pExcepInfo, puArgErr);
2299 }
2300
2301 static HRESULT WINAPI HTMLNamespaceCollection_get_length(IHTMLNamespaceCollection *iface, LONG *p)
2302 {
2303     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2304     FIXME("(%p)->(%p) returning 0\n", This, p);
2305     *p = 0;
2306     return S_OK;
2307 }
2308
2309 static HRESULT WINAPI HTMLNamespaceCollection_item(IHTMLNamespaceCollection *iface, VARIANT index, IDispatch **p)
2310 {
2311     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2312     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(&index), p);
2313     return E_NOTIMPL;
2314 }
2315
2316 static HRESULT WINAPI HTMLNamespaceCollection_add(IHTMLNamespaceCollection *iface, BSTR namespace, BSTR urn,
2317                                                   VARIANT implementation_url, IDispatch **p)
2318 {
2319     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2320     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(namespace), debugstr_w(urn), debugstr_variant(&implementation_url), p);
2321     return E_NOTIMPL;
2322 }
2323
2324 static const IHTMLNamespaceCollectionVtbl HTMLNamespaceCollectionVtbl = {
2325     HTMLNamespaceCollection_QueryInterface,
2326     HTMLNamespaceCollection_AddRef,
2327     HTMLNamespaceCollection_Release,
2328     HTMLNamespaceCollection_GetTypeInfoCount,
2329     HTMLNamespaceCollection_GetTypeInfo,
2330     HTMLNamespaceCollection_GetIDsOfNames,
2331     HTMLNamespaceCollection_Invoke,
2332     HTMLNamespaceCollection_get_length,
2333     HTMLNamespaceCollection_item,
2334     HTMLNamespaceCollection_add
2335 };
2336
2337 static const tid_t HTMLNamespaceCollection_iface_tids[] = {
2338     IHTMLNamespaceCollection_tid,
2339     0
2340 };
2341 static dispex_static_data_t HTMLNamespaceCollection_dispex = {
2342     NULL,
2343     DispHTMLNamespaceCollection_tid,
2344     HTMLNamespaceCollection_iface_tids
2345 };
2346
2347 HRESULT create_namespace_collection(IHTMLNamespaceCollection **ret)
2348 {
2349     HTMLNamespaceCollection *namespaces;
2350
2351     if (!(namespaces = heap_alloc_zero(sizeof(*namespaces))))
2352         return E_OUTOFMEMORY;
2353
2354     namespaces->IHTMLNamespaceCollection_iface.lpVtbl = &HTMLNamespaceCollectionVtbl;
2355     namespaces->ref = 1;
2356     init_dispex(&namespaces->dispex, (IUnknown*)&namespaces->IHTMLNamespaceCollection_iface, &HTMLNamespaceCollection_dispex);
2357     *ret = &namespaces->IHTMLNamespaceCollection_iface;
2358     return S_OK;
2359 }