Fix out of order SYN_STEAM frames.

net/spdy/spdy_session.h

 // Copyright (c) 2012 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_
 #pragma once
 
 #include <algorithm>
 #include <list>
@@ skipping 78 matching lines @@
                SpdyProtocolErrorDetails_SpdyErrors_mismatch);
 
 COMPILE_ASSERT(PROTOCOL_ERROR_UNEXPECTED_PING ==
                static_cast<SpdyProtocolErrorDetails>(NUM_STATUS_CODES +
                                                      STATUS_CODE_INVALID),
                SpdyProtocolErrorDetails_SpdyErrors_mismatch);
 
 class NET_EXPORT SpdySession : public base::RefCounted<SpdySession>,
                                public BufferedSpdyFramerVisitorInterface {
  public:
+// Defines an interface for producing SPDY frames.
+class NET_EXPORT_PRIVATE SpdyFrameProducer {

[willchan no longer on Chromium, 2012/06/21 23:51:03]

Indentation

[Ryan Hamilton, 2012/06/22 16:17:32]

Done.

+ public:
+  SpdyFrameProducer() {}
+
+  // Returns a newly created SpdyFrame, owned by the called.
+  virtual SpdyFrame* ProduceNextFrame(SpdySession* session) = 0;
+
+  // Returns the priority of frames produced by this producer.
+  virtual RequestPriority GetPriority() const = 0;
+
+  // Returns a pointer to the underlying SpdyStream, or NULL if none exits.
+  virtual SpdyStream* GetSpdyStream() = 0;

[willchan no longer on Chromium, 2012/06/21 23:51:03]

Do you still need this one?

[Ryan Hamilton, 2012/06/22 16:17:32]

It is still used because when we decide that we need to close a stream, we
remove the corresponding SpdyFrameProducer from the the write_queue.  To do this
we look at the SpdyStream associated with each Producer.  If you would prefer,
however, I could remove this method and add a IsAssociateWith(SpdyStream*)
method, or some such?

[willchan no longer on Chromium, 2012/06/22 21:10:44]

I see. I think I'd rather keep it out of this interface and have the SpdySession
maintain the mapping of streams to SpdyFrameProducers, so it can delete those
SpdyFrameProducers when the stream is canceled.

+
+  virtual ~SpdyFrameProducer() {}
+
+  // Activates |spdy_stream| in |spdy_session|.
+  void ActivateStream(SpdySession* spdy_session, SpdyStream* spdy_stream);

[willchan no longer on Chromium, 2012/06/21 23:51:03]

Can this be static?

[Ryan Hamilton, 2012/06/22 16:17:32]

Done.

+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SpdyFrameProducer);
+};
+
   // Create a new SpdySession.
   // |host_port_proxy_pair| is the host/port that this session connects to, and
   // the proxy configuration settings that it's using.
   // |spdy_session_pool| is the SpdySessionPool that owns us.  Its lifetime must
   // strictly be greater than |this|.
   // |session| is the HttpNetworkSession.  |net_log| is the NetLog that we log
   // network events to.
   SpdySession(const HostPortProxyPair& host_port_proxy_pair,
               SpdySessionPool* spdy_session_pool,
               HttpServerProperties* http_server_properties,
@@ skipping 42 matching lines @@
   // If the session is un-authenticated, then this call always returns true.
   // For SSL-based sessions, verifies that the server certificate in use by
   // this session provides authentication for the domain and no client
   // certificate was sent to the original server during the SSL handshake.
   // NOTE:  This function can have false negatives on some platforms.
   // TODO(wtc): rename this function and the Net.SpdyIPPoolDomainMatch
   // histogram because this function does more than verifying domain
   // authentication now.
   bool VerifyDomainAuthentication(const std::string& domain);
 
+  // Records that |stream| has a write available.
+  void SetStreamHasWriteAvailable(SpdyStream* stream);
+
   // Send the SYN frame for |stream_id|. This also sends PING message to check
   // the status of the connection.
-  int WriteSynStream(
+  SpdySynStreamControlFrame* CreateSynStream(
       SpdyStreamId stream_id,
       RequestPriority priority,
       uint8 credential_slot,
       SpdyControlFlags flags,
       const linked_ptr<SpdyHeaderBlock>& headers);
 
   // Write a CREDENTIAL frame to the session.
-  int WriteCredentialFrame(const std::string& origin,
-                           SSLClientCertType type,
-                           const std::string& key,
-                           const std::string& cert,
-                           RequestPriority priority);
+  SpdyCredentialControlFrame* CreateCredentialFrame(const std::string& origin,
+                                                    SSLClientCertType type,
+                                                    const std::string& key,
+                                                    const std::string& cert,
+                                                    RequestPriority priority);
 
   // Write a data frame to the stream.
   // Used to create and queue a data frame for the given stream.
-  int WriteStreamData(SpdyStreamId stream_id, net::IOBuffer* data,
-                      int len,
-                      SpdyDataFlags flags);
+  SpdyDataFrame* CreateDataFrame(SpdyStreamId stream_id,
+                                 net::IOBuffer* data, int len,
+                                 SpdyDataFlags flags);
 
   // Close a stream.
   void CloseStream(SpdyStreamId stream_id, int status);
 
+  // Close a stream that has been created but is not yet active.
+  void CloseCreatedStream(SpdyStream* stream, int status);
+
   // Reset a stream by sending a RST_STREAM frame with given status code.
   // Also closes the stream.  Was not piggybacked to CloseStream since not
   // all of the calls to CloseStream necessitate sending a RST_STREAM.
   void ResetStream(SpdyStreamId stream_id,
                    SpdyStatusCodes status,
                    const std::string& description);
 
   // Check if a stream is active.
   bool IsStreamActive(SpdyStreamId stream_id) const;
 
@@ skipping 67 matching lines @@
   bool WasEverUsed() const {
     return connection_->socket()->WasEverUsed();
   }
 
   void set_spdy_session_pool(SpdySessionPool* pool) {
     spdy_session_pool_ = NULL;
   }
 
   // Returns true if session is not currently active
   bool is_active() const {
-    return !active_streams_.empty();
+    return !active_streams_.empty() || !created_streams_.empty();
   }
 
   // Access to the number of active and pending streams.  These are primarily
   // available for testing and diagnostics.
   size_t num_active_streams() const { return active_streams_.size(); }
   size_t num_unclaimed_pushed_streams() const {
       return unclaimed_pushed_streams_.size();
   }
+  size_t num_created_streams() const { return created_streams_.size(); }
 
   // Returns true if flow control is enabled for the session.
   bool is_flow_control_enabled() const {
     return flow_control_;
   }
 
   // Returns the current |initial_send_window_size_|.
   int32 initial_send_window_size() const {
     return initial_send_window_size_;
   }
@@ skipping 55 matching lines @@
     RequestPriority priority;
     scoped_refptr<SpdyStream>* spdy_stream;
     const BoundNetLog* stream_net_log;
     CompletionCallback callback;
   };
   typedef std::queue<PendingCreateStream, std::list< PendingCreateStream> >
       PendingCreateStreamQueue;
   typedef std::map<int, scoped_refptr<SpdyStream> > ActiveStreamMap;
   // Only HTTP push a stream.
   typedef std::map<std::string, scoped_refptr<SpdyStream> > PushedStreamMap;
-  typedef std::priority_queue<SpdyIOBuffer> OutputQueue;
+  typedef std::set<scoped_refptr<SpdyStream> > CreatedStreamSet;
+  class SpdyFrameProducerCompare {
+   public:
+    bool operator() (const SpdyFrameProducer* lhs,
+                     const SpdyFrameProducer* rhs) const {
+      return lhs->GetPriority() < rhs->GetPriority();
+    }
+  };
+  typedef std::priority_queue<SpdyFrameProducer*,
+                              std::vector<SpdyFrameProducer*>,
+                              SpdyFrameProducerCompare> WriteQueue;
 
   struct CallbackResultPair {
     CallbackResultPair(const CompletionCallback& callback_in, int result_in)
         : callback(callback_in), result(result_in) {}
     ~CallbackResultPair();
 
     CompletionCallback callback;
     int result;
   };
 
@@ skipping 54 matching lines @@
   // Write current data to the socket.
   void WriteSocketLater();
   void WriteSocket();
 
   // Get a new stream id.
   int GetNewStreamId();
 
   // Queue a frame for sending.
   // |frame| is the frame to send.
   // |priority| is the priority for insertion into the queue.
-  // |stream| is the stream which this IO is associated with (or NULL).
-  void QueueFrame(SpdyFrame* frame, RequestPriority priority,
-                  SpdyStream* stream);
+  void QueueFrame(SpdyFrame* frame, RequestPriority priority);
 
   // Track active streams in the active stream list.
   void ActivateStream(SpdyStream* stream);
   void DeleteStream(SpdyStreamId id, int status);
 
   // Removes this session from the session pool.
   void RemoveFromPool();
 
   // Check if we have a pending pushed-stream for this url
   // Returns the stream if found (and returns it from the pending
@@ skipping 106 matching lines @@
   // 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_;
   // Map of all the streams that have already started to be pushed by the
   // server, but do not have consumers yet.
   PushedStreamMap unclaimed_pushed_streams_;
 
-  // As we gather data to be sent, we put it into the output queue.
-  OutputQueue queue_;
+  // Set of all created streams but that have not yet sent any frames.
+  CreatedStreamSet created_streams_;
+
+  // As streams have data to be sent, we put them into the write queue.
+  WriteQueue write_queue_;
 
   // The packet we are currently sending.
   bool write_pending_;            // Will be true when a write is in progress.
   SpdyIOBuffer 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 SpdySession.
   bool is_secure_;
@@ skipping 143 matching lines @@
  private:
   const int status_;
   const std::string description_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdySessionCloseParameter);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_