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

net/spdy/core/spdy_framer.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_CORE_SPDY_FRAMER_H_
 #define NET_SPDY_CORE_SPDY_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 27 matching lines @@
 class SpdyStreamTest;
 
 class SpdyFramer;
 class SpdyFrameBuilder;
 class SpdyFramerDecoderAdapter;
 
 namespace test {
 
 class TestSpdyVisitor;
 class SpdyFramerPeer;
+class SpdyFramerTest_MultipleContinuationFramesWithIterator_Test;
+class SpdyFramerTest_PushPromiseFramesWithIterator_Test;
 
 }  // namespace test
 
 // SpdyFramerVisitorInterface is a set of callbacks for the SpdyFramer.
 // Implement this interface to receive event callbacks as frames are
 // decoded from the framer.
 //
 // Control frames that contain HTTP2 header blocks (HEADER, and PUSH_PROMISE)
 // are processed in fashion that allows the decompressed header block to be
 // delivered in chunks to the visitor.
@@ skipping 145 matching lines @@
                           int weight,
                           bool exclusive) {}
 
   // Called when a frame type we don't recognize is received.
   // Return true if this appears to be a valid extension frame, false otherwise.
   // We distinguish between extension frames and nonsense by checking
   // whether the stream id is valid.
   virtual bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) = 0;
 };
 
