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

net/url_request/url_request_ftp_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_ftp_job.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_states.h"
 #include "net/base/request_priority.h"
 #include "net/ftp/ftp_auth_cache.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_server.h"
 #include "net/socket/socket_test_util.h"
 #include "net/test/gtest_util.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/ftp_protocol_handler.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 124 matching lines @@
 // Fixture for priority-related tests. Priority matters when there is
 // an HTTP proxy.
 class URLRequestFtpJobPriorityTest : public testing::Test {
  protected:
   URLRequestFtpJobPriorityTest()
       : proxy_service_(base::WrapUnique(new SimpleProxyConfigService),
                        NULL,
                        NULL),
         req_(context_.CreateRequest(GURL("ftp://ftp.example.com"),
                                     DEFAULT_PRIORITY,
-                                    &delegate_)) {
+                                    &delegate_,
+                                    TRAFFIC_ANNOTATION_FOR_TESTS)) {
     context_.set_proxy_service(&proxy_service_);
     context_.set_http_transaction_factory(&network_layer_);
   }
 
   ProxyService proxy_service_;
   MockNetworkLayer network_layer_;
   MockFtpTransactionFactory ftp_factory_;
   FtpAuthCache ftp_auth_cache_;
   TestURLRequestContext context_;
   TestDelegate delegate_;
