Network traffic annotation added to OAuth2ApiCallFlow and its subclasses.

components/cryptauth/cryptauth_client_impl.cc

 // Copyright 2014 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/cryptauth/cryptauth_client_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 49 matching lines @@
       has_call_started_(false),
       weak_ptr_factory_(this) {}
 
 CryptAuthClientImpl::~CryptAuthClientImpl() {
 }
 
 void CryptAuthClientImpl::GetMyDevices(
     const GetMyDevicesRequest& request,
     const GetMyDevicesCallback& callback,
     const ErrorCallback& error_callback) {
-  MakeApiCall(kGetMyDevicesPath, request, callback, error_callback);
+  net::PartialNetworkTrafficAnnotationTag partial_traffic_annotation =
+      net::DefinePartialNetworkTrafficAnnotation("...", "oauth2_api_call_flow",
+                                                 R"(
+      semantics {
+        sender: "..."
+        description: "..."
+        trigger: "..."
+        data: "..."
+        destination: WEBSITE/GOOGLE_OWNED_SERVICE/OTHER/LOCAL
+      }
+      policy {
+        setting: "..."
+        chrome_policy {
+          [POLICY_NAME] {
+            policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+            [POLICY_NAME]: ... //(value to disable it)
+          }
+        }
+        policy_exception_justification: "..."
+      })");
+  MakeApiCall(kGetMyDevicesPath, request, callback, error_callback,
+              partial_traffic_annotation);
 }
 
 void CryptAuthClientImpl::FindEligibleUnlockDevices(
     const FindEligibleUnlockDevicesRequest& request,
     const FindEligibleUnlockDevicesCallback& callback,
     const ErrorCallback& error_callback) {
-  MakeApiCall(kFindEligibleUnlockDevicesPath, request, callback,
-              error_callback);
+  net::PartialNetworkTrafficAnnotationTag partial_traffic_annotation =
+      net::DefinePartialNetworkTrafficAnnotation("...", "oauth2_api_call_flow",
+                                                 R"(
+      semantics {
+        sender: "..."
+        description: "..."
+        trigger: "..."
+        data: "..."
+        destination: WEBSITE/GOOGLE_OWNED_SERVICE/OTHER/LOCAL
+      }
+      policy {
+        setting: "..."
+        chrome_policy {
+          [POLICY_NAME] {
+            policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+            [POLICY_NAME]: ... //(value to disable it)
+          }
+        }
+        policy_exception_justification: "..."
+      })");
+  MakeApiCall(kFindEligibleUnlockDevicesPath, request, callback, error_callback,
+              partial_traffic_annotation);
 }
 
 void CryptAuthClientImpl::SendDeviceSyncTickle(
     const SendDeviceSyncTickleRequest& request,
     const SendDeviceSyncTickleCallback& callback,
     const ErrorCallback& error_callback) {
-  MakeApiCall(kSendDeviceSyncTicklePath, request, callback, error_callback);
+  net::PartialNetworkTrafficAnnotationTag partial_traffic_annotation =
+      net::DefinePartialNetworkTrafficAnnotation("...", "oauth2_api_call_flow",
+                                                 R"(
+      semantics {
+        sender: "..."
+        description: "..."
+        trigger: "..."
+        data: "..."
+        destination: WEBSITE/GOOGLE_OWNED_SERVICE/OTHER/LOCAL
+      }
+      policy {
+        setting: "..."
+        chrome_policy {
+          [POLICY_NAME] {
+            policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+            [POLICY_NAME]: ... //(value to disable it)
+          }
+        }
+        policy_exception_justification: "..."
+      })");
+  MakeApiCall(kSendDeviceSyncTicklePath, request, callback, error_callback,
+              partial_traffic_annotation);
 }
 
 void CryptAuthClientImpl::ToggleEasyUnlock(
     const ToggleEasyUnlockRequest& request,
     const ToggleEasyUnlockCallback& callback,
     const ErrorCallback& error_callback) {
-  MakeApiCall(kToggleEasyUnlockPath, request, callback, error_callback);
+  net::PartialNetworkTrafficAnnotationTag partial_traffic_annotation =
+      net::DefinePartialNetworkTrafficAnnotation("...", "oauth2_api_call_flow",
+                                                 R"(
+      semantics {
+        sender: "..."
+        description: "..."
+        trigger: "..."
+        data: "..."
+        destination: WEBSITE/GOOGLE_OWNED_SERVICE/OTHER/LOCAL
+      }
+      policy {
+        setting: "..."
+        chrome_policy {
+          [POLICY_NAME] {
+            policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+            [POLICY_NAME]: ... //(value to disable it)
+          }
+        }
+        policy_exception_justification: "..."
+      })");
+  MakeApiCall(kToggleEasyUnlockPath, request, callback, error_callback,
+              partial_traffic_annotation);
 }
 
 void CryptAuthClientImpl::SetupEnrollment(
     const SetupEnrollmentRequest& request,
     const SetupEnrollmentCallback& callback,
     const ErrorCallback& error_callback) {
-  MakeApiCall(kSetupEnrollmentPath, request, callback, error_callback);
+  net::PartialNetworkTrafficAnnotationTag partial_traffic_annotation =
+      net::DefinePartialNetworkTrafficAnnotation("...", "oauth2_api_call_flow",
+                                                 R"(
+      semantics {
+        sender: "..."
+        description: "..."
+        trigger: "..."
+        data: "..."
+        destination: WEBSITE/GOOGLE_OWNED_SERVICE/OTHER/LOCAL
+      }
+      policy {
+        setting: "..."
+        chrome_policy {
+          [POLICY_NAME] {
+            policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+            [POLICY_NAME]: ... //(value to disable it)
+          }
+        }
+        policy_exception_justification: "..."
+      })");
+  MakeApiCall(kSetupEnrollmentPath, request, callback, error_callback,
+              partial_traffic_annotation);
 }
 
 void CryptAuthClientImpl::FinishEnrollment(
     const FinishEnrollmentRequest& request,
     const FinishEnrollmentCallback& callback,
     const ErrorCallback& error_callback) {
-  MakeApiCall(kFinishEnrollmentPath, request, callback, error_callback);
+  net::PartialNetworkTrafficAnnotationTag partial_traffic_annotation =
+      net::DefinePartialNetworkTrafficAnnotation("...", "oauth2_api_call_flow",
+                                                 R"(
+      semantics {
+        sender: "..."
+        description: "..."
+        trigger: "..."
+        data: "..."
+        destination: WEBSITE/GOOGLE_OWNED_SERVICE/OTHER/LOCAL
+      }
+      policy {
+        setting: "..."
+        chrome_policy {
+          [POLICY_NAME] {
+            policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+            [POLICY_NAME]: ... //(value to disable it)
+          }
+        }
+        policy_exception_justification: "..."
+      })");
+  MakeApiCall(kFinishEnrollmentPath, request, callback, error_callback,
+              partial_traffic_annotation);
 }
 
 std::string CryptAuthClientImpl::GetAccessTokenUsed() {
   return access_token_used_;
 }
 
 template <class RequestProto, class ResponseProto>
 void CryptAuthClientImpl::MakeApiCall(
     const std::string& request_path,
     const RequestProto& request_proto,
     const base::Callback<void(const ResponseProto&)>& response_callback,
-    const ErrorCallback& error_callback) {
+    const ErrorCallback& error_callback,
+    const net::PartialNetworkTrafficAnnotationTag& partial_traffic_annotation) {
   if (has_call_started_) {
     error_callback.Run(
         "Client has been used for another request. Do not reuse.");
     return;
   }
   has_call_started_ = true;
 
+  api_call_flow_->SetPartialNetworkTrafficAnnotation(
+      partial_traffic_annotation);
+
   // The |device_classifier| field must be present for all CryptAuth requests.
   RequestProto request_copy(request_proto);
   request_copy.mutable_device_classifier()->CopyFrom(device_classifier_);
 
   std::string serialized_request;
   if (!request_copy.SerializeToString(&serialized_request)) {
     error_callback.Run(std::string("Failed to serialize ") +
                        request_proto.GetTypeName() + " proto.");
     return;
   }
@@ skipping 58 matching lines @@
 
 std::unique_ptr<CryptAuthClient> CryptAuthClientFactoryImpl::CreateInstance() {
   return base::MakeUnique<CryptAuthClientImpl>(
       base::WrapUnique(new CryptAuthApiCallFlow()),
       base::WrapUnique(
           new CryptAuthAccessTokenFetcherImpl(token_service_, account_id_)),
       url_request_context_, device_classifier_);
 }
 
 }  // namespace cryptauth