/// <summary>
        /// Creates nsIRequest wrapper
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Request WrapRequest(nsIRequest request)
        {
            if (request is nsIChannel)
            {
                return Channel.WrapChannel((nsIChannel)request);
            }
            if (request is nsIAsyncStreamCopier)
            {
                return new AsyncStreamCopier((nsIAsyncStreamCopier)request);
            }
            if (request is nsILoadGroup)
            {
                return new LoadGroup((nsILoadGroup)request);
            }
            if (request is nsIIncrementalDownload)
            {
                return new IncrementalDownload((nsIIncrementalDownload)request);
            }
            if (request is imgIRequest)
            {
                return new ImgRequest((imgIRequest)request);
            }
            if (request is nsIInputStreamPump)
            {

            }
            if (request is nsIURIChecker)
            {
                return new UriChecker((nsIURIChecker)request);
            }
            return new Request(request);
        }

		Boolean nsIURIContentListener.DoContent(String aContentType, Boolean aIsContentPreferred, nsIRequest aRequest, out nsIStreamListener aContentHandler)
		{
			Trace.TraceInformation("nsIURIContentListener.DoContent: \"{0}\"", aContentType);

			aContentHandler = null;
			return false;
		}

		bool nsIURIContentListener.doContent (string aContentType,
				 bool aIsContentPreferred,
				 nsIRequest aRequest,
				out nsIStreamListener aContentHandler)
		{
			aContentHandler = null;
			return true;
		}

		void nsIRequestObserver.OnStopRequest( nsIRequest aRequest, nsISupports aContext, int aStatusCode )
		{
			var stopped = Stopped;
			if (stopped != null)
			{
				stopped( this, EventArgs.Empty );
			}
		}

		void nsIWebProgressListener.OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation)
		{
			Trace.TraceInformation("nsIWebProgressListener.OnLocationChange");

			var e = new LocationChangeEventArgs(aLocation.ToUri());
			Events.Raise(EventKey.LocationChange, e);
			if (e.Cancel && (aRequest != null))
			{
				aRequest.Cancel(nsResult.NS_BINDING_ABORTED);
			}
		}

		void nsIWebProgressListener.OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, Int32 aCurSelfProgress, Int32 aMaxSelfProgress, Int32 aCurTotalProgress, Int32 aMaxTotalProgress)
		{
			Trace.TraceInformation("nsIWebProgressListener.OnProgressChange");

			var e = new RequestProgressChangeEventArgs(aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress);
			Events.Raise(EventKey.RequestProgressChange, e);
			if (e.Cancel && (aRequest != null))
			{
				aRequest.Cancel(nsResult.NS_BINDING_ABORTED);
			}
		}

		void nsIWebProgressListener.OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, UInt32 aStatus, String aMessage)
		{
			Trace.TraceInformation("nsIWebProgressListener.OnStatusChange");

			var e = new RequestStatusChangeEventArgs(aStatus, aMessage);
			Events.Raise(EventKey.RequestStatusChange, e);
			if (e.Cancel && (aRequest != null))
			{
				aRequest.Cancel(nsResult.NS_BINDING_ABORTED);
			}
		}

		internal GeckoResponse(nsIRequest request)
		{
			// we use only one wrapper
			_request = Request.WrapRequest( request );
			if ( _request is Channel )
			{
				_channel = ( Channel ) _request;
				if ( _channel is HttpChannel )
				{
					_httpChannel = ( HttpChannel ) _channel;
				}
			}
		}

        public void OnProgressChange(nsIWebProgress webProgress, nsIRequest request, int currentSelfProgress,
		                             int maxSelfProgress,
		                             int currentTotalProgress, int maxTotalProgress)
        {
            if (maxTotalProgress == 0)
                return;

            // if we use the maxTotalProgress, the problem is that it starts off below 100, the jumps to 100 at the end
            // so it looks a lot better to just always scale, to 100, the current progress by the max at that point
            RaiseStatusChanged(new PdfMakingStatus()
                {
                    percentage = (int) (100.0*(currentTotalProgress)/maxTotalProgress),
                    statusLabel = Status
                });
        }

 public void OnStateChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus)
 {
     _finished = (aStateFlags & nsIWebProgressListenerConstants.STATE_STOP) != 0;
 }

 public void OnSecurityChange(nsIWebProgress aWebProgress, nsIRequest aRequest, uint aState)
 {
 }

 public void OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation, uint aFlags)
 {
 }

 public void OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage)
 {
 }

		public void OnProgressChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aCurSelfProgress, int aMaxSelfProgress, int aCurTotalProgress, int aMaxTotalProgress)
		{
		}

 private void OnStatusChange( nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage )
 {
     if (!_isListening) return;
     var evnt = _onStatusChangeCallback;
     if ( evnt != null ) evnt( aMessage );
 }

 void nsIWebProgressListener.OnStatusChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aStatus, string aMessage)
 {
     if (aWebProgress.GetIsLoadingDocument())
     {
         StatusText = aMessage;
         UpdateCommandStatus();
     }
 }

 void nsIWebProgressListener.OnSecurityChange(nsIWebProgress aWebProgress, nsIRequest aRequest, int aState)
 {
     SetSecurityState((GeckoSecurityState) aState);
 }

 void nsIWebProgressListener2.OnLocationChange(nsIWebProgress aWebProgress, nsIRequest aRequest, nsIURI aLocation, uint aFlags)
 {
     OnLocationChange(aWebProgress, aRequest, aLocation, aFlags);
 }

 void nsIWebProgressListener.OnStateChange( nsIWebProgress aWebProgress, nsIRequest aRequest, uint aStateFlags, int aStatus )
 {
     OnStateChange(aWebProgress, aRequest, aStateFlags, aStatus);
 }

 void nsIWebProgressListener.OnSecurityChange( nsIWebProgress aWebProgress, nsIRequest aRequest, uint aState )
 {
     OnSecurityChange( aWebProgress, aRequest, aState );
 }