Make NetworkChangeNotifier NetworkHandles readable in NetLog on Android M

net/base/logging_network_change_observer.cc

 // Copyright (c) 2016 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/logging_network_change_observer.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/log/net_log.h"
 
+#if defined(OS_ANDROID)
+#include "base/android/build_info.h"
+#endif
+
 namespace net {
 
 namespace {
 
+// Returns a human readable integer from a NetworkHandle.
+int HumanReadableNetworkHandle(NetworkChangeNotifier::NetworkHandle network) {
+#if defined(OS_ANDROID)
+  // On Marshmallow, demunge the NetID to undo munging done in java

[xunjieli, 2016/08/18 17:15:17]

Could you add a comment here that the NetID's lower 32 bit is 0xfacade? and
include the link that you just gave me?

[pauljensen, 2016/08/19 11:57:47]

Done.

+  // Network.getNetworkHandle().
+  if (base::android::BuildInfo::GetInstance()->sdk_int() >=
+      base::android::SDK_VERSION_MARSHMALLOW) {
+    return network >> 32;
+  }
+#endif
+  return network;
+}
+
 // Return a dictionary of values that provide information about a
 // network-specific change. This also includes relevant current state
 // like the default network, and the types of active networks.
 std::unique_ptr<base::Value> NetworkSpecificNetLogCallback(
     NetworkChangeNotifier::NetworkHandle network,
     NetLogCaptureMode capture_mode) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("changed_network_handle", network);
+  dict->SetInteger("changed_network_handle",
+                   HumanReadableNetworkHandle(network));
   dict->SetString(
       "changed_network_type",
       NetworkChangeNotifier::ConnectionTypeToString(
           NetworkChangeNotifier::GetNetworkConnectionType(network)));
-  dict->SetInteger("default_active_network_handle",
-                   NetworkChangeNotifier::GetDefaultNetwork());
+  dict->SetInteger(
+      "default_active_network_handle",
+      HumanReadableNetworkHandle(NetworkChangeNotifier::GetDefaultNetwork()));
   NetworkChangeNotifier::NetworkList networks;
   NetworkChangeNotifier::GetConnectedNetworks(&networks);
   for (NetworkChangeNotifier::NetworkHandle active_network : networks) {
     dict->SetString(
-        "current_active_networks." + base::IntToString(active_network),
+        "current_active_networks." +
+            base::IntToString(HumanReadableNetworkHandle(active_network)),

[xunjieli, 2016/08/18 16:13:16]

Why does ">>32" make network handle human readable? 

Can we use base::Int64ToString instead and remove the demungling? (since the
handles are 64bits?) 

[pauljensen, 2016/08/18 16:16:49]

">> 32" makes it readable because it undoes the munging of
Network.getNetworkHandle(), " << 32 | 0xfacade":
http://androidxref.com/6.0.1_r10/xref/frameworks/base/core/java/android/net/N...

[xunjieli, 2016/08/18 17:15:16]

Makes sense. I forgot about the 0xfacade part. 

         NetworkChangeNotifier::ConnectionTypeToString(
             NetworkChangeNotifier::GetNetworkConnectionType(active_network)));
   }
   return std::move(dict);
 }
 
 }  // namespace
 
 LoggingNetworkChangeObserver::LoggingNetworkChangeObserver(NetLog* net_log)
     : net_log_(net_log) {
@@ skipping 69 matching lines @@
 
 void LoggingNetworkChangeObserver::OnNetworkMadeDefault(
     NetworkChangeNotifier::NetworkHandle network) {
   VLOG(1) << "Observed network " << network << " made the default network";
 
   net_log_->AddGlobalEntry(NetLog::TYPE_SPECIFIC_NETWORK_MADE_DEFAULT,
                            base::Bind(&NetworkSpecificNetLogCallback, network));
 }
 
 }  // namespace net