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

net/url_request/url_request_job_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 "net/url_request/url_request_job.h"
 
 #include <memory>
 
 #include "base/run_loop.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_transaction_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_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::IsError;
 using net::test::IsOk;
 
 namespace net {
 
@@ skipping 146 matching lines @@
 };
 
 }  // namespace
 
 TEST(URLRequestJob, TransactionNoFilter) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
-  std::unique_ptr<URLRequest> req(context.CreateRequest(
-      GURL(kNoFilter_Transaction.url), DEFAULT_PRIORITY, &d));
+  std::unique_ptr<URLRequest> req(
+      context.CreateRequest(GURL(kNoFilter_Transaction.url), DEFAULT_PRIORITY,
+                            &d, TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kNoFilter_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_FALSE(d.request_failed());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_EQ("hello", d.data_received());
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&kNoFilter_Transaction);
 }
 
 TEST(URLRequestJob, TransactionNotifiedWhenDone) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
-      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d));
+      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d,
+                            TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kGZip_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.response_completed());
   EXPECT_EQ(OK, d.request_status());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_EQ("", d.data_received());
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&kGZip_Transaction);
 }
 
 TEST(URLRequestJob, SyncTransactionNotifiedWhenDone) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
-      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d));
+      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d,
+                            TRAFFIC_ANNOTATION_FOR_TESTS));
   MockTransaction transaction(kGZip_Transaction);
   transaction.test_mode = TEST_MODE_SYNC_ALL;
   AddMockTransaction(&transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.response_completed());
   EXPECT_EQ(OK, d.request_status());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_EQ("", d.data_received());
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests processing a large gzip header one byte at a time.
 TEST(URLRequestJob, SyncSlowTransaction) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
-      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d));
+      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d,
+                            TRAFFIC_ANNOTATION_FOR_TESTS));
   MockTransaction transaction(kGZip_Transaction);
   transaction.test_mode = TEST_MODE_SYNC_ALL | TEST_MODE_SLOW_READ;
   transaction.handler = &BigGZipServer;
   AddMockTransaction(&transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.response_completed());
   EXPECT_EQ(OK, d.request_status());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_EQ("", d.data_received());
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&transaction);
 }
 
 TEST(URLRequestJob, RedirectTransactionNotifiedWhenDone) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
-  std::unique_ptr<URLRequest> req(context.CreateRequest(
-      GURL(kRedirect_Transaction.url), DEFAULT_PRIORITY, &d));
+  std::unique_ptr<URLRequest> req(
+      context.CreateRequest(GURL(kRedirect_Transaction.url), DEFAULT_PRIORITY,
+                            &d, TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kRedirect_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&kRedirect_Transaction);
@@ skipping 167 matching lines @@
     MakeMockReferrerPolicyTransaction(test.original_url,
                                       request_headers.c_str(),
                                       test.response_headers, &transaction);
 
     MockNetworkLayer network_layer;
     TestURLRequestContext context;
     context.set_http_transaction_factory(&network_layer);
 
     TestDelegate d;
     std::unique_ptr<URLRequest> req(
-        context.CreateRequest(GURL(transaction.url), DEFAULT_PRIORITY, &d));
+        context.CreateRequest(GURL(transaction.url), DEFAULT_PRIORITY, &d,
+                              TRAFFIC_ANNOTATION_FOR_TESTS));
     AddMockTransaction(&transaction);
 
     req->set_referrer_policy(test.original_referrer_policy);
     req->SetReferrer(test.original_referrer);
 
     req->set_method("GET");
     req->Start();
 
     base::RunLoop().Run();
 
@@ skipping 11 matching lines @@
 TEST(URLRequestJob, TransactionNotCachedWhenNetworkDelegateRedirects) {
   MockNetworkLayer network_layer;
   TestNetworkDelegate network_delegate;
   network_delegate.set_redirect_on_headers_received_url(GURL("http://foo"));
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
   context.set_network_delegate(&network_delegate);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
-      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d));
+      context.CreateRequest(GURL(kGZip_Transaction.url), DEFAULT_PRIORITY, &d,
+                            TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kGZip_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_TRUE(network_layer.stop_caching_called());
 
   RemoveMockTransaction(&kGZip_Transaction);
 }
 
 // Makes sure that ReadRawDataComplete correctly updates request status before
 // calling ReadFilteredData.
 // Regression test for crbug.com/553300.
 TEST(URLRequestJob, EmptyBodySkipFilter) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(context.CreateRequest(
-      GURL(kEmptyBodyGzip_Transaction.url), DEFAULT_PRIORITY, &d));
+      GURL(kEmptyBodyGzip_Transaction.url), DEFAULT_PRIORITY, &d,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kEmptyBodyGzip_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_FALSE(d.request_failed());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_TRUE(d.data_received().empty());
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&kEmptyBodyGzip_Transaction);
 }
 
 // Regression test for crbug.com/575213.
 TEST(URLRequestJob, InvalidContentGZipTransaction) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(context.CreateRequest(
-      GURL(kInvalidContentGZip_Transaction.url), DEFAULT_PRIORITY, &d));
+      GURL(kInvalidContentGZip_Transaction.url), DEFAULT_PRIORITY, &d,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kInvalidContentGZip_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   // Request failed indicates the request failed before headers were received,
   // so should be false.
   EXPECT_FALSE(d.request_failed());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_FALSE(req->status().is_success());
   EXPECT_EQ(ERR_CONTENT_DECODING_FAILED, d.request_status());
   EXPECT_TRUE(d.data_received().empty());
   EXPECT_FALSE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&kInvalidContentGZip_Transaction);
 }
 
 // Regression test for crbug.com/553300.
 TEST(URLRequestJob, SlowFilterRead) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
-  std::unique_ptr<URLRequest> req(context.CreateRequest(
-      GURL(kGzip_Slow_Transaction.url), DEFAULT_PRIORITY, &d));
+  std::unique_ptr<URLRequest> req(
+      context.CreateRequest(GURL(kGzip_Slow_Transaction.url), DEFAULT_PRIORITY,
+                            &d, TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kGzip_Slow_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().Run();
 
   EXPECT_FALSE(d.request_failed());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_EQ("hello\n", d.data_received());
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&kGzip_Slow_Transaction);
 }
 
 TEST(URLRequestJob, SlowBrotliRead) {
   MockNetworkLayer network_layer;
   TestURLRequestContext context;
   context.set_http_transaction_factory(&network_layer);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(context.CreateRequest(
-      GURL(kBrotli_Slow_Transaction.url), DEFAULT_PRIORITY, &d));
+      GURL(kBrotli_Slow_Transaction.url), DEFAULT_PRIORITY, &d,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   AddMockTransaction(&kBrotli_Slow_Transaction);
 
   req->set_method("GET");
   req->Start();
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(d.request_failed());
   EXPECT_EQ(200, req->GetResponseCode());
   EXPECT_EQ(kHelloData, d.data_received());
   EXPECT_TRUE(network_layer.done_reading_called());
 
   RemoveMockTransaction(&kBrotli_Slow_Transaction);
 }
 
 }  // namespace net