Lines Matching full:stream
119 // A helper class used to manage a request to create a stream.
126 // Starts the request to create a stream. If OK is returned, then
128 // then when the stream is created, |callback| will be called, at
129 // which point ReleaseStream() may be called. Otherwise, the stream
145 // Cancels any pending stream creation request. May be called
149 // Transfers the created stream (guaranteed to not be NULL) to the
152 // set a delegate for the returned stream (except for test code).
158 // Called by |session_| when the stream attempt has finished
160 void OnRequestCompleteSuccess(base::WeakPtr<SpdyStream>* stream);
162 // Called by |session_| when the stream attempt has finished with an
164 // while the stream attempt is still pending.
231 // Get a pushed stream for a given |url|. If the server initiates a
232 // stream, it might already exist for a given path. The server
233 // might also not have initiated the stream yet, but indicated it
234 // will via X-Associated-Content. Returns OK if a stream was found
236 // okay to create a new stream (in which case |spdy_stream| is
283 // |stream|. |stream| is guaranteed to be activated before the
285 void EnqueueStreamWrite(const base::WeakPtr<SpdyStream>& stream,
313 // Close the stream with the given ID, which must exist and be
314 // active. Note that that stream may hold the last reference to the
318 // Close the given created stream, which must exist but not yet be
319 // active. Note that |stream| may hold the last reference to the
321 void CloseCreatedStream(const base::WeakPtr<SpdyStream>& stream, int status);
324 // stream with the given ID, which must exist and be active. Note
325 // that that stream may hold the last reference to the session.
330 // Check if a stream is active.
350 // Send a WINDOW_UPDATE frame for a stream. Called by a stream
355 // Whether the stream is closed, i.e. it has stopped processing data
388 // stream. If it's not the first stream, the connection is considered reused
389 // for that stream.
393 // stream using the session. IsReused(), on the other hand, indicates if the
431 // Returns true if no stream in the session can send data due to
509 explicit ActiveStreamInfo(SpdyStream* stream);
512 SpdyStream* stream;
565 // Checks whether a stream for the given |url| can be created or
572 // stream. If OK is returned, then |stream| will be filled in with a
573 // valid stream. If ERR_IO_PENDING is returned, then
575 // when the stream is created (unless it is cancelled). Otherwise,
576 // no stream is created and the error is returned.
578 base::WeakPtr<SpdyStream>* stream);
580 // Actually create a stream into |stream|. Returns OK if successful;
581 // otherwise, returns an error and |stream| is not filled.
583 base::WeakPtr<SpdyStream>* stream);
585 // Called by SpdyStreamRequest to remove |request| from the stream
589 // Called when there is room to create more streams (e.g., a stream
590 // was closed). Processes as many pending stream requests as
594 // Close the stream pointed to by the given iterator. Note that that
595 // stream may hold the last reference to the session.
598 // Close the stream pointed to by the given iterator. Note that that
599 // stream may hold the last reference to the session.
609 // either be no active stream with the given ID, or that active
610 // stream should be closed shortly after this function is called.
690 // Get a new stream id.
699 // Puts |producer| associated with |stream| onto the write queue
704 const base::WeakPtr<SpdyStream>& stream);
706 // Inserts a newly-created stream into |created_streams_|.
707 void InsertCreatedStream(scoped_ptr<SpdyStream> stream);
709 // Activates |stream| (which must be in |created_streams_|) by
711 scoped_ptr<SpdyStream> ActivateCreatedStream(SpdyStream* stream);
713 // Inserts a newly-activated stream into |active_streams_|.
714 void InsertActivatedStream(scoped_ptr<SpdyStream> stream);
716 // Remove all internal references to |stream|, call OnClose() on it,
717 // and process any pending stream requests before deleting it. Note
718 // that |stream| may hold the last reference to the session.
719 void DeleteStream(scoped_ptr<SpdyStream> stream, int status);
721 // Check if we have a pending pushed-stream for this url
722 // Returns the stream if found (and returns it from the pending
726 // Delegates to |stream->OnInitialResponseHeadersReceived()|. If an
732 SpdyStream* stream);
739 // there are no pending stream creation requests, and that there are
749 // Closes all active streams with stream id's greater than
761 // If the stream is already closed, does nothing. Otherwise, moves
775 // Called right before closing a (possibly-inactive) stream for a
776 // reason other than being requested to by the stream.
777 void LogAbandonedStream(SpdyStream* stream, Error status);
779 // Called right before closing an active stream for a reason other
780 // than being requested to by the stream.
784 // Invokes a user callback for stream creation. We provide this method so it
858 // (which is in turn called by a stream) to decrease this session's
891 // Queue a send-stalled stream for possibly resuming once we're not
893 void QueueSendStalledStream(const SpdyStream& stream);
899 // Returns the next stream to possibly resume, or 0 if the queue is
957 int stream_hi_water_mark_; // The next stream id to use.
959 // Queue, for each priority, of pending stream requests that have
964 // stream to actually be created). This is necessary since we kick
965 // off the stream creation asynchronously, and so the request may be
966 // cancelled before the asynchronous task to create the stream runs.
969 // Map from stream id to all active streams. Streams are active in the sense
972 // the server to start pushing the stream]) or there are still network events
1003 // The stream to notify when |in_flight_write_| has been written to
1090 // A queue of stream IDs that have been send-stalled at some point
