ipc/mojo/ipc_channel_mojo_readers.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ipc/mojo/ipc_channel_mojo_readers.h"
   6
   7 #include "ipc/mojo/ipc_channel_mojo.h"
   8
   9 namespace IPC {
  10 namespace internal {
  11
  12 //------------------------------------------------------------------------------
  13
  14 MessageReader::MessageReader(mojo::ScopedMessagePipeHandle pipe,
  15                              ChannelMojo* owner)
  16     : internal::MessagePipeReader(pipe.Pass()), owner_(owner) {
  17 }
  18
  19 void MessageReader::OnMessageReceived() {
  20   Message message(data_buffer().empty() ? "" : &data_buffer()[0],
  21                   static_cast<uint32>(data_buffer().size()));
  22
  23   std::vector<MojoHandle> handle_buffer;
  24   TakeHandleBuffer(&handle_buffer);
  25 #if defined(OS_POSIX) && !defined(OS_NACL)
  26   MojoResult write_result =
  27       ChannelMojo::WriteToFileDescriptorSet(handle_buffer, &message);
  28   if (write_result != MOJO_RESULT_OK) {
  29     CloseWithError(write_result);
  30     return;
  31   }
  32 #else
  33   DCHECK(handle_buffer.empty());
  34 #endif
  35
  36   message.TraceMessageEnd();
  37   owner_->OnMessageReceived(message);
  38 }
  39
  40 void MessageReader::OnPipeClosed() {
  41   if (!owner_)
  42     return;
  43   owner_->OnPipeClosed(this);
  44   owner_ = NULL;
  45 }
  46
  47 void MessageReader::OnPipeError(MojoResult error) {
  48   if (!owner_)
  49     return;
  50   owner_->OnPipeError(this);
  51 }
  52
  53 bool MessageReader::Send(scoped_ptr<Message> message) {
  54   DCHECK(IsValid());
  55
  56   message->TraceMessageBegin();
  57   std::vector<MojoHandle> handles;
  58 #if defined(OS_POSIX) && !defined(OS_NACL)
  59   MojoResult read_result =
  60       ChannelMojo::ReadFromFileDescriptorSet(message.get(), &handles);
  61   if (read_result != MOJO_RESULT_OK) {
  62     std::for_each(handles.begin(), handles.end(), &MojoClose);
  63     CloseWithError(read_result);
  64     return false;
  65   }
  66 #endif
  67   MojoResult write_result =
  68       MojoWriteMessage(handle(),
  69                        message->data(),
  70                        static_cast<uint32>(message->size()),
  71                        handles.empty() ? NULL : &handles[0],
  72                        static_cast<uint32>(handles.size()),
  73                        MOJO_WRITE_MESSAGE_FLAG_NONE);
  74   if (MOJO_RESULT_OK != write_result) {
  75     std::for_each(handles.begin(), handles.end(), &MojoClose);
  76     CloseWithError(write_result);
  77     return false;
  78   }
  79
  80   return true;
  81 }
  82
  83 }  // namespace internal
  84 }  // namespace IPC