Add QUIC_EXPORT macros

net/quic/core/crypto/quic_crypto_server_config.h

 // Copyright 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_CRYPTO_QUIC_CRYPTO_SERVER_CONFIG_H_
 #define NET_QUIC_CORE_CRYPTO_QUIC_CRYPTO_SERVER_CONFIG_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
-#include "net/base/net_export.h"
 #include "net/quic/core/crypto/crypto_handshake.h"
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/crypto_secret_boxer.h"
 #include "net/quic/core/crypto/proof_source.h"
 #include "net/quic/core/crypto/quic_compressed_certs_cache.h"
 #include "net/quic/core/crypto/quic_crypto_proof.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/quic/core/proto/source_address_token.pb.h"
 #include "net/quic/core/quic_time.h"
+#include "net/quic/platform/api/quic_export.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 
 namespace net {
 
 class CryptoHandshakeMessage;
 class EphemeralKeySource;
 class KeyExchange;
 class ProofSource;
 class QuicClock;
 class QuicRandom;
@@ skipping 33 matching lines @@
  public:
   PrimaryConfigChangedCallback();
   virtual ~PrimaryConfigChangedCallback();
   virtual void Run(const std::string& scid) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PrimaryConfigChangedCallback);
 };
 
 // Callback used to accept the result of the |client_hello| validation step.
-class NET_EXPORT_PRIVATE ValidateClientHelloResultCallback {
+class QUIC_EXPORT_PRIVATE ValidateClientHelloResultCallback {
  public:
   // Opaque token that holds information about the client_hello and
   // its validity.  Can be interpreted by calling ProcessClientHello.
-  struct NET_EXPORT_PRIVATE Result : public base::RefCountedThreadSafe<Result> {
+  struct QUIC_EXPORT_PRIVATE Result
+      : public base::RefCountedThreadSafe<Result> {
     Result(const CryptoHandshakeMessage& in_client_hello,
            QuicIpAddress in_client_ip,
            QuicWallTime in_now);
 
     CryptoHandshakeMessage client_hello;
     ClientHelloInfo info;
     QuicErrorCode error_code;
     std::string error_details;
 
     // Populated if the CHLO STK contained a CachedNetworkParameters proto.
     CachedNetworkParameters cached_network_params;
 
    private:
     friend class base::RefCountedThreadSafe<Result>;
     ~Result();
   };
 
   ValidateClientHelloResultCallback();
   virtual void Run(scoped_refptr<Result> result,
                    std::unique_ptr<ProofSource::Details> details) = 0;
   virtual ~ValidateClientHelloResultCallback();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ValidateClientHelloResultCallback);
 };
 
 // Callback used to accept the result of the ProcessClientHello method.
-class NET_EXPORT_PRIVATE ProcessClientHelloResultCallback {
+class QUIC_EXPORT_PRIVATE ProcessClientHelloResultCallback {
  public:
   ProcessClientHelloResultCallback();
   virtual ~ProcessClientHelloResultCallback();
   virtual void Run(QuicErrorCode error,
                    const std::string& error_details,
                    std::unique_ptr<CryptoHandshakeMessage> message,
                    std::unique_ptr<DiversificationNonce> diversification_nonce,
                    std::unique_ptr<ProofSource::Details> details) = 0;
 
  private:
@@ skipping 24 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RejectionObserver);
 };
 
 // QuicCryptoServerConfig contains the crypto configuration of a QUIC server.
 // Unlike a client, a QUIC server can have multiple configurations active in
 // order to support clients resuming with a previous configuration.
 // TODO(agl): when adding configurations at runtime is added, this object will
 // need to consider locking.
-class NET_EXPORT_PRIVATE QuicCryptoServerConfig {
+class QUIC_EXPORT_PRIVATE QuicCryptoServerConfig {
  public:
   // ConfigOptions contains options for generating server configs.
-  struct NET_EXPORT_PRIVATE ConfigOptions {
+  struct QUIC_EXPORT_PRIVATE ConfigOptions {
     ConfigOptions();
     ConfigOptions(const ConfigOptions& other);
     ~ConfigOptions();
 
     // expiry_time is the time, in UNIX seconds, when the server config will
     // expire. If unset, it defaults to the current time plus six months.
     QuicWallTime expiry_time;
     // channel_id_enabled controls whether the server config will indicate
     // support for ChannelIDs.
     bool channel_id_enabled;
@@ skipping 244 matching lines @@
   void set_rejection_observer(RejectionObserver* rejection_observer) {
     rejection_observer_ = rejection_observer;
   }
 
  private:
   friend class test::QuicCryptoServerConfigPeer;
   friend struct QuicSignedServerConfig;
 
   // Config represents a server config: a collection of preferences and
   // Diffie-Hellman public values.
-  class NET_EXPORT_PRIVATE Config : public QuicCryptoConfig,
-                                    public base::RefCounted<Config> {
+  class QUIC_EXPORT_PRIVATE Config : public QuicCryptoConfig,
+                                     public base::RefCounted<Config> {
    public:
     Config();
 
     // TODO(rtenneti): since this is a class, we should probably do
     // getters/setters here.
     // |serialized| contains the bytes of this server config, suitable for
     // sending on the wire.
     std::string serialized;
     // id contains the SCID of this server config.
     std::string id;
@@ skipping 335 matching lines @@
 
   // Enable serving SCT or not.
   bool enable_serving_sct_;
 
   // Does not own this observer.
   RejectionObserver* rejection_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoServerConfig);
 };
 
-struct NET_EXPORT_PRIVATE QuicSignedServerConfig
+struct QUIC_EXPORT_PRIVATE QuicSignedServerConfig
     : public base::RefCounted<QuicSignedServerConfig> {
   QuicSignedServerConfig();
 
   QuicCryptoProof proof;
   scoped_refptr<ProofSource::Chain> chain;
   // The server config that is used for this proof (and the rest of the
   // request).
   scoped_refptr<QuicCryptoServerConfig::Config> config;
   std::string primary_scid;
 
  private:
   friend class base::RefCounted<QuicSignedServerConfig>;
   virtual ~QuicSignedServerConfig();
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_CRYPTO_QUIC_CRYPTO_SERVER_CONFIG_H_