Add tests for HttpRequestCompletionErrorCodes

chrome/browser/net/chrome_network_delegate_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 "chrome/browser/net/chrome_network_delegate.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 217 matching lines @@
       RequestURL(context(), socket_factory());
 
   EXPECT_EQ(0, fake_aggregator.on_the_record_tx_bytes());
   EXPECT_EQ(0, fake_aggregator.on_the_record_rx_bytes());
   EXPECT_EQ(request->GetTotalSentBytes(),
             fake_aggregator.off_the_record_tx_bytes());
   EXPECT_EQ(request->GetTotalReceivedBytes(),
             fake_aggregator.off_the_record_rx_bytes());
 }
 
+TEST_F(ChromeNetworkDelegateTest, HttpRequestCompletionErrorCodes) {
+  Initialize();
+
+  const struct {
+    const GURL url;
+    int net_error;
+    bool is_main_frame;
+    int expected_sample_bucket;
+    int expected_request_completion_count;
+    int expected_request_completion_main_frame_count;
+  } tests[] = {

[asanka, 2017/03/08 21:23:30]

kTests

+      {GURL("http://example.com"), net::OK, true, std::abs(net::OK), 1, 1},
+      {GURL("http://example.com"), net::ERR_ABORTED, true,
+       std::abs(net::ERR_ABORTED), 1, 1},
+      {GURL("http://example.com"), net::OK, false, std::abs(net::OK), 1, 0},
+      {GURL("https://example.com"), net::OK, true, std::abs(net::OK), 0, 0},
+  };
+
+  const char http_request_completion_error_code[] =

[asanka, 2017/03/08 21:23:30]

kHttpRequestCompletionErrorCode for constants.

+      "Net.HttpRequestCompletionErrorCodes";
+  const char http_request_completion_error_code_main_frame[] =

[asanka, 2017/03/08 21:23:30]

kHttpRequestCompletionErrorCodeMainFrame

+      "Net.HttpRequestCompletionErrorCodes.MainFrame";
+
+  for (const auto& test : tests) {
+    base::HistogramTester histograms;
+
+    net::TestDelegate test_delegate;
+    std::unique_ptr<net::URLRequest> request(context()->CreateRequest(
+        test.url, net::DEFAULT_PRIORITY, &test_delegate));
+    if (test.is_main_frame) {
+      request->SetLoadFlags(request->load_flags() |
+                            net::LOAD_MAIN_FRAME_DEPRECATED);
+    }
+    network_delegate()->NotifyCompleted(request.get(), false, test.net_error);
+
+    histograms.ExpectTotalCount(http_request_completion_error_code,
+                                test.expected_request_completion_count);
+    histograms.ExpectUniqueSample(http_request_completion_error_code,
+                                  test.expected_sample_bucket,
+                                  test.expected_request_completion_count);
+    histograms.ExpectTotalCount(
+        http_request_completion_error_code_main_frame,
+        test.expected_request_completion_main_frame_count);
+    histograms.ExpectUniqueSample(
+        http_request_completion_error_code_main_frame,
+        test.expected_sample_bucket,
+        test.expected_request_completion_main_frame_count);
+  }
+}
+
 class ChromeNetworkDelegatePolicyTest : public testing::Test {
  public:
   ChromeNetworkDelegatePolicyTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
     forwarder_ = new extensions::EventRouterForwarder();
 #endif
   }
 
  protected:
@@ skipping 335 matching lines @@
 
   // Files in external storage are allowed.
   base::FilePath external_storage_path;
   PathService::Get(base::DIR_ANDROID_EXTERNAL_STORAGE, &external_storage_path);
   EXPECT_TRUE(IsAccessAllowed(
       external_storage_path.AppendASCII("foo.txt").AsUTF8Unsafe(), ""));
   // The external storage root itself is not allowed.
   EXPECT_FALSE(IsAccessAllowed(external_storage_path.AsUTF8Unsafe(), ""));
 #endif
 }