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 42 matching lines @@
   EXPECT_EQ(nullptr, provided_task_);
   provider.SetObserver(this);
   EXPECT_NE(nullptr, provided_task_);
 
   Task* result = provider.GetTaskOfUrlRequest(1, 0, 0);
   EXPECT_EQ(nullptr, result);
   result = provider.GetTaskOfUrlRequest(0, -1, 0);
   EXPECT_EQ(provided_task_, result);
 }
 
-// Test the provided browser process task itself.
+// Test the provided browser process task for recieved bytes rate

[ncarter (slow), 2017/06/08 23:37:18]

This comment should be restored; you didn't edit this test.

[cburn, 2017/06/14 18:04:37]

Done.

 TEST_F(BrowserProcessTaskProviderTest, TestProvidedTask) {
   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());
   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);

[ncarter (slow), 2017/06/08 23:37:18]

Since we have new tests specifically focused on network usage, maybe remove the
OnNetworkBytesRead and below from this one?

[cburn, 2017/06/14 18:04:37]

Done.

   EXPECT_TRUE(provided_task_->ReportsNetworkUsage());
   EXPECT_EQ(received_bytes, provided_task_->network_usage());
 }
 
+// Test the provided browser process task for sent bytes rate
+TEST_F(BrowserProcessTaskProviderTest, TestSentTask) {

[ncarter (slow), 2017/06/08 23:37:18]

A good name for this test would be:

BrowserProcessTaskProviderTest.NetworkBytesSent

('Test' and 'Task' already appears in the fixture name
[BrowserProcessTaskProviderTest] so you don't need to put it in the text name
too). Name the test after what it does differently from the other tests.

[cburn, 2017/06/14 18:04:37]

Done.

+  BrowserProcessTaskProvider provider;
+  EXPECT_EQ(nullptr, provided_task_);
+  provider.SetObserver(this);
+  ASSERT_NE(nullptr, provided_task_);
+
+  EXPECT_EQ(base::GetCurrentProcessHandle(), provided_task_->process_handle());

[ncarter (slow), 2017/06/08 23:37:18]

It's not necessary to duplicate the GetCurrentProcHandle asserts into the new
tests -- they're redundant to the coverage that TestProvidedTask does.

[cburn, 2017/06/14 18:04:37]

Done.

+  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 sent_bytes = 1024;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage());
+  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());
+}
+
+// Test the provided browser process task for recieved then sent bytes rate

[ncarter (slow), 2017/06/08 23:37:18]

recieved -> received (here and elsewhere)

[cburn, 2017/06/14 18:04:37]

Done.

+TEST_F(BrowserProcessTaskProviderTest, TestRecievedSentTask) {

[ncarter (slow), 2017/06/08 23:37:18]

BrowserProcessTaskProviderTest.NetworkBytesReceived

[cburn, 2017/06/14 18:04:37]

Done.

+  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;
+  const int sent_bytes = 1024;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage());
+  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());
+}
+
+// Test the provided browser process task for sent then recieved rate.
+TEST_F(BrowserProcessTaskProviderTest, TestSentRecievedTask) {
+  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;
+  const int sent_bytes = 1024;
+  EXPECT_FALSE(provided_task_->ReportsNetworkUsage());
+  EXPECT_EQ(-1, provided_task_->network_usage());
+  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());
+}
+
+TEST_F(BrowserProcessTaskProviderTest, TestTotalRecievedBytes) {
+  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());
+  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_->total_network_usage());
+}
+
 }  // namespace task_manager