proposed interface change at //net for webrtc

net/base/address_tracker_linux.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/base/address_tracker_linux.h"
 
 #include <errno.h>
 #include <linux/if.h>
 #include <sys/ioctl.h>
 
@@ skipping 195 matching lines @@
   is_offline_ = false;
   is_offline_initialized_ = true;
   is_offline_initialized_cv_.Signal();
 }
 
 AddressTrackerLinux::AddressMap AddressTrackerLinux::GetAddressMap() const {
   base::AutoLock lock(address_map_lock_);
   return address_map_;
 }
 
+base::hash_set<int> AddressTrackerLinux::GetOnlineLinks() const {
+  base::AutoLock lock(online_links_lock_);
+  return online_links_;
+}
+
 NetworkChangeNotifier::ConnectionType
 AddressTrackerLinux::GetCurrentConnectionType() {
   // http://crbug.com/125097
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   base::AutoLock lock(is_offline_lock_);
   // Make sure the initial offline state is set before returning.
   while (!is_offline_initialized_) {
     is_offline_initialized_cv_.Wait();
   }
   // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
@@ skipping 23 matching lines @@
     }
     if (rv < 0) {
       if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
         break;
       PLOG(ERROR) << "Failed to recv from netlink socket";
       return;
     }
     HandleMessage(buffer, rv, address_changed, link_changed, tunnel_changed);
   };
   if (*link_changed) {
+    bool is_offline;
+    {
+        base::AutoLock lock(online_links_lock_);
+        is_offline = online_links_.empty();
+    }
     base::AutoLock lock(is_offline_lock_);
-    is_offline_ = online_links_.empty();
+    is_offline_ = is_offline;
   }
 }
 
 void AddressTrackerLinux::HandleMessage(char* buffer,
                                         size_t length,
                                         bool* address_changed,
                                         bool* link_changed,
                                         bool* tunnel_changed) {
   DCHECK(buffer);
   for (struct nlmsghdr* header = reinterpret_cast<struct nlmsghdr*>(buffer);
@@ skipping 41 matching lines @@
           base::AutoLock lock(address_map_lock_);
           if (address_map_.erase(address))
             *address_changed = true;
         }
       } break;
       case RTM_NEWLINK: {
         const struct ifinfomsg* msg =
             reinterpret_cast<struct ifinfomsg*>(NLMSG_DATA(header));
         if (!(msg->ifi_flags & IFF_LOOPBACK) && (msg->ifi_flags & IFF_UP) &&
             (msg->ifi_flags & IFF_LOWER_UP) && (msg->ifi_flags & IFF_RUNNING)) {
+          base::AutoLock lock(online_links_lock_);
           if (online_links_.insert(msg->ifi_index).second) {
             *link_changed = true;
             if (IsTunnelInterface(msg))
               *tunnel_changed = true;
           }
         } else {
+          base::AutoLock lock(online_links_lock_);
           if (online_links_.erase(msg->ifi_index)) {
             *link_changed = true;
             if (IsTunnelInterface(msg))
               *tunnel_changed = true;
           }
         }
       } break;
       case RTM_DELLINK: {
         const struct ifinfomsg* msg =
             reinterpret_cast<struct ifinfomsg*>(NLMSG_DATA(header));
+        base::AutoLock lock(online_links_lock_);
         if (online_links_.erase(msg->ifi_index)) {
           *link_changed = true;
           if (IsTunnelInterface(msg))
             *tunnel_changed = true;
         }
       } break;
       default:
         break;
     }
   }
@@ skipping 21 matching lines @@
   netlink_fd_ = -1;
 }
 
 bool AddressTrackerLinux::IsTunnelInterface(const struct ifinfomsg* msg) const {
   // Linux kernel drivers/net/tun.c uses "tun" name prefix.
   return strncmp(get_interface_name_(msg->ifi_index), "tun", 3) == 0;
 }
 
 }  // namespace internal
 }  // namespace net