Switch from OnIPAddressChanged and OnConnectionTypeChange to OnNetworkChanged

net/dns/address_sorter_posix.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/address_sorter_posix.h"
 
 #include <netinet/in.h>
 
 #if defined(OS_MACOSX) || defined(OS_BSD)
 #include <sys/socket.h>  // Must be included before ifaddrs.h.
@@ skipping 252 matching lines @@
 }  // namespace
 
 AddressSorterPosix::AddressSorterPosix(ClientSocketFactory* socket_factory)
     : socket_factory_(socket_factory),
       precedence_table_(LoadPolicy(kDefaultPrecedenceTable,
                                    arraysize(kDefaultPrecedenceTable))),
       label_table_(LoadPolicy(kDefaultLabelTable,
                               arraysize(kDefaultLabelTable))),
       ipv4_scope_table_(LoadPolicy(kDefaultIPv4ScopeTable,
                               arraysize(kDefaultIPv4ScopeTable))) {
-  NetworkChangeNotifier::AddIPAddressObserver(this);
-  OnIPAddressChanged();
+  NetworkChangeNotifier::AddNetworkChangeObserver(this);
+  OnNetworkChanged(NetworkChangeNotifier::CONNECTION_NONE);
 }
 
 AddressSorterPosix::~AddressSorterPosix() {
-  NetworkChangeNotifier::RemoveIPAddressObserver(this);
+  NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void AddressSorterPosix::Sort(const AddressList& list,
                               const CallbackType& callback) const {
   DCHECK(CalledOnValidThread());
   ScopedVector<DestinationInfo> sort_list;
 
   for (size_t i = 0; i < list.size(); ++i) {
     scoped_ptr<DestinationInfo> info(new DestinationInfo());
     info->address = list[i].address();
@@ skipping 44 matching lines @@
 
   std::stable_sort(sort_list.begin(), sort_list.end(), CompareDestinations);
 
   AddressList result;
   for (size_t i = 0; i < sort_list.size(); ++i)
     result.push_back(IPEndPoint(sort_list[i]->address, 0 /* port */));
 
   callback.Run(true, result);
 }
 
-void AddressSorterPosix::OnIPAddressChanged() {
+void AddressSorterPosix::OnNetworkChanged(
+    NetworkChangeNotifier::ConnectionType type) {
   DCHECK(CalledOnValidThread());
+  if (type != NetworkChangeNotifier::CONNECTION_NONE)

[szym, 2013/01/20 06:52:08]

I suggest a comment:
// Update the map on the "destructive" update, so that we have the new map ready
before the "constructive" update.

It might be more intuitive if this was CONNECTION_TRANSIENT, or a completely
separate OnNetworkAboutToChange.

+    return;
   source_map_.clear();
 #if defined(OS_LINUX)
   const internal::AddressTrackerLinux* tracker =
       NetworkChangeNotifier::GetAddressTracker();
   if (!tracker)
     return;
   typedef internal::AddressTrackerLinux::AddressMap AddressMap;
   AddressMap map = tracker->GetAddressMap();
   for (AddressMap::const_iterator it = map.begin(); it != map.end(); ++it) {
     const IPAddressNumber& address = it->first;
@@ skipping 64 matching lines @@
 }
 
 // static
 scoped_ptr<AddressSorter> AddressSorter::CreateAddressSorter() {
   return scoped_ptr<AddressSorter>(
       new AddressSorterPosix(ClientSocketFactory::GetDefaultFactory()));
 }
 
 }  // namespace net