Add QUIC_EXPORT macros

net/quic/core/quic_connection.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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 12 matching lines @@
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
-#include "net/base/net_export.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/quic_alarm.h"
 #include "net/quic/core/quic_alarm_factory.h"
 #include "net/quic/core/quic_blocked_writer_interface.h"
 #include "net/quic/core/quic_connection_stats.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_multipath_sent_packet_manager.h"
 #include "net/quic/core/quic_one_block_arena.h"
 #include "net/quic/core/quic_packet_creator.h"
 #include "net/quic/core/quic_packet_generator.h"
 #include "net/quic/core/quic_packet_writer.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_received_packet_manager.h"
 #include "net/quic/core/quic_sent_packet_manager_interface.h"
 #include "net/quic/core/quic_time.h"
 #include "net/quic/core/quic_types.h"
+#include "net/quic/platform/api/quic_export.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 
 namespace net {
 
 class QuicClock;
 class QuicConfig;
 class QuicConnection;
 class QuicEncrypter;
 class QuicRandom;
 
@@ skipping 26 matching lines @@
 static_assert(kMtuDiscoveryTargetPacketSizeHigh <= kMaxPacketSize,
               "MTU discovery target is too large");
 
 static_assert(kMtuDiscoveryTargetPacketSizeLow > kDefaultMaxPacketSize,
               "MTU discovery target does not exceed the default packet size");
 static_assert(kMtuDiscoveryTargetPacketSizeHigh > kDefaultMaxPacketSize,
               "MTU discovery target does not exceed the default packet size");
 
 // Class that receives callbacks from the connection when frames are received
 // and when other interesting events happen.
-class NET_EXPORT_PRIVATE QuicConnectionVisitorInterface {
+class QUIC_EXPORT_PRIVATE QuicConnectionVisitorInterface {
  public:
   virtual ~QuicConnectionVisitorInterface() {}
 
   // A simple visitor interface for dealing with a data frame.
   virtual void OnStreamFrame(const QuicStreamFrame& frame) = 0;
 
   // The session should process the WINDOW_UPDATE frame, adjusting both stream
   // and connection level flow control windows.
   virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) = 0;
 
@@ skipping 47 matching lines @@
   virtual bool HasPendingHandshake() const = 0;
 
   // Called to ask if any streams are open in this visitor, excluding the
   // reserved crypto and headers stream.
   virtual bool HasOpenDynamicStreams() const = 0;
 };
 
 // Interface which gets callbacks from the QuicConnection at interesting
 // points.  Implementations must not mutate the state of the connection
 // as a result of these callbacks.
-class NET_EXPORT_PRIVATE QuicConnectionDebugVisitor
+class QUIC_EXPORT_PRIVATE QuicConnectionDebugVisitor
     : public QuicSentPacketManagerInterface::DebugDelegate {
  public:
   ~QuicConnectionDebugVisitor() override {}
 
   // Called when a packet has been sent.
   virtual void OnPacketSent(const SerializedPacket& serialized_packet,
                             QuicPathId original_path_id,
                             QuicPacketNumber original_packet_number,
                             TransmissionType transmission_type,
                             QuicTime sent_time) {}
@@ skipping 89 matching lines @@
 
   // Called when RTT may have changed, including when an RTT is read from
   // the config.
   virtual void OnRttChanged(QuicTime::Delta rtt) const {}
 };
 
 // QuicConnections currently use around 1KB of polymorphic types which would
 // ordinarily be on the heap. Instead, store them inline in an arena.
 using QuicConnectionArena = QuicOneBlockArena<1024>;
 
-class NET_EXPORT_PRIVATE QuicConnectionHelperInterface {
+class QUIC_EXPORT_PRIVATE QuicConnectionHelperInterface {
  public:
   virtual ~QuicConnectionHelperInterface() {}
 
   // Returns a QuicClock to be used for all time related functions.
   virtual const QuicClock* GetClock() const = 0;
 
   // Returns a QuicRandom to be used for all random number related functions.
   virtual QuicRandom* GetRandomGenerator() = 0;
 
   // Returns a QuicBufferAllocator to be used for all stream frame buffers.
   virtual QuicBufferAllocator* GetBufferAllocator() = 0;
 };
 
-class NET_EXPORT_PRIVATE QuicConnection
+class QUIC_EXPORT_PRIVATE QuicConnection
     : public QuicFramerVisitorInterface,
       public QuicBlockedWriterInterface,
       public QuicPacketGenerator::DelegateInterface,
       public QuicSentPacketManagerInterface::NetworkChangeVisitor {
  public:
   enum AckBundling {
     // Send an ack if it's already queued in the connection.
     SEND_ACK_IF_QUEUED,
     // Always send an ack.
     SEND_ACK,
@@ skipping 310 matching lines @@
   }
 
   bool CanWrite(HasRetransmittableData retransmittable);
 
   // Stores current batch state for connection, puts the connection
   // into batch mode, and destruction restores the stored batch state.
   // While the bundler is in scope, any generated frames are bundled
   // as densely as possible into packets.  In addition, this bundler
   // can be configured to ensure that an ACK frame is included in the
   // first packet created, if there's new ack information to be sent.
-  class NET_EXPORT_PRIVATE ScopedPacketBundler {
+  class QUIC_EXPORT_PRIVATE ScopedPacketBundler {
    public:
     // In addition to all outgoing frames being bundled when the
     // bundler is in scope, setting |include_ack| to true ensures that
     // an ACK frame is opportunistically bundled with the first
     // outgoing packet.
     ScopedPacketBundler(QuicConnection* connection, AckBundling send_ack);
     ~ScopedPacketBundler();
 
    private:
     bool ShouldSendAck(AckBundling ack_mode) const;
 
     QuicConnection* connection_;
     bool already_in_batch_mode_;
   };
 
   // Delays setting the retransmission alarm until the scope is exited.
   // When nested, only the outermost scheduler will set the alarm, and inner
   // ones have no effect.
-  class NET_EXPORT_PRIVATE ScopedRetransmissionScheduler {
+  class QUIC_EXPORT_PRIVATE ScopedRetransmissionScheduler {
    public:
     explicit ScopedRetransmissionScheduler(QuicConnection* connection);
     ~ScopedRetransmissionScheduler();
 
    private:
     QuicConnection* connection_;
     // Set to the connection's delay_setting_retransmission_alarm_ value in the
     // constructor and when true, causes this class to do nothing.
     const bool already_delayed_;
   };
@@ skipping 457 matching lines @@
   // Indicates whether a write error is encountered currently. This is used to
   // avoid infinite write errors.
   bool write_error_occured_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_CONNECTION_H_