Migrate WaitableEvent to enum-based constructor in base/

base/threading/thread_perftest.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 <stddef.h>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 17 matching lines @@
 
 namespace {
 
 const int kNumRuns = 100000;
 
 // Base class for a threading perf-test. This sets up some threads for the
 // test and measures the clock-time in addition to time spent on each thread.
 class ThreadPerfTest : public testing::Test {
  public:
   ThreadPerfTest()
-      : done_(false, false) {
+      : done_(WaitableEvent::ResetPolicy::AUTOMATIC,
+              WaitableEvent::InitialState::NOT_SIGNALED) {
     // Disable the task profiler as it adds significant cost!
     CommandLine::Init(0, NULL);
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kProfilerTiming,
         switches::kProfilerTimingDisabledValue);
   }
 
   // To be implemented by each test. Subclass must uses threads_ such that
   // their cpu-time can be measured. Test must return from PingPong() _and_
   // call FinishMeasurement from any thread to complete the test.
   virtual void Init() {
     if (ThreadTicks::IsSupported())
       ThreadTicks::WaitUntilInitialized();
   }
   virtual void PingPong(int hops) = 0;
   virtual void Reset() {}
 
   void TimeOnThread(base::ThreadTicks* ticks, base::WaitableEvent* done) {
     *ticks = base::ThreadTicks::Now();
     done->Signal();
   }
 
   base::ThreadTicks ThreadNow(base::Thread* thread) {
-    base::WaitableEvent done(false, false);
+    base::WaitableEvent done(WaitableEvent::ResetPolicy::AUTOMATIC,
+                             WaitableEvent::InitialState::NOT_SIGNALED);
     base::ThreadTicks ticks;
     thread->task_runner()->PostTask(
         FROM_HERE, base::Bind(&ThreadPerfTest::TimeOnThread,
                               base::Unretained(this), &ticks, &done));
     done.Wait();
     return ticks;
   }
 
   void RunPingPongTest(const std::string& name, unsigned num_threads) {
     // Create threads and collect starting cpu-time for each thread.
@@ skipping 99 matching lines @@
   RunPingPongTest("4_Task_Threads_With_Observer", 4);
 }
 
 // Class to test our WaitableEvent performance by signaling back and fort.
 // WaitableEvent is templated so we can also compare with other versions.
 template <typename WaitableEventType>
 class EventPerfTest : public ThreadPerfTest {
  public:
   void Init() override {
     for (size_t i = 0; i < threads_.size(); i++)
-      events_.push_back(new WaitableEventType(false, false));
+      events_.push_back(
+          new WaitableEventType(WaitableEvent::ResetPolicy::AUTOMATIC,
+                                WaitableEvent::InitialState::NOT_SIGNALED));

[gab, 2016/06/01 19:16:05]

@etienneb: weird that clang-tidy made this change given not all instantiations
of this template are happy with it.

This is causing compile failures for patch set #1.

I'll undo it for now and do it manually on its own.

[etienneb, 2016/06/01 19:53:27]

You can use this to avoid template instantiation.

  isInTemplateInstantiation() or unless(...)

But, to know if something depend on the instantiation, class Expression has this
function: clang::Expr::isInstantiationDependent
 
http://clang.llvm.org/doxygen/classclang_1_1Expr.html#ae6915a41dbc08e0c2ce21a...

I don't remember if there is a matcher, but you can easily write one.

   }
 
   void Reset() override { events_.clear(); }
 
   void WaitAndSignalOnThread(size_t event) {
     size_t next_event = (event + 1) % events_.size();
     int my_hops = 0;
     do {
       events_[event]->Wait();
       my_hops = --remaining_hops_;  // We own 'hops' between Wait and Signal.
@@ skipping 111 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base