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 140 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 56 matching lines @@
     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_;
 
+  // Set of all created streams that have not yet been activated.

[willchan no longer on Chromium, 2012/06/07 23:02:06]

This comment makes no sense without context of what "activation" means. Please
write more so someone unfamiliar with the code can understand.

[Ryan Hamilton, 2012/06/08 00:02:26]

Done.

+  CreatedStreamSet created_streams_;
+
   // As we gather data to be sent, we put it into the output queue.
   OutputQueue queue_;

[willchan no longer on Chromium, 2012/06/07 23:02:06]

Can this die?

[Ryan Hamilton, 2012/06/08 00:02:26]

Indeed!  Done.

 
+  // 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 142 matching lines @@
  private:
   const int status_;
   const std::string description_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdySessionCloseParameter);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_