Remove one layer of abstraction from HTTP/2 frame representations.

net/spdy/core/spdy_protocol.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.
 
 // This file contains some protocol structures for use with SPDY 3 and HTTP 2
 // The SPDY 3 spec can be found at:
 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
 
 #ifndef NET_SPDY_CORE_SPDY_PROTOCOL_H_
 #define NET_SPDY_CORE_SPDY_PROTOCOL_H_
@@ skipping 363 matching lines @@
 
 class SpdyFrameVisitor;
 
 // Intermediate representation for HTTP2 frames.
 class SPDY_EXPORT_PRIVATE SpdyFrameIR {
  public:
   virtual ~SpdyFrameIR() {}
 
   virtual void Visit(SpdyFrameVisitor* visitor) const = 0;
   virtual SpdyFrameType frame_type() const = 0;
+  SpdyStreamId stream_id() const { return stream_id_; }
 
  protected:
-  SpdyFrameIR() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SpdyFrameIR);
-};
-
-// Abstract class intended to be inherited by IRs that have a stream associated
-// to them.
-class SPDY_EXPORT_PRIVATE SpdyFrameWithStreamIdIR : public SpdyFrameIR {
- public:
-  ~SpdyFrameWithStreamIdIR() override {}
-  SpdyStreamId stream_id() const { return stream_id_; }
-  void set_stream_id(SpdyStreamId stream_id) {
-    DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
-    stream_id_ = stream_id;
-  }
-
- protected:
-  explicit SpdyFrameWithStreamIdIR(SpdyStreamId stream_id) {
-    set_stream_id(stream_id);
-  }
+  SpdyFrameIR() : stream_id_(0) {}
+  explicit SpdyFrameIR(SpdyStreamId stream_id) : stream_id_(stream_id) {}
 
  private:
   SpdyStreamId stream_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithStreamIdIR);
+  DISALLOW_COPY_AND_ASSIGN(SpdyFrameIR);
 };
 
 // Abstract class intended to be inherited by IRs that have the option of a FIN
-// flag. Implies SpdyFrameWithStreamIdIR.
-class SPDY_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameWithStreamIdIR {
+// flag.
+class SPDY_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameIR {
  public:
   ~SpdyFrameWithFinIR() override {}
   bool fin() const { return fin_; }
   void set_fin(bool fin) { fin_ = fin; }
 
  protected:
   explicit SpdyFrameWithFinIR(SpdyStreamId stream_id)
-      : SpdyFrameWithStreamIdIR(stream_id),
-        fin_(false) {}
+      : SpdyFrameIR(stream_id), fin_(false) {}
 
  private:
   bool fin_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithFinIR);
 };
 
 // Abstract class intended to be inherited by IRs that contain a header
 // block. Implies SpdyFrameWithFinIR.
 class SPDY_EXPORT_PRIVATE SpdyFrameWithHeaderBlockIR
@@ skipping 87 matching lines @@
   const char* data_;
   size_t data_len_;
 
   bool padded_;
   // padding_payload_len_ = desired padding length - len(padding length field).
   int padding_payload_len_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyDataIR);
 };
 
-class SPDY_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameIR {
  public:
   SpdyRstStreamIR(SpdyStreamId stream_id, SpdyErrorCode error_code);
 
   ~SpdyRstStreamIR() override;
 
   SpdyErrorCode error_code() const { return error_code_; }
   void set_error_code(SpdyErrorCode error_code) { error_code_ = error_code; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
@@ skipping 129 matching lines @@
   bool has_priority_ = false;
   int weight_ = kHttp2DefaultStreamWeight;
   SpdyStreamId parent_stream_id_ = 0;
   bool exclusive_ = false;
   bool padded_ = false;
   int padding_payload_len_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyHeadersIR);
 };
 
-class SPDY_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameIR {
  public:
   SpdyWindowUpdateIR(SpdyStreamId stream_id, int32_t delta)
-      : SpdyFrameWithStreamIdIR(stream_id) {
+      : SpdyFrameIR(stream_id) {
     set_delta(delta);
   }
   int32_t delta() const { return delta_; }
   void set_delta(int32_t delta) {
     DCHECK_LE(0, delta);
     DCHECK_LE(delta, kSpdyMaximumWindowSize);
     delta_ = delta;
   }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
@@ skipping 36 matching lines @@
 
  private:
   SpdyStreamId promised_stream_id_;
 
   bool padded_;
   int padding_payload_len_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyPushPromiseIR);
 };
 
-class SPDY_EXPORT_PRIVATE SpdyContinuationIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyContinuationIR : public SpdyFrameIR {
  public:
   explicit SpdyContinuationIR(SpdyStreamId stream_id);
   ~SpdyContinuationIR() override;
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
   bool end_headers() const { return end_headers_; }
   void set_end_headers(bool end_headers) {end_headers_ = end_headers;}
   const SpdyString& encoding() const { return *encoding_; }
   void take_encoding(std::unique_ptr<SpdyString> encoding) {
     encoding_ = std::move(encoding);
   }
 
  private:
   std::unique_ptr<SpdyString> encoding_;
   bool end_headers_;
   DISALLOW_COPY_AND_ASSIGN(SpdyContinuationIR);
 };
 
-class SPDY_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameIR {
  public:
   explicit SpdyAltSvcIR(SpdyStreamId stream_id);
   ~SpdyAltSvcIR() override;
 
   SpdyString origin() const { return origin_; }
   const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector() const {
     return altsvc_vector_;
   }
 
   void set_origin(SpdyString origin) { origin_ = std::move(origin); }
   void add_altsvc(const SpdyAltSvcWireFormat::AlternativeService& altsvc) {
     altsvc_vector_.push_back(altsvc);
   }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
  private:
   SpdyString origin_;
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
   DISALLOW_COPY_AND_ASSIGN(SpdyAltSvcIR);
 };
 
-class SPDY_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameIR {
  public:
   SpdyPriorityIR(SpdyStreamId stream_id,
                  SpdyStreamId parent_stream_id,
                  int weight,
                  bool exclusive)
-      : SpdyFrameWithStreamIdIR(stream_id),
+      : SpdyFrameIR(stream_id),
         parent_stream_id_(parent_stream_id),
         weight_(weight),
         exclusive_(exclusive) {}
   SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
   int weight() const { return weight_; }
   bool exclusive() const { return exclusive_; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
@@ skipping 105 matching lines @@
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_CORE_SPDY_PROTOCOL_H_