Network traffic annotation added to URLLoaderImpl.

content/common/throttling_url_loader.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/single_thread_task_runner.h"
 
 namespace content {
 
@@ skipping 39 matching lines @@
 
 // static
 std::unique_ptr<ThrottlingURLLoader> ThrottlingURLLoader::CreateLoaderAndStart(
     mojom::URLLoaderFactory* factory,
     std::vector<std::unique_ptr<URLLoaderThrottle>> throttles,
     int32_t routing_id,
     int32_t request_id,
     uint32_t options,
     std::unique_ptr<ResourceRequest> url_request,
     mojom::URLLoaderClient* client,
+    const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  std::unique_ptr<ThrottlingURLLoader> loader(
-      new ThrottlingURLLoader(std::move(throttles), client));
+  std::unique_ptr<ThrottlingURLLoader> loader(new ThrottlingURLLoader(
+      std::move(throttles), client, traffic_annotation));
   loader->Start(factory, routing_id, request_id, options,
                 std::move(url_request), std::move(task_runner));
   return loader;
 }
 
 ThrottlingURLLoader::~ThrottlingURLLoader() {}
 
 void ThrottlingURLLoader::FollowRedirect() {
   if (url_loader_)
     url_loader_->FollowRedirect();
 }
 
 void ThrottlingURLLoader::SetPriority(net::RequestPriority priority,
                                       int32_t intra_priority_value) {
   if (!url_loader_ && !cancelled_by_throttle_) {
     DCHECK_EQ(DEFERRED_START, deferred_stage_);
     priority_info_ =
         base::MakeUnique<PriorityInfo>(priority, intra_priority_value);
     return;
   }
 
   url_loader_->SetPriority(priority, intra_priority_value);
 }
 
 ThrottlingURLLoader::ThrottlingURLLoader(
     std::vector<std::unique_ptr<URLLoaderThrottle>> throttles,
-    mojom::URLLoaderClient* client)
-    : forwarding_client_(client), client_binding_(this) {
+    mojom::URLLoaderClient* client,
+    const net::MutableNetworkTrafficAnnotationTag& traffic_annotation)
+    : forwarding_client_(client),
+      client_binding_(this),
+      traffic_annotation_(traffic_annotation) {
   if (throttles.size() > 0) {
     // TODO(yzshen): Implement a URLLoaderThrottle subclass which handles a list
     // of URLLoaderThrottles.
     CHECK_EQ(1u, throttles.size());
     throttle_ = std::move(throttles[0]);
     throttle_->set_delegate(this);
   }
 }
 
 void ThrottlingURLLoader::Start(
@@ skipping 19 matching lines @@
                                                 options, std::move(url_request),
                                                 std::move(task_runner));
       return;
     }
   }
 
   mojom::URLLoaderClientPtr client;
   client_binding_.Bind(mojo::MakeRequest(&client), std::move(task_runner));
   factory->CreateLoaderAndStart(mojo::MakeRequest(&url_loader_), routing_id,
                                 request_id, options, *url_request,
-                                std::move(client));
+                                std::move(client), traffic_annotation_);
 }
 
 void ThrottlingURLLoader::OnReceiveResponse(
     const ResourceResponseHead& response_head,
     const base::Optional<net::SSLInfo>& ssl_info,
     mojom::DownloadedTempFilePtr downloaded_file) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
   DCHECK(!cancelled_by_throttle_);
 
   if (throttle_) {
@@ skipping 113 matching lines @@
     return;
 
   switch (deferred_stage_) {
     case DEFERRED_START: {
       mojom::URLLoaderClientPtr client;
       client_binding_.Bind(
           mojo::MakeRequest(&client), std::move(start_info_->task_runner));
       start_info_->url_loader_factory->CreateLoaderAndStart(
           mojo::MakeRequest(&url_loader_), start_info_->routing_id,
           start_info_->request_id, start_info_->options,
-          *start_info_->url_request, std::move(client));
+          *start_info_->url_request, std::move(client), traffic_annotation_);
 
       if (priority_info_) {
         auto priority_info = std::move(priority_info_);
         url_loader_->SetPriority(priority_info->priority,
                                  priority_info->intra_priority_value);
       }
       break;
     }
     case DEFERRED_REDIRECT: {
       client_binding_.ResumeIncomingMethodCallProcessing();
       forwarding_client_->OnReceiveRedirect(redirect_info_->redirect_info,
                                             redirect_info_->response_head);
       break;
     }
     case DEFERRED_RESPONSE: {
       client_binding_.ResumeIncomingMethodCallProcessing();
       forwarding_client_->OnReceiveResponse(
           response_info_->response_head, response_info_->ssl_info,
           std::move(response_info_->downloaded_file));
       break;
     }
     default:
       NOTREACHED();
       break;
   }
   deferred_stage_ = DEFERRED_NONE;
 }
 
 }  // namespace content