Network traffic annotation added to common/cloud.

components/policy/core/common/cloud/external_policy_data_fetcher.cc

 // Copyright 2013 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 "components/policy/core/common/cloud/external_policy_data_fetcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 namespace policy {
 
 namespace {
 
 // Helper that forwards the result of a fetch job from the thread that the
 // ExternalPolicyDataFetcherBackend runs on to the thread that the
@@ skipping 140 matching lines @@
 std::unique_ptr<ExternalPolicyDataFetcher>
 ExternalPolicyDataFetcherBackend::CreateFrontend(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   return base::MakeUnique<ExternalPolicyDataFetcher>(
       task_runner, io_task_runner_, weak_factory_.GetWeakPtr());
 }
 
 void ExternalPolicyDataFetcherBackend::StartJob(
     ExternalPolicyDataFetcher::Job* job) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
-  std::unique_ptr<net::URLFetcher> owned_fetcher = net::URLFetcher::Create(
-      ++last_fetch_id_, job->url, net::URLFetcher::GET, this);
+  net::NetworkTrafficAnnotationTag traffic_annotation =
+      net::DefineNetworkTrafficAnnotation("external_policy_fetcher", R"(
+        semantics {
+          sender: "Cloud Policy"
+          description:
+            "Used to fetch policy for extensions, policy-controlled wallpaper, "
+            "and custom terms of service."
+          trigger:
+            "Periodically loaded when a managed user is signed in to Chrome."
+          data:
+            "This request does not send any data. It loads external resources "
+            "by a unique URL provided by the admin."
+          destination: GOOGLE_OWNED_SERVICE
+        }
+        policy {
+          cookies_allowed: false
+          setting:
+            "This feature cannot be controlled by Chrome settings, but users "
+            "can sign out of Chrome to disable it."
+          policy_exception_justification:
+            "Not implemented, considered not useful. This request is part of "
+            "the policy fetcher itself."
+        })");
+  std::unique_ptr<net::URLFetcher> owned_fetcher =
+      net::URLFetcher::Create(++last_fetch_id_, job->url, net::URLFetcher::GET,
+                              this, traffic_annotation);
   net::URLFetcher* fetcher = owned_fetcher.get();
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher, data_use_measurement::DataUseUserData::POLICY);
   fetcher->SetRequestContext(request_context_.get());
   fetcher->SetLoadFlags(net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE |
                         net::LOAD_DO_NOT_SAVE_COOKIES |
                         net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SEND_AUTH_DATA);
   fetcher->SetAutomaticallyRetryOnNetworkChanges(3);
   fetcher->Start();
@@ skipping 74 matching lines @@
   ExternalPolicyDataFetcher::Job* job = it->second.job;
   int64_t max_size = job->max_size;
   if (current > max_size || total > max_size) {
     job_map_.erase(it);
     job->callback.Run(job, ExternalPolicyDataFetcher::MAX_SIZE_EXCEEDED,
                       std::unique_ptr<std::string>());
   }
 }
 
 }  // namespace policy