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