Add QUIC_EXPORT macros

net/quic/core/frames/quic_ack_frame.h

 // Copyright (c) 2016 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_FRAMES_QUIC_ACK_FRAME_H_
 #define NET_QUIC_CORE_FRAMES_QUIC_ACK_FRAME_H_
 
 #include <string>
 
 #include "base/strings/string_piece.h"
-#include "net/base/net_export.h"
 #include "net/quic/core/interval_set.h"
 #include "net/quic/core/quic_types.h"
+#include "net/quic/platform/api/quic_export.h"
 
 namespace net {
 
 // A sequence of packet numbers where each number is unique. Intended to be used
 // in a sliding window fashion, where smaller old packet numbers are removed and
 // larger new packet numbers are added, with the occasional random access.
-class NET_EXPORT_PRIVATE PacketNumberQueue {
+class QUIC_EXPORT_PRIVATE PacketNumberQueue {
  public:
   using const_iterator = IntervalSet<QuicPacketNumber>::const_iterator;
   using const_reverse_iterator =
       IntervalSet<QuicPacketNumber>::const_reverse_iterator;
 
   PacketNumberQueue();
   PacketNumberQueue(const PacketNumberQueue& other);
   PacketNumberQueue(PacketNumberQueue&& other);
   ~PacketNumberQueue();
 
@@ skipping 48 matching lines @@
   // Returns the length of last interval.
   QuicPacketNumber LastIntervalLength() const;
 
   // Returns iterators over the packet number intervals.
   const_iterator begin() const;
   const_iterator end() const;
   const_reverse_iterator rbegin() const;
   const_reverse_iterator rend() const;
   const_iterator lower_bound(QuicPacketNumber packet_number) const;
 
-  friend NET_EXPORT_PRIVATE std::ostream& operator<<(
+  friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
       std::ostream& os,
       const PacketNumberQueue& q);
 
  private:
   IntervalSet<QuicPacketNumber> packet_number_intervals_;
 };
 
-struct NET_EXPORT_PRIVATE QuicAckFrame {
+struct QUIC_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame();
   QuicAckFrame(const QuicAckFrame& other);
   ~QuicAckFrame();
 
-  friend NET_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
-                                                     const QuicAckFrame& s);
+  friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
+                                                      const QuicAckFrame& s);
 
   // The highest packet number we've observed from the peer.
   QuicPacketNumber largest_observed;
 
   // Time elapsed since largest_observed was received until this Ack frame was
   // sent.
   QuicTime::Delta ack_delay_time;
 
   // Vector of <packet_number, time> for when packets arrived.
   PacketTimeVector received_packet_times;
 
   // Set of packets.
   PacketNumberQueue packets;
 
   // Path which this ack belongs to.
   QuicPathId path_id;
 };
 
 // True if the packet number is greater than largest_observed or is listed
 // as missing.
 // Always returns false for packet numbers less than least_unacked.
-NET_EXPORT_PRIVATE bool IsAwaitingPacket(
+QUIC_EXPORT_PRIVATE bool IsAwaitingPacket(
     const QuicAckFrame& ack_frame,
     QuicPacketNumber packet_number,
     QuicPacketNumber peer_least_packet_awaiting_ack);
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_FRAMES_QUIC_ACK_FRAME_H_