Add a new NetworkActivityMonitor to track network activity

net/base/network_activity_monitor_unittest.cc

Index: net/base/network_activity_monitor_unittest.cc
diff --git a/net/base/network_activity_monitor_unittest.cc b/net/base/network_activity_monitor_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4ffeffca911dcf1a5756e1e1c9f1651724a687fe
--- /dev/null
+++ b/net/base/network_activity_monitor_unittest.cc
@@ -0,0 +1,117 @@
+// 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 void ResetMonitor() {
+    NetworkActivityMonitor* monitor = NetworkActivityMonitor::GetInstance();
+    monitor->bytes_sent_ = 0;

[eroman, 2014/11/14 20:57:04]

It might be possible for TSAN to bark about this, since bytes_sent_ etc are
accessed later from another thread. I suggest acquiring the lock to avoid any
testing noise.

[Ryan Hamilton, 2014/11/14 22:18:17]

Done.

+    monitor->bytes_received_ = 0;
+    monitor->last_received_ticks_ = base::TimeTicks();
+    monitor->last_write_ticks_ = base::TimeTicks();
+  }
+};
+
+class NetworkActivityMontiorTest : public testing::Test {
+ public:
+  NetworkActivityMontiorTest()
+      : monitor_(NetworkActivityMonitor::GetInstance()) {
+    NetworkActivityMonitorPeer::ResetMonitor();
+  }
+  NetworkActivityMonitor* monitor_;
+};
+
+TEST_F(NetworkActivityMontiorTest, GetInstance) {
+  NetworkActivityMonitor* monitor = NetworkActivityMonitor::GetInstance();
+  EXPECT_TRUE(monitor != NULL);
+  EXPECT_TRUE(monitor == NetworkActivityMonitor::GetInstance());
+}
+
+TEST_F(NetworkActivityMontiorTest, BytesReceived) {
+  base::TimeTicks start = base::TimeTicks::Now();
+  EXPECT_EQ(0u, monitor_->GetBytesReceived());
+  uint64_t 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_F(NetworkActivityMontiorTest, BytesSent) {
+  base::TimeTicks start = base::TimeTicks::Now();
+  EXPECT_EQ(0u, monitor_->GetBytesSent());
+  uint64_t bytes = 12345;
+  monitor_->IncrementBytesSent(bytes);
+  EXPECT_EQ(bytes, monitor_->GetBytesSent());
+  base::TimeDelta delta = monitor_->GetTimeSinceLastSent();
+  EXPECT_LE(base::TimeDelta(), delta);
+  EXPECT_GE(base::TimeTicks::Now() - start, delta);
+}
+
+class Verifier {
+ public:
+  void VerifyBytesReceivedIsMultipleOf(NetworkActivityMonitor* monitor,
+                                       uint64_t bytes) {
+    EXPECT_EQ(0u, monitor->GetBytesReceived() % bytes);
+  }
+
+  void VerifyBytesSentIsMultipleOf(NetworkActivityMonitor* monitor,
+                                   uint64_t bytes) {
+    EXPECT_EQ(0u, monitor->GetBytesSent() % bytes);
+  }
+};
+
+TEST_F(NetworkActivityMontiorTest, Threading) {
+  base::Thread* threads[3];
+  for (size_t i = 0; i < arraysize(threads); ++i) {
+    threads[i] = new base::Thread(base::UintToString(i));
+    threads[i]->Start();

[eroman, 2014/11/14 20:57:04]

nit: I suggest wrapping this inside an ASSERT_TRUE()

(I have seen these failures in the wild on Windows, but usually because of third
party malware exceeding max number of handles/threads).

[Ryan Hamilton, 2014/11/14 22:18:17]

Done.

+  }
+
+  Verifier verifier;
+
+  size_t num_increments = 157;

[eroman, 2014/11/14 20:57:04]

Fancy... i like it!

[Ryan Hamilton, 2014/11/14 22:18:17]

Thanks!

+  uint64_t bytes_received = 7294954321u;

[eroman, 2014/11/14 20:57:04]

[no action necessary] Strictly speaking you probably want ull, but "u" should be
sufficient to avoid the compiler truncation warning :)

[Ryan Hamilton, 2014/11/14 22:18:17]

Oh! Thanks for the reminder. I actually need to use GG_UINT64_C() because ...
compilers.  (We have this problem all the time in QUIC tests since we use lots
of uint64s)

+  uint64_t bytes_sent = 91294998765u;
+  for (size_t i = 0; i < num_increments; ++i) {
+    threads[i % arraysize(threads)]->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&NetworkActivityMonitor::IncrementBytesReceived,
+                              base::Unretained(monitor_), bytes_received));
+    threads[i % arraysize(threads)]->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&NetworkActivityMonitor::IncrementBytesSent,
+                              base::Unretained(monitor_), bytes_sent));
+    threads[i % arraysize(threads)]->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&Verifier::VerifyBytesSentIsMultipleOf,

[eroman, 2014/11/14 20:57:04]

The Verifier class feels it could just be static methods (no instance variables
are used).


And then this becomes:
  base::Bind(&VerifyBytesSentIsMultipleOf, monitor_, bytes_sent)

Without the need for Unretained.

Also, I would encourage not passing monitor_ and retrieving the singleton inside
the verifier function. This has the benefit of making sure (by way of TSAN) that
retrieving the singleton across threads is safe too.

[Ryan Hamilton, 2014/11/14 22:18:17]

AH! For some reason I forgot that this as an option. Done!
Good idea.

+                   base::Unretained(&verifier), monitor_, bytes_sent));
+    threads[i % arraysize(threads)]->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&Verifier::VerifyBytesReceivedIsMultipleOf,
+                   base::Unretained(&verifier), monitor_, bytes_received));
+  }
+
+  for (size_t i = 0; i < arraysize(threads); ++i) {
+    threads[i]->Stop();

[eroman, 2014/11/14 20:57:04]

Calling Stop() is not necessary, the dtor handles it. (In fact there is
weirdness with thread subclasses specifically so they can handle this case!)

[Ryan Hamilton, 2014/11/14 22:18:17]

Done.

+    delete threads[i];

[eroman, 2014/11/14 20:57:04]

[optional] If you wanted to be fancy, could use STLDeleteContainerPointers()
instead of looping.

Meh, probably lame. I guess if you went that route should just make the array a
std::vector<> and then call STLDeleteElements(&threads). Whatever

[Ryan Hamilton, 2014/11/14 22:18:17]

I like it! Done.

+  }
+
+  EXPECT_EQ(num_increments * bytes_received, monitor_->GetBytesReceived());
+  EXPECT_EQ(num_increments * bytes_sent, monitor_->GetBytesSent());

[eroman, 2014/11/14 20:57:04]

Overall I like this test, thanks!

[Ryan Hamilton, 2014/11/14 22:18:17]

Thank you very much for encouraging me to write it. It's definitely much better
than what I had previously.

+}
+
+}  // namespace test
+
+}  // namespace net