Sync the browser test host resolver with the network process before a test runs.

net/dns/mock_host_resolver.cc

 // 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.
 
 #include "net/dns/mock_host_resolver.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 229 matching lines @@
 
   RequestImpl* req = it->second;
   requests_.erase(it);
 
   int error = ResolveProc(req->info(), req->addresses());
   req->OnResolveCompleted(this, error);
 }
 
 //-----------------------------------------------------------------------------
 
-struct RuleBasedHostResolverProc::Rule {
-  enum ResolverType {
-    kResolverTypeFail,
-    kResolverTypeSystem,
-    kResolverTypeIPLiteral,
-  };
+RuleBasedHostResolverProc::Rule::Rule(
+    ResolverType resolver_type,
+    const std::string& host_pattern,
+    AddressFamily address_family,
+    HostResolverFlags host_resolver_flags,
+    const std::string& replacement,
+    const std::string& canonical_name,
+    int latency_ms)
+    : resolver_type(resolver_type),
+      host_pattern(host_pattern),
+      address_family(address_family),
+      host_resolver_flags(host_resolver_flags),
+      replacement(replacement),
+      canonical_name(canonical_name),
+      latency_ms(latency_ms) {}
 
-  ResolverType resolver_type;
-  std::string host_pattern;
-  AddressFamily address_family;
-  HostResolverFlags host_resolver_flags;
-  std::string replacement;
-  std::string canonical_name;
-  int latency_ms;  // In milliseconds.
-
-  Rule(ResolverType resolver_type,
-       const std::string& host_pattern,
-       AddressFamily address_family,
-       HostResolverFlags host_resolver_flags,
-       const std::string& replacement,
-       const std::string& canonical_name,
-       int latency_ms)
-      : resolver_type(resolver_type),
-        host_pattern(host_pattern),
-        address_family(address_family),
-        host_resolver_flags(host_resolver_flags),
-        replacement(replacement),
-        canonical_name(canonical_name),
-        latency_ms(latency_ms) {}
-};
+RuleBasedHostResolverProc::Rule::Rule(const Rule& other) = default;
 
 RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous)
-    : HostResolverProc(previous) {
-}
+    : HostResolverProc(previous), locked_(false) {}
 
 void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern,
                                         const std::string& replacement) {
   AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
                           replacement);
 }
 
 void RuleBasedHostResolverProc::AddRuleForAddressFamily(
     const std::string& host_pattern,
     AddressFamily address_family,
@@ skipping 68 matching lines @@
             host_pattern,
             ADDRESS_FAMILY_UNSPECIFIED,
             flags,
             std::string(),
             std::string(),
             0);
   AddRuleInternal(rule);
 }
 
 void RuleBasedHostResolverProc::ClearRules() {
+  CHECK(!locked_);

[mmenke, 2017/04/25 16:37:51]

include base/logging.h

[jam, 2017/04/25 17:04:40]

Done.

   base::AutoLock lock(rule_lock_);
   rules_.clear();
 }
 
+void RuleBasedHostResolverProc::Lock() {
+  CHECK(!locked_);
+  locked_ = true;
+}
+
+RuleBasedHostResolverProc::RuleList RuleBasedHostResolverProc::GetRules() {
+  RuleList rv;
+  {
+    base::AutoLock lock(rule_lock_);
+    rv = rules_;
+  }
+  return rv;
+}
+
 int RuleBasedHostResolverProc::Resolve(const std::string& host,
                                        AddressFamily address_family,
                                        HostResolverFlags host_resolver_flags,
                                        AddressList* addrlist,
                                        int* os_error) {
   base::AutoLock lock(rule_lock_);
   RuleList::iterator r;
   for (r = rules_.begin(); r != rules_.end(); ++r) {
     bool matches_address_family =
         r->address_family == ADDRESS_FAMILY_UNSPECIFIED ||
@@ skipping 40 matching lines @@
     }
   }
   return ResolveUsingPrevious(host, address_family,
                               host_resolver_flags, addrlist, os_error);
 }
 
 RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 }
 
 void RuleBasedHostResolverProc::AddRuleInternal(const Rule& rule) {
+  CHECK(!locked_);
   base::AutoLock lock(rule_lock_);
   rules_.push_back(rule);
 }
 
 RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() {
   RuleBasedHostResolverProc* catchall = new RuleBasedHostResolverProc(NULL);
   catchall->AddIPLiteralRule("*", "127.0.0.1", "localhost");
 
   // Next add a rules-based layer the use controls.
   return new RuleBasedHostResolverProc(catchall);
@@ skipping 32 matching lines @@
   CHECK_EQ(old_proc, current_proc_.get());
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_.get());
   current_proc_->SetLastProc(previous_proc_.get());
 }
 
 }  // namespace net