Add DatagramClientSocket::BindToDefaultNetwork(),GetBoundNetwork()

net/udp/udp_socket_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/udp/udp_socket_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <net/if.h>
 #include <netdb.h>
@@ skipping 308 matching lines @@
   if (rv < 0)
     return rv;
 
   is_connected_ = true;
   local_address_.reset();
   return rv;
 }
 
 int UDPSocketPosix::BindToNetwork(
     NetworkChangeNotifier::NetworkHandle network) {
-#if defined(OS_ANDROID)
   DCHECK_NE(socket_, kInvalidSocket);
   DCHECK(CalledOnValidThread());
   DCHECK(!is_connected());
+  if (network == NetworkChangeNotifier::kInvalidNetworkHandle)
+    return ERR_INVALID_ARGUMENT;
+#if defined(OS_ANDROID)
   // Android prior to Lollipop didn't have support for binding sockets to
   // networks.
   if (base::android::BuildInfo::GetInstance()->sdk_int() <
       base::android::SDK_VERSION_LOLLIPOP) {
     return ERR_NOT_IMPLEMENTED;

[Jana, 2015/12/04 20:30:16]

Not for this CL, but this seems like another platform support check that
probably belongs in NCN.

[pauljensen, 2015/12/07 13:05:55]

Why?  This support check is directly related to the setNetworkForSocket() call. 
NCN should not be thought of as a general-purpose system interface.  Of course
this is all somewhat silly because there is no way to get a NetworkHandle to
pass to this call without being on at least Lollipop.

[Jana, 2015/12/07 17:30:52]

Oh yes, apologies -- this doesn't belong in NCN. What I was after was that
having a different global way to check platform that's better than #defines
would be useful.

   }
   // NOTE(pauljensen): This does rely on Android implementation details, but
   // these details are unlikely to change.
   typedef int (*SetNetworkForSocket)(unsigned netId, int socketFd);
   static SetNetworkForSocket setNetworkForSocket;
   // This is racy, but all racers should come out with the same answer so it
   // shouldn't matter.
   if (setNetworkForSocket == nullptr) {
     // Android's netd client library should always be loaded in our address
     // space as it shims libc functions like connect().
     base::FilePath file(base::FilePath::FromUTF16Unsafe(
         base::GetNativeLibraryName(base::ASCIIToUTF16("netd_client"))));
     base::NativeLibrary lib = base::LoadNativeLibrary(file, nullptr);
     setNetworkForSocket = reinterpret_cast<SetNetworkForSocket>(
         base::GetFunctionPointerFromNativeLibrary(lib, "setNetworkForSocket"));
   }
   if (setNetworkForSocket == nullptr)
     return ERR_NOT_IMPLEMENTED;
-  return MapSystemError(setNetworkForSocket(network, socket_));
+  int rv = setNetworkForSocket(network, socket_);
+  // If |network| has since disconnected, |rv| will be ENONET.  Surface this as
+  // ERR_NETWORK_CHANGED, rather than MapSystemError(ENONET) which gives back
+  // the less descriptive ERR_FAILED.
+  if (rv == ENONET)
+    return ERR_NETWORK_CHANGED;

[Jana, 2015/12/04 20:30:16]

This is probably fine, but shouldn't this be ERR_INTERNET_DISCONNECTED? (You
could loop a few times in the BindToDefaultNetwork() and not return immediately
on ERR_INTERNET_DISCONNECTED as well.)

[pauljensen, 2015/12/07 13:05:55]

ERR_INTERNET_DISCONNECTED means there are no networks connected at all (i.e.
completely disconnected).  Failing here with ENONET just means |network| has
gone away but does not imply anything about other networks.  Frequently the race
here will be encountered when we change from one default network to another, so
we may not be completely disconnected.

+  return MapSystemError(rv);
 #else
   NOTIMPLEMENTED();
   return ERR_NOT_IMPLEMENTED;
 #endif
 }
 
 int UDPSocketPosix::SetReceiveBufferSize(int32_t size) {
   DCHECK_NE(socket_, kInvalidSocket);
   DCHECK(CalledOnValidThread());
   int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
@@ skipping 419 matching lines @@
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketPosix::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net