Test network annotation tags added to unittests in net/url_request.

net/url_request/url_request_http_job_unittest.cc

 // Copyright (c) 2013 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/url_request/url_request_http_job.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <memory>
@@ skipping 13 matching lines @@
 #include "net/http/http_transaction_test_util.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/net_features.h"
 #include "net/socket/socket_test_util.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
 
@@ skipping 79 matching lines @@
 TEST_F(URLRequestHttpJobSetUpSourceTest, SetUpSourceFails) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
-  std::unique_ptr<URLRequest> request = context_.CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate_);
+  std::unique_ptr<URLRequest> request =
+      context_.CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                             &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   std::unique_ptr<TestURLRequestHttpJob> job(
       new TestURLRequestHttpJob(request.get()));
   job->set_use_null_source_stream(true);
   test_job_interceptor_->set_main_intercept_job(std::move(job));
   request->Start();
 
   base::RunLoop().Run();
   EXPECT_EQ(ERR_CONTENT_DECODING_INIT_FAILED, delegate_.request_status());
 }
 
 // Tests that if there is an unknown content-encoding type, the raw response
 // body is passed through.
 TEST_F(URLRequestHttpJobSetUpSourceTest, UnknownEncoding) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Encoding: foo, gzip\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
-  std::unique_ptr<URLRequest> request = context_.CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate_);
+  std::unique_ptr<URLRequest> request =
+      context_.CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                             &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   std::unique_ptr<TestURLRequestHttpJob> job(
       new TestURLRequestHttpJob(request.get()));
   test_job_interceptor_->set_main_intercept_job(std::move(job));
   request->Start();
 
   base::RunLoop().Run();
   EXPECT_EQ(OK, delegate_.request_status());
   EXPECT_EQ("Test Content", delegate_.data_received());
 }
 
 // Received a malformed SDCH encoded response when there is no SdchManager.
 TEST_F(URLRequestHttpJobSetUpSourceTest, SdchNotAdvertisedGotSdchResponse) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Encoding: sdch\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   // This test expects TestURLRequestContexts to have no SdchManager.
   DCHECK(!context_.sdch_manager());
 