-class SpdyFrameSequence {
+class SPDY_EXPORT_PRIVATE SpdyFrameSequence {
  public:
   virtual ~SpdyFrameSequence() {}
 
   // Serializes the next frame in the sequence to |output|. Returns the number
   // of bytes written to |output|.
   virtual size_t NextFrame(ZeroCopyOutputBuffer* output) = 0;
 
   // Returns true iff there is at least one more frame in the sequence.
   virtual bool HasNextFrame() const = 0;
 };
@@ skipping 160 matching lines @@
   SpdyState state() const;
   bool HasError() const { return state() == SPDY_ERROR; }
 
   // Given a buffer containing a serialized header block parse out a
   // SpdyHeaderBlock, putting the results in the given header block.
   // Returns true if successfully parsed, false otherwise.
   bool ParseHeaderBlockInBuffer(const char* header_data,
                                 size_t header_length,
                                 SpdyHeaderBlock* block) const;
 
-  // Iteratively converts a SpdyFrameWithHeaderBlockIR into an appropriate
-  // sequence of SpdySerializedFrames.
-  class SPDY_EXPORT_PRIVATE SpdyFrameIterator {
-   public:
-    // Creates an iterator with the provided framer.
-    // Does not take ownership of |framer|.
-    // |framer| must outlive this instance.
-    explicit SpdyFrameIterator(SpdyFramer* framer);
-    virtual ~SpdyFrameIterator();
-
-    // Serializes the next frame in the sequence to |output|. Returns the number
-    // of bytes written to |output|.
-    virtual bool NextFrame(ZeroCopyOutputBuffer* output);
-
-    // Returns true iff there is at least one more frame in the sequence.
-    virtual bool HasNextFrame() const;
-
-    // SpdyFrameIterator is neither copyable nor movable.
-    SpdyFrameIterator(const SpdyFrameIterator&) = delete;
-    SpdyFrameIterator& operator=(const SpdyFrameIterator&) = delete;
-
-   protected:
-    virtual SpdyFrameWithHeaderBlockIR* GetIR() const = 0;
-    virtual size_t GetFrameSizeSansBlock() const = 0;
-    virtual bool SerializeGivenEncoding(const SpdyString& encoding,
-                                        ZeroCopyOutputBuffer* output) const = 0;
-
-    SpdyFramer* GetFramer() const { return framer_; }
-    void SetEncoder(SpdyFrameWithHeaderBlockIR* ir) {
-      encoder_ =
-          framer_->GetHpackEncoder()->EncodeHeaderSet(ir->header_block());
-    }
-
-   private:
-    SpdyFramer* const framer_;
-    std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoder_;
-    bool is_first_frame_;
-    bool has_next_frame_;
-
-    // Field for debug reporting.
-    size_t debug_total_size_;
-  };
-
-  // Iteratively converts a SpdyHeadersIR (with a possibly huge
-  // SpdyHeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
-  // write to the output.
-  class SPDY_EXPORT_PRIVATE SpdyHeaderFrameIterator : public SpdyFrameIterator {
-   public:
-    // Does not take ownership of |framer|. Take ownership of |headers_ir|.
-    SpdyHeaderFrameIterator(SpdyFramer* framer,
-                            std::unique_ptr<SpdyHeadersIR> headers_ir);
-
-    ~SpdyHeaderFrameIterator() override;
-
-   private:
-    SpdyFrameWithHeaderBlockIR* GetIR() const override;
-    size_t GetFrameSizeSansBlock() const override;
-    bool SerializeGivenEncoding(const SpdyString& encoding,
-                                ZeroCopyOutputBuffer* output) const override;
-
-    const std::unique_ptr<SpdyHeadersIR> headers_ir_;
-  };
-
-  // Iteratively converts a SpdyPushPromiseIR (with a possibly huge
-  // SpdyHeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
-  // write to the output.
-  class SPDY_EXPORT_PRIVATE SpdyPushPromiseFrameIterator
-      : public SpdyFrameIterator {
-   public:
-    // Does not take ownership of |framer|. Take ownership of |push_promise_ir|.
-    SpdyPushPromiseFrameIterator(
-        SpdyFramer* framer,
-        std::unique_ptr<SpdyPushPromiseIR> push_promise_ir);
-
-    ~SpdyPushPromiseFrameIterator() override;
-
-   private:
-    SpdyFrameWithHeaderBlockIR* GetIR() const override;
-    size_t GetFrameSizeSansBlock() const override;
-    bool SerializeGivenEncoding(const SpdyString& encoding,
-                                ZeroCopyOutputBuffer* output) const override;
-
-    const std::unique_ptr<SpdyPushPromiseIR> push_promise_ir_;
-  };
+  // Create a SpdyFrameSequence to serialize |frame_ir|.
+  static std::unique_ptr<SpdyFrameSequence> CreateIterator(
+      SpdyFramer* framer,
+      std::unique_ptr<SpdyFrameIR> frame_ir);
 
   // Serialize a data frame.
   SpdySerializedFrame SerializeData(const SpdyDataIR& data) const;
   // Serializes the data frame header and optionally padding length fields,
   // excluding actual data payload and padding.
   SpdySerializedFrame SerializeDataFrameHeaderWithPaddingLengthField(
       const SpdyDataIR& data) const;
 
   SpdySerializedFrame SerializeRstStream(
       const SpdyRstStreamIR& rst_stream) const;
@@ skipping 100 matching lines @@
   // availability of an alternative service to the client.
   bool SerializeAltSvc(const SpdyAltSvcIR& altsvc,
                        ZeroCopyOutputBuffer* output);
 
   // Serializes a PRIORITY frame. The PRIORITY frame advises a change in
   // the relative priority of the given stream.
   bool SerializePriority(const SpdyPriorityIR& priority,
                          ZeroCopyOutputBuffer* output) const;
 
   // Serialize a frame of unknown type.
-  bool SerializeFrame(const SpdyFrameIR& frame, ZeroCopyOutputBuffer* output);
+  size_t SerializeFrame(const SpdyFrameIR& frame, ZeroCopyOutputBuffer* output);
 
   // Returns whether this SpdyFramer will compress header blocks using HPACK.
   bool compression_enabled() const {
     return compression_option_ == ENABLE_COMPRESSION;
   }
 
   void SetHpackIndexingPolicy(HpackEncoder::IndexingPolicy policy) {
     GetHpackEncoder()->SetIndexingPolicy(std::move(policy));
   }
 
@@ skipping 76 matching lines @@
   friend class HttpNetworkLayer;  // This is temporary for the server.
   friend class HttpNetworkTransactionTest;
   friend class HttpProxyClientSocketPoolTest;
   friend class SpdyHttpStreamTest;
   friend class SpdyNetworkTransactionTest;
   friend class SpdyProxyClientSocketTest;
   friend class SpdySessionTest;
   friend class SpdyStreamTest;
   friend class test::TestSpdyVisitor;
   friend class test::SpdyFramerPeer;
+  friend class test::SpdyFramerTest_MultipleContinuationFramesWithIterator_Test;
+  friend class test::SpdyFramerTest_PushPromiseFramesWithIterator_Test;
+
+  // Iteratively converts a SpdyFrameIR into an appropriate sequence of Spdy
+  // frames.
+  // Example usage:
+  // std::unique_ptr<SpdyFrameSequence> it = CreateIterator(framer, frame_ir);
+  // while (it->HasNextFrame()) {
+  //   if(it->NextFrame(output) == 0) {
+  //     // Write failed;
+  //   }
+  // }
+  class SPDY_EXPORT_PRIVATE SpdyFrameIterator : public SpdyFrameSequence {
+   public:
+    // Creates an iterator with the provided framer. Does not take ownership of
+    // |framer|, |framer| must outlive this instance.
+    explicit SpdyFrameIterator(SpdyFramer* framer);
+    ~SpdyFrameIterator() override;
+
+    // Serializes the next frame in the sequence to |output|. Returns the number
+    // of bytes written to |output|.
+    size_t NextFrame(ZeroCopyOutputBuffer* output) override;
+
+    // Returns true iff there is at least one more frame in the sequence.
+    bool HasNextFrame() const override;
+
+    // SpdyFrameIterator is neither copyable nor movable.
+    SpdyFrameIterator(const SpdyFrameIterator&) = delete;
+    SpdyFrameIterator& operator=(const SpdyFrameIterator&) = delete;
+
+   protected:
+    virtual SpdyFrameWithHeaderBlockIR* GetIR() const = 0;
+    virtual size_t GetFrameSizeSansBlock() const = 0;
+    virtual bool SerializeGivenEncoding(const SpdyString& encoding,
+                                        ZeroCopyOutputBuffer* output) const = 0;
+
+    SpdyFramer* GetFramer() const { return framer_; }
+    void SetEncoder(SpdyFrameWithHeaderBlockIR* ir) {
+      encoder_ =
+          framer_->GetHpackEncoder()->EncodeHeaderSet(ir->header_block());
+    }
+
+   private:
+    SpdyFramer* const framer_;
+    std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoder_;
+    bool is_first_frame_;
+    bool has_next_frame_;
+
+    // Field for debug reporting.
+    size_t debug_total_size_;
+  };
+
+  // Iteratively converts a SpdyHeadersIR (with a possibly huge
+  // SpdyHeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
+  // write to the output.
+  class SPDY_EXPORT_PRIVATE SpdyHeaderFrameIterator : public SpdyFrameIterator {
+   public:
+    // Does not take ownership of |framer|. Take ownership of |headers_ir|.
+    SpdyHeaderFrameIterator(SpdyFramer* framer,
+                            std::unique_ptr<SpdyHeadersIR> headers_ir);
+
+    ~SpdyHeaderFrameIterator() override;
+
+   private:
+    SpdyFrameWithHeaderBlockIR* GetIR() const override;
+    size_t GetFrameSizeSansBlock() const override;
+    bool SerializeGivenEncoding(const SpdyString& encoding,
+                                ZeroCopyOutputBuffer* output) const override;
+
+    const std::unique_ptr<SpdyHeadersIR> headers_ir_;
+  };
+
+  // Iteratively converts a SpdyPushPromiseIR (with a possibly huge
+  // SpdyHeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
+  // write to the output.
+  class SPDY_EXPORT_PRIVATE SpdyPushPromiseFrameIterator
+      : public SpdyFrameIterator {
+   public:
+    // Does not take ownership of |framer|. Take ownership of |push_promise_ir|.
+    SpdyPushPromiseFrameIterator(
+        SpdyFramer* framer,
+        std::unique_ptr<SpdyPushPromiseIR> push_promise_ir);
+
+    ~SpdyPushPromiseFrameIterator() override;
+
+   private:
+    SpdyFrameWithHeaderBlockIR* GetIR() const override;
+    size_t GetFrameSizeSansBlock() const override;
+    bool SerializeGivenEncoding(const SpdyString& encoding,
+                                ZeroCopyOutputBuffer* output) const override;
+
+    const std::unique_ptr<SpdyPushPromiseIR> push_promise_ir_;
+  };
+
+  // Converts a SpdyFrameIR into one Spdy frame (a sequence of length 1), and
+  // write it to the output.
+  class SpdyControlFrameIterator : public SpdyFrameSequence {
+   public:
+    SpdyControlFrameIterator(SpdyFramer* framer,
+                             std::unique_ptr<SpdyFrameIR> frame_ir);
+    ~SpdyControlFrameIterator() override;
+
+    size_t NextFrame(ZeroCopyOutputBuffer* output) override;
+
+    bool HasNextFrame() const override;
+
+   private:
+    SpdyFramer* const framer_;
+    std::unique_ptr<SpdyFrameIR> frame_ir_;
+  };
 
  private:
   class CharBuffer {
    public:
     explicit CharBuffer(size_t capacity);
     ~CharBuffer();
 
     void CopyFrom(const char* data, size_t size);
     void Rewind();
 
@@ skipping 243 matching lines @@
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 
   // Latched value of FLAGS_chromium_http2_flag_remove_rewritelength.
   bool skip_rewritelength_ = false;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_CORE_SPDY_FRAMER_H_