Add ipc_channel_nacl to the untrusted build and fix all compile/link errors.

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 "base/file_util.h"
 #include "base/logging.h"
 
 // This file is currently a stub to get us linking.
 // TODO(brettw) implement this.
 
 namespace IPC {
 
-ChannelImpl::ChannelImpl(const IPC::ChannelHandle& channel_handle,
+Channel::ChannelImpl::ChannelImpl(const IPC::ChannelHandle& channel_handle,
                          Mode mode,
                          Listener* listener)
     : ChannelReader(listener) {
 }
 
-ChannelImpl::~ChannelImpl() {
+Channel::ChannelImpl::~ChannelImpl() {
   Close();
 }
 
-bool ChannelImpl::Connect() {
+bool Channel::ChannelImpl::Connect() {
   NOTIMPLEMENTED();
   return false;
 }
 
-void ChannelImpl::Close() {
+void Channel::ChannelImpl::Close() {
   NOTIMPLEMENTED();
 }
 
-bool ChannelImpl::Send(Message* message) {
+bool Channel::ChannelImpl::Send(Message* message) {
   NOTIMPLEMENTED();
 }
 
-int ChannelImpl::GetClientFileDescriptor() const {
+int Channel::ChannelImpl::GetClientFileDescriptor() const {
   NOTIMPLEMENTED();
   return -1;
 }
 
-int ChannelImpl::TakeClientFileDescriptor() {
+int Channel::ChannelImpl::TakeClientFileDescriptor() {
   NOTIMPLEMENTED();
   return -1;
 }
 
-bool ChannelImpl::AcceptsConnections() const {
+bool Channel::ChannelImpl::AcceptsConnections() const {
   NOTIMPLEMENTED();
   return false;
 }
 
-bool ChannelImpl::HasAcceptedConnection() const {
+bool Channel::ChannelImpl::HasAcceptedConnection() const {
   NOTIMPLEMENTED();
   return false;
 }
 
-bool ChannelImpl::GetClientEuid(uid_t* client_euid) const {
+bool Channel::ChannelImpl::GetClientEuid(uid_t* client_euid) const {
   NOTIMPLEMENTED();
   return false;
 }
 
-void ChannelImpl::ResetToAcceptingConnectionState() {
+void Channel::ChannelImpl::ResetToAcceptingConnectionState() {
   NOTIMPLEMENTED();
 }
 
+Channel::ChannelImpl::ReadState
+    Channel::ChannelImpl::ReadData(char* buffer,

[brettw, 2012/04/23 21:17:35]

I think generally we wouldn't indent this second line any.

+                                   int buffer_len,
+                                   int* bytes_read) {
+  return Channel::ChannelImpl::ReadState();
+}
+
+bool Channel::ChannelImpl::WillDispatchInputMessage(Message* msg) {
+  return false;
+}
+
+bool Channel::ChannelImpl::DidEmptyInputBuffers() {
+  return false;
+}
+
+void Channel::ChannelImpl::HandleHelloMessage(const Message& msg) {
+}
+
 // static
 bool Channel::ChannelImpl::IsNamedServerInitialized(
     const std::string& channel_id) {
-  return file_util::PathExists(FilePath(channel_id));
+  return false;  //file_util::PathExists(FilePath(channel_id));
 }
 
 //------------------------------------------------------------------------------
 // Channel's methods simply call through to ChannelImpl.
 
 Channel::Channel(const IPC::ChannelHandle& channel_handle,
                  Mode mode,
                  Listener* listener)
     : channel_impl_(new ChannelImpl(channel_handle, mode, listener)) {
 }
@@ skipping 35 matching lines @@
 }
 
 bool Channel::GetClientEuid(uid_t* client_euid) const {
   return channel_impl_->GetClientEuid(client_euid);
 }
 
 void Channel::ResetToAcceptingConnectionState() {
   channel_impl_->ResetToAcceptingConnectionState();
 }
 
+base::ProcessId Channel::peer_pid() const { return 0; }

[brettw, 2012/04/23 21:17:35]

I'd do multiple lines except for some cases in a class definition.

+
 // static
 bool Channel::IsNamedServerInitialized(const std::string& channel_id) {
   return ChannelImpl::IsNamedServerInitialized(channel_id);
 }
 
 // static
 std::string Channel::GenerateVerifiedChannelID(const std::string& prefix) {
   // A random name is sufficient validation on posix systems, so we don't need
   // an additional shared secret.
   std::string id = prefix;
   if (!id.empty())
     id.append(".");
 
   return id.append(GenerateUniqueRandomChannelID());
 }
 
 }  // namespace IPC