Adding non-tracking mode support to AddressTracker.

net/base/address_tracker_linux_unittest.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 "base/memory/scoped_ptr.h"
 #include "net/base/address_tracker_linux.h"
 
 #include <linux/if.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #ifndef IFA_F_HOMEADDRESS
@@ skipping 11 matching lines @@
     return "tun0";
   return "eth0";
 }
 
 }  // namespace
 
 typedef std::vector<char> Buffer;
 
 class AddressTrackerLinuxTest : public testing::Test {
  protected:
-  AddressTrackerLinuxTest()
-      : tracker_(base::Bind(&base::DoNothing),
-                 base::Bind(&base::DoNothing),
-                 base::Bind(&base::DoNothing)),
-        original_get_interface_name_(tracker_.get_interface_name_) {
-    tracker_.get_interface_name_ = TestGetInterfaceName;
+  AddressTrackerLinuxTest() {}
+
+  void InitializeAddressTracker(bool tracking) {
+    if (tracking) {
+      tracker_.reset(new AddressTrackerLinux(base::Bind(&base::DoNothing),
+                                             base::Bind(&base::DoNothing),
+                                             base::Bind(&base::DoNothing)));
+    } else {
+      tracker_.reset(new AddressTrackerLinux());
+    }
+    original_get_interface_name_ = tracker_->get_interface_name_;
+    tracker_->get_interface_name_ = TestGetInterfaceName;
   }
 
   bool HandleAddressMessage(const Buffer& buf) {
     Buffer writable_buf = buf;
     bool address_changed = false;
     bool link_changed = false;
     bool tunnel_changed = false;
-    tracker_.HandleMessage(&writable_buf[0], buf.size(),
+    tracker_->HandleMessage(&writable_buf[0], buf.size(),
                            &address_changed, &link_changed, &tunnel_changed);
     EXPECT_FALSE(link_changed);
     return address_changed;
   }
 
   bool HandleLinkMessage(const Buffer& buf) {
     Buffer writable_buf = buf;
     bool address_changed = false;
     bool link_changed = false;
     bool tunnel_changed = false;
-    tracker_.HandleMessage(&writable_buf[0], buf.size(),
+    tracker_->HandleMessage(&writable_buf[0], buf.size(),
                            &address_changed, &link_changed, &tunnel_changed);
     EXPECT_FALSE(address_changed);
     return link_changed;
   }
 
   bool HandleTunnelMessage(const Buffer& buf) {
     Buffer writable_buf = buf;
     bool address_changed = false;
     bool link_changed = false;
     bool tunnel_changed = false;
-    tracker_.HandleMessage(&writable_buf[0], buf.size(),
+    tracker_->HandleMessage(&writable_buf[0], buf.size(),
                            &address_changed, &link_changed, &tunnel_changed);
     EXPECT_FALSE(address_changed);
     return tunnel_changed;
   }
 
   AddressTrackerLinux::AddressMap GetAddressMap() {
-    return tracker_.GetAddressMap();
+    return tracker_->GetAddressMap();
   }
 
-  const base::hash_set<int>* GetOnlineLinks() const {
-    return &tracker_.online_links_;
+  const base::hash_set<int> GetOnlineLinks() const {
+    return tracker_->GetOnlineLinks();
   }
 
-  AddressTrackerLinux tracker_;
+  scoped_ptr<AddressTrackerLinux> tracker_;
   AddressTrackerLinux::GetInterfaceNameFunction original_get_interface_name_;
 };
 
 namespace {
 
 class NetlinkMessage {
  public:
   explicit NetlinkMessage(uint16 type) : buffer_(NLMSG_HDRLEN) {
     header()->nlmsg_type = type;
     Align();
@@ skipping 87 matching lines @@
   nlmsg.AppendTo(output);
 }
 
 const unsigned char kAddress0[] = { 127, 0, 0, 1 };
 const unsigned char kAddress1[] = { 10, 0, 0, 1 };
 const unsigned char kAddress2[] = { 192, 168, 0, 1 };
 const unsigned char kAddress3[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                     0, 0, 0, 1 };
 
 TEST_F(AddressTrackerLinuxTest, NewAddress) {
+  InitializeAddressTracker(true);
+
   const IPAddressNumber kEmpty;
   const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
   const IPAddressNumber kAddr1(kAddress1, kAddress1 + arraysize(kAddress1));
   const IPAddressNumber kAddr2(kAddress2, kAddress2 + arraysize(kAddress2));
   const IPAddressNumber kAddr3(kAddress3, kAddress3 + arraysize(kAddress3));
 
   Buffer buffer;
   MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty,
                   &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
@@ skipping 14 matching lines @@
 
   buffer.clear();
   MakeAddrMessage(RTM_NEWADDR, 0, AF_INET6, kEmpty, kAddr3, &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   map = GetAddressMap();
   EXPECT_EQ(3u, map.size());
   EXPECT_EQ(1u, map.count(kAddr3));
 }
 
 TEST_F(AddressTrackerLinuxTest, NewAddressChange) {
+  InitializeAddressTracker(true);
+
   const IPAddressNumber kEmpty;
   const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
 
   Buffer buffer;
   MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty,
                   &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   AddressTrackerLinux::AddressMap map = GetAddressMap();
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(1u, map.count(kAddr0));
@@ skipping 14 matching lines @@
                   &buffer);
   MakeAddrMessage(RTM_NEWADDR, IFA_F_HOMEADDRESS, AF_INET, kAddr0, kEmpty,
                   &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   map = GetAddressMap();
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(IFA_F_HOMEADDRESS, map[kAddr0].ifa_flags);
 }
 
 TEST_F(AddressTrackerLinuxTest, NewAddressDuplicate) {
+  InitializeAddressTracker(true);
+
   const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
 
   Buffer buffer;
   MakeAddrMessage(RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kAddr0,
                   &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   AddressTrackerLinux::AddressMap map = GetAddressMap();
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(1u, map.count(kAddr0));
   EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
 
   EXPECT_FALSE(HandleAddressMessage(buffer));
   map = GetAddressMap();
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
 }
 
 TEST_F(AddressTrackerLinuxTest, DeleteAddress) {
+  InitializeAddressTracker(true);
+
   const IPAddressNumber kEmpty;
   const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
   const IPAddressNumber kAddr1(kAddress1, kAddress1 + arraysize(kAddress1));
   const IPAddressNumber kAddr2(kAddress2, kAddress2 + arraysize(kAddress2));
 
   Buffer buffer;
   MakeAddrMessage(RTM_NEWADDR, 0, AF_INET, kAddr0, kEmpty, &buffer);
   MakeAddrMessage(RTM_NEWADDR, 0, AF_INET, kAddr1, kAddr2, &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   AddressTrackerLinux::AddressMap map = GetAddressMap();
@@ skipping 15 matching lines @@
   EXPECT_EQ(1u, map.size());
 
   buffer.clear();
   MakeAddrMessage(RTM_DELADDR, 0, AF_INET, kAddr2, kEmpty, &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   map = GetAddressMap();
   EXPECT_EQ(0u, map.size());
 }
 
 TEST_F(AddressTrackerLinuxTest, DeprecatedLifetime) {
+  InitializeAddressTracker(true);
+
   const IPAddressNumber kEmpty;
   const IPAddressNumber kAddr3(kAddress3, kAddress3 + arraysize(kAddress3));
 
   Buffer buffer;
   MakeAddrMessage(RTM_NEWADDR, 0, AF_INET6, kEmpty, kAddr3, &buffer);
   EXPECT_TRUE(HandleAddressMessage(buffer));
   AddressTrackerLinux::AddressMap map = GetAddressMap();
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(1u, map.count(kAddr3));
   EXPECT_EQ(0, map[kAddr3].ifa_flags);
@@ skipping 20 matching lines @@
   buffer.clear();
   MakeAddrMessageWithCacheInfo(RTM_NEWADDR, 0, AF_INET6, kEmpty, kAddr3, 0,
                                &buffer);
   EXPECT_FALSE(HandleAddressMessage(buffer));
   map = GetAddressMap();
   EXPECT_EQ(1u, map.size());
   EXPECT_EQ(IFA_F_DEPRECATED, map[kAddr3].ifa_flags);
 }
 
 TEST_F(AddressTrackerLinuxTest, IgnoredMessage) {
+  InitializeAddressTracker(true);
+
   const IPAddressNumber kEmpty;
   const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
   const IPAddressNumber kAddr3(kAddress3, kAddress3 + arraysize(kAddress3));
 
   Buffer buffer;
   // Ignored family.
   MakeAddrMessage(RTM_NEWADDR, 0, AF_UNSPEC, kAddr3, kAddr0, &buffer);
   // No address.
   MakeAddrMessage(RTM_NEWADDR, 0, AF_INET, kEmpty, kEmpty, &buffer);
   // Ignored type.
@@ skipping 10 matching lines @@
   struct ifa_cacheinfo cache_info = {};
   nlmsg.AddAttribute(IFA_CACHEINFO, &cache_info, sizeof(cache_info));
   nlmsg.AddAttribute(IFA_ADDRESS, &kAddr0[0], kAddr0.size());
   nlmsg.AppendTo(&buffer);
 
   EXPECT_TRUE(HandleAddressMessage(buffer));
   EXPECT_EQ(1u, GetAddressMap().size());
 }
 
 TEST_F(AddressTrackerLinuxTest, AddInterface) {
+  InitializeAddressTracker(true);
+
   Buffer buffer;
 
   // Ignores loopback.
   MakeLinkMessage(RTM_NEWLINK,
                   IFF_LOOPBACK | IFF_UP | IFF_LOWER_UP | IFF_RUNNING,
                   0, &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
-  EXPECT_TRUE(GetOnlineLinks()->empty());
+  EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Ignores not IFF_LOWER_UP.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
-  EXPECT_TRUE(GetOnlineLinks()->empty());
+  EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Ignores deletion.
   MakeLinkMessage(RTM_DELLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
-  EXPECT_TRUE(GetOnlineLinks()->empty());
+  EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Verify success.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_TRUE(HandleLinkMessage(buffer));
-  EXPECT_EQ(1u, GetOnlineLinks()->count(0));
-  EXPECT_EQ(1u, GetOnlineLinks()->size());
+  EXPECT_EQ(1u, GetOnlineLinks().count(0));
+  EXPECT_EQ(1u, GetOnlineLinks().size());
 
   // Ignores redundant enables.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
-  EXPECT_EQ(1u, GetOnlineLinks()->count(0));
-  EXPECT_EQ(1u, GetOnlineLinks()->size());
+  EXPECT_EQ(1u, GetOnlineLinks().count(0));
+  EXPECT_EQ(1u, GetOnlineLinks().size());
 
   // Verify adding another online device (e.g. VPN) is considered a change.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 1, &buffer);
   EXPECT_TRUE(HandleLinkMessage(buffer));
-  EXPECT_EQ(1u, GetOnlineLinks()->count(0));
-  EXPECT_EQ(1u, GetOnlineLinks()->count(1));
-  EXPECT_EQ(2u, GetOnlineLinks()->size());
+  EXPECT_EQ(1u, GetOnlineLinks().count(0));
+  EXPECT_EQ(1u, GetOnlineLinks().count(1));
+  EXPECT_EQ(2u, GetOnlineLinks().size());
 }
 
 TEST_F(AddressTrackerLinuxTest, RemoveInterface) {
+  InitializeAddressTracker(true);
+
   Buffer buffer;
 
   // Should disappear when not IFF_LOWER_UP.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_TRUE(HandleLinkMessage(buffer));
-  EXPECT_FALSE(GetOnlineLinks()->empty());
+  EXPECT_FALSE(GetOnlineLinks().empty());
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_TRUE(HandleLinkMessage(buffer));
-  EXPECT_TRUE(GetOnlineLinks()->empty());
+  EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Ignores redundant disables.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
-  EXPECT_TRUE(GetOnlineLinks()->empty());
+  EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Ignores deleting down interfaces.
   MakeLinkMessage(RTM_DELLINK, IFF_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_FALSE(HandleLinkMessage(buffer));
-  EXPECT_TRUE(GetOnlineLinks()->empty());
+  EXPECT_TRUE(GetOnlineLinks().empty());
 
   // Should disappear when deleted.
   MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_TRUE(HandleLinkMessage(buffer));
-  EXPECT_FALSE(GetOnlineLinks()->empty());
+  EXPECT_FALSE(GetOnlineLinks().empty());
   MakeLinkMessage(RTM_DELLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
   EXPECT_TRUE(HandleLinkMessage(buffer));
-  EXPECT_TRUE(GetOnlineLinks()->empty());
+  EXPECT_TRUE(GetOnlineLinks().empty());
 }
 
 TEST_F(AddressTrackerLinuxTest, TunnelInterface) {
+  InitializeAddressTracker(true);
+
   Buffer buffer;
 
   // Ignores without "tun" prefixed name.
   MakeLinkMessage(RTM_NEWLINK,
                   IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
                   0, &buffer);
   EXPECT_FALSE(HandleTunnelMessage(buffer));
 
   // Verify success.
   MakeLinkMessage(RTM_NEWLINK,
@@ skipping 22 matching lines @@
   // Ignores redundant deletions.
   MakeLinkMessage(RTM_DELLINK,
                   IFF_UP | IFF_LOWER_UP | IFF_RUNNING | IFF_POINTOPOINT,
                   kTestInterfaceTun, &buffer);
   EXPECT_FALSE(HandleTunnelMessage(buffer));
 }
 
 // Check AddressTrackerLinux::get_interface_name_ original implementation
 // doesn't crash or return NULL.
 TEST_F(AddressTrackerLinuxTest, GetInterfaceName) {
+  InitializeAddressTracker(true);
+
   for (int i = 0; i < 10; i++)
     EXPECT_NE((const char*)NULL, original_get_interface_name_(i));
 }
 
+TEST_F(AddressTrackerLinuxTest, NonTrackingMode) {
+  InitializeAddressTracker(false);
+
+  const IPAddressNumber kEmpty;
+  const IPAddressNumber kAddr0(kAddress0, kAddress0 + arraysize(kAddress0));
+
+  Buffer buffer;
+  MakeAddrMessage(
+      RTM_NEWADDR, IFA_F_TEMPORARY, AF_INET, kAddr0, kEmpty, &buffer);
+  EXPECT_TRUE(HandleAddressMessage(buffer));
+  AddressTrackerLinux::AddressMap map = GetAddressMap();
+  EXPECT_EQ(1u, map.size());
+  EXPECT_EQ(1u, map.count(kAddr0));
+  EXPECT_EQ(IFA_F_TEMPORARY, map[kAddr0].ifa_flags);
+
+  MakeLinkMessage(RTM_NEWLINK, IFF_UP | IFF_LOWER_UP | IFF_RUNNING, 0, &buffer);
+  EXPECT_TRUE(HandleLinkMessage(buffer));
+  EXPECT_EQ(1u, GetOnlineLinks().count(0));
+  EXPECT_EQ(1u, GetOnlineLinks().size());
+}
+
+TEST_F(AddressTrackerLinuxTest, NonTrackingModeInit) {
+  AddressTrackerLinux tracker;
+  tracker.Init();
+}
+
 }  // namespace
 
 }  // namespace internal
 }  // namespace net