Fixing ODR violations in Roll abseil_revision abd0824ba6..af7882601a

I forgot to patch dynamic_annotations following the instructions in
README.chromium when I rolled Abseil last time.

TBR=phoglund@chromium.org

Bug: None
Change-Id: Ib295b0b9d59cb50853f552b5c38a5b1d54b50a3f
Reviewed-on: https://chromium-review.googlesource.com/1046054Reviewed-by: Patrik Höglund <phoglund@chromium.org>
Commit-Queue: Mirko Bonadei <mbonadei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556389}

third_party/abseil-cpp/absl/base/dynamic_annotations.cc

@@ -42,29 +42,29 @@
 extern "C" {
 #endif
 
-void AnnotateRWLockCreate(const char *, int,
+void AbslAnnotateRWLockCreate(const char *, int,
                           const volatile void *){}
-void AnnotateRWLockDestroy(const char *, int,
+void AbslAnnotateRWLockDestroy(const char *, int,
                            const volatile void *){}
-void AnnotateRWLockAcquired(const char *, int,
+void AbslAnnotateRWLockAcquired(const char *, int,
                             const volatile void *, long){}
-void AnnotateRWLockReleased(const char *, int,
+void AbslAnnotateRWLockReleased(const char *, int,
                             const volatile void *, long){}
-void AnnotateBenignRace(const char *, int,
+void AbslAnnotateBenignRace(const char *, int,
                         const volatile void *,
                         const char *){}
-void AnnotateBenignRaceSized(const char *, int,
+void AbslAnnotateBenignRaceSized(const char *, int,
                              const volatile void *,
                              size_t,
                              const char *) {}
-void AnnotateThreadName(const char *, int,
+void AbslAnnotateThreadName(const char *, int,
                         const char *){}
-void AnnotateIgnoreReadsBegin(const char *, int){}
-void AnnotateIgnoreReadsEnd(const char *, int){}
-void AnnotateIgnoreWritesBegin(const char *, int){}
-void AnnotateIgnoreWritesEnd(const char *, int){}
-void AnnotateEnableRaceDetection(const char *, int, int){}
-void AnnotateMemoryIsInitialized(const char *, int,
+void AbslAnnotateIgnoreReadsBegin(const char *, int){}
+void AbslAnnotateIgnoreReadsEnd(const char *, int){}
+void AbslAnnotateIgnoreWritesBegin(const char *, int){}
+void AbslAnnotateIgnoreWritesEnd(const char *, int){}
+void AbslAnnotateEnableRaceDetection(const char *, int, int){}
+void AbslAnnotateMemoryIsInitialized(const char *, int,
                                  const volatile void *mem, size_t size) {
 #if __has_feature(memory_sanitizer)
   __msan_unpoison(mem, size);
@@ -74,7 +74,7 @@ void AnnotateMemoryIsInitialized(const char *, int,
 #endif
 }
 
-void AnnotateMemoryIsUninitialized(const char *, int,
+void AbslAnnotateMemoryIsUninitialized(const char *, int,
                                    const volatile void *mem, size_t size) {
 #if __has_feature(memory_sanitizer)
   __msan_allocated_memory(mem, size);
@@ -84,7 +84,7 @@ void AnnotateMemoryIsUninitialized(const char *, int,
 #endif
 }
 
-static int GetRunningOnValgrind(void) {
+static int GetAbslRunningOnValgrind(void) {
 #ifdef RUNNING_ON_VALGRIND
   if (RUNNING_ON_VALGRIND) return 1;
 #endif
@@ -96,24 +96,24 @@ static int GetRunningOnValgrind(void) {
 }
 
 /* See the comments in dynamic_annotations.h */
-int RunningOnValgrind(void) {
+int AbslRunningOnValgrind(void) {
   static volatile int running_on_valgrind = -1;
   int local_running_on_valgrind = running_on_valgrind;
   /* C doesn't have thread-safe initialization of statics, and we
      don't want to depend on pthread_once here, so hack it. */
   ANNOTATE_BENIGN_RACE(&running_on_valgrind, "safe hack");
   if (local_running_on_valgrind == -1)
-    running_on_valgrind = local_running_on_valgrind = GetRunningOnValgrind();
+    running_on_valgrind = local_running_on_valgrind = GetAbslRunningOnValgrind();
   return local_running_on_valgrind;
 }
 
 /* See the comments in dynamic_annotations.h */
-double ValgrindSlowdown(void) {
-  /* Same initialization hack as in RunningOnValgrind(). */
+double AbslValgrindSlowdown(void) {
+  /* Same initialization hack as in AbslRunningOnValgrind(). */
   static volatile double slowdown = 0.0;
   double local_slowdown = slowdown;
   ANNOTATE_BENIGN_RACE(&slowdown, "safe hack");
-  if (RunningOnValgrind() == 0) {
+  if (AbslRunningOnValgrind() == 0) {
     return 1.0;
   }
   if (local_slowdown == 0.0) {

third_party/abseil-cpp/absl/debugging/internal/vdso_support.cc

@@ -79,7 +79,7 @@ const void *VDSOSupport::Init() {
     // on stack, and so glibc works as if VDSO was not present.
     // But going directly to kernel via /proc/self/auxv below bypasses
     // Valgrind zapping. So we check for Valgrind separately.
-    if (RunningOnValgrind()) {
+    if (AbslRunningOnValgrind()) {
       vdso_base_.store(nullptr, std::memory_order_relaxed);
       getcpu_fn_.store(&GetCPUViaSyscall, std::memory_order_relaxed);
       return nullptr;

third_party/abseil-cpp/absl/strings/string_view_test.cc

@@ -1052,7 +1052,7 @@ TEST(FindOneCharTest, EdgeCases) {
 
 #ifndef THREAD_SANITIZER  // Allocates too much memory for tsan.
 TEST(HugeStringView, TwoPointTwoGB) {
-  if (sizeof(size_t) <= 4 || RunningOnValgrind())
+  if (sizeof(size_t) <= 4 || AbslRunningOnValgrind())
     return;
   // Try a huge std::string piece.
   const size_t size = size_t{2200} * 1000 * 1000;