Refactor BufferedSpdyFramer so that SpdySession is not a visitor of

net/spdy/buffered_spdy_framer.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/buffered_spdy_framer.h"
 
 #include "base/logging.h"
 
 namespace spdy {
 
 BufferedSpdyFramer::BufferedSpdyFramer()
     : visitor_(NULL),
       header_buffer_used_(0),
       header_buffer_valid_(false),
       header_stream_id_(SpdyFramer::kInvalidStream) {
   memset(header_buffer_, 0, sizeof(header_buffer_));
 }
 
 BufferedSpdyFramer::~BufferedSpdyFramer() {
 }
 
 void BufferedSpdyFramer::set_visitor(
     BufferedSpdyFramerVisitorInterface* visitor) {
   visitor_ = visitor;
-  spdy_framer_.set_visitor(visitor);
+  spdy_framer_.set_visitor(this);
+}
+
+void BufferedSpdyFramer::OnError(spdy::SpdyFramer* /*framer*/) {
+  visitor_->OnError();
 }
 
 void BufferedSpdyFramer::OnControl(const SpdyControlFrame* frame) {
+  frames_received_++;

[James Hawkins, 2012/02/20 21:45:43]

|frames_received_| is uninitialized.

   switch (frame->type()) {
     case SYN_STREAM:
     case SYN_REPLY:
     case HEADERS:
       InitHeaderStreaming(frame);
       break;
+    case spdy::GOAWAY:
+      visitor_->OnGoAway(
+          *reinterpret_cast<const spdy::SpdyGoAwayControlFrame*>(frame));
+      break;
+    case spdy::PING:
+      visitor_->OnPing(
+          *reinterpret_cast<const spdy::SpdyPingControlFrame*>(frame));
+      break;
+    case spdy::SETTINGS:
+      visitor_->OnSettings(
+          *reinterpret_cast<const spdy::SpdySettingsControlFrame*>(frame));
+      break;
+    case spdy::RST_STREAM:
+      visitor_->OnRstStream(
+          *reinterpret_cast<const spdy::SpdyRstStreamControlFrame*>(frame));
+      break;
+    case spdy::WINDOW_UPDATE:
+      visitor_->OnWindowUpdate(
+          *reinterpret_cast<const spdy::SpdyWindowUpdateControlFrame*>(frame));
+      break;
     default:
-      DCHECK(false);  // Error!
-      break;
+      NOTREACHED();  // Error!
   }
 }
 
+bool BufferedSpdyFramer::OnCredentialFrameData(const char* frame_data,
+                                               size_t len) {
+  DCHECK(false);
+  return false;
+}
+
 bool BufferedSpdyFramer::OnControlFrameHeaderData(SpdyStreamId stream_id,
                                                   const char* header_data,
                                                   size_t len) {
   CHECK_EQ(header_stream_id_, stream_id);
 
   if (len == 0) {
     // Indicates end-of-header-block.
     CHECK(header_buffer_valid_);
 
     const linked_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
     bool parsed_headers = SpdyFramer::ParseHeaderBlockInBuffer(
         header_buffer_, header_buffer_used_, headers.get());
     if (!parsed_headers) {
       LOG(WARNING) << "Could not parse Spdy Control Frame Header.";
+      visitor_->OnStreamError(stream_id);
       return false;
     }
     SpdyControlFrame* control_frame =
         reinterpret_cast<SpdyControlFrame*>(control_frame_.get());
     switch (control_frame->type()) {
       case SYN_STREAM:
-        visitor_->OnSyn(
+        visitor_->OnSynStream(
             *reinterpret_cast<const SpdySynStreamControlFrame*>(
                 control_frame), headers);
         break;
       case SYN_REPLY:
         visitor_->OnSynReply(
             *reinterpret_cast<const SpdySynReplyControlFrame*>(
                 control_frame), headers);
         break;
       case HEADERS:
         visitor_->OnHeaders(
             *reinterpret_cast<const SpdyHeadersControlFrame*>(
                 control_frame), headers);
         break;
       default:
         DCHECK(false);  // Error!
         break;
     }
     return true;
   }
 
   const size_t available = kHeaderBufferSize - header_buffer_used_;
   if (len > available) {
     header_buffer_valid_ = false;
+    visitor_->OnStreamError(stream_id);
     return false;
   }
   memcpy(header_buffer_ + header_buffer_used_, header_data, len);
   header_buffer_used_ += len;
   return true;
 }
 
 void BufferedSpdyFramer::OnDataFrameHeader(const SpdyDataFrame* frame) {
+  frames_received_++;
   header_stream_id_ = frame->stream_id();
 }
 
+void BufferedSpdyFramer::OnStreamFrameData(SpdyStreamId stream_id,
+                                           const char* data,
+                                           size_t len) {
+  visitor_->OnStreamFrameData(stream_id, data, len);
+}
+
+
 size_t BufferedSpdyFramer::ProcessInput(const char* data, size_t len) {
   return spdy_framer_.ProcessInput(data, len);
 }
 
 void BufferedSpdyFramer::Reset() {
   spdy_framer_.Reset();
 }
 
 SpdyFramer::SpdyError BufferedSpdyFramer::error_code() const {
   return spdy_framer_.error_code();
@@ skipping 79 matching lines @@
     default:
       DCHECK(false);  // Error!
       break;
   }
   control_frame_.reset(new SpdyFrame(frame_size_without_header_block));
   memcpy(control_frame_.get()->data(), frame->data(),
          frame_size_without_header_block);
 }
 
 }  // namespace spdy