Java core implementation: ensure correct alignment.

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 46 matching lines @@
   return MojoGetTimeTicksNow();
 }
 
 static jint WaitMany(JNIEnv* env,
                      jobject jcaller,
                      jobject buffer,
                      jlong deadline) {
   // Buffer contains first the list of handles, then the list of signals.
   const void* buffer_start = env->GetDirectBufferAddress(buffer);
   DCHECK(buffer_start);
+  DCHECK_EQ(0, reinterpret_cast<const uintptr_t>(buffer_start) % 8);

[viettrungluu, 2014/07/21 17:12:29]

Nit (here and everywhere else): No need for |const| here.

Also, it's probably also more natural to write it as |DCHECK(..., 0);|.

[qsr, 2014/07/22 08:15:11]

Done.

   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 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,
                                  jobject options_buffer) {
   const MojoCreateMessagePipeOptions* options = NULL;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
     DCHECK(buffer_start);
+    DCHECK_EQ(0, reinterpret_cast<const uintptr_t>(buffer_start) % 8);
     const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer);
     DCHECK_EQ(buffer_size, sizeof(MojoCreateMessagePipeOptions));
     options = static_cast<const MojoCreateMessagePipeOptions*>(buffer_start);
     DCHECK_EQ(options->struct_size, buffer_size);
   }
   MojoHandle handle1;
   MojoHandle handle2;
   MojoResult result = MojoCreateMessagePipe(options, &handle1, &handle2);
   return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2)
       .Release();
 }
 
 static jobject CreateDataPipe(JNIEnv* env,
                               jobject jcaller,
                               jobject options_buffer) {
   const MojoCreateDataPipeOptions* options = NULL;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
     DCHECK(buffer_start);
+    DCHECK_EQ(0, reinterpret_cast<const uintptr_t>(buffer_start) % 8);
     const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer);
     DCHECK_EQ(buffer_size, sizeof(MojoCreateDataPipeOptions));
     options = static_cast<const MojoCreateDataPipeOptions*>(buffer_start);
     DCHECK_EQ(options->struct_size, buffer_size);
   }
   MojoHandle handle1;
   MojoHandle handle2;
   MojoResult result = MojoCreateDataPipe(options, &handle1, &handle2);
   return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2)
       .Release();
 }
 
 static jobject CreateSharedBuffer(JNIEnv* env,
                                   jobject jcaller,
                                   jobject options_buffer,
                                   jlong num_bytes) {
   const MojoCreateSharedBufferOptions* options = 0;
   if (options_buffer) {
     const void* buffer_start = env->GetDirectBufferAddress(options_buffer);
     DCHECK(buffer_start);
+    DCHECK_EQ(0, reinterpret_cast<const uintptr_t>(buffer_start) % 8);
     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();
 }
@@ skipping 235 matching lines @@
       reinterpret_cast<AsyncWaitCallbackData*>(data_ptr));
   mojo::Environment::GetDefaultAsyncWaiter()->CancelWait(id);
 }
 
 bool RegisterCoreImpl(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 }  // namespace mojo