Network traffic annotation added to OAuth2ApiCallFlow and its subclasses.

components/cryptauth/cryptauth_client_impl_unittest.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 "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/null_task_runner.h"
 #include "components/cryptauth/cryptauth_access_token_fetcher.h"
 #include "components/cryptauth/cryptauth_api_call_flow.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/switches.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Return;
 using testing::SaveArg;
@@ skipping 30 matching lines @@
     access_token_ = access_token;
   };
 
  private:
   std::string access_token_;
 };
 
 // Mock CryptAuthApiCallFlow, which handles the HTTP requests to CryptAuth.
 class MockCryptAuthApiCallFlow : public CryptAuthApiCallFlow {
  public:
-  MockCryptAuthApiCallFlow() : CryptAuthApiCallFlow() {}
+  MockCryptAuthApiCallFlow() : CryptAuthApiCallFlow() {
+    SetPartialNetworkTrafficAnnotation(PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
+  }
   virtual ~MockCryptAuthApiCallFlow() {}
 
   MOCK_METHOD6(Start,
                void(const GURL&,
                     net::URLRequestContextGetter* context,
                     const std::string& access_token,
                     const std::string& serialized_request,
                     const ResultCallback& result_callback,
                     const ErrorCallback& error_callback));
 
@@ skipping 82 matching lines @@
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   GetMyDevicesResponse result_proto;
   GetMyDevicesRequest request_proto;
   request_proto.set_allow_stale_read(true);
   client_->GetMyDevices(
       request_proto,
       base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto),
-      base::Bind(&NotCalled<std::string>));
+      base::Bind(&NotCalled<std::string>),
+      PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
   GetMyDevicesRequest expected_request;
   EXPECT_TRUE(expected_request.ParseFromString(serialized_request_));
   EXPECT_TRUE(expected_request.allow_stale_read());
 
   // Return two devices, one unlock key and one unlockable device.
   {
     GetMyDevicesResponse response_proto;
     response_proto.add_devices();
     response_proto.mutable_devices(0)->set_public_key(kPublicKey1);
@@ skipping 16 matching lines @@
 }
 
 TEST_F(CryptAuthClientTest, GetMyDevicesFailure) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   std::string error_message;
   client_->GetMyDevices(GetMyDevicesRequest(),
                         base::Bind(&NotCalled<GetMyDevicesResponse>),
-                        base::Bind(&SaveResult<std::string>, &error_message));
+                        base::Bind(&SaveResult<std::string>, &error_message),
+                        PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
   std::string kStatus500Error("HTTP status: 500");
   FailApiCallFlow(kStatus500Error);
   EXPECT_EQ(kStatus500Error, error_message);
 }
 
 TEST_F(CryptAuthClientTest, FindEligibleUnlockDevicesSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "findeligibleunlockdevices?alt=proto");
@@ skipping 55 matching lines @@
 }
 
 TEST_F(CryptAuthClientTest, SendDeviceSyncTickleSuccess) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "senddevicesynctickle?alt=proto");
 
   SendDeviceSyncTickleResponse result_proto;
   client_->SendDeviceSyncTickle(
       SendDeviceSyncTickleRequest(),
-      base::Bind(&SaveResult<SendDeviceSyncTickleResponse>,
-                 &result_proto),
-      base::Bind(&NotCalled<std::string>));
+      base::Bind(&SaveResult<SendDeviceSyncTickleResponse>, &result_proto),
+      base::Bind(&NotCalled<std::string>),
+      PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
   SendDeviceSyncTickleRequest expected_request;
   EXPECT_TRUE(expected_request.ParseFromString(serialized_request_));
 
   SendDeviceSyncTickleResponse response_proto;
   FinishApiCallFlow(&response_proto);
 }
 
 TEST_F(CryptAuthClientTest, ToggleEasyUnlockSuccess) {
   ExpectRequest(
@@ skipping 99 matching lines @@
   }
   EXPECT_EQ("OK", result_proto.status());
 }
 
 TEST_F(CryptAuthClientTest, FetchAccessTokenFailure) {
   access_token_fetcher_->set_access_token("");
 
   std::string error_message;
   client_->GetMyDevices(GetMyDevicesRequest(),
                         base::Bind(&NotCalled<GetMyDevicesResponse>),
-                        base::Bind(&SaveResult<std::string>, &error_message));
+                        base::Bind(&SaveResult<std::string>, &error_message),
+                        PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
   EXPECT_EQ("Failed to get a valid access token.", error_message);
 }
 
 TEST_F(CryptAuthClientTest, ParseResponseProtoFailure) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   std::string error_message;
   client_->GetMyDevices(GetMyDevicesRequest(),
                         base::Bind(&NotCalled<GetMyDevicesResponse>),
-                        base::Bind(&SaveResult<std::string>, &error_message));
+                        base::Bind(&SaveResult<std::string>, &error_message),
+                        PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
   flow_result_callback_.Run("Not a valid serialized response message.");
   EXPECT_EQ("Failed to parse response proto.", error_message);
 }
 
 TEST_F(CryptAuthClientTest,
        MakeSecondRequestBeforeFirstRequestSucceeds) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   // Make first request.
   GetMyDevicesResponse result_proto;
   client_->GetMyDevices(
       GetMyDevicesRequest(),
       base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto),
