Rename NET_API to NET_EXPORT, and rename NET_TEST to NET_EXPORT_PRIVATE.

net/disk_cache/disk_cache.h

 // Copyright (c) 2011 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.
 
 // Defines the public interface of the disk cache. For more details see
 // http://dev.chromium.org/developers/design-documents/network-stack/disk-cache
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_H_
 #define NET_DISK_CACHE_DISK_CACHE_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/time.h"
-#include "net/base/net_api.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
+#include "net/base/net_export.h"
 
 class FilePath;
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace net {
 class IOBuffer;
 class NetLog;
@@ skipping 13 matching lines @@
 // files will be deleted and a new set will be created. |max_bytes| is the
 // maximum size the cache can grow to. If zero is passed in as |max_bytes|, the
 // cache will determine the value to use. |thread| can be used to perform IO
 // operations if a dedicated thread is required; a valid value is expected for
 // any backend that performs operations on a disk. The returned pointer can be
 // NULL if a fatal error is found. The actual return value of the function is a
 // net error code. If this function returns ERR_IO_PENDING, the |callback| will
 // be invoked when a backend is available or a fatal error condition is reached.
 // The pointer to receive the |backend| must remain valid until the operation
 // completes (the callback is notified).
-NET_API int CreateCacheBackend(net::CacheType type, const FilePath& path,
-                               int max_bytes, bool force,
-                               base::MessageLoopProxy* thread,
-                               net::NetLog* net_log, Backend** backend,
-                               CompletionCallback* callback);
+NET_EXPORT int CreateCacheBackend(net::CacheType type, const FilePath& path,
+                                  int max_bytes, bool force,
+                                  base::MessageLoopProxy* thread,
+                                  net::NetLog* net_log, Backend** backend,
+                                  CompletionCallback* callback);
 
 // The root interface for a disk cache instance.
-class NET_API Backend {
+class NET_EXPORT Backend {
  public:
   // If the backend is destroyed when there are operations in progress (any
   // callback that has not been invoked yet), this method cancels said
   // operations so the callbacks are not invoked, possibly leaving the work
   // half way (for instance, dooming just a few entries). Note that pending IO
   // for a given Entry (as opposed to the Backend) will still generate a
   // callback from within this method.
   virtual ~Backend() {}
 
   // Returns the number of entries in the cache.
@@ skipping 66 matching lines @@
   // Return a list of cache statistics.
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) = 0;
 
   // Called whenever an external cache in the system reuses the resource
   // referred to by |key|.
   virtual void OnExternalCacheHit(const std::string& key) = 0;
 };
 
 // This interface represents an entry in the disk cache.
-class NET_TEST Entry {
+class NET_EXPORT_PRIVATE Entry {

[rvargas (doing something else), 2011/08/11 01:25:29]

Could you make this a NET_EXPORT?. My mistake.

  public:
   // Marks this cache entry for deletion.
   virtual void Doom() = 0;
 
   // Releases this entry. Calling this method does not cancel pending IO
   // operations on this entry. Even after the last reference to this object has
   // been released, pending completion callbacks may be invoked.
   virtual void Close() = 0;
 
   // Returns the key associated with this cache entry.
@@ skipping 137 matching lines @@
   // Note: This method is deprecated.
   virtual int ReadyForSparseIO(CompletionCallback* completion_callback) = 0;
 
  protected:
   virtual ~Entry() {}
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H_