Remove ANNOTATE_BENIGN_RACE from trace_event_synthetic_delay.cc

base/trace_event/trace_event_synthetic_delay.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 "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 
 namespace {
@@ skipping 58 matching lines @@
   AutoLock lock(lock_);
   mode_ = mode;
 }
 
 void TraceEventSyntheticDelay::SetClock(TraceEventSyntheticDelayClock* clock) {
   AutoLock lock(lock_);
   clock_ = clock;
 }
 
 void TraceEventSyntheticDelay::Begin() {
-  // Note that we check for a non-zero target duration without locking to keep
-  // things quick for the common case when delays are disabled. Since the delay
-  // calculation is done with a lock held, it will always be correct. The only
-  // downside of this is that we may fail to apply some delays when the target
-  // duration changes.
-  ANNOTATE_BENIGN_RACE(&target_duration_, "Synthetic delay duration");

[Sami, 2017/03/21 11:52:55]

There is actually a race here (SetTargetDuration writes to target_duration_ and
we read it without locking), but we just don't have enough code using synthetic
delays to trigger it. Actually I'm considering deleting the entire synthetic
delay subsystem since we haven't really made use of it recently. If you want to
remove the macros before that that's fine, but please leave a comment here
saying there is an actual race.

   if (!target_duration_.ToInternalValue())
     return;
 
   TimeTicks start_time = clock_->Now();
   {
     AutoLock lock(lock_);
     if (++begin_count_ != 1)
       return;
     end_time_ = CalculateEndTimeLocked(start_time);
   }
 }
 
 void TraceEventSyntheticDelay::BeginParallel(TimeTicks* out_end_time) {
-  // See note in Begin().
-  ANNOTATE_BENIGN_RACE(&target_duration_, "Synthetic delay duration");
   if (!target_duration_.ToInternalValue()) {
     *out_end_time = TimeTicks();
     return;
   }
 
   TimeTicks start_time = clock_->Now();
   {
     AutoLock lock(lock_);
     *out_end_time = CalculateEndTimeLocked(start_time);
   }
 }
 
 void TraceEventSyntheticDelay::End() {
-  // See note in Begin().
-  ANNOTATE_BENIGN_RACE(&target_duration_, "Synthetic delay duration");
   if (!target_duration_.ToInternalValue())
     return;
 
   TimeTicks end_time;
   {
     AutoLock lock(lock_);
     if (!begin_count_ || --begin_count_ != 0)
       return;
     end_time = end_time_;
   }
@@ skipping 101 matching lines @@
     delay_impl =
         base::trace_event::TraceEventSyntheticDelayRegistry::GetInstance()
             ->GetOrCreateDelay(name);
     base::subtle::Release_Store(
         impl_ptr, reinterpret_cast<base::subtle::AtomicWord>(delay_impl));
   }
   return delay_impl;
 }
 
 }  // namespace trace_event_internal