Migrate WaitableEvent to enum-based constructor in net/

net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc

 // Copyright (c) 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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 68 matching lines @@
 }
 
 }  // namespace
 
 typedef std::vector<CanonicalCookie*> CanonicalCookieVector;
 
 class SQLitePersistentCookieStoreTest : public testing::Test {
  public:
   SQLitePersistentCookieStoreTest()
       : pool_owner_(new base::SequencedWorkerPoolOwner(3, "Background Pool")),
-        loaded_event_(false, false),
-        key_loaded_event_(false, false),
-        db_thread_event_(false, false) {}
+        loaded_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                      base::WaitableEvent::InitialState::NOT_SIGNALED),
+        key_loaded_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                          base::WaitableEvent::InitialState::NOT_SIGNALED),
+        db_thread_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                         base::WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   void OnLoaded(const CanonicalCookieVector& cookies) {
     cookies_ = cookies;
     loaded_event_.Signal();
   }
 
   void OnKeyLoaded(const CanonicalCookieVector& cookies) {
     cookies_ = cookies;
     key_loaded_event_.Signal();
   }
 
   void Load(CanonicalCookieVector* cookies) {
     EXPECT_FALSE(loaded_event_.IsSignaled());
     store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                             base::Unretained(this)));
     loaded_event_.Wait();
     *cookies = cookies_;
   }
 
   void Flush() {
-    base::WaitableEvent event(false, false);
+    base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                              base::WaitableEvent::InitialState::NOT_SIGNALED);
     store_->Flush(
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
     event.Wait();
   }
 
   scoped_refptr<base::SequencedTaskRunner> background_task_runner() {
     return pool_owner_->pool()->GetSequencedTaskRunner(
         pool_owner_->pool()->GetNamedSequenceToken("background"));
   }
 
@@ skipping 186 matching lines @@
 
   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
   // until both Load and Flush have been posted to its task queue.
   background_task_runner()->PostTask(
       FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
                             base::Unretained(this)));
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   t += base::TimeDelta::FromInternalValue(10);
   AddCookieWithExpiration("A", "B", "c.com", "/", t, base::Time());
-  base::WaitableEvent event(false, false);
+  base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   store_->Flush(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
 
   // Now the DB-thread queue contains:
   // (active:)
   // 1. Wait (on db_event)
   // (pending:)
   // 2. "Init And Chain-Load First Domain"
   // 3. Add Cookie (c.com)
   // 4. Flush Cookie (c.com)
@@ skipping 474 matching lines @@
   EXPECT_TRUE(was_called_with_no_cookies);
 
   // Same with trying to load a specific cookie.
   was_called_with_no_cookies = false;
   store_->LoadCookiesForKey("foo.bar", base::Bind(WasCalledWithNoCookies,
                                                   &was_called_with_no_cookies));
   EXPECT_TRUE(was_called_with_no_cookies);
 }
 
 }  // namespace net