Refactor BufferedSpdyFramer so that SpdySession is not a visitor of

net/spdy/spdy_session.cc

 // 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.
 
 #include "net/spdy/spdy_session.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
@@ skipping 277 matching lines @@
       delayed_write_pending_(false),
       is_secure_(false),
       certificate_error_code_(OK),
       error_(OK),
       state_(IDLE),
       max_concurrent_streams_(init_max_concurrent_streams_),
       streams_initiated_count_(0),
       streams_pushed_count_(0),
       streams_pushed_and_claimed_count_(0),
       streams_abandoned_count_(0),
-      frames_received_(0),
       bytes_received_(0),
       sent_settings_(false),
       received_settings_(false),
       stalled_streams_(0),
       pings_in_flight_(0),
       next_ping_id_(1),
       received_data_time_(base::TimeTicks::Now()),
       trailing_ping_pending_(false),
       check_ping_status_pending_(false),
       need_to_send_ping_(false),
@@ skipping 789 matching lines @@
   dict->SetBoolean("is_secure", is_secure_);
 
   dict->SetInteger("error", error_);
   dict->SetInteger("max_concurrent_streams", max_concurrent_streams_);
 
   dict->SetInteger("streams_initiated_count", streams_initiated_count_);
   dict->SetInteger("streams_pushed_count", streams_pushed_count_);
   dict->SetInteger("streams_pushed_and_claimed_count",
       streams_pushed_and_claimed_count_);
   dict->SetInteger("streams_abandoned_count", streams_abandoned_count_);
-  dict->SetInteger("frames_received", frames_received_);
+  dict->SetInteger("frames_received", buffered_spdy_framer_.frames_received());
 
   dict->SetBoolean("sent_settings", sent_settings_);
   dict->SetBoolean("received_settings", received_settings_);
   return dict;
 }
 
 int SpdySession::GetPeerAddress(AddressList* address) const {
   if (!connection_->socket())
     return ERR_SOCKET_NOT_CONNECTED;
 
@@ skipping 104 matching lines @@
 
 SSLClientCertType SpdySession::GetOriginBoundCertType() const {
   if (!is_secure_) {
     return CLIENT_CERT_INVALID_TYPE;
   }
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   return ssl_socket->origin_bound_cert_type();
 }
 
-void SpdySession::OnError(spdy::SpdyFramer* framer) {
+void SpdySession::OnError() {
   CloseSessionOnError(net::ERR_SPDY_PROTOCOL_ERROR, true);
 }
 
+void SpdySession::OnStreamError(spdy::SpdyStreamId stream_id) {
+  if (IsStreamActive(stream_id))
+    ResetStream(stream_id, spdy::PROTOCOL_ERROR, "");
+}
+
 void SpdySession::OnStreamFrameData(spdy::SpdyStreamId stream_id,
                                     const char* data,
                                     size_t len) {
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_RECV_DATA,
         make_scoped_refptr(new NetLogSpdyDataParameter(
             stream_id, len, spdy::SpdyDataFlags())));
   }
 
@@ skipping 13 matching lines @@
   rv = stream->OnResponseReceived(headers);
   if (rv < 0) {
     DCHECK_NE(rv, ERR_IO_PENDING);
     const spdy::SpdyStreamId stream_id = stream->stream_id();
     DeleteStream(stream_id, rv);
     return false;
   }
   return true;
 }
 
-void SpdySession::OnSyn(const spdy::SpdySynStreamControlFrame& frame,
-                        const linked_ptr<spdy::SpdyHeaderBlock>& headers) {
+void SpdySession::OnSynStream(
+    const spdy::SpdySynStreamControlFrame& frame,
+    const linked_ptr<spdy::SpdyHeaderBlock>& headers) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
   spdy::SpdyStreamId associated_stream_id = frame.associated_stream_id();
 
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_SPDY_SESSION_PUSHED_SYN_STREAM,
         make_scoped_refptr(new NetLogSpdySynParameter(
             headers, static_cast<spdy::SpdyControlFlags>(frame.flags()),
             stream_id, associated_stream_id)));
   }
@@ skipping 149 matching lines @@
   }
 
   int rv = stream->OnHeaders(*headers);
   if (rv < 0) {
     DCHECK_NE(rv, ERR_IO_PENDING);
     const spdy::SpdyStreamId stream_id = stream->stream_id();
     DeleteStream(stream_id, rv);
   }
 }
 
-void SpdySession::OnControl(const spdy::SpdyControlFrame* frame) {
-  uint32 type = frame->type();
-  if (type == spdy::SYN_STREAM ||
-      type == spdy::SYN_REPLY ||
-      type == spdy::HEADERS) {
-    buffered_spdy_framer_.OnControl(frame);
-    return;
-  }
-
-  frames_received_++;
-
-  switch (type) {
-    case spdy::GOAWAY:
-      OnGoAway(*reinterpret_cast<const spdy::SpdyGoAwayControlFrame*>(frame));
-      break;
-    case spdy::PING:
-      OnPing(*reinterpret_cast<const spdy::SpdyPingControlFrame*>(frame));
-      break;
-    case spdy::SETTINGS:
-      OnSettings(
-          *reinterpret_cast<const spdy::SpdySettingsControlFrame*>(frame));
-      break;
-    case spdy::RST_STREAM:
-      OnRst(*reinterpret_cast<const spdy::SpdyRstStreamControlFrame*>(frame));
-      break;
-    case spdy::WINDOW_UPDATE:
-      OnWindowUpdate(
-          *reinterpret_cast<const spdy::SpdyWindowUpdateControlFrame*>(frame));
-      break;
-    default:
-      DCHECK(false);  // Error!
-  }
-}
-
-bool SpdySession::OnControlFrameHeaderData(spdy::SpdyStreamId stream_id,
-                                           const char* header_data,
-                                           size_t len) {
-  if (!buffered_spdy_framer_.OnControlFrameHeaderData(
-          stream_id, header_data, len)) {
-    if (IsStreamActive(stream_id))
-      ResetStream(stream_id, spdy::PROTOCOL_ERROR, "");
-    return false;
-  }
-  if (len == 0) {
-    // Indicates end-of-header-block.
-    frames_received_++;
-  }
-  return true;
-}
-
-bool SpdySession::OnCredentialFrameData(const char* frame_data,
-                                        size_t len) {
-  DCHECK(false);
-  return false;
-}
-
-void SpdySession::OnDataFrameHeader(const spdy::SpdyDataFrame* frame) {
-  buffered_spdy_framer_.OnDataFrameHeader(frame);
-}
-
-void SpdySession::OnRst(const spdy::SpdyRstStreamControlFrame& frame) {
+void SpdySession::OnRstStream(const spdy::SpdyRstStreamControlFrame& frame) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
 
   net_log().AddEvent(
       NetLog::TYPE_SPDY_SESSION_RST_STREAM,
       make_scoped_refptr(
           new NetLogSpdyRstParameter(stream_id, frame.status(), "")));
 
   bool valid_stream = IsStreamActive(stream_id);
   if (!valid_stream) {
     // NOTE:  it may just be that the stream was cancelled.
@@ skipping 410 matching lines @@
   if (it == pending_callback_map_.end())
     return;
 
   CompletionCallback callback = it->second.callback;
   int result = it->second.result;
   pending_callback_map_.erase(it);
   callback.Run(result);
 }
 
 }  // namespace net