-  std::unique_ptr<URLRequest> request = context_.CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate_);
+  std::unique_ptr<URLRequest> request =
+      context_.CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                             &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   std::unique_ptr<TestURLRequestHttpJob> job(
       new TestURLRequestHttpJob(request.get()));
   test_job_interceptor_->set_main_intercept_job(std::move(job));
   request->Start();
 
   base::RunLoop().Run();
   EXPECT_EQ(ERR_CONTENT_DECODING_FAILED, delegate_.request_status());
 }
 
 class URLRequestHttpJobTest : public ::testing::Test {
  protected:
   URLRequestHttpJobTest() : context_(true) {
     context_.set_http_transaction_factory(&network_layer_);
 
     // The |test_job_factory_| takes ownership of the interceptor.
     test_job_interceptor_ = new TestJobInterceptor();
     EXPECT_TRUE(test_job_factory_.SetProtocolHandler(
         url::kHttpScheme, base::WrapUnique(test_job_interceptor_)));
     context_.set_job_factory(&test_job_factory_);
     context_.set_net_log(&net_log_);
     context_.Init();
 
-    req_ = context_.CreateRequest(GURL("http://www.example.com"),
-                                  DEFAULT_PRIORITY, &delegate_);
+    req_ =
+        context_.CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                               &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   }
 
   bool TransactionAcceptsSdchEncoding() {
     base::WeakPtr<MockNetworkTransaction> transaction(
         network_layer_.last_transaction());
     EXPECT_TRUE(transaction);
     if (!transaction) return false;
 
     const HttpRequestInfo* request_info = transaction->request();
     EXPECT_TRUE(request_info);
@@ skipping 51 matching lines @@
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_THAT(delegate.request_status(), IsOk());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             network_delegate_.total_network_bytes_sent());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             network_delegate_.total_network_bytes_received());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestContentLengthSuccessfulHttp09Request) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("Test Content"),
                       MockRead(net::SYNCHRONOUS, net::OK)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_THAT(delegate.request_status(), IsOk());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             network_delegate_.total_network_bytes_sent());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             network_delegate_.total_network_bytes_received());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest, TestContentLengthFailedRequest) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 20\r\n\r\n"),
                       MockRead("Test Content"),
                       MockRead(net::SYNCHRONOUS, net::ERR_FAILED)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_THAT(delegate.request_status(), IsError(ERR_FAILED));
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
@@ skipping 10 matching lines @@
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 20\r\n\r\n"),
                       MockRead("Test Content"),
                       MockRead(net::SYNCHRONOUS, net::ERR_IO_PENDING)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   delegate.set_cancel_in_received_data(true);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate.request_status(), IsError(ERR_ABORTED));
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
@@ skipping 15 matching lines @@
 
   MockRead reads[] = {MockRead(response_header.c_str()),
                       MockRead(content_data.c_str()),
                       MockRead(net::SYNCHRONOUS, net::OK)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_EQ(net::OK, request->status().error());
   EXPECT_EQ(static_cast<int>(content_data.size()),
             request->received_response_content_length());
   EXPECT_EQ(static_cast<int>(response_header.size()),
             request->raw_header_size());
@@ skipping 13 matching lines @@
 
   MockRead reads[] = {
       MockRead(continue_header.c_str()), MockRead(response_header.c_str()),
       MockRead(content_data.c_str()), MockRead(net::SYNCHRONOUS, net::OK)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_EQ(net::OK, request->status().error());
   EXPECT_EQ(static_cast<int>(content_data.size()),
             request->received_response_content_length());
   EXPECT_EQ(static_cast<int>(continue_header.size() + response_header.size()),
             request->raw_header_size());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestRawHeaderSizeFailureTruncatedHeaders) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.0 200 OK\r\n"
                                "Content-Len"),
                       MockRead(net::SYNCHRONOUS, net::OK)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   delegate.set_cancel_in_response_started(true);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ERR_ABORTED, request->status().error());
   EXPECT_EQ(0, request->received_response_content_length());
   EXPECT_EQ(28, request->raw_header_size());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestRawHeaderSizeSuccessfullContinuiousRead) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   const std::string& header_data =
       "HTTP/1.1 200 OK\r\n"
       "Content-Length: 12\r\n\r\n";
   const std::string& content_data = "Test Content";
   std::string single_read_content = header_data;
   single_read_content.append(content_data);
   MockRead reads[] = {MockRead(single_read_content.c_str())};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(net::OK, request->status().error());
   EXPECT_EQ(static_cast<int>(content_data.size()),
             request->received_response_content_length());
   EXPECT_EQ(static_cast<int>(header_data.size()), request->raw_header_size());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
@@ skipping 21 matching lines @@
   MockWrite final_writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead final_reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                      "Content-Length: 12\r\n\r\n"),
                             MockRead("Test Content")};
   StaticSocketDataProvider final_socket_data(
       final_reads, arraysize(final_reads), final_writes,
       arraysize(final_writes));
   socket_factory_.AddSocketDataProvider(&final_socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.redirect.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.redirect.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate.request_status(), IsOk());
   EXPECT_EQ(12, request->received_response_content_length());
   // Should not include the redirect.
   EXPECT_EQ(CountWriteBytes(final_writes, arraysize(final_writes)),
             request->GetTotalSentBytes());
