"Reland" of r241209. DialServiceImpl now binds to all ipv4 and interfaces instead of just the first

chrome/browser/extensions/api/dial/dial_service.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 "chrome/browser/extensions/api/dial/dial_service.h"
 
 #include <algorithm>
+#include <set>
+#include <utility>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/extensions/api/dial/dial_device_data.h"
 #include "chrome/common/chrome_version_info.h"
@@ skipping 444 matching lines @@
 #else
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
       &GetNetworkListOnFileThread,
       base::MessageLoopProxy::current(), base::Bind(
           &DialServiceImpl::SendNetworkList, AsWeakPtr())));
 #endif
 }
 
 void DialServiceImpl::SendNetworkList(const NetworkInterfaceList& networks) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  typedef std::pair<uint32, net::AddressFamily> InterfaceIndexAddressFamily;
+  std::set<InterfaceIndexAddressFamily> interface_index_addr_family_seen;
   std::vector<IPAddressNumber> ip_addresses;
 
-  // Returns the first IPv4 address found.  If there is a need for discovery
-  // across multiple networks, we could manage multiple sockets.
+  // Binds a socket to each IPv4 network interface found. Note that
+  // there may be duplicates in |networks|, so address family + interface index
+  // is used to identify unique interfaces.
   // TODO(mfoltz): Support IPV6 multicast.  http://crbug.com/165286
   for (NetworkInterfaceList::const_iterator iter = networks.begin();
        iter != networks.end(); ++iter) {
+    net::AddressFamily addr_family = net::GetAddressFamily(iter->address);
     DVLOG(1) << "Found " << iter->name << ", "
-             << net::IPAddressToString(iter->address);
-    if (iter->address.size() == net::kIPv4AddressSize) {
-      ip_addresses.push_back(iter->address);
-      break;
+             << net::IPAddressToString(iter->address)
+             << ", address family: " << addr_family;
+    if (addr_family == net::ADDRESS_FAMILY_IPV4) {
+      InterfaceIndexAddressFamily interface_index_addr_family =
+          std::make_pair(iter->interface_index, addr_family);
+      bool inserted = interface_index_addr_family_seen
+          .insert(interface_index_addr_family)
+          .second;
+      // We have not seen this interface before, so add its IP address to the
+      // discovery list.
+      if (inserted) {
+        VLOG(2) << "Encountered "
+                << "interface index: " << iter->interface_index << ", "
+                << "address family: " << addr_family << " for the first time, "
+                << "adding IP address " << net::IPAddressToString(iter->address)
+                << " to list.";
+        ip_addresses.push_back(iter->address);
+      } else {
+        VLOG(2) << "Already encountered "
+                << "interface index: " << iter->interface_index << ", "
+                << "address family: " << addr_family << " before, not adding.";
+      }
     }
   }
 
   DiscoverOnAddresses(ip_addresses);
 }
 
 void DialServiceImpl::DiscoverOnAddresses(
     const std::vector<IPAddressNumber>& ip_addresses) {
-  if (ip_addresses.size() == 0) {
+  if (ip_addresses.empty()) {
     DVLOG(1) << "Could not find a valid interface to bind. Finishing discovery";
     FinishDiscovery();
     return;
   }
 
   // Schedule a timer to finish the discovery process (and close the sockets).
   if (finish_delay_ > TimeDelta::FromSeconds(0)) {
     VLOG(2) << "Starting timer to finish discovery.";
     finish_timer_.Start(FROM_HERE,
                         finish_delay_,
                         this,
                         &DialServiceImpl::FinishDiscovery);
   }
 
   for (std::vector<IPAddressNumber>::const_iterator iter = ip_addresses.begin();
        iter != ip_addresses.end();
-       ++iter) {
+       ++iter)
     BindAndAddSocket(*iter);
-  }
 
   SendOneRequest();
 }
 
 void DialServiceImpl::BindAndAddSocket(const IPAddressNumber& bind_ip_address) {
   scoped_ptr<DialServiceImpl::DialSocket> dial_socket(CreateDialSocket());
   if (dial_socket->CreateAndBindSocket(bind_ip_address, net_log_,
                                        net_log_source_))
     dial_sockets_.push_back(dial_socket.release());
 }
@@ skipping 32 matching lines @@
   if (!discovery_active_) {
     VLOG(2) << "Request sent after discovery finished.  Ignoring.";
     return;
   }
 
   VLOG(2) << "Notifying observers of discovery request";
   FOR_EACH_OBSERVER(Observer, observer_list_, OnDiscoveryRequest(this));
   // If we need to send additional requests, schedule a timer to do so.
   if (num_requests_sent_ < max_requests_ && num_requests_sent_ == 1) {
     VLOG(2) << "Scheduling timer to send additional requests";
+    // TODO(imcheng): Move this to SendOneRequest() once the implications are
+    // understood.
     request_timer_.Start(FROM_HERE,
                          request_interval_,
                          this,
                          &DialServiceImpl::SendOneRequest);
   }
 }
 
 void DialServiceImpl::NotifyOnDeviceDiscovered(
     const DialDeviceData& device_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!discovery_active_) {
     VLOG(2) << "Got response after discovery finished.  Ignoring.";
     return;
   }
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnDeviceDiscovered(this, device_data));
 }
 
 void DialServiceImpl::NotifyOnError() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  // TODO(imcheng): Modify upstream so that the device list is not cleared
+  // when it could still potentially discover devices on other sockets.
   FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnError(this, DIAL_SERVICE_SOCKET_ERROR));
+                    OnError(this,
+                            HasOpenSockets() ? DIAL_SERVICE_SOCKET_ERROR
+                                             : DIAL_SERVICE_NO_INTERFACES));
 }
 
 void DialServiceImpl::FinishDiscovery() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(discovery_active_);
   VLOG(2) << "Discovery finished.";
   // Close all open sockets.
   dial_sockets_.clear();
   finish_timer_.Stop();
   request_timer_.Stop();
   discovery_active_ = false;
   num_requests_sent_ = 0;
   FOR_EACH_OBSERVER(Observer, observer_list_, OnDiscoveryFinished(this));
 }
 
 bool DialServiceImpl::HasOpenSockets() {
   for (ScopedVector<DialSocket>::const_iterator iter = dial_sockets_.begin();
        iter != dial_sockets_.end();
        ++iter) {
     if (!((*iter)->IsClosed()))
       return true;
   }
   return false;
 }
 
 }  // namespace extensions