dlls/mshtml/nsio.c

   1 /*
   2  * Copyright 2006-2010 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "winreg.h"
  27 #include "winternl.h"
  28 #include "ole2.h"
  29 #include "shlguid.h"
  30 #include "wininet.h"
  31 #include "shlwapi.h"
  32
  33 #include "wine/debug.h"
  34
  35 #include "mshtml_private.h"
  36 #include "binding.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39
  40 #define NS_IOSERVICE_CLASSNAME "nsIOService"
  41 #define NS_IOSERVICE_CONTRACTID "@mozilla.org/network/io-service;1"
  42
  43 static const IID NS_IOSERVICE_CID =
  44     {0x9ac9e770, 0x18bc, 0x11d3, {0x93, 0x37, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40}};
  45 static const IID IID_nsWineURI =
  46     {0x5088272e, 0x900b, 0x11da, {0xc6,0x87, 0x00,0x0f,0xea,0x57,0xf2,0x1a}};
  47
  48 static nsIIOService *nsio = NULL;
  49
  50 static const char *request_method_strings[] = {"GET", "PUT", "POST"};
  51
  52 struct  nsWineURI {
  53     nsIFileURL nsIFileURL_iface; /* For non-file URL objects, it's just nsIURL */
  54     nsIStandardURL nsIStandardURL_iface;
  55
  56     LONG ref;
  57
  58     nsChannelBSC *channel_bsc;
  59     IUri *uri;
  60     IUriBuilder *uri_builder;
  61     BOOL is_mutable;
  62     DWORD scheme;
  63 };
  64
  65 static BOOL ensure_uri(nsWineURI *This)
  66 {
  67     HRESULT hres;
  68
  69     assert(This->uri || This->uri_builder);
  70
  71     if(!This->uri) {
  72         hres = IUriBuilder_CreateUriSimple(This->uri_builder, 0, 0, &This->uri);
  73         if(FAILED(hres)) {
  74             WARN("CreateUriSimple failed: %08lx\n", hres);
  75             return FALSE;
  76         }
  77     }
  78
  79     return TRUE;
  80 }
  81
  82 IUri *nsuri_get_uri(nsWineURI *nsuri)
  83 {
  84     if(!ensure_uri(nsuri))
  85         return NULL;
  86
  87     IUri_AddRef(nsuri->uri);
  88     return nsuri->uri;
  89 }
  90
  91 IUri *get_uri_nofrag(IUri *uri)
  92 {
  93     IUriBuilder *uri_builder;
  94     IUri *ret;
  95     BOOL b;
  96     HRESULT hres;
  97
  98     hres = IUri_HasProperty(uri, Uri_PROPERTY_FRAGMENT, &b);
  99     if(SUCCEEDED(hres) && !b) {
 100         IUri_AddRef(uri);
 101         return uri;
 102     }
 103
 104     hres = CreateIUriBuilder(uri, 0, 0, &uri_builder);
 105     if(FAILED(hres))
 106         return NULL;
 107
 108     hres = IUriBuilder_RemoveProperties(uri_builder, Uri_HAS_FRAGMENT);
 109     if(SUCCEEDED(hres))
 110         hres = IUriBuilder_CreateUriSimple(uri_builder, 0, 0, &ret);
 111     IUriBuilder_Release(uri_builder);
 112     if(FAILED(hres))
 113         return NULL;
 114
 115     return ret;
 116 }
 117
 118 static BOOL compare_ignoring_frag(IUri *uri1, IUri *uri2)
 119 {
 120     IUri *uri_nofrag1, *uri_nofrag2;
 121     BOOL ret = FALSE;
 122
 123     uri_nofrag1 = get_uri_nofrag(uri1);
 124     if(!uri_nofrag1)
 125         return FALSE;
 126
 127     uri_nofrag2 = get_uri_nofrag(uri2);
 128     if(uri_nofrag2) {
 129         IUri_IsEqual(uri_nofrag1, uri_nofrag2, &ret);
 130         IUri_Release(uri_nofrag2);
 131     }
 132
 133     IUri_Release(uri_nofrag1);
 134     return ret;
 135 }
 136
 137 static HRESULT combine_url(IUri *base_uri, const WCHAR *rel_url, IUri **ret)
 138 {
 139     IUri *uri_nofrag;
 140     HRESULT hres;
 141
 142     uri_nofrag = get_uri_nofrag(base_uri);
 143     if(!uri_nofrag)
 144         return E_FAIL;
 145
 146     hres = CoInternetCombineUrlEx(uri_nofrag, rel_url, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO,
 147                 ret, 0);
 148     IUri_Release(uri_nofrag);
 149     if(FAILED(hres))
 150         WARN("CoInternetCombineUrlEx failed: %08lx\n", hres);
 151     return hres;
 152 }
 153
 154 static nsresult create_nsuri(IUri*,nsWineURI**);
 155
 156 static const char *debugstr_nsacstr(const nsACString *nsstr)
 157 {
 158     const char *data;
 159
 160     nsACString_GetData(nsstr, &data);
 161     return debugstr_a(data);
 162 }
 163
 164 static nsresult return_wstr_nsacstr(nsACString *ret_str, const WCHAR *str, int len)
 165 {
 166     char *stra;
 167     int lena;
 168
 169     TRACE("returning %s\n", debugstr_wn(str, len));
 170
 171     if(!*str) {
 172         nsACString_SetData(ret_str, "");
 173         return NS_OK;
 174     }
 175
 176     lena = WideCharToMultiByte(CP_UTF8, 0, str, len, NULL, 0, NULL, NULL);
 177     stra = heap_alloc(lena+1);
 178     if(!stra)
 179         return NS_ERROR_OUT_OF_MEMORY;
 180
 181     WideCharToMultiByte(CP_UTF8, 0, str, len, stra, lena, NULL, NULL);
 182     stra[lena] = 0;
 183
 184     nsACString_SetData(ret_str, stra);
 185     heap_free(stra);
 186     return NS_OK;
 187 }
 188
 189 HRESULT nsuri_to_url(LPCWSTR nsuri, BOOL ret_empty, BSTR *ret)
 190 {
 191     const WCHAR *ptr = nsuri;
 192
 193     static const WCHAR wine_prefixW[] = {'w','i','n','e',':'};
 194
 195     if(!wcsncmp(nsuri, wine_prefixW, ARRAY_SIZE(wine_prefixW)))
 196         ptr += ARRAY_SIZE(wine_prefixW);
 197
 198     if(*ptr || ret_empty) {
 199         *ret = SysAllocString(ptr);
 200         if(!*ret)
 201             return E_OUTOFMEMORY;
 202     }else {
 203         *ret = NULL;
 204     }
 205
 206     TRACE("%s -> %s\n", debugstr_w(nsuri), debugstr_w(*ret));
 207     return S_OK;
 208 }
 209
 210 static BOOL exec_shldocvw_67(HTMLDocumentObj *doc, BSTR url)
 211 {
 212     IOleCommandTarget *cmdtrg = NULL;
 213     HRESULT hres;
 214
 215     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
 216     if(SUCCEEDED(hres)) {
 217         VARIANT varUrl, varRes;
 218
 219         V_VT(&varUrl) = VT_BSTR;
 220         V_BSTR(&varUrl) = url;
 221         V_VT(&varRes) = VT_BOOL;
 222
 223         hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &varUrl, &varRes);
 224
 225         IOleCommandTarget_Release(cmdtrg);
 226
 227         if(SUCCEEDED(hres) && !V_BOOL(&varRes)) {
 228             TRACE("got VARIANT_FALSE, do not load\n");
 229             return FALSE;
 230         }
 231     }
 232
 233     return TRUE;
 234 }
 235
 236 static nsresult before_async_open(nsChannel *channel, GeckoBrowser *container, BOOL *cancel)
 237 {
 238     HTMLDocumentObj *doc = container->doc;
 239     BSTR display_uri;
 240     HRESULT hres;
 241
 242     if(!doc->client) {
 243         *cancel = TRUE;
 244         return NS_OK;
 245     }
 246
 247     hres = IUri_GetDisplayUri(channel->uri->uri, &display_uri);
 248     if(FAILED(hres))
 249         return NS_ERROR_FAILURE;
 250
 251     if(doc->hostui) {
 252         OLECHAR *new_url;
 253         hres = IDocHostUIHandler_TranslateUrl(doc->hostui, 0, display_uri, &new_url);
 254         if(hres == S_OK && new_url) {
 255             if(wcscmp(display_uri, new_url)) {
 256                 FIXME("TranslateUrl returned new URL %s -> %s\n", debugstr_w(display_uri), debugstr_w(new_url));
 257                 CoTaskMemFree(new_url);
 258                 *cancel = TRUE;
 259                 return NS_OK;
 260             }
 261             CoTaskMemFree(new_url);
 262         }
 263     }
 264
 265     if(!exec_shldocvw_67(doc, display_uri)) {
 266         SysFreeString(display_uri);
 267         *cancel = FALSE;
 268         return NS_OK;
 269     }
 270
 271     hres = hlink_frame_navigate(&doc->basedoc, display_uri, channel, 0, cancel);
 272     SysFreeString(display_uri);
 273     if(FAILED(hres))
 274         *cancel = TRUE;
 275     return NS_OK;
 276 }
 277
 278 HRESULT load_nsuri(HTMLOuterWindow *window, nsWineURI *uri, nsIInputStream *post_stream,
 279         nsChannelBSC *channelbsc, DWORD flags)
 280 {
 281     nsIWebNavigation *web_navigation;
 282     nsIDocShellLoadInfo *load_info;
 283     nsIDocShell *doc_shell;
 284     HTMLDocumentNode *doc;
 285     nsresult nsres;
 286
 287     nsres = get_nsinterface((nsISupports*)window->nswindow, &IID_nsIWebNavigation, (void**)&web_navigation);
 288     if(NS_FAILED(nsres)) {
 289         ERR("Could not get nsIWebNavigation interface: %08lx\n", nsres);
 290         return E_FAIL;
 291     }
 292
 293     nsres = nsIWebNavigation_QueryInterface(web_navigation, &IID_nsIDocShell, (void**)&doc_shell);
 294     nsIWebNavigation_Release(web_navigation);
 295     if(NS_FAILED(nsres)) {
 296         ERR("Could not get nsIDocShell: %08lx\n", nsres);
 297         return E_FAIL;
 298     }
 299
 300     nsres = nsIDocShell_CreateLoadInfo(doc_shell, &load_info);
 301     if(NS_FAILED(nsres)) {
 302         nsIDocShell_Release(doc_shell);
 303         return E_FAIL;
 304     }
 305
 306     nsres = nsIDocShellLoadInfo_SetLoadType(load_info, (flags & LOAD_FLAGS_BYPASS_CACHE) ? loadNormalBypassCache : loadNormal);
 307     assert(nsres == NS_OK);
 308
 309     if(post_stream) {
 310         nsres = nsIDocShellLoadInfo_SetPostDataStream(load_info, post_stream);
 311         assert(nsres == NS_OK);
 312     }
 313
 314     if(window->uri_nofrag) {
 315         nsWineURI *referrer_uri;
 316         nsres = create_nsuri(window->uri_nofrag, &referrer_uri);
 317         if(NS_SUCCEEDED(nsres)) {
 318             nsres = nsIDocShellLoadInfo_SetReferrer(load_info, (nsIURI*)&referrer_uri->nsIFileURL_iface);
 319             assert(nsres == NS_OK);
 320             nsIFileURL_Release(&referrer_uri->nsIFileURL_iface);
 321         }
 322     }
 323
 324     uri->channel_bsc = channelbsc;
 325     doc = window->base.inner_window->doc;
 326     doc->skip_mutation_notif = TRUE;
 327     nsres = nsIDocShell_LoadURI(doc_shell, (nsIURI*)&uri->nsIFileURL_iface, load_info, flags, FALSE);
 328     if(doc == window->base.inner_window->doc)
 329         doc->skip_mutation_notif = FALSE;
 330     uri->channel_bsc = NULL;
 331     nsIDocShell_Release(doc_shell);
 332     nsIDocShellLoadInfo_Release(load_info);
 333     if(NS_FAILED(nsres)) {
 334         WARN("LoadURI failed: %08lx\n", nsres);
 335         return E_FAIL;
 336     }
 337
 338     return S_OK;
 339 }
 340
 341 static inline BOOL is_http_channel(nsChannel *This)
 342 {
 343     return This->uri->scheme == URL_SCHEME_HTTP || This->uri->scheme == URL_SCHEME_HTTPS;
 344 }
 345
 346 static http_header_t *find_http_header(struct list *headers, const WCHAR *name, int len)
 347 {
 348     http_header_t *iter;
 349
 350     LIST_FOR_EACH_ENTRY(iter, headers, http_header_t, entry) {
 351         if(!wcsnicmp(iter->header, name, len) && !iter->header[len])
 352             return iter;
 353     }
 354
 355     return NULL;
 356 }
 357
 358 static nsresult get_channel_http_header(struct list *headers, const nsACString *header_name_str,
 359         nsACString *_retval)
 360 {
 361     const char *header_namea;
 362     http_header_t *header;
 363     WCHAR *header_name;
 364     char *data;
 365
 366     nsACString_GetData(header_name_str, &header_namea);
 367     header_name = heap_strdupAtoW(header_namea);
 368     if(!header_name)
 369         return NS_ERROR_UNEXPECTED;
 370
 371     header = find_http_header(headers, header_name, lstrlenW(header_name));
 372     heap_free(header_name);
 373     if(!header)
 374         return NS_ERROR_NOT_AVAILABLE;
 375
 376     data = heap_strdupWtoA(header->data);
 377     if(!data)
 378         return NS_ERROR_UNEXPECTED;
 379
 380     TRACE("%s -> %s\n", debugstr_a(header_namea), debugstr_a(data));
 381     nsACString_SetData(_retval, data);
 382     heap_free(data);
 383     return NS_OK;
 384 }
 385
 386 HRESULT set_http_header(struct list *headers, const WCHAR *name, int name_len,
 387         const WCHAR *value, int value_len)
 388 {
 389     http_header_t *header;
 390
 391     TRACE("%s: %s\n", debugstr_wn(name, name_len), debugstr_wn(value, value_len));
 392
 393     header = find_http_header(headers, name, name_len);
 394     if(header) {
 395         WCHAR *new_data;
 396
 397         new_data = heap_strndupW(value, value_len);
 398         if(!new_data)
 399             return E_OUTOFMEMORY;
 400
 401         heap_free(header->data);
 402         header->data = new_data;
 403     }else {
 404         header = heap_alloc(sizeof(http_header_t));
 405         if(!header)
 406             return E_OUTOFMEMORY;
 407
 408         header->header = heap_strndupW(name, name_len);
 409         header->data = heap_strndupW(value, value_len);
 410         if(!header->header || !header->data) {
 411             heap_free(header->header);
 412             heap_free(header->data);
 413             heap_free(header);
 414             return E_OUTOFMEMORY;
 415         }
 416
 417         list_add_tail(headers, &header->entry);
 418     }
 419
 420     return S_OK;
 421 }
 422
 423 static nsresult set_channel_http_header(struct list *headers, const nsACString *name_str,
 424         const nsACString *value_str)
 425 {
 426     const char *namea, *valuea;
 427     WCHAR *name, *value;
 428     HRESULT hres;
 429
 430     nsACString_GetData(name_str, &namea);
 431     name = heap_strdupAtoW(namea);
 432     if(!name)
 433         return NS_ERROR_UNEXPECTED;
 434
 435     nsACString_GetData(value_str, &valuea);
 436     value = heap_strdupAtoW(valuea);
 437     if(!value) {
 438         heap_free(name);
 439         return NS_ERROR_UNEXPECTED;
 440     }
 441
 442     hres = set_http_header(headers, name, lstrlenW(name), value, lstrlenW(value));
 443
 444     heap_free(name);
 445     heap_free(value);
 446     return SUCCEEDED(hres) ? NS_OK : NS_ERROR_UNEXPECTED;
 447 }
 448
 449 static nsresult visit_http_headers(struct list *headers, nsIHttpHeaderVisitor *visitor)
 450 {
 451     nsACString header_str, value_str;
 452     char *header, *value;
 453     http_header_t *iter;
 454     nsresult nsres;
 455
 456     LIST_FOR_EACH_ENTRY(iter, headers, http_header_t, entry) {
 457         header = heap_strdupWtoA(iter->header);
 458         if(!header)
 459             return NS_ERROR_OUT_OF_MEMORY;
 460
 461         value = heap_strdupWtoA(iter->data);
 462         if(!value) {
 463             heap_free(header);
 464             return NS_ERROR_OUT_OF_MEMORY;
 465         }
 466
 467         nsACString_InitDepend(&header_str, header);
 468         nsACString_InitDepend(&value_str, value);
 469         nsres = nsIHttpHeaderVisitor_VisitHeader(visitor, &header_str, &value_str);
 470         nsACString_Finish(&header_str);
 471         nsACString_Finish(&value_str);
 472         heap_free(header);
 473         heap_free(value);
 474         if(NS_FAILED(nsres))
 475             break;
 476     }
 477
 478     return NS_OK;
 479 }
 480
 481 static void free_http_headers(struct list *list)
 482 {
 483     http_header_t *iter, *iter_next;
 484
 485     LIST_FOR_EACH_ENTRY_SAFE(iter, iter_next, list, http_header_t, entry) {
 486         list_remove(&iter->entry);
 487         heap_free(iter->header);
 488         heap_free(iter->data);
 489         heap_free(iter);
 490     }
 491 }
 492
 493 static inline nsChannel *impl_from_nsIHttpChannel(nsIHttpChannel *iface)
 494 {
 495     return CONTAINING_RECORD(iface, nsChannel, nsIHttpChannel_iface);
 496 }
 497
 498 static nsresult NSAPI nsChannel_QueryInterface(nsIHttpChannel *iface, nsIIDRef riid, void **result)
 499 {
 500     nsChannel *This = impl_from_nsIHttpChannel(iface);
 501
 502     if(IsEqualGUID(&IID_nsISupports, riid)) {
 503         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
 504         *result = &This->nsIHttpChannel_iface;
 505     }else if(IsEqualGUID(&IID_nsIRequest, riid)) {
 506         TRACE("(%p)->(IID_nsIRequest %p)\n", This, result);
 507         *result = &This->nsIHttpChannel_iface;
 508     }else if(IsEqualGUID(&IID_nsIChannel, riid)) {
 509         TRACE("(%p)->(IID_nsIChannel %p)\n", This, result);
 510         *result = &This->nsIHttpChannel_iface;
 511     }else if(IsEqualGUID(&IID_nsIHttpChannel, riid)) {
 512         TRACE("(%p)->(IID_nsIHttpChannel %p)\n", This, result);
 513         *result = is_http_channel(This) ? &This->nsIHttpChannel_iface : NULL;
 514     }else if(IsEqualGUID(&IID_nsIUploadChannel, riid)) {
 515         TRACE("(%p)->(IID_nsIUploadChannel %p)\n", This, result);
 516         *result = &This->nsIUploadChannel_iface;
 517     }else if(IsEqualGUID(&IID_nsIFormPOSTActionChannel, riid)) {
 518         TRACE("(%p)->(IID_nsIFormPOSTActionChannel %p)\n", This, result);
 519         *result = &This->nsIUploadChannel_iface;
 520     }else if(IsEqualGUID(&IID_nsIHttpChannelInternal, riid)) {
 521         TRACE("(%p)->(IID_nsIHttpChannelInternal %p)\n", This, result);
 522         *result = is_http_channel(This) ? &This->nsIHttpChannelInternal_iface : NULL;
 523     }else if(IsEqualGUID(&IID_nsICacheInfoChannel, riid)) {
 524         TRACE("(%p)->(IID_nsICacheInfoChannel %p)\n", This, result);
 525         *result = is_http_channel(This) ? &This->nsICacheInfoChannel_iface : NULL;
 526     }else {
 527         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 528         *result = NULL;
 529     }
 530
 531     if(*result) {
 532         nsIHttpChannel_AddRef(&This->nsIHttpChannel_iface);
 533         return NS_OK;
 534     }
 535
 536     return NS_NOINTERFACE;
 537 }
 538
 539 static nsrefcnt NSAPI nsChannel_AddRef(nsIHttpChannel *iface)
 540 {
 541     nsChannel *This = impl_from_nsIHttpChannel(iface);
 542     nsrefcnt ref = InterlockedIncrement(&This->ref);
 543
 544     TRACE("(%p) ref=%ld\n", This, ref);
 545
 546     return ref;
 547 }
 548
 549 static nsrefcnt NSAPI nsChannel_Release(nsIHttpChannel *iface)
 550 {
 551     nsChannel *This = impl_from_nsIHttpChannel(iface);
 552     LONG ref = InterlockedDecrement(&This->ref);
 553
 554     if(!ref) {
 555         nsIFileURL_Release(&This->uri->nsIFileURL_iface);
 556         if(This->owner)
 557             nsISupports_Release(This->owner);
 558         if(This->post_data_stream)
 559             nsIInputStream_Release(This->post_data_stream);
 560         if(This->load_group)
 561             nsILoadGroup_Release(This->load_group);
 562         if(This->notif_callback)
 563             nsIInterfaceRequestor_Release(This->notif_callback);
 564         if(This->original_uri)
 565             nsIURI_Release(This->original_uri);
 566         if(This->referrer)
 567             nsIURI_Release(This->referrer);
 568
 569         free_http_headers(&This->response_headers);
 570         free_http_headers(&This->request_headers);
 571
 572         heap_free(This->content_type);
 573         heap_free(This->charset);
 574         heap_free(This);
 575     }
 576
 577     return ref;
 578 }
 579
 580 static nsresult NSAPI nsChannel_GetName(nsIHttpChannel *iface, nsACString *aName)
 581 {
 582     nsChannel *This = impl_from_nsIHttpChannel(iface);
 583
 584     TRACE("(%p)->(%p)\n", This, aName);
 585
 586     return nsIFileURL_GetSpec(&This->uri->nsIFileURL_iface, aName);
 587 }
 588
 589 static nsresult NSAPI nsChannel_IsPending(nsIHttpChannel *iface, cpp_bool *_retval)
 590 {
 591     nsChannel *This = impl_from_nsIHttpChannel(iface);
 592
 593     FIXME("(%p)->(%p)\n", This, _retval);
 594
 595     return NS_ERROR_NOT_IMPLEMENTED;
 596 }
 597
 598 static nsresult NSAPI nsChannel_GetStatus(nsIHttpChannel *iface, nsresult *aStatus)
 599 {
 600     nsChannel *This = impl_from_nsIHttpChannel(iface);
 601
 602     WARN("(%p)->(%p) returning NS_OK\n", This, aStatus);
 603
 604     return *aStatus = NS_OK;
 605 }
 606
 607 static nsresult NSAPI nsChannel_Cancel(nsIHttpChannel *iface, nsresult aStatus)
 608 {
 609     nsChannel *This = impl_from_nsIHttpChannel(iface);
 610
 611     TRACE("(%p)->(%08lx)\n", This, aStatus);
 612
 613     if(This->binding && This->binding->bsc.binding)
 614         IBinding_Abort(This->binding->bsc.binding);
 615     else
 616         WARN("No binding to cancel\n");
 617     return NS_OK;
 618 }
 619
 620 static nsresult NSAPI nsChannel_Suspend(nsIHttpChannel *iface)
 621 {
 622     nsChannel *This = impl_from_nsIHttpChannel(iface);
 623
 624     FIXME("(%p)\n", This);
 625
 626     return NS_ERROR_NOT_IMPLEMENTED;
 627 }
 628
 629 static nsresult NSAPI nsChannel_Resume(nsIHttpChannel *iface)
 630 {
 631     nsChannel *This = impl_from_nsIHttpChannel(iface);
 632
 633     FIXME("(%p)\n", This);
 634
 635     return NS_ERROR_NOT_IMPLEMENTED;
 636 }
 637
 638 static nsresult NSAPI nsChannel_GetLoadGroup(nsIHttpChannel *iface, nsILoadGroup **aLoadGroup)
 639 {
 640     nsChannel *This = impl_from_nsIHttpChannel(iface);
 641
 642     TRACE("(%p)->(%p)\n", This, aLoadGroup);
 643
 644     if(This->load_group)
 645         nsILoadGroup_AddRef(This->load_group);
 646
 647     *aLoadGroup = This->load_group;
 648     return NS_OK;
 649 }
 650
 651 static nsresult NSAPI nsChannel_SetLoadGroup(nsIHttpChannel *iface, nsILoadGroup *aLoadGroup)
 652 {
 653     nsChannel *This = impl_from_nsIHttpChannel(iface);
 654
 655     TRACE("(%p)->(%p)\n", This, aLoadGroup);
 656
 657     if(This->load_group)
 658         nsILoadGroup_Release(This->load_group);
 659     if(aLoadGroup)
 660         nsILoadGroup_AddRef(aLoadGroup);
 661     This->load_group = aLoadGroup;
 662
 663     return NS_OK;
 664 }
 665
 666 static nsresult NSAPI nsChannel_GetLoadFlags(nsIHttpChannel *iface, nsLoadFlags *aLoadFlags)
 667 {
 668     nsChannel *This = impl_from_nsIHttpChannel(iface);
 669
 670     TRACE("(%p)->(%p)\n", This, aLoadFlags);
 671
 672     *aLoadFlags = This->load_flags;
 673     return NS_OK;
 674 }
 675
 676 static nsresult NSAPI nsChannel_SetLoadFlags(nsIHttpChannel *iface, nsLoadFlags aLoadFlags)
 677 {
 678     nsChannel *This = impl_from_nsIHttpChannel(iface);
 679
 680     TRACE("(%p)->(%08x)\n", This, aLoadFlags);
 681
 682     This->load_flags = aLoadFlags;
 683     return NS_OK;
 684 }
 685
 686 static nsresult NSAPI nsChannel_GetOriginalURI(nsIHttpChannel *iface, nsIURI **aOriginalURI)
 687 {
 688     nsChannel *This = impl_from_nsIHttpChannel(iface);
 689
 690     TRACE("(%p)->(%p)\n", This, aOriginalURI);
 691
 692     if(This->original_uri)
 693         nsIURI_AddRef(This->original_uri);
 694
 695     *aOriginalURI = This->original_uri;
 696     return NS_OK;
 697 }
 698
 699 static nsresult NSAPI nsChannel_SetOriginalURI(nsIHttpChannel *iface, nsIURI *aOriginalURI)
 700 {
 701     nsChannel *This = impl_from_nsIHttpChannel(iface);
 702
 703     TRACE("(%p)->(%p)\n", This, aOriginalURI);
 704
 705     if(This->original_uri)
 706         nsIURI_Release(This->original_uri);
 707
 708     nsIURI_AddRef(aOriginalURI);
 709     This->original_uri = aOriginalURI;
 710     return NS_OK;
 711 }
 712
 713 static nsresult NSAPI nsChannel_GetURI(nsIHttpChannel *iface, nsIURI **aURI)
 714 {
 715     nsChannel *This = impl_from_nsIHttpChannel(iface);
 716
 717     TRACE("(%p)->(%p)\n", This, aURI);
 718
 719     nsIFileURL_AddRef(&This->uri->nsIFileURL_iface);
 720     *aURI = (nsIURI*)&This->uri->nsIFileURL_iface;
 721
 722     return NS_OK;
 723 }
 724
 725 static nsresult NSAPI nsChannel_GetOwner(nsIHttpChannel *iface, nsISupports **aOwner)
 726 {
 727     nsChannel *This = impl_from_nsIHttpChannel(iface);
 728
 729     TRACE("(%p)->(%p)\n", This, aOwner);
 730
 731     if(This->owner)
 732         nsISupports_AddRef(This->owner);
 733     *aOwner = This->owner;
 734
 735     return NS_OK;
 736 }
 737
 738 static nsresult NSAPI nsChannel_SetOwner(nsIHttpChannel *iface, nsISupports *aOwner)
 739 {
 740     nsChannel *This = impl_from_nsIHttpChannel(iface);
 741
 742     TRACE("(%p)->(%p)\n", This, aOwner);
 743
 744     if(aOwner)
 745         nsISupports_AddRef(aOwner);
 746     if(This->owner)
 747         nsISupports_Release(This->owner);
 748     This->owner = aOwner;
 749
 750     return NS_OK;
 751 }
 752
 753 static nsresult NSAPI nsChannel_GetNotificationCallbacks(nsIHttpChannel *iface,
 754         nsIInterfaceRequestor **aNotificationCallbacks)
 755 {
 756     nsChannel *This = impl_from_nsIHttpChannel(iface);
 757
 758     TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
 759
 760     if(This->notif_callback)
 761         nsIInterfaceRequestor_AddRef(This->notif_callback);
 762     *aNotificationCallbacks = This->notif_callback;
 763
 764     return NS_OK;
 765 }
 766
 767 static nsresult NSAPI nsChannel_SetNotificationCallbacks(nsIHttpChannel *iface,
 768         nsIInterfaceRequestor *aNotificationCallbacks)
 769 {
 770     nsChannel *This = impl_from_nsIHttpChannel(iface);
 771
 772     TRACE("(%p)->(%p)\n", This, aNotificationCallbacks);
 773
 774     if(This->notif_callback)
 775         nsIInterfaceRequestor_Release(This->notif_callback);
 776     if(aNotificationCallbacks)
 777         nsIInterfaceRequestor_AddRef(aNotificationCallbacks);
 778
 779     This->notif_callback = aNotificationCallbacks;
 780
 781     return NS_OK;
 782 }
 783
 784 static nsresult NSAPI nsChannel_GetSecurityInfo(nsIHttpChannel *iface, nsISupports **aSecurityInfo)
 785 {
 786     nsChannel *This = impl_from_nsIHttpChannel(iface);
 787
 788     TRACE("(%p)->(%p)\n", This, aSecurityInfo);
 789
 790     return NS_ERROR_NOT_IMPLEMENTED;
 791 }
 792
 793 static nsresult NSAPI nsChannel_GetContentType(nsIHttpChannel *iface, nsACString *aContentType)
 794 {
 795     nsChannel *This = impl_from_nsIHttpChannel(iface);
 796
 797     TRACE("(%p)->(%p)\n", This, aContentType);
 798
 799     if(This->content_type) {
 800         nsACString_SetData(aContentType, This->content_type);
 801         return S_OK;
 802     }
 803
 804     if(This->load_flags & LOAD_DOCUMENT_URI) {
 805         WARN("Document channel with no MIME set. Assuming text/html\n");
 806         nsACString_SetData(aContentType, "text/html");
 807         return S_OK;
 808     }
 809
 810     WARN("unknown type\n");
 811     return NS_ERROR_FAILURE;
 812 }
 813
 814 static nsresult NSAPI nsChannel_SetContentType(nsIHttpChannel *iface,
 815                                                const nsACString *aContentType)
 816 {
 817     nsChannel *This = impl_from_nsIHttpChannel(iface);
 818     const char *content_type;
 819
 820     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aContentType));
 821
 822     nsACString_GetData(aContentType, &content_type);
 823     heap_free(This->content_type);
 824     This->content_type = heap_strdupA(content_type);
 825
 826     return NS_OK;
 827 }
 828
 829 static nsresult NSAPI nsChannel_GetContentCharset(nsIHttpChannel *iface,
 830                                                   nsACString *aContentCharset)
 831 {
 832     nsChannel *This = impl_from_nsIHttpChannel(iface);
 833
 834     TRACE("(%p)->(%p)\n", This, aContentCharset);
 835
 836     if(This->charset) {
 837         nsACString_SetData(aContentCharset, This->charset);
 838         return NS_OK;
 839     }
 840
 841     nsACString_SetData(aContentCharset, "");
 842     return NS_OK;
 843 }
 844
 845 static nsresult NSAPI nsChannel_SetContentCharset(nsIHttpChannel *iface,
 846                                                   const nsACString *aContentCharset)
 847 {
 848     nsChannel *This = impl_from_nsIHttpChannel(iface);
 849     const char *data;
 850     char *charset;
 851
 852     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aContentCharset));
 853
 854     nsACString_GetData(aContentCharset, &data);
 855     charset = heap_strdupA(data);
 856     if(!charset)
 857         return NS_ERROR_OUT_OF_MEMORY;
 858
 859     heap_free(This->charset);
 860     This->charset = charset;
 861     return NS_OK;
 862 }
 863
 864 static nsresult NSAPI nsChannel_GetContentLength(nsIHttpChannel *iface, INT64 *aContentLength)
 865 {
 866     nsChannel *This = impl_from_nsIHttpChannel(iface);
 867
 868     FIXME("(%p)->(%p)\n", This, aContentLength);
 869
 870     return NS_ERROR_NOT_IMPLEMENTED;
 871 }
 872
 873 static nsresult NSAPI nsChannel_SetContentLength(nsIHttpChannel *iface, INT64 aContentLength)
 874 {
 875     nsChannel *This = impl_from_nsIHttpChannel(iface);
 876
 877     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(aContentLength));
 878
 879     return NS_ERROR_NOT_IMPLEMENTED;
 880 }
 881
 882 static nsresult NSAPI nsChannel_Open(nsIHttpChannel *iface, nsIInputStream **_retval)
 883 {
 884     nsChannel *This = impl_from_nsIHttpChannel(iface);
 885
 886     FIXME("(%p)->(%p)\n", This, _retval);
 887
 888     return NS_ERROR_NOT_IMPLEMENTED;
 889 }
 890
 891 static nsresult NSAPI nsChannel_Open2(nsIHttpChannel *iface, nsIInputStream **_retval)
 892 {
 893     nsChannel *This = impl_from_nsIHttpChannel(iface);
 894
 895     FIXME("(%p)->(%p)\n", This, _retval);
 896
 897     return NS_ERROR_NOT_IMPLEMENTED;
 898 }
 899
 900 static HTMLOuterWindow *get_channel_window(nsChannel *This)
 901 {
 902     nsIWebProgress *web_progress = NULL;
 903     mozIDOMWindowProxy *mozwindow;
 904     HTMLOuterWindow *window;
 905     nsresult nsres;
 906
 907     if(This->load_group) {
 908         nsIRequestObserver *req_observer;
 909
 910         nsres = nsILoadGroup_GetGroupObserver(This->load_group, &req_observer);
 911         if(NS_FAILED(nsres)) {
 912             ERR("GetGroupObserver failed: %08lx\n", nsres);
 913             return NULL;
 914         }
 915
 916         if(req_observer) {
 917             nsres = nsIRequestObserver_QueryInterface(req_observer, &IID_nsIWebProgress, (void**)&web_progress);
 918             nsIRequestObserver_Release(req_observer);
 919             if(NS_FAILED(nsres)) {
 920                 ERR("Could not get nsIWebProgress iface: %08lx\n", nsres);
 921                 return NULL;
 922             }
 923         }
 924     }
 925
 926     if(!web_progress && This->notif_callback) {
 927         nsres = nsIInterfaceRequestor_GetInterface(This->notif_callback, &IID_nsIWebProgress, (void**)&web_progress);
 928         if(NS_FAILED(nsres)) {
 929             ERR("GetInterface(IID_nsIWebProgress failed: %08lx\n", nsres);
 930             return NULL;
 931         }
 932     }
 933
 934     if(!web_progress) {
 935         ERR("Could not find nsIWebProgress\n");
 936         return NULL;
 937     }
 938
 939     nsres = nsIWebProgress_GetDOMWindow(web_progress, &mozwindow);
 940     nsIWebProgress_Release(web_progress);
 941     if(NS_FAILED(nsres) || !mozwindow) {
 942         ERR("GetDOMWindow failed: %08lx\n", nsres);
 943         return NULL;
 944     }
 945
 946     window = mozwindow_to_window(mozwindow);
 947     mozIDOMWindowProxy_Release(mozwindow);
 948
 949     if(window)
 950         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 951     else
 952         FIXME("NULL window for %p\n", mozwindow);
 953     return window;
 954 }
 955
 956 typedef struct {
 957     task_t header;
 958     HTMLInnerWindow *window;
 959     nsChannelBSC *bscallback;
 960 } start_binding_task_t;
 961
 962 static void start_binding_proc(task_t *_task)
 963 {
 964     start_binding_task_t *task = (start_binding_task_t*)_task;
 965
 966     start_binding(task->window, (BSCallback*)task->bscallback, NULL);
 967 }
 968
 969 static void start_binding_task_destr(task_t *_task)
 970 {
 971     start_binding_task_t *task = (start_binding_task_t*)_task;
 972
 973     IBindStatusCallback_Release(&task->bscallback->bsc.IBindStatusCallback_iface);
 974     heap_free(task);
 975 }
 976
 977 static nsresult async_open(nsChannel *This, HTMLOuterWindow *window, BOOL is_doc_channel, nsIStreamListener *listener,
 978         nsISupports *context)
 979 {
 980     nsChannelBSC *bscallback;
 981     IMoniker *mon = NULL;
 982     HRESULT hres;
 983
 984     hres = CreateURLMonikerEx2(NULL, This->uri->uri, &mon, 0);
 985     if(FAILED(hres)) {
 986         WARN("CreateURLMoniker failed: %08lx\n", hres);
 987         return NS_ERROR_UNEXPECTED;
 988     }
 989
 990     if(is_doc_channel)
 991         set_current_mon(window, mon, BINDING_NAVIGATED);
 992
 993     hres = create_channelbsc(mon, NULL, NULL, 0, is_doc_channel, &bscallback);
 994     IMoniker_Release(mon);
 995     if(FAILED(hres))
 996         return NS_ERROR_UNEXPECTED;
 997
 998     channelbsc_set_channel(bscallback, This, listener, context);
 999
1000     if(is_doc_channel) {
1001         hres = create_pending_window(window, bscallback);
1002         if(SUCCEEDED(hres))
1003             async_start_doc_binding(window, window->pending_window);
1004         IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
1005         if(FAILED(hres))
1006             return NS_ERROR_UNEXPECTED;
1007     }else {
1008         start_binding_task_t *task;
1009
1010         task = heap_alloc(sizeof(start_binding_task_t));
1011         if(!task) {
1012             IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
1013             return NS_ERROR_OUT_OF_MEMORY;
1014         }
1015
1016         task->window = window->base.inner_window;
1017         task->bscallback = bscallback;
1018         hres = push_task(&task->header, start_binding_proc, start_binding_task_destr, window->base.inner_window->task_magic);
1019         if(FAILED(hres))
1020             return NS_ERROR_OUT_OF_MEMORY;
1021     }
1022
1023     return NS_OK;
1024 }
1025
1026 static nsresult NSAPI nsChannel_AsyncOpen(nsIHttpChannel *iface, nsIStreamListener *aListener,
1027                                           nsISupports *aContext)
1028 {
1029     nsChannel *This = impl_from_nsIHttpChannel(iface);
1030     HTMLOuterWindow *window = NULL;
1031     BOOL is_document_channel;
1032     BOOL cancel = FALSE;
1033     nsresult nsres = NS_OK;
1034
1035     TRACE("(%p)->(%p %p)\n", This, aListener, aContext);
1036
1037     if(!ensure_uri(This->uri))
1038         return NS_ERROR_FAILURE;
1039
1040     if(TRACE_ON(mshtml)) {
1041         HRESULT hres;
1042         BSTR uri_str;
1043
1044         hres = IUri_GetDisplayUri(This->uri->uri, &uri_str);
1045         if(SUCCEEDED(hres)) {
1046             TRACE("opening %s\n", debugstr_w(uri_str));
1047             SysFreeString(uri_str);
1048         }else {
1049             WARN("GetDisplayUri failed: %08lx\n", hres);
1050         }
1051     }
1052
1053     window = get_channel_window(This);
1054     if(!window) {
1055         ERR("window = NULL\n");
1056         return NS_ERROR_UNEXPECTED;
1057     }
1058
1059     is_document_channel = !!(This->load_flags & LOAD_DOCUMENT_URI);
1060
1061     if(is_document_channel) {
1062         if(This->uri->channel_bsc) {
1063             channelbsc_set_channel(This->uri->channel_bsc, This, aListener, aContext);
1064             cancel = TRUE;
1065         }
1066
1067         if(is_main_content_window(window)) {
1068             if(!This->uri->channel_bsc) {
1069                 /* top window navigation initiated by Gecko */
1070                 nsres = before_async_open(This, window->browser, &cancel);
1071                 if(NS_SUCCEEDED(nsres)  && cancel) {
1072                     TRACE("canceled\n");
1073                     nsres = NS_BINDING_ABORTED;
1074                 }
1075             }else if(window->browser->doc->mime) {
1076                 heap_free(This->content_type);
1077                 This->content_type = heap_strdupWtoA(window->browser->doc->mime);
1078             }
1079         }
1080     }
1081
1082     if(!cancel)
1083         nsres = async_open(This, window, is_document_channel, aListener, aContext);
1084
1085     if(NS_SUCCEEDED(nsres) && This->load_group) {
1086         nsres = nsILoadGroup_AddRequest(This->load_group, (nsIRequest*)&This->nsIHttpChannel_iface,
1087                 aContext);
1088         if(NS_FAILED(nsres))
1089             ERR("AddRequest failed: %08lx\n", nsres);
1090     }
1091
1092     IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
1093     return nsres;
1094 }
1095
1096 static nsresult NSAPI nsChannel_AsyncOpen2(nsIHttpChannel *iface, nsIStreamListener *aListener)
1097 {
1098     nsChannel *This = impl_from_nsIHttpChannel(iface);
1099     FIXME("(%p)->(%p)\n", This, aListener);
1100     return nsIHttpChannel_AsyncOpen(&This->nsIHttpChannel_iface, aListener, NULL);
1101 }
1102
1103 static nsresult NSAPI nsChannel_GetContentDisposition(nsIHttpChannel *iface, UINT32 *aContentDisposition)
1104 {
1105     nsChannel *This = impl_from_nsIHttpChannel(iface);
1106     TRACE("(%p)->(%p) unimplemented\n", This, aContentDisposition);
1107     return NS_ERROR_NOT_IMPLEMENTED;
1108 }
1109
1110 static nsresult NSAPI nsChannel_SetContentDisposition(nsIHttpChannel *iface, UINT32 aContentDisposition)
1111 {
1112     nsChannel *This = impl_from_nsIHttpChannel(iface);
1113     FIXME("(%p)->(%u)\n", This, aContentDisposition);
1114     return NS_ERROR_NOT_IMPLEMENTED;
1115 }
1116
1117 static nsresult NSAPI nsChannel_GetContentDispositionFilename(nsIHttpChannel *iface, nsAString *aContentDispositionFilename)
1118 {
1119     nsChannel *This = impl_from_nsIHttpChannel(iface);
1120     FIXME("(%p)->(%p)\n", This, aContentDispositionFilename);
1121     return NS_ERROR_NOT_IMPLEMENTED;
1122 }
1123
1124 static nsresult NSAPI nsChannel_SetContentDispositionFilename(nsIHttpChannel *iface, const nsAString *aContentDispositionFilename)
1125 {
1126     nsChannel *This = impl_from_nsIHttpChannel(iface);
1127     FIXME("(%p)->(%p)\n", This, aContentDispositionFilename);
1128     return NS_ERROR_NOT_IMPLEMENTED;
1129 }
1130
1131 static nsresult NSAPI nsChannel_GetContentDispositionHeader(nsIHttpChannel *iface, nsACString *aContentDispositionHeader)
1132 {
1133     nsChannel *This = impl_from_nsIHttpChannel(iface);
1134     TRACE("(%p)->(%p) unimplemented\n", This, aContentDispositionHeader);
1135     return NS_ERROR_NOT_IMPLEMENTED;
1136 }
1137
1138 static nsresult NSAPI nsChannel_GetLoadInfo(nsIHttpChannel *iface, nsILoadInfo **aLoadInfo)
1139 {
1140     nsChannel *This = impl_from_nsIHttpChannel(iface);
1141
1142     TRACE("(%p)->(%p)\n", This, aLoadInfo);
1143
1144     if(This->load_info)
1145         nsISupports_AddRef(This->load_info);
1146     *aLoadInfo = This->load_info;
1147     return NS_OK;
1148 }
1149
1150 static nsresult NSAPI nsChannel_SetLoadInfo(nsIHttpChannel *iface, nsILoadInfo *aLoadInfo)
1151 {
1152     nsChannel *This = impl_from_nsIHttpChannel(iface);
1153
1154     TRACE("(%p)->(%p)\n", This, aLoadInfo);
1155
1156     if(This->load_info)
1157         nsISupports_Release(This->load_info);
1158     This->load_info = aLoadInfo;
1159     if(This->load_info)
1160         nsISupports_AddRef(This->load_info);
1161     return NS_OK;
1162 }
1163
1164 static nsresult NSAPI nsChannel_GetRequestMethod(nsIHttpChannel *iface, nsACString *aRequestMethod)
1165 {
1166     nsChannel *This = impl_from_nsIHttpChannel(iface);
1167
1168     TRACE("(%p)->(%p)\n", This, aRequestMethod);
1169
1170     nsACString_SetData(aRequestMethod, request_method_strings[This->request_method]);
1171     return NS_OK;
1172 }
1173
1174 static nsresult NSAPI nsChannel_SetRequestMethod(nsIHttpChannel *iface,
1175                                                  const nsACString *aRequestMethod)
1176 {
1177     nsChannel *This = impl_from_nsIHttpChannel(iface);
1178     const char *method;
1179     unsigned i;
1180
1181     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aRequestMethod));
1182
1183     nsACString_GetData(aRequestMethod, &method);
1184     for(i=0; i < ARRAY_SIZE(request_method_strings); i++) {
1185         if(!stricmp(method, request_method_strings[i])) {
1186             This->request_method = i;
1187             return NS_OK;
1188         }
1189     }
1190
1191     ERR("Invalid method %s\n", debugstr_a(method));
1192     return NS_ERROR_UNEXPECTED;
1193 }
1194
1195 static nsresult NSAPI nsChannel_GetReferrer(nsIHttpChannel *iface, nsIURI **aReferrer)
1196 {
1197     nsChannel *This = impl_from_nsIHttpChannel(iface);
1198
1199     TRACE("(%p)->(%p)\n", This, aReferrer);
1200
1201     if(This->referrer)
1202         nsIURI_AddRef(This->referrer);
1203     *aReferrer = This->referrer;
1204     return NS_OK;
1205 }
1206
1207 static nsresult NSAPI nsChannel_SetReferrer(nsIHttpChannel *iface, nsIURI *aReferrer)
1208 {
1209     nsChannel *This = impl_from_nsIHttpChannel(iface);
1210
1211     TRACE("(%p)->(%p)\n", This, aReferrer);
1212
1213     return nsIHttpChannel_SetReferrerWithPolicy(&This->nsIHttpChannel_iface, aReferrer, 0);
1214 }
1215
1216 static nsresult NSAPI nsChannel_GetReferrerPolicy(nsIHttpChannel *iface, UINT32 *aReferrerPolicy)
1217 {
1218     nsChannel *This = impl_from_nsIHttpChannel(iface);
1219     TRACE("(%p)->(%p) unimplemented\n", This, aReferrerPolicy);
1220     return NS_ERROR_NOT_IMPLEMENTED;
1221 }
1222
1223 static nsresult NSAPI nsChannel_SetReferrerWithPolicy(nsIHttpChannel *iface, nsIURI *aReferrer, UINT32 aReferrerPolicy)
1224 {
1225     nsChannel *This = impl_from_nsIHttpChannel(iface);
1226     DWORD channel_scheme, referrer_scheme;
1227     nsWineURI *referrer;
1228     BSTR referrer_uri;
1229     nsresult nsres;
1230     HRESULT hres;
1231
1232     static const WCHAR refererW[] = {'R','e','f','e','r','e','r'};
1233
1234     TRACE("(%p)->(%p %d)\n", This, aReferrer, aReferrerPolicy);
1235
1236     if(aReferrerPolicy)
1237         FIXME("refferer policy %d not implemented\n", aReferrerPolicy);
1238
1239     if(This->referrer) {
1240         nsIURI_Release(This->referrer);
1241         This->referrer = NULL;
1242     }
1243     if(!aReferrer)
1244         return NS_OK;
1245
1246     nsres = nsIURI_QueryInterface(aReferrer, &IID_nsWineURI, (void**)&referrer);
1247     if(NS_FAILED(nsres))
1248         return NS_OK;
1249
1250     if(!ensure_uri(referrer)) {
1251         nsIFileURL_Release(&referrer->nsIFileURL_iface);
1252         return NS_ERROR_UNEXPECTED;
1253     }
1254
1255     if(!ensure_uri(This->uri) || FAILED(IUri_GetScheme(This->uri->uri, &channel_scheme)))
1256         channel_scheme = INTERNET_SCHEME_UNKNOWN;
1257
1258     if(FAILED(IUri_GetScheme(referrer->uri, &referrer_scheme)))
1259         referrer_scheme = INTERNET_SCHEME_UNKNOWN;
1260
1261     if(referrer_scheme == INTERNET_SCHEME_HTTPS && channel_scheme != INTERNET_SCHEME_HTTPS) {
1262         TRACE("Ignoring https referrer on non-https channel\n");
1263         nsIFileURL_Release(&referrer->nsIFileURL_iface);
1264         return NS_OK;
1265     }
1266
1267     hres = IUri_GetDisplayUri(referrer->uri, &referrer_uri);
1268     if(SUCCEEDED(hres)) {
1269         set_http_header(&This->request_headers, refererW, ARRAY_SIZE(refererW), referrer_uri, SysStringLen(referrer_uri));
1270         SysFreeString(referrer_uri);
1271     }
1272
1273     This->referrer = (nsIURI*)&referrer->nsIFileURL_iface;
1274     return NS_OK;
1275 }
1276
1277 static nsresult NSAPI nsHttpChannel_GetProtocolVersion(nsIHttpChannel *iface, nsACString *aProtocolVersion)
1278 {
1279     nsChannel *This = impl_from_nsIHttpChannel(iface);
1280     FIXME("(%p)->(%p)\n", This, aProtocolVersion);
1281     return NS_ERROR_NOT_IMPLEMENTED;
1282 }
1283
1284 static nsresult NSAPI nsHttpChannel_GetTransferSize(nsIHttpChannel *iface, UINT64 *aTransferSize)
1285 {
1286     nsChannel *This = impl_from_nsIHttpChannel(iface);
1287     FIXME("(%p)->(%p)\n", This, aTransferSize);
1288     return NS_ERROR_NOT_IMPLEMENTED;
1289 }
1290
1291 static nsresult NSAPI nsHttpChannel_GetDecodedBodySize(nsIHttpChannel *iface, UINT64 *aDecodedBodySize)
1292 {
1293     nsChannel *This = impl_from_nsIHttpChannel(iface);
1294     FIXME("(%p)->(%p)\n", This, aDecodedBodySize);
1295     return NS_ERROR_NOT_IMPLEMENTED;
1296 }
1297
1298 static nsresult NSAPI nsHttpChannel_GetEncodedBodySize(nsIHttpChannel *iface, UINT64 *aEncodedBodySize)
1299 {
1300     nsChannel *This = impl_from_nsIHttpChannel(iface);
1301     FIXME("(%p)->(%p)\n", This, aEncodedBodySize);
1302     return NS_ERROR_NOT_IMPLEMENTED;
1303 }
1304
1305 static nsresult NSAPI nsChannel_GetRequestHeader(nsIHttpChannel *iface,
1306          const nsACString *aHeader, nsACString *_retval)
1307 {
1308     nsChannel *This = impl_from_nsIHttpChannel(iface);
1309
1310     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(aHeader), _retval);
1311
1312     return get_channel_http_header(&This->request_headers, aHeader, _retval);
1313 }
1314
1315 static nsresult NSAPI nsChannel_SetRequestHeader(nsIHttpChannel *iface,
1316          const nsACString *aHeader, const nsACString *aValue, cpp_bool aMerge)
1317 {
1318     nsChannel *This = impl_from_nsIHttpChannel(iface);
1319
1320     TRACE("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(aHeader), debugstr_nsacstr(aValue), aMerge);
1321
1322     if(aMerge)
1323         FIXME("aMerge not supported\n");
1324
1325     return set_channel_http_header(&This->request_headers, aHeader, aValue);
1326 }
1327
1328 static nsresult NSAPI nsChannel_SetEmptyRequestHeader(nsIHttpChannel *iface, const nsACString *aHeader)
1329 {
1330     nsChannel *This = impl_from_nsIHttpChannel(iface);
1331     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aHeader));
1332     return NS_ERROR_NOT_IMPLEMENTED;
1333 }
1334
1335 static nsresult NSAPI nsChannel_VisitRequestHeaders(nsIHttpChannel *iface,
1336                                                     nsIHttpHeaderVisitor *aVisitor)
1337 {
1338     nsChannel *This = impl_from_nsIHttpChannel(iface);
1339
1340     FIXME("(%p)->(%p)\n", This, aVisitor);
1341
1342     return NS_ERROR_NOT_IMPLEMENTED;
1343 }
1344
1345 static nsresult NSAPI nsChannel_VisitNonDefaultRequestHeaders(nsIHttpChannel *iface, nsIHttpHeaderVisitor *aVisitor)
1346 {
1347     nsChannel *This = impl_from_nsIHttpChannel(iface);
1348     FIXME("(%p)->(%p)\n", This, aVisitor);
1349     return NS_ERROR_NOT_IMPLEMENTED;
1350 }
1351
1352 static nsresult NSAPI nsChannel_GetAllowPipelining(nsIHttpChannel *iface, cpp_bool *aAllowPipelining)
1353 {
1354     nsChannel *This = impl_from_nsIHttpChannel(iface);
1355
1356     FIXME("(%p)->(%p)\n", This, aAllowPipelining);
1357
1358     return NS_ERROR_NOT_IMPLEMENTED;
1359 }
1360
1361 static nsresult NSAPI nsChannel_SetAllowPipelining(nsIHttpChannel *iface, cpp_bool aAllowPipelining)
1362 {
1363     nsChannel *This = impl_from_nsIHttpChannel(iface);
1364
1365     FIXME("(%p)->(%x)\n", This, aAllowPipelining);
1366
1367     return NS_ERROR_NOT_IMPLEMENTED;
1368 }
1369
1370 static nsresult NSAPI nsChannel_GetAllowTLS(nsIHttpChannel *iface, cpp_bool *aAllowTLS)
1371 {
1372     nsChannel *This = impl_from_nsIHttpChannel(iface);
1373     FIXME("(%p)->(%p)\n", This, aAllowTLS);
1374     return NS_ERROR_NOT_IMPLEMENTED;
1375 }
1376
1377 static nsresult NSAPI nsChannel_SetAllowTLS(nsIHttpChannel *iface, cpp_bool aAllowTLS)
1378 {
1379     nsChannel *This = impl_from_nsIHttpChannel(iface);
1380     FIXME("(%p)->(%x)\n", This, aAllowTLS);
1381     return NS_ERROR_NOT_IMPLEMENTED;
1382 }
1383
1384 static nsresult NSAPI nsChannel_GetRedirectionLimit(nsIHttpChannel *iface, UINT32 *aRedirectionLimit)
1385 {
1386     nsChannel *This = impl_from_nsIHttpChannel(iface);
1387
1388     FIXME("(%p)->(%p)\n", This, aRedirectionLimit);
1389
1390     return NS_ERROR_NOT_IMPLEMENTED;
1391 }
1392
1393 static nsresult NSAPI nsChannel_SetRedirectionLimit(nsIHttpChannel *iface, UINT32 aRedirectionLimit)
1394 {
1395     nsChannel *This = impl_from_nsIHttpChannel(iface);
1396
1397     FIXME("(%p)->(%u)\n", This, aRedirectionLimit);
1398
1399     return NS_ERROR_NOT_IMPLEMENTED;
1400 }
1401
1402 static nsresult NSAPI nsChannel_GetResponseStatus(nsIHttpChannel *iface, UINT32 *aResponseStatus)
1403 {
1404     nsChannel *This = impl_from_nsIHttpChannel(iface);
1405
1406     TRACE("(%p)->(%p)\n", This, aResponseStatus);
1407
1408     if(This->response_status) {
1409         *aResponseStatus = This->response_status;
1410         return NS_OK;
1411     }
1412
1413     WARN("No response status\n");
1414     return NS_ERROR_UNEXPECTED;
1415 }
1416
1417 static nsresult NSAPI nsChannel_GetResponseStatusText(nsIHttpChannel *iface,
1418                                                       nsACString *aResponseStatusText)
1419 {
1420     nsChannel *This = impl_from_nsIHttpChannel(iface);
1421
1422     TRACE("(%p)->(%p)\n", This, aResponseStatusText);
1423
1424     nsACString_SetData(aResponseStatusText, This->response_status_text);
1425     return NS_OK;
1426 }
1427
1428 static nsresult NSAPI nsChannel_GetRequestSucceeded(nsIHttpChannel *iface,
1429                                                     cpp_bool *aRequestSucceeded)
1430 {
1431     nsChannel *This = impl_from_nsIHttpChannel(iface);
1432
1433     TRACE("(%p)->(%p)\n", This, aRequestSucceeded);
1434
1435     if(!This->response_status)
1436         return NS_ERROR_NOT_AVAILABLE;
1437
1438     *aRequestSucceeded = This->response_status/100 == 2;
1439
1440     return NS_OK;
1441 }
1442
1443 static nsresult NSAPI nsChannel_GetIsMainDocumentChannel(nsIHttpChannel *iface, cpp_bool *aIsMainDocumentChannel)
1444 {
1445     nsChannel *This = impl_from_nsIHttpChannel(iface);
1446     FIXME("(%p)->(%p)\n", This, aIsMainDocumentChannel);
1447     return NS_ERROR_NOT_IMPLEMENTED;
1448 }
1449
1450 static nsresult NSAPI nsChannel_SetIsMainDocumentChannel(nsIHttpChannel *iface, cpp_bool aIsMainDocumentChannel)
1451 {
1452     nsChannel *This = impl_from_nsIHttpChannel(iface);
1453     FIXME("(%p)->(%x)\n", This, aIsMainDocumentChannel);
1454     return NS_ERROR_NOT_IMPLEMENTED;
1455 }
1456
1457 static nsresult NSAPI nsChannel_GetResponseHeader(nsIHttpChannel *iface,
1458          const nsACString *header, nsACString *_retval)
1459 {
1460     nsChannel *This = impl_from_nsIHttpChannel(iface);
1461
1462     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(header), _retval);
1463
1464     return get_channel_http_header(&This->response_headers, header, _retval);
1465 }
1466
1467 static nsresult NSAPI nsChannel_SetResponseHeader(nsIHttpChannel *iface,
1468         const nsACString *header, const nsACString *value, cpp_bool merge)
1469 {
1470     nsChannel *This = impl_from_nsIHttpChannel(iface);
1471
1472     FIXME("(%p)->(%s %s %x)\n", This, debugstr_nsacstr(header), debugstr_nsacstr(value), merge);
1473
1474     return NS_ERROR_NOT_IMPLEMENTED;
1475 }
1476
1477 static nsresult NSAPI nsChannel_VisitResponseHeaders(nsIHttpChannel *iface,
1478         nsIHttpHeaderVisitor *aVisitor)
1479 {
1480     nsChannel *This = impl_from_nsIHttpChannel(iface);
1481
1482     TRACE("(%p)->(%p)\n", This, aVisitor);
1483
1484     return visit_http_headers(&This->response_headers, aVisitor);
1485 }
1486
1487 static nsresult NSAPI nsChannel_IsNoStoreResponse(nsIHttpChannel *iface, cpp_bool *_retval)
1488 {
1489     nsChannel *This = impl_from_nsIHttpChannel(iface);
1490     http_header_t *header;
1491
1492     static const WCHAR cache_controlW[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l'};
1493
1494     TRACE("(%p)->(%p)\n", This, _retval);
1495
1496     header = find_http_header(&This->response_headers, cache_controlW, ARRAY_SIZE(cache_controlW));
1497     *_retval = header && !wcsicmp(header->data, L"no-store");
1498     return NS_OK;
1499 }
1500
1501 static nsresult NSAPI nsChannel_IsNoCacheResponse(nsIHttpChannel *iface, cpp_bool *_retval)
1502 {
1503     nsChannel *This = impl_from_nsIHttpChannel(iface);
1504     http_header_t *header;
1505
1506     static const WCHAR cache_controlW[] = {'C','a','c','h','e','-','C','o','n','t','r','o','l'};
1507
1508     TRACE("(%p)->(%p)\n", This, _retval);
1509
1510     header = find_http_header(&This->response_headers, cache_controlW, ARRAY_SIZE(cache_controlW));
1511     *_retval = header && !wcsicmp(header->data, L"no-cache");
1512     /* FIXME: Gecko also checks if max-age is in the past */
1513     return NS_OK;
1514 }
1515
1516 static nsresult NSAPI nsChannel_IsPrivateResponse(nsIHttpChannel *iface, cpp_bool *_retval)
1517 {
1518     nsChannel *This = impl_from_nsIHttpChannel(iface);
1519
1520     FIXME("(%p)->(%p)\n", This, _retval);
1521
1522     return NS_ERROR_NOT_IMPLEMENTED;
1523 }
1524
1525 static nsresult NSAPI nsChannel_RedirectTo(nsIHttpChannel *iface, nsIURI *aTargetURI)
1526 {
1527     nsChannel *This = impl_from_nsIHttpChannel(iface);
1528
1529     FIXME("(%p)->(%p)\n", This, aTargetURI);
1530
1531     return NS_ERROR_NOT_IMPLEMENTED;
1532 }
1533
1534 static nsresult NSAPI nsHttpChannel_GetSchedulingContextID(nsIHttpChannel *iface, nsIID *aSchedulingContextID)
1535 {
1536     nsChannel *This = impl_from_nsIHttpChannel(iface);
1537
1538     FIXME("(%p)->(%p)\n", This, aSchedulingContextID);
1539
1540     return NS_ERROR_NOT_IMPLEMENTED;
1541 }
1542
1543 static nsresult NSAPI nsHttpChannel_SetSchedulingContextID(nsIHttpChannel *iface, const nsIID aSchedulingContextID)
1544 {
1545     nsChannel *This = impl_from_nsIHttpChannel(iface);
1546
1547     FIXME("(%p)->(%s)\n", This, debugstr_guid(&aSchedulingContextID));
1548
1549     return NS_ERROR_NOT_IMPLEMENTED;
1550 }
1551
1552 static const nsIHttpChannelVtbl nsChannelVtbl = {
1553     nsChannel_QueryInterface,
1554     nsChannel_AddRef,
1555     nsChannel_Release,
1556     nsChannel_GetName,
1557     nsChannel_IsPending,
1558     nsChannel_GetStatus,
1559     nsChannel_Cancel,
1560     nsChannel_Suspend,
1561     nsChannel_Resume,
1562     nsChannel_GetLoadGroup,
1563     nsChannel_SetLoadGroup,
1564     nsChannel_GetLoadFlags,
1565     nsChannel_SetLoadFlags,
1566     nsChannel_GetOriginalURI,
1567     nsChannel_SetOriginalURI,
1568     nsChannel_GetURI,
1569     nsChannel_GetOwner,
1570     nsChannel_SetOwner,
1571     nsChannel_GetNotificationCallbacks,
1572     nsChannel_SetNotificationCallbacks,
1573     nsChannel_GetSecurityInfo,
1574     nsChannel_GetContentType,
1575     nsChannel_SetContentType,
1576     nsChannel_GetContentCharset,
1577     nsChannel_SetContentCharset,
1578     nsChannel_GetContentLength,
1579     nsChannel_SetContentLength,
1580     nsChannel_Open,
1581     nsChannel_Open2,
1582     nsChannel_AsyncOpen,
1583     nsChannel_AsyncOpen2,
1584     nsChannel_GetContentDisposition,
1585     nsChannel_SetContentDisposition,
1586     nsChannel_GetContentDispositionFilename,
1587     nsChannel_SetContentDispositionFilename,
1588     nsChannel_GetContentDispositionHeader,
1589     nsChannel_GetLoadInfo,
1590     nsChannel_SetLoadInfo,
1591     nsChannel_GetRequestMethod,
1592     nsChannel_SetRequestMethod,
1593     nsChannel_GetReferrer,
1594     nsChannel_SetReferrer,
1595     nsChannel_GetReferrerPolicy,
1596     nsChannel_SetReferrerWithPolicy,
1597     nsHttpChannel_GetProtocolVersion,
1598     nsHttpChannel_GetTransferSize,
1599     nsHttpChannel_GetDecodedBodySize,
1600     nsHttpChannel_GetEncodedBodySize,
1601     nsChannel_GetRequestHeader,
1602     nsChannel_SetRequestHeader,
1603     nsChannel_SetEmptyRequestHeader,
1604     nsChannel_VisitRequestHeaders,
1605     nsChannel_VisitNonDefaultRequestHeaders,
1606     nsChannel_GetAllowPipelining,
1607     nsChannel_SetAllowPipelining,
1608     nsChannel_GetAllowTLS,
1609     nsChannel_SetAllowTLS,
1610     nsChannel_GetRedirectionLimit,
1611     nsChannel_SetRedirectionLimit,
1612     nsChannel_GetResponseStatus,
1613     nsChannel_GetResponseStatusText,
1614     nsChannel_GetRequestSucceeded,
1615     nsChannel_GetIsMainDocumentChannel,
1616     nsChannel_SetIsMainDocumentChannel,
1617     nsChannel_GetResponseHeader,
1618     nsChannel_SetResponseHeader,
1619     nsChannel_VisitResponseHeaders,
1620     nsChannel_IsNoStoreResponse,
1621     nsChannel_IsNoCacheResponse,
1622     nsChannel_IsPrivateResponse,
1623     nsChannel_RedirectTo,
1624     nsHttpChannel_GetSchedulingContextID,
1625     nsHttpChannel_SetSchedulingContextID
1626 };
1627
1628 static inline nsChannel *impl_from_nsIUploadChannel(nsIUploadChannel *iface)
1629 {
1630     return CONTAINING_RECORD(iface, nsChannel, nsIUploadChannel_iface);
1631 }
1632
1633 static nsresult NSAPI nsUploadChannel_QueryInterface(nsIUploadChannel *iface, nsIIDRef riid,
1634         void **result)
1635 {
1636     nsChannel *This = impl_from_nsIUploadChannel(iface);
1637     return nsIHttpChannel_QueryInterface(&This->nsIHttpChannel_iface, riid, result);
1638 }
1639
1640 static nsrefcnt NSAPI nsUploadChannel_AddRef(nsIUploadChannel *iface)
1641 {
1642     nsChannel *This = impl_from_nsIUploadChannel(iface);
1643     return nsIHttpChannel_AddRef(&This->nsIHttpChannel_iface);
1644 }
1645
1646 static nsrefcnt NSAPI nsUploadChannel_Release(nsIUploadChannel *iface)
1647 {
1648     nsChannel *This = impl_from_nsIUploadChannel(iface);
1649     return nsIHttpChannel_Release(&This->nsIHttpChannel_iface);
1650 }
1651
1652 static nsresult NSAPI nsUploadChannel_SetUploadStream(nsIUploadChannel *iface,
1653         nsIInputStream *aStream, const nsACString *aContentType, INT64 aContentLength)
1654 {
1655     nsChannel *This = impl_from_nsIUploadChannel(iface);
1656     const char *content_type;
1657
1658     static const WCHAR content_typeW[] =
1659         {'C','o','n','t','e','n','t','-','T','y','p','e'};
1660
1661     TRACE("(%p)->(%p %s %s)\n", This, aStream, debugstr_nsacstr(aContentType), wine_dbgstr_longlong(aContentLength));
1662
1663     This->post_data_contains_headers = TRUE;
1664
1665     if(aContentType) {
1666         nsACString_GetData(aContentType, &content_type);
1667         if(*content_type) {
1668             WCHAR *ct;
1669
1670             ct = heap_strdupAtoW(content_type);
1671             if(!ct)
1672                 return NS_ERROR_UNEXPECTED;
1673
1674             set_http_header(&This->request_headers, content_typeW, ARRAY_SIZE(content_typeW), ct, lstrlenW(ct));
1675             heap_free(ct);
1676             This->post_data_contains_headers = FALSE;
1677         }
1678     }
1679
1680     if(aContentLength != -1)
1681         FIXME("Unsupported acontentLength = %s\n", wine_dbgstr_longlong(aContentLength));
1682
1683     if(This->post_data_stream)
1684         nsIInputStream_Release(This->post_data_stream);
1685     This->post_data_stream = aStream;
1686     if(aStream)
1687         nsIInputStream_AddRef(aStream);
1688
1689     This->request_method = METHOD_POST;
1690     return NS_OK;
1691 }
1692
1693 static nsresult NSAPI nsUploadChannel_GetUploadStream(nsIUploadChannel *iface,
1694         nsIInputStream **aUploadStream)
1695 {
1696     nsChannel *This = impl_from_nsIUploadChannel(iface);
1697
1698     TRACE("(%p)->(%p)\n", This, aUploadStream);
1699
1700     if(This->post_data_stream)
1701         nsIInputStream_AddRef(This->post_data_stream);
1702
1703     *aUploadStream = This->post_data_stream;
1704     return NS_OK;
1705 }
1706
1707 static const nsIUploadChannelVtbl nsUploadChannelVtbl = {
1708     nsUploadChannel_QueryInterface,
1709     nsUploadChannel_AddRef,
1710     nsUploadChannel_Release,
1711     nsUploadChannel_SetUploadStream,
1712     nsUploadChannel_GetUploadStream
1713 };
1714
1715 static inline nsChannel *impl_from_nsIHttpChannelInternal(nsIHttpChannelInternal *iface)
1716 {
1717     return CONTAINING_RECORD(iface, nsChannel, nsIHttpChannelInternal_iface);
1718 }
1719
1720 static nsresult NSAPI nsHttpChannelInternal_QueryInterface(nsIHttpChannelInternal *iface, nsIIDRef riid,
1721         void **result)
1722 {
1723     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1724     return nsIHttpChannel_QueryInterface(&This->nsIHttpChannel_iface, riid, result);
1725 }
1726
1727 static nsrefcnt NSAPI nsHttpChannelInternal_AddRef(nsIHttpChannelInternal *iface)
1728 {
1729     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1730     return nsIHttpChannel_AddRef(&This->nsIHttpChannel_iface);
1731 }
1732
1733 static nsrefcnt NSAPI nsHttpChannelInternal_Release(nsIHttpChannelInternal *iface)
1734 {
1735     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1736     return nsIHttpChannel_Release(&This->nsIHttpChannel_iface);
1737 }
1738
1739 static nsresult NSAPI nsHttpChannelInternal_GetDocumentURI(nsIHttpChannelInternal *iface, nsIURI **aDocumentURI)
1740 {
1741     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1742
1743     FIXME("(%p)->()\n", This);
1744
1745     return NS_ERROR_NOT_IMPLEMENTED;
1746 }
1747
1748 static nsresult NSAPI nsHttpChannelInternal_SetDocumentURI(nsIHttpChannelInternal *iface, nsIURI *aDocumentURI)
1749 {
1750     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1751
1752     TRACE("(%p)->() unimplemented\n", This);
1753
1754     return NS_ERROR_NOT_IMPLEMENTED;
1755 }
1756
1757 static nsresult NSAPI nsHttpChannelInternal_GetRequestVersion(nsIHttpChannelInternal *iface, UINT32 *major, UINT32 *minor)
1758 {
1759     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1760
1761     FIXME("(%p)->()\n", This);
1762
1763     return NS_ERROR_NOT_IMPLEMENTED;
1764 }
1765
1766 static nsresult NSAPI nsHttpChannelInternal_GetResponseVersion(nsIHttpChannelInternal *iface, UINT32 *major, UINT32 *minor)
1767 {
1768     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1769
1770     FIXME("(%p)->()\n", This);
1771
1772     return NS_ERROR_NOT_IMPLEMENTED;
1773 }
1774
1775 static nsresult NSAPI nsHttpChannelInternal_TakeAllSecurityMessages(nsIHttpChannelInternal *iface, void *aMessages)
1776 {
1777     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1778
1779     TRACE("(%p)->(%p) unimplemented\n", This, aMessages);
1780
1781     return NS_ERROR_NOT_IMPLEMENTED;
1782 }
1783
1784 static nsresult NSAPI nsHttpChannelInternal_SetCookie(nsIHttpChannelInternal *iface, const char *aCookieHeader)
1785 {
1786     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1787
1788     FIXME("(%p)->()\n", This);
1789
1790     return NS_ERROR_NOT_IMPLEMENTED;
1791 }
1792
1793 static nsresult NSAPI nsHttpChannelInternal_SetupFallbackChannel(nsIHttpChannelInternal *iface, const char *aFallbackKey)
1794 {
1795     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1796
1797     FIXME("(%p)->()\n", This);
1798
1799     return NS_ERROR_NOT_IMPLEMENTED;
1800 }
1801
1802 static nsresult NSAPI nsHttpChannelInternal_GetThirdPartyFlags(nsIHttpChannelInternal *iface, UINT32 *aThirdPartyFlags)
1803 {
1804     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1805     FIXME("(%p)->(%p)\n", This, aThirdPartyFlags);
1806     return NS_ERROR_NOT_IMPLEMENTED;
1807 }
1808
1809 static nsresult NSAPI nsHttpChannelInternal_SetThirdPartyFlags(nsIHttpChannelInternal *iface, UINT32 aThirdPartyFlags)
1810 {
1811     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1812     FIXME("(%p)->(%x)\n", This, aThirdPartyFlags);
1813     return NS_ERROR_NOT_IMPLEMENTED;
1814 }
1815
1816 static nsresult NSAPI nsHttpChannelInternal_GetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, cpp_bool *aForceThirdPartyCookie)
1817 {
1818     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1819
1820     FIXME("(%p)->()\n", This);
1821
1822     return NS_ERROR_NOT_IMPLEMENTED;
1823 }
1824
1825 static nsresult NSAPI nsHttpChannelInternal_SetForceAllowThirdPartyCookie(nsIHttpChannelInternal *iface, cpp_bool aForceThirdPartyCookie)
1826 {
1827     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1828
1829     FIXME("(%p)->()\n", This);
1830
1831     return NS_ERROR_NOT_IMPLEMENTED;
1832 }
1833
1834 static nsresult NSAPI nsHttpChannelInternal_GetCanceled(nsIHttpChannelInternal *iface, cpp_bool *aCanceled)
1835 {
1836     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1837
1838     FIXME("(%p)->(%p)\n", This, aCanceled);
1839
1840     return NS_ERROR_NOT_IMPLEMENTED;
1841 }
1842
1843 static nsresult NSAPI nsHttpChannelInternal_GetChannelIsForDownload(nsIHttpChannelInternal *iface, cpp_bool *aCanceled)
1844 {
1845     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1846
1847     FIXME("(%p)->(%p)\n", This, aCanceled);
1848
1849     return NS_ERROR_NOT_IMPLEMENTED;
1850 }
1851
1852 static nsresult NSAPI nsHttpChannelInternal_SetChannelIsForDownload(nsIHttpChannelInternal *iface, cpp_bool aCanceled)
1853 {
1854     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1855
1856     FIXME("(%p)->(%x)\n", This, aCanceled);
1857
1858     return NS_ERROR_NOT_IMPLEMENTED;
1859 }
1860
1861 static nsresult NSAPI nsHttpChannelInternal_GetLocalAddress(nsIHttpChannelInternal *iface, nsACString *aLocalAddress)
1862 {
1863     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1864
1865     FIXME("(%p)->(%p)\n", This, aLocalAddress);
1866
1867     return NS_ERROR_NOT_IMPLEMENTED;
1868 }
1869
1870 static nsresult NSAPI nsHttpChannelInternal_GetLocalPort(nsIHttpChannelInternal *iface, LONG *aLocalPort)
1871 {
1872     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1873
1874     FIXME("(%p)->(%p)\n", This, aLocalPort);
1875
1876     return NS_ERROR_NOT_IMPLEMENTED;
1877 }
1878
1879 static nsresult NSAPI nsHttpChannelInternal_GetRemoteAddress(nsIHttpChannelInternal *iface, nsACString *aRemoteAddress)
1880 {
1881     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1882
1883     FIXME("(%p)->(%p)\n", This, aRemoteAddress);
1884
1885     return NS_ERROR_NOT_IMPLEMENTED;
1886 }
1887
1888 static nsresult NSAPI nsHttpChannelInternal_GetRemotePort(nsIHttpChannelInternal *iface, LONG *aRemotePort)
1889 {
1890     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1891
1892     FIXME("(%p)->(%p)\n", This, aRemotePort);
1893
1894     return NS_ERROR_NOT_IMPLEMENTED;
1895 }
1896
1897 static nsresult NSAPI nsHttpChannelInternal_SetCacheKeysRedirectChain(nsIHttpChannelInternal *iface, void *cacheKeys)
1898 {
1899     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1900
1901     FIXME("(%p)->(%p)\n", This, cacheKeys);
1902
1903     return NS_ERROR_NOT_IMPLEMENTED;
1904 }
1905
1906 static nsresult NSAPI nsHttpChannelInternal_HTTPUpgrade(nsIHttpChannelInternal *iface,
1907         const nsACString *aProtocolName, nsIHttpUpgradeListener *aListener)
1908 {
1909     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1910     FIXME("(%p)->(%s %p)\n", This, debugstr_nsacstr(aProtocolName), aListener);
1911     return NS_ERROR_NOT_IMPLEMENTED;
1912 }
1913
1914 static nsresult NSAPI nsHttpChannelInternal_GetAllowSpdy(nsIHttpChannelInternal *iface, cpp_bool *aAllowSpdy)
1915 {
1916     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1917     FIXME("(%p)->(%p)\n", This, aAllowSpdy);
1918     return NS_ERROR_NOT_IMPLEMENTED;
1919 }
1920
1921 static nsresult NSAPI nsHttpChannelInternal_SetAllowSpdy(nsIHttpChannelInternal *iface, cpp_bool aAllowSpdy)
1922 {
1923     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1924     FIXME("(%p)->(%x)\n", This, aAllowSpdy);
1925     return NS_ERROR_NOT_IMPLEMENTED;
1926 }
1927
1928 static nsresult NSAPI nsHttpChannelInternal_GetResponseTimeoutEnabled(nsIHttpChannelInternal *iface,
1929         cpp_bool *aResponseTimeoutEnabled)
1930 {
1931     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1932     FIXME("(%p)->(%p)\n", This, aResponseTimeoutEnabled);
1933     return NS_ERROR_NOT_IMPLEMENTED;
1934 }
1935
1936 static nsresult NSAPI nsHttpChannelInternal_SetResponseTimeoutEnabled(nsIHttpChannelInternal *iface,
1937         cpp_bool aResponseTimeoutEnabled)
1938 {
1939     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1940     FIXME("(%p)->(%x)\n", This, aResponseTimeoutEnabled);
1941     return NS_ERROR_NOT_IMPLEMENTED;
1942 }
1943
1944 static nsresult NSAPI nsHttpChannelInternal_GetInitialRwin(nsIHttpChannelInternal *iface,
1945         UINT32 *aInitialRwin)
1946 {
1947     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1948     FIXME("(%p)->(%p)\n", This, aInitialRwin);
1949     return NS_ERROR_NOT_IMPLEMENTED;
1950 }
1951
1952 static nsresult NSAPI nsHttpChannelInternal_SetInitialRwin(nsIHttpChannelInternal *iface,
1953         UINT32 aInitialRwin)
1954 {
1955     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1956     FIXME("(%p)->(%x)\n", This, aInitialRwin);
1957     return NS_ERROR_NOT_IMPLEMENTED;
1958 }
1959
1960 static nsresult NSAPI nsHttpChannelInternal_GetApiRedirectToURI(nsIHttpChannelInternal *iface, nsIURI **aApiRedirectToURI)
1961 {
1962     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1963     FIXME("(%p)->(%p)\n", This, aApiRedirectToURI);
1964     return NS_ERROR_NOT_IMPLEMENTED;
1965 }
1966
1967 static nsresult NSAPI nsHttpChannelInternal_GetAllowAltSvc(nsIHttpChannelInternal *iface, cpp_bool *aAllowAltSvc)
1968 {
1969     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1970     FIXME("(%p)->(%p)\n", This, aAllowAltSvc);
1971     return NS_ERROR_NOT_IMPLEMENTED;
1972 }
1973
1974 static nsresult NSAPI nsHttpChannelInternal_SetAllowAltSvc(nsIHttpChannelInternal *iface, cpp_bool aAllowAltSvc)
1975 {
1976     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1977     FIXME("(%p)->(%x)\n", This, aAllowAltSvc);
1978     return NS_ERROR_NOT_IMPLEMENTED;
1979 }
1980
1981 static nsresult NSAPI nsHttpChannelInternal_GetLastModifiedTime(nsIHttpChannelInternal *iface, PRTime *aLastModifiedTime)
1982 {
1983     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1984     FIXME("(%p)->(%p)\n", This, aLastModifiedTime);
1985     return NS_ERROR_NOT_IMPLEMENTED;
1986 }
1987
1988 static nsresult NSAPI nsHttpChannelInternal_ForceIntercepted(nsIHttpChannelInternal *iface, UINT64 aInterceptionID)
1989 {
1990     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1991     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(aInterceptionID));
1992     return NS_ERROR_NOT_IMPLEMENTED;
1993 }
1994
1995 static nsresult NSAPI nsHttpChannelInternal_GetResponseSynthesized(nsIHttpChannelInternal *iface, cpp_bool *ResponseSynthesized)
1996 {
1997     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
1998     FIXME("(%p, %p)\n", This, ResponseSynthesized);
1999     return NS_ERROR_NOT_IMPLEMENTED;
2000 }
2001
2002 static nsresult NSAPI nsHttpChannelInternal_GetCorsIncludeCredentials(nsIHttpChannelInternal *iface,
2003         cpp_bool *aCorsIncludeCredentials)
2004 {
2005     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2006     FIXME("(%p)->(%p)\n", This, aCorsIncludeCredentials);
2007     return NS_ERROR_NOT_IMPLEMENTED;
2008 }
2009
2010 static nsresult NSAPI nsHttpChannelInternal_SetCorsIncludeCredentials(nsIHttpChannelInternal *iface,
2011         cpp_bool aCorsIncludeCredentials)
2012 {
2013     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2014     TRACE("(%p)->(%x)\n", This, aCorsIncludeCredentials);
2015     return NS_OK;
2016 }
2017
2018 static nsresult NSAPI nsHttpChannelInternal_GetCorsMode(nsIHttpChannelInternal *iface, UINT32 *aCorsMode)
2019 {
2020     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2021     FIXME("(%p)->(%p)\n", This, aCorsMode);
2022     return NS_ERROR_NOT_IMPLEMENTED;
2023 }
2024
2025 static nsresult NSAPI nsHttpChannelInternal_SetCorsMode(nsIHttpChannelInternal *iface, UINT32 aCorsMode)
2026 {
2027     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2028     TRACE("(%p)->(%d)\n", This, aCorsMode);
2029     return NS_OK;
2030 }
2031
2032 static nsresult NSAPI nsHttpChannelInternal_GetRedirectMode(nsIHttpChannelInternal *iface, UINT32 *aRedirectMode)
2033 {
2034     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2035     FIXME("(%p)->(%p)\n", This, aRedirectMode);
2036     return NS_ERROR_NOT_IMPLEMENTED;
2037 }
2038
2039 static nsresult NSAPI nsHttpChannelInternal_SetRedirectMode(nsIHttpChannelInternal *iface, UINT32 aRedirectMode)
2040 {
2041     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2042     TRACE("(%p)->(%d) unimplemented\n", This, aRedirectMode);
2043     return NS_ERROR_NOT_IMPLEMENTED;
2044 }
2045
2046 static nsresult NSAPI nsHttpChannelInternal_GetTopWindowURI(nsIHttpChannelInternal *iface, nsIURI **aTopWindowURI)
2047 {
2048     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2049     FIXME("(%p)->(%p)\n", This, aTopWindowURI);
2050     return NS_ERROR_NOT_IMPLEMENTED;
2051 }
2052
2053 static nsresult NSAPI nsHttpChannelInternal_GetNetworkInterfaceId(nsIHttpChannelInternal *iface,
2054         nsACString *aNetworkInterfaceId)
2055 {
2056     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2057     FIXME("(%p)->(%p)\n", This, aNetworkInterfaceId);
2058     return NS_ERROR_NOT_IMPLEMENTED;
2059 }
2060
2061 static nsresult NSAPI nsHttpChannelInternal_SetNetworkInterfaceId(nsIHttpChannelInternal *iface,
2062         const nsACString *aNetworkInterfaceId)
2063 {
2064     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2065     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aNetworkInterfaceId));
2066     return NS_ERROR_NOT_IMPLEMENTED;
2067 }
2068
2069 static nsresult NSAPI nsHttpChannelInternal_GetProxyURI(nsIHttpChannelInternal *iface, nsIURI **aProxyURI)
2070 {
2071     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2072     FIXME("(%p)->(%p)\n", This, aProxyURI);
2073     return NS_ERROR_NOT_IMPLEMENTED;
2074 }
2075
2076 static nsresult NSAPI nsHttpChannelInternal_SetCorsPreflightParameters(nsIHttpChannelInternal *iface,
2077         const void /*nsTArray<nsCString>*/ *unsafeHeaders)
2078 {
2079     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2080     FIXME("(%p)->(%p)\n", This, unsafeHeaders);
2081     return NS_ERROR_NOT_IMPLEMENTED;
2082 }
2083
2084 static nsresult NSAPI nsHttpChannelInternal_GetBlockAuthPrompt(nsIHttpChannelInternal *iface, cpp_bool *aBlockAuthPrompt)
2085 {
2086     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2087     FIXME("(%p)->(%p)\n", This, aBlockAuthPrompt);
2088     return NS_ERROR_NOT_IMPLEMENTED;
2089 }
2090
2091 static nsresult NSAPI nsHttpChannelInternal_SetBlockAuthPrompt(nsIHttpChannelInternal *iface, cpp_bool aBlockAuthPrompt)
2092 {
2093     nsChannel *This = impl_from_nsIHttpChannelInternal(iface);
2094     FIXME("(%p)->(%x)\n", This, aBlockAuthPrompt);
2095     return NS_ERROR_NOT_IMPLEMENTED;
2096 }
2097
2098 static const nsIHttpChannelInternalVtbl nsHttpChannelInternalVtbl = {
2099     nsHttpChannelInternal_QueryInterface,
2100     nsHttpChannelInternal_AddRef,
2101     nsHttpChannelInternal_Release,
2102     nsHttpChannelInternal_GetDocumentURI,
2103     nsHttpChannelInternal_SetDocumentURI,
2104     nsHttpChannelInternal_GetRequestVersion,
2105     nsHttpChannelInternal_GetResponseVersion,
2106     nsHttpChannelInternal_TakeAllSecurityMessages,
2107     nsHttpChannelInternal_SetCookie,
2108     nsHttpChannelInternal_SetupFallbackChannel,
2109     nsHttpChannelInternal_GetThirdPartyFlags,
2110     nsHttpChannelInternal_SetThirdPartyFlags,
2111     nsHttpChannelInternal_GetForceAllowThirdPartyCookie,
2112     nsHttpChannelInternal_SetForceAllowThirdPartyCookie,
2113     nsHttpChannelInternal_GetCanceled,
2114     nsHttpChannelInternal_GetChannelIsForDownload,
2115     nsHttpChannelInternal_SetChannelIsForDownload,
2116     nsHttpChannelInternal_GetLocalAddress,
2117     nsHttpChannelInternal_GetLocalPort,
2118     nsHttpChannelInternal_GetRemoteAddress,
2119     nsHttpChannelInternal_GetRemotePort,
2120     nsHttpChannelInternal_SetCacheKeysRedirectChain,
2121     nsHttpChannelInternal_HTTPUpgrade,
2122     nsHttpChannelInternal_GetAllowSpdy,
2123     nsHttpChannelInternal_SetAllowSpdy,
2124     nsHttpChannelInternal_GetResponseTimeoutEnabled,
2125     nsHttpChannelInternal_SetResponseTimeoutEnabled,
2126     nsHttpChannelInternal_GetInitialRwin,
2127     nsHttpChannelInternal_SetInitialRwin,
2128     nsHttpChannelInternal_GetApiRedirectToURI,
2129     nsHttpChannelInternal_GetAllowAltSvc,
2130     nsHttpChannelInternal_SetAllowAltSvc,
2131     nsHttpChannelInternal_GetLastModifiedTime,
2132     nsHttpChannelInternal_ForceIntercepted,
2133     nsHttpChannelInternal_GetResponseSynthesized,
2134     nsHttpChannelInternal_GetCorsIncludeCredentials,
2135     nsHttpChannelInternal_SetCorsIncludeCredentials,
2136     nsHttpChannelInternal_GetCorsMode,
2137     nsHttpChannelInternal_SetCorsMode,
2138     nsHttpChannelInternal_GetRedirectMode,
2139     nsHttpChannelInternal_SetRedirectMode,
2140     nsHttpChannelInternal_GetTopWindowURI,
2141     nsHttpChannelInternal_GetNetworkInterfaceId,
2142     nsHttpChannelInternal_SetNetworkInterfaceId,
2143     nsHttpChannelInternal_GetProxyURI,
2144     nsHttpChannelInternal_SetCorsPreflightParameters,
2145     nsHttpChannelInternal_GetBlockAuthPrompt,
2146     nsHttpChannelInternal_SetBlockAuthPrompt
2147 };
2148
2149 static inline nsChannel *impl_from_nsICacheInfoChannel(nsICacheInfoChannel *iface)
2150 {
2151     return CONTAINING_RECORD(iface, nsChannel, nsICacheInfoChannel_iface);
2152 }
2153
2154 static nsresult NSAPI nsCacheInfoChannel_QueryInterface(nsICacheInfoChannel *iface, nsIIDRef riid,
2155         void **result)
2156 {
2157     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2158     return nsIHttpChannel_QueryInterface(&This->nsIHttpChannel_iface, riid, result);
2159 }
2160
2161 static nsrefcnt NSAPI nsCacheInfoChannel_AddRef(nsICacheInfoChannel *iface)
2162 {
2163     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2164     return nsIHttpChannel_AddRef(&This->nsIHttpChannel_iface);
2165 }
2166
2167 static nsrefcnt NSAPI nsCacheInfoChannel_Release(nsICacheInfoChannel *iface)
2168 {
2169     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2170     return nsIHttpChannel_Release(&This->nsIHttpChannel_iface);
2171 }
2172
2173 static nsresult NSAPI nsCacheInfoChannel_GetCacheTokenExpirationTime(nsICacheInfoChannel *iface, UINT32 *p)
2174 {
2175     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2176     FIXME("(%p)->(%p)\n", This, p);
2177     return E_NOTIMPL;
2178 }
2179
2180 static nsresult NSAPI nsCacheInfoChannel_GetCacheTokenCachedCharset(nsICacheInfoChannel *iface, nsACString *p)
2181 {
2182     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2183     FIXME("(%p)->(%p)\n", This, p);
2184     return E_NOTIMPL;
2185 }
2186
2187 static nsresult NSAPI nsCacheInfoChannel_SetCacheTokenCachedCharset(nsICacheInfoChannel *iface, const nsACString *p)
2188 {
2189     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2190     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(p));
2191     return E_NOTIMPL;
2192 }
2193
2194 static nsresult NSAPI nsCacheInfoChannel_IsFromCache(nsICacheInfoChannel *iface, cpp_bool *p)
2195 {
2196     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2197     FIXME("(%p)->(%p)\n", This, p);
2198     *p = FALSE;
2199     return NS_OK;
2200 }
2201
2202 static nsresult NSAPI nsCacheInfoChannel_GetCacheKey(nsICacheInfoChannel *iface, nsISupports **p)
2203 {
2204     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2205     FIXME("(%p)->(%p)\n", This, p);
2206     return E_NOTIMPL;
2207 }
2208
2209 static nsresult NSAPI nsCacheInfoChannel_SetCacheKey(nsICacheInfoChannel *iface, nsISupports *key)
2210 {
2211     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2212     FIXME("(%p)->(%p)\n", This, key);
2213     return E_NOTIMPL;
2214 }
2215
2216 static nsresult NSAPI nsCacheInfoChannel_GetAllowStaleCacheContent(nsICacheInfoChannel *iface, cpp_bool *p)
2217 {
2218     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2219     FIXME("(%p)->(%p)\n", This, p);
2220     return E_NOTIMPL;
2221 }
2222
2223 static nsresult NSAPI nsCacheInfoChannel_SetAllowStaleCacheContent(nsICacheInfoChannel *iface, cpp_bool allow)
2224 {
2225     nsChannel *This = impl_from_nsICacheInfoChannel(iface);
2226     FIXME("(%p)->(%x)\n", This, allow);
2227     return E_NOTIMPL;
2228 }
2229
2230 static const nsICacheInfoChannelVtbl nsCacheInfoChannelVtbl = {
2231     nsCacheInfoChannel_QueryInterface,
2232     nsCacheInfoChannel_AddRef,
2233     nsCacheInfoChannel_Release,
2234     nsCacheInfoChannel_GetCacheTokenExpirationTime,
2235     nsCacheInfoChannel_GetCacheTokenCachedCharset,
2236     nsCacheInfoChannel_SetCacheTokenCachedCharset,
2237     nsCacheInfoChannel_IsFromCache,
2238     nsCacheInfoChannel_GetCacheKey,
2239     nsCacheInfoChannel_SetCacheKey,
2240     nsCacheInfoChannel_GetAllowStaleCacheContent,
2241     nsCacheInfoChannel_SetAllowStaleCacheContent
2242 };
2243
2244 static void invalidate_uri(nsWineURI *This)
2245 {
2246     if(This->uri) {
2247         IUri_Release(This->uri);
2248         This->uri = NULL;
2249     }
2250 }
2251
2252 static BOOL ensure_uri_builder(nsWineURI *This)
2253 {
2254     if(!This->is_mutable) {
2255         WARN("Not mutable URI\n");
2256         return FALSE;
2257     }
2258
2259     if(!This->uri_builder) {
2260         HRESULT hres;
2261
2262         if(!ensure_uri(This))
2263             return FALSE;
2264
2265         hres = CreateIUriBuilder(This->uri, 0, 0, &This->uri_builder);
2266         if(FAILED(hres)) {
2267             WARN("CreateIUriBuilder failed: %08lx\n", hres);
2268             return FALSE;
2269         }
2270     }
2271
2272     invalidate_uri(This);
2273     return TRUE;
2274 }
2275
2276 static nsresult get_uri_string(nsWineURI *This, Uri_PROPERTY prop, nsACString *ret)
2277 {
2278     char *vala;
2279     BSTR val;
2280     HRESULT hres;
2281
2282     if(!ensure_uri(This))
2283         return NS_ERROR_UNEXPECTED;
2284
2285     hres = IUri_GetPropertyBSTR(This->uri, prop, &val, 0);
2286     if(FAILED(hres)) {
2287         WARN("GetPropertyBSTR failed: %08lx\n", hres);
2288         return NS_ERROR_UNEXPECTED;
2289     }
2290
2291     vala = heap_strdupWtoU(val);
2292     SysFreeString(val);
2293     if(!vala)
2294         return NS_ERROR_OUT_OF_MEMORY;
2295
2296     TRACE("ret %s\n", debugstr_a(vala));
2297     nsACString_SetData(ret, vala);
2298     heap_free(vala);
2299     return NS_OK;
2300 }
2301
2302 static inline nsWineURI *impl_from_nsIFileURL(nsIFileURL *iface)
2303 {
2304     return CONTAINING_RECORD(iface, nsWineURI, nsIFileURL_iface);
2305 }
2306
2307 static nsresult NSAPI nsURI_QueryInterface(nsIFileURL *iface, nsIIDRef riid, void **result)
2308 {
2309     nsWineURI *This = impl_from_nsIFileURL(iface);
2310
2311     *result = NULL;
2312
2313     if(IsEqualGUID(&IID_nsISupports, riid)) {
2314         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
2315         *result = &This->nsIFileURL_iface;
2316     }else if(IsEqualGUID(&IID_nsIURI, riid)) {
2317         TRACE("(%p)->(IID_nsIURI %p)\n", This, result);
2318         *result = &This->nsIFileURL_iface;
2319     }else if(IsEqualGUID(&IID_nsIURL, riid)) {
2320         TRACE("(%p)->(IID_nsIURL %p)\n", This, result);
2321         *result = &This->nsIFileURL_iface;
2322     }else if(IsEqualGUID(&IID_nsIFileURL, riid)) {
2323         TRACE("(%p)->(IID_nsIFileURL %p)\n", This, result);
2324         *result = This->scheme == URL_SCHEME_FILE ? &This->nsIFileURL_iface : NULL;
2325     }else if(IsEqualGUID(&IID_nsIMutable, riid)) {
2326         TRACE("(%p)->(IID_nsIMutable %p)\n", This, result);
2327         *result = &This->nsIStandardURL_iface;
2328     }else if(IsEqualGUID(&IID_nsIStandardURL, riid)) {
2329         TRACE("(%p)->(IID_nsIStandardURL %p)\n", This, result);
2330         *result = &This->nsIStandardURL_iface;
2331     }else if(IsEqualGUID(&IID_nsWineURI, riid)) {
2332         TRACE("(%p)->(IID_nsWineURI %p)\n", This, result);
2333         *result = This;
2334     }
2335
2336     if(*result) {
2337         nsIFileURL_AddRef(&This->nsIFileURL_iface);
2338         return NS_OK;
2339     }
2340
2341     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
2342     return NS_NOINTERFACE;
2343 }
2344
2345 static nsrefcnt NSAPI nsURI_AddRef(nsIFileURL *iface)
2346 {
2347     nsWineURI *This = impl_from_nsIFileURL(iface);
2348     LONG ref = InterlockedIncrement(&This->ref);
2349
2350     TRACE("(%p) ref=%ld\n", This, ref);
2351
2352     return ref;
2353 }
2354
2355 static nsrefcnt NSAPI nsURI_Release(nsIFileURL *iface)
2356 {
2357     nsWineURI *This = impl_from_nsIFileURL(iface);
2358     LONG ref = InterlockedDecrement(&This->ref);
2359
2360     TRACE("(%p) ref=%ld\n", This, ref);
2361
2362     if(!ref) {
2363         if(This->uri)
2364             IUri_Release(This->uri);
2365         if(This->uri_builder)
2366             IUriBuilder_Release(This->uri_builder);
2367         heap_free(This);
2368     }
2369
2370     return ref;
2371 }
2372
2373 static nsresult NSAPI nsURI_GetSpec(nsIFileURL *iface, nsACString *aSpec)
2374 {
2375     nsWineURI *This = impl_from_nsIFileURL(iface);
2376
2377     TRACE("(%p)->(%p)\n", This, aSpec);
2378
2379     return get_uri_string(This, Uri_PROPERTY_DISPLAY_URI, aSpec);
2380 }
2381
2382 static nsresult NSAPI nsURI_SetSpec(nsIFileURL *iface, const nsACString *aSpec)
2383 {
2384     nsWineURI *This = impl_from_nsIFileURL(iface);
2385     const char *speca;
2386     WCHAR *spec;
2387     IUri *uri;
2388     HRESULT hres;
2389
2390     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aSpec));
2391
2392     if(!This->is_mutable)
2393         return NS_ERROR_UNEXPECTED;
2394
2395     nsACString_GetData(aSpec, &speca);
2396     spec = heap_strdupUtoW(speca);
2397     if(!spec)
2398         return NS_ERROR_OUT_OF_MEMORY;
2399
2400     hres = create_uri(spec, 0, &uri);
2401     heap_free(spec);
2402     if(FAILED(hres)) {
2403         WARN("create_uri failed: %08lx\n", hres);
2404         return NS_ERROR_FAILURE;
2405     }
2406
2407     invalidate_uri(This);
2408     if(This->uri_builder) {
2409         IUriBuilder_Release(This->uri_builder);
2410         This->uri_builder = NULL;
2411     }
2412
2413     This->uri = uri;
2414     return NS_OK;
2415 }
2416
2417 static nsresult NSAPI nsURI_GetPrePath(nsIFileURL *iface, nsACString *aPrePath)
2418 {
2419     nsWineURI *This = impl_from_nsIFileURL(iface);
2420     IUriBuilder *uri_builder;
2421     BSTR display_uri;
2422     IUri *uri;
2423     int len;
2424     nsresult nsres;
2425     HRESULT hres;
2426
2427     TRACE("(%p)->(%p)\n", This, aPrePath);
2428
2429     if(!ensure_uri(This))
2430         return NS_ERROR_UNEXPECTED;
2431
2432     hres = CreateIUriBuilder(This->uri, 0, 0, &uri_builder);
2433     if(FAILED(hres))
2434         return NS_ERROR_FAILURE;
2435
2436     hres = IUriBuilder_RemoveProperties(uri_builder, Uri_HAS_PATH|Uri_HAS_QUERY|Uri_HAS_FRAGMENT);
2437     if(SUCCEEDED(hres))
2438         hres = IUriBuilder_CreateUriSimple(uri_builder, 0, 0, &uri);
2439     IUriBuilder_Release(uri_builder);
2440     if(FAILED(hres))
2441         return NS_ERROR_FAILURE;
2442
2443     hres = IUri_GetDisplayUri(uri, &display_uri);
2444     IUri_Release(uri);
2445     if(FAILED(hres))
2446         return NS_ERROR_FAILURE;
2447
2448     /* Remove trailing slash that may be appended as default path. */
2449     len = SysStringLen(display_uri);
2450     if(len && display_uri[len-1] == '/')
2451         display_uri[len-1] = 0;
2452
2453     nsres = return_wstr_nsacstr(aPrePath, display_uri, -1);
2454     SysFreeString(display_uri);
2455     return nsres;
2456 }
2457
2458 static nsresult NSAPI nsURI_GetScheme(nsIFileURL *iface, nsACString *aScheme)
2459 {
2460     nsWineURI *This = impl_from_nsIFileURL(iface);
2461     DWORD scheme;
2462     HRESULT hres;
2463
2464     TRACE("(%p)->(%p)\n", This, aScheme);
2465
2466     if(!ensure_uri(This))
2467         return NS_ERROR_UNEXPECTED;
2468
2469     hres = IUri_GetScheme(This->uri, &scheme);
2470     if(FAILED(hres)) {
2471         WARN("GetScheme failed: %08lx\n", hres);
2472         return NS_ERROR_UNEXPECTED;
2473     }
2474
2475     if(scheme == URL_SCHEME_ABOUT) {
2476         nsACString_SetData(aScheme, "wine");
2477         return NS_OK;
2478     }
2479
2480     return get_uri_string(This, Uri_PROPERTY_SCHEME_NAME, aScheme);
2481 }
2482
2483 static nsresult NSAPI nsURI_SetScheme(nsIFileURL *iface, const nsACString *aScheme)
2484 {
2485     nsWineURI *This = impl_from_nsIFileURL(iface);
2486     const char *schemea;
2487     WCHAR *scheme;
2488     HRESULT hres;
2489
2490     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aScheme));
2491
2492     if(!ensure_uri_builder(This))
2493         return NS_ERROR_UNEXPECTED;
2494
2495     nsACString_GetData(aScheme, &schemea);
2496     scheme = heap_strdupUtoW(schemea);
2497     if(!scheme)
2498         return NS_ERROR_OUT_OF_MEMORY;
2499
2500     hres = IUriBuilder_SetSchemeName(This->uri_builder, scheme);
2501     heap_free(scheme);
2502     if(FAILED(hres))
2503         return NS_ERROR_UNEXPECTED;
2504
2505     return NS_OK;
2506 }
2507
2508 static nsresult NSAPI nsURI_GetUserPass(nsIFileURL *iface, nsACString *aUserPass)
2509 {
2510     nsWineURI *This = impl_from_nsIFileURL(iface);
2511     BSTR user, pass;
2512     HRESULT hres;
2513
2514     TRACE("(%p)->(%p)\n", This, aUserPass);
2515
2516     if(!ensure_uri(This))
2517         return NS_ERROR_UNEXPECTED;
2518
2519     hres = IUri_GetUserName(This->uri, &user);
2520     if(FAILED(hres))
2521         return NS_ERROR_FAILURE;
2522
2523     hres = IUri_GetPassword(This->uri, &pass);
2524     if(FAILED(hres)) {
2525         SysFreeString(user);
2526         return NS_ERROR_FAILURE;
2527     }
2528
2529     if(*user || *pass) {
2530         FIXME("Construct user:pass string\n");
2531     }else {
2532         nsACString_SetData(aUserPass, "");
2533     }
2534
2535     SysFreeString(user);
2536     SysFreeString(pass);
2537     return NS_OK;
2538 }
2539
2540 static nsresult NSAPI nsURI_SetUserPass(nsIFileURL *iface, const nsACString *aUserPass)
2541 {
2542     nsWineURI *This = impl_from_nsIFileURL(iface);
2543     WCHAR *user = NULL, *pass = NULL, *buf = NULL;
2544     const char *user_pass;
2545     HRESULT hres;
2546
2547     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUserPass));
2548
2549     if(!ensure_uri_builder(This))
2550         return NS_ERROR_UNEXPECTED;
2551
2552     nsACString_GetData(aUserPass, &user_pass);
2553     if(*user_pass) {
2554         WCHAR *ptr;
2555
2556         buf = heap_strdupUtoW(user_pass);
2557         if(!buf)
2558             return NS_ERROR_OUT_OF_MEMORY;
2559
2560         ptr = wcschr(buf, ':');
2561         if(!ptr) {
2562             user = buf;
2563         }else if(ptr != buf) {
2564             *ptr++ = 0;
2565             user = buf;
2566             if(*ptr)
2567                 pass = ptr;
2568         }else {
2569             pass = buf+1;
2570         }
2571     }
2572
2573     hres = IUriBuilder_SetUserName(This->uri_builder, user);
2574     if(SUCCEEDED(hres))
2575         hres = IUriBuilder_SetPassword(This->uri_builder, pass);
2576
2577     heap_free(buf);
2578     return SUCCEEDED(hres) ? NS_OK : NS_ERROR_FAILURE;
2579 }
2580
2581 static nsresult NSAPI nsURI_GetUsername(nsIFileURL *iface, nsACString *aUsername)
2582 {
2583     nsWineURI *This = impl_from_nsIFileURL(iface);
2584
2585     TRACE("(%p)->(%p)\n", This, aUsername);
2586
2587     return get_uri_string(This, Uri_PROPERTY_USER_NAME, aUsername);
2588 }
2589
2590 static nsresult NSAPI nsURI_SetUsername(nsIFileURL *iface, const nsACString *aUsername)
2591 {
2592     nsWineURI *This = impl_from_nsIFileURL(iface);
2593     const char *usera;
2594     WCHAR *user;
2595     HRESULT hres;
2596
2597     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aUsername));
2598
2599     if(!ensure_uri_builder(This))
2600         return NS_ERROR_UNEXPECTED;
2601
2602     nsACString_GetData(aUsername, &usera);
2603     user = heap_strdupUtoW(usera);
2604     if(!user)
2605         return NS_ERROR_OUT_OF_MEMORY;
2606
2607     hres = IUriBuilder_SetUserName(This->uri_builder, user);
2608     heap_free(user);
2609     if(FAILED(hres))
2610         return NS_ERROR_UNEXPECTED;
2611
2612     return NS_OK;
2613 }
2614
2615 static nsresult NSAPI nsURI_GetPassword(nsIFileURL *iface, nsACString *aPassword)
2616 {
2617     nsWineURI *This = impl_from_nsIFileURL(iface);
2618
2619     TRACE("(%p)->(%p)\n", This, aPassword);
2620
2621     return get_uri_string(This, Uri_PROPERTY_PASSWORD, aPassword);
2622 }
2623
2624 static nsresult NSAPI nsURI_SetPassword(nsIFileURL *iface, const nsACString *aPassword)
2625 {
2626     nsWineURI *This = impl_from_nsIFileURL(iface);
2627     const char *passa;
2628     WCHAR *pass;
2629     HRESULT hres;
2630
2631     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPassword));
2632
2633     if(!ensure_uri_builder(This))
2634         return NS_ERROR_UNEXPECTED;
2635
2636     nsACString_GetData(aPassword, &passa);
2637     pass = heap_strdupUtoW(passa);
2638     if(!pass)
2639         return NS_ERROR_OUT_OF_MEMORY;
2640
2641     hres = IUriBuilder_SetPassword(This->uri_builder, pass);
2642     heap_free(pass);
2643     if(FAILED(hres))
2644         return NS_ERROR_UNEXPECTED;
2645
2646     return NS_OK;
2647 }
2648
2649 static nsresult NSAPI nsURI_GetHostPort(nsIFileURL *iface, nsACString *aHostPort)
2650 {
2651     nsWineURI *This = impl_from_nsIFileURL(iface);
2652     const WCHAR *ptr;
2653     char *vala;
2654     BSTR val;
2655     HRESULT hres;
2656
2657     TRACE("(%p)->(%p)\n", This, aHostPort);
2658
2659     if(!ensure_uri(This))
2660         return NS_ERROR_UNEXPECTED;
2661
2662     hres = IUri_GetAuthority(This->uri, &val);
2663     if(FAILED(hres)) {
2664         WARN("GetAuthority failed: %08lx\n", hres);
2665         return NS_ERROR_UNEXPECTED;
2666     }
2667
2668     ptr = wcschr(val, '@');
2669     if(!ptr)
2670         ptr = val;
2671
2672     vala = heap_strdupWtoU(ptr);
2673     SysFreeString(val);
2674     if(!vala)
2675         return NS_ERROR_OUT_OF_MEMORY;
2676
2677     TRACE("ret %s\n", debugstr_a(vala));
2678     nsACString_SetData(aHostPort, vala);
2679     heap_free(vala);
2680     return NS_OK;
2681 }
2682
2683 static nsresult NSAPI nsURI_SetHostPort(nsIFileURL *iface, const nsACString *aHostPort)
2684 {
2685     nsWineURI *This = impl_from_nsIFileURL(iface);
2686
2687     WARN("(%p)->(%s)\n", This, debugstr_nsacstr(aHostPort));
2688
2689     /* Not implemented by Gecko */
2690     return NS_ERROR_NOT_IMPLEMENTED;
2691 }
2692
2693 static nsresult NSAPI nsURI_GetHost(nsIFileURL *iface, nsACString *aHost)
2694 {
2695     nsWineURI *This = impl_from_nsIFileURL(iface);
2696
2697     TRACE("(%p)->(%p)\n", This, aHost);
2698
2699     return get_uri_string(This, Uri_PROPERTY_HOST, aHost);
2700 }
2701
2702 static nsresult NSAPI nsURI_SetHost(nsIFileURL *iface, const nsACString *aHost)
2703 {
2704     nsWineURI *This = impl_from_nsIFileURL(iface);
2705     const char *hosta;
2706     WCHAR *host;
2707     HRESULT hres;
2708
2709     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aHost));
2710
2711     if(!ensure_uri_builder(This))
2712         return NS_ERROR_UNEXPECTED;
2713
2714     nsACString_GetData(aHost, &hosta);
2715     host = heap_strdupUtoW(hosta);
2716     if(!host)
2717         return NS_ERROR_OUT_OF_MEMORY;
2718
2719     hres = IUriBuilder_SetHost(This->uri_builder, host);
2720     heap_free(host);
2721     if(FAILED(hres))
2722         return NS_ERROR_UNEXPECTED;
2723
2724     return NS_OK;
2725 }
2726
2727 static nsresult NSAPI nsURI_GetPort(nsIFileURL *iface, LONG *aPort)
2728 {
2729     nsWineURI *This = impl_from_nsIFileURL(iface);
2730     DWORD port;
2731     HRESULT hres;
2732
2733     TRACE("(%p)->(%p)\n", This, aPort);
2734
2735     if(!ensure_uri(This))
2736         return NS_ERROR_UNEXPECTED;
2737
2738     hres = IUri_GetPort(This->uri, &port);
2739     if(FAILED(hres)) {
2740         WARN("GetPort failed: %08lx\n", hres);
2741         return NS_ERROR_UNEXPECTED;
2742     }
2743
2744     *aPort = port ? port : -1;
2745     return NS_OK;
2746 }
2747
2748 static nsresult NSAPI nsURI_SetPort(nsIFileURL *iface, LONG aPort)
2749 {
2750     nsWineURI *This = impl_from_nsIFileURL(iface);
2751     HRESULT hres;
2752
2753     TRACE("(%p)->(%ld)\n", This, aPort);
2754
2755     if(!ensure_uri_builder(This))
2756         return NS_ERROR_UNEXPECTED;
2757
2758     hres = IUriBuilder_SetPort(This->uri_builder, aPort != -1, aPort);
2759     return SUCCEEDED(hres) ? NS_OK : NS_ERROR_FAILURE;
2760 }
2761
2762 static nsresult NSAPI nsURI_GetPath(nsIFileURL *iface, nsACString *aPath)
2763 {
2764     nsWineURI *This = impl_from_nsIFileURL(iface);
2765
2766     TRACE("(%p)->(%p)\n", This, aPath);
2767
2768     return get_uri_string(This, Uri_PROPERTY_PATH, aPath);
2769 }
2770
2771 static nsresult NSAPI nsURI_SetPath(nsIFileURL *iface, const nsACString *aPath)
2772 {
2773     nsWineURI *This = impl_from_nsIFileURL(iface);
2774     const char *patha;
2775     WCHAR *path;
2776     HRESULT hres;
2777
2778     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aPath));
2779
2780     if(!ensure_uri_builder(This))
2781         return NS_ERROR_UNEXPECTED;
2782
2783     nsACString_GetData(aPath, &patha);
2784     path = heap_strdupUtoW(patha);
2785     if(!path)
2786         return NS_ERROR_OUT_OF_MEMORY;
2787
2788     hres = IUriBuilder_SetPath(This->uri_builder, path);
2789     heap_free(path);
2790     if(FAILED(hres))
2791         return NS_ERROR_UNEXPECTED;
2792
2793     return NS_OK;
2794 }
2795
2796 static nsresult NSAPI nsURI_Equals(nsIFileURL *iface, nsIURI *other, cpp_bool *_retval)
2797 {
2798     nsWineURI *This = impl_from_nsIFileURL(iface);
2799     nsWineURI *other_obj;
2800     nsresult nsres;
2801     HRESULT hres;
2802
2803     TRACE("(%p)->(%p %p)\n", This, other, _retval);
2804
2805     nsres = nsIURI_QueryInterface(other, &IID_nsWineURI, (void**)&other_obj);
2806     if(NS_FAILED(nsres)) {
2807         TRACE("Could not get nsWineURI interface\n");
2808         *_retval = FALSE;
2809         return NS_OK;
2810     }
2811
2812     if(ensure_uri(This) && ensure_uri(other_obj)) {
2813         BOOL b;
2814
2815         hres = IUri_IsEqual(This->uri, other_obj->uri, &b);
2816         if(SUCCEEDED(hres)) {
2817             *_retval = b;
2818             nsres = NS_OK;
2819         }else {
2820             nsres = NS_ERROR_FAILURE;
2821         }
2822     }else {
2823         nsres = NS_ERROR_UNEXPECTED;
2824     }
2825
2826     nsIFileURL_Release(&other_obj->nsIFileURL_iface);
2827     return nsres;
2828 }
2829
2830 static nsresult NSAPI nsURI_SchemeIs(nsIFileURL *iface, const char *scheme, cpp_bool *_retval)
2831 {
2832     nsWineURI *This = impl_from_nsIFileURL(iface);
2833     WCHAR buf[INTERNET_MAX_SCHEME_LENGTH];
2834     BSTR scheme_name;
2835     HRESULT hres;
2836
2837     TRACE("(%p)->(%s %p)\n", This, debugstr_a(scheme), _retval);
2838
2839     if(!ensure_uri(This))
2840         return NS_ERROR_UNEXPECTED;
2841
2842     hres = IUri_GetSchemeName(This->uri, &scheme_name);
2843     if(FAILED(hres))
2844         return NS_ERROR_UNEXPECTED;
2845
2846     MultiByteToWideChar(CP_UTF8, 0, scheme, -1, buf, ARRAY_SIZE(buf));
2847     *_retval = !wcscmp(scheme_name, buf);
2848     SysFreeString(scheme_name);
2849     return NS_OK;
2850 }
2851
2852 static nsresult NSAPI nsURI_Clone(nsIFileURL *iface, nsIURI **_retval)
2853 {
2854     nsWineURI *This = impl_from_nsIFileURL(iface);
2855     nsWineURI *wine_uri;
2856     nsresult nsres;
2857
2858     TRACE("(%p)->(%p)\n", This, _retval);
2859
2860     if(!ensure_uri(This))
2861         return NS_ERROR_UNEXPECTED;
2862
2863     nsres = create_nsuri(This->uri, &wine_uri);
2864     if(NS_FAILED(nsres)) {
2865         WARN("create_nsuri failed: %08lx\n", nsres);
2866         return nsres;
2867     }
2868
2869     *_retval = (nsIURI*)&wine_uri->nsIFileURL_iface;
2870     return NS_OK;
2871 }
2872
2873 static nsresult NSAPI nsURI_Resolve(nsIFileURL *iface, const nsACString *aRelativePath,
2874         nsACString *_retval)
2875 {
2876     nsWineURI *This = impl_from_nsIFileURL(iface);
2877     const char *patha;
2878     IUri *new_uri;
2879     WCHAR *path;
2880     char *reta;
2881     BSTR ret;
2882     HRESULT hres;
2883
2884     TRACE("(%p)->(%s %p)\n", This, debugstr_nsacstr(aRelativePath), _retval);
2885
2886     if(!ensure_uri(This))
2887         return NS_ERROR_UNEXPECTED;
2888
2889     nsACString_GetData(aRelativePath, &patha);
2890     path = heap_strdupUtoW(patha);
2891     if(!path)
2892         return NS_ERROR_OUT_OF_MEMORY;
2893
2894     hres = combine_url(This->uri, path, &new_uri);
2895     heap_free(path);
2896     if(FAILED(hres))
2897         return NS_ERROR_FAILURE;
2898
2899     hres = IUri_GetDisplayUri(new_uri, &ret);
2900     IUri_Release(new_uri);
2901     if(FAILED(hres))
2902         return NS_ERROR_FAILURE;
2903
2904     reta = heap_strdupWtoU(ret);
2905     SysFreeString(ret);
2906     if(!reta)
2907         return NS_ERROR_OUT_OF_MEMORY;
2908
2909     TRACE("returning %s\n", debugstr_a(reta));
2910     nsACString_SetData(_retval, reta);
2911     heap_free(reta);
2912     return NS_OK;
2913 }
2914
2915 static nsresult NSAPI nsURI_GetAsciiSpec(nsIFileURL *iface, nsACString *aAsciiSpec)
2916 {
2917     nsWineURI *This = impl_from_nsIFileURL(iface);
2918
2919     TRACE("(%p)->(%p)\n", This, aAsciiSpec);
2920
2921     return nsIFileURL_GetSpec(&This->nsIFileURL_iface, aAsciiSpec);
2922 }
2923
2924 static nsresult NSAPI nsURI_GetAsciiHostPort(nsIFileURL *iface, nsACString *aAsciiHostPort)
2925 {
2926     nsWineURI *This = impl_from_nsIFileURL(iface);
2927
2928     WARN("(%p)->(%p) FIXME: Use Uri_PUNYCODE_IDN_HOST flag\n", This, aAsciiHostPort);
2929
2930     return nsIFileURL_GetHostPort(&This->nsIFileURL_iface, aAsciiHostPort);
2931 }
2932
2933 static nsresult NSAPI nsURI_GetAsciiHost(nsIFileURL *iface, nsACString *aAsciiHost)
2934 {
2935     nsWineURI *This = impl_from_nsIFileURL(iface);
2936
2937     WARN("(%p)->(%p) FIXME: Use Uri_PUNYCODE_IDN_HOST flag\n", This, aAsciiHost);
2938
2939     return get_uri_string(This, Uri_PROPERTY_HOST, aAsciiHost);
2940 }
2941
2942 static nsresult NSAPI nsURI_GetOriginCharset(nsIFileURL *iface, nsACString *aOriginCharset)
2943 {
2944     nsWineURI *This = impl_from_nsIFileURL(iface);
2945
2946     TRACE("(%p)->(%p)\n", This, aOriginCharset);
2947
2948     nsACString_SetData(aOriginCharset, NULL); /* assume utf-8, we store URI as utf-16 anyway */
2949     return NS_OK;
2950 }
2951
2952 static nsresult NSAPI nsURL_GetRef(nsIFileURL *iface, nsACString *aRef)
2953 {
2954     nsWineURI *This = impl_from_nsIFileURL(iface);
2955     char *refa = NULL;
2956     BSTR ref;
2957     HRESULT hres;
2958
2959     TRACE("(%p)->(%p)\n", This, aRef);
2960
2961     if(!ensure_uri(This))
2962         return NS_ERROR_UNEXPECTED;
2963
2964     hres = IUri_GetFragment(This->uri, &ref);
2965     if(FAILED(hres))
2966         return NS_ERROR_UNEXPECTED;
2967
2968     refa = heap_strdupWtoU(ref);
2969     SysFreeString(ref);
2970     if(ref && !refa)
2971         return NS_ERROR_OUT_OF_MEMORY;
2972
2973     nsACString_SetData(aRef, refa && *refa == '#' ? refa+1 : refa);
2974     heap_free(refa);
2975     return NS_OK;
2976 }
2977
2978 static nsresult NSAPI nsURL_SetRef(nsIFileURL *iface, const nsACString *aRef)
2979 {
2980     nsWineURI *This = impl_from_nsIFileURL(iface);
2981     const char *refa;
2982     WCHAR *ref;
2983     HRESULT hres;
2984
2985     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aRef));
2986
2987     if(!ensure_uri_builder(This))
2988         return NS_ERROR_UNEXPECTED;
2989
2990     nsACString_GetData(aRef, &refa);
2991     ref = heap_strdupUtoW(refa);
2992     if(!ref)
2993         return NS_ERROR_OUT_OF_MEMORY;
2994
2995     hres = IUriBuilder_SetFragment(This->uri_builder, ref);
2996     heap_free(ref);
2997     if(FAILED(hres))
2998         return NS_ERROR_UNEXPECTED;
2999
3000     return NS_OK;
3001 }
3002
3003 static nsresult NSAPI nsURI_EqualsExceptRef(nsIFileURL *iface, nsIURI *other, cpp_bool *_retval)
3004 {
3005     nsWineURI *This = impl_from_nsIFileURL(iface);
3006     nsWineURI *other_obj;
3007     nsresult nsres;
3008
3009     TRACE("(%p)->(%p %p)\n", This, other, _retval);
3010
3011     nsres = nsIURI_QueryInterface(other, &IID_nsWineURI, (void**)&other_obj);
3012     if(NS_FAILED(nsres)) {
3013         TRACE("Could not get nsWineURI interface\n");
3014         *_retval = FALSE;
3015         return NS_OK;
3016     }
3017
3018     if(ensure_uri(This) && ensure_uri(other_obj)) {
3019         *_retval = compare_ignoring_frag(This->uri, other_obj->uri);
3020         nsres = NS_OK;
3021     }else {
3022         nsres = NS_ERROR_UNEXPECTED;
3023     }
3024
3025     nsIFileURL_Release(&other_obj->nsIFileURL_iface);
3026     return nsres;
3027 }
3028
3029 static nsresult NSAPI nsURI_CloneIgnoreRef(nsIFileURL *iface, nsIURI **_retval)
3030 {
3031     nsWineURI *This = impl_from_nsIFileURL(iface);
3032     nsWineURI *wine_uri;
3033     IUri *uri;
3034     nsresult nsres;
3035
3036     TRACE("(%p)->(%p)\n", This, _retval);
3037
3038     if(!ensure_uri(This))
3039         return NS_ERROR_UNEXPECTED;
3040
3041     uri = get_uri_nofrag(This->uri);
3042     if(!uri)
3043         return NS_ERROR_FAILURE;
3044
3045     nsres = create_nsuri(uri, &wine_uri);
3046     IUri_Release(uri);
3047     if(NS_FAILED(nsres)) {
3048         WARN("create_nsuri failed: %08lx\n", nsres);
3049         return nsres;
3050     }
3051
3052     *_retval = (nsIURI*)&wine_uri->nsIFileURL_iface;
3053     return NS_OK;
3054 }
3055
3056 static nsresult NSAPI nsURI_GetSpecIgnoringRef(nsIFileURL *iface, nsACString *aSpecIgnoringRef)
3057 {
3058     nsWineURI *This = impl_from_nsIFileURL(iface);
3059
3060     FIXME("(%p)->(%p)\n", This, aSpecIgnoringRef);
3061
3062     return nsIFileURL_GetSpec(&This->nsIFileURL_iface, aSpecIgnoringRef);
3063 }
3064
3065 static nsresult NSAPI nsURI_GetHasRef(nsIFileURL *iface, cpp_bool *aHasRef)
3066 {
3067     nsWineURI *This = impl_from_nsIFileURL(iface);
3068     BOOL b;
3069     HRESULT hres;
3070
3071     TRACE("(%p)->(%p)\n", This, aHasRef);
3072
3073     if(!ensure_uri(This))
3074         return NS_ERROR_UNEXPECTED;
3075
3076     hres = IUri_HasProperty(This->uri, Uri_PROPERTY_FRAGMENT, &b);
3077     if(FAILED(hres))
3078         return NS_ERROR_FAILURE;
3079
3080     *aHasRef = b;
3081     return NS_OK;
3082 }
3083
3084 static nsresult NSAPI nsURL_GetFilePath(nsIFileURL *iface, nsACString *aFilePath)
3085 {
3086     nsWineURI *This = impl_from_nsIFileURL(iface);
3087
3088     TRACE("(%p)->(%p)\n", This, aFilePath);
3089
3090     return nsIFileURL_GetPath(&This->nsIFileURL_iface, aFilePath);
3091 }
3092
3093 static nsresult NSAPI nsURL_SetFilePath(nsIFileURL *iface, const nsACString *aFilePath)
3094 {
3095     nsWineURI *This = impl_from_nsIFileURL(iface);
3096
3097     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aFilePath));
3098
3099     if(!This->is_mutable)
3100         return NS_ERROR_UNEXPECTED;
3101
3102     return nsIFileURL_SetPath(&This->nsIFileURL_iface, aFilePath);
3103 }
3104
3105 static nsresult NSAPI nsURL_GetQuery(nsIFileURL *iface, nsACString *aQuery)
3106 {
3107     nsWineURI *This = impl_from_nsIFileURL(iface);
3108     WCHAR *ptr;
3109     BSTR query;
3110     nsresult nsres;
3111     HRESULT hres;
3112
3113     TRACE("(%p)->(%p)\n", This, aQuery);
3114
3115     if(!ensure_uri(This))
3116         return NS_ERROR_UNEXPECTED;
3117
3118     hres = IUri_GetQuery(This->uri, &query);
3119     if(FAILED(hres))
3120         return NS_ERROR_FAILURE;
3121
3122     ptr = query;
3123     if(ptr && *ptr == '?')
3124         ptr++;
3125
3126     nsres = return_wstr_nsacstr(aQuery, ptr, -1);
3127     SysFreeString(query);
3128     return nsres;
3129 }
3130
3131 static nsresult NSAPI nsURL_SetQuery(nsIFileURL *iface, const nsACString *aQuery)
3132 {
3133     nsWineURI *This = impl_from_nsIFileURL(iface);
3134     const char *querya;
3135     WCHAR *query;
3136     HRESULT hres;
3137
3138     TRACE("(%p)->(%s)\n", This, debugstr_nsacstr(aQuery));
3139
3140     if(!ensure_uri_builder(This))
3141         return NS_ERROR_UNEXPECTED;
3142
3143     nsACString_GetData(aQuery, &querya);
3144     query = heap_strdupUtoW(querya);
3145     if(!query)
3146         return NS_ERROR_OUT_OF_MEMORY;
3147
3148     hres = IUriBuilder_SetQuery(This->uri_builder, query);
3149     heap_free(query);
3150     if(FAILED(hres))
3151         return NS_ERROR_UNEXPECTED;
3152
3153     return NS_OK;
3154 }
3155
3156 static nsresult get_uri_path(nsWineURI *This, BSTR *path, const WCHAR **file, const WCHAR **ext)
3157 {
3158     const WCHAR *ptr;
3159     HRESULT hres;
3160
3161     if(!ensure_uri(This))
3162         return NS_ERROR_UNEXPECTED;
3163
3164     hres = IUri_GetPath(This->uri, path);
3165     if(FAILED(hres))
3166         return NS_ERROR_FAILURE;
3167
3168     for(ptr = *path + SysStringLen(*path)-1; ptr > *path && *ptr != '/' && *ptr != '\\'; ptr--);
3169     if(*ptr == '/' || *ptr == '\\')
3170         ptr++;
3171     *file = ptr;
3172
3173     if(ext) {
3174         ptr = wcsrchr(ptr, '.');
3175         if(!ptr)
3176             ptr = *path + SysStringLen(*path);
3177         *ext = ptr;
3178     }
3179
3180     return NS_OK;
3181 }
3182
3183 static nsresult NSAPI nsURL_GetDirectory(nsIFileURL *iface, nsACString *aDirectory)
3184 {
3185     nsWineURI *This = impl_from_nsIFileURL(iface);
3186     const WCHAR *file;
3187     BSTR path;
3188     nsresult nsres;
3189
3190     TRACE("(%p)->(%p)\n", This, aDirectory);
3191
3192     nsres = get_uri_path(This, &path, &file, NULL);
3193     if(NS_FAILED(nsres))
3194         return nsres;
3195
3196     nsres = return_wstr_nsacstr(aDirectory, path, file-path);
3197     SysFreeString(path);
3198     return nsres;
3199 }
3200
3201 static nsresult NSAPI nsURL_SetDirectory(nsIFileURL *iface, const nsACString *aDirectory)
3202 {
3203     nsWineURI *This = impl_from_nsIFileURL(iface);
3204
3205     WARN("(%p)->(%s)\n", This, debugstr_nsacstr(aDirectory));
3206
3207     /* Not implemented by Gecko */
3208     return NS_ERROR_NOT_IMPLEMENTED;
3209 }
3210
3211 static nsresult NSAPI nsURL_GetFileName(nsIFileURL *iface, nsACString *aFileName)
3212 {
3213     nsWineURI *This = impl_from_nsIFileURL(iface);
3214     const WCHAR *file;
3215     BSTR path;
3216     nsresult nsres;
3217
3218     TRACE("(%p)->(%p)\n", This, aFileName);
3219
3220     nsres = get_uri_path(This, &path, &file, NULL);
3221     if(NS_FAILED(nsres))
3222         return nsres;
3223
3224     nsres = return_wstr_nsacstr(aFileName, file, -1);
3225     SysFreeString(path);
3226     return nsres;
3227 }
3228
3229 static nsresult NSAPI nsURL_SetFileName(nsIFileURL *iface, const nsACString *aFileName)
3230 {
3231     nsWineURI *This = impl_from_nsIFileURL(iface);
3232     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aFileName));
3233     return NS_ERROR_NOT_IMPLEMENTED;
3234 }
3235
3236 static nsresult NSAPI nsURL_GetFileBaseName(nsIFileURL *iface, nsACString *aFileBaseName)
3237 {
3238     nsWineURI *This = impl_from_nsIFileURL(iface);
3239     const WCHAR *file, *ext;
3240     BSTR path;
3241     nsresult nsres;
3242
3243     TRACE("(%p)->(%p)\n", This, aFileBaseName);
3244
3245     nsres = get_uri_path(This, &path, &file, &ext);
3246     if(NS_FAILED(nsres))
3247         return nsres;
3248
3249     nsres = return_wstr_nsacstr(aFileBaseName, file, ext-file);
3250     SysFreeString(path);
3251     return nsres;
3252 }
3253
3254 static nsresult NSAPI nsURL_SetFileBaseName(nsIFileURL *iface, const nsACString *aFileBaseName)
3255 {
3256     nsWineURI *This = impl_from_nsIFileURL(iface);
3257     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aFileBaseName));
3258     return NS_ERROR_NOT_IMPLEMENTED;
3259 }
3260
3261 static nsresult NSAPI nsURL_GetFileExtension(nsIFileURL *iface, nsACString *aFileExtension)
3262 {
3263     nsWineURI *This = impl_from_nsIFileURL(iface);
3264
3265     TRACE("(%p)->(%p)\n", This, aFileExtension);
3266
3267     return get_uri_string(This, Uri_PROPERTY_EXTENSION, aFileExtension);
3268 }
3269
3270 static nsresult NSAPI nsURL_SetFileExtension(nsIFileURL *iface, const nsACString *aFileExtension)
3271 {
3272     nsWineURI *This = impl_from_nsIFileURL(iface);
3273     FIXME("(%p)->(%s)\n", This, debugstr_nsacstr(aFileExtension));
3274     return NS_ERROR_NOT_IMPLEMENTED;
3275 }
3276
3277 static nsresult NSAPI nsURL_GetCommonBaseSpec(nsIFileURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
3278 {
3279     nsWineURI *This = impl_from_nsIFileURL(iface);
3280     FIXME("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
3281     return NS_ERROR_NOT_IMPLEMENTED;
3282 }
3283
3284 static nsresult NSAPI nsURL_GetRelativeSpec(nsIFileURL *iface, nsIURI *aURIToCompare, nsACString *_retval)
3285 {
3286     nsWineURI *This = impl_from_nsIFileURL(iface);
3287     FIXME("(%p)->(%p %p)\n", This, aURIToCompare, _retval);
3288     return NS_ERROR_NOT_IMPLEMENTED;
3289 }
3290
3291 static nsresult NSAPI nsFileURL_GetFile(nsIFileURL *iface, nsIFile **aFile)
3292 {
3293     nsWineURI *This = impl_from_nsIFileURL(iface);
3294     WCHAR path[MAX_PATH];
3295     DWORD size;
3296     HRESULT hres;
3297
3298     TRACE("(%p)->(%p)\n", This, aFile);
3299
3300     hres = CoInternetParseIUri(This->uri, PARSE_PATH_FROM_URL, 0, path, ARRAY_SIZE(path), &size, 0);
3301     if(FAILED(hres)) {
3302         WARN("CoInternetParseIUri failed: %08lx\n", hres);
3303         return NS_ERROR_FAILURE;
3304     }
3305
3306     return create_nsfile(path, aFile);
3307 }
3308
3309 static nsresult NSAPI nsFileURL_SetFile(nsIFileURL *iface, nsIFile *aFile)
3310 {
3311     nsWineURI *This = impl_from_nsIFileURL(iface);
3312     FIXME("(%p)->(%p)\n", This, aFile);
3313     return NS_ERROR_NOT_IMPLEMENTED;
3314 }
3315
3316 static const nsIFileURLVtbl nsFileURLVtbl = {
3317     nsURI_QueryInterface,
3318     nsURI_AddRef,
3319     nsURI_Release,
3320     nsURI_GetSpec,
3321     nsURI_SetSpec,
3322     nsURI_GetPrePath,
3323     nsURI_GetScheme,
3324     nsURI_SetScheme,
3325     nsURI_GetUserPass,
3326     nsURI_SetUserPass,
3327     nsURI_GetUsername,
3328     nsURI_SetUsername,
3329     nsURI_GetPassword,
3330     nsURI_SetPassword,
3331     nsURI_GetHostPort,
3332     nsURI_SetHostPort,
3333     nsURI_GetHost,
3334     nsURI_SetHost,
3335     nsURI_GetPort,
3336     nsURI_SetPort,
3337     nsURI_GetPath,
3338     nsURI_SetPath,
3339     nsURI_Equals,
3340     nsURI_SchemeIs,
3341     nsURI_Clone,
3342     nsURI_Resolve,
3343     nsURI_GetAsciiSpec,
3344     nsURI_GetAsciiHostPort,
3345     nsURI_GetAsciiHost,
3346     nsURI_GetOriginCharset,
3347     nsURL_GetRef,
3348     nsURL_SetRef,
3349     nsURI_EqualsExceptRef,
3350     nsURI_CloneIgnoreRef,
3351     nsURI_GetSpecIgnoringRef,
3352     nsURI_GetHasRef,
3353     nsURL_GetFilePath,
3354     nsURL_SetFilePath,
3355     nsURL_GetQuery,
3356     nsURL_SetQuery,
3357     nsURL_GetDirectory,
3358     nsURL_SetDirectory,
3359     nsURL_GetFileName,
3360     nsURL_SetFileName,
3361     nsURL_GetFileBaseName,
3362     nsURL_SetFileBaseName,
3363     nsURL_GetFileExtension,
3364     nsURL_SetFileExtension,
3365     nsURL_GetCommonBaseSpec,
3366     nsURL_GetRelativeSpec,
3367     nsFileURL_GetFile,
3368     nsFileURL_SetFile
3369 };
3370
3371 static inline nsWineURI *impl_from_nsIStandardURL(nsIStandardURL *iface)
3372 {
3373     return CONTAINING_RECORD(iface, nsWineURI, nsIStandardURL_iface);
3374 }
3375
3376 static nsresult NSAPI nsStandardURL_QueryInterface(nsIStandardURL *iface, nsIIDRef riid,
3377         void **result)
3378 {
3379     nsWineURI *This = impl_from_nsIStandardURL(iface);
3380     return nsIFileURL_QueryInterface(&This->nsIFileURL_iface, riid, result);
3381 }
3382
3383 static nsrefcnt NSAPI nsStandardURL_AddRef(nsIStandardURL *iface)
3384 {
3385     nsWineURI *This = impl_from_nsIStandardURL(iface);
3386     return nsIFileURL_AddRef(&This->nsIFileURL_iface);
3387 }
3388
3389 static nsrefcnt NSAPI nsStandardURL_Release(nsIStandardURL *iface)
3390 {
3391     nsWineURI *This = impl_from_nsIStandardURL(iface);
3392     return nsIFileURL_Release(&This->nsIFileURL_iface);
3393 }
3394
3395 static nsresult NSAPI nsStandardURL_GetMutable(nsIStandardURL *iface, cpp_bool *aMutable)
3396 {
3397     nsWineURI *This = impl_from_nsIStandardURL(iface);
3398
3399     TRACE("(%p)->(%p)\n", This, aMutable);
3400
3401     *aMutable = This->is_mutable;
3402     return NS_OK;
3403 }
3404
3405 static nsresult NSAPI nsStandardURL_SetMutable(nsIStandardURL *iface, cpp_bool aMutable)
3406 {
3407     nsWineURI *This = impl_from_nsIStandardURL(iface);
3408
3409     TRACE("(%p)->(%x)\n", This, aMutable);
3410
3411     This->is_mutable = aMutable;
3412     return NS_OK;
3413 }
3414
3415 static nsresult NSAPI nsStandardURL_Init(nsIStandardURL *iface, UINT32 aUrlType, LONG aDefaultPort,
3416         const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI)
3417 {
3418     nsWineURI *This = impl_from_nsIStandardURL(iface);
3419     FIXME("(%p)->(%d %ld %s %s %p)\n", This, aUrlType, aDefaultPort, debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset), aBaseURI);
3420     return NS_ERROR_NOT_IMPLEMENTED;
3421 }
3422
3423 static nsresult NSAPI nsStandardURL_SetDefaultPort(nsIStandardURL *iface, LONG aNewDefaultPort)
3424 {
3425     nsWineURI *This = impl_from_nsIStandardURL(iface);
3426     FIXME("(%p)->(%ld)\n", This, aNewDefaultPort);
3427     return NS_ERROR_NOT_IMPLEMENTED;
3428 }
3429
3430 static const nsIStandardURLVtbl nsStandardURLVtbl = {
3431     nsStandardURL_QueryInterface,
3432     nsStandardURL_AddRef,
3433     nsStandardURL_Release,
3434     nsStandardURL_GetMutable,
3435     nsStandardURL_SetMutable,
3436     nsStandardURL_Init,
3437     nsStandardURL_SetDefaultPort
3438 };
3439
3440 static nsresult create_nsuri(IUri *iuri, nsWineURI **_retval)
3441 {
3442     nsWineURI *ret;
3443     HRESULT hres;
3444
3445     ret = heap_alloc_zero(sizeof(nsWineURI));
3446     if(!ret)
3447         return NS_ERROR_OUT_OF_MEMORY;
3448
3449     ret->nsIFileURL_iface.lpVtbl = &nsFileURLVtbl;
3450     ret->nsIStandardURL_iface.lpVtbl = &nsStandardURLVtbl;
3451     ret->ref = 1;
3452     ret->is_mutable = TRUE;
3453
3454     IUri_AddRef(iuri);
3455     ret->uri = iuri;
3456
3457     hres = IUri_GetScheme(iuri, &ret->scheme);
3458     if(FAILED(hres))
3459         ret->scheme = URL_SCHEME_UNKNOWN;
3460
3461     TRACE("retval=%p\n", ret);
3462     *_retval = ret;
3463     return NS_OK;
3464 }
3465
3466 HRESULT create_doc_uri(IUri *iuri, nsWineURI **ret)
3467 {
3468     nsresult nsres;
3469     nsres = create_nsuri(iuri, ret);
3470     return NS_SUCCEEDED(nsres) ? S_OK : E_OUTOFMEMORY;
3471 }
3472
3473 static nsresult create_nschannel(nsWineURI *uri, nsChannel **ret)
3474 {
3475     nsChannel *channel;
3476
3477     if(!ensure_uri(uri))
3478         return NS_ERROR_UNEXPECTED;
3479
3480     channel = heap_alloc_zero(sizeof(nsChannel));
3481     if(!channel)
3482         return NS_ERROR_OUT_OF_MEMORY;
3483
3484     channel->nsIHttpChannel_iface.lpVtbl = &nsChannelVtbl;
3485     channel->nsIUploadChannel_iface.lpVtbl = &nsUploadChannelVtbl;
3486     channel->nsIHttpChannelInternal_iface.lpVtbl = &nsHttpChannelInternalVtbl;
3487     channel->nsICacheInfoChannel_iface.lpVtbl = &nsCacheInfoChannelVtbl;
3488     channel->ref = 1;
3489     channel->request_method = METHOD_GET;
3490     list_init(&channel->response_headers);
3491     list_init(&channel->request_headers);
3492
3493     nsIFileURL_AddRef(&uri->nsIFileURL_iface);
3494     channel->uri = uri;
3495
3496     *ret = channel;
3497     return NS_OK;
3498 }
3499
3500 HRESULT create_redirect_nschannel(const WCHAR *url, nsChannel *orig_channel, nsChannel **ret)
3501 {
3502     nsChannel *channel;
3503     nsWineURI *uri;
3504     IUri *iuri;
3505     nsresult nsres;
3506     HRESULT hres;
3507
3508     hres = create_uri(url, 0, &iuri);
3509     if(FAILED(hres))
3510         return hres;
3511
3512     nsres = create_nsuri(iuri, &uri);
3513     IUri_Release(iuri);
3514     if(NS_FAILED(nsres))
3515         return E_FAIL;
3516
3517     nsres = create_nschannel(uri, &channel);
3518     nsIFileURL_Release(&uri->nsIFileURL_iface);
3519     if(NS_FAILED(nsres))
3520         return E_FAIL;
3521
3522     if(orig_channel->load_group) {
3523         nsILoadGroup_AddRef(orig_channel->load_group);
3524         channel->load_group = orig_channel->load_group;
3525     }
3526
3527     if(orig_channel->notif_callback) {
3528         nsIInterfaceRequestor_AddRef(orig_channel->notif_callback);
3529         channel->notif_callback = orig_channel->notif_callback;
3530     }
3531
3532     channel->load_flags = orig_channel->load_flags | LOAD_REPLACE;
3533
3534     if(orig_channel->request_method == METHOD_POST)
3535         FIXME("unsupported POST method\n");
3536
3537     if(orig_channel->original_uri) {
3538         nsIURI_AddRef(orig_channel->original_uri);
3539         channel->original_uri = orig_channel->original_uri;
3540     }
3541
3542     if(orig_channel->referrer) {
3543         nsIURI_AddRef(orig_channel->referrer);
3544         channel->referrer = orig_channel->referrer;
3545     }
3546
3547     *ret = channel;
3548     return S_OK;
3549 }
3550
3551 typedef struct {
3552     nsIProtocolHandler nsIProtocolHandler_iface;
3553
3554     LONG ref;
3555
3556     nsIProtocolHandler *nshandler;
3557 } nsProtocolHandler;
3558
3559 static inline nsProtocolHandler *impl_from_nsIProtocolHandler(nsIProtocolHandler *iface)
3560 {
3561     return CONTAINING_RECORD(iface, nsProtocolHandler, nsIProtocolHandler_iface);
3562 }
3563
3564 static nsresult NSAPI nsProtocolHandler_QueryInterface(nsIProtocolHandler *iface, nsIIDRef riid,
3565         void **result)
3566 {
3567     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3568
3569     *result = NULL;
3570
3571     if(IsEqualGUID(&IID_nsISupports, riid)) {
3572         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
3573         *result = &This->nsIProtocolHandler_iface;
3574     }else if(IsEqualGUID(&IID_nsIProtocolHandler, riid)) {
3575         TRACE("(%p)->(IID_nsIProtocolHandler %p)\n", This, result);
3576         *result = &This->nsIProtocolHandler_iface;
3577     }else if(IsEqualGUID(&IID_nsIExternalProtocolHandler, riid)) {
3578         TRACE("(%p)->(IID_nsIExternalProtocolHandler %p), returning NULL\n", This, result);
3579         return NS_NOINTERFACE;
3580     }
3581
3582     if(*result) {
3583         nsISupports_AddRef((nsISupports*)*result);
3584         return NS_OK;
3585     }
3586
3587     WARN("(%s %p)\n", debugstr_guid(riid), result);
3588     return NS_NOINTERFACE;
3589 }
3590
3591 static nsrefcnt NSAPI nsProtocolHandler_AddRef(nsIProtocolHandler *iface)
3592 {
3593     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3594     LONG ref = InterlockedIncrement(&This->ref);
3595
3596     TRACE("(%p) ref=%ld\n", This, ref);
3597
3598     return ref;
3599 }
3600
3601 static nsrefcnt NSAPI nsProtocolHandler_Release(nsIProtocolHandler *iface)
3602 {
3603     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3604     LONG ref = InterlockedDecrement(&This->ref);
3605
3606     TRACE("(%p) ref=%ld\n", This, ref);
3607
3608     if(!ref) {
3609         if(This->nshandler)
3610             nsIProtocolHandler_Release(This->nshandler);
3611         heap_free(This);
3612     }
3613
3614     return ref;
3615 }
3616
3617 static nsresult NSAPI nsProtocolHandler_GetScheme(nsIProtocolHandler *iface, nsACString *aScheme)
3618 {
3619     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3620
3621     TRACE("(%p)->(%p)\n", This, aScheme);
3622
3623     if(This->nshandler)
3624         return nsIProtocolHandler_GetScheme(This->nshandler, aScheme);
3625     return NS_ERROR_NOT_IMPLEMENTED;
3626 }
3627
3628 static nsresult NSAPI nsProtocolHandler_GetDefaultPort(nsIProtocolHandler *iface,
3629         LONG *aDefaultPort)
3630 {
3631     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3632
3633     TRACE("(%p)->(%p)\n", This, aDefaultPort);
3634
3635     if(This->nshandler)
3636         return nsIProtocolHandler_GetDefaultPort(This->nshandler, aDefaultPort);
3637     return NS_ERROR_NOT_IMPLEMENTED;
3638 }
3639
3640 static nsresult NSAPI nsProtocolHandler_GetProtocolFlags(nsIProtocolHandler *iface,
3641                                                          UINT32 *aProtocolFlags)
3642 {
3643     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3644
3645     TRACE("(%p)->(%p)\n", This, aProtocolFlags);
3646
3647     if(This->nshandler)
3648         return nsIProtocolHandler_GetProtocolFlags(This->nshandler, aProtocolFlags);
3649     return NS_ERROR_NOT_IMPLEMENTED;
3650 }
3651
3652 static nsresult NSAPI nsProtocolHandler_NewURI(nsIProtocolHandler *iface,
3653         const nsACString *aSpec, const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
3654 {
3655     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3656
3657     TRACE("((%p)->%s %s %p %p)\n", This, debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
3658           aBaseURI, _retval);
3659
3660     if(This->nshandler)
3661         return nsIProtocolHandler_NewURI(This->nshandler, aSpec, aOriginCharset, aBaseURI, _retval);
3662     return NS_ERROR_NOT_IMPLEMENTED;
3663 }
3664
3665 static nsresult NSAPI nsProtocolHandler_NewChannel2(nsIProtocolHandler *iface,
3666         nsIURI *aURI, nsILoadInfo *aLoadInfo, nsIChannel **_retval)
3667 {
3668     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3669
3670     TRACE("(%p)->(%p %p %p)\n", This, aURI, aLoadInfo, _retval);
3671
3672     if(This->nshandler)
3673         return nsIProtocolHandler_NewChannel2(This->nshandler, aURI, aLoadInfo, _retval);
3674     return NS_ERROR_NOT_IMPLEMENTED;
3675 }
3676
3677 static nsresult NSAPI nsProtocolHandler_NewChannel(nsIProtocolHandler *iface,
3678         nsIURI *aURI, nsIChannel **_retval)
3679 {
3680     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3681
3682     TRACE("(%p)->(%p %p)\n", This, aURI, _retval);
3683
3684     if(This->nshandler)
3685         return nsIProtocolHandler_NewChannel(This->nshandler, aURI, _retval);
3686     return NS_ERROR_NOT_IMPLEMENTED;
3687 }
3688
3689 static nsresult NSAPI nsProtocolHandler_AllowPort(nsIProtocolHandler *iface,
3690         LONG port, const char *scheme, cpp_bool *_retval)
3691 {
3692     nsProtocolHandler *This = impl_from_nsIProtocolHandler(iface);
3693
3694     TRACE("(%p)->(%ld %s %p)\n", This, port, debugstr_a(scheme), _retval);
3695
3696     if(This->nshandler)
3697         return nsIProtocolHandler_AllowPort(This->nshandler, port, scheme, _retval);
3698     return NS_ERROR_NOT_IMPLEMENTED;
3699 }
3700
3701 static const nsIProtocolHandlerVtbl nsProtocolHandlerVtbl = {
3702     nsProtocolHandler_QueryInterface,
3703     nsProtocolHandler_AddRef,
3704     nsProtocolHandler_Release,
3705     nsProtocolHandler_GetScheme,
3706     nsProtocolHandler_GetDefaultPort,
3707     nsProtocolHandler_GetProtocolFlags,
3708     nsProtocolHandler_NewURI,
3709     nsProtocolHandler_NewChannel2,
3710     nsProtocolHandler_NewChannel,
3711     nsProtocolHandler_AllowPort
3712 };
3713
3714 static nsresult NSAPI nsIOServiceHook_QueryInterface(nsIIOServiceHook *iface, nsIIDRef riid,
3715         void **result)
3716 {
3717     if(IsEqualGUID(&IID_nsISupports, riid)) {
3718         TRACE("(IID_nsISupports %p)\n", result);
3719         *result = iface;
3720     }else if(IsEqualGUID(&IID_nsIIOServiceHook, riid)) {
3721         TRACE("(IID_nsIIOServiceHook %p)\n", result);
3722         *result = iface;
3723     }else {
3724         ERR("(%s %p)\n", debugstr_guid(riid), result);
3725         *result = NULL;
3726         return NS_NOINTERFACE;
3727     }
3728
3729     nsISupports_AddRef((nsISupports*)*result);
3730     return NS_OK;
3731 }
3732
3733 static nsrefcnt NSAPI nsIOServiceHook_AddRef(nsIIOServiceHook *iface)
3734 {
3735     return 2;
3736 }
3737
3738 static nsrefcnt NSAPI nsIOServiceHook_Release(nsIIOServiceHook *iface)
3739 {
3740     return 1;
3741 }
3742
3743 static nsresult NSAPI nsIOServiceHook_NewChannel(nsIIOServiceHook *iface, nsIURI *aURI,
3744         nsILoadInfo *aLoadInfo, nsIChannel **_retval)
3745 {
3746     nsWineURI *wine_uri;
3747     nsChannel *ret;
3748     nsresult nsres;
3749
3750     TRACE("(%p %p %p)\n", aURI, aLoadInfo, _retval);
3751
3752     nsres = nsIURI_QueryInterface(aURI, &IID_nsWineURI, (void**)&wine_uri);
3753     if(NS_FAILED(nsres)) {
3754         TRACE("Could not get nsWineURI: %08lx\n", nsres);
3755         return NS_SUCCESS_DEFAULT_ACTION;
3756     }
3757
3758     nsres = create_nschannel(wine_uri, &ret);
3759     nsIFileURL_Release(&wine_uri->nsIFileURL_iface);
3760     if(NS_FAILED(nsres))
3761         return nsres;
3762
3763     nsIURI_AddRef(aURI);
3764     ret->original_uri = aURI;
3765
3766     if(aLoadInfo)
3767         nsIHttpChannel_SetLoadInfo(&ret->nsIHttpChannel_iface, aLoadInfo);
3768
3769     *_retval = (nsIChannel*)&ret->nsIHttpChannel_iface;
3770     return NS_OK;
3771 }
3772
3773 static nsresult NSAPI nsIOServiceHook_GetProtocolHandler(nsIIOServiceHook *iface, nsIProtocolHandler *aHandler,
3774         nsIProtocolHandler **_retval)
3775 {
3776     nsIExternalProtocolHandler *nsexthandler;
3777     nsProtocolHandler *ret;
3778     nsresult nsres;
3779
3780     TRACE("(%p %p)\n", aHandler, _retval);
3781
3782     nsres = nsIProtocolHandler_QueryInterface(aHandler, &IID_nsIExternalProtocolHandler, (void**)&nsexthandler);
3783     if(NS_FAILED(nsres)) {
3784         nsIProtocolHandler_AddRef(aHandler);
3785         *_retval = aHandler;
3786         return NS_OK;
3787     }
3788
3789     nsIExternalProtocolHandler_Release(nsexthandler);
3790
3791     ret = heap_alloc(sizeof(nsProtocolHandler));
3792     if(!ret)
3793         return NS_ERROR_OUT_OF_MEMORY;
3794
3795     ret->nsIProtocolHandler_iface.lpVtbl = &nsProtocolHandlerVtbl;
3796     ret->ref = 1;
3797     nsIProtocolHandler_AddRef(aHandler);
3798     ret->nshandler = aHandler;
3799
3800
3801     *_retval = &ret->nsIProtocolHandler_iface;
3802     TRACE("return %p\n", *_retval);
3803     return NS_OK;
3804 }
3805
3806 static BOOL is_gecko_special_uri(const char *spec)
3807 {
3808     static const char *special_schemes[] = {"chrome:", "data:", "jar:", "moz-safe-about", "resource://gre/", "resource://gre-resources/", "javascript:", "wyciwyg:"};
3809     unsigned int i;
3810
3811     for(i=0; i < ARRAY_SIZE(special_schemes); i++) {
3812         if(!_strnicmp(spec, special_schemes[i], strlen(special_schemes[i])))
3813             return TRUE;
3814     }
3815
3816     if(!_strnicmp(spec, "file:", 5)) {
3817         const char *ptr = spec+5;
3818         while(*ptr == '/')
3819             ptr++;
3820         return is_gecko_path(ptr);
3821     }
3822
3823     return FALSE;
3824 }
3825
3826 static nsresult NSAPI nsIOServiceHook_NewURI(nsIIOServiceHook *iface, const nsACString *aSpec,
3827         const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
3828 {
3829     nsWineURI *wine_uri, *base_wine_uri = NULL;
3830     WCHAR new_spec[INTERNET_MAX_URL_LENGTH];
3831     const char *spec = NULL;
3832     UINT cp = CP_UTF8;
3833     IUri *urlmon_uri;
3834     nsresult nsres;
3835     HRESULT hres;
3836
3837     TRACE("(%s %s %p %p)\n", debugstr_nsacstr(aSpec), debugstr_a(aOriginCharset),
3838           aBaseURI, _retval);
3839
3840     nsACString_GetData(aSpec, &spec);
3841     if(is_gecko_special_uri(spec))
3842         return NS_SUCCESS_DEFAULT_ACTION;
3843
3844     if(!strncmp(spec, "wine:", 5))
3845         spec += 5;
3846
3847     if(aBaseURI) {
3848         nsres = nsIURI_QueryInterface(aBaseURI, &IID_nsWineURI, (void**)&base_wine_uri);
3849         if(NS_SUCCEEDED(nsres)) {
3850             if(!ensure_uri(base_wine_uri))
3851                 return NS_ERROR_UNEXPECTED;
3852         }else {
3853             WARN("Could not get base nsWineURI: %08lx\n", nsres);
3854         }
3855     }
3856
3857     if(aOriginCharset && *aOriginCharset && _strnicmp(aOriginCharset, "utf", 3)) {
3858         BSTR charset;
3859         int len;
3860
3861         len = MultiByteToWideChar(CP_UTF8, 0, aOriginCharset, -1, NULL, 0);
3862         charset = SysAllocStringLen(NULL, len-1);
3863         if(!charset)
3864             return NS_ERROR_OUT_OF_MEMORY;
3865         MultiByteToWideChar(CP_UTF8, 0, aOriginCharset, -1, charset, len);
3866
3867         cp = cp_from_charset_string(charset);
3868
3869         SysFreeString(charset);
3870     }
3871
3872     MultiByteToWideChar(cp, 0, spec, -1, new_spec, ARRAY_SIZE(new_spec));
3873
3874     if(base_wine_uri) {
3875         hres = combine_url(base_wine_uri->uri, new_spec, &urlmon_uri);
3876     }else {
3877         hres = create_uri(new_spec, 0, &urlmon_uri);
3878         if(FAILED(hres))
3879             WARN("create_uri failed: %08lx\n", hres);
3880     }
3881
3882     if(FAILED(hres))
3883         return NS_SUCCESS_DEFAULT_ACTION;
3884
3885     nsres = create_nsuri(urlmon_uri, &wine_uri);
3886     IUri_Release(urlmon_uri);
3887     if(base_wine_uri)
3888         nsIFileURL_Release(&base_wine_uri->nsIFileURL_iface);
3889     if(NS_FAILED(nsres))
3890         return nsres;
3891
3892     *_retval = (nsIURI*)&wine_uri->nsIFileURL_iface;
3893     return nsres;
3894 }
3895
3896 static const char *debugstr_protocol_flags(UINT32 flags)
3897 {
3898     switch(flags) {
3899 #define X(f) case f: return #f
3900     X(URI_STD);
3901     X(URI_NORELATIVE);
3902     X(URI_NOAUTH);
3903     X(ALLOWS_PROXY);
3904     X(ALLOWS_PROXY_HTTP);
3905     X(URI_INHERITS_SECURITY_CONTEXT);
3906     X(URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT);
3907     X(URI_LOADABLE_BY_ANYONE);
3908     X(URI_DANGEROUS_TO_LOAD);
3909     X(URI_IS_UI_RESOURCE);
3910     X(URI_IS_LOCAL_FILE);
3911     X(URI_LOADABLE_BY_SUBSUMERS);
3912     X(URI_DOES_NOT_RETURN_DATA);
3913     X(URI_IS_LOCAL_RESOURCE);
3914     X(URI_OPENING_EXECUTES_SCRIPT);
3915     X(URI_NON_PERSISTABLE);
3916     X(URI_FORBIDS_COOKIE_ACCESS);
3917     X(URI_CROSS_ORIGIN_NEEDS_WEBAPPS_PERM);
3918     X(URI_SYNC_LOAD_IS_OK);
3919     X(URI_SAFE_TO_LOAD_IN_SECURE_CONTEXT);
3920     X(URI_FETCHABLE_BY_ANYONE);
3921 #undef X
3922     default:
3923         return wine_dbg_sprintf("%08x", flags);
3924     }
3925 }
3926
3927 static nsresult NSAPI nsIOServiceHook_ProtocolHasFlags(nsIIOServiceHook *iface, nsIURI *aURI, UINT32 aFlags, cpp_bool *_retval)
3928 {
3929     TRACE("(%p %s %p)\n", aURI, debugstr_protocol_flags(aFlags), _retval);
3930     return NS_SUCCESS_DEFAULT_ACTION;
3931 }
3932
3933 static nsresult NSAPI nsIOServiceHook_URIChainHasFlags(nsIIOServiceHook *iface, nsIURI *aURI, UINT32 aFlags, cpp_bool *_retval)
3934 {
3935     TRACE("(%p %s %p)\n", aURI, debugstr_protocol_flags(aFlags), _retval);
3936
3937     if(aFlags == URI_DOES_NOT_RETURN_DATA) {
3938         *_retval = FALSE;
3939         return S_OK;
3940     }
3941
3942     return NS_SUCCESS_DEFAULT_ACTION;
3943 }
3944
3945 static const nsIIOServiceHookVtbl nsIOServiceHookVtbl = {
3946     nsIOServiceHook_QueryInterface,
3947     nsIOServiceHook_AddRef,
3948     nsIOServiceHook_Release,
3949     nsIOServiceHook_NewChannel,
3950     nsIOServiceHook_GetProtocolHandler,
3951     nsIOServiceHook_NewURI,
3952     nsIOServiceHook_ProtocolHasFlags,
3953     nsIOServiceHook_URIChainHasFlags
3954 };
3955
3956 static nsIIOServiceHook nsIOServiceHook = { &nsIOServiceHookVtbl };
3957
3958 void init_nsio(nsIComponentManager *component_manager)
3959 {
3960     nsIFactory *old_factory = NULL;
3961     nsresult nsres;
3962
3963     nsres = nsIComponentManager_GetClassObject(component_manager, &NS_IOSERVICE_CID,
3964                                                &IID_nsIFactory, (void**)&old_factory);
3965     if(NS_FAILED(nsres)) {
3966         ERR("Could not get factory: %08lx\n", nsres);
3967         return;
3968     }
3969
3970     nsres = nsIFactory_CreateInstance(old_factory, NULL, &IID_nsIIOService, (void**)&nsio);
3971     if(NS_FAILED(nsres)) {
3972         ERR("Couldn not create nsIOService instance %08lx\n", nsres);
3973         nsIFactory_Release(old_factory);
3974         return;
3975     }
3976
3977     nsres = nsIIOService_SetHook(nsio, &nsIOServiceHook);
3978     assert(nsres == NS_OK);
3979 }
3980
3981 void release_nsio(void)
3982 {
3983     if(nsio) {
3984         nsIIOService_Release(nsio);
3985         nsio = NULL;
3986     }
3987 }
3988
3989 nsresult create_onload_blocker_request(nsIRequest **ret)
3990 {
3991     nsIChannel *channel;
3992     nsACString spec;
3993     nsresult nsres;
3994
3995     nsACString_InitDepend(&spec, "about:wine-script-onload-blocker");
3996     nsres = nsIIOService_NewChannel(nsio, &spec, NULL, NULL, &channel);
3997     nsACString_Finish(&spec);
3998     if(NS_FAILED(nsres)) {
3999         ERR("Failed to create channel: %08lx\n", nsres);
4000         return nsres;
4001     }
4002
4003     *ret = (nsIRequest *)channel;
4004     return NS_OK;
4005 }