SPDY: Add WriteHeaders interface to SpdySession and SpdyStream

net/spdy/spdy_stream.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_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 
 #include <list>
 #include <string>
 #include <vector>
@@ skipping 70 matching lines @@
     virtual void OnClose(int status) = 0;
 
    protected:
     friend class base::RefCounted<Delegate>;
     virtual ~Delegate() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
+  // Indicates pending frame type.
+  enum PendingFrameType {
+    TYPE_HEADER,
+    TYPE_DATA
+  };
+
+  // Structure to contains pending frame information.
+  typedef struct {
+    PendingFrameType type;
+    union {
+      SpdyHeaderBlock* header_block;
+      SpdyDataFrame* data_frame;
+    } data;

[Ryan Hamilton, 2012/08/02 16:32:23]

nit:  you should be able to use an anonymous union here.  (Just leave off the
"data").  This will let you refer to 

  pending_frame.header_block and pending_frame.data_frame

without needing to stick .data in there

[Takashi Toyoshima, 2012/08/03 05:11:12]

Ah, anonymous looks better here.
Thanks!

+  } PendingFrame;
+
   // SpdyStream constructor
   SpdyStream(SpdySession* session,
              bool pushed,
              const BoundNetLog& net_log);
 
   // Set new |delegate|. |delegate| must not be NULL.
   // If it already received SYN_REPLY or data, OnResponseReceived() or
   // OnDataReceived() will be called.
   void SetDelegate(Delegate* delegate);
   Delegate* GetDelegate() { return delegate_; }
@@ skipping 114 matching lines @@
   // TODO(satorux): This is only for testing. We should be able to remove
   // this once crbug.com/113107 is addressed.
   bool body_sent() const { return io_state_ > STATE_SEND_BODY_COMPLETE; }
 
   // Interface for Spdy[Http|WebSocket]Stream to use.
 
   // Sends the request.
   // For non push stream, it will send SYN_STREAM frame.
   int SendRequest(bool has_upload_data);
 
+  // Sends a HEADERS frame. SpdyStream owns |headers| and will release it after
+  // the HEADERS frame is actually sent.
+  int WriteHeaders(SpdyHeaderBlock* headers);
+
   // Sends DATA frame.
   int WriteStreamData(IOBuffer* data, int length,
                       SpdyDataFlags flags);
 
   // Fills SSL info in |ssl_info| and returns true when SSL is in use.
   bool GetSSLInfo(SSLInfo* ssl_info,
                   bool* was_npn_negotiated,
                   NextProto* protocol_negotiated);
 
   // Fills SSL Certificate Request info |cert_request_info| and returns
@@ skipping 103 matching lines @@
   // The request to send.
   scoped_ptr<SpdyHeaderBlock> request_;
 
   // The time at which the request was made that resulted in this response.
   // For cached responses, this time could be "far" in the past.
   base::Time request_time_;
 
   scoped_ptr<SpdyHeaderBlock> response_;
   base::Time response_time_;
 
-  std::list<SpdyFrame*> pending_data_frames_;
+  std::list<PendingFrame> pending_frames_;
 
   State io_state_;
 
   // Since we buffer the response, we also buffer the response status.
   // Not valid until the stream is closed.
   int response_status_;
 
   bool cancelled_;
   bool has_upload_data_;
 
@@ skipping 11 matching lines @@
   std::string domain_bound_private_key_;
   std::string domain_bound_cert_;
   ServerBoundCertService::RequestHandle domain_bound_cert_request_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_