2001-09-29 00:14:13 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode:nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
1999-11-02 22:36:43 +03:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* The contents of this file are subject to the Netscape Public License
|
|
|
|
* Version 1.1 (the "License"); you may not use this file except in
|
|
|
|
* compliance with the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/NPL/
|
1999-11-02 22:36:43 +03:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
1999-11-02 22:36:43 +03:00
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1999
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:43:54 +03:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
|
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1999-11-02 22:36:43 +03:00
|
|
|
|
|
|
|
#include "nsURILoader.h"
|
1999-11-05 09:01:40 +03:00
|
|
|
#include "nsIURIContentListener.h"
|
1999-11-06 02:06:16 +03:00
|
|
|
#include "nsIContentHandler.h"
|
1999-11-05 09:01:40 +03:00
|
|
|
#include "nsILoadGroup.h"
|
2000-01-29 09:02:36 +03:00
|
|
|
#include "nsIDocumentLoader.h"
|
2000-04-03 06:26:05 +04:00
|
|
|
#include "nsIWebProgress.h"
|
|
|
|
#include "nsIWebProgressListener.h"
|
1999-11-05 09:01:40 +03:00
|
|
|
#include "nsIIOService.h"
|
|
|
|
#include "nsIServiceManager.h"
|
|
|
|
#include "nsIStreamListener.h"
|
1999-11-30 00:00:52 +03:00
|
|
|
#include "nsIURI.h"
|
1999-11-05 09:01:40 +03:00
|
|
|
#include "nsIChannel.h"
|
1999-11-18 10:36:41 +03:00
|
|
|
#include "nsIInterfaceRequestor.h"
|
2001-09-06 01:28:38 +04:00
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
1999-11-10 09:24:40 +03:00
|
|
|
#include "nsIProgressEventSink.h"
|
1999-11-30 00:00:52 +03:00
|
|
|
#include "nsIInputStream.h"
|
1999-11-18 04:02:31 +03:00
|
|
|
#include "nsIStreamConverterService.h"
|
2000-02-15 07:04:34 +03:00
|
|
|
#include "nsWeakReference.h"
|
2001-05-12 01:05:08 +04:00
|
|
|
#include "nsIHttpChannel.h"
|
2002-09-04 02:00:22 +04:00
|
|
|
#include "nsIMultiPartChannel.h"
|
2002-03-21 01:50:33 +03:00
|
|
|
#include "netCore.h"
|
2002-05-15 22:55:21 +04:00
|
|
|
#include "nsCRT.h"
|
2001-05-14 06:16:27 +04:00
|
|
|
#include "nsIDocShell.h"
|
2000-02-15 07:04:34 +03:00
|
|
|
#include "nsIDocShellTreeItem.h"
|
|
|
|
#include "nsIDocShellTreeOwner.h"
|
1999-11-05 09:01:40 +03:00
|
|
|
|
1999-11-02 22:36:43 +03:00
|
|
|
#include "nsXPIDLString.h"
|
|
|
|
#include "nsString.h"
|
|
|
|
|
2000-09-01 05:54:35 +04:00
|
|
|
#include "nsIDOMWindowInternal.h"
|
2000-04-21 09:18:15 +04:00
|
|
|
#include "nsDOMError.h"
|
2000-03-01 00:33:23 +03:00
|
|
|
|
2001-11-30 03:07:13 +03:00
|
|
|
#include "nsICategoryManager.h"
|
2000-09-14 03:57:52 +04:00
|
|
|
#include "nsCExternalHandlerService.h" // contains contractids for the helper app service
|
2000-06-23 08:43:28 +04:00
|
|
|
|
1999-11-18 04:02:31 +03:00
|
|
|
static NS_DEFINE_CID(kStreamConverterServiceCID, NS_STREAMCONVERTERSERVICE_CID);
|
1999-11-05 09:01:40 +03:00
|
|
|
|
2000-01-29 09:02:36 +03:00
|
|
|
|
1999-11-05 09:01:40 +03:00
|
|
|
/*
|
|
|
|
* The nsDocumentOpenInfo contains the state required when a single document
|
|
|
|
* is being opened in order to discover the content type... Each instance remains alive until its target URL has
|
|
|
|
* been loaded (or aborted).
|
|
|
|
*
|
|
|
|
*/
|
1999-11-16 00:35:40 +03:00
|
|
|
class nsDocumentOpenInfo : public nsIStreamListener
|
1999-11-05 09:01:40 +03:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsDocumentOpenInfo();
|
|
|
|
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
nsresult Open(nsIChannel* channel,
|
2001-10-27 06:52:39 +04:00
|
|
|
PRBool aIsContentPreferred,
|
2000-01-29 09:02:36 +03:00
|
|
|
nsISupports * aWindowContext);
|
1999-11-05 09:01:40 +03:00
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
nsresult DispatchContent(nsIRequest *request, nsISupports * aCtxt);
|
|
|
|
nsresult RetargetOutput(nsIRequest *request, const char * aSrcContentType,
|
1999-11-18 04:02:31 +03:00
|
|
|
const char * aOutContentType, nsIStreamListener * aStreamListener);
|
|
|
|
|
2001-04-10 10:01:08 +04:00
|
|
|
// nsIRequestObserver methods:
|
|
|
|
NS_DECL_NSIREQUESTOBSERVER
|
1999-11-05 09:01:40 +03:00
|
|
|
|
2000-10-04 10:53:52 +04:00
|
|
|
// nsIStreamListener methods:
|
1999-11-16 00:35:40 +03:00
|
|
|
NS_DECL_NSISTREAMLISTENER
|
1999-11-05 09:01:40 +03:00
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual ~nsDocumentOpenInfo();
|
1999-12-28 12:20:05 +03:00
|
|
|
nsDocumentOpenInfo* Clone();
|
|
|
|
|
1999-11-05 09:01:40 +03:00
|
|
|
protected:
|
|
|
|
nsCOMPtr<nsIURIContentListener> m_contentListener;
|
1999-11-16 00:35:40 +03:00
|
|
|
nsCOMPtr<nsIStreamListener> m_targetStreamListener;
|
2000-03-09 11:17:40 +03:00
|
|
|
nsCOMPtr<nsISupports> m_originalContext;
|
2001-10-27 06:52:39 +04:00
|
|
|
PRBool mIsContentPreferred;
|
1999-11-05 09:01:40 +03:00
|
|
|
};
|
|
|
|
|
2000-03-06 00:26:01 +03:00
|
|
|
NS_IMPL_THREADSAFE_ADDREF(nsDocumentOpenInfo);
|
|
|
|
NS_IMPL_THREADSAFE_RELEASE(nsDocumentOpenInfo);
|
1999-11-30 00:00:52 +03:00
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsDocumentOpenInfo)
|
2001-04-10 10:01:08 +04:00
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRequestObserver)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
|
1999-11-30 00:00:52 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
|
2000-03-06 00:26:01 +03:00
|
|
|
NS_INTERFACE_MAP_END_THREADSAFE
|
1999-11-05 09:01:40 +03:00
|
|
|
|
|
|
|
nsDocumentOpenInfo::nsDocumentOpenInfo()
|
|
|
|
{
|
|
|
|
NS_INIT_ISUPPORTS();
|
|
|
|
}
|
|
|
|
|
|
|
|
nsDocumentOpenInfo::~nsDocumentOpenInfo()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
1999-12-28 12:20:05 +03:00
|
|
|
nsDocumentOpenInfo* nsDocumentOpenInfo::Clone()
|
|
|
|
{
|
|
|
|
nsDocumentOpenInfo* newObject;
|
|
|
|
|
|
|
|
newObject = new nsDocumentOpenInfo();
|
|
|
|
if (newObject) {
|
2001-10-27 06:52:39 +04:00
|
|
|
newObject->m_contentListener = m_contentListener;
|
|
|
|
newObject->mIsContentPreferred = mIsContentPreferred;
|
|
|
|
newObject->m_originalContext = m_originalContext;
|
1999-12-28 12:20:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return newObject;
|
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
nsresult nsDocumentOpenInfo::Open(nsIChannel *aChannel,
|
2001-10-27 06:52:39 +04:00
|
|
|
PRBool aIsContentPreferred,
|
2000-01-29 09:02:36 +03:00
|
|
|
nsISupports * aWindowContext)
|
1999-11-05 09:01:40 +03:00
|
|
|
{
|
|
|
|
// this method is not complete!!! Eventually, we should first go
|
|
|
|
// to the content listener and ask them for a protocol handler...
|
|
|
|
// if they don't give us one, we need to go to the registry and get
|
|
|
|
// the preferred protocol handler.
|
|
|
|
|
|
|
|
// But for now, I'm going to let necko do the work for us....
|
|
|
|
|
2001-10-27 06:52:39 +04:00
|
|
|
nsresult rv;
|
2001-05-14 06:16:27 +04:00
|
|
|
|
1999-11-05 09:01:40 +03:00
|
|
|
// store any local state
|
2001-10-27 06:52:39 +04:00
|
|
|
mIsContentPreferred = aIsContentPreferred;
|
1999-11-05 09:01:40 +03:00
|
|
|
|
2001-05-14 06:16:27 +04:00
|
|
|
m_originalContext = aWindowContext;
|
|
|
|
|
|
|
|
// ask the window context if it has a uri content listener...
|
|
|
|
m_contentListener = do_GetInterface(aWindowContext, &rv);
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
2000-04-03 06:26:05 +04:00
|
|
|
// now just open the channel!
|
2001-02-21 23:38:08 +03:00
|
|
|
if (aChannel){
|
|
|
|
rv = aChannel->AsyncOpen(this, nsnull);
|
|
|
|
}
|
|
|
|
|
2001-09-08 08:58:59 +04:00
|
|
|
// no content from this load - that's OK.
|
|
|
|
if (rv == NS_ERROR_DOM_RETVAL_UNDEFINED ||
|
|
|
|
rv == NS_ERROR_NO_CONTENT) {
|
2000-04-21 09:18:15 +04:00
|
|
|
rv = NS_OK;
|
|
|
|
}
|
2001-09-08 08:58:59 +04:00
|
|
|
|
1999-11-05 09:01:40 +03:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
NS_IMETHODIMP nsDocumentOpenInfo::OnStartRequest(nsIRequest *request, nsISupports * aCtxt)
|
1999-11-05 09:01:40 +03:00
|
|
|
{
|
2000-06-17 01:21:04 +04:00
|
|
|
nsresult rv = NS_OK;
|
2000-05-25 09:12:58 +04:00
|
|
|
|
|
|
|
//
|
|
|
|
// Deal with "special" HTTP responses:
|
|
|
|
//
|
|
|
|
// - In the case of a 204 (No Content) response, do not try to find a
|
|
|
|
// content handler. Just return. This causes the request to be
|
|
|
|
// ignored.
|
|
|
|
//
|
2001-05-12 01:05:08 +04:00
|
|
|
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(request, &rv));
|
2000-05-25 09:12:58 +04:00
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
|
|
PRUint32 responseCode = 0;
|
|
|
|
|
2001-08-02 02:52:42 +04:00
|
|
|
rv = httpChannel->GetResponseStatus(&responseCode);
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
// behave as in the canceled case
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-05-25 09:12:58 +04:00
|
|
|
if (204 == responseCode) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-11-13 10:47:22 +03:00
|
|
|
//
|
|
|
|
// Make sure that the transaction has succeeded, so far...
|
|
|
|
//
|
|
|
|
nsresult status;
|
|
|
|
|
|
|
|
rv = request->GetStatus(&status);
|
|
|
|
|
|
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Unable to get request status!");
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
if (NS_FAILED(status)) {
|
|
|
|
//
|
|
|
|
// The transaction has already reported an error - so it will be torn
|
|
|
|
// down. Therefore, it is not necessary to return an error code...
|
|
|
|
//
|
2000-06-17 01:21:04 +04:00
|
|
|
return NS_OK;
|
2001-11-13 10:47:22 +03:00
|
|
|
}
|
2000-06-17 01:21:04 +04:00
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
rv = DispatchContent(request, aCtxt);
|
1999-11-18 04:02:31 +03:00
|
|
|
if (m_targetStreamListener)
|
2001-02-21 23:38:08 +03:00
|
|
|
rv = m_targetStreamListener->OnStartRequest(request, aCtxt);
|
1999-11-16 00:35:40 +03:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
NS_IMETHODIMP nsDocumentOpenInfo::OnDataAvailable(nsIRequest *request, nsISupports * aCtxt,
|
1999-11-16 00:35:40 +03:00
|
|
|
nsIInputStream * inStr, PRUint32 sourceOffset, PRUint32 count)
|
|
|
|
{
|
|
|
|
// if we have retarged to the end stream listener, then forward the call....
|
|
|
|
// otherwise, don't do anything
|
|
|
|
|
|
|
|
nsresult rv = NS_OK;
|
2000-06-17 01:21:04 +04:00
|
|
|
|
1999-11-16 00:35:40 +03:00
|
|
|
if (m_targetStreamListener)
|
2001-02-21 23:38:08 +03:00
|
|
|
rv = m_targetStreamListener->OnDataAvailable(request, aCtxt, inStr, sourceOffset, count);
|
1999-11-05 09:01:40 +03:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
NS_IMETHODIMP nsDocumentOpenInfo::OnStopRequest(nsIRequest *request, nsISupports *aCtxt,
|
2001-04-10 10:01:08 +04:00
|
|
|
nsresult aStatus)
|
1999-11-05 09:01:40 +03:00
|
|
|
{
|
2001-06-27 02:58:18 +04:00
|
|
|
if ( m_targetStreamListener)
|
2000-05-10 06:05:54 +04:00
|
|
|
{
|
2001-06-29 07:09:59 +04:00
|
|
|
nsCOMPtr<nsIStreamListener> listener(m_targetStreamListener);
|
1999-11-05 09:01:40 +03:00
|
|
|
|
2001-06-29 07:09:59 +04:00
|
|
|
m_targetStreamListener = 0;
|
|
|
|
listener->OnStopRequest(request, aCtxt, aStatus);
|
|
|
|
}
|
1999-12-28 12:20:05 +03:00
|
|
|
|
2001-11-13 10:47:22 +03:00
|
|
|
// Remember...
|
|
|
|
// In the case of multiplexed streams (such as multipart/x-mixed-replace)
|
|
|
|
// these stream listener methods could be called again :-)
|
|
|
|
//
|
2001-06-29 07:09:59 +04:00
|
|
|
return NS_OK;
|
1999-11-05 09:01:40 +03:00
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
nsresult nsDocumentOpenInfo::DispatchContent(nsIRequest *request, nsISupports * aCtxt)
|
1999-11-18 04:02:31 +03:00
|
|
|
{
|
2000-01-05 07:44:27 +03:00
|
|
|
nsresult rv;
|
2002-03-21 01:50:33 +03:00
|
|
|
nsCAutoString contentType;
|
2000-04-19 00:41:38 +04:00
|
|
|
nsCOMPtr<nsISupports> originalWindowContext = m_originalContext; // local variable to keep track of this.
|
2000-06-23 08:43:28 +04:00
|
|
|
nsCOMPtr<nsIStreamListener> contentStreamListener;
|
2001-02-21 23:38:08 +03:00
|
|
|
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
|
2001-04-10 10:01:08 +04:00
|
|
|
if (!aChannel) {
|
2001-02-21 23:38:08 +03:00
|
|
|
return NS_ERROR_FAILURE;
|
2001-04-10 10:01:08 +04:00
|
|
|
}
|
2000-01-05 07:44:27 +03:00
|
|
|
|
2002-03-21 01:50:33 +03:00
|
|
|
rv = aChannel->GetContentType(contentType);
|
1999-11-18 04:02:31 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
2000-01-05 07:44:27 +03:00
|
|
|
// go to the uri dispatcher and give them our stuff...
|
2001-05-14 06:16:27 +04:00
|
|
|
nsCOMPtr<nsIURILoader> uriLoader;
|
|
|
|
uriLoader = do_GetService(NS_URI_LOADER_CONTRACTID, &rv);
|
1999-11-18 04:02:31 +03:00
|
|
|
if (NS_SUCCEEDED(rv))
|
|
|
|
{
|
2000-01-05 07:44:27 +03:00
|
|
|
nsCOMPtr<nsIURIContentListener> contentListener;
|
|
|
|
nsXPIDLCString desiredContentType;
|
|
|
|
|
2002-09-04 02:00:22 +04:00
|
|
|
// Check whether the data should be forced to be handled
|
|
|
|
// externally. This could happen because the Content-Disposition
|
|
|
|
// header is set so, or, in the future, because the user has
|
|
|
|
// specified external handling for the MIME type.
|
|
|
|
PRBool forceExternalHandling = PR_FALSE;
|
|
|
|
nsCAutoString disposition;
|
|
|
|
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(request));
|
|
|
|
if (httpChannel)
|
|
|
|
{
|
|
|
|
rv = httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("content-disposition"),
|
|
|
|
disposition);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIMultiPartChannel> multipartChannel(do_QueryInterface(request));
|
|
|
|
if (multipartChannel)
|
|
|
|
{
|
|
|
|
rv = multipartChannel->GetContentDisposition(disposition);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NS_SUCCEEDED(rv) && !disposition.IsEmpty())
|
|
|
|
{
|
|
|
|
nsCAutoString::const_iterator start, end;
|
|
|
|
disposition.BeginReading(start);
|
|
|
|
disposition.EndReading(end);
|
|
|
|
// skip leading whitespace
|
|
|
|
while (start != end && nsCRT::IsAsciiSpace(*start))
|
|
|
|
{
|
|
|
|
++start;
|
|
|
|
}
|
|
|
|
nsCAutoString::const_iterator iter = start;
|
|
|
|
// walk forward till we hit the next whitespace or semicolon
|
|
|
|
while (iter != end && *iter != ';' && !nsCRT::IsAsciiSpace(*iter))
|
|
|
|
{
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
if (start != iter &&
|
|
|
|
Substring(start, iter).Equals(NS_LITERAL_CSTRING("attachment"),
|
|
|
|
nsCaseInsensitiveCStringComparator()))
|
|
|
|
{
|
|
|
|
// We have a content-disposition of "attachment"
|
|
|
|
forceExternalHandling = PR_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!forceExternalHandling)
|
|
|
|
{
|
|
|
|
//
|
|
|
|
// First step: See if any nsIURIContentListener prefers to handle this
|
|
|
|
// content type.
|
|
|
|
//
|
|
|
|
PRBool abortDispatch = PR_FALSE;
|
|
|
|
rv = uriLoader->DispatchContent(contentType.get(),
|
|
|
|
mIsContentPreferred,
|
|
|
|
request, aCtxt,
|
|
|
|
m_contentListener,
|
|
|
|
m_originalContext,
|
|
|
|
getter_Copies(desiredContentType),
|
|
|
|
getter_AddRefs(contentListener),
|
|
|
|
&abortDispatch);
|
|
|
|
|
|
|
|
// if the uri loader says to abort the dispatch then someone
|
|
|
|
// else must have stepped in and taken over for us...so stop..
|
|
|
|
|
|
|
|
if (abortDispatch) return NS_OK;
|
|
|
|
}
|
|
|
|
|
2000-01-05 07:44:27 +03:00
|
|
|
//
|
|
|
|
// Second step: If no listener prefers this type, see if any stream
|
|
|
|
// decoders exist to transform this content type into
|
|
|
|
// some other.
|
|
|
|
//
|
2002-09-04 02:00:22 +04:00
|
|
|
|
|
|
|
// We always want to do this, since even content being forced to
|
|
|
|
// be handled externally may need decoding (eg via the unknown
|
|
|
|
// content decoder)
|
2000-06-23 08:43:28 +04:00
|
|
|
if (!contentListener)
|
|
|
|
{
|
2002-03-21 01:50:33 +03:00
|
|
|
rv = RetargetOutput(request, contentType.get(), "*/*", nsnull);
|
2000-06-23 08:43:28 +04:00
|
|
|
if (m_targetStreamListener)
|
|
|
|
return NS_OK;
|
2000-01-05 07:44:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Step 3:
|
|
|
|
//
|
|
|
|
// BIG TIME HACK ALERT!!!!! WE NEED THIS HACK IN PLACE UNTIL OUR NEW UNKNOWN CONTENT
|
|
|
|
// HANDLER COMES ONLINE!!!
|
|
|
|
// Until that day, if we couldn't find a handler for the content type, then go back to the listener who
|
|
|
|
// originated the url request and force them to handle the content....this forces us through the old code
|
|
|
|
// path for unknown content types which brings up the file save as dialog...
|
|
|
|
if (!contentListener) {
|
|
|
|
contentListener = m_contentListener;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Good news! Some content listener can handle this content type.
|
|
|
|
//
|
|
|
|
if (contentListener)
|
1999-11-18 04:02:31 +03:00
|
|
|
{
|
2002-09-04 02:00:22 +04:00
|
|
|
if (!forceExternalHandling)
|
2000-01-29 09:02:36 +03:00
|
|
|
{
|
2002-09-04 02:00:22 +04:00
|
|
|
PRBool bAbortProcess = PR_FALSE;
|
|
|
|
nsCAutoString contentTypeToUse;
|
|
|
|
if (desiredContentType)
|
|
|
|
contentTypeToUse.Assign(desiredContentType);
|
|
|
|
else
|
|
|
|
contentTypeToUse.Assign(contentType);
|
|
|
|
|
|
|
|
// We need to first figure out if we are retargeting the load
|
|
|
|
// to a content listener that is different from the one that
|
|
|
|
// originated the request....if so, set
|
|
|
|
// LOAD_RETARGETED_DOCUMENT_URI on the channel.
|
|
|
|
|
|
|
|
if (contentListener != m_contentListener)
|
|
|
|
{
|
|
|
|
// we must be retargeting...so set an appropriate flag on
|
|
|
|
// the channel
|
|
|
|
nsLoadFlags loadFlags = 0;
|
|
|
|
aChannel->GetLoadFlags(&loadFlags);
|
|
|
|
loadFlags |= nsIChannel::LOAD_RETARGETED_DOCUMENT_URI;
|
|
|
|
aChannel->SetLoadFlags(loadFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = contentListener->DoContent(contentTypeToUse.get(),
|
|
|
|
mIsContentPreferred,
|
|
|
|
request,
|
|
|
|
getter_AddRefs(contentStreamListener),
|
|
|
|
&bAbortProcess);
|
|
|
|
|
|
|
|
// Do not continue loading if nsIURIContentListener::DoContent(...)
|
|
|
|
// fails - It means that an unexpected error occurred...
|
|
|
|
//
|
|
|
|
// If bAbortProcess is TRUE then the listener is doing all the work from
|
|
|
|
// here...we are done!!!
|
|
|
|
if (NS_FAILED(rv) || bAbortProcess) {
|
|
|
|
return rv;
|
|
|
|
}
|
2001-08-21 10:26:59 +04:00
|
|
|
}
|
2002-09-04 02:00:22 +04:00
|
|
|
|
2001-02-07 05:44:09 +03:00
|
|
|
// try to detect if there is a helper application we an use...
|
2001-10-27 06:52:39 +04:00
|
|
|
if (!contentStreamListener)
|
2000-06-23 08:43:28 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
PRBool abortProcess = PR_FALSE;
|
|
|
|
aChannel->GetURI(getter_AddRefs(uri));
|
2000-09-14 03:57:52 +04:00
|
|
|
nsCOMPtr<nsIExternalHelperAppService> helperAppService (do_GetService(NS_EXTERNALHELPERAPPSERVICE_CONTRACTID));
|
2000-06-28 01:43:17 +04:00
|
|
|
if (helperAppService)
|
|
|
|
{
|
2002-03-21 01:50:33 +03:00
|
|
|
rv = helperAppService->DoContent(contentType.get(), uri, m_originalContext, &abortProcess, getter_AddRefs(contentStreamListener));
|
2000-06-28 01:43:17 +04:00
|
|
|
if (NS_SUCCEEDED(rv) && contentStreamListener)
|
2002-03-21 01:50:33 +03:00
|
|
|
return RetargetOutput(request, contentType.get(), contentType.get(), contentStreamListener);
|
2000-06-28 01:43:17 +04:00
|
|
|
}
|
|
|
|
rv = NS_ERROR_FAILURE; // this will cause us to bring up the unknown content handler dialog.
|
2000-06-23 08:43:28 +04:00
|
|
|
}
|
|
|
|
|
1999-11-18 04:02:31 +03:00
|
|
|
// okay, all registered listeners have had a chance to handle this content...
|
|
|
|
// did one of them give us a stream listener back? if so, let's start reading data
|
|
|
|
// into it...
|
2002-03-21 01:50:33 +03:00
|
|
|
rv = RetargetOutput(request, contentType.get(), desiredContentType, contentStreamListener);
|
2002-03-07 23:57:55 +03:00
|
|
|
// Reinitialize the content listener in case this is a multipart stream.
|
|
|
|
m_contentListener = do_GetInterface(m_originalContext);
|
2000-01-05 07:44:27 +03:00
|
|
|
}
|
1999-11-18 04:02:31 +03:00
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
nsresult nsDocumentOpenInfo::RetargetOutput(nsIRequest *request, const char * aSrcContentType, const char * aOutContentType,
|
1999-11-18 04:02:31 +03:00
|
|
|
nsIStreamListener * aStreamListener)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
2000-06-23 08:43:28 +04:00
|
|
|
|
|
|
|
// catch the case when some joker server sends back a content type of "*/*"
|
|
|
|
// because we said we could handle "*/*" in our accept headers
|
|
|
|
if (aOutContentType && *aOutContentType && nsCRT::strcasecmp(aSrcContentType, aOutContentType) && nsCRT::strcmp(aSrcContentType, "*/*"))
|
1999-11-18 04:02:31 +03:00
|
|
|
{
|
2001-07-25 11:54:28 +04:00
|
|
|
nsCOMPtr<nsIStreamConverterService> StreamConvService =
|
|
|
|
do_GetService(kStreamConverterServiceCID, &rv);
|
2000-01-05 07:44:27 +03:00
|
|
|
if (NS_FAILED(rv)) return rv;
|
2000-04-02 13:15:46 +04:00
|
|
|
nsAutoString from_w; from_w.AssignWithConversion (aSrcContentType);
|
|
|
|
nsAutoString to_w; to_w.AssignWithConversion (aOutContentType);
|
2000-06-23 08:43:28 +04:00
|
|
|
|
|
|
|
nsDocumentOpenInfo* nextLink;
|
|
|
|
|
|
|
|
// When applying stream decoders, it is necessary to "insert" an
|
|
|
|
// intermediate nsDocumentOpenInfo instance to handle the targeting of
|
|
|
|
// the "final" stream or streams.
|
|
|
|
//
|
|
|
|
// For certain content types (ie. multi-part/x-mixed-replace) the input
|
|
|
|
// stream is split up into multiple destination streams. This
|
|
|
|
// intermediate instance is used to target these "decoded" streams...
|
|
|
|
//
|
|
|
|
nextLink = Clone();
|
|
|
|
if (!nextLink) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
NS_ADDREF(nextLink);
|
|
|
|
|
|
|
|
// Set up the final destination listener.
|
|
|
|
nextLink->m_targetStreamListener = nsnull;
|
1999-12-28 12:20:05 +03:00
|
|
|
|
1999-11-18 04:02:31 +03:00
|
|
|
// The following call binds this channelListener's mNextListener (typically
|
|
|
|
// the nsDocumentBindInfo) to the underlying stream converter, and returns
|
|
|
|
// the underlying stream converter which we then set to be this channelListener's
|
|
|
|
// mNextListener. This effectively nestles the stream converter down right
|
|
|
|
// in between the raw stream and the final listener.
|
2001-06-30 15:02:25 +04:00
|
|
|
rv = StreamConvService->AsyncConvertData(from_w.get(),
|
|
|
|
to_w.get(),
|
2000-06-23 08:43:28 +04:00
|
|
|
nextLink,
|
2001-02-21 23:38:08 +03:00
|
|
|
request,
|
2000-01-05 07:44:27 +03:00
|
|
|
getter_AddRefs(m_targetStreamListener));
|
2000-06-23 08:43:28 +04:00
|
|
|
NS_RELEASE(nextLink);
|
1999-11-18 04:02:31 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
m_targetStreamListener = aStreamListener; // no converter necessary so use a direct pipe
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
1999-11-06 02:06:16 +03:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Implementation of nsURILoader
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
1999-11-02 22:36:43 +03:00
|
|
|
nsURILoader::nsURILoader()
|
|
|
|
{
|
|
|
|
NS_INIT_ISUPPORTS();
|
2001-03-28 22:09:03 +04:00
|
|
|
NS_NewISupportsArray(getter_AddRefs(m_listeners));
|
1999-11-02 22:36:43 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
nsURILoader::~nsURILoader()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
1999-11-30 00:00:52 +03:00
|
|
|
NS_IMPL_ADDREF(nsURILoader);
|
|
|
|
NS_IMPL_RELEASE(nsURILoader);
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsURILoader)
|
1999-12-02 09:59:39 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIURILoader)
|
1999-11-30 00:00:52 +03:00
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIURILoader)
|
|
|
|
NS_INTERFACE_MAP_END
|
1999-11-02 22:36:43 +03:00
|
|
|
|
|
|
|
NS_IMETHODIMP nsURILoader::RegisterContentListener(nsIURIContentListener * aContentListener)
|
|
|
|
{
|
|
|
|
nsresult rv = NS_OK;
|
2001-03-28 22:09:03 +04:00
|
|
|
if (!m_listeners) return NS_ERROR_FAILURE;
|
|
|
|
|
|
|
|
nsWeakPtr weakListener = do_GetWeakReference(aContentListener);
|
|
|
|
NS_ASSERTION(weakListener, "your URIContentListener must support weak refs!\n");
|
|
|
|
|
|
|
|
if (weakListener)
|
|
|
|
m_listeners->AppendElement(weakListener);
|
1999-11-02 22:36:43 +03:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsURILoader::UnRegisterContentListener(nsIURIContentListener * aContentListener)
|
|
|
|
{
|
2001-03-28 22:09:03 +04:00
|
|
|
if (!m_listeners) return NS_OK;
|
|
|
|
|
|
|
|
nsWeakPtr weakListener = do_GetWeakReference(aContentListener);
|
|
|
|
if (weakListener)
|
|
|
|
m_listeners->RemoveElement(weakListener);
|
|
|
|
|
1999-11-02 22:36:43 +03:00
|
|
|
return NS_OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
NS_IMETHODIMP nsURILoader::OpenURI(nsIChannel *channel,
|
2001-10-27 06:52:39 +04:00
|
|
|
PRBool aIsContentPreferred,
|
2000-01-29 09:02:36 +03:00
|
|
|
nsISupports * aWindowContext)
|
1999-11-06 02:06:16 +03:00
|
|
|
{
|
2001-10-27 06:52:39 +04:00
|
|
|
return OpenURIVia(channel, aIsContentPreferred, aWindowContext,
|
|
|
|
0 /* ip address */);
|
2000-02-15 07:04:34 +03:00
|
|
|
}
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
NS_IMETHODIMP nsURILoader::OpenURIVia(nsIChannel *channel,
|
2001-10-27 06:52:39 +04:00
|
|
|
PRBool aIsContentPreferred,
|
2001-05-14 06:16:27 +04:00
|
|
|
nsISupports * aWindowContext,
|
1999-11-18 23:47:57 +03:00
|
|
|
PRUint32 aLocalIP)
|
1999-11-02 22:36:43 +03:00
|
|
|
{
|
1999-11-05 09:01:40 +03:00
|
|
|
// we need to create a DocumentOpenInfo object which will go ahead and open the url
|
|
|
|
// and discover the content type....
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsDocumentOpenInfo* loader = nsnull;
|
|
|
|
|
2001-02-21 23:38:08 +03:00
|
|
|
if (!channel) return NS_ERROR_NULL_POINTER;
|
1999-11-05 09:01:40 +03:00
|
|
|
|
2000-03-24 03:23:40 +03:00
|
|
|
// Let the window context's uriListener know that the open is starting. This
|
|
|
|
// gives that window a chance to abort the load process.
|
2001-05-14 06:16:27 +04:00
|
|
|
nsCOMPtr<nsIURIContentListener> winContextListener(do_GetInterface(aWindowContext));
|
|
|
|
if(winContextListener) {
|
2001-02-21 23:38:08 +03:00
|
|
|
// get channel from request
|
2000-03-24 03:23:40 +03:00
|
|
|
nsCOMPtr<nsIURI> uri;
|
2001-02-21 23:38:08 +03:00
|
|
|
channel->GetURI(getter_AddRefs(uri));
|
2001-05-14 06:16:27 +04:00
|
|
|
if(uri) {
|
2000-03-30 07:21:26 +04:00
|
|
|
PRBool doAbort = PR_FALSE;
|
2001-05-14 06:16:27 +04:00
|
|
|
winContextListener->OnStartURIOpen(uri, &doAbort);
|
2000-03-24 03:23:40 +03:00
|
|
|
|
2000-03-30 07:21:26 +04:00
|
|
|
if(doAbort)
|
2000-03-24 03:23:40 +03:00
|
|
|
return NS_OK;
|
2001-05-14 06:16:27 +04:00
|
|
|
}
|
|
|
|
}
|
2000-02-15 07:04:34 +03:00
|
|
|
|
1999-11-05 09:01:40 +03:00
|
|
|
NS_NEWXPCOM(loader, nsDocumentOpenInfo);
|
|
|
|
if (!loader) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
NS_ADDREF(loader);
|
2000-01-29 09:02:36 +03:00
|
|
|
|
2000-05-07 06:01:10 +04:00
|
|
|
nsCOMPtr<nsIInterfaceRequestor> loadCookie;
|
2001-05-14 06:16:27 +04:00
|
|
|
SetupLoadCookie(aWindowContext, getter_AddRefs(loadCookie));
|
1999-11-05 09:01:40 +03:00
|
|
|
|
|
|
|
// now instruct the loader to go ahead and open the url
|
2001-10-27 06:52:39 +04:00
|
|
|
rv = loader->Open(channel, aIsContentPreferred, aWindowContext);
|
1999-11-05 09:01:40 +03:00
|
|
|
NS_RELEASE(loader);
|
|
|
|
|
2000-04-21 09:18:15 +04:00
|
|
|
return rv;
|
1999-11-05 09:01:40 +03:00
|
|
|
}
|
|
|
|
|
2000-02-14 13:12:55 +03:00
|
|
|
NS_IMETHODIMP nsURILoader::Stop(nsISupports* aLoadCookie)
|
|
|
|
{
|
2000-05-07 06:01:10 +04:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIDocumentLoader> docLoader;
|
2000-02-14 13:12:55 +03:00
|
|
|
|
2000-05-07 06:01:10 +04:00
|
|
|
NS_ENSURE_ARG_POINTER(aLoadCookie);
|
2000-02-14 13:12:55 +03:00
|
|
|
|
2000-05-07 06:01:10 +04:00
|
|
|
docLoader = do_GetInterface(aLoadCookie, &rv);
|
|
|
|
if (docLoader) {
|
|
|
|
rv = docLoader->Stop();
|
|
|
|
}
|
|
|
|
return rv;
|
2000-02-14 13:12:55 +03:00
|
|
|
}
|
|
|
|
|
2000-01-29 09:02:36 +03:00
|
|
|
NS_IMETHODIMP
|
2000-05-07 06:01:10 +04:00
|
|
|
nsURILoader::GetLoadGroupForContext(nsISupports * aWindowContext,
|
|
|
|
nsILoadGroup ** aLoadGroup)
|
2000-01-29 09:02:36 +03:00
|
|
|
{
|
2000-05-07 06:01:10 +04:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIInterfaceRequestor> loadCookieForWindow;
|
|
|
|
|
|
|
|
// Initialize the [out] parameter...
|
|
|
|
*aLoadGroup= nsnull;
|
|
|
|
|
2000-01-29 09:02:36 +03:00
|
|
|
NS_ENSURE_ARG(aWindowContext);
|
2000-05-07 06:01:10 +04:00
|
|
|
|
|
|
|
rv = SetupLoadCookie(aWindowContext, getter_AddRefs(loadCookieForWindow));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
2000-01-29 09:02:36 +03:00
|
|
|
|
2000-05-07 06:01:10 +04:00
|
|
|
rv = loadCookieForWindow->GetInterface(NS_GET_IID(nsILoadGroup),
|
|
|
|
(void **) aLoadGroup);
|
|
|
|
return rv;
|
2000-01-29 09:02:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2000-05-07 06:01:10 +04:00
|
|
|
nsURILoader::GetDocumentLoaderForContext(nsISupports * aWindowContext,
|
|
|
|
nsIDocumentLoader ** aDocLoader)
|
2000-01-29 09:02:36 +03:00
|
|
|
{
|
2000-05-07 06:01:10 +04:00
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIInterfaceRequestor> loadCookieForWindow;
|
|
|
|
|
|
|
|
// Initialize the [out] parameter...
|
|
|
|
*aDocLoader = nsnull;
|
|
|
|
|
2000-01-29 09:02:36 +03:00
|
|
|
NS_ENSURE_ARG(aWindowContext);
|
2000-05-07 06:01:10 +04:00
|
|
|
|
|
|
|
rv = SetupLoadCookie(aWindowContext, getter_AddRefs(loadCookieForWindow));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
2000-01-29 09:02:36 +03:00
|
|
|
|
2000-05-07 06:01:10 +04:00
|
|
|
rv = loadCookieForWindow->GetInterface(NS_GET_IID(nsIDocumentLoader),
|
|
|
|
(void **) aDocLoader);
|
|
|
|
return rv;
|
2000-01-29 09:02:36 +03:00
|
|
|
}
|
|
|
|
|
2000-05-07 06:01:10 +04:00
|
|
|
nsresult nsURILoader::SetupLoadCookie(nsISupports * aWindowContext,
|
|
|
|
nsIInterfaceRequestor ** aLoadCookie)
|
2000-01-29 09:02:36 +03:00
|
|
|
{
|
|
|
|
// first, see if we have already set a load cookie on the cnt listener..
|
|
|
|
// i.e. if this isn't the first time we've tried to run a url through this window
|
|
|
|
// context then we don't need to create another load cookie, we can reuse the first one.
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
nsCOMPtr<nsISupports> loadCookie;
|
|
|
|
|
2000-05-07 06:01:10 +04:00
|
|
|
// Initialize the [out] parameter...
|
|
|
|
*aLoadCookie = nsnull;
|
|
|
|
|
2000-01-29 09:02:36 +03:00
|
|
|
nsCOMPtr<nsIURIContentListener> cntListener (do_GetInterface(aWindowContext));
|
2000-05-07 06:01:10 +04:00
|
|
|
if (cntListener) {
|
|
|
|
// Get the load cookie for the requested window context...
|
2000-01-29 09:02:36 +03:00
|
|
|
rv = cntListener->GetLoadCookie(getter_AddRefs(loadCookie));
|
2000-05-07 06:01:10 +04:00
|
|
|
|
|
|
|
//
|
|
|
|
// If we don't have a load cookie for this window context yet, then
|
|
|
|
// go create one! In order to create a load cookie, we need to get
|
|
|
|
// the parent's load cookie if there is one...
|
|
|
|
//
|
|
|
|
if (!loadCookie) {
|
2000-01-29 09:02:36 +03:00
|
|
|
nsCOMPtr<nsIURIContentListener> parentListener;
|
2000-05-07 06:01:10 +04:00
|
|
|
nsCOMPtr<nsIDocumentLoader> parentDocLoader;
|
|
|
|
nsCOMPtr<nsIDocumentLoader> newDocLoader;
|
|
|
|
|
|
|
|
// Try to get the parent's load cookie...
|
2000-01-29 09:02:36 +03:00
|
|
|
cntListener->GetParentContentListener(getter_AddRefs(parentListener));
|
2000-05-07 06:01:10 +04:00
|
|
|
if (parentListener) {
|
2000-01-29 09:02:36 +03:00
|
|
|
rv = parentListener->GetLoadCookie(getter_AddRefs(loadCookie));
|
2000-05-07 06:01:10 +04:00
|
|
|
|
|
|
|
// if we had a parent cookie use it to help with the creation process
|
|
|
|
if (loadCookie) {
|
|
|
|
parentDocLoader = do_GetInterface(loadCookie);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If there is no parent DocLoader, then use the global DocLoader
|
|
|
|
// service as the parent...
|
|
|
|
if (!parentDocLoader) {
|
2000-09-14 03:57:52 +04:00
|
|
|
parentDocLoader = do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID, &rv);
|
2000-05-07 06:01:10 +04:00
|
|
|
}
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
//
|
|
|
|
// Create a new document loader. The document loader represents
|
|
|
|
// the load cookie which the uriloader hands out...
|
|
|
|
//
|
|
|
|
rv = parentDocLoader->CreateDocumentLoader(getter_AddRefs(newDocLoader));
|
|
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
|
|
|
|
newDocLoader->QueryInterface(NS_GET_IID(nsIInterfaceRequestor),
|
|
|
|
getter_AddRefs(loadCookie));
|
|
|
|
rv = cntListener->SetLoadCookie(loadCookie);
|
2000-01-29 09:02:36 +03:00
|
|
|
} // if we don't have a load cookie already
|
|
|
|
} // if we have a cntListener
|
|
|
|
|
2000-05-11 05:33:25 +04:00
|
|
|
// loadCookie may be null - for example, <a target="popupWin"> if popupWin is
|
|
|
|
// not a defined window. The following prevents a crash (Bug 32898)
|
|
|
|
if (loadCookie) {
|
|
|
|
rv = loadCookie->QueryInterface(NS_GET_IID(nsIInterfaceRequestor),
|
2000-05-07 06:01:10 +04:00
|
|
|
(void**)aLoadCookie);
|
2000-05-11 05:33:25 +04:00
|
|
|
} else {
|
|
|
|
rv = NS_ERROR_UNEXPECTED;
|
|
|
|
}
|
2000-01-29 09:02:36 +03:00
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
1999-11-30 00:00:52 +03:00
|
|
|
|
2000-02-04 11:43:34 +03:00
|
|
|
PRBool nsURILoader::ShouldHandleContent(nsIURIContentListener * aCntListener,
|
|
|
|
const char * aContentType,
|
2001-10-27 06:52:39 +04:00
|
|
|
PRBool aIsContentPreferred,
|
2000-02-04 11:43:34 +03:00
|
|
|
char ** aContentTypeToUse)
|
|
|
|
{
|
|
|
|
PRBool foundContentHandler = PR_FALSE;
|
2001-10-27 06:52:39 +04:00
|
|
|
if (aIsContentPreferred) {
|
|
|
|
aCntListener->IsPreferred(aContentType,
|
|
|
|
aContentTypeToUse,
|
|
|
|
&foundContentHandler);
|
|
|
|
} else {
|
|
|
|
aCntListener->CanHandleContent(aContentType, PR_FALSE,
|
2000-02-04 11:43:34 +03:00
|
|
|
aContentTypeToUse,
|
|
|
|
&foundContentHandler);
|
2001-10-27 06:52:39 +04:00
|
|
|
}
|
2000-02-04 11:43:34 +03:00
|
|
|
return foundContentHandler;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsURILoader::DispatchContent(const char * aContentType,
|
2001-10-27 06:52:39 +04:00
|
|
|
PRBool aIsContentPreferred,
|
2001-02-21 23:38:08 +03:00
|
|
|
nsIRequest *request,
|
2000-02-04 11:43:34 +03:00
|
|
|
nsISupports * aCtxt,
|
|
|
|
nsIURIContentListener * aContentListener,
|
2000-03-09 11:17:40 +03:00
|
|
|
nsISupports * aSrcWindowContext,
|
2000-02-04 11:43:34 +03:00
|
|
|
char ** aContentTypeToUse,
|
|
|
|
nsIURIContentListener ** aContentListenerToUse,
|
|
|
|
PRBool * aAbortProcess)
|
1999-11-05 09:01:40 +03:00
|
|
|
{
|
2000-02-04 11:43:34 +03:00
|
|
|
NS_ENSURE_ARG(aContentType);
|
2001-02-21 23:38:08 +03:00
|
|
|
NS_ENSURE_ARG(request);
|
2000-02-04 11:43:34 +03:00
|
|
|
|
2001-03-28 22:09:03 +04:00
|
|
|
// okay, now we've discovered the content type. We need to do the
|
|
|
|
// following:
|
|
|
|
// (1) We always start with the original content listener (if any)
|
|
|
|
// that originated the request and then ask if it can handle the
|
|
|
|
// content.
|
|
|
|
// (2) if it can't, we'll move on to the registered content
|
|
|
|
// listeners and give them a crack at handling the content.
|
|
|
|
// (3) if we cannot find a registered content lister to handle the
|
|
|
|
// type, then we move on to phase II which is to try to find a
|
|
|
|
// content handler in the registry for the content type.
|
|
|
|
// hitting this phase usually means we'll be creating a new
|
|
|
|
// window or handing off to an external application.
|
2000-02-04 11:43:34 +03:00
|
|
|
|
1999-11-05 09:01:40 +03:00
|
|
|
nsresult rv = NS_OK;
|
|
|
|
|
1999-11-06 02:06:16 +03:00
|
|
|
nsCOMPtr<nsIURIContentListener> listenerToUse = aContentListener;
|
2001-05-14 06:16:27 +04:00
|
|
|
|
|
|
|
PRBool foundContentHandler = PR_FALSE;
|
|
|
|
if (listenerToUse)
|
|
|
|
foundContentHandler = ShouldHandleContent(listenerToUse,
|
|
|
|
aContentType,
|
2001-10-27 06:52:39 +04:00
|
|
|
aIsContentPreferred,
|
2001-05-14 06:16:27 +04:00
|
|
|
aContentTypeToUse);
|
2000-02-15 07:04:34 +03:00
|
|
|
|
|
|
|
|
2001-05-14 06:16:27 +04:00
|
|
|
// if it can't handle the content, scan through the list of
|
|
|
|
// registered listeners
|
|
|
|
if (!foundContentHandler)
|
|
|
|
{
|
|
|
|
PRUint32 count = 0;
|
|
|
|
PRInt32 i;
|
|
|
|
|
|
|
|
// keep looping until we get a content listener back
|
|
|
|
m_listeners->Count(&count);
|
|
|
|
for(i = 0; i < (PRInt32)count && !foundContentHandler; i++)
|
2000-02-15 07:04:34 +03:00
|
|
|
{
|
2001-05-14 06:16:27 +04:00
|
|
|
//nsIURIContentListener's aren't refcounted.
|
|
|
|
nsWeakPtr weakListener;
|
|
|
|
nsCOMPtr<nsIURIContentListener> listener;
|
|
|
|
|
|
|
|
m_listeners->QueryElementAt(i, NS_GET_IID(nsIWeakReference),
|
|
|
|
getter_AddRefs(weakListener));
|
2001-03-28 22:09:03 +04:00
|
|
|
|
2001-05-14 06:16:27 +04:00
|
|
|
listener = do_QueryReferent(weakListener);
|
|
|
|
if (listener)
|
|
|
|
{
|
|
|
|
foundContentHandler = ShouldHandleContent(listener,
|
|
|
|
aContentType,
|
2001-10-27 06:52:39 +04:00
|
|
|
aIsContentPreferred,
|
2001-05-14 06:16:27 +04:00
|
|
|
aContentTypeToUse);
|
|
|
|
if (foundContentHandler) {
|
|
|
|
listenerToUse = listener;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// remove from the listener list, and reset i
|
|
|
|
m_listeners->RemoveElementAt(i);
|
|
|
|
i--;
|
|
|
|
}
|
|
|
|
} // for loop
|
|
|
|
} // if we can't handle the content
|
|
|
|
|
|
|
|
|
|
|
|
if (foundContentHandler && listenerToUse)
|
|
|
|
{
|
|
|
|
*aContentListenerToUse = listenerToUse;
|
|
|
|
NS_IF_ADDREF(*aContentListenerToUse);
|
|
|
|
return rv;
|
1999-11-05 09:01:40 +03:00
|
|
|
}
|
|
|
|
|
2001-11-30 03:07:13 +03:00
|
|
|
// Try to find a content listener, that had not yet the chance to register,
|
|
|
|
// as it is contained in a not-yet-loaded module, but which has registered a contract ID.
|
|
|
|
nsCOMPtr<nsICategoryManager> catman = do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
|
|
|
|
if (catman)
|
|
|
|
{
|
|
|
|
// see if someone has registered a content listener for aContentType with the category manager...
|
|
|
|
nsXPIDLCString contractidString;
|
|
|
|
rv = catman->GetCategoryEntry(NS_CONTENT_LISTENER_CATEGORYMANAGER_ENTRY,
|
|
|
|
aContentType, getter_Copies(contractidString));
|
|
|
|
if (NS_SUCCEEDED(rv) && contractidString.get())
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIURIContentListener> listener;
|
|
|
|
listener = do_CreateInstance(contractidString.get(), &rv);
|
|
|
|
if (NS_SUCCEEDED(rv)) // we did indeed have a content listener for this type!! yippee...
|
|
|
|
{
|
|
|
|
foundContentHandler = ShouldHandleContent(listener, aContentType, aIsContentPreferred, aContentTypeToUse);
|
|
|
|
|
|
|
|
if (foundContentHandler && listener)
|
|
|
|
{
|
|
|
|
*aContentListenerToUse = listener;
|
|
|
|
NS_IF_ADDREF(*aContentListenerToUse);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
} // if we were able to create a uri content listener...
|
|
|
|
} // if we got a valid contract ID
|
|
|
|
} // if we can get the category manager....
|
|
|
|
|
1999-11-05 09:01:40 +03:00
|
|
|
// no registered content listeners to handle this type!!! so go to the register
|
|
|
|
// and get a registered nsIContentHandler for our content type. Hand it off
|
|
|
|
// to them...
|
1999-11-06 02:06:16 +03:00
|
|
|
// eventually we want to hit up the category manager so we can allow people to
|
|
|
|
// over ride the default content type handlers....for now...i'm skipping that part.
|
1999-11-05 09:01:40 +03:00
|
|
|
|
2000-09-14 03:57:52 +04:00
|
|
|
nsCAutoString handlerContractID (NS_CONTENT_HANDLER_CONTRACTID_PREFIX);
|
|
|
|
handlerContractID += aContentType;
|
1999-11-06 02:06:16 +03:00
|
|
|
|
|
|
|
nsCOMPtr<nsIContentHandler> aContentHandler;
|
2001-10-25 07:49:28 +04:00
|
|
|
aContentHandler = do_CreateInstance(handlerContractID.get(), &rv);
|
1999-11-06 02:06:16 +03:00
|
|
|
if (NS_SUCCEEDED(rv)) // we did indeed have a content handler for this type!! yippee...
|
2000-01-18 01:21:25 +03:00
|
|
|
{
|
2002-09-24 23:53:43 +04:00
|
|
|
rv = aContentHandler->HandleContent(aContentType, "view", aSrcWindowContext, request);
|
|
|
|
if (rv != NS_ERROR_WONT_HANDLE_CONTENT) {
|
2000-02-04 11:43:34 +03:00
|
|
|
*aAbortProcess = PR_TRUE;
|
2002-09-24 23:53:43 +04:00
|
|
|
|
|
|
|
// The content handler has unexpectedly failed. Cancel the request
|
|
|
|
// just in case the handler didn't...
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
request->Cancel(rv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If WONT_HANDLE_CONTENT is returned -- do not abort. Just return the
|
|
|
|
// failure and keep looking for another consumer (ie. the unknown
|
|
|
|
// content handler)...
|
2000-01-18 01:21:25 +03:00
|
|
|
}
|
1999-12-02 09:59:39 +03:00
|
|
|
|
1999-11-06 02:06:16 +03:00
|
|
|
return rv;
|
1999-11-02 22:36:43 +03:00
|
|
|
}
|
|
|
|
|