Network traffic annotation added to google_apis/gaia.

google_apis/gaia/oauth2_api_call_flow.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 "google_apis/gaia/oauth2_api_call_flow.h"
 
 #include <string>
 #include <vector>
 
 #include "base/strings/stringprintf.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using net::URLFetcher;
 using net::URLFetcherDelegate;
 using net::URLRequestContextGetter;
 using net::URLRequestStatus;
 
 namespace {
 static const char kAuthorizationHeaderFormat[] =
@@ skipping 46 matching lines @@
   CHECK(source);
   CHECK_EQ(API_CALL_STARTED, state_);
   EndApiCall(source);
 }
 
 std::unique_ptr<URLFetcher> OAuth2ApiCallFlow::CreateURLFetcher(
     net::URLRequestContextGetter* context,
     const std::string& access_token) {
   std::string body = CreateApiCallBody();
   net::URLFetcher::RequestType request_type = GetRequestTypeForBody(body);
-  std::unique_ptr<URLFetcher> result =
-      net::URLFetcher::Create(0, CreateApiCallUrl(), request_type, this);
+  net::NetworkTrafficAnnotationTag traffic_annotation =

[msarda, 2017/05/03 09:03:54]

I do not know what this fetcher is supposed to do.

Roger: May I ask you to maybe provide a description for this?

[Roger Tawa OOO till Jul 10th, 2017/05/15 15:14:18]

OAuth2ApiCallFlow helps write code to call google apis.  Users of this class
derive from it, then provide implementations of the CreateApiCallXXX and
GetRequestXXX methods for the particular google api that needs to be called. 
This method creates the URL fetcher based on the return value of these
implementations.

All this to say that I don't think this function knows the semantics of the call
being made.  It seems like OAuth2ApiCallFlow should have a virtual function
like:

virtual net::NetworkTrafficAnnotationTag GetNetworkAnnotation() = 0;

that derived classes need to also implement.  Does not seem like there are lots
of derived classes:

https://cs.chromium.org/search/?q=%22public+OAuth2ApiCallFlow%22&type=cs

[Ramin Halavati, 2017/05/16 05:26:02]

What about adding NetworkTrafficAnnotation as an input argument to this
function?
If it seems good to you, I will move this class from this CL to a new one and
add the 3 other classes that would be affected by this change to the new CL.

+      net::DefineNetworkTrafficAnnotation("...", R"(
+        semantics {
+          sender: "..."
+          description: "..."
+          trigger: "..."
+          data: "..."
+          destination: WEBSITE/GOOGLE_OWNED_SERVICE/OTHER
+        }
+        policy {
+          cookies_allowed: false
+          setting: "..."
+          chrome_policy {
+            [POLICY_NAME] {
+              policy_options {mode: MANDATORY/RECOMMENDED/UNSET}
+              [POLICY_NAME]: ... //(value to disable it)
+            }
+          }
+          policy_exception_justification: "..."
+        })");
+  std::unique_ptr<URLFetcher> result = net::URLFetcher::Create(
+      0, CreateApiCallUrl(), request_type, this, traffic_annotation);
 
   gaia::MarkURLFetcherAsGaia(result.get());
   result->SetRequestContext(context);
   result->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                        net::LOAD_DO_NOT_SAVE_COOKIES);
   result->AddExtraRequestHeader(MakeAuthorizationHeader(access_token));
   // Fetchers are sometimes cancelled because a network change was detected,
   // especially at startup and after sign-in on ChromeOS. Retrying once should
   // be enough in those cases; let the fetcher retry up to 3 times just in case.
   // http://crbug.com/163710
   result->SetAutomaticallyRetryOnNetworkChanges(3);
 
   // Even if the the body is empty, we still set the Content-Type because an
   // empty string may be a meaningful value. For example, a Protocol Buffer
   // message with only default values will be serialized as an empty string.
   if (request_type != net::URLFetcher::GET)
     result->SetUploadData(CreateApiCallBodyContentType(), body);
 
   return result;
 }