Created new SpdyFramerVisitorInterface::OnSynStream(), SpdyFramerVisitorInterface::OnHeaders() and OnSynStream().

Remove SpdyFramerVisitorInterface::OnControl().
Lands server change 31251012, 31269046, 31356969.

Review URL: https://chromiumcodereview.appspot.com/10690066

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@145763 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 74 insertions, 34 deletions

diff --git a/net/tools/flip_server/spdy_interface.cc b/net/tools/flip_server/spdy_interface.cc
index 85e574e..54dc3d6 100644
--- a/net/tools/flip_server/spdy_interface.cc
+++ b/net/tools/flip_server/spdy_interface.cc
@@ -119,13 +119,14 @@ SMInterface* SpdySM::FindOrMakeNewSMConnectionInterface(
 }
 
 int SpdySM::SpdyHandleNewStream(
-    const SpdySynStreamControlFrame* syn_stream,
+    SpdyStreamId stream_id,
+    SpdyPriority priority,
     const linked_ptr<SpdyHeaderBlock>& headers,
     std::string &http_data,
     bool* is_https_scheme) {
   *is_https_scheme = false;
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSyn("
-          << syn_stream->stream_id() << ")";
+          << stream_id << ")";
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: # headers: "
           << headers->size();
 
@@ -156,9 +157,7 @@ int SpdySM::SpdyHandleNewStream(
     VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second
             << " " << uri;
     std::string filename = EncodeURL(uri, host, method->second);
-    NewStream(syn_stream->stream_id(),
-              syn_stream->priority(),
-              filename);
+    NewStream(stream_id, priority, filename);
   } else {
     SpdyHeaderBlock::iterator version = headers->find("version");
     http_data += method->second + " " + uri + " " + version->second + "\r\n";
@@ -199,11 +198,16 @@ void SpdySM::OnStreamFrameData(SpdyStreamId stream_id,
     interface->ProcessWriteInput(data, len);
 }
 
-void SpdySM::OnSynStream(const SpdySynStreamControlFrame& syn_stream,
+void SpdySM::OnSynStream(SpdyStreamId stream_id,
+                         SpdyStreamId associated_stream_id,
+                         SpdyPriority priority,
+                         uint8 credential_slot,
+                         bool fin,
+                         bool unidirectional,
                          const linked_ptr<SpdyHeaderBlock>& headers) {
   std::string http_data;
   bool is_https_scheme;
-  int ret = SpdyHandleNewStream(&syn_stream, headers, http_data,
+  int ret = SpdyHandleNewStream(stream_id, priority, headers, http_data,
                                 &is_https_scheme);
   if (!ret) {
     LOG(ERROR) << "SpdySM: Could not convert spdy into http.";
@@ -225,31 +229,34 @@ void SpdySM::OnSynStream(const SpdySynStreamControlFrame& syn_stream,
     }
     SMInterface* sm_http_interface =
         FindOrMakeNewSMConnectionInterface(server_ip, server_port);
-    stream_to_smif_[syn_stream.stream_id()] = sm_http_interface;
-    sm_http_interface->SetStreamID(syn_stream.stream_id());
+    stream_to_smif_[stream_id] = sm_http_interface;
+    sm_http_interface->SetStreamID(stream_id);
     sm_http_interface->ProcessWriteInput(http_data.c_str(),
                                          http_data.size());
   }
 }
 
-void SpdySM::OnSynReply(const SpdySynReplyControlFrame& frame,
+void SpdySM::OnSynReply(SpdyStreamId stream_id,
+                        bool fin,
                         const linked_ptr<SpdyHeaderBlock>& headers) {
   // TODO(willchan): if there is an error parsing headers, we
   // should send a RST_STREAM.
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSynReply("
-          << frame.stream_id() << ")";
+          << stream_id << ")";
 }
 
-void SpdySM::OnHeaders(const SpdyHeadersControlFrame& frame,
+void SpdySM::OnHeaders(SpdyStreamId stream_id,
+                       bool fin,
                        const linked_ptr<SpdyHeaderBlock>& headers) {
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnHeaders("
-          << frame.stream_id() << ")";
+          << stream_id << ")";
 }
 
-void SpdySM::OnRstStream(const SpdyRstStreamControlFrame& frame) {
+void SpdySM::OnRstStream(SpdyStreamId stream_id,
+                         SpdyStatusCodes status) {
   VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnRstStream("
-          << frame.stream_id() << ")";
-  client_output_ordering_.RemoveStreamId(frame.stream_id());
+          << stream_id << ")";
+  client_output_ordering_.RemoveStreamId(stream_id);
 }
 
 size_t SpdySM::ProcessReadInput(const char* data, size_t len) {
diff --git a/net/tools/flip_server/spdy_interface.h b/net/tools/flip_server/spdy_interface.h
index 06f3c18..528227e 100644
--- a/net/tools/flip_server/spdy_interface.h
+++ b/net/tools/flip_server/spdy_interface.h
@@ -50,7 +50,8 @@ class SpdySM : public BufferedSpdyFramerVisitorInterface,
   SMInterface* NewConnectionInterface();
   SMInterface* FindOrMakeNewSMConnectionInterface(std::string server_ip,
                                                   std::string server_port);
-  int SpdyHandleNewStream(const SpdySynStreamControlFrame* frame,
+  int SpdyHandleNewStream(SpdyStreamId stream_id,
+                          SpdyPriority priority,
                           const linked_ptr<SpdyHeaderBlock>& headers,
                           std::string& http_data,
                           bool* is_https_scheme);
@@ -59,29 +60,61 @@ class SpdySM : public BufferedSpdyFramerVisitorInterface,
   virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {}
   virtual void OnStreamError(SpdyStreamId stream_id,
                              const std::string& description) OVERRIDE {}
-  virtual void OnRstStream(
-      const SpdyRstStreamControlFrame& frame) OVERRIDE;
-  virtual void OnGoAway(const SpdyGoAwayControlFrame& frame) OVERRIDE {}
-  virtual void OnPing(const SpdyPingControlFrame& frame) OVERRIDE {}
-  virtual void OnWindowUpdate(
-      const SpdyWindowUpdateControlFrame& frame) OVERRIDE {}
+  // Called after all the header data for SYN_STREAM control frame is received.
+  virtual void OnSynStream(SpdyStreamId stream_id,
+                           SpdyStreamId associated_stream_id,
+                           SpdyPriority priority,
+                           uint8 credential_slot,
+                           bool fin,
+                           bool unidirectional,
+                           const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
+
+  // Called after all the header data for SYN_REPLY control frame is received.
+  virtual void OnSynReply(SpdyStreamId stream_id,
+                          bool fin,
+                          const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
+
+  // Called after all the header data for HEADERS control frame is received.
+  virtual void OnHeaders(SpdyStreamId stream_id,
+                         bool fin,
+                         const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
+
+  // Called when data is received.
+  // |stream_id| The stream receiving data.
+  // |data| A buffer containing the data received.
+  // |len| The length of the data buffer.
+  // When the other side has finished sending data on this stream,
+  // this method will be called with a zero-length buffer.
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len) OVERRIDE;
+
+  // Called when an individual setting within a SETTINGS frame has been parsed
+  // and validated.
+  virtual void OnSetting(SpdySettingsIds id,
+                         uint8 flags,
+                         uint32 value) OVERRIDE {};
+
+  // Called when a PING frame has been parsed.
+  virtual void OnPing(uint32 unique_id) OVERRIDE {};
+
+  // Called when a RST_STREAM frame has been parsed.
+  virtual void OnRstStream(SpdyStreamId stream_id,
+                           SpdyStatusCodes status) OVERRIDE;
+
+  // Called when a GOAWAY frame has been parsed.
+  virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                        SpdyGoAwayStatus status) OVERRIDE {};
+
+  // Called when a WINDOW_UPDATE frame has been parsed.
+  virtual void OnWindowUpdate(SpdyStreamId stream_id,
+                              int delta_window_size) OVERRIDE {};
+
+  // Called after a control frame has been compressed to allow the visitor
+  // to record compression statistics.
   virtual void OnControlFrameCompressed(
       const SpdyControlFrame& uncompressed_frame,
       const SpdyControlFrame& compressed_frame) OVERRIDE {};
-  virtual void OnSetting(
-      SpdySettingsIds id, uint8 flags, uint32 value)  OVERRIDE {}
-  virtual void OnSynStream(
-      const SpdySynStreamControlFrame& frame,
-      const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
-  virtual void OnSynReply(
-      const SpdySynReplyControlFrame& frame,
-      const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
-  virtual void OnHeaders(
-      const SpdyHeadersControlFrame& frame,
-      const linked_ptr<SpdyHeaderBlock>& headers) OVERRIDE;
 
  public:
   virtual size_t ProcessReadInput(const char* data, size_t len) OVERRIDE;