Test network annotation tags added to unittests in net/.

net/nqe/throughput_analyzer_unittest.cc

 // Copyright 2016 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/nqe/throughput_analyzer.h"
 
 #include <stdint.h>
 
 #include <deque>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/url_util.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/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace nqe {
 
 namespace {
 
@@ skipping 55 matching lines @@
     ASSERT_FALSE(throughput_analyzer.disable_throughput_measurements());
     std::deque<std::unique_ptr<URLRequest>> requests;
 
     // Start more requests than the maximum number of requests that can be held
     // in the memory.
     const std::string url = test.use_local_requests
                                 ? "http://127.0.0.1/test.html"
                                 : "http://example.com/test.html";
     for (size_t i = 0; i < 1000; ++i) {
       std::unique_ptr<URLRequest> request(
-          context.CreateRequest(GURL(url), DEFAULT_PRIORITY, &test_delegate));
+          context.CreateRequest(GURL(url), DEFAULT_PRIORITY, &test_delegate,
+                                TRAFFIC_ANNOTATION_FOR_TESTS));
       ASSERT_EQ(test.use_local_requests, IsLocalhost(request->url().host()));
 
       throughput_analyzer.NotifyStartTransaction(*(request.get()));
       requests.push_back(std::move(request));
     }
     // Too many local requests should cause the |throughput_analyzer| to disable
     // throughput measurements.
     EXPECT_EQ(test.use_local_requests,
               throughput_analyzer.disable_throughput_measurements());
   }
@@ skipping 20 matching lines @@
 
   for (const auto& test : tests) {
     // Localhost requests are not allowed for estimation purposes.
     TestThroughputAnalyzer throughput_analyzer;
 
     TestDelegate test_delegate;
     TestURLRequestContext context;
 
     std::unique_ptr<URLRequest> request_local;
 
-    std::unique_ptr<URLRequest> request_not_local(
-        context.CreateRequest(GURL("http://example.com/echo.html"),
-                              DEFAULT_PRIORITY, &test_delegate));
+    std::unique_ptr<URLRequest> request_not_local(context.CreateRequest(
+        GURL("http://example.com/echo.html"), DEFAULT_PRIORITY, &test_delegate,
+        TRAFFIC_ANNOTATION_FOR_TESTS));
     request_not_local->Start();
 
     if (test.start_local_request) {
       request_local = context.CreateRequest(GURL("http://localhost/echo.html"),
-                                            DEFAULT_PRIORITY, &test_delegate);
+                                            DEFAULT_PRIORITY, &test_delegate,
+                                            TRAFFIC_ANNOTATION_FOR_TESTS);
       request_local->Start();
     }
 
     base::RunLoop().Run();
 
     EXPECT_EQ(0, throughput_analyzer.throughput_observations_received());
 
     // If |test.start_local_request| is true, then |request_local| starts
     // before |request_not_local|, and ends after |request_not_local|. Thus,
     // network quality estimator should not get a chance to record throughput
@@ skipping 42 matching lines @@
 
   for (const auto& test : tests) {
     // Localhost requests are not allowed for estimation purposes.
     TestThroughputAnalyzer throughput_analyzer;
     TestDelegate test_delegate;
     TestURLRequestContext context;
 
     EXPECT_EQ(0, throughput_analyzer.throughput_observations_received());
 
     std::unique_ptr<URLRequest> request_network_1 = context.CreateRequest(
-        GURL("http://example.com/echo.html"), DEFAULT_PRIORITY, &test_delegate);
+        GURL("http://example.com/echo.html"), DEFAULT_PRIORITY, &test_delegate,
+        TRAFFIC_ANNOTATION_FOR_TESTS);
     std::unique_ptr<URLRequest> request_network_2 = context.CreateRequest(
-        GURL("http://example.com/echo.html"), DEFAULT_PRIORITY, &test_delegate);
+        GURL("http://example.com/echo.html"), DEFAULT_PRIORITY, &test_delegate,
+        TRAFFIC_ANNOTATION_FOR_TESTS);
     request_network_1->Start();
     request_network_2->Start();
 
     base::RunLoop().Run();
 
     EXPECT_LE(0, throughput_analyzer.throughput_observations_received());
 
     throughput_analyzer.NotifyStartTransaction(*request_network_1);
     throughput_analyzer.NotifyStartTransaction(*request_network_2);
 
@@ skipping 12 matching lines @@
       EXPECT_EQ(0, throughput_analyzer.throughput_observations_received());
     }
   }
 }
 
 }  // namespace
 
 }  // namespace nqe
 
 }  // namespace net