Network traffic annotation added to CloudPrintUrlFetcher.

chrome/service/cloud_print/printer_job_handler.cc

 // Copyright (c) 2012 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 "chrome/service/cloud_print/printer_job_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/md5.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/common/cloud_print/cloud_print_helpers.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/service/cloud_print/cloud_print_service_helpers.h"
 #include "chrome/service/cloud_print/job_status_updater.h"
 #include "net/base/mime_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 #include "printing/printing_utils.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 namespace cloud_print {
 
 namespace {
 
 base::subtle::Atomic32 g_total_jobs_started = 0;
 base::subtle::Atomic32 g_total_jobs_done = 0;
@@ skipping 10 matching lines @@
   JOB_HANDLER_SET_IN_PROGRESS,
   JOB_HANDLER_SET_START_PRINTING,
   JOB_HANDLER_START_SPOOLING,
   JOB_HANDLER_SPOOLED,
   JOB_HANDLER_JOB_COMPLETED,
   JOB_HANDLER_INVALID_TICKET,
   JOB_HANDLER_INVALID_DATA,
   JOB_HANDLER_MAX,
 };
 
+net::PartialNetworkTrafficAnnotationTag kPartialTrafficAnnotation =
+    net::DefinePartialNetworkTrafficAnnotation("printer_job_handler",
+                                               "cloud_print",
+                                               R"(
+        semantics {
+          description:
+            "Handles Cloud Print jobs for a particular printer, including "
+            "connecting to printer, sending jobs, updating jobs, and getting "
+            "status."
+          trigger:
+            "Automatic checking if printer is available, registering printer, "
+            "and starting or continuing a printer task."
+          data:
+            "Cloud Print server URL, printer id, job details."
+        })");
+
 }  // namespace
 
 PrinterJobHandler::PrinterInfoFromCloud::PrinterInfoFromCloud()
     : current_xmpp_timeout(0), pending_xmpp_timeout(0) {
 }
 
 PrinterJobHandler::PrinterInfoFromCloud::PrinterInfoFromCloud(
     const PrinterInfoFromCloud& other) = default;
 
 PrinterJobHandler::PrinterJobHandler(
@@ skipping 241 matching lines @@
         job_queue_handler_.GetJobsFromQueue(*json_data);
     if (!jobs.empty()) {
       if (jobs[0].time_remaining_.is_zero()) {
         job_available = true;
         job_details_ = jobs[0];
         job_start_time_ = base::Time::Now();
         base::subtle::NoBarrier_AtomicIncrement(&g_total_jobs_started, 1);
         UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                                   JOB_HANDLER_JOB_STARTED, JOB_HANDLER_MAX);
         SetNextDataHandler(&PrinterJobHandler::HandlePrintTicketResponse);
-        request_ = CloudPrintURLFetcher::Create();
+        request_ = CloudPrintURLFetcher::Create(kPartialTrafficAnnotation);
         if (print_system_->UseCddAndCjt()) {
           request_->StartGetRequest(
               CloudPrintURLFetcher::REQUEST_TICKET,
               GetUrlForJobCjt(cloud_print_server_url_, job_details_.job_id_,
                               job_fetch_reason_),
               this, kJobDataMaxRetryCount, std::string());
         } else {
           request_->StartGetRequest(
               CloudPrintURLFetcher::REQUEST_TICKET,
               GURL(job_details_.print_ticket_url_), this, kJobDataMaxRetryCount,
@@ skipping 27 matching lines @@
           << ", printer id: " << printer_info_cloud_.printer_id;
   std::string mime_type;
   source->GetResponseHeaders()->GetMimeType(&mime_type);
   if (print_system_->ValidatePrintTicket(printer_info_.printer_name, data,
                                          mime_type)) {
     UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                               JOB_HANDLER_VALID_TICKET, JOB_HANDLER_MAX);
     job_details_.print_ticket_ = data;
     job_details_.print_ticket_mime_type_ = mime_type;
     SetNextDataHandler(&PrinterJobHandler::HandlePrintDataResponse);
-    request_ = CloudPrintURLFetcher::Create();
+    request_ = CloudPrintURLFetcher::Create(kPartialTrafficAnnotation);
     std::string accept_headers = "Accept: ";
     accept_headers += print_system_->GetSupportedMimeTypes();
     request_->StartGetRequest(CloudPrintURLFetcher::REQUEST_DATA,
         GURL(job_details_.print_data_url_), this, kJobDataMaxRetryCount,
         accept_headers);
   } else {
     UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                               JOB_HANDLER_INVALID_TICKET, JOB_HANDLER_MAX);
     // The print ticket was not valid. We are done here.
     ValidatePrintTicketFailed();
@@ skipping 87 matching lines @@
       if (!task_in_progress_ && job_check_pending_) {
         UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                                   JOB_HANDLER_JOB_CHECK, JOB_HANDLER_MAX);
         task_in_progress_ = true;
         VLOG(1) << "CP_CONNECTOR: Changed task in progress"
                 ", printer id: " << printer_info_cloud_.printer_id
                 << ", task in progress: " << task_in_progress_;
         job_check_pending_ = false;
         // We need to fetch any pending jobs for this printer
         SetNextJSONHandler(&PrinterJobHandler::HandleJobMetadataResponse);
-        request_ = CloudPrintURLFetcher::Create();
+        request_ = CloudPrintURLFetcher::Create(kPartialTrafficAnnotation);
         request_->StartGetRequest(
             CloudPrintURLFetcher::REQUEST_JOB_FETCH,
             GetUrlForJobFetch(
                 cloud_print_server_url_, printer_info_cloud_.printer_id,
                 job_fetch_reason_),
             this,
             kCloudPrintAPIMaxRetryCount,
             std::string());
         last_job_fetch_time_ = base::TimeTicks::Now();
         VLOG(1) << "CP_CONNECTOR: Last job fetch time"
@@ skipping 71 matching lines @@
   if (error == JOB_SUCCESS) {
     DCHECK_EQ(status, PRINT_JOB_STATUS_IN_PROGRESS);
     UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                               JOB_HANDLER_SET_IN_PROGRESS, JOB_HANDLER_MAX);
     SetNextJSONHandler(
         &PrinterJobHandler::HandleInProgressStatusUpdateResponse);
   } else {
     SetNextJSONHandler(
         &PrinterJobHandler::HandleFailureStatusUpdateResponse);
   }
-  request_ = CloudPrintURLFetcher::Create();
+  request_ = CloudPrintURLFetcher::Create(kPartialTrafficAnnotation);
   request_->StartGetRequest(
       CloudPrintURLFetcher::REQUEST_UPDATE_JOB,
       GetUrlForJobStatusUpdate(cloud_print_server_url_, job_details_.job_id_,
                                status, error),
       this, kCloudPrintAPIMaxRetryCount, std::string());
 }
 
 void PrinterJobHandler::RunScheduledJobCheck() {
   CheckForJobs(kJobFetchReasonRetry);
 }
@@ skipping 30 matching lines @@
   UMA_HISTOGRAM_LONG_TIMES("CloudPrint.SpoolingTime",
                            base::Time::Now() - spooling_start_time_);
   if (shutting_down_)
     return;
 
   local_job_id_ = local_job_id;
   print_thread_.Stop();
 
   // The print job has been spooled locally. We now need to create an object
   // that monitors the status of the job and updates the server.
-  scoped_refptr<JobStatusUpdater> job_status_updater(
-      new JobStatusUpdater(printer_info_.printer_name, job_details_.job_id_,
-                            local_job_id_, cloud_print_server_url_,
-                            print_system_.get(), this));
+  scoped_refptr<JobStatusUpdater> job_status_updater(new JobStatusUpdater(
+      printer_info_.printer_name, job_details_.job_id_, local_job_id_,
+      cloud_print_server_url_, print_system_.get(), this,
+      kPartialTrafficAnnotation));
   job_status_updater_list_.push_back(job_status_updater);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&JobStatusUpdater::UpdateStatus, job_status_updater));
 
   CheckForJobs(kJobFetchReasonQueryMore);
 
   VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
           << ", printer id: " << printer_info_cloud_.printer_id;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 112 matching lines @@
             printer_info_cloud_.current_xmpp_timeout),
         mime_boundary, std::string(), &post_data);
   }
 
   printer_info_ = printer_info;
   if (!post_data.empty()) {
     net::AddMultipartFinalDelimiterForUpload(mime_boundary, &post_data);
     std::string mime_type("multipart/form-data; boundary=");
     mime_type += mime_boundary;
     SetNextJSONHandler(&PrinterJobHandler::HandlePrinterUpdateResponse);
-    request_ = CloudPrintURLFetcher::Create();
+    request_ = CloudPrintURLFetcher::Create(kPartialTrafficAnnotation);
     request_->StartPostRequest(
         CloudPrintURLFetcher::REQUEST_UPDATE_PRINTER,
         GetUrlForPrinterUpdate(
             cloud_print_server_url_, printer_info_cloud_.printer_id),
         this,
         kCloudPrintAPIMaxRetryCount,
         mime_type,
         post_data,
         std::string());
   } else {
@@ skipping 34 matching lines @@
                            this)) {
     OnJobSpoolFailed();
   }
 }
 
 bool PrinterJobHandler::CurrentlyOnPrintThread() const {
   return print_thread_.task_runner()->BelongsToCurrentThread();
 }
 
 }  // namespace cloud_print