plumb network upload into the task manager

chrome/browser/task_manager/providers/browser_process_task_unittest.cc

 // Copyright 2015 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/macros.h"
 #include "chrome/browser/task_manager/providers/browser_process_task_provider.h"
 #include "chrome/browser/task_manager/task_manager_observer.h"
 #include "chrome/grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 58 matching lines @@
 
   EXPECT_EQ(base::GetCurrentProcessHandle(), provided_task_->process_handle());
   EXPECT_EQ(base::GetCurrentProcId(), provided_task_->process_id());
   EXPECT_FALSE(provided_task_->ReportsWebCacheStats());
   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_WEB_BROWSER_CELL_TEXT),
             provided_task_->title());
   EXPECT_EQ(Task::BROWSER, provided_task_->GetType());
   EXPECT_EQ(0, provided_task_->GetChildProcessUniqueID());
   const int received_bytes = 1024;
   EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
-  EXPECT_EQ(-1, provided_task_->network_usage());
+  EXPECT_EQ(-1, provided_task_->network_usage_rate());
+  provided_task_->OnNetworkBytesRead(received_bytes);
+  // Do a refresh with a 1-second update time.
+  provided_task_->Refresh(base::TimeDelta::FromSeconds(1),
+                          REFRESH_TYPE_NETWORK_USAGE);
+}
+
+// Test the provided browser process task itself.
+TEST_F(BrowserProcessTaskProviderTest, NetworkBytesReceived) {
+  BrowserProcessTaskProvider provider;
+  EXPECT_EQ(nullptr, provided_task_);
+  provider.SetObserver(this);
+  ASSERT_NE(nullptr, provided_task_);
+
+  EXPECT_EQ(base::GetCurrentProcessHandle(), provided_task_->process_handle());
+  EXPECT_EQ(base::GetCurrentProcId(), provided_task_->process_id());
+  EXPECT_FALSE(provided_task_->ReportsWebCacheStats());
+  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_WEB_BROWSER_CELL_TEXT),
+            provided_task_->title());
+  EXPECT_EQ(Task::BROWSER, provided_task_->GetType());
+  EXPECT_EQ(0, provided_task_->GetChildProcessUniqueID());
+  const int received_bytes = 1024;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage_rate());
   provided_task_->OnNetworkBytesRead(received_bytes);
   // Do a refresh with a 1-second update time.
   provided_task_->Refresh(base::TimeDelta::FromSeconds(1),
                           REFRESH_TYPE_NETWORK_USAGE);
   EXPECT_TRUE(provided_task_->ReportsNetworkUsage());
-  EXPECT_EQ(received_bytes, provided_task_->network_usage());
+  EXPECT_EQ(received_bytes, provided_task_->network_usage_rate());
+}
+
+// Test the provided browser process task for sent bytes rate
+TEST_F(BrowserProcessTaskProviderTest, NetworkBytesSent) {
+  BrowserProcessTaskProvider provider;
+  provider.SetObserver(this);
+
+  const int sent_bytes = 1024;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage_rate());
+  provided_task_->OnNetworkBytesSent(sent_bytes);
+  // Do a refresh with a 1-second update time.
+  provided_task_->Refresh(base::TimeDelta::FromSeconds(1),
+                          REFRESH_TYPE_NETWORK_USAGE);
+  EXPECT_TRUE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(sent_bytes, provided_task_->network_usage_rate());
+}
+
+// Test the provided browser process task for received then sent bytes rate
+TEST_F(BrowserProcessTaskProviderTest, NetworkBytesReceivedThenSent) {
+  BrowserProcessTaskProvider provider;
+  provider.SetObserver(this);
+
+  const int received_bytes = 1024;
+  const int sent_bytes = 1024;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage_rate());
+  provided_task_->OnNetworkBytesRead(received_bytes);
+  provided_task_->OnNetworkBytesSent(sent_bytes);
+  // Do a refresh with a 1-second update time.
+  provided_task_->Refresh(base::TimeDelta::FromSeconds(1),
+                          REFRESH_TYPE_NETWORK_USAGE);
+  EXPECT_TRUE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(received_bytes + sent_bytes, provided_task_->network_usage_rate());
+}
+
+// Test the provided browser process task for sent then received rate.
+TEST_F(BrowserProcessTaskProviderTest, NetworkBytesSentThenReceived) {
+  BrowserProcessTaskProvider provider;
+  provider.SetObserver(this);
+
+  const int received_bytes = 1024;
+  const int sent_bytes = 1024;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage_rate());
+  provided_task_->OnNetworkBytesSent(sent_bytes);
+  provided_task_->OnNetworkBytesRead(received_bytes);
+  // Do a refresh with a 1-second update time.
+  provided_task_->Refresh(base::TimeDelta::FromSeconds(1),
+                          REFRESH_TYPE_NETWORK_USAGE);
+  EXPECT_TRUE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(sent_bytes + received_bytes, provided_task_->network_usage_rate());

