Mojo: MojoWaitFlags -> MojoHandleSignals.

mojo/android/system/core_impl.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 "mojo/android/system/core_impl.h"
 
 #include "base/android/base_jni_registrar.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_registrar.h"
 #include "base/android/library_loader/library_loader_hooks.h"
@@ skipping 52 matching lines @@
                      jlong deadline) {
   // Buffer contains first the list of handles, then the list of flags.
   const void* buffer_start = env->GetDirectBufferAddress(buffer);
   DCHECK(buffer_start);
   const size_t record_size = 8;
   const size_t buffer_size = env->GetDirectBufferCapacity(buffer);
   DCHECK_EQ(buffer_size % record_size, 0u);
 
   const size_t nb_handles = buffer_size / record_size;
   const MojoHandle* handle_start = static_cast<const MojoHandle*>(buffer_start);
-  const MojoWaitFlags* flags_start =
-      static_cast<const MojoWaitFlags*>(handle_start + nb_handles);
-  return MojoWaitMany(handle_start, flags_start, nb_handles, deadline);
+  const MojoHandleSignals* signals_start =
+      static_cast<const MojoHandleSignals*>(handle_start + nb_handles);
+  return MojoWaitMany(handle_start, signals_start, nb_handles, deadline);
 }
 
 static jobject CreateMessagePipe(JNIEnv* env, jobject jcaller) {
   MojoHandle handle1;
   MojoHandle handle2;
   // TODO(vtl): Add support for the options struct.
   MojoResult result = MojoCreateMessagePipe(NULL, &handle1, &handle2);
   return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2)
       .Release();
 }
@@ skipping 36 matching lines @@
       .Release();
 }
 
 static jint Close(JNIEnv* env, jobject jcaller, jint mojo_handle) {
   return MojoClose(mojo_handle);
 }
 
 static jint Wait(JNIEnv* env,
                  jobject jcaller,
                  jint mojo_handle,
-                 jint flags,
+                 jint signals,
                  jlong deadline) {
-  return MojoWait(mojo_handle, flags, deadline);
+  return MojoWait(mojo_handle, signals, deadline);
 }
 
 static jint WriteMessage(JNIEnv* env,
                          jobject jcaller,
                          jint mojo_handle,
                          jobject bytes,
                          jint num_bytes,
                          jobject handles_buffer,
                          jint flags) {
   const void* buffer_start = 0;
@@ skipping 170 matching lines @@
 
 static int Unmap(JNIEnv* env, jobject jcaller, jobject buffer) {
   void* buffer_start = env->GetDirectBufferAddress(buffer);
   DCHECK(buffer_start);
   return MojoUnmapBuffer(buffer_start);
 }
 
 static jobject AsyncWait(JNIEnv* env,
                          jobject jcaller,
                          jint mojo_handle,
-                         jint flags,
+                         jint signals,
                          jlong deadline,
                          jobject callback) {
   AsyncWaitCallbackData* callback_data =
       new AsyncWaitCallbackData(env, jcaller, callback);
   MojoAsyncWaitID cancel_id;
   if (static_cast<MojoHandle>(mojo_handle) != MOJO_HANDLE_INVALID) {
     cancel_id = mojo::GetDefaultAsyncWaiter()->AsyncWait(mojo_handle,
-                                                         flags,
+                                                         signals,
                                                          deadline,
                                                          AsyncWaitCallback,
                                                          callback_data);
   } else {
     cancel_id = kInvalidHandleCancelID;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(
             &AsyncWaitCallback, callback_data, MOJO_RESULT_INVALID_ARGUMENT));
   }
@@ skipping 18 matching lines @@
       reinterpret_cast<AsyncWaitCallbackData*>(data_ptr));
   mojo::GetDefaultAsyncWaiter()->CancelWait(id);
 }
 
 bool RegisterCoreImpl(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 }  // namespace mojo