Implement SPDY_EXPORT and SPDY_EXPORT_PRIVATE macros.

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_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <iosfwd>
 #include <limits>
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sys_byteorder.h"
-#include "net/base/net_export.h"
 #include "net/spdy/core/spdy_alt_svc_wire_format.h"
 #include "net/spdy/core/spdy_bitmasks.h"
 #include "net/spdy/core/spdy_bug_tracker.h"
 #include "net/spdy/core/spdy_header_block.h"
+#include "net/spdy/platform/api/spdy_export.h"
 #include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/platform/api/spdy_string_piece.h"
 
 namespace net {
 
 // A stream id is a 31 bit entity.
 typedef uint32_t SpdyStreamId;
 
 // Specifies the stream ID used to denote the current session (for
 // flow control).
@@ skipping 18 matching lines @@
 
 // Maximum padding size in octets for one DATA or HEADERS or PUSH_PROMISE frame.
 const int32_t kPaddingSizePerFrame = 256;
 
 // The HTTP/2 connection preface, which must be the first bytes sent by the
 // client upon starting an HTTP/2 connection, and which must be followed by a
 // SETTINGS frame.  Note that even though |kHttp2ConnectionHeaderPrefix| is
 // defined as a string literal with a null terminator, the actual connection
 // preface is only the first |kHttp2ConnectionHeaderPrefixSize| bytes, which
 // excludes the null terminator.
-NET_EXPORT_PRIVATE extern const char* const kHttp2ConnectionHeaderPrefix;
+SPDY_EXPORT_PRIVATE extern const char* const kHttp2ConnectionHeaderPrefix;
 const int kHttp2ConnectionHeaderPrefixSize = 24;
 
 // Wire values for HTTP2 frame types.
 enum class SpdyFrameType : uint8_t {
   DATA = 0x00,
   HEADERS = 0x01,
   PRIORITY = 0x02,
   RST_STREAM = 0x03,
   SETTINGS = 0x04,
   PUSH_PROMISE = 0x05,
@@ skipping 62 matching lines @@
   SETTINGS_INITIAL_WINDOW_SIZE = 0x4,
   // The size of the largest frame payload that a receiver is willing to accept.
   SETTINGS_MAX_FRAME_SIZE = 0x5,
   // The maximum size of header list that the sender is prepared to accept.
   SETTINGS_MAX_HEADER_LIST_SIZE = 0x6,
   SETTINGS_MAX = SETTINGS_MAX_HEADER_LIST_SIZE
 };
 
 // This explicit operator is needed, otherwise compiler finds
 // overloaded operator to be ambiguous.
-NET_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                            SpdySettingsIds id);
+SPDY_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
+                                             SpdySettingsIds id);
 
 // This operator is needed, because SpdyFrameType is an enum class,
 // therefore implicit conversion to underlying integer type is not allowed.