[ncarter (slow), 2017/06/14 20:20:58]

To really validate that cumulative is "since the beginning of time" and rate is
"just the last Refresh cycle", we ought to do a second refresh cycle in at least
one of these tests. Try this (though maybe you want to spread it out into
multiple tests):

  const int batch_one_bytes = sent_bytes + received_bytes;
  EXPECT_EQ(batch_one_bytes, provided_task_->cumulative_network_usage());
  EXPECT_EQ(batch_one_bytes, provided_task_->network_usage_rate());

  // Some more events are reported by the network stack. The rate should be
  // determined only by these events, but cumulative should include the first
  // cycle.
  int batch_two_bytes = 0;
  for (int sent : {1241, 26424}) {
    batch_two_bytes += sent;
    provided_task_->OnNetworkBytesSent(sent);
  }

  for (int read : {55, 56, 889}) {
    batch_two_bytes += read;
    provided_task_->OnNetworkBytesSent(read);
  }

  // Until Refresh() occurs, the task should still report stats for the original
  // batch.
  EXPECT_EQ(batch_one_bytes, provided_task_->cumulative_network_usage());
  EXPECT_EQ(batch_one_bytes, provided_task_->network_usage_rate());

  // Do a refresh with a 2-second update time.
  provided_task_->Refresh(base::TimeDelta::FromSeconds(1),
                          REFRESH_TYPE_NETWORK_USAGE);

  // After Refresh(), the cumulative network usage should reflect a combination
  // of both batches.
  EXPECT_EQ(batch_one_bytes + batch_two_bytes,
            provided_task_->cumulative_network_usage());
  // But the instantaneous rate should reflect only what happened in the
  // previous refresh window.
  EXPECT_EQ(batch_two_bytes, provided_task_->network_usage_rate());

[cburn, 2017/06/16 21:52:26]

I've added some tests that cover this case. 

+}
+
+TEST_F(BrowserProcessTaskProviderTest, TotalNetworkBytesReceived) {
+  BrowserProcessTaskProvider provider;
+  provider.SetObserver(this);
+
+  const int refresh_secs = 2;
+  const int received_bytes = 1024 * refresh_secs;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage_rate());
+  provided_task_->OnNetworkBytesRead(received_bytes);
+  // Do a refresh with a 2-second update time so network_usage_rate() should be
+  // half of cumulative_network_usage();
+  provided_task_->Refresh(base::TimeDelta::FromSeconds(2),

[ncarter (slow), 2017/06/14 20:20:58]

2 -> refresh_secs

[cburn, 2017/06/16 21:52:26]

Done.

+                          REFRESH_TYPE_NETWORK_USAGE);
+  EXPECT_TRUE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(received_bytes, provided_task_->cumulative_network_usage());

[ncarter (slow), 2017/06/14 20:20:58]

EXPECT_EQ(received_bytes / refresh_secs, provided_task_->network_usage_rate());

[cburn, 2017/06/16 21:52:26]

Done.

+}
+
+TEST_F(BrowserProcessTaskProviderTest, TotalNetworkBytesSent) {
+  BrowserProcessTaskProvider provider;
+  provider.SetObserver(this);
+
+  const int refresh_secs = 2;
+  const int sent_bytes = 1024 * refresh_secs;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage_rate());
+  provided_task_->OnNetworkBytesRead(sent_bytes);
+  // Do a refresh with a 2-second update time so network_usage_rate() should be
+  // half of cumulative_network_usage();
+  provided_task_->Refresh(base::TimeDelta::FromSeconds(2),

[ncarter (slow), 2017/06/14 20:20:58]

2 -> refresh_secs

[cburn, 2017/06/16 21:52:26]

Done.

+                          REFRESH_TYPE_NETWORK_USAGE);
+  EXPECT_TRUE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(sent_bytes, provided_task_->cumulative_network_usage());

[ncarter (slow), 2017/06/14 20:20:58]

EXPECT_EQ(sent_bytes / refresh_secs, provided_task_->network_usage_rate());

[cburn, 2017/06/16 21:52:26]

Done.

 }
 
 }  // namespace task_manager