@@ skipping 115 matching lines @@
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 2, "Content-Length: 9\r\n\r\n"),
     MockRead(ASYNC, 3, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   ASSERT_TRUE(url_request->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_THAT(request_delegate.request_status(), IsOk());
   EXPECT_EQ(ProxyServer(ProxyServer::SCHEME_HTTP,
                         HostPortPair::FromString("localhost:80")),
             url_request->proxy_server());
@@ skipping 10 matching lines @@
   MockProxyResolverFactory* resolver_factory = owned_resolver_factory.get();
 
   // Use a PAC URL so that URLRequestFtpJob's |pac_request_| field is non-NULL.
   request_context()->set_proxy_service(base::WrapUnique(new ProxyService(
       base::WrapUnique(new ProxyConfigServiceFixed(
           ProxyConfig::CreateFromCustomPacURL(GURL("http://foo")))),
       std::move(owned_resolver_factory), nullptr)));
 
   TestDelegate request_delegate;
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
 
   // Verify PAC request is in progress.
   EXPECT_EQ(net::LoadState::LOAD_STATE_RESOLVING_PROXY_FOR_URL,
             url_request->GetLoadState().state);
   EXPECT_EQ(1u, resolver_factory->resolver()->pending_jobs().size());
   EXPECT_EQ(0u, resolver_factory->resolver()->cancelled_jobs().size());
 
   // Destroying the request should cancel the PAC request.
   url_request.reset();
@@ skipping 10 matching lines @@
   MockProxyResolverFactory* resolver_factory = owned_resolver_factory.get();
 
   // Use a PAC URL so that URLRequestFtpJob's |pac_request_| field is non-NULL.
   request_context()->set_proxy_service(base::WrapUnique(new ProxyService(
       base::WrapUnique(new ProxyConfigServiceFixed(
           ProxyConfig::CreateFromCustomPacURL(GURL("http://foo")))),
       std::move(owned_resolver_factory), nullptr)));
 
   TestDelegate request_delegate;
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
 
   // Verify PAC request is in progress.
   url_request->Start();
   EXPECT_EQ(net::LoadState::LOAD_STATE_RESOLVING_PROXY_FOR_URL,
             url_request->GetLoadState().state);
   EXPECT_EQ(1u, resolver_factory->resolver()->pending_jobs().size());
   EXPECT_EQ(0u, resolver_factory->resolver()->cancelled_jobs().size());
 
   // Cancelling the request should cancel the PAC request.
   url_request->Cancel();
@@ skipping 14 matching lines @@
     MockRead(ASYNC, 2, "Proxy-Authenticate: Basic "
              "realm=\"MyRealm1\"\r\n"),
     MockRead(ASYNC, 3, "Content-Length: 9\r\n\r\n"),
     MockRead(ASYNC, 4, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   ASSERT_TRUE(url_request->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_THAT(request_delegate.request_status(), IsOk());
   EXPECT_EQ(ProxyServer(ProxyServer::SCHEME_HTTP,
                         HostPortPair::FromString("localhost:80")),
             url_request->proxy_server());
@@ skipping 26 matching lines @@
     MockRead(ASYNC, 7, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 8, "test2.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   request_delegate.set_credentials(
       AuthCredentials(ASCIIToUTF16("myuser"), ASCIIToUTF16("mypass")));
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   ASSERT_TRUE(url_request->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_THAT(request_delegate.request_status(), IsOk());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
@@ skipping 12 matching lines @@
     MockRead(ASYNC, 2, "WWW-Authenticate: Basic "
              "realm=\"MyRealm1\"\r\n"),
     MockRead(ASYNC, 3, "Content-Length: 9\r\n\r\n"),
     MockRead(ASYNC, 4, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   ASSERT_TRUE(url_request->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_THAT(request_delegate.request_status(), IsOk());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
@@ skipping 23 matching lines @@
     MockRead(ASYNC, 7, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 8, "test2.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   request_delegate.set_credentials(
       AuthCredentials(ASCIIToUTF16("myuser"), ASCIIToUTF16("mypass")));
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   ASSERT_TRUE(url_request->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_THAT(request_delegate.request_status(), IsOk());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_TRUE(request_delegate.auth_required_called());
@@ skipping 44 matching lines @@
 
   // Make sure cached FTP credentials are not used for proxy authentication.
   request_context()->GetFtpAuthCache()->Add(
       url.GetOrigin(),
       AuthCredentials(ASCIIToUTF16("userdonotuse"),
                       ASCIIToUTF16("passworddonotuse")));
 
   TestDelegate request_delegate;
   request_delegate.set_quit_on_auth_required(true);
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      url, DEFAULT_PRIORITY, &request_delegate));
+      url, DEFAULT_PRIORITY, &request_delegate, TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   ASSERT_TRUE(url_request->is_pending());
 
   // Run until proxy auth is requested.
   base::RunLoop().Run();
 
   ASSERT_TRUE(request_delegate.auth_required_called());
   EXPECT_EQ(0, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   url_request->SetAuth(
@@ skipping 27 matching lines @@
     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 2, "Content-Length: 9\r\n"),
     MockRead(ASYNC, 3, "Set-Cookie: name=value\r\n\r\n"),
     MockRead(ASYNC, 4, "test.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   ASSERT_TRUE(url_request->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_THAT(request_delegate.request_status(), IsOk());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 
@@ skipping 12 matching lines @@
   };
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 302 Found\r\n"),
     MockRead(ASYNC, 2, "Location: http://other.example.com/\r\n\r\n"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate;
   std::unique_ptr<URLRequest> url_request(request_context()->CreateRequest(
-      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
+      GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request->Start();
   EXPECT_TRUE(url_request->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(1, network_delegate()->error_count());
   EXPECT_FALSE(url_request->status().is_success());
   EXPECT_THAT(url_request->status().error(), IsError(ERR_UNSAFE_REDIRECT));
@@ skipping 15 matching lines @@
     MockRead(ASYNC, 3, "test1.html"),
     MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 6, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 7, "test2.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   TestDelegate request_delegate1;
 
-  std::unique_ptr<URLRequest> url_request1(
-      request_context()->CreateRequest(GURL("ftp://ftp.example.com/first"),
-                                       DEFAULT_PRIORITY, &request_delegate1));
+  std::unique_ptr<URLRequest> url_request1(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/first"), DEFAULT_PRIORITY, &request_delegate1,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request1->Start();
   ASSERT_TRUE(url_request1->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_TRUE(url_request1->status().is_success());
   EXPECT_EQ(ProxyServer(ProxyServer::SCHEME_HTTP,
                         HostPortPair::FromString("localhost:80")),
             url_request1->proxy_server());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate1.auth_required_called());
   EXPECT_EQ("test1.html", request_delegate1.data_received());
 
   TestDelegate request_delegate2;
-  std::unique_ptr<URLRequest> url_request2(
-      request_context()->CreateRequest(GURL("ftp://ftp.example.com/second"),
-                                       DEFAULT_PRIORITY, &request_delegate2));
+  std::unique_ptr<URLRequest> url_request2(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/second"), DEFAULT_PRIORITY,
+      &request_delegate2, TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request2->Start();
   ASSERT_TRUE(url_request2->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_TRUE(url_request2->status().is_success());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate2.auth_required_called());
@@ skipping 24 matching lines @@
   MockRead reads2[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 2, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 3, "test2.html"),
   };
 
   AddSocket(reads1, arraysize(reads1), writes1, arraysize(writes1));
   AddSocket(reads2, arraysize(reads2), writes2, arraysize(writes2));
 
   TestDelegate request_delegate1;
-  std::unique_ptr<URLRequest> url_request1(
-      request_context()->CreateRequest(GURL("ftp://ftp.example.com/first"),
-                                       DEFAULT_PRIORITY, &request_delegate1));
+  std::unique_ptr<URLRequest> url_request1(request_context()->CreateRequest(
+      GURL("ftp://ftp.example.com/first"), DEFAULT_PRIORITY, &request_delegate1,
+      TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request1->Start();
   ASSERT_TRUE(url_request1->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_TRUE(url_request1->status().is_success());
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate1.auth_required_called());
   EXPECT_EQ("test1.html", request_delegate1.data_received());
 
   TestDelegate request_delegate2;
-  std::unique_ptr<URLRequest> url_request2(
-      request_context()->CreateRequest(GURL("http://ftp.example.com/second"),
-                                       DEFAULT_PRIORITY, &request_delegate2));
+  std::unique_ptr<URLRequest> url_request2(request_context()->CreateRequest(
+      GURL("http://ftp.example.com/second"), DEFAULT_PRIORITY,
+      &request_delegate2, TRAFFIC_ANNOTATION_FOR_TESTS));
   url_request2->Start();
   ASSERT_TRUE(url_request2->is_pending());
 
   // The TestDelegate will by default quit the message loop on completion.
   base::RunLoop().Run();
 
   EXPECT_TRUE(url_request2->status().is_success());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate2.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate2.data_received());
 }
 
 }  // namespace
 
 }  // namespace net