Add QUIC_EXPORT macros

net/quic/core/quic_config.h

 // Copyright (c) 2013 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_QUIC_CORE_QUIC_CONFIG_H_
 #define NET_QUIC_CORE_QUIC_CONFIG_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
-#include "net/base/net_export.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_time.h"
+#include "net/quic/platform/api/quic_export.h"
 
 namespace net {
 
 namespace test {
 class QuicConfigPeer;
 }  // namespace test
 
 class CryptoHandshakeMessage;
 
 // Describes whether or not a given QuicTag is required or optional in the
 // handshake message.
 enum QuicConfigPresence {
   // This negotiable value can be absent from the handshake message. Default
   // value is selected as the negotiated value in such a case.
   PRESENCE_OPTIONAL,
   // This negotiable value is required in the handshake message otherwise the
   // Process*Hello function returns an error.
   PRESENCE_REQUIRED,
 };
 
 // Whether the CryptoHandshakeMessage is from the client or server.
 enum HelloType {
   CLIENT,
   SERVER,
 };
 
 // An abstract base class that stores a value that can be sent in CHLO/SHLO
 // message. These values can be OPTIONAL or REQUIRED, depending on |presence_|.
-class NET_EXPORT_PRIVATE QuicConfigValue {
+class QUIC_EXPORT_PRIVATE QuicConfigValue {
  public:
   QuicConfigValue(QuicTag tag, QuicConfigPresence presence);
   virtual ~QuicConfigValue();
 
   // Serialises tag name and value(s) to |out|.
   virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const = 0;
 
   // Selects a mutually acceptable value from those offered in |peer_hello|
   // and those defined in the subclass.
   virtual QuicErrorCode ProcessPeerHello(
       const CryptoHandshakeMessage& peer_hello,
       HelloType hello_type,
       std::string* error_details) = 0;
 
  protected:
   const QuicTag tag_;
   const QuicConfigPresence presence_;
 };
 
-class NET_EXPORT_PRIVATE QuicNegotiableValue : public QuicConfigValue {
+class QUIC_EXPORT_PRIVATE QuicNegotiableValue : public QuicConfigValue {
  public:
   QuicNegotiableValue(QuicTag tag, QuicConfigPresence presence);
   ~QuicNegotiableValue() override;
 
   bool negotiated() const { return negotiated_; }
 
  protected:
   void set_negotiated(bool negotiated) { negotiated_ = negotiated; }
 
  private:
   bool negotiated_;
 };
 
-class NET_EXPORT_PRIVATE QuicNegotiableUint32 : public QuicNegotiableValue {
+class QUIC_EXPORT_PRIVATE QuicNegotiableUint32 : public QuicNegotiableValue {
   // TODO(fayang): some negotiated values use uint32 as bool (e.g., silent
   // close). Consider adding a QuicNegotiableBool type.
  public:
   // Default and max values default to 0.
   QuicNegotiableUint32(QuicTag name, QuicConfigPresence presence);
   ~QuicNegotiableUint32() override;
 
   // Sets the maximum possible value that can be achieved after negotiation and
   // also the default values to be assumed if PRESENCE_OPTIONAL and the *HLO msg
   // doesn't contain a value corresponding to |name_|. |max| is serialised via
@@ skipping 19 matching lines @@
                                  HelloType hello_type,
                                  std::string* error_details) override;
 
  private:
   uint32_t max_value_;
   uint32_t default_value_;
   uint32_t negotiated_value_;
 };
 
 // Stores uint32_t from CHLO or SHLO messages that are not negotiated.
-class NET_EXPORT_PRIVATE QuicFixedUint32 : public QuicConfigValue {
+class QUIC_EXPORT_PRIVATE QuicFixedUint32 : public QuicConfigValue {
  public:
   QuicFixedUint32(QuicTag name, QuicConfigPresence presence);
   ~QuicFixedUint32() override;
 
   bool HasSendValue() const;
 
   uint32_t GetSendValue() const;
 
   void SetSendValue(uint32_t value);
 
@@ skipping 12 matching lines @@
                                  std::string* error_details) override;
 
  private:
   uint32_t send_value_;
   bool has_send_value_;
   uint32_t receive_value_;
   bool has_receive_value_;
 };
 
 // Stores tag from CHLO or SHLO messages that are not negotiated.
-class NET_EXPORT_PRIVATE QuicFixedTagVector : public QuicConfigValue {
+class QUIC_EXPORT_PRIVATE QuicFixedTagVector : public QuicConfigValue {
  public:
   QuicFixedTagVector(QuicTag name, QuicConfigPresence presence);
   QuicFixedTagVector(const QuicFixedTagVector& other);
   ~QuicFixedTagVector() override;
 
   bool HasSendValues() const;
 
   QuicTagVector GetSendValues() const;
 
   void SetSendValues(const QuicTagVector& values);
@@ skipping 15 matching lines @@
                                  std::string* error_details) override;
 
  private:
   QuicTagVector send_values_;
   bool has_send_values_;
   QuicTagVector receive_values_;
   bool has_receive_values_;
 };
 
 // Stores QuicSocketAddress from CHLO or SHLO messages that are not negotiated.
-class NET_EXPORT_PRIVATE QuicFixedSocketAddress : public QuicConfigValue {
+class QUIC_EXPORT_PRIVATE QuicFixedSocketAddress : public QuicConfigValue {
  public:
   QuicFixedSocketAddress(QuicTag tag, QuicConfigPresence presence);
   ~QuicFixedSocketAddress() override;
 
   bool HasSendValue() const;
 
   const QuicSocketAddress& GetSendValue() const;
 
   void SetSendValue(const QuicSocketAddress& value);
 
@@ skipping 11 matching lines @@
 
  private:
   QuicSocketAddress send_value_;
   bool has_send_value_;
   QuicSocketAddress receive_value_;
   bool has_receive_value_;
 };
 
 // QuicConfig contains non-crypto configuration options that are negotiated in
 // the crypto handshake.
-class NET_EXPORT_PRIVATE QuicConfig {
+class QUIC_EXPORT_PRIVATE QuicConfig {
  public:
   QuicConfig();
   QuicConfig(const QuicConfig& other);
   ~QuicConfig();
 
   void SetConnectionOptionsToSend(const QuicTagVector& connection_options);
 
   bool HasReceivedConnectionOptions() const;
 
   // Sets initial received connection options.  All received connection options
@@ skipping 211 matching lines @@
   // Force HOL blocking for measurement purposes.
   QuicFixedUint32 force_hol_blocking_;
 
   // Whether support HTTP/2 SETTINGS_MAX_HEADER_LIST_SIZE SETTINGS frame.
   QuicFixedUint32 support_max_header_list_size_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_CONFIG_H_