Make IPC::Channel polymorphic

ipc/ipc_channel_nacl.cc

 // Copyright (c) 2012 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 "ipc/ipc_channel_nacl.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <sys/types.h>
 
@@ skipping 44 matching lines @@
   }
   DCHECK(bytes_read);
   // Resize the buffers down to the number of bytes and fds we actually read.
   contents->data.resize(bytes_read);
   contents->fds.resize(msg.desc_length);
   return true;
 }
 
 }  // namespace
 
-class Channel::ChannelImpl::ReaderThreadRunner
+class ChannelNacl::ReaderThreadRunner
     : public base::DelegateSimpleThread::Delegate {
  public:
   // |pipe|: A file descriptor from which we will read using imc_recvmsg.
   // |data_read_callback|: A callback we invoke (on the main thread) when we
   //                       have read data.
   // |failure_callback|: A callback we invoke when we have a failure reading
   //                     from |pipe|.
   // |main_message_loop|: A proxy for the main thread, where we will invoke the
   //                      above callbacks.
   ReaderThreadRunner(
       int pipe,
       base::Callback<void (scoped_ptr<MessageContents>)> data_read_callback,
       base::Callback<void ()> failure_callback,
       scoped_refptr<base::MessageLoopProxy> main_message_loop);
 
   // DelegateSimpleThread implementation. Reads data from the pipe in a loop
   // until either we are told to quit or a read fails.
   virtual void Run() OVERRIDE;
 
  private:
   int pipe_;
   base::Callback<void (scoped_ptr<MessageContents>)> data_read_callback_;
   base::Callback<void ()> failure_callback_;
   scoped_refptr<base::MessageLoopProxy> main_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(ReaderThreadRunner);
 };
 
