Network traffic annotation added to chrome/browser/ unittests.

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 21 matching lines @@
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/previews_state.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/features/features.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_request_headers.h"
 #include "net/socket/socket_test_util.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #endif
 
 namespace {
@@ skipping 14 matching lines @@
 
   net::MockRead response_mock_reads[] = {
       net::MockRead("HTTP/1.1 200 OK\r\n\r\n"), net::MockRead("response body"),
       net::MockRead(net::SYNCHRONOUS, net::OK),
   };
   net::StaticSocketDataProvider response_socket_data_provider(
       response_mock_reads, arraysize(response_mock_reads), nullptr, 0);
   socket_factory->AddSocketDataProvider(&response_socket_data_provider);
   net::TestDelegate test_delegate;
   test_delegate.set_quit_on_complete(true);
-  std::unique_ptr<net::URLRequest> request(context->CreateRequest(
-      GURL("http://example.com"), net::DEFAULT_PRIORITY, &test_delegate));
+  std::unique_ptr<net::URLRequest> request(
+      context->CreateRequest(GURL("http://example.com"), net::DEFAULT_PRIORITY,
+                             &test_delegate, TRAFFIC_ANNOTATION_FOR_TESTS));
 
   content::ResourceRequestInfo::AllocateForTesting(
       request.get(), content::RESOURCE_TYPE_MAIN_FRAME, nullptr, -2, -2, -2,
       true, false, true, true, content::PREVIEWS_OFF);
 
   request->Start();
   base::RunLoop().RunUntilIdle();
   return request;
 }
 
@@ skipping 167 matching lines @@
 
   const char kHttpRequestCompletionErrorCode[] =
       "Net.HttpRequestCompletionErrorCodes";
   const char kHttpRequestCompletionErrorCodeMainFrame[] =
       "Net.HttpRequestCompletionErrorCodes.MainFrame";
 
   for (const auto& test : kTests) {
     base::HistogramTester histograms;
 
     net::TestDelegate test_delegate;
-    std::unique_ptr<net::URLRequest> request(context()->CreateRequest(
-        test.url, net::DEFAULT_PRIORITY, &test_delegate));
+    std::unique_ptr<net::URLRequest> request(
+        context()->CreateRequest(test.url, net::DEFAULT_PRIORITY,
+                                 &test_delegate, TRAFFIC_ANNOTATION_FOR_TESTS));
     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(kHttpRequestCompletionErrorCode,
                                 test.expected_request_completion_count);
     histograms.ExpectUniqueSample(kHttpRequestCompletionErrorCode,
                                   test.expected_sample_bucket,
@@ skipping 66 matching lines @@
     force_google_safe_search_.SetValue(google_safe_search);
     force_youtube_restrict_.SetValue(youtube_restrict);
   }
 
   // Does a request to an arbitrary URL and verifies that the SafeSearch
   // enforcement utility functions were called/not called as expected.
   void QueryURL(bool expect_google_safe_search, bool expect_youtube_restrict) {
     safe_search_util::ClearForceGoogleSafeSearchCountForTesting();
     safe_search_util::ClearForceYouTubeRestrictCountForTesting();
 
-    std::unique_ptr<net::URLRequest> request(context_.CreateRequest(
-        GURL("http://anyurl.com"), net::DEFAULT_PRIORITY, &delegate_));
+    std::unique_ptr<net::URLRequest> request(
+        context_.CreateRequest(GURL("http://anyurl.com"), net::DEFAULT_PRIORITY,
+                               &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS));
 
     request->Start();
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(expect_google_safe_search ? 1 : 0,
               safe_search_util::GetForceGoogleSafeSearchCountForTesting());
     EXPECT_EQ(expect_youtube_restrict ? 1 : 0,
               safe_search_util::GetForceYouTubeRestrictCountForTesting());
   }
 
@@ skipping 49 matching lines @@
   // If |expected| is passed as false, this routine verifies that no
   // X-GoogApps-Allowed-Domains header is set. If |expected| is passed as true,
   // this routine verifies that the X-GoogApps-Allowed-Domains header is set and
   // the value is identical to |allowed|.
   void CheckAllowedDomainsHeaders(const std::string& allowed,
                                   const GURL& url,
                                   bool expected) {
     allowed_domains_for_apps_.SetValue(allowed);
 
     std::unique_ptr<net::URLRequest> request(context_.CreateRequest(
-        url, net::DEFAULT_PRIORITY, &delegate_));
+        url, net::DEFAULT_PRIORITY, &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS));
 
     request->Start();
     base::RunLoop().RunUntilIdle();
 
     net::HttpRequestHeaders request_headers = request->extra_request_headers();
 
     const char allowed_domains_header_name[] = "X-GoogApps-Allowed-Domains";
     EXPECT_EQ(expected, request_headers.HasHeader(allowed_domains_header_name));
 
     if (expected) {
@@ skipping 197 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
 }