net: Add NET_API to net/base

net/base/mock_host_resolver.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
 #ifndef NET_BASE_MOCK_HOST_RESOLVER_H_
 #define NET_BASE_MOCK_HOST_RESOLVER_H_
 #pragma once
 
 #include <list>
 
 #include "base/synchronization/waitable_event.h"
 #include "net/base/host_resolver_impl.h"
 #include "net/base/host_resolver_proc.h"
+#include "net/base/net_api.h"
 
 namespace net {
 
 class RuleBasedHostResolverProc;
 
 // In most cases, it is important that unit tests avoid relying on making actual
 // DNS queries since the resulting tests can be flaky, especially if the network
 // is unreliable for some reason.  To simplify writing tests that avoid making
 // actual DNS queries, pass a MockHostResolver as the HostResolver dependency.
 // The socket addresses returned can be configured using the
 // RuleBasedHostResolverProc:
 //
 //   host_resolver->rules()->AddRule("foo.com", "1.2.3.4");
 //   host_resolver->rules()->AddRule("bar.com", "2.3.4.5");
 //
 // The above rules define a static mapping from hostnames to IP address
 // literals.  The first parameter to AddRule specifies a host pattern to match
 // against, and the second parameter indicates what value should be used to
 // replace the given hostname.  So, the following is also supported:
 //
 //   host_mapper->AddRule("*.com", "127.0.0.1");
 //
 // Replacement doesn't have to be string representing an IP address. It can
 // re-map one hostname to another as well.
 
 // Base class shared by MockHostResolver and MockCachingHostResolver.
-class MockHostResolverBase : public HostResolver {
+class NET_TEST MockHostResolverBase : public HostResolver {
  public:
   virtual ~MockHostResolverBase();
 
   RuleBasedHostResolverProc* rules() { return rules_; }
 
   // Controls whether resolutions complete synchronously or asynchronously.
   void set_synchronous_mode(bool is_synchronous) {
     synchronous_mode_ = is_synchronous;
   }
 
@@ skipping 43 matching lines @@
 class MockCachingHostResolver : public MockHostResolverBase {
  public:
   MockCachingHostResolver() : MockHostResolverBase(true /*use_caching*/) {}
   ~MockCachingHostResolver() {}
 };
 
 // RuleBasedHostResolverProc applies a set of rules to map a host string to
 // a replacement host string. It then uses the system host resolver to return
 // a socket address. Generally the replacement should be an IPv4 literal so
 // there is no network dependency.
-class RuleBasedHostResolverProc : public HostResolverProc {
+class NET_TEST RuleBasedHostResolverProc : public HostResolverProc {
  public:
   explicit RuleBasedHostResolverProc(HostResolverProc* previous);
 
   // Any hostname matching the given pattern will be replaced with the given
   // replacement value.  Usually, replacement should be an IP address literal.
   void AddRule(const std::string& host_pattern,
                const std::string& replacement);
 
   // Same as AddRule(), but further restricts to |address_family|.
   void AddRuleForAddressFamily(const std::string& host_pattern,
@@ skipping 30 matching lines @@
  private:
   struct Rule;
   typedef std::list<Rule> RuleList;
 
   ~RuleBasedHostResolverProc();
 
   RuleList rules_;
 };
 
 // Using WaitingHostResolverProc you can simulate very long lookups.
-class WaitingHostResolverProc : public HostResolverProc {
+class NET_TEST WaitingHostResolverProc : public HostResolverProc {
  public:
   explicit WaitingHostResolverProc(HostResolverProc* previous);
 
   void Signal();
 
   // HostResolverProc methods:
   virtual int Resolve(const std::string& host,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
                       int* os_error);
 
  private:
   virtual ~WaitingHostResolverProc();
 
   base::WaitableEvent event_;
 };
 
 // This class sets the default HostResolverProc for a particular scope.  The
 // chain of resolver procs starting at |proc| is placed in front of any existing
 // default resolver proc(s).  This means that if multiple
 // ScopedDefaultHostResolverProcs are declared, then resolving will start with
 // the procs given to the last-allocated one, then fall back to the procs given
 // to the previously-allocated one, and so forth.
 //
 // NOTE: Only use this as a catch-all safety net. Individual tests should use
 // MockHostResolver.
-class ScopedDefaultHostResolverProc {
+class NET_TEST ScopedDefaultHostResolverProc {
  public:
   ScopedDefaultHostResolverProc();
   explicit ScopedDefaultHostResolverProc(HostResolverProc* proc);
 
   ~ScopedDefaultHostResolverProc();
 
   void Init(HostResolverProc* proc);
 
  private:
   scoped_refptr<HostResolverProc> current_proc_;
   scoped_refptr<HostResolverProc> previous_proc_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_MOCK_HOST_RESOLVER_H_