Migrate WaitableEvent to enum-based constructor in components/

components/browser_sync/browser/profile_sync_service_autofill_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 <memory>
 #include <set>
 #include <string>
@@ skipping 228 matching lines @@
 
 class WebDataServiceFake : public AutofillWebDataService {
  public:
   WebDataServiceFake(
       const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& db_thread)
       : AutofillWebDataService(ui_thread, db_thread),
         web_database_(NULL),
         autocomplete_syncable_service_(NULL),
         autofill_profile_syncable_service_(NULL),
-        syncable_service_created_or_destroyed_(false, false),
+        syncable_service_created_or_destroyed_(
+            base::WaitableEvent::ResetPolicy::AUTOMATIC,
+            base::WaitableEvent::InitialState::NOT_SIGNALED),
         db_thread_(db_thread),
         ui_thread_(ui_thread) {}
 
   void SetDatabase(WebDatabase* web_database) {
     web_database_ = web_database;
   }
 
   void StartSyncableService() {
     // The |autofill_profile_syncable_service_| must be constructed on the DB
     // thread.
@@ skipping 14 matching lines @@
                          base::Bind(&WebDataServiceFake::DestroySyncableService,
                                     base::Unretained(this)));
     syncable_service_created_or_destroyed_.Wait();
   }
 
   bool IsDatabaseLoaded() override { return true; }
 
   WebDatabase* GetDatabase() override { return web_database_; }
 
   void OnAutofillEntriesChanged(const AutofillChangeList& changes) {
-    WaitableEvent event(true, false);
+    WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED);
 
     base::Closure notify_cb =
         base::Bind(&AutocompleteSyncableService::AutofillEntriesChanged,
                    base::Unretained(autocomplete_syncable_service_),
                    changes);
     db_thread_->PostTask(FROM_HERE,
                          base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
   void OnAutofillProfileChanged(const AutofillProfileChange& changes) {
-    WaitableEvent event(true, false);
+    WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED);
 
     base::Closure notify_cb =
         base::Bind(&AutocompleteSyncableService::AutofillProfileChanged,
                    base::Unretained(autofill_profile_syncable_service_),
                    changes);
     db_thread_->PostTask(FROM_HERE,
                          base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
@@ skipping 396 matching lines @@
 class FakeServerUpdater : public base::RefCountedThreadSafe<FakeServerUpdater> {
  public:
   FakeServerUpdater(TestProfileSyncService* service,
                     WaitableEvent* wait_for_start,
                     WaitableEvent* wait_for_syncapi,
                     scoped_refptr<base::SequencedTaskRunner> db_thread)
       : entry_(MakeAutofillEntry("0", "0", 0)),
         service_(service),
         wait_for_start_(wait_for_start),
         wait_for_syncapi_(wait_for_syncapi),
-        is_finished_(false, false),
+        is_finished_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                     base::WaitableEvent::InitialState::NOT_SIGNALED),
         db_thread_(db_thread) {}
 
   void Update() {
     // This gets called in a modelsafeworker thread.
     ASSERT_TRUE(db_thread_->RunsTasksOnCurrentThread());
 
     syncer::UserShare* user_share = service_->GetUserShare();
     syncer::syncable::Directory* directory = user_share->directory.get();
 
     // Create autofill protobuf.
@@ skipping 685 matching lines @@
   // On the other hand Autofill and Autocomplete are separated now, so
   // GetAutofillProfiles() should not be called.
   EXPECT_CALL(autofill_table(), GetAutofillProfiles(_)).Times(0);
   EXPECT_CALL(autofill_table(), UpdateAutofillEntries(_))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(personal_data_manager(), Refresh()).Times(3);
   CreateRootHelper create_root(this, AUTOFILL);
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
-  // (true, false) means we have to reset after |Signal|, init to unsignaled.
-  std::unique_ptr<WaitableEvent> wait_for_start(new WaitableEvent(true, false));
+  std::unique_ptr<WaitableEvent> wait_for_start(
+      new WaitableEvent(base::WaitableEvent::ResetPolicy::MANUAL,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED));
   std::unique_ptr<WaitableEvent> wait_for_syncapi(
-      new WaitableEvent(true, false));
+      new WaitableEvent(base::WaitableEvent::ResetPolicy::MANUAL,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED));
   scoped_refptr<FakeServerUpdater> updater(new FakeServerUpdater(
       sync_service(), wait_for_start.get(), wait_for_syncapi.get(),
       data_type_thread()->task_runner()));
 
   // This server side update will stall waiting for CommitWaiter.
   updater->CreateNewEntry(MakeAutofillEntry("server", "entry", 1));
   wait_for_start->Wait();
 
   AutofillEntry syncapi_entry(MakeAutofillEntry("syncapi", "entry", 2));
   ASSERT_TRUE(AddAutofillSyncNode(syncapi_entry));
@@ skipping 15 matching lines @@
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
              << ", " << sync_entries[i].key().value();
   }
 }