Create frame iterator for frame types except HEADER, PUSH_PROMISE and DATA. This helps use unified …

net/spdy/core/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/core/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cctype>
@@ skipping 1656 matching lines @@
 }
 
 SpdyFramer::SpdyFrameIterator::SpdyFrameIterator(SpdyFramer* framer)
     : framer_(framer),
       is_first_frame_(true),
       has_next_frame_(true),
       debug_total_size_(0) {}
 
 SpdyFramer::SpdyFrameIterator::~SpdyFrameIterator() {}
 
-bool SpdyFramer::SpdyFrameIterator::NextFrame(ZeroCopyOutputBuffer* output) {
+size_t SpdyFramer::SpdyFrameIterator::NextFrame(ZeroCopyOutputBuffer* output) {
   SpdyFrameWithHeaderBlockIR* frame_ir = GetIR();
   if (frame_ir == nullptr) {
     LOG(WARNING) << "frame_ir doesn't exist.";
     return false;
   }
   if (!has_next_frame_) {
     SPDY_BUG << "SpdyFramer::SpdyFrameIterator::NextFrame called without "
              << "a next frame.";
     return false;
   }
@@ skipping 17 matching lines @@
           framer_->GetSerializedLength(&frame_ir->header_block());
       framer_->debug_visitor_->OnSendCompressedFrame(
           frame_ir->stream_id(), frame_ir->frame_type(), debug_payload_len,
           debug_total_size_);
     }
   }
 
   if (is_first_frame_) {
     is_first_frame_ = false;
     frame_ir->set_end_headers(!has_next_frame_);
-    return SerializeGivenEncoding(*encoding, output);
+    size_t free_bytes_before = output->BytesFree();
+    bool ok = SerializeGivenEncoding(*encoding, output);
+    return ok ? free_bytes_before - output->BytesFree() : 0;
   } else {
     SpdyContinuationIR continuation_ir(frame_ir->stream_id());
     continuation_ir.set_end_headers(!has_next_frame_);
     continuation_ir.take_encoding(std::move(encoding));
     return framer_->SerializeContinuation(continuation_ir, output);
   }
 }
 
 bool SpdyFramer::SpdyFrameIterator::HasNextFrame() const {
   return has_next_frame_;
@@ skipping 41 matching lines @@
   return GetFramer()->GetPushPromiseFrameSizeSansBlock(*push_promise_ir_);
 }
 
 bool SpdyFramer::SpdyPushPromiseFrameIterator::SerializeGivenEncoding(
     const SpdyString& encoding,
     ZeroCopyOutputBuffer* output) const {
   return GetFramer()->SerializePushPromiseGivenEncoding(*push_promise_ir_,
                                                         encoding, output);
 }
 
+SpdyFramer::SpdyControlFrameIterator::SpdyControlFrameIterator(
+    SpdyFramer* framer,
+    std::unique_ptr<SpdyFrameIR> frame_ir)
+    : framer_(framer), frame_ir_(std::move(frame_ir)) {}
+
+SpdyFramer::SpdyControlFrameIterator::~SpdyControlFrameIterator() {}
+
+size_t SpdyFramer::SpdyControlFrameIterator::NextFrame(
+    ZeroCopyOutputBuffer* output) {
+  size_t size_written = framer_->SerializeFrame(*frame_ir_, output);
+  frame_ir_.reset();
+  return size_written;
+}
+
+bool SpdyFramer::SpdyControlFrameIterator::HasNextFrame() const {
+  return frame_ir_ != nullptr;
+}
+
+// TODO(yasong): remove all the down_casts.
+std::unique_ptr<SpdyFrameSequence> SpdyFramer::CreateIterator(
+    SpdyFramer* framer,
+    std::unique_ptr<SpdyFrameIR> frame_ir) {
+  std::unique_ptr<SpdyFrameSequence> result = nullptr;
+  switch (frame_ir->frame_type()) {
+    case SpdyFrameType::DATA: {
+      DLOG(ERROR) << "Data should use a different path to write";
+      result = nullptr;
+      break;
+    }
+    case SpdyFrameType::HEADERS: {
+      result = base::MakeUnique<SpdyHeaderFrameIterator>(
+          framer,
+          base::WrapUnique(static_cast<SpdyHeadersIR*>(frame_ir.get())));
+      break;
+    }
+    case SpdyFrameType::PUSH_PROMISE: {
+      result = base::MakeUnique<SpdyPushPromiseFrameIterator>(
+          framer,
+          base::WrapUnique(static_cast<SpdyPushPromiseIR*>(frame_ir.get())));
+      break;
+    }
+    default: {
+      result = base::MakeUnique<SpdyControlFrameIterator>(framer,
+                                                          std::move(frame_ir));
+    }
+  }
+  return result;
+}
+
 void SpdyFramer::SerializeDataBuilderHelper(const SpdyDataIR& data_ir,
                                             uint8_t* flags,
                                             int* num_padding_fields,
                                             size_t* size_with_padding) const {
   if (data_ir.fin()) {
     *flags = DATA_FLAG_FIN;
   }
 
   if (data_ir.padded()) {
     *flags = *flags | DATA_FLAG_PADDED;
@@ skipping 912 matching lines @@
 
 namespace {
 
 class FrameSerializationVisitorWithOutput : public SpdyFrameVisitor {
  public:
   explicit FrameSerializationVisitorWithOutput(SpdyFramer* framer,
                                                ZeroCopyOutputBuffer* output)
       : framer_(framer), output_(output), result_(false) {}
   ~FrameSerializationVisitorWithOutput() override {}
 
-  bool Result() { return result_; }
+  size_t Result() { return result_; }
 
   void VisitData(const SpdyDataIR& data) override {
     result_ = framer_->SerializeData(data, output_);
   }
   void VisitRstStream(const SpdyRstStreamIR& rst_stream) override {
     result_ = framer_->SerializeRstStream(rst_stream, output_);
   }
   void VisitSettings(const SpdySettingsIR& settings) override {
     result_ = framer_->SerializeSettings(settings, output_);
   }
@@ skipping 23 matching lines @@
   }
 
  private:
   SpdyFramer* framer_;
   ZeroCopyOutputBuffer* output_;
   bool result_;
 };
 
 }  // namespace
 
-bool SpdyFramer::SerializeFrame(const SpdyFrameIR& frame,
-                                ZeroCopyOutputBuffer* output) {
+size_t SpdyFramer::SerializeFrame(const SpdyFrameIR& frame,
+                                  ZeroCopyOutputBuffer* output) {
   FrameSerializationVisitorWithOutput visitor(this, output);
+  size_t free_bytes_before = output->BytesFree();
   frame.Visit(&visitor);
-  return visitor.Result();
+  return visitor.Result() ? free_bytes_before - output->BytesFree() : 0;
 }
 
 size_t SpdyFramer::GetNumberRequiredContinuationFrames(size_t size) {
   DCHECK_GT(size, kMaxControlFrameSize);
   size_t overflow = size - kMaxControlFrameSize;
   size_t payload_size = kMaxControlFrameSize - GetContinuationMinimumSize();
   // This is ceiling(overflow/payload_size) using integer arithmetics.
   return (overflow - 1) / payload_size + 1;
 }
 
@@ skipping 182 matching lines @@
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
     builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 }  // namespace net