@@ skipping 10 matching lines @@
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestNetworkBytesCancelledAfterHeaders) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n\r\n")};
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   delegate.set_cancel_in_response_started(true);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate.request_status(), IsError(ERR_ABORTED));
   EXPECT_EQ(0, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             network_delegate_.total_network_bytes_sent());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             network_delegate_.total_network_bytes_received());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestNetworkBytesCancelledImmediately) {
   StaticSocketDataProvider socket_data(nullptr, 0, nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   request->Cancel();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate.request_status(), IsError(ERR_ABORTED));
   EXPECT_EQ(0, request->received_response_content_length());
   EXPECT_EQ(0, request->GetTotalSentBytes());
   EXPECT_EQ(0, request->GetTotalReceivedBytes());
   EXPECT_EQ(0, network_delegate_.total_network_bytes_received());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest, TestHttpTimeToFirstByte) {
   base::HistogramTester histograms;
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
   histograms.ExpectTotalCount("Net.HttpTimeToFirstByte", 0);
 
   request->Start();
   base::RunLoop().Run();
 
   EXPECT_THAT(delegate.request_status(), IsOk());
   histograms.ExpectTotalCount("Net.HttpTimeToFirstByte", 1);
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestHttpTimeToFirstByteForCancelledTask) {
   base::HistogramTester histograms;
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   request->Cancel();
   base::RunLoop().Run();
 
   EXPECT_THAT(delegate.request_status(), IsError(ERR_ABORTED));
   histograms.ExpectTotalCount("Net.HttpTimeToFirstByte", 0);
 }
 
 TEST_F(URLRequestHttpJobTest, TestCancelWhileReadingCookies) {
   DelayedCookieMonster cookie_monster;
   TestURLRequestContext context(true);
   context.set_cookie_store(&cookie_monster);
   context.Init();
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context.CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context.CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                            &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
 
   request->Start();
   request->Cancel();
   base::RunLoop().Run();
 
   EXPECT_THAT(delegate.request_status(), IsError(ERR_ABORTED));
 }
 
 // Make sure that SetPriority actually sets the URLRequestHttpJob's
 // priority, before start.  Other tests handle the after start case.
@@ skipping 82 matching lines @@
     {"ws://upgrade.test:123/", true, "wss://upgrade.test:123/"},
     {"ws://no-upgrade.test/", false, "ws://no-upgrade.test/"},
     {"ws://no-upgrade.test:123/", false, "ws://no-upgrade.test:123/"},
 #endif  // BUILDFLAG(ENABLE_WEBSOCKETS)
   };
 
   for (const auto& test : cases) {
     SCOPED_TRACE(test.url);
     TestDelegate d;
     TestNetworkDelegate network_delegate;
-    std::unique_ptr<URLRequest> r(
-        context_.CreateRequest(GURL(test.url), DEFAULT_PRIORITY, &d));
+    std::unique_ptr<URLRequest> r(context_.CreateRequest(
+        GURL(test.url), DEFAULT_PRIORITY, &d, TRAFFIC_ANNOTATION_FOR_TESTS));
 
     net_log_.Clear();
     r->Start();
     base::RunLoop().Run();
 
     if (test.upgrade_expected) {
       net::TestNetLogEntry::List entries;
       net_log_.GetEntries(&entries);
       int redirects = 0;
       for (const auto& entry : entries) {
@@ skipping 58 matching lines @@
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   MockSdchObserver sdch_observer;
   SdchManager sdch_manager;
   sdch_manager.AddObserver(&sdch_observer);
   context_.set_sdch_manager(&sdch_manager);
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_.CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_.CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                             &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
   request->Start();
 
   base::RunLoop().Run();
   // SdchPolicyDelegate::OnDictionaryIdError() detects that the response is
   // malformed (missing dictionary), and will issue a pass-through of the raw
   // response.
   EXPECT_EQ(OK, delegate.request_status());
   EXPECT_EQ("Test Content", delegate.data_received());
   // Cleanup manager.
   sdch_manager.RemoveObserver(&sdch_observer);
@@ skipping 21 matching lines @@
   SdchManager sdch_manager;
   sdch_manager.AddObserver(&sdch_observer);
   context_.set_sdch_manager(&sdch_manager);
 
   // First response will be "from network" and we should have OnGetDictionary
   // invoked.
   GURL url("http://example.com");
   EXPECT_CALL(sdch_observer,
               OnGetDictionary(url, GURL("http://example.com/sdch.dict")));
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request =
-      context_.CreateRequest(url, DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request = context_.CreateRequest(
+      url, DEFAULT_PRIORITY, &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate.request_status(), IsOk());
 
   // Second response should be from cache without notification of SdchObserver
   TestDelegate delegate2;
-  std::unique_ptr<URLRequest> request2 =
-      context_.CreateRequest(url, DEFAULT_PRIORITY, &delegate2);
+  std::unique_ptr<URLRequest> request2 = context_.CreateRequest(
+      url, DEFAULT_PRIORITY, &delegate2, TRAFFIC_ANNOTATION_FOR_TESTS);
   request2->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate2.request_status(), IsOk());
 
   // Cleanup manager.
   sdch_manager.RemoveObserver(&sdch_observer);
 }
 
 class URLRequestHttpJobWithBrotliSupportTest : public ::testing::Test {
@@ skipping 15 matching lines @@
 TEST_F(URLRequestHttpJobWithBrotliSupportTest, NoBrotliAdvertisementOverHttp) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate.request_status(), IsOk());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
 }
@@ skipping 13 matching lines @@
                 "Accept-Encoding: gzip, deflate, br\r\n"
                 "Accept-Language: en-us,fr\r\n\r\n")};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  std::unique_ptr<URLRequest> request = context_->CreateRequest(
-      GURL("https://www.example.com"), DEFAULT_PRIORITY, &delegate);
+  std::unique_ptr<URLRequest> request =
+      context_->CreateRequest(GURL("https://www.example.com"), DEFAULT_PRIORITY,
+                              &delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(delegate.request_status(), IsOk());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
 }
