From dab9c7d4a7c5d4c5157043ee4db2d792b8a2f3b6 Mon Sep 17 00:00:00 2001 From: "mbelshe@chromium.org" Date: Sat, 6 Feb 2010 21:44:32 +0000 Subject: Rename all files from flip* to spdy*. I haven't yet renamed the classes. BUG=30747 TEST=none Review URL: http://codereview.chromium.org/582001 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@38315 0039d316-1c4b-4281-b951-d872f2087c98 --- net/spdy/spdy_session.h | 237 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 net/spdy/spdy_session.h (limited to 'net/spdy/spdy_session.h') diff --git a/net/spdy/spdy_session.h b/net/spdy/spdy_session.h new file mode 100644 index 0000000..e91753d --- /dev/null +++ b/net/spdy/spdy_session.h @@ -0,0 +1,237 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef NET_SPDY_SPDY_SESSION_H_ +#define NET_SPDY_SPDY_SESSION_H_ + +#include +#include +#include +#include +#include + +#include "base/ref_counted.h" +#include "net/base/io_buffer.h" +#include "net/base/load_states.h" +#include "net/base/net_errors.h" +#include "net/base/request_priority.h" +#include "net/base/ssl_config_service.h" +#include "net/base/upload_data_stream.h" +#include "net/socket/client_socket.h" +#include "net/socket/client_socket_handle.h" +#include "testing/platform_test.h" +#include "net/spdy/spdy_framer.h" +#include "net/spdy/spdy_io_buffer.h" +#include "net/spdy/spdy_protocol.h" +#include "net/spdy/spdy_session_pool.h" + +namespace net { + +class FlipStream; +class HttpNetworkSession; +class HttpRequestInfo; +class HttpResponseInfo; +class LoadLog; +class SSLInfo; + +class FlipSession : public base::RefCounted, + public flip::FlipFramerVisitorInterface { + public: + // Get the domain for this FlipSession. + const std::string& domain() const { return domain_; } + + // Connect the FLIP Socket. + // Returns net::Error::OK on success. + // Note that this call does not wait for the connect to complete. Callers can + // immediately start using the FlipSession while it connects. + net::Error Connect(const std::string& group_name, + const HostResolver::RequestInfo& host, + RequestPriority priority, + LoadLog* load_log); + + // Get a stream for a given |request|. In the typical case, this will involve + // the creation of a new stream (and will send the SYN frame). If the server + // initiates a stream, it might already exist for a given path. The server + // might also not have initiated the stream yet, but indicated it will via + // X-Associated-Content. + // Returns the new or existing stream. Never returns NULL. + scoped_refptr GetOrCreateStream(const HttpRequestInfo& request, + const UploadDataStream* upload_data, LoadLog* log); + + // Write a data frame to the stream. + // Used to create and queue a data frame for the given stream. + int WriteStreamData(flip::FlipStreamId stream_id, net::IOBuffer* data, + int len); + + // Cancel a stream. + bool CancelStream(flip::FlipStreamId stream_id); + + // Check if a stream is active. + bool IsStreamActive(flip::FlipStreamId stream_id) const; + + // The LoadState is used for informing the user of the current network + // status, such as "resolving host", "connecting", etc. + LoadState GetLoadState() const; + + // Enable or disable SSL. + static void SetSSLMode(bool enable) { use_ssl_ = enable; } + static bool SSLMode() { return use_ssl_; } + + protected: + friend class FlipSessionPool; + + enum State { + IDLE, + CONNECTING, + CONNECTED, + CLOSED + }; + + // Provide access to the framer for testing. + flip::FlipFramer* GetFramer() { return &flip_framer_; } + + // Create a new FlipSession. + // |host| is the hostname that this session connects to. + FlipSession(const std::string& host, HttpNetworkSession* session); + + // Closes all open streams. Used as part of shutdown. + void CloseAllStreams(net::Error code); + + private: + friend class base::RefCounted; + + typedef std::map > ActiveStreamMap; + typedef std::list > ActiveStreamList; + typedef std::map > PendingStreamMap; + typedef std::priority_queue OutputQueue; + + virtual ~FlipSession(); + + // Used by FlipSessionPool to initialize with a pre-existing socket. + void InitializeWithSocket(ClientSocketHandle* connection); + + // FlipFramerVisitorInterface + virtual void OnError(flip::FlipFramer*); + virtual void OnStreamFrameData(flip::FlipStreamId stream_id, + const char* data, + size_t len); + virtual void OnControl(const flip::FlipControlFrame* frame); + + // Control frame handlers. + void OnSyn(const flip::FlipSynStreamControlFrame* frame, + const flip::FlipHeaderBlock* headers); + void OnSynReply(const flip::FlipSynReplyControlFrame* frame, + const flip::FlipHeaderBlock* headers); + void OnFin(const flip::FlipFinStreamControlFrame* frame); + + // IO Callbacks + void OnTCPConnect(int result); + void OnSSLConnect(int result); + void OnReadComplete(int result); + void OnWriteComplete(int result); + + // Start reading from the socket. + void ReadSocket(); + + // Write current data to the socket. + void WriteSocketLater(); + void WriteSocket(); + + // Get a new stream id. + int GetNewStreamId(); + + // Closes this session. This will close all active streams and mark + // the session as permanently closed. + // |err| should not be OK; this function is intended to be called on + // error. + void CloseSessionOnError(net::Error err); + + // Track active streams in the active stream list. + void ActivateStream(FlipStream* stream); + void DeactivateStream(flip::FlipStreamId id); + + // Check if we have a pending pushed-stream for this url + // Returns the stream if found (and returns it from the pending + // list), returns NULL otherwise. + scoped_refptr GetPushStream(const std::string& url); + + void GetSSLInfo(SSLInfo* ssl_info); + + // Callbacks for the Flip session. + CompletionCallbackImpl connect_callback_; + CompletionCallbackImpl ssl_connect_callback_; + CompletionCallbackImpl read_callback_; + CompletionCallbackImpl write_callback_; + + // The domain this session is connected to. + std::string domain_; + + SSLConfig ssl_config_; + + scoped_refptr session_; + + // The socket handle for this session. + scoped_ptr connection_; + + // The read buffer used to read data from the socket. + scoped_refptr read_buffer_; + bool read_pending_; + + int stream_hi_water_mark_; // The next stream id to use. + + // TODO(mbelshe): We need to track these stream lists better. + // I suspect it is possible to remove a stream from + // one list, but not the other. + + // Map from stream id to all active streams. Streams are active in the sense + // that they have a consumer (typically FlipNetworkTransaction and regardless + // of whether or not there is currently any ongoing IO [might be waiting for + // the server to start pushing the stream]) or there are still network events + // incoming even though the consumer has already gone away (cancellation). + // TODO(willchan): Perhaps we should separate out cancelled streams and move + // them into a separate ActiveStreamMap, and not deliver network events to + // them? + ActiveStreamMap active_streams_; + // List of all the streams that have already started to be pushed by the + // server, but do not have consumers yet. + ActiveStreamList pushed_streams_; + // List of streams declared in X-Associated-Content headers, but do not have + // consumers yet. + // The key is a string representing the path of the URI being pushed. + PendingStreamMap pending_streams_; + + // As we gather data to be sent, we put it into the output queue. + OutputQueue queue_; + + // The packet we are currently sending. + bool write_pending_; // Will be true when a write is in progress. + FlipIOBuffer in_flight_write_; // This is the write buffer in progress. + + // Flag if we have a pending message scheduled for WriteSocket. + bool delayed_write_pending_; + + // Flag if we're using an SSL connection for this FlipSession. + bool is_secure_; + + // Flip Frame state. + flip::FlipFramer flip_framer_; + + // If an error has occurred on the session, the session is effectively + // dead. Record this error here. When no error has occurred, |error_| will + // be OK. + net::Error error_; + State state_; + + // Some statistics counters for the session. + int streams_initiated_count_; + int streams_pushed_count_; + int streams_pushed_and_claimed_count_; + int streams_abandoned_count_; + + static bool use_ssl_; +}; + +} // namespace net + +#endif // NET_SPDY_SPDY_SESSION_H_ -- cgit v1.1