Network traffic annotation added to URLLoaderImpl.

content/common/throttling_url_loader_unittest.cc

 // Copyright 2017 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 "content/common/throttling_url_loader.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/common/url_loader.mojom.h"
 #include "content/common/url_loader_factory.mojom.h"
 #include "content/public/common/url_loader_throttle.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 namespace {
 
 class TestURLLoaderFactory : public mojom::URLLoaderFactory {
  public:
   TestURLLoaderFactory() : binding_(this) {
     binding_.Bind(mojo::MakeRequest(&factory_ptr_));
   }
@@ skipping 20 matching lines @@
     client_ptr_->OnComplete(data);
   }
 
  private:
   // mojom::URLLoaderFactory implementation.
   void CreateLoaderAndStart(mojom::URLLoaderAssociatedRequest request,
                             int32_t routing_id,
                             int32_t request_id,
                             uint32_t options,
                             const ResourceRequest& url_request,
-                            mojom::URLLoaderClientPtr client) override {
+                            mojom::URLLoaderClientPtr client,
+                            const net::MutableNetworkTrafficAnnotationTag&
+                                traffic_annotation) override {
     create_loader_and_start_called_++;
 
     client_ptr_ = std::move(client);
   }
 
   void SyncLoad(int32_t routing_id,
                 int32_t request_id,
                 const ResourceRequest& request,
                 SyncLoadCallback callback) override {
     NOTREACHED();
@@ skipping 138 matching lines @@
     throttle_ = throttle.get();
 
     throttles_.push_back(std::move(throttle));
   }
 
   void CreateLoaderAndStart() {
     auto request = base::MakeUnique<ResourceRequest>();
     request->url = GURL("http://example.org");
     loader_ = ThrottlingURLLoader::CreateLoaderAndStart(
         factory_.factory_ptr().get(), std::move(throttles_), 0, 0, 0,
-        std::move(request), &client_);
+        std::move(request), &client_,
+        net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS));
     factory_.factory_ptr().FlushForTesting();
   }
 
   // Be the first member so it is destroyed last.
   base::MessageLoop message_loop_;
 
   std::unique_ptr<ThrottlingURLLoader> loader_;
   std::vector<std::unique_ptr<URLLoaderThrottle>> throttles_;
 
   TestURLLoaderFactory factory_;
@@ skipping 328 matching lines @@
   EXPECT_EQ(0u, throttle_->will_redirect_request_called());
   EXPECT_EQ(1u, throttle_->will_process_response_called());
 
   EXPECT_EQ(0u, client_.on_received_response_called());
   EXPECT_EQ(0u, client_.on_received_redirect_called());
   EXPECT_EQ(1u, client_.on_complete_called());
 }
 
 }  // namespace
 }  // namespace content