Fix new Mojo EDK multiplexing code on Android.

mojo/edk/system/routed_raw_channel.cc

 // Copyright 2015 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/routed_raw_channel.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 
 namespace mojo {
 namespace edk {
 
 namespace {
 const uint64_t kInternalRoutingId = 0;
-
-// These are messages sent over our internal routing id above, meant for the
-// other side's RoutedRawChannel to dispatch.
-enum InternalMessages {
-  ROUTE_CLOSED = 0,
-};
 }
 
 RoutedRawChannel::PendingMessage::PendingMessage() {
 }
 
 RoutedRawChannel::PendingMessage::~PendingMessage() {
 }
 
 RoutedRawChannel::RoutedRawChannel(
     ScopedPlatformHandle handle,
@@ skipping 37 matching lines @@
   CHECK_EQ(routes_[pipe_id], pipe);
   routes_.erase(pipe_id);
 
   // Only send a message to the other side to close the route if we hadn't
   // received a close route message. Otherwise they would keep going back and
   // forth.
   if (close_routes_.find(pipe_id) != close_routes_.end()) {
     close_routes_.erase(pipe_id);
   } else if (channel_) {
     // Default route id of 0 to reach the other side's RoutedRawChannel.
-    char message_data[sizeof(char) + sizeof(uint64_t)];
-    message_data[0] = ROUTE_CLOSED;
-    memcpy(&message_data[1], &pipe_id, sizeof(uint64_t));
+    char message_data[sizeof(uint64_t)];
+    memcpy(&message_data[0], &pipe_id, sizeof(uint64_t));
     scoped_ptr<MessageInTransit> message(new MessageInTransit(
         MessageInTransit::Type::MESSAGE, arraysize(message_data),
           message_data));
     message->set_route_id(kInternalRoutingId);
     channel_->WriteMessage(message.Pass());
   }
 
   if (!channel_ && routes_.empty()) {
     // PostTask to avoid reentrancy since the broker might be calling us.
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
@@ skipping 10 matching lines @@
   DCHECK(internal::g_io_thread_task_runner->RunsTasksOnCurrentThread());
   // Note: normally, when a message arrives here we should find a corresponding
   // entry for the MessagePipeDispatcher with the given route_id. However it is
   // possible that they just connected, and due to race conditions one side has
   // connected and sent a message (and even closed) before the other side had a
   // chance to register with this RoutedRawChannel. In that case, we must buffer
   // all messages.
   base::AutoLock auto_lock(lock_);
   uint64_t route_id = message_view.route_id();
   if (route_id == kInternalRoutingId) {
-    if (message_view.num_bytes() != sizeof(char) + sizeof(uint64_t)) {
-      NOTREACHED() << "Invalid internal message in RoutedRawChannel.";
+    if (message_view.num_bytes() !=  sizeof(uint64_t)) {
+      NOTREACHED() << "Invalid internal message in RoutedRawChannel." ;
       return;
     }
-    const char* bytes = static_cast<const char*>(message_view.bytes());
-    if (bytes[0] != ROUTE_CLOSED) {
-      NOTREACHED() << "Unknown internal message in RoutedRawChannel.";
-      return;
-    }
-    uint64_t closed_route = *reinterpret_cast<const uint64_t*>(&bytes[1]);
+    uint64_t closed_route = *static_cast<const uint64_t*>(message_view.bytes());
     if (close_routes_.find(closed_route) != close_routes_.end()) {
       NOTREACHED() << "Should only receive one ROUTE_CLOSED per route.";
       return;
     }
     close_routes_.insert(closed_route);
     if (routes_.find(closed_route) == routes_.end())
       return;  // This side hasn't connected yet.
 
     routes_[closed_route]->OnError(ERROR_READ_SHUTDOWN);
     return;
@@ skipping 26 matching lines @@
         it->second->OnError(error);
     }
   }
 
   if (destruct)
     delete this;
 }
 
 }  // namespace edk
 }  // namespace mojo