Network traffic annotation added to OAuth2ApiCallFlow and its subclasses.

components/proximity_auth/webui/reachable_phone_flow.cc

 // Copyright 2015 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/proximity_auth/webui/reachable_phone_flow.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/cryptauth/cryptauth_client.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/logging/logging.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 
 namespace proximity_auth {
 
 namespace {
 
 // The time, in milliseconds, to wait for phones to respond to the CryptAuth
 // ping before querying for reachable devices.
 const int kWaitTimeMillis = 7000;
 
 }  // namespace
@@ skipping 10 matching lines @@
     callback.Run(std::vector<cryptauth::ExternalDeviceInfo>());
     return;
   }
 
   callback_ = callback;
   client_ = client_factory_->CreateInstance();
 
   // Ping the user's devices to update themselves with CryptAuth.
   cryptauth::SendDeviceSyncTickleRequest tickle_request;
   tickle_request.set_tickle_type(cryptauth::UPDATE_ENROLLMENT);
+  net::PartialNetworkTrafficAnnotationTag partial_traffic_annotation =
+      net::DefinePartialNetworkTrafficAnnotation("cryptauth_device_sync_tickle",
+                                                 "oauth2_api_call_flow", R"(
+      semantics {
+        sender: "EasyUnlock Debug UI"
+        description:
+          "Triggers a sync on all other device (for the same user) registered "
+          "on CryptAuth."
+        trigger: "User manually opens the EasyUnlock debug UI."
+        data: "OAuth 2.0 token and the device public key."
+        destination: GOOGLE_OWNED_SERVICE
+      }
+      policy {
+        setting:
+          "This feature cannot be disabled in settings, but this request will "
+          "only be sent if the user opens the EasyUnlock debug UI."
+        chrome_policy {
+          SigninAllowed {
+            SigninAllowed: false
+          }
+        }
+      })");
   client_->SendDeviceSyncTickle(
-      tickle_request, base::Bind(&ReachablePhoneFlow::OnSyncTickleSuccess,
-                                 weak_ptr_factory_.GetWeakPtr()),
+      tickle_request,
+      base::Bind(&ReachablePhoneFlow::OnSyncTickleSuccess,
+                 weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&ReachablePhoneFlow::OnApiCallError,
-                 weak_ptr_factory_.GetWeakPtr()));
+                 weak_ptr_factory_.GetWeakPtr()),
+      partial_traffic_annotation);
 }
 
 void ReachablePhoneFlow::OnSyncTickleSuccess(
     const cryptauth::SendDeviceSyncTickleResponse& response) {
   PA_LOG(INFO) << "Waiting " << kWaitTimeMillis
                << "ms for phones to callback to CryptAuth...";
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ReachablePhoneFlow::QueryReachablePhones,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kWaitTimeMillis));
@@ skipping 23 matching lines @@
             response.eligible_devices().end(), reachable_phones.begin());
   callback_.Run(reachable_phones);
 }
 
 void ReachablePhoneFlow::OnApiCallError(const std::string& error) {
   PA_LOG(ERROR) << "Error making api call: " << error;
   callback_.Run(std::vector<cryptauth::ExternalDeviceInfo>());
 }
 
 }  // namespace proximity_auth