Implement SPDY_EXPORT and SPDY_EXPORT_PRIVATE macros.

net/spdy/core/spdy_framer.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.
 
 #ifndef NET_SPDY_CORE_SPDY_FRAMER_H_
 #define NET_SPDY_CORE_SPDY_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/sys_byteorder.h"
-#include "net/base/net_export.h"
 #include "net/spdy/chromium/spdy_flags.h"
 #include "net/spdy/core/hpack/hpack_decoder_interface.h"
 #include "net/spdy/core/hpack/hpack_encoder.h"
 #include "net/spdy/core/spdy_alt_svc_wire_format.h"
 #include "net/spdy/core/spdy_header_block.h"
 #include "net/spdy/core/spdy_headers_handler_interface.h"
 #include "net/spdy/core/spdy_protocol.h"
 #include "net/spdy/core/zero_copy_output_buffer.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 {
 
 class HttpProxyClientSocketPoolTest;
 class HttpNetworkLayer;
 class HttpNetworkTransactionTest;
 class SpdyHttpStreamTest;
 class SpdyNetworkTransactionTest;
@@ skipping 21 matching lines @@
 // delivered in chunks to the visitor.
 // The following steps are followed:
 //   1. OnHeaders, or OnPushPromise is called.
 //   2. OnHeaderFrameStart is called; visitor is expected to return an instance
 //      of SpdyHeadersHandlerInterface that will receive the header key-value
 //      pairs.
 //   3. OnHeaderFrameEnd is called, indicating that the full header block has
 //      been delivered for the control frame.
 // During step 2, if the visitor is not interested in accepting the header data,
 // it should return a no-op implementation of SpdyHeadersHandlerInterface.
-class NET_EXPORT_PRIVATE SpdyFramerVisitorInterface {
+class SPDY_EXPORT_PRIVATE SpdyFramerVisitorInterface {
  public:
   virtual ~SpdyFramerVisitorInterface() {}
 
   // Called if an error is detected in the SpdySerializedFrame protocol.
   virtual void OnError(SpdyFramer* framer) = 0;
 
   // Called when the common header for a frame is received. Validating the
   // common header occurs in later processing.
   virtual void OnCommonHeader(SpdyStreamId stream_id,
                               size_t length,
@@ skipping 162 matching lines @@
   // no explicit indication of the end of the frame payload.
   virtual void OnFramePayload(const char* data, size_t len) = 0;
 };
 
 // Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
 // SpdyFramerDebugVisitorInterface may be used in conjunction with SpdyFramer in
 // order to extract debug/internal information about the SpdyFramer as it
 // operates.
 //
 // Most HTTP2 implementations need not bother with this interface at all.
-class NET_EXPORT_PRIVATE SpdyFramerDebugVisitorInterface {
+class SPDY_EXPORT_PRIVATE SpdyFramerDebugVisitorInterface {
  public:
   virtual ~SpdyFramerDebugVisitorInterface() {}
 
   // Called after compressing a frame with a payload of
   // a list of name-value pairs.
   // |payload_len| is the uncompressed payload size.
   // |frame_len| is the compressed frame size.
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
                                      size_t frame_len) {}
 
   // Called when a frame containing a compressed payload of
   // name-value pairs is received.
   // |frame_len| is the compressed frame size.
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
                                         size_t frame_len) {}
 };
 
-class NET_EXPORT_PRIVATE SpdyFramer {
+class SPDY_EXPORT_PRIVATE SpdyFramer {
  public:
   // HTTP2 states.
   enum SpdyState {
     SPDY_ERROR,
     SPDY_READY_FOR_FRAME,  // Framer is ready for reading the next frame.
     SPDY_FRAME_COMPLETE,  // Framer has finished reading a frame, need to reset.
     SPDY_READING_COMMON_HEADER,
     SPDY_CONTROL_FRAME_PAYLOAD,
     SPDY_READ_DATA_FRAME_PADDING_LENGTH,
     SPDY_CONSUME_PADDING,
@@ skipping 104 matching lines @@
 
   // Given a buffer containing a serialized header block parse out a
   // SpdyHeaderBlock, putting the results in the given header block.
   // Returns true if successfully parsed, false otherwise.
   bool ParseHeaderBlockInBuffer(const char* header_data,
                                 size_t header_length,
                                 SpdyHeaderBlock* block) const;
 
   // Iteratively converts a SpdyFrameWithHeaderBlockIR into an appropriate
   // sequence of SpdySerializedFrames.
-  class NET_EXPORT_PRIVATE SpdyFrameIterator {
+  class SPDY_EXPORT_PRIVATE SpdyFrameIterator {
    public:
     // Creates an iterator with the provided framer.
     // Does not take ownership of |framer|.
     // |framer| must outlive this instance.
     explicit SpdyFrameIterator(SpdyFramer* framer);
     virtual ~SpdyFrameIterator();
 
     // Serializes the next frame in the sequence to |output|. Returns the number
     // of bytes written to |output|.
     virtual bool NextFrame(ZeroCopyOutputBuffer* output);
@@ skipping 23 matching lines @@
     bool is_first_frame_;
     bool has_next_frame_;
 
     // Field for debug reporting.
     size_t debug_total_size_;
   };
 
   // Iteratively converts a SpdyHeadersIR (with a possibly huge
   // SpdyHeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
   // write to the output.
-  class NET_EXPORT_PRIVATE SpdyHeaderFrameIterator : public SpdyFrameIterator {
+  class SPDY_EXPORT_PRIVATE SpdyHeaderFrameIterator : public SpdyFrameIterator {
    public:
     // Does not take ownership of |framer|. Take ownership of |headers_ir|.
     SpdyHeaderFrameIterator(SpdyFramer* framer,
                             std::unique_ptr<SpdyHeadersIR> headers_ir);
 
     ~SpdyHeaderFrameIterator() override;
 
    private:
     SpdyFrameWithHeaderBlockIR* GetIR() const override;
     size_t GetFrameSizeSansBlock() const override;
     bool SerializeGivenEncoding(const SpdyString& encoding,
                                 ZeroCopyOutputBuffer* output) const override;
 
     const std::unique_ptr<SpdyHeadersIR> headers_ir_;
   };
 
   // Iteratively converts a SpdyPushPromiseIR (with a possibly huge
   // SpdyHeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
   // write to the output.
-  class NET_EXPORT_PRIVATE SpdyPushPromiseFrameIterator
+  class SPDY_EXPORT_PRIVATE SpdyPushPromiseFrameIterator
       : public SpdyFrameIterator {
    public:
     // Does not take ownership of |framer|. Take ownership of |push_promise_ir|.
     SpdyPushPromiseFrameIterator(
         SpdyFramer* framer,
         std::unique_ptr<SpdyPushPromiseIR> push_promise_ir);
 
     ~SpdyPushPromiseFrameIterator() override;
 
    private:
@@ skipping 477 matching lines @@
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 
   // Latched value of FLAGS_chromium_http2_flag_remove_rewritelength.
   bool skip_rewritelength_ = false;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_CORE_SPDY_FRAMER_H_