Fixing logic for using android_setsocknetwork() with bind().

webrtc/sdk/android/src/jni/androidnetworkmonitor_jni.cc

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 219 matching lines @@
       GetMethodID(jni(), *j_network_monitor_class_, "stopMonitoring", "(J)V");
   jni()->CallVoidMethod(*j_network_monitor_, m, jlongFromPointer(this));
   CHECK_EXCEPTION(jni()) << "Error during NetworkMonitor.stopMonitoring";
 
   network_handle_by_address_.clear();
   network_info_by_handle_.clear();
 }
 
 // The implementation is largely taken from UDPSocketPosix::BindToNetwork in
 // https://cs.chromium.org/chromium/src/net/udp/udp_socket_posix.cc
-int AndroidNetworkMonitor::BindSocketToNetwork(int socket_fd,
-                                               const rtc::IPAddress& address) {
+rtc::NetworkBindingResult AndroidNetworkMonitor::BindSocketToNetwork(
+    int socket_fd,
+    const rtc::IPAddress& address) {
   RTC_CHECK(thread_checker_.CalledOnValidThread());
   // Android prior to Lollipop didn't have support for binding sockets to
   // networks. In that case it should not have reached here because
   // |network_handle_by_address_| is only populated in Android Lollipop
   // and above.
   if (android_sdk_int_ < SDK_VERSION_LOLLIPOP) {
     LOG(LS_ERROR) << "BindSocketToNetwork is not supported in Android SDK "
                   << android_sdk_int_;
-    return rtc::NETWORK_BIND_NOT_IMPLEMENTED;
+    return rtc::NetworkBindingResult::NOT_IMPLEMENTED;
   }
 
   auto iter = network_handle_by_address_.find(address);
   if (iter == network_handle_by_address_.end()) {
-    return rtc::NETWORK_BIND_ADDRESS_NOT_FOUND;
+    return rtc::NetworkBindingResult::ADDRESS_NOT_FOUND;
   }
   NetworkHandle network_handle = iter->second;
 
   int rv = 0;
   if (android_sdk_int_ >= 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)(NetworkHandle net,
                                                   int socket);
     static MarshmallowSetNetworkForSocket marshmallowSetNetworkForSocket;
     // This is not thread-safe, but we are running this only on the worker
     // thread.
     if (!marshmallowSetNetworkForSocket) {
       const std::string android_native_lib_path = "libandroid.so";
       void* lib = dlopen(android_native_lib_path.c_str(), RTLD_NOW);
       if (lib == nullptr) {
         LOG(LS_ERROR) << "Library " << android_native_lib_path << " not found!";
-        return rtc::NETWORK_BIND_NOT_IMPLEMENTED;
+        return rtc::NetworkBindingResult::NOT_IMPLEMENTED;
       }
       marshmallowSetNetworkForSocket =
           reinterpret_cast<MarshmallowSetNetworkForSocket>(
               dlsym(lib, "android_setsocknetwork"));
     }
     if (!marshmallowSetNetworkForSocket) {
       LOG(LS_ERROR) << "Symbol marshmallowSetNetworkForSocket is not found";
-      return rtc::NETWORK_BIND_NOT_IMPLEMENTED;
+      return rtc::NetworkBindingResult::NOT_IMPLEMENTED;
     }
     rv = marshmallowSetNetworkForSocket(network_handle, socket_fd);
   } else {
     // NOTE: This relies on Android implementation details, but it won't change
     // because Lollipop is already released.
     typedef int (*LollipopSetNetworkForSocket)(unsigned net, int socket);
     static LollipopSetNetworkForSocket lollipopSetNetworkForSocket;
     // This is not threadsafe, but we are running this only on the worker
     // thread.
     if (!lollipopSetNetworkForSocket) {
       // Android's netd client library should always be loaded in our address
       // space as it shims libc functions like connect().
       const std::string net_library_path = "libnetd_client.so";
       // 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* lib = dlopen(net_library_path.c_str(), RTLD_NOW | RTLD_NOLOAD);
       if (lib == nullptr) {
         LOG(LS_ERROR) << "Library " << net_library_path << " not found!";
-        return rtc::NETWORK_BIND_NOT_IMPLEMENTED;
+        return rtc::NetworkBindingResult::NOT_IMPLEMENTED;
       }
       lollipopSetNetworkForSocket =
           reinterpret_cast<LollipopSetNetworkForSocket>(
               dlsym(lib, "setNetworkForSocket"));
     }
     if (!lollipopSetNetworkForSocket) {
       LOG(LS_ERROR) << "Symbol lollipopSetNetworkForSocket is not found ";
-      return rtc::NETWORK_BIND_NOT_IMPLEMENTED;
+      return rtc::NetworkBindingResult::NOT_IMPLEMENTED;
     }
     rv = lollipopSetNetworkForSocket(network_handle, socket_fd);
   }
 
   // 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 == 0) {
-    return rtc::NETWORK_BIND_SUCCESS;
+    return rtc::NetworkBindingResult::SUCCESS;
   }
   if (rv == ENONET) {
-    return rtc::NETWORK_BIND_NETWORK_CHANGED;
+    return rtc::NetworkBindingResult::NETWORK_CHANGED;
   }
-  return rtc::NETWORK_BIND_FAILURE;
+  return rtc::NetworkBindingResult::FAILURE;
 }
 
 void AndroidNetworkMonitor::OnNetworkConnected(
     const NetworkInformation& network_info) {
   worker_thread()->Invoke<void>(
       RTC_FROM_HERE, rtc::Bind(&AndroidNetworkMonitor::OnNetworkConnected_w,
                                this, network_info));
   // Fire SignalNetworksChanged to update the list of networks.
   OnNetworksChanged();
 }
@@ skipping 90 matching lines @@
 JOW(void, NetworkMonitor_nativeNotifyOfNetworkDisconnect)(
     JNIEnv* jni, jobject j_monitor, jlong j_native_monitor,
     jlong network_handle) {
   AndroidNetworkMonitor* network_monitor =
       reinterpret_cast<AndroidNetworkMonitor*>(j_native_monitor);
   network_monitor->OnNetworkDisconnected(
       static_cast<NetworkHandle>(network_handle));
 }
 
 }  // namespace webrtc_jni