-NET_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
-                                            SpdyFrameType frame_type);
+SPDY_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
+                                             SpdyFrameType frame_type);
 
 using SettingsMap = std::map<SpdySettingsIds, uint32_t>;
 
 // HTTP/2 error codes, RFC 7540 Section 7.
 enum SpdyErrorCode : uint32_t {
   ERROR_CODE_NO_ERROR = 0x0,
   ERROR_CODE_PROTOCOL_ERROR = 0x1,
   ERROR_CODE_INTERNAL_ERROR = 0x2,
   ERROR_CODE_FLOW_CONTROL_ERROR = 0x3,
   ERROR_CODE_SETTINGS_TIMEOUT = 0x4,
@@ skipping 12 matching lines @@
 // A SPDY priority is a number between 0 and 7 (inclusive).
 typedef uint8_t SpdyPriority;
 
 // Lowest and Highest here refer to SPDY priorities as described in
 
 // https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority
 const SpdyPriority kV3HighestPriority = 0;
 const SpdyPriority kV3LowestPriority = 7;
 
 // Returns SPDY 3.x priority value clamped to the valid range of [0, 7].
-NET_EXPORT_PRIVATE SpdyPriority ClampSpdy3Priority(SpdyPriority priority);
+SPDY_EXPORT_PRIVATE SpdyPriority ClampSpdy3Priority(SpdyPriority priority);
 
 // HTTP/2 stream weights are integers in range [1, 256], as specified in RFC
 // 7540 section 5.3.2. Default stream weight is defined in section 5.3.5.
 const int kHttp2MinStreamWeight = 1;
 const int kHttp2MaxStreamWeight = 256;
 const int kHttp2DefaultStreamWeight = 16;
 
 // Returns HTTP/2 weight clamped to the valid range of [1, 256].
-NET_EXPORT_PRIVATE int ClampHttp2Weight(int weight);
+SPDY_EXPORT_PRIVATE int ClampHttp2Weight(int weight);
 
 // Maps SPDY 3.x priority value in range [0, 7] to HTTP/2 weight value in range
 // [1, 256], where priority 0 (i.e. highest precedence) corresponds to maximum
 // weight 256 and priority 7 (lowest precedence) corresponds to minimum weight
 // 1.
-NET_EXPORT_PRIVATE int Spdy3PriorityToHttp2Weight(SpdyPriority priority);
+SPDY_EXPORT_PRIVATE int Spdy3PriorityToHttp2Weight(SpdyPriority priority);
 
 // Maps HTTP/2 weight value in range [1, 256] to SPDY 3.x priority value in
 // range [0, 7], where minimum weight 1 corresponds to priority 7 (lowest
 // precedence) and maximum weight 256 corresponds to priority 0 (highest
 // precedence).
-NET_EXPORT_PRIVATE SpdyPriority Http2WeightToSpdy3Priority(int weight);
+SPDY_EXPORT_PRIVATE SpdyPriority Http2WeightToSpdy3Priority(int weight);
 
 // Reserved ID for root stream of HTTP/2 stream dependency tree, as specified
 // in RFC 7540 section 5.3.1.
 const unsigned int kHttp2RootStreamId = 0;
 
 typedef uint64_t SpdyPingId;
 
 // Returns true if a given on-the-wire enumeration of a frame type is defined
 // in a standardized HTTP/2 specification, false otherwise.
-NET_EXPORT_PRIVATE bool IsDefinedFrameType(uint8_t frame_type_field);
+SPDY_EXPORT_PRIVATE bool IsDefinedFrameType(uint8_t frame_type_field);
 
 // Parses a frame type from an on-the-wire enumeration.
 // Behavior is undefined for invalid frame type fields; consumers should first
 // use IsValidFrameType() to verify validity of frame type fields.
-NET_EXPORT_PRIVATE SpdyFrameType ParseFrameType(uint8_t frame_type_field);
+SPDY_EXPORT_PRIVATE SpdyFrameType ParseFrameType(uint8_t frame_type_field);
 
 // Serializes a frame type to the on-the-wire value.
-NET_EXPORT_PRIVATE uint8_t SerializeFrameType(SpdyFrameType frame_type);
+SPDY_EXPORT_PRIVATE uint8_t SerializeFrameType(SpdyFrameType frame_type);
 
 // (HTTP/2) All standard frame types except WINDOW_UPDATE are
 // (stream-specific xor connection-level). Returns false iff we know
 // the given frame type does not align with the given streamID.
-NET_EXPORT_PRIVATE bool IsValidHTTP2FrameStreamId(
+SPDY_EXPORT_PRIVATE bool IsValidHTTP2FrameStreamId(
     SpdyStreamId current_frame_stream_id,
     SpdyFrameType frame_type_field);
 
 // Serialize |frame_type| to string for logging/debugging.
 const char* FrameTypeToString(SpdyFrameType frame_type);
 
 // If |wire_setting_id| is the on-the-wire representation of a defined SETTINGS
 // parameter, parse it to |*setting_id| and return true.
-NET_EXPORT_PRIVATE bool ParseSettingsId(uint16_t wire_setting_id,
-                                        SpdySettingsIds* setting_id);
+SPDY_EXPORT_PRIVATE bool ParseSettingsId(uint16_t wire_setting_id,
+                                         SpdySettingsIds* setting_id);
 
 // Return if |id| corresponds to a defined setting;
 // stringify |id| to |*settings_id_string| regardless.
-NET_EXPORT_PRIVATE bool SettingsIdToString(SpdySettingsIds id,
-                                           const char** settings_id_string);
+SPDY_EXPORT_PRIVATE bool SettingsIdToString(SpdySettingsIds id,
+                                            const char** settings_id_string);
 
 // Parse |wire_error_code| to a SpdyErrorCode.
 // Treat unrecognized error codes as INTERNAL_ERROR
 // as recommended by the HTTP/2 specification.
-NET_EXPORT_PRIVATE SpdyErrorCode ParseErrorCode(uint32_t wire_error_code);
+SPDY_EXPORT_PRIVATE SpdyErrorCode ParseErrorCode(uint32_t wire_error_code);
 
 // Serialize RST_STREAM or GOAWAY frame error code to string
 // for logging/debugging.
 const char* ErrorCodeToString(SpdyErrorCode error_code);
 
 // Number of octets in the frame header.
 const size_t kFrameHeaderSize = 9;
 // Size, in bytes, of the data frame header.
 const size_t kDataFrameMinimumSize = kFrameHeaderSize;
 // Maximum possible configurable size of a frame in octets.
@@ skipping 101 matching lines @@
     SpdyPriority spdy3_priority_;
     Http2StreamDependency http2_stream_dependency_;
   };
 };
 
 typedef StreamPrecedence<SpdyStreamId> SpdyStreamPrecedence;
 
 class SpdyFrameVisitor;
 
 // Intermediate representation for HTTP2 frames.
