diff --git a/talk/base/fakenetwork.h b/talk/base/fakenetwork.h
index 497ff20..3bdc97f 100644
--- a/talk/base/fakenetwork.h
+++ b/talk/base/fakenetwork.h
@@ -109,12 +109,10 @@
         prefix_length = kFakeIPv6NetworkPrefixLength;
       }
       IPAddress prefix = TruncateIP(it->ipaddr(), prefix_length);
-      std::string key = MakeNetworkKey(it->hostname(), prefix, prefix_length);
       scoped_ptr<Network> net(new Network(it->hostname(),
                                           it->hostname(),
                                           prefix,
-                                          prefix_length,
-                                          key));
+                                          prefix_length));
       net->AddIP(it->ipaddr());
       networks.push_back(net.release());
     }
diff --git a/talk/base/network.cc b/talk/base/network.cc
index e3458eb..829507a 100644
--- a/talk/base/network.cc
+++ b/talk/base/network.cc
@@ -112,6 +112,24 @@
   return a->key() > b->key();
 }
 
+std::string AdapterTypeToString(AdapterType type) {
+  switch (type) {
+    case ADAPTER_TYPE_UNKNOWN:
+      return "Unknown";
+    case ADAPTER_TYPE_ETHERNET:
+      return "Ethernet";
+    case ADAPTER_TYPE_WIFI:
+      return "Wifi";
+    case ADAPTER_TYPE_CELLULAR:
+      return "Cellular";
+    case ADAPTER_TYPE_VPN:
+      return "VPN";
+    default:
+      ASSERT(false);
+      return std::string();
+  }
+}
+
 }  // namespace
 
 std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
@@ -292,8 +310,7 @@
       scoped_ptr<Network> network(new Network(cursor->ifa_name,
                                               cursor->ifa_name,
                                               prefix,
-                                              prefix_length,
-                                              key));
+                                              prefix_length));
       network->set_scope_id(scope_id);
       network->AddIP(ip);
       bool ignored = ((cursor->ifa_flags & IFF_LOOPBACK) ||
@@ -439,8 +456,7 @@
           scoped_ptr<Network> network(new Network(name,
                                                   description,
                                                   prefix,
-                                                  prefix_length,
-                                                  key));
+                                                  prefix_length));
           network->set_scope_id(scope_id);
           network->AddIP(ip);
           bool ignore = ((adapter_addrs->IfType == IF_TYPE_SOFTWARE_LOOPBACK) ||
@@ -608,18 +624,19 @@
 }
 
 Network::Network(const std::string& name, const std::string& desc,
-                 const IPAddress& prefix, int prefix_length,
-                 const std::string& key)
+                 const IPAddress& prefix, int prefix_length)
     : name_(name), description_(desc), prefix_(prefix),
-      prefix_length_(prefix_length), key_(key), scope_id_(0), ignored_(false),
-      type_(ADAPTER_TYPE_UNKNOWN), preference_(0) {
+      prefix_length_(prefix_length),
+      key_(MakeNetworkKey(name, prefix, prefix_length)), scope_id_(0),
+      ignored_(false), type_(ADAPTER_TYPE_UNKNOWN), preference_(0) {
 }
 
 Network::Network(const std::string& name, const std::string& desc,
-                 const IPAddress& prefix, int prefix_length)
+                 const IPAddress& prefix, int prefix_length, AdapterType type)
     : name_(name), description_(desc), prefix_(prefix),
-      prefix_length_(prefix_length), scope_id_(0), ignored_(false),
-      type_(ADAPTER_TYPE_UNKNOWN), preference_(0) {
+      prefix_length_(prefix_length),
+      key_(MakeNetworkKey(name, prefix, prefix_length)), scope_id_(0),
+      ignored_(false), type_(type), preference_(0) {
 }
 
 std::string Network::ToString() const {
@@ -627,7 +644,8 @@
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
-     << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_ << "]";
+     << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
+     << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
diff --git a/talk/base/network.h b/talk/base/network.h
index e4ff5f8..2be81bb 100644
--- a/talk/base/network.h
+++ b/talk/base/network.h
@@ -182,15 +182,12 @@
 // Represents a Unix-type network interface, with a name and single address.
 class Network {
  public:
-  Network() : prefix_(INADDR_ANY), scope_id_(0),
-              type_(ADAPTER_TYPE_UNKNOWN) {}
-  Network(const std::string& name, const std::string& description,
-          const IPAddress& prefix, int prefix_length,
-          const std::string& key);
-
   Network(const std::string& name, const std::string& description,
           const IPAddress& prefix, int prefix_length);
 
+  Network(const std::string& name, const std::string& description,
+          const IPAddress& prefix, int prefix_length, AdapterType type);
+
   // Returns the name of the interface this network is associated wtih.
   const std::string& name() const { return name_; }
 
diff --git a/talk/base/network_unittest.cc b/talk/base/network_unittest.cc
index 85aa2f8..56b11c6 100644
--- a/talk/base/network_unittest.cc
+++ b/talk/base/network_unittest.cc
@@ -554,6 +554,24 @@
   EXPECT_TRUE(net1->preference() < net2->preference());
 }
 
+TEST_F(NetworkTest, TestNetworkAdapterTypes) {
+  Network wifi("wlan0", "Wireless Adapter", IPAddress(0x12345600U), 24,
+               ADAPTER_TYPE_WIFI);
+  EXPECT_EQ(ADAPTER_TYPE_WIFI, wifi.type());
+  Network ethernet("eth0", "Ethernet", IPAddress(0x12345600U), 24,
+                   ADAPTER_TYPE_ETHERNET);
+  EXPECT_EQ(ADAPTER_TYPE_ETHERNET, ethernet.type());
+  Network cellular("test_cell", "Cellular Adapter", IPAddress(0x12345600U), 24,
+                   ADAPTER_TYPE_CELLULAR);
+  EXPECT_EQ(ADAPTER_TYPE_CELLULAR, cellular.type());
+  Network vpn("bridge_test", "VPN Adapter", IPAddress(0x12345600U), 24,
+              ADAPTER_TYPE_VPN);
+  EXPECT_EQ(ADAPTER_TYPE_VPN, vpn.type());
+  Network unknown("test", "Test Adapter", IPAddress(0x12345600U), 24,
+                  ADAPTER_TYPE_UNKNOWN);
+  EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, unknown.type());
+}
+
 #if defined(POSIX)
 // Verify that we correctly handle interfaces with no address.
 TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) {