Java: Introduce ResultAnd<> and use it.

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 126 matching lines @@
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
     DCHECK(buffer_start);
     DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u);
     const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer);
     DCHECK_EQ(buffer_size, sizeof(MojoCreateSharedBufferOptions));
     options = static_cast<const MojoCreateSharedBufferOptions*>(buffer_start);
     DCHECK_EQ(options->struct_size, buffer_size);
   }
   MojoHandle handle;
   MojoResult result = MojoCreateSharedBuffer(options, num_bytes, &handle);
-  return Java_CoreImpl_newNativeCreationResult(env, result, handle, 0)
-      .Release();
+  return Java_CoreImpl_newResultAndInteger(env, result, handle).Release();
 }
 
 static jint Close(JNIEnv* env, jobject jcaller, jint mojo_handle) {
   return MojoClose(mojo_handle);
 }
 
 static jint Wait(JNIEnv* env,
                  jobject jcaller,
                  jobject buffer,
                  jint mojo_handle,
@@ skipping 57 matching lines @@
         static_cast<MojoHandle*>(env->GetDirectBufferAddress(handles_buffer));
     num_handles = env->GetDirectBufferCapacity(handles_buffer) / 4;
   }
   MojoResult result = MojoReadMessage(
       mojo_handle, buffer_start, &buffer_size, handles, &num_handles, flags);
   // Jave code will handle taking ownership of any received handle.
   return Java_CoreImpl_newReadMessageResult(
              env, result, buffer_size, num_handles).Release();
 }
 
-static jint ReadData(JNIEnv* env,
-                     jobject jcaller,
-                     jint mojo_handle,
-                     jobject elements,
-                     jint elements_capacity,
-                     jint flags) {
+static jobject ReadData(JNIEnv* env,
+                        jobject jcaller,
+                        jint mojo_handle,
+                        jobject elements,
+                        jint elements_capacity,
+                        jint flags) {
   void* buffer_start = 0;
   uint32_t buffer_size = elements_capacity;
   if (elements) {
     buffer_start = env->GetDirectBufferAddress(elements);
     DCHECK(buffer_start);
     DCHECK(elements_capacity <= env->GetDirectBufferCapacity(elements));
   }
   MojoResult result =
       MojoReadData(mojo_handle, buffer_start, &buffer_size, flags);
-  if (result < 0) {
-    return result;
-  }
-  return buffer_size;
+  return Java_CoreImpl_newResultAndInteger(
+             env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0)
+      .Release();
 }
 
 static jobject BeginReadData(JNIEnv* env,
                              jobject jcaller,
                              jint mojo_handle,
                              jint num_bytes,
                              jint flags) {
   void const* buffer = 0;
   uint32_t buffer_size = num_bytes;
   MojoResult result =
       MojoBeginReadData(mojo_handle, &buffer, &buffer_size, flags);
   jobject byte_buffer = 0;
   if (result == MOJO_RESULT_OK) {
     byte_buffer =
         env->NewDirectByteBuffer(const_cast<void*>(buffer), buffer_size);
   }
-  return Java_CoreImpl_newNativeCodeAndBufferResult(env, result, byte_buffer)
-      .Release();
+  return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer).Release();
 }
 
 static jint EndReadData(JNIEnv* env,
                         jobject jcaller,
                         jint mojo_handle,
                         jint num_bytes_read) {
   return MojoEndReadData(mojo_handle, num_bytes_read);
 }
 
-static jint WriteData(JNIEnv* env,
-                      jobject jcaller,
-                      jint mojo_handle,
-                      jobject elements,
-                      jint limit,
-                      jint flags) {
+static jobject WriteData(JNIEnv* env,
+                         jobject jcaller,
+                         jint mojo_handle,
+                         jobject elements,
+                         jint limit,
+                         jint flags) {
   void* buffer_start = env->GetDirectBufferAddress(elements);
   DCHECK(buffer_start);
   DCHECK(limit <= env->GetDirectBufferCapacity(elements));
   uint32_t buffer_size = limit;
   MojoResult result =
       MojoWriteData(mojo_handle, buffer_start, &buffer_size, flags);
-  if (result < 0) {
-    return result;
-  }
-  return buffer_size;
+  return Java_CoreImpl_newResultAndInteger(
+             env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0)
+      .Release();
 }
 
 static jobject BeginWriteData(JNIEnv* env,
                               jobject jcaller,
                               jint mojo_handle,
                               jint num_bytes,
                               jint flags) {
   void* buffer = 0;
   uint32_t buffer_size = num_bytes;
   MojoResult result =
       MojoBeginWriteData(mojo_handle, &buffer, &buffer_size, flags);
   jobject byte_buffer = 0;
   if (result == MOJO_RESULT_OK) {
     byte_buffer = env->NewDirectByteBuffer(buffer, buffer_size);
   }
-  return Java_CoreImpl_newNativeCodeAndBufferResult(env, result, byte_buffer)
-      .Release();
+  return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer).Release();
 }
 
 static jint EndWriteData(JNIEnv* env,
                          jobject jcaller,
                          jint mojo_handle,
                          jint num_bytes_written) {
   return MojoEndWriteData(mojo_handle, num_bytes_written);
 }
 
 static jobject Duplicate(JNIEnv* env,
                          jobject jcaller,
                          jint mojo_handle,
                          jobject options_buffer) {
   const MojoDuplicateBufferHandleOptions* options = 0;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
     DCHECK(buffer_start);
     const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer);
     DCHECK_EQ(buffer_size, sizeof(MojoDuplicateBufferHandleOptions));
     options =
         static_cast<const MojoDuplicateBufferHandleOptions*>(buffer_start);
     DCHECK_EQ(options->struct_size, buffer_size);
   }
   MojoHandle handle;
   MojoResult result = MojoDuplicateBufferHandle(mojo_handle, options, &handle);
-  return Java_CoreImpl_newNativeCreationResult(env, result, handle, 0)
-      .Release();
+  return Java_CoreImpl_newResultAndInteger(env, result, handle).Release();
 }
 
 static jobject Map(JNIEnv* env,
                    jobject jcaller,
                    jint mojo_handle,
                    jlong offset,
                    jlong num_bytes,
                    jint flags) {
   void* buffer = 0;
   MojoResult result =
       MojoMapBuffer(mojo_handle, offset, num_bytes, &buffer, flags);
   jobject byte_buffer = 0;
   if (result == MOJO_RESULT_OK) {
     byte_buffer = env->NewDirectByteBuffer(buffer, num_bytes);
   }
-  return Java_CoreImpl_newNativeCodeAndBufferResult(env, result, byte_buffer)
-      .Release();
+  return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer).Release();
 }
 
 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,
@@ skipping 35 matching lines @@
       reinterpret_cast<AsyncWaitCallbackData*>(data_ptr));
   Environment::GetDefaultAsyncWaiter()->CancelWait(id);
 }
 
 bool RegisterCoreImpl(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 }  // namespace mojo