Make ChannelMojo compile under NaCl.

ipc/mojo/ipc_channel_mojo.cc

 // Copyright 2014 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/mojo/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_attachment_set.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/mojo/ipc_mojo_bootstrap.h"
 #include "ipc/mojo/ipc_mojo_handle_attachment.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
-#if defined(OS_POSIX) && !defined(OS_NACL)
+#if defined(OS_POSIX)
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "ipc/mach_port_attachment_mac.h"
 #endif
 
 #if defined(OS_WIN)
 #include "ipc/handle_attachment_win.h"
 #endif
@@ skipping 36 matching lines @@
   MojoResult wrap_result = mojo::edk::CreatePlatformHandleWrapper(
       std::move(handle), &wrapped_handle);
   if (wrap_result != MOJO_RESULT_OK)
     return wrap_result;
 
   *serialized = CreateSerializedHandle(
       mojo::MakeScopedHandle(mojo::Handle(wrapped_handle)), type);
   return MOJO_RESULT_OK;
 }
 
-#if defined(OS_POSIX) && !defined(OS_NACL)
+#if defined(OS_POSIX)
 
 base::ScopedFD TakeOrDupFile(internal::PlatformFileAttachment* attachment) {
   return attachment->Owns() ? base::ScopedFD(attachment->TakePlatformFile())
                             : base::ScopedFD(dup(attachment->file()));
 }
 
 #endif
 
 MojoResult WrapAttachmentImpl(MessageAttachment* attachment,
                               mojom::SerializedHandlePtr* serialized) {
   if (attachment->GetType() == MessageAttachment::TYPE_MOJO_HANDLE) {
     *serialized = CreateSerializedHandle(
         static_cast<internal::MojoHandleAttachment&>(*attachment).TakeHandle(),
         mojom::SerializedHandle::Type::MOJO_HANDLE);
     return MOJO_RESULT_OK;
   }
-#if defined(OS_POSIX) && !defined(OS_NACL)
+#if defined(OS_POSIX)
   if (attachment->GetType() == MessageAttachment::TYPE_PLATFORM_FILE) {
     // We dup() the handles in IPC::Message to transmit.
     // IPC::MessageAttachmentSet has intricate lifecycle semantics
     // of FDs, so just to dup()-and-own them is the safest option.
     base::ScopedFD file = TakeOrDupFile(
         static_cast<IPC::internal::PlatformFileAttachment*>(attachment));
     if (!file.is_valid()) {
       DPLOG(WARNING) << "Failed to dup FD to transmit.";
       return MOJO_RESULT_UNKNOWN;
     }
@@ skipping 257 matching lines @@
                "line", IPC_MESSAGE_ID_LINE(message.type()));
   if (AttachmentBroker* broker = AttachmentBroker::GetGlobal()) {
     if (broker->OnMessageReceived(message))
       return;
   }
   listener_->OnMessageReceived(message);
   if (message.dispatch_error())
     listener_->OnBadMessageReceived(message);
 }
 
-#if defined(OS_POSIX) && !defined(OS_NACL)
+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
 int ChannelMojo::GetClientFileDescriptor() const {
   return -1;
 }
 
 base::ScopedFD ChannelMojo::TakeClientFileDescriptor() {
   return base::ScopedFD(GetClientFileDescriptor());
 }
-#endif  // defined(OS_POSIX) && !defined(OS_NACL)
+#endif  // defined(OS_POSIX) && !defined(OS_NACL_SFI)
 
 // static
 MojoResult ChannelMojo::ReadFromMessageAttachmentSet(
     Message* message,
     mojo::Array<mojom::SerializedHandlePtr>* handles) {
   if (message->HasAttachments()) {
     MessageAttachmentSet* set = message->attachment_set();
     for (unsigned i = 0; i < set->num_non_brokerable_attachments(); ++i) {
       MojoResult result = WrapAttachment(
               set->GetNonBrokerableAttachmentAt(i).get(), handles);
@@ skipping 35 matching lines @@
     DCHECK(ok);
     if (!ok) {
       LOG(ERROR) << "Failed to add new Mojo handle.";
       return MOJO_RESULT_UNKNOWN;
     }
   }
   return MOJO_RESULT_OK;
 }
 
 }  // namespace IPC