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

net/url_request/url_request_simple_job_unittest.cc

 // Copyright 2014 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_simple_job.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/scoped_task_scheduler.h"
 #include "net/base/request_priority.h"
 #include "net/test/gtest_util.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.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;
 
@@ skipping 80 matching lines @@
 
 class URLRequestSimpleJobTest : public ::testing::Test {
  public:
   URLRequestSimpleJobTest()
       : context_(true), scoped_task_scheduler_(base::MessageLoop::current()) {
     job_factory_.SetProtocolHandler(
         "data", base::MakeUnique<SimpleJobProtocolHandler>());
     context_.set_job_factory(&job_factory_);
     context_.Init();
 
-    request_ =
-        context_.CreateRequest(GURL("data:test"), DEFAULT_PRIORITY, &delegate_);
+    request_ = context_.CreateRequest(GURL("data:test"), DEFAULT_PRIORITY,
+                                      &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   }
 
   void StartRequest(const HttpRequestHeaders* headers) {
     if (headers)
       request_->SetExtraRequestHeaders(*headers);
     request_->Start();
 
     EXPECT_TRUE(request_->is_pending());
     base::RunLoop().Run();
     EXPECT_FALSE(request_->is_pending());
@@ skipping 56 matching lines @@
       "bytes=%d-%d", kRangeLastPosition, kRangeFirstPosition);
   headers.SetHeader(HttpRequestHeaders::kRange, range);
 
   StartRequest(&headers);
 
   EXPECT_THAT(delegate_.request_status(), IsOk());
   EXPECT_EQ(kTestData, delegate_.data_received());
 }
 
 TEST_F(URLRequestSimpleJobTest, EmptyDataRequest) {
-  request_ =
-      context_.CreateRequest(GURL("data:empty"), DEFAULT_PRIORITY, &delegate_);
+  request_ = context_.CreateRequest(GURL("data:empty"), DEFAULT_PRIORITY,
+                                    &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   StartRequest(nullptr);
   EXPECT_THAT(delegate_.request_status(), IsOk());
   EXPECT_EQ("", delegate_.data_received());
 }
 
 TEST_F(URLRequestSimpleJobTest, CancelBeforeResponseStarts) {
-  request_ =
-      context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY, &delegate_);
+  request_ = context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
+                                    &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   request_->Start();
   request_->Cancel();
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(delegate_.request_status(), IsError(ERR_ABORTED));
   EXPECT_EQ(1, delegate_.response_started_count());
 }
 
 TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) {
   CancelAfterFirstReadURLRequestDelegate cancel_delegate;
-  request_ = context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
-                                    &cancel_delegate);
+  request_ =
+      context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
+                             &cancel_delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
   request_->Start();
   cancel_delegate.WaitUntilHeadersReceived();
 
   // Run ScopedTaskScheduler tasks.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(cancel_delegate.request_status(), IsError(ERR_ABORTED));
   EXPECT_EQ(1, cancel_delegate.response_started_count());
   EXPECT_EQ("", cancel_delegate.data_received());
   // Destroy the request so it doesn't outlive its delegate.
   request_.reset();
 }
 
 }  // namespace net