Mojo: Rename MOJO_WAIT_FLAG_... -> MOJO_HANDLE_SIGNAL_....

mojo/common/handle_watcher_unittest.cc

 // Copyright 2013 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 "mojo/common/handle_watcher.h"
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
@@ skipping 60 matching lines @@
     return base::Bind(&CallbackHelper::OnCallback, weak_factory_.GetWeakPtr());
   }
 
   void Start(HandleWatcher* watcher, const MessagePipeHandle& handle) {
     StartWithCallback(watcher, handle, GetCallback());
   }
 
   void StartWithCallback(HandleWatcher* watcher,
                          const MessagePipeHandle& handle,
                          const base::Callback<void(MojoResult)>& callback) {
-    watcher->Start(handle, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE,
-                   callback);
+    watcher->Start(handle, MOJO_HANDLE_SIGNAL_READABLE,
+                   MOJO_DEADLINE_INDEFINITE, callback);
   }
 
  private:
   void OnCallback(MojoResult result) {
     got_callback_ = true;
     if (run_loop_)
       run_loop_->Quit();
   }
 
   // Set to true when the callback is called.
@@ skipping 179 matching lines @@
   // Add a watcher with an infinite timeout.
   HandleWatcher watcher1;
   callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 
   // Add another watcher wth a timeout of 500 microseconds.
   HandleWatcher watcher2;
-  watcher2.Start(test_pipe2.handle0.get(), MOJO_WAIT_FLAG_READABLE, 500,
+  watcher2.Start(test_pipe2.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE, 500,
                  callback_helper2.GetCallback());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 
   // Advance the clock passed the deadline. We also have to start another
   // watcher to wake up the background thread.
   tick_clock_.Advance(base::TimeDelta::FromMicroseconds(501));
 
@@ skipping 25 matching lines @@
   bool was_signaled = false;
   MojoResult result = MOJO_RESULT_OK;
 
   base::ShadowingAtExitManager at_exit;
   MessagePipe pipe;
   HandleWatcher watcher;
   {
     base::MessageLoop loop;
 
     watcher.Start(pipe.handle0.get(),
-                  MOJO_WAIT_FLAG_READABLE,
+                  MOJO_HANDLE_SIGNAL_READABLE,
                   MOJO_DEADLINE_INDEFINITE,
                   base::Bind(&ObserveCallback, &was_signaled, &result));
 
     // Now, let the MessageLoop get torn down. We expect our callback to run.
   }
 
   EXPECT_TRUE(was_signaled);
   EXPECT_EQ(MOJO_RESULT_ABORTED, result);
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo