[mojo-edk] Keep old wire format and semantics on Android.

mojo/edk/system/channel.cc

 // Copyright 2016 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/edk/system/channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "mojo/edk/embedder/platform_handle.h"
 
 namespace mojo {
 namespace edk {
 
 namespace {
 
 static_assert(sizeof(Channel::Message::Header) % kChannelMessageAlignment == 0,
     "Invalid Header size.");
 
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
 static_assert(sizeof(Channel::Message::Header) == 8,
-              "Header must be 8 bytes on ChromeOS");
+              "Header must be 8 bytes on ChromeOS and Android");
 #endif
 
 }  // namespace
 
 const size_t kReadBufferSize = 4096;
 const size_t kMaxUnusedReadBufferCapacity = 256 * 1024;
 const size_t kMaxChannelMessageSize = 256 * 1024 * 1024;
 const size_t kMaxAttachedHandles = 128;
 
 Channel::Message::Message(size_t payload_size,
                           size_t max_handles,
                           Header::MessageType message_type)
     : max_handles_(max_handles) {
   DCHECK_LE(max_handles_, kMaxAttachedHandles);
 
   size_t extra_header_size = 0;
 #if defined(OS_WIN)
   // On Windows we serialize platform handles into the extra header space.
   extra_header_size = max_handles_ * sizeof(PlatformHandle);
 #endif
   // Pad extra header data to be aliged to |kChannelMessageAlignment| bytes.
   if (extra_header_size % kChannelMessageAlignment) {
     extra_header_size += kChannelMessageAlignment -
                          (extra_header_size % kChannelMessageAlignment);
   }
   DCHECK_EQ(0u, extra_header_size % kChannelMessageAlignment);
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   DCHECK_EQ(0u, extra_header_size);
 #endif
 
   size_ = sizeof(Header) + extra_header_size + payload_size;
   data_ = static_cast<char*>(base::AlignedAlloc(size_,
                                                 kChannelMessageAlignment));
   // Only zero out the header and not the payload. Since the payload is going to
   // be memcpy'd, zeroing the payload is unnecessary work and a significant
   // performance issue when dealing with large messages. Any sanitizer errors
   // complaining about an uninitialized read in the payload area should be
   // treated as an error and fixed.
   memset(data_, 0, sizeof(Header) + extra_header_size);
   header_ = reinterpret_cast<Header*>(data_);
 
   DCHECK_LE(size_, std::numeric_limits<uint32_t>::max());
   header_->num_bytes = static_cast<uint32_t>(size_);
 
   DCHECK_LE(sizeof(Header) + extra_header_size,
             std::numeric_limits<uint16_t>::max());
   header_->message_type = message_type;
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   header_->num_handles = static_cast<uint16_t>(max_handles);
 #else
   header_->num_header_bytes =
       static_cast<uint16_t>(sizeof(Header) + extra_header_size);
 #endif
 
 #if defined(OS_WIN)
   if (max_handles_ > 0) {
     handles_ = reinterpret_cast<PlatformHandle*>(mutable_extra_header());
     // Initialize all handles to invalid values.
@@ skipping 60 matching lines @@
   memcpy(message->mutable_extra_header(),
          static_cast<const char*>(data) + sizeof(Header),
          message->extra_header_size());
   message->header_->num_handles = header->num_handles;
 
   return message;
 #endif
 }
 
 size_t Channel::Message::payload_size() const {
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   return header_->num_bytes - sizeof(Header);
 #else
   return size_ - header_->num_header_bytes;
 #endif
 }
 
 PlatformHandle* Channel::Message::handles() {
-#if defined(OS_CHROMEOS)
-  // Old semantics for ChromeOS.
+#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
+  // Old semantics for ChromeOS and Android.
   if (header_->num_handles == 0)
     return nullptr;
   CHECK(handle_vector_);
   return handle_vector_->data();
 #else
   if (max_handles_ == 0)
     return nullptr;
 #if defined(OS_WIN)
   return handles_;
 #else
   CHECK(handle_vector_);
   return handle_vector_->data();
 #endif  // defined(OS_WIN)
-#endif  // defined(OS_CHROMEOS)
+#endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID)
 }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 bool Channel::Message::has_mach_ports() const {
   if (!has_handles())
     return false;
 
   for (const auto& handle : (*handle_vector_)) {
     if (handle.type == PlatformHandle::Type::MACH)
       return true;
   }
   return false;
 }
 #endif
 
 void Channel::Message::SetHandles(ScopedPlatformHandleVectorPtr new_handles) {
-#if defined(OS_CHROMEOS)
-  // Old semantics for ChromeOS.
+#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
+  // Old semantics for ChromeOS and Android
   if (header_->num_handles == 0) {
     CHECK(!new_handles || new_handles->size() == 0);
     return;
   }
   CHECK(new_handles && new_handles->size() == header_->num_handles);
   std::swap(handle_vector_, new_handles);
 
 #else
   if (max_handles_ == 0) {
     CHECK(!new_handles || new_handles->size() == 0);
     return;
   }
 
   CHECK(new_handles && new_handles->size() <= max_handles_);
   header_->num_handles = static_cast<uint16_t>(new_handles->size());
 #if defined(OS_WIN)
   memcpy(handles(), new_handles->data(),
          sizeof(PlatformHandle) * new_handles->size());
   new_handles->clear();
 #else
   std::swap(handle_vector_, new_handles);
 #endif  // defined(OS_WIN)
-#endif  // defined(OS_CHROMEOS)
+#endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID)
 }
 
 ScopedPlatformHandleVectorPtr Channel::Message::TakeHandles() {
 #if defined(OS_WIN)
   if (header_->num_handles == 0)
     return ScopedPlatformHandleVectorPtr();
   ScopedPlatformHandleVectorPtr moved_handles(
       new PlatformHandleVector(header_->num_handles));
   for (size_t i = 0; i < header_->num_handles; ++i)
     std::swap(moved_handles->at(i), handles()[i]);
@@ skipping 165 matching lines @@
     }
 
     if (read_buffer_->num_occupied_bytes() < header->num_bytes) {
       // Not enough data available to read the full message. Hint to the
       // implementation that it should try reading the full size of the message.
       *next_read_size_hint =
           header->num_bytes - read_buffer_->num_occupied_bytes();
       return true;
     }
 
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
     size_t extra_header_size = 0;
     const void* extra_header = nullptr;
     size_t payload_size = header->num_bytes - sizeof(Message::Header);
     void* payload = payload_size ? const_cast<Message::Header*>(&header[1])
                                  : nullptr;
 #else
     size_t extra_header_size =
         header->num_header_bytes - sizeof(Message::Header);
     const void* extra_header = header + 1;
     size_t payload_size = header->num_bytes - header->num_header_bytes;
     void* payload =
         payload_size ? reinterpret_cast<Message::Header*>(
                            const_cast<char*>(read_buffer_->occupied_bytes()) +
                            header->num_header_bytes)
                      : nullptr;
-#endif
+#endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID)
 
     ScopedPlatformHandleVectorPtr handles;
     if (header->num_handles > 0) {
       handles = GetReadPlatformHandles(header->num_handles, extra_header,
                                        extra_header_size);
       if (!handles) {
         // Not enough handles available for this message.
         break;
       }
     }
@@ skipping 15 matching lines @@
   return true;
 }
 
 void Channel::OnError() {
   if (delegate_)
     delegate_->OnChannelError();
 }
 
 }  // namespace edk
 }  // namespace mojo