-Channel::ChannelImpl::ReaderThreadRunner::ReaderThreadRunner(
+ChannelNacl::ReaderThreadRunner::ReaderThreadRunner(
     int pipe,
     base::Callback<void (scoped_ptr<MessageContents>)> data_read_callback,
     base::Callback<void ()> failure_callback,
     scoped_refptr<base::MessageLoopProxy> main_message_loop)
     : pipe_(pipe),
       data_read_callback_(data_read_callback),
       failure_callback_(failure_callback),
       main_message_loop_(main_message_loop) {
 }
 
-void Channel::ChannelImpl::ReaderThreadRunner::Run() {
+void ChannelNacl::ReaderThreadRunner::Run() {
   while (true) {
     scoped_ptr<MessageContents> msg_contents(new MessageContents);
     bool success = ReadDataOnReaderThread(pipe_, msg_contents.get());
     if (success) {
       main_message_loop_->PostTask(FROM_HERE,
           base::Bind(data_read_callback_, base::Passed(&msg_contents)));
     } else {
       main_message_loop_->PostTask(FROM_HERE, failure_callback_);
       // Because the read failed, we know we're going to quit. Don't bother
       // trying to read again.
       return;
     }
   }
 }
 
-Channel::ChannelImpl::ChannelImpl(const IPC::ChannelHandle& channel_handle,
-                                  Mode mode,
-                                  Listener* listener)
+ChannelNacl::ChannelNacl(const IPC::ChannelHandle& channel_handle,
+                         Mode mode,
+                         Listener* listener)
     : ChannelReader(listener),
       mode_(mode),
       waiting_connect_(true),
       pipe_(-1),
       pipe_name_(channel_handle.name),
       weak_ptr_factory_(this) {
   if (!CreatePipe(channel_handle)) {
     // The pipe may have been closed already.
     const char *modestr = (mode_ & MODE_SERVER_FLAG) ? "server" : "client";
     LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name
                  << "\" in " << modestr << " mode";
   }
 }
 
-Channel::ChannelImpl::~ChannelImpl() {
+ChannelNacl::~ChannelNacl() {
   Close();
 }
 
-base::ProcessId Channel::ChannelImpl::peer_pid() const {
+base::ProcessId ChannelNacl::GetPeerPID() const {
   // This shouldn't actually get used in the untrusted side of the proxy, and we
   // don't have the real pid anyway.
   return -1;
 }
 
-bool Channel::ChannelImpl::Connect() {
+bool ChannelNacl::Connect() {
   if (pipe_ == -1) {
     DLOG(WARNING) << "Channel creation failed: " << pipe_name_;
     return false;
   }
 
   // Note that Connect is called on the "Channel" thread (i.e., the same thread
   // where Channel::Send will be called, and the same thread that should receive
   // messages). The constructor might be invoked on another thread (see
   // ChannelProxy for an example of that). Therefore, we must wait until Connect
   // is called to decide which MessageLoopProxy to pass to ReaderThreadRunner.
   reader_thread_runner_.reset(
       new ReaderThreadRunner(
           pipe_,
-          base::Bind(&Channel::ChannelImpl::DidRecvMsg,
+          base::Bind(&ChannelNacl::DidRecvMsg,
                      weak_ptr_factory_.GetWeakPtr()),
-          base::Bind(&Channel::ChannelImpl::ReadDidFail,
+          base::Bind(&ChannelNacl::ReadDidFail,
                      weak_ptr_factory_.GetWeakPtr()),
           base::MessageLoopProxy::current()));
   reader_thread_.reset(
       new base::DelegateSimpleThread(reader_thread_runner_.get(),
                                      "ipc_channel_nacl reader thread"));
   reader_thread_->Start();
   waiting_connect_ = false;
   // If there were any messages queued before connection, send them.
   ProcessOutgoingMessages();
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
-      base::Bind(&Channel::ChannelImpl::CallOnChannelConnected,
+      base::Bind(&ChannelNacl::CallOnChannelConnected,
                  weak_ptr_factory_.GetWeakPtr()));
 
   return true;
 }
 
-void Channel::ChannelImpl::Close() {
+void ChannelNacl::Close() {
   // For now, we assume that at shutdown, the reader thread will be woken with
   // a failure (see NaClIPCAdapter::BlockingRead and CloseChannel). Or... we
   // might simply be killed with no chance to clean up anyway :-).
   // If untrusted code tries to close the channel prior to shutdown, it's likely
   // to hang.
   // TODO(dmichael): Can we do anything smarter here to make sure the reader
   //                 thread wakes up and quits?
   reader_thread_->Join();
   close(pipe_);
   pipe_ = -1;
   reader_thread_runner_.reset();
   reader_thread_.reset();
   read_queue_.clear();
   output_queue_.clear();
 }
 
-bool Channel::ChannelImpl::Send(Message* message) {
+bool ChannelNacl::Send(Message* message) {
   DVLOG(2) << "sending message @" << message << " on channel @" << this
            << " with type " << message->type();
   scoped_ptr<Message> message_ptr(message);
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   Logging::GetInstance()->OnSendMessage(message_ptr.get(), "");
 #endif  // IPC_MESSAGE_LOG_ENABLED
 
   message->TraceMessageBegin();
   output_queue_.push_back(linked_ptr<Message>(message_ptr.release()));
   if (!waiting_connect_)
     return ProcessOutgoingMessages();
 
   return true;
 }
 
-void Channel::ChannelImpl::DidRecvMsg(scoped_ptr<MessageContents> contents) {
+void ChannelNacl::DidRecvMsg(scoped_ptr<MessageContents> contents) {
   // Close sets the pipe to -1. It's possible we'll get a buffer sent to us from
   // the reader thread after Close is called. If so, we ignore it.
   if (pipe_ == -1)
     return;
 
   linked_ptr<std::vector<char> > data(new std::vector<char>);
   data->swap(contents->data);
   read_queue_.push_back(data);
 
   input_fds_.insert(input_fds_.end(),
                     contents->fds.begin(), contents->fds.end());
   contents->fds.clear();
 
   // In POSIX, we would be told when there are bytes to read by implementing
   // OnFileCanReadWithoutBlocking in MessageLoopForIO::Watcher. In NaCl, we
   // instead know at this point because the reader thread posted some data to
   // us.
   ProcessIncomingMessages();
 }
 
-void Channel::ChannelImpl::ReadDidFail() {
+void ChannelNacl::ReadDidFail() {
   Close();
 }
 
-bool Channel::ChannelImpl::CreatePipe(
+bool ChannelNacl::CreatePipe(
     const IPC::ChannelHandle& channel_handle) {
   DCHECK(pipe_ == -1);
 
   // There's one possible case in NaCl:
   // 1) It's a channel wrapping a pipe that is given to us.
   // We don't support these:
   // 2) It's for a named channel.
   // 3) It's for a client that we implement ourself.
   // 4) It's the initial IPC channel.
 
   if (channel_handle.socket.fd == -1) {
     NOTIMPLEMENTED();
     return false;
   }
   pipe_ = channel_handle.socket.fd;
   return true;
 }
 
-bool Channel::ChannelImpl::ProcessOutgoingMessages() {
+bool ChannelNacl::ProcessOutgoingMessages() {
   DCHECK(!waiting_connect_);  // Why are we trying to send messages if there's
                               // no connection?
   if (output_queue_.empty())
     return true;
 
   if (pipe_ == -1)
     return false;
 
   // Write out all the messages. The trusted implementation is guaranteed to not
   // block. See NaClIPCAdapter::Send for the implementation of imc_sendmsg.
@@ skipping 27 matching lines @@
       msg->file_descriptor_set()->CommitAll();
     }
 
     // Message sent OK!
     DVLOG(2) << "sent message @" << msg.get() << " with type " << msg->type()
              << " on fd " << pipe_;
   }
   return true;
 }
 
-void Channel::ChannelImpl::CallOnChannelConnected() {
-  listener()->OnChannelConnected(peer_pid());
+void ChannelNacl::CallOnChannelConnected() {
+  listener()->OnChannelConnected(GetPeerPID());
 }
 
-Channel::ChannelImpl::ReadState Channel::ChannelImpl::ReadData(
+ChannelNacl::ReadState ChannelNacl::ReadData(
     char* buffer,
     int buffer_len,
     int* bytes_read) {
   *bytes_read = 0;
   if (pipe_ == -1)
     return READ_FAILED;
   if (read_queue_.empty())
     return READ_PENDING;
   while (!read_queue_.empty() && *bytes_read < buffer_len) {
     linked_ptr<std::vector<char> > vec(read_queue_.front());
@@ skipping 10 matching lines @@
       // the code simple).
       std::copy(vec->begin(), vec->begin() + bytes_to_read,
                 buffer + *bytes_read);
       vec->erase(vec->begin(), vec->begin() + bytes_to_read);
       *bytes_read += bytes_to_read;
     }
   }
   return READ_SUCCEEDED;
 }
 
-bool Channel::ChannelImpl::WillDispatchInputMessage(Message* msg) {
+bool ChannelNacl::WillDispatchInputMessage(Message* msg) {
   uint16 header_fds = msg->header()->num_fds;
   CHECK(header_fds == input_fds_.size());
   if (header_fds == 0)
     return true;  // Nothing to do.
 
   // The shenaniganery below with &foo.front() requires input_fds_ to have
   // contiguous underlying storage (such as a simple array or a std::vector).
   // This is why the header warns not to make input_fds_ a deque<>.
   msg->file_descriptor_set()->SetDescriptors(&input_fds_.front(),
                                              header_fds);
   input_fds_.clear();
   return true;
 }
 
-bool Channel::ChannelImpl::DidEmptyInputBuffers() {
+bool ChannelNacl::DidEmptyInputBuffers() {
   // When the input data buffer is empty, the fds should be too.
   return input_fds_.empty();
 }
 
-void Channel::ChannelImpl::HandleInternalMessage(const Message& msg) {
+void ChannelNacl::HandleInternalMessage(const Message& msg) {
   // The trusted side IPC::Channel should handle the "hello" handshake; we
   // should not receive the "Hello" message.
   NOTREACHED();
 }
 
-//------------------------------------------------------------------------------
-// Channel's methods simply call through to ChannelImpl.
+// Channel's methods
 
-Channel::Channel(const IPC::ChannelHandle& channel_handle,
-                 Mode mode,
-                 Listener* listener)
-    : channel_impl_(new ChannelImpl(channel_handle, mode, listener)) {
-}
-
-Channel::~Channel() {
-  delete channel_impl_;
-}
-
-bool Channel::Connect() {
-  return channel_impl_->Connect();
-}
-
-void Channel::Close() {
-  channel_impl_->Close();
-}
-
-base::ProcessId Channel::peer_pid() const {
-  return channel_impl_->peer_pid();
-}
-
-bool Channel::Send(Message* message) {
-  return channel_impl_->Send(message);
+// static
+scoped_ptr<Channel> Channel::Create(
+    const IPC::ChannelHandle &channel_handle, Mode mode, Listener* listener) {
+  return scoped_ptr<Channel>(
+      new ChannelNacl(channel_handle, mode, listener));
 }
 
 }  // namespace IPC