Add a new NetworkActivityMonitor to track network activity

net/base/network_activity_monitor_unittest.cc

+// Copyright (c) 2014 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/network_activity_monitor.h"
+
+#include "base/bind.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/threading/thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace test {
+
+class NetworkActivityMonitorPeer {
+ public:
+  static NetworkActivityMonitor* CreateMonitor() {
+    return new NetworkActivityMonitor();
+  }
+};
+
+TEST(NetworkActivityMontiorTest, GetInstance) {
+  NetworkActivityMonitor* monitor = NetworkActivityMonitor::GetInstance();
+  EXPECT_TRUE(monitor != NULL);
+  EXPECT_TRUE(monitor == NetworkActivityMonitor::GetInstance());
+}
+
+TEST(NetworkActivityMontiorTest, BytesReceived) {
+  base::TimeTicks start = base::TimeTicks::Now();
+  NetworkActivityMonitor* monitor = NetworkActivityMonitorPeer::CreateMonitor();

[eroman, 2014/11/14 00:06:16]

Looks like |monitor| is leaked in these tests.

Perhaps a scoped_ptr<>

[Ryan Hamilton, 2014/11/14 00:32:29]

I fixed the leak, but since the monitor has a private destructor I ended up not
being able to use a scoped_ptr and instead added a method to the peer. Work for
you?

Alternatively, I could make the Peer a subclass of Monitor and use that in the
tests in a scoped_ptr. That might be cleaner?

[eroman, 2014/11/14 00:46:13]

Or instead you could add some :
  ResetStateForTest() 

private method which rests counters to zero.

You could use a test fixture, which resets as part of the setup, so it now
predictably starts at zero.

This has the advantage of being able to test through the singleton interface.
the only read disadvantage is it means the tests can't be run in parallel, but
that is true of many of our tests anyway.

[Ryan Hamilton, 2014/11/14 16:51:57]

I considered that, but my general fear of using statics/singletons in tests
scared me away. It also means that I would not be able to test that the
bytes_sent and bytes_received default to 0. 

That being said, I've uploaded a patch with this change. If it seems better to
you, I'm happy.

+  EXPECT_EQ(0u, monitor->GetBytesReceived());
+  uint64 bytes = 12345;
+  monitor->IncrementBytesReceived(bytes);
+  EXPECT_EQ(bytes, monitor->GetBytesReceived());
+  base::TimeDelta delta = monitor->GetTimeSinceLastReceived();
+  EXPECT_LE(base::TimeDelta(), delta);
+  EXPECT_GE(base::TimeTicks::Now() - start, delta);
+}
+
+TEST(NetworkActivityMontiorTest, BytesWritten) {
+  base::TimeTicks start = base::TimeTicks::Now();
+  NetworkActivityMonitor* monitor = NetworkActivityMonitorPeer::CreateMonitor();
+  EXPECT_EQ(0u, monitor->GetBytesWritten());
+  uint64 bytes = 12345;

[eroman, 2014/11/14 00:06:16]

for funzies you could use a value larger than (2^32 - 1), to make sure it really
is 64-bits.

[Ryan Hamilton, 2014/11/14 00:32:29]

Done.

+  monitor->IncrementBytesWritten(bytes);
+  EXPECT_EQ(bytes, monitor->GetBytesWritten());
+  base::TimeDelta delta = monitor->GetTimeSinceLastWrite();
+  EXPECT_LE(base::TimeDelta(), delta);
+  EXPECT_GE(base::TimeTicks::Now() - start, delta);
+}
+
+class Verifier {
+ public:
+  void VerifyBytesReceivedIsMultipleOf(NetworkActivityMonitor* monitor,
+                                   uint64 bytes) {

[eroman, 2014/11/14 00:06:16]

indentation.

suggest running "git cl format" for auto-awesome.

[Ryan Hamilton, 2014/11/14 00:32:29]

Done.

+    EXPECT_EQ(0u, monitor->GetBytesReceived() % bytes);
+  }
+
+  void VerifyBytesWrittenIsMultipleOf(NetworkActivityMonitor* monitor,
+                                   uint64 bytes) {

[eroman, 2014/11/14 00:06:16]

ditto

[Ryan Hamilton, 2014/11/14 00:32:29]

Done.

+    EXPECT_EQ(0u, monitor->GetBytesWritten() % bytes);
+  }
+};
+
+TEST(NetworkActivityMontiorTest, Threading) {
+  NetworkActivityMonitor* monitor = NetworkActivityMonitorPeer::CreateMonitor();
+  base::Thread* threceiveds[3];

[eroman, 2014/11/14 00:06:16]

more german.

[Ryan Hamilton, 2014/11/14 00:32:29]

Done.

+  for (size_t i = 0; i < arraysize(threceiveds); ++i) {
+    threceiveds[i] = new base::Thread(base::UintToString(i));
+    threceiveds[i]->Start();
+  }
+
+  Verifier verifier;
+
+  size_t num_increments = 157;
+  uint64 bytes_received = 12345u;
+  uint64 bytes_written = 78954u;
+  for (size_t i = 0; i < num_increments; ++i) {
+    threceiveds[i % arraysize(threceiveds)]->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&NetworkActivityMonitor::IncrementBytesReceived,
+                   base::Unretained(monitor),
+                   bytes_received));
+    threceiveds[i % arraysize(threceiveds)]->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&NetworkActivityMonitor::IncrementBytesWritten,
+                   base::Unretained(monitor),
+                   bytes_written));
+    threceiveds[i % arraysize(threceiveds)]->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&Verifier::VerifyBytesWrittenIsMultipleOf,
+                   base::Unretained(&verifier),
+                   monitor,
+                   bytes_written));
+    threceiveds[i % arraysize(threceiveds)]->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&Verifier::VerifyBytesReceivedIsMultipleOf,
+                   base::Unretained(&verifier),
+                   monitor,
+                   bytes_received));
+  }
+
+  for (size_t i = 0; i < arraysize(threceiveds); ++i) {
+    threceiveds[i]->Stop();

[eroman, 2014/11/14 00:06:17]

have you tried not leaking thereceiveds ?
;)

[Ryan Hamilton, 2014/11/14 00:32:29]

leaking threads! leaking monitors. Leak all the things!

Done. Thanks!

+  }
+
+  EXPECT_EQ(num_increments * bytes_received, monitor->GetBytesReceived());
+  EXPECT_EQ(num_increments * bytes_written, monitor->GetBytesWritten());
+}
+
+}  // namespace test
+
+}  // namespace net