Allow HostCache to handle network changes itself

components/cronet/stale_host_resolver_unittest.cc

 // Copyright 2016 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 "components/cronet/stale_host_resolver.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/cronet/url_request_context_config.h"
+#include "net/android/network_change_notifier_factory_android.h"
 #include "net/base/net_errors.h"
+#include "net/base/network_change_notifier.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/host_resolver_proc.h"
 #include "net/http/http_network_session.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 100 matching lines @@
     resolver_ = resolver;
   }
 
   void ClearResolver() {
     DCHECK(resolver_);
     DCHECK(!stale_resolver_);
 
     resolver_ = nullptr;
   }
 
+  void CreateNetworkChangeNotifier() {
+    net::NetworkChangeNotifier::SetFactory(
+        new net::NetworkChangeNotifierFactoryAndroid());
+    net::NetworkChangeNotifier::Create();
+  }
+
   // Creates a cache entry for |kHostname| that is |age_sec| seconds old.
   void CreateCacheEntry(int age_sec) {
     DCHECK(resolver_);
     DCHECK(resolver_->GetHostCache());
 
     base::TimeDelta ttl(base::TimeDelta::FromSeconds(kCacheEntryTTLSec));
     net::HostCache::Key key(kHostname, net::ADDRESS_FAMILY_IPV4, 0);
     net::HostCache::Entry entry(net::OK, MakeAddressList(kCacheAddress), ttl);
     base::TimeDelta age = base::TimeDelta::FromSeconds(age_sec);
     base::TimeTicks then = base::TimeTicks::Now() - age;
     resolver_->GetHostCache()->Set(key, entry, then, ttl);
   }
 
   void OnNetworkChange() {
-    DCHECK(resolver_);
-    DCHECK(resolver_->GetHostCache());
-
-    resolver_->GetHostCache()->OnNetworkChange();
+    net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
+    base::RunLoop().RunUntilIdle();  // Wait for notification.
   }
 
   void LookupStale() {
     DCHECK(resolver_);
     DCHECK(resolver_->GetHostCache());
 
     net::HostCache::Key key(kHostname, net::ADDRESS_FAMILY_IPV4, 0);
     base::TimeTicks now = base::TimeTicks::Now();
     const net::HostCache::Entry* entry;
     net::HostCache::EntryStaleness stale;
@@ skipping 227 matching lines @@
       {2, 0, true, 1, 1, 1, true},
       {2, 0, true, 1, 1, 9, true},
 
       // Disallowing other networks only accepts zero network changes.
       {2, 0, false, 1, 1, 0, true},
       {2, 0, false, 1, 1, 1, false},
       {2, 0, false, 1, 1, 9, false},
   };
 
   SetStaleDelay(kNoStaleDelaySec);
+  CreateNetworkChangeNotifier();
 
   for (size_t i = 0; i < arraysize(kUsabilityTestCases); ++i) {
     const auto& test_case = kUsabilityTestCases[i];
 
     SetStaleUsability(test_case.max_expired_time_sec, test_case.max_stale_uses,
                       test_case.allow_other_network);
     CreateResolver();
     CreateCacheEntry(kCacheEntryTTLSec + test_case.age_sec);
     for (int j = 0; j < test_case.network_changes; ++j)
       OnNetworkChange();
@@ skipping 78 matching lines @@
 
   EXPECT_TRUE(resolve_complete());
   EXPECT_EQ(net::OK, resolve_error());
   EXPECT_EQ(1u, resolve_addresses().size());
   EXPECT_EQ(kCacheAddress, resolve_addresses()[0].ToStringWithoutPort());
 }
 
 }  // namespace
 
 }  // namespace cronet