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

net/dns/mock_host_resolver.cc

Index: net/dns/mock_host_resolver.cc
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index 10258b3d910d7e5aee322f4e4d76367debd1ecc9..ab7e5e7bf4697abc642dead61d0027c7b2540ae1 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -247,40 +247,26 @@ void MockHostResolverBase::ResolveNow(size_t id) {
 
 //-----------------------------------------------------------------------------
 
-struct RuleBasedHostResolverProc::Rule {
-  enum ResolverType {
-    kResolverTypeFail,
-    kResolverTypeSystem,
-    kResolverTypeIPLiteral,
-  };
-
-  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(
+    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) {
@@ -369,10 +355,25 @@ void RuleBasedHostResolverProc::AddSimulatedFailure(
 }
 
 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,
@@ -433,6 +434,7 @@ RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 }
 
 void RuleBasedHostResolverProc::AddRuleInternal(const Rule& rule) {
+  CHECK(!locked_);
   base::AutoLock lock(rule_lock_);
   rules_.push_back(rule);
 }