mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
cca184acac
When a connection that involves a pipelined transaction has been stalled (i.e. idle with an open transaction, not an idle persistent connection) for a second move any transactions that are pipelined after the current one onto different connections (and implicitly close this connection when done with the current transaction). when it has been stalled for 10 seconds (pref configurable), cancel the current transaction itself too - depending on its state it can hopefully be restarted on a clean connection.
236 lines
9.4 KiB
C++
236 lines
9.4 KiB
C++
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla 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/MPL/
|
|
*
|
|
* 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.
|
|
*
|
|
* The Original Code is Mozilla.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 2002
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Darin Fisher <darin@netscape.com>
|
|
*
|
|
* 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 MPL, 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 MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#ifndef nsAHttpTransaction_h__
|
|
#define nsAHttpTransaction_h__
|
|
|
|
#include "nsISupports.h"
|
|
#include "nsTArray.h"
|
|
|
|
class nsAHttpConnection;
|
|
class nsAHttpSegmentReader;
|
|
class nsAHttpSegmentWriter;
|
|
class nsIInterfaceRequestor;
|
|
class nsIEventTarget;
|
|
class nsITransport;
|
|
class nsHttpRequestHead;
|
|
class nsHttpPipeline;
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Abstract base class for a HTTP transaction:
|
|
//
|
|
// A transaction is a "sink" for the response data. The connection pushes
|
|
// data to the transaction by writing to it. The transaction supports
|
|
// WriteSegments and may refuse to accept data if its buffers are full (its
|
|
// write function returns NS_BASE_STREAM_WOULD_BLOCK in this case).
|
|
//----------------------------------------------------------------------------
|
|
|
|
class nsAHttpTransaction : public nsISupports
|
|
{
|
|
public:
|
|
// called by the connection when it takes ownership of the transaction.
|
|
virtual void SetConnection(nsAHttpConnection *) = 0;
|
|
|
|
// used to obtain the connection associated with this transaction
|
|
virtual nsAHttpConnection *Connection() = 0;
|
|
|
|
// called by the connection to get security callbacks to set on the
|
|
// socket transport.
|
|
virtual void GetSecurityCallbacks(nsIInterfaceRequestor **,
|
|
nsIEventTarget **) = 0;
|
|
|
|
// called to report socket status (see nsITransportEventSink)
|
|
virtual void OnTransportStatus(nsITransport* transport,
|
|
nsresult status, PRUint64 progress) = 0;
|
|
|
|
// called to check the transaction status.
|
|
virtual bool IsDone() = 0;
|
|
virtual nsresult Status() = 0;
|
|
virtual PRUint8 Caps() = 0;
|
|
|
|
// called to find out how much request data is available for writing.
|
|
virtual PRUint32 Available() = 0;
|
|
|
|
// called to read request data from the transaction.
|
|
virtual nsresult ReadSegments(nsAHttpSegmentReader *reader,
|
|
PRUint32 count, PRUint32 *countRead) = 0;
|
|
|
|
// called to write response data to the transaction.
|
|
virtual nsresult WriteSegments(nsAHttpSegmentWriter *writer,
|
|
PRUint32 count, PRUint32 *countWritten) = 0;
|
|
|
|
// called to close the transaction
|
|
virtual void Close(nsresult reason) = 0;
|
|
|
|
// called to indicate a failure at the SSL setup level
|
|
virtual void SetSSLConnectFailed() = 0;
|
|
|
|
// called to retrieve the request headers of the transaction
|
|
virtual nsHttpRequestHead *RequestHead() = 0;
|
|
|
|
// determine the number of real http/1.x transactions on this
|
|
// abstract object. Pipelines may have multiple, SPDY has 0,
|
|
// normal http transactions have 1.
|
|
virtual PRUint32 Http1xTransactionCount() = 0;
|
|
|
|
// called to remove the unused sub transactions from an object that can
|
|
// handle multiple transactions simultaneously (i.e. pipelines or spdy).
|
|
//
|
|
// Returns NS_ERROR_NOT_IMPLEMENTED if the object does not implement
|
|
// sub-transactions.
|
|
//
|
|
// Returns NS_ERROR_ALREADY_OPENED if the subtransactions have been
|
|
// at least partially written and cannot be moved.
|
|
//
|
|
virtual nsresult TakeSubTransactions(
|
|
nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions) = 0;
|
|
|
|
// called to add a sub-transaction in the case of pipelined transactions
|
|
// classes that do not implement sub transactions
|
|
// return NS_ERROR_NOT_IMPLEMENTED
|
|
virtual nsresult AddTransaction(nsAHttpTransaction *transaction) = 0;
|
|
|
|
// The total length of the outstanding pipeline comprised of transacations
|
|
// and sub-transactions.
|
|
virtual PRUint32 PipelineDepth() = 0;
|
|
|
|
// Used to inform the connection that it is being used in a pipelined
|
|
// context. That may influence the handling of some errors.
|
|
// The value is the pipeline position (> 1).
|
|
virtual nsresult SetPipelinePosition(PRInt32) = 0;
|
|
virtual PRInt32 PipelinePosition() = 0;
|
|
|
|
// If we used rtti this would be the result of doing
|
|
// dynamic_cast<nsHttpPipeline *>(this).. i.e. it can be nsnull for
|
|
// non pipeline implementations of nsAHttpTransaction
|
|
virtual nsHttpPipeline *QueryPipeline() { return nsnull; }
|
|
|
|
// Every transaction is classified into one of the types below. When using
|
|
// HTTP pipelines, only transactions with the same type appear on the same
|
|
// pipeline.
|
|
enum Classifier {
|
|
// Transactions that expect a short 304 (no-content) response
|
|
CLASS_REVALIDATION,
|
|
|
|
// Transactions for content expected to be CSS or JS
|
|
CLASS_SCRIPT,
|
|
|
|
// Transactions for content expected to be an image
|
|
CLASS_IMAGE,
|
|
|
|
// Transactions that cannot involve a pipeline
|
|
CLASS_SOLO,
|
|
|
|
// Transactions that do not fit any of the other categories. HTML
|
|
// is normally GENERAL.
|
|
CLASS_GENERAL,
|
|
|
|
CLASS_MAX
|
|
};
|
|
};
|
|
|
|
#define NS_DECL_NSAHTTPTRANSACTION \
|
|
void SetConnection(nsAHttpConnection *); \
|
|
nsAHttpConnection *Connection(); \
|
|
void GetSecurityCallbacks(nsIInterfaceRequestor **, \
|
|
nsIEventTarget **); \
|
|
void OnTransportStatus(nsITransport* transport, \
|
|
nsresult status, PRUint64 progress); \
|
|
bool IsDone(); \
|
|
nsresult Status(); \
|
|
PRUint8 Caps(); \
|
|
PRUint32 Available(); \
|
|
nsresult ReadSegments(nsAHttpSegmentReader *, PRUint32, PRUint32 *); \
|
|
nsresult WriteSegments(nsAHttpSegmentWriter *, PRUint32, PRUint32 *); \
|
|
void Close(nsresult reason); \
|
|
void SetSSLConnectFailed(); \
|
|
nsHttpRequestHead *RequestHead(); \
|
|
PRUint32 Http1xTransactionCount(); \
|
|
nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions); \
|
|
nsresult AddTransaction(nsAHttpTransaction *); \
|
|
PRUint32 PipelineDepth(); \
|
|
nsresult SetPipelinePosition(PRInt32); \
|
|
PRInt32 PipelinePosition();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// nsAHttpSegmentReader
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class nsAHttpSegmentReader
|
|
{
|
|
public:
|
|
// any returned failure code stops segment iteration
|
|
virtual nsresult OnReadSegment(const char *segment,
|
|
PRUint32 count,
|
|
PRUint32 *countRead) = 0;
|
|
|
|
// Ask the segment reader to commit to accepting size bytes of
|
|
// data from subsequent OnReadSegment() calls or throw hard
|
|
// (i.e. not wouldblock) exceptions. Implementations
|
|
// can return NS_ERROR_FAILURE if they never make commitments of that size
|
|
// (the default), NS_BASE_STREAM_WOULD_BLOCK if they cannot make
|
|
// the commitment now but might in the future, or NS_OK
|
|
// if they make the commitment.
|
|
//
|
|
// Spdy uses this to make sure frames are atomic.
|
|
virtual nsresult CommitToSegmentSize(PRUint32 size)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
};
|
|
|
|
#define NS_DECL_NSAHTTPSEGMENTREADER \
|
|
nsresult OnReadSegment(const char *, PRUint32, PRUint32 *);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// nsAHttpSegmentWriter
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class nsAHttpSegmentWriter
|
|
{
|
|
public:
|
|
// any returned failure code stops segment iteration
|
|
virtual nsresult OnWriteSegment(char *segment,
|
|
PRUint32 count,
|
|
PRUint32 *countWritten) = 0;
|
|
};
|
|
|
|
#define NS_DECL_NSAHTTPSEGMENTWRITER \
|
|
nsresult OnWriteSegment(char *, PRUint32, PRUint32 *);
|
|
|
|
#endif // nsAHttpTransaction_h__
|