Network traffic annotation added to chrome/browser/ unittests.

chrome/browser/extensions/api/web_request/web_request_api_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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
@@ skipping 38 matching lines @@
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/features/feature.h"
 #include "net/base/auth.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log_with_source.h"
 #include "net/log/test_net_log.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest-message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
 namespace web_request = extensions::api::web_request;
 
 using base::BinaryValue;
@@ skipping 173 matching lines @@
 
   net::URLRequestJobFactoryImpl job_factory;
   job_factory.SetProtocolHandler(
       url::kAboutScheme,
       base::WrapUnique(new about_handler::AboutProtocolHandler()));
   context_->set_job_factory(&job_factory);
 
   GURL redirect_url("about:redirected");
   GURL not_chosen_redirect_url("about:not_chosen");
 
-  std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
-      GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(GURL("about:blank"), net::DEFAULT_PRIORITY,
+                              &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS));
   {
     // onBeforeRequest will be dispatched twice initially. The second response -
     // the redirect - should win, since it has a later |install_time|. The
     // redirect will dispatch another pair of onBeforeRequest. There, the first
     // response should win (later |install_time|).
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension1 response. Arrives first, but ignored due to install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
@@ skipping 32 matching lines @@
     base::RunLoop().Run();
 
     EXPECT_TRUE(!request->is_pending());
     EXPECT_EQ(net::OK, delegate_.request_status());
     EXPECT_EQ(redirect_url, request->url());
     EXPECT_EQ(2U, request->url_chain().size());
     EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
   }
 
   // Now test the same thing but the extensions answer in reverse order.
-  std::unique_ptr<net::URLRequest> request2(context_->CreateRequest(
-      GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request2(
+      context_->CreateRequest(GURL("about:blank"), net::DEFAULT_PRIORITY,
+                              &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS));
   {
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension2 response. Arrives first, and chosen because of install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     response->new_url = redirect_url;
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension2_id, kEventName, kEventName + "/2",
@@ skipping 56 matching lines @@
       &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName,
       kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
   std::unique_ptr<net::URLRequest> request(
-      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_,
+                              TRAFFIC_ANNOTATION_FOR_TESTS));
 
   // onBeforeRequest will be dispatched twice. The second response -
   // the redirect - would win, since it has a later |install_time|, but
   // the first response takes precedence because cancel >> redirect.
   GURL redirect_url("about:redirected");
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
   // Extension1 response. Arrives first, would be ignored in principle due to
   // install_time but "cancel" always wins.
   response = new ExtensionWebRequestEventRouter::EventResponse(
@@ skipping 50 matching lines @@
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension_id, extension_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension_id, extension_id, events::FOR_TEST, kEventName2,
       kEventName2 + "/1", filter, 0, 0, 0, ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
   std::unique_ptr<net::URLRequest> request(
-      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_,
+                              TRAFFIC_ANNOTATION_FOR_TESTS));
 
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
   // Extension response for the OnBeforeRequest handler. This should not be
   // processed because request is canceled before the handler responds.
   response = new ExtensionWebRequestEventRouter::EventResponse(
       extension_id, base::Time::FromDoubleT(1));
   GURL redirect_url("about:redirected");
   response->new_url = redirect_url;
   ipc_sender_.PushTask(
@@ skipping 47 matching lines @@
 }  // namespace
 
 void ExtensionWebRequestTest::FireURLRequestWithData(
     const std::string& method,
     const char* content_type,
     const std::vector<char>& bytes_1,
     const std::vector<char>& bytes_2) {
   // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
   GURL request_url("http://www.example.com");
   std::unique_ptr<net::URLRequest> request(
-      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_,
+                              TRAFFIC_ANNOTATION_FOR_TESTS));
   request->set_method(method);
   if (content_type != NULL) {
     request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType,
                                          content_type,
                                          true /* overwrite */);
   }
   std::vector<std::unique_ptr<net::UploadElementReader>> element_readers;
   element_readers.push_back(base::MakeUnique<net::UploadBytesElementReader>(
       &(bytes_1[0]), bytes_1.size()));
   element_readers.push_back(base::MakeUnique<net::UploadFileElementReader>(
@@ skipping 282 matching lines @@
   // Subscribe to OnBeforeRequest with requestBody requirement.
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension_id, extension_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, extra_info_spec, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
   const GURL request_url("http://www.example.com");
 
   for (size_t i = 0; i < arraysize(kMethods); ++i) {
-    std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
-        request_url, net::DEFAULT_PRIORITY, &delegate_));
+    std::unique_ptr<net::URLRequest> request(
+        context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_,
+                                TRAFFIC_ANNOTATION_FOR_TESTS));
     request->set_method(kMethods[i]);
     ipc_sender_.PushTask(base::Bind(&base::DoNothing));
     request->Start();
   }
 
   // We inspect the result in the message list of |ipc_sender_| later.
   base::RunLoop().RunUntilIdle();
 
   ExtensionWebRequestEventRouter::EventListener::ID id1(
       &profile_, extension_id, kEventName + "/1", 0, 0);
@@ skipping 75 matching lines @@
   ExtensionWebRequestEventRouter::EventListener::ID id(&profile_, extension_id,
                                                        kEventName + "/1", 0, 0);
   ExtensionWebRequestEventRouter::EventListener* listener =
       ExtensionWebRequestEventRouter::GetInstance()->FindEventListener(id);
   ASSERT_NE(nullptr, listener);
   EXPECT_EQ(0u, listener->blocked_requests.size());
 
   // Send a request. It should block. Wait for the run loop to become idle.
   GURL request_url("about:blank");
   std::unique_ptr<net::URLRequest> request(
-      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_,
+                              TRAFFIC_ANNOTATION_FOR_TESTS));
   // Extension response for OnErrorOccurred: Terminate the message loop.
   {
     base::RunLoop run_loop;
     ipc_sender_.PushTask(
         base::Bind(base::IgnoreResult(&base::SingleThreadTaskRunner::PostTask),
                    base::ThreadTaskRunnerHandle::Get(), FROM_HERE,
                    run_loop.QuitWhenIdleClosure()));
     request->Start();
     run_loop.Run();
   }
@@ skipping 112 matching lines @@
 
   // Install one extension that observes the final headers.
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension3_id, extension3_id, events::FOR_TEST,
       keys::kOnSendHeadersEvent, std::string(keys::kOnSendHeadersEvent) + "/3",
       filter, ExtraInfoSpec::REQUEST_HEADERS, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("http://doesnotexist/does_not_exist.html");
   std::unique_ptr<net::URLRequest> request(
-      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_,
+                              TRAFFIC_ANNOTATION_FOR_TESTS));
 
   // Initialize headers available before extensions are notified of the
   // onBeforeSendHeaders event.
   HeaderModificationTest test = GetParam();
   net::HttpRequestHeaders before_headers;
   for (int i = 0; i < test.before_size; ++i)
     before_headers.SetHeader(test.before[i].name, test.before[i].value);
   request->SetExtraRequestHeaders(before_headers);
 
   // Gather the modifications to the headers for the respective extensions.
@@ skipping 1407 matching lines @@
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
 }  // namespace extensions