Implement SPDY_EXPORT and SPDY_EXPORT_PRIVATE macros.

net/spdy/core/spdy_header_block.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_HEADER_BLOCK_H_
 #define NET_SPDY_CORE_SPDY_HEADER_BLOCK_H_
 
 #include <stddef.h>
 
 #include <list>
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "net/base/linked_hash_map.h"
-#include "net/base/net_export.h"
 #include "net/log/net_log.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 base {
 class Value;
 }
 
 namespace net {
 
 class NetLogCaptureMode;
 
 namespace test {
 class SpdyHeaderBlockPeer;
 class ValueProxyPeer;
 }
 
 // This class provides a key-value map that can be used to store SPDY header
 // names and values. This data structure preserves insertion order.
 //
 // Under the hood, this data structure uses large, contiguous blocks of memory
 // to store names and values. Lookups may be performed with SpdyStringPiece
 // keys, and values are returned as SpdyStringPieces (via ValueProxy, below).
 // Value SpdyStringPieces are valid as long as the SpdyHeaderBlock exists;
 // allocated memory is never freed until SpdyHeaderBlock's destruction.
 //
 // This implementation does not make much of an effort to minimize wasted space.
 // It's expected that keys are rarely deleted from a SpdyHeaderBlock.
-class NET_EXPORT SpdyHeaderBlock {
+class SPDY_EXPORT_PRIVATE SpdyHeaderBlock {
  private:
   class Storage;
 
   // Stores a list of value fragments that can be joined later with a
   // key-dependent separator.
-  class NET_EXPORT HeaderValue {
+  class SPDY_EXPORT_PRIVATE HeaderValue {
    public:
     HeaderValue(Storage* storage,
                 SpdyStringPiece key,
                 SpdyStringPiece initial_value);
 
     // Moves are allowed.
     HeaderValue(HeaderValue&& other);
     HeaderValue& operator=(HeaderValue&& other);
 
     // Copies are not.
@@ skipping 22 matching lines @@
   typedef linked_hash_map<SpdyStringPiece, HeaderValue, base::StringPieceHash>
       MapType;
 
  public:
   typedef std::pair<SpdyStringPiece, SpdyStringPiece> value_type;
 
   // Provides iteration over a sequence of std::pair<SpdyStringPiece,
   // SpdyStringPiece>, even though the underlying MapType::value_type is
   // different. Dereferencing the iterator will result in memory allocation for
   // multi-value headers.
-  class NET_EXPORT iterator {
+  class SPDY_EXPORT_PRIVATE iterator {
    public:
     // The following type definitions fulfill the requirements for iterator
     // implementations.
     typedef std::pair<SpdyStringPiece, SpdyStringPiece> value_type;
     typedef value_type& reference;
     typedef value_type* pointer;
     typedef std::forward_iterator_tag iterator_category;
     typedef MapType::iterator::difference_type difference_type;
 
     // In practice, this iterator only offers access to const value_type.
@@ skipping 73 matching lines @@
   // If there is no such key, a new header with the key and value is added.
   void AppendValueOrAddHeader(const SpdyStringPiece key,
                               const SpdyStringPiece value);
 
   // Allows either lookup or mutation of the value associated with a key.
   ValueProxy operator[](const SpdyStringPiece key);
 
   // This object provides automatic conversions that allow SpdyHeaderBlock to be
   // nearly a drop-in replacement for linked_hash_map<SpdyString, SpdyString>.
   // It reads data from or writes data to a SpdyHeaderBlock::Storage.
-  class NET_EXPORT ValueProxy {
+  class SPDY_EXPORT_PRIVATE ValueProxy {
    public:
     ~ValueProxy();
 
     // Moves are allowed.
     ValueProxy(ValueProxy&& other);
     ValueProxy& operator=(ValueProxy&& other);
 
     // Copies are not.
     ValueProxy(const ValueProxy& other) = delete;
     ValueProxy& operator=(const ValueProxy& other) = delete;
@@ skipping 30 matching lines @@
   size_t bytes_allocated() const;
 
   // SpdyStringPieces held by |block_| point to memory owned by |*storage_|.
   // |storage_| might be nullptr as long as |block_| is empty.
   MapType block_;
   std::unique_ptr<Storage> storage_;
 };
 
 // Writes |fragments| to |dst|, joined by |separator|. |dst| must be large
 // enough to hold the result. Returns the number of bytes written.
-NET_EXPORT size_t Join(char* dst,
-                       const std::vector<SpdyStringPiece>& fragments,
-                       SpdyStringPiece separator);
+SPDY_EXPORT_PRIVATE size_t Join(char* dst,
+                                const std::vector<SpdyStringPiece>& fragments,
+                                SpdyStringPiece separator);
 
 // Converts a SpdyHeaderBlock into NetLog event parameters.
-NET_EXPORT std::unique_ptr<base::Value> SpdyHeaderBlockNetLogCallback(
+SPDY_EXPORT_PRIVATE std::unique_ptr<base::Value> SpdyHeaderBlockNetLogCallback(
     const SpdyHeaderBlock* headers,
     NetLogCaptureMode capture_mode);
 
 // Converts NetLog event parameters into a SPDY header block and writes them
 // to |headers|.  |event_param| must have been created by
 // SpdyHeaderBlockNetLogCallback.  On failure, returns false and clears
 // |headers|.
-NET_EXPORT bool SpdyHeaderBlockFromNetLogParam(
+SPDY_EXPORT_PRIVATE bool SpdyHeaderBlockFromNetLogParam(
     const base::Value* event_param,
     SpdyHeaderBlock* headers);
 
 }  // namespace net
 
 #endif  // NET_SPDY_CORE_SPDY_HEADER_BLOCK_H_