@@ skipping 13 matching lines @@
       {"https://blocked.test/", false, false},
   };
 
   for (const TestCase& test : cases) {
     JNIEnv* env = base::android::AttachCurrentThread();
     Java_AndroidNetworkLibraryTestUtil_setUpSecurityPolicyForTesting(
         env, test.cleartext_permitted);
 
     TestDelegate delegate;
     std::unique_ptr<URLRequest> request =
-        context_.CreateRequest(GURL(test.url), DEFAULT_PRIORITY, &delegate);
+        context_.CreateRequest(GURL(test.url), DEFAULT_PRIORITY, &delegate,
+                               TRAFFIC_ANNOTATION_FOR_TESTS);
     request->Start();
     base::RunLoop().Run();
 
     int sdk_int = base::android::BuildInfo::GetInstance()->sdk_int();
     bool expect_blocked = (sdk_int >= base::android::SDK_VERSION_MARSHMALLOW &&
                            test.should_block);
     if (expect_blocked) {
       EXPECT_THAT(delegate.request_status(),
                   IsError(ERR_CLEARTEXT_NOT_PERMITTED));
     } else {
@@ skipping 26 matching lines @@
   MockClientSocketFactory socket_factory_;
   TestURLRequestContext context_;
 };
 
 class URLRequestHttpJobWebSocketTest
     : public URLRequestHttpJobWebSocketTestBase {
  protected:
   URLRequestHttpJobWebSocketTest()
       : req_(context_.CreateRequest(GURL("ws://www.example.com"),
                                     DEFAULT_PRIORITY,
-                                    &delegate_)) {
-  }
+                                    &delegate_,
+                                    TRAFFIC_ANNOTATION_FOR_TESTS)) {}
 
   TestDelegate delegate_;
   std::unique_ptr<URLRequest> req_;
 };
 
 class MockCreateHelper : public WebSocketHandshakeStreamBase::CreateHelper {
  public:
   // GoogleMock does not appear to play nicely with move-only types like
   // std::unique_ptr, so this forwarding method acts as a workaround.
   WebSocketHandshakeStreamBase* CreateBasicStream(
@@ skipping 119 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(delegate_.request_status(), IsError(ERR_IO_PENDING));
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 #endif  // BUILDFLAG(ENABLE_WEBSOCKETS)
 
 }  // namespace
 
 }  // namespace net