Migrate WaitableEvent to enum-based constructor in sync/

sync/internal_api/http_bridge_unittest.cc

 // Copyright 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bit_cast.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
@@ skipping 400 matching lines @@
 
 // Tests an interesting case where code using the HttpBridge aborts the fetch
 // and releases ownership before a pending fetch completed callback is issued by
 // the underlying URLFetcher (and before that URLFetcher is destroyed, which
 // would cancel the callback).
 TEST_F(MAYBE_SyncHttpBridgeTest, AbortAndReleaseBeforeFetchComplete) {
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
   // First, block the sync thread on the post.
-  base::WaitableEvent signal_when_created(false, false);
-  base::WaitableEvent signal_when_released(false, false);
+  base::WaitableEvent signal_when_created(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  base::WaitableEvent signal_when_released(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
   sync_thread.message_loop()->PostTask(FROM_HERE,
       base::Bind(&MAYBE_SyncHttpBridgeTest::RunSyncThreadBridgeUseTest,
                  base::Unretained(this),
                  &signal_when_created,
                  &signal_when_released));
 
   // Stop IO so we can control order of operations.
-  base::WaitableEvent io_waiter(false, false);
+  base::WaitableEvent io_waiter(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
   ASSERT_TRUE(io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&io_waiter))));
 
   signal_when_created.Wait();  // Wait till we have a bridge to abort.
   ASSERT_TRUE(bridge_for_race_test());
 
   // Schedule the fetch completion callback (but don't run it yet). Don't take
   // a reference to the bridge to mimic URLFetcher's handling of the delegate.
   net::URLFetcherDelegate* delegate =
@@ skipping 61 matching lines @@
 TEST_F(MAYBE_SyncHttpBridgeTest, RequestContextGetterReleaseOrder) {
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
   syncer::HttpPostProviderFactory* factory = NULL;
   syncer::HttpPostProviderInterface* bridge = NULL;
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
 
-  base::WaitableEvent signal_when_created(false, false);
-  base::WaitableEvent wait_for_shutdown(false, false);
+  base::WaitableEvent signal_when_created(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  base::WaitableEvent wait_for_shutdown(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   CancelationSignal release_request_context_signal;
 
   // Create bridge factory and factory on sync thread and wait for the creation
   // to finish.
   sync_thread.message_loop()->PostTask(
       FROM_HERE, base::Bind(&HttpBridgeRunOnSyncThread,
                             base::Unretained(baseline_context_getter.get()),
                             &release_request_context_signal, &factory, &bridge,
                             &signal_when_created, &wait_for_shutdown));
   signal_when_created.Wait();
 
   // Simulate sync shutdown by aborting bridge and shutting down factory on
   // frontend.
   bridge->Abort();
   release_request_context_signal.Signal();
 
   // Wait for sync's RequestContextGetter to be cleared on IO thread and
   // check for reference count.
-  base::WaitableEvent signal_wait_start(false, false);
-  base::WaitableEvent wait_done(false, false);
+  base::WaitableEvent signal_wait_start(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  base::WaitableEvent wait_done(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
   io_thread()->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&WaitOnIOThread, &signal_wait_start, &wait_done));
   signal_wait_start.Wait();
   // |baseline_context_getter| should have only one reference from local
   // variable.
   EXPECT_TRUE(baseline_context_getter->HasOneRef());
   baseline_context_getter = NULL;
 
   // Unblock and stop IO thread before sync thread.
@@ skipping 27 matching lines @@
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent", BindToTrackerCallback());
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 }
 
 }  // namespace syncer