-class NET_EXPORT_PRIVATE SpdyFrameIR {
+class SPDY_EXPORT_PRIVATE SpdyFrameIR {
  public:
   virtual ~SpdyFrameIR() {}
 
   virtual void Visit(SpdyFrameVisitor* visitor) const = 0;
   virtual SpdyFrameType frame_type() const = 0;
 
  protected:
   SpdyFrameIR() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameIR);
 };
 
 // Abstract class intended to be inherited by IRs that have a stream associated
 // to them.
-class NET_EXPORT_PRIVATE SpdyFrameWithStreamIdIR : public SpdyFrameIR {
+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);
   }
 
  private:
   SpdyStreamId stream_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithStreamIdIR);
 };
 
 // Abstract class intended to be inherited by IRs that have the option of a FIN
 // flag. Implies SpdyFrameWithStreamIdIR.
-class NET_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameWithStreamIdIR {
  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) {}
 
  private:
   bool fin_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithFinIR);
 };
 
 // Abstract class intended to be inherited by IRs that contain a header
 // block. Implies SpdyFrameWithFinIR.
-class NET_EXPORT_PRIVATE SpdyFrameWithHeaderBlockIR
+class SPDY_EXPORT_PRIVATE SpdyFrameWithHeaderBlockIR
     : public NON_EXPORTED_BASE(SpdyFrameWithFinIR) {
  public:
   ~SpdyFrameWithHeaderBlockIR() override;
 
   const SpdyHeaderBlock& header_block() const { return header_block_; }
   void set_header_block(SpdyHeaderBlock header_block) {
     // Deep copy.
     header_block_ = std::move(header_block);
   }
   void SetHeader(SpdyStringPiece name, SpdyStringPiece value) {
     header_block_[name] = value;
   }
   bool end_headers() const { return end_headers_; }
   void set_end_headers(bool end_headers) { end_headers_ = end_headers; }
 
  protected:
   SpdyFrameWithHeaderBlockIR(SpdyStreamId stream_id,
                              SpdyHeaderBlock header_block);
 
  private:
   SpdyHeaderBlock header_block_;
   bool end_headers_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithHeaderBlockIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyDataIR
+class SPDY_EXPORT_PRIVATE SpdyDataIR
     : public NON_EXPORTED_BASE(SpdyFrameWithFinIR) {
  public:
   // Performs a deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, SpdyStringPiece data);
 
   // Performs a deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, const char* data);
 
   // Moves data into data_store_. Makes a copy if passed a non-movable string.
   SpdyDataIR(SpdyStreamId stream_id, SpdyString data);
@@ skipping 50 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 NET_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameWithStreamIdIR {
  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;
 
   SpdyFrameType frame_type() const override;
 
  private:
   SpdyErrorCode error_code_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyRstStreamIR);
 };
 
-class NET_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR {
+class SPDY_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR {
  public:
   SpdySettingsIR();
   ~SpdySettingsIR() override;
 
   // Overwrites as appropriate.
   const SettingsMap& values() const { return values_; }
   void AddSetting(SpdySettingsIds id, int32_t value) { values_[id] = value; }
 
   bool is_ack() const { return is_ack_; }
   void set_is_ack(bool is_ack) {
     is_ack_ = is_ack;
   }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
  private:
   SettingsMap values_;
   bool is_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySettingsIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyPingIR : public SpdyFrameIR {
+class SPDY_EXPORT_PRIVATE SpdyPingIR : public SpdyFrameIR {
  public:
   explicit SpdyPingIR(SpdyPingId id) : id_(id), is_ack_(false) {}
   SpdyPingId id() const { return id_; }
 
   bool is_ack() const { return is_ack_; }
   void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
  private:
   SpdyPingId id_;
   bool is_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyPingIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyGoAwayIR : public SpdyFrameIR {
+class SPDY_EXPORT_PRIVATE SpdyGoAwayIR : public SpdyFrameIR {
  public:
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
   SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                SpdyErrorCode error_code,
                SpdyStringPiece description);
 
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
   SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
@@ skipping 26 matching lines @@
 
  private:
   SpdyStreamId last_good_stream_id_;
   SpdyErrorCode error_code_;
   const SpdyString description_store_;
   const SpdyStringPiece description_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyGoAwayIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
+class SPDY_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
  public:
   explicit SpdyHeadersIR(SpdyStreamId stream_id)
       : SpdyHeadersIR(stream_id, SpdyHeaderBlock()) {}
   SpdyHeadersIR(SpdyStreamId stream_id, SpdyHeaderBlock header_block)
       : SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)) {}
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
   SpdyFrameType frame_type() const override;
 
@@ skipping 19 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 NET_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameWithStreamIdIR {
  public:
   SpdyWindowUpdateIR(SpdyStreamId stream_id, int32_t delta)
       : SpdyFrameWithStreamIdIR(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;
 
   SpdyFrameType frame_type() const override;
 
  private:
   int32_t delta_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyWindowUpdateIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyPushPromiseIR : public SpdyFrameWithHeaderBlockIR {
+class SPDY_EXPORT_PRIVATE SpdyPushPromiseIR
+    : public SpdyFrameWithHeaderBlockIR {
  public:
   SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
       : SpdyPushPromiseIR(stream_id, promised_stream_id, SpdyHeaderBlock()) {}
   SpdyPushPromiseIR(SpdyStreamId stream_id,
                     SpdyStreamId promised_stream_id,
                     SpdyHeaderBlock header_block)
       : SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)),
         promised_stream_id_(promised_stream_id),
         padded_(false),
         padding_payload_len_(0) {}
@@ skipping 15 matching lines @@
 
  private:
   SpdyStreamId promised_stream_id_;
 
   bool padded_;
   int padding_payload_len_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyPushPromiseIR);
 };
 
-class NET_EXPORT_PRIVATE SpdyContinuationIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyContinuationIR : public SpdyFrameWithStreamIdIR {
  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 NET_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR {
  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 NET_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
+class SPDY_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR {
  public:
   SpdyPriorityIR(SpdyStreamId stream_id,
                  SpdyStreamId parent_stream_id,
                  int weight,
                  bool exclusive)
       : SpdyFrameWithStreamIdIR(stream_id),
         parent_stream_id_(parent_stream_id),
         weight_(weight),
         exclusive_(exclusive) {}
   SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
@@ skipping 111 matching lines @@
   SpdyFrameVisitor() {}
   virtual ~SpdyFrameVisitor() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_CORE_SPDY_PROTOCOL_H_