Use supported Android network handles in Android M and newer.

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 328 matching lines @@
   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;
   }
-  // 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) {
-    // Android's netd client library should always be loaded in our address
-    // space as it shims socket() which was used to create |socket_|.
-    base::FilePath file(base::GetNativeLibraryName("netd_client"));
-    // Use RTLD_NOW to match Android's prior loading of the library:
-    // http://androidxref.com/6.0.0_r5/xref/bionic/libc/bionic/NetdClient.cpp#37
-    // Use RTLD_NOLOAD to assert that the library is already loaded and
-    // avoid doing any disk IO.
-    void* dl = dlopen(file.value().c_str(), RTLD_NOW | RTLD_NOLOAD);
-    setNetworkForSocket =
-        reinterpret_cast<SetNetworkForSocket>(dlsym(dl, "setNetworkForSocket"));
+  int rv;
+  // On Android M and newer releases use supported NDK API. On Android L use
+  // setNetworkForSocket from libnetd_client.so.
+  if (base::android::BuildInfo::GetInstance()->sdk_int() >=
+      base::android::SDK_VERSION_MARSHMALLOW) {
+    // See declaration of android_setsocknetwork() here:
+    // http://androidxref.com/6.0.0_r1/xref/development/ndk/platforms/android-M/include/android/multinetwork.h#65
+    // Function cannot be called directly as it will cause app to fail to load
+    // on pre-marshmallow devices.
+    typedef int (*MarshmallowSetNetworkForSocket)(int64_t netId, int socketFd);
+    static MarshmallowSetNetworkForSocket marshmallowSetNetworkForSocket;
+    // This is racy, but all racers should come out with the same answer so it

[xunjieli, 2016/07/20 17:55:49]

One last question: why is this racy? If all socket connects happen on the
network thread, isn't this single threaded?

[pauljensen, 2016/07/20 18:02:16]

There are multiple network threads but only one static value being read and
written here.

[xunjieli, 2016/07/20 18:08:03]

Ah, i see. I always forget Cronet can have multiple network threads. 

+    // shouldn't matter.
+    if (!marshmallowSetNetworkForSocket) {
+      base::FilePath file(base::GetNativeLibraryName("android"));
+      void* dl = dlopen(file.value().c_str(), RTLD_NOW);
+      marshmallowSetNetworkForSocket =
+          reinterpret_cast<MarshmallowSetNetworkForSocket>(
+              dlsym(dl, "android_setsocknetwork"));
+    }
+    if (!marshmallowSetNetworkForSocket)
+      return ERR_NOT_IMPLEMENTED;
+    rv = marshmallowSetNetworkForSocket(network, socket_);
+    if (rv)
+      rv = errno;
+  } else {
+    // NOTE(pauljensen): This does rely on Android implementation details, but
+    // they won't change because Lollipop is already released.
+    typedef int (*LollipopSetNetworkForSocket)(unsigned netId, int socketFd);
+    static LollipopSetNetworkForSocket lollipopSetNetworkForSocket;
+    // This is racy, but all racers should come out with the same answer so it
+    // shouldn't matter.
+    if (!lollipopSetNetworkForSocket) {
+      // Android's netd client library should always be loaded in our address
+      // space as it shims socket() which was used to create |socket_|.
+      base::FilePath file(base::GetNativeLibraryName("netd_client"));
+      // Use RTLD_NOW to match Android's prior loading of the library:
+      // http://androidxref.com/6.0.0_r5/xref/bionic/libc/bionic/NetdClient.cpp#37
+      // Use RTLD_NOLOAD to assert that the library is already loaded and
+      // avoid doing any disk IO.
+      void* dl = dlopen(file.value().c_str(), RTLD_NOW | RTLD_NOLOAD);
+      lollipopSetNetworkForSocket =
+          reinterpret_cast<LollipopSetNetworkForSocket>(
+              dlsym(dl, "setNetworkForSocket"));
+    }
+    if (!lollipopSetNetworkForSocket)
+      return ERR_NOT_IMPLEMENTED;
+    rv = -lollipopSetNetworkForSocket(network, socket_);
   }
-  if (!setNetworkForSocket)
-    return ERR_NOT_IMPLEMENTED;
-  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;
   if (rv == 0)
     bound_network_ = network;
   return MapSystemError(rv);
 #else
   NOTIMPLEMENTED();
@@ skipping 433 matching lines @@
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketPosix::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net