Network traffic annotation added to URLLoaderImpl.

net/traffic_annotation/network_traffic_annotation.h

 // Copyright 2017 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.
 
 #ifndef NET_TRAFFIC_ANNOTATION_NETWORK_TRAFFIC_ANNOTATION_H_
 #define NET_TRAFFIC_ANNOTATION_NETWORK_TRAFFIC_ANNOTATION_H_
 
 #include "base/logging.h"
 
 namespace {
@@ skipping 20 matching lines @@
 
 namespace net {
 
 // Defined types for network traffic annotation tags.
 struct NetworkTrafficAnnotationTag {
   const int32_t unique_id_hash_code;
 };
 struct PartialNetworkTrafficAnnotationTag {
   const int32_t unique_id_hash_code;
 
-#if defined(_DEBUG) || defined(DCHECK_ALWAYS_ON)
+#ifndef NDEBUG

[jochen (gone - plz use gerrit), 2017/06/12 08:34:25]

can you keep the DCHECK_ALWAYS_ON check? i.e.

!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)

[Ramin Halavati, 2017/06/12 09:04:55]

Done.

   // |completing_id_hash_code| holds a reference to the hash coded unique id
   // of a network traffic annotation (or group id of several network traffic
   // annotations) that complete a partial network annotation. Please refer to
   // the description of DefinePartialNetworkTrafficAnnotation function for more
   // details.
   // This value is used by the clang tools to find linkage between partial
   // annotations and their completing parts, and is used in debug mode to check
   // if an intended completing part is added to a partial network annotation.
   const int32_t completing_id_hash_code;
 #endif
@@ skipping 38 matching lines @@
 // 'BranchedCompleteNetworkTrafficAnnotation' functions. In case of
 // CompleteNetworkTrafficAnnotation, |completing_id| is the unique id of the
 // annotation that will complete it. In the case of
 // BranchedCompleteNetworkTrafficAnnotation, |completing_id| is the group id
 // of the completing annotations.
 template <size_t N1, size_t N2, size_t N3>
 constexpr PartialNetworkTrafficAnnotationTag
 DefinePartialNetworkTrafficAnnotation(const char (&unique_id)[N1],
                                       const char (&completing_id)[N2],
                                       const char (&proto)[N3]) {
-#if defined(_DEBUG) || defined(DCHECK_ALWAYS_ON)
+#ifndef NDEBUG
   return PartialNetworkTrafficAnnotationTag(
       {COMPUTE_STRING_HASH(unique_id), COMPUTE_STRING_HASH(completing_id)});
 #else
   return PartialNetworkTrafficAnnotationTag({COMPUTE_STRING_HASH(unique_id)});
 #endif
 }
 
 // This function can be used to define a completing partial annotation. This
 // annotation adds details to another annotation that is defined before.
 // |partial_annotation| is the PartialNetworkTrafficAnnotationTag returned
 // by a call to DefinePartialNetworkTrafficAnnotation().
 template <size_t N1, size_t N2>
 NetworkTrafficAnnotationTag CompleteNetworkTrafficAnnotation(
     const char (&unique_id)[N1],
     const PartialNetworkTrafficAnnotationTag& partial_annotation,
     const char (&proto)[N2]) {
-#if defined(_DEBUG) || defined(DCHECK_ALWAYS_ON)
+#ifndef NDEBUG
   DCHECK(partial_annotation.completing_id_hash_code ==
              COMPUTE_STRING_HASH(unique_id) ||
          partial_annotation.unique_id_hash_code ==
              COMPUTE_STRING_HASH("test_partial") ||
          partial_annotation.unique_id_hash_code ==
              COMPUTE_STRING_HASH("undefined"));
 #endif
   return NetworkTrafficAnnotationTag({partial_annotation.unique_id_hash_code});
 }
 
 // This function can be used to define a completing partial annotation that is
 // branched into several annotations. In this case, |group_id| is a common id
 // that is used by all members of the branch and referenced by partial
 // annotation that is completed by them.
 template <size_t N1, size_t N2, size_t N3>
 NetworkTrafficAnnotationTag BranchedCompleteNetworkTrafficAnnotation(
     const char (&unique_id)[N1],
     const char (&group_id)[N2],
     const PartialNetworkTrafficAnnotationTag& partial_annotation,
     const char (&proto)[N3]) {
-#if defined(_DEBUG) || defined(DCHECK_ALWAYS_ON)
+#ifndef NDEBUG
   DCHECK(partial_annotation.completing_id_hash_code ==
              COMPUTE_STRING_HASH(unique_id) ||
          partial_annotation.unique_id_hash_code ==
              COMPUTE_STRING_HASH("test_partial") ||
          partial_annotation.unique_id_hash_code ==
              COMPUTE_STRING_HASH("undefined"));
 #endif
   return NetworkTrafficAnnotationTag({COMPUTE_STRING_HASH(unique_id)});
 }
 
@@ skipping 38 matching lines @@
 //     // final_tag is hash code of "call_bool_branch_1".
 //     net::URLFetcher::Create(url1, ..., final_tag);
 //   } else {
 //     auto final_tag = BranchedCompleteNetworkTrafficAnnotation(
 //       "call_bool_branch_2", "completion_by_bar", tag, [rest_of_proto]);
 //     // final_tag is hash code of "call_bool_branch_2".
 //     net::URLFetcher::Create(url2, ..., final_tag);
 //   }
 // }
 
+#define TRAFFIC_ANNOTATION_UNINITIALIZED -1
+
+// Do not use this unless net-serialization is required.
+// TODO(crbug.com/690323): Add tools to check constructor of this structure is
+// used only in .mojom.cc files.
+struct MutableNetworkTrafficAnnotationTag {
+  MutableNetworkTrafficAnnotationTag()
+      : unique_id_hash_code(TRAFFIC_ANNOTATION_UNINITIALIZED) {}
+  explicit MutableNetworkTrafficAnnotationTag(
+      const NetworkTrafficAnnotationTag& traffic_annotation)
+      : unique_id_hash_code(traffic_annotation.unique_id_hash_code) {}
+
+  int32_t unique_id_hash_code;
+
+  explicit operator NetworkTrafficAnnotationTag() const {
+    return NetworkTrafficAnnotationTag({unique_id_hash_code});
+  }
+};
+
+struct MutablePartialNetworkTrafficAnnotationTag {
+#ifndef NDEBUG
+  MutablePartialNetworkTrafficAnnotationTag()
+      : unique_id_hash_code(TRAFFIC_ANNOTATION_UNINITIALIZED),
+        completing_id_hash_code(TRAFFIC_ANNOTATION_UNINITIALIZED) {}
+  explicit MutablePartialNetworkTrafficAnnotationTag(
+      const PartialNetworkTrafficAnnotationTag& partial_traffic_annotation)
+      : unique_id_hash_code(partial_traffic_annotation.unique_id_hash_code),
+        completing_id_hash_code(
+            partial_traffic_annotation.completing_id_hash_code) {}
+
+  int32_t unique_id_hash_code;
+  int32_t completing_id_hash_code;
+
+  explicit operator PartialNetworkTrafficAnnotationTag() const {
+    return PartialNetworkTrafficAnnotationTag(
+        {unique_id_hash_code, completing_id_hash_code});
+  }
+#else
+  MutablePartialNetworkTrafficAnnotationTag()
+      : unique_id_hash_code(TRAFFIC_ANNOTATION_UNINITIALIZED) {}
+  explicit MutablePartialNetworkTrafficAnnotationTag(
+      const PartialNetworkTrafficAnnotationTag& partial_traffic_annotation)
+      : unique_id_hash_code(partial_traffic_annotation.unique_id_hash_code) {}
+
+  int32_t unique_id_hash_code;
+
+  explicit operator PartialNetworkTrafficAnnotationTag() const {
+    return PartialNetworkTrafficAnnotationTag({unique_id_hash_code});
+  }
+#endif  // NDEBUG
+};
+
 }  // namespace net
 
 // Placeholder for unannotated usages.
 #define NO_TRAFFIC_ANNOTATION_YET \
   net::DefineNetworkTrafficAnnotation("undefined", "Nothing here yet.")
 
 #define NO_PARTIAL_TRAFFIC_ANNOTATION_YET                              \
   net::DefinePartialNetworkTrafficAnnotation("undefined", "undefined", \
                                              "Nothing here yet.")
 
 #define MISSING_TRAFFIC_ANNOTATION     \
   net::DefineNetworkTrafficAnnotation( \
       "missing", "Function called without traffic annotation.")
 
 #undef COMPUTE_STRING_HASH
 
 #endif  // NET_TRAFFIC_ANNOTATION_NETWORK_TRAFFIC_ANNOTATION_H_