-      base::Bind(&NotCalled<std::string>));
+      base::Bind(&NotCalled<std::string>),
+      PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
   // With request pending, make second request.
   {
     std::string error_message;
     client_->FindEligibleUnlockDevices(
         FindEligibleUnlockDevicesRequest(),
         base::Bind(&NotCalled<FindEligibleUnlockDevicesResponse>),
         base::Bind(&SaveResult<std::string>, &error_message));
     EXPECT_EQ("Client has been used for another request. Do not reuse.",
               error_message);
@@ skipping 14 matching lines @@
 TEST_F(CryptAuthClientTest,
        MakeSecondRequestBeforeFirstRequestFails) {
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   // Make first request.
   std::string error_message;
   client_->GetMyDevices(GetMyDevicesRequest(),
                         base::Bind(&NotCalled<GetMyDevicesResponse>),
-                        base::Bind(&SaveResult<std::string>, &error_message));
+                        base::Bind(&SaveResult<std::string>, &error_message),
+                        PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
   // With request pending, make second request.
   {
     std::string error_message;
     client_->FindEligibleUnlockDevices(
         FindEligibleUnlockDevicesRequest(),
         base::Bind(&NotCalled<FindEligibleUnlockDevicesResponse>),
         base::Bind(&SaveResult<std::string>, &error_message));
     EXPECT_EQ("Client has been used for another request. Do not reuse.",
               error_message);
   }
 
   // Fail first request.
   std::string kStatus429Error = "HTTP status: 429";
   FailApiCallFlow(kStatus429Error);
   EXPECT_EQ(kStatus429Error, error_message);
 }
 
 TEST_F(CryptAuthClientTest,
        MakeSecondRequestAfterFirstRequestSucceeds) {
   // Make first request successfully.
   {
     ExpectRequest(
         "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
         "getmydevices?alt=proto");
     GetMyDevicesResponse result_proto;
     client_->GetMyDevices(
         GetMyDevicesRequest(),
         base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto),
-        base::Bind(&NotCalled<std::string>));
+        base::Bind(&NotCalled<std::string>),
+        PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
 
     GetMyDevicesResponse response_proto;
     response_proto.add_devices();
     response_proto.mutable_devices(0)->set_public_key(kPublicKey1);
     FinishApiCallFlow(&response_proto);
     ASSERT_EQ(1, result_proto.devices_size());
     EXPECT_EQ(kPublicKey1, result_proto.devices(0).public_key());
   }
 
   // Second request fails.
@@ skipping 12 matching lines @@
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   GetMyDevicesResponse result_proto;
   GetMyDevicesRequest request_proto;
   request_proto.set_allow_stale_read(true);
   client_->GetMyDevices(
       request_proto,
       base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto),
-      base::Bind(&NotCalled<std::string>));
+      base::Bind(&NotCalled<std::string>),
+      PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
   GetMyDevicesRequest expected_request;
   EXPECT_TRUE(expected_request.ParseFromString(serialized_request_));
 
   const DeviceClassifier& device_classifier =
       expected_request.device_classifier();
   EXPECT_EQ(kDeviceOsVersionCode, device_classifier.device_os_version_code());
   EXPECT_EQ(kDeviceSoftwareVersionCode,
             device_classifier.device_software_version_code());
   EXPECT_EQ(kDeviceSoftwarePackage,
             device_classifier.device_software_package());
   EXPECT_EQ(kDeviceType, device_classifier.device_type());
 }
 
 TEST_F(CryptAuthClientTest, GetAccessTokenUsed) {
   EXPECT_TRUE(client_->GetAccessTokenUsed().empty());
   ExpectRequest(
       "https://www.testgoogleapis.com/cryptauth/v1/deviceSync/"
       "getmydevices?alt=proto");
 
   GetMyDevicesResponse result_proto;
   GetMyDevicesRequest request_proto;
   request_proto.set_allow_stale_read(true);
   client_->GetMyDevices(
       request_proto,
       base::Bind(&SaveResult<GetMyDevicesResponse>, &result_proto),
-      base::Bind(&NotCalled<std::string>));
+      base::Bind(&NotCalled<std::string>),
+      PARTIAL_TRAFFIC_ANNOTATION_FOR_TESTS);
   EXPECT_EQ(kAccessToken, client_->GetAccessTokenUsed());
 }
 
 }  // namespace cryptauth