Exclude host-side code from the NaCl IRT proxy build.

ppapi/proxy/ppb_file_io_proxy.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 "ppapi/proxy/ppb_file_io_proxy.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_file_ref_proxy.h"
@@ skipping 10 matching lines @@
 
 namespace {
 
 // The maximum size we'll support reading in one chunk. The renderer process
 // must allocate a buffer sized according to the request of the plugin. To
 // keep things from getting out of control, we cap the read size to this value.
 // This should generally be OK since the API specifies that it may perform a
 // partial read.
 static const int32_t kMaxReadSize = 33554432;  // 32MB
 
+#if !defined(OS_NACL)
 typedef EnterHostFromHostResourceForceCallback<PPB_FileIO_API> EnterHostFileIO;
+#endif
 typedef EnterPluginFromHostResource<PPB_FileIO_API> EnterPluginFileIO;
 
 class FileIO : public PPB_FileIO_Shared {
  public:
   explicit FileIO(const HostResource& host_resource);
   virtual ~FileIO();
 
   // PPB_FileIO_API implementation (not provided by FileIOImpl).
   virtual void Close() OVERRIDE;
   virtual int32_t GetOSFileDescriptor() OVERRIDE;
@@ skipping 169 matching lines @@
   dispatcher->Send(new PpapiHostMsg_PPBFileIO_Create(kApiID, instance,
                                                      &result));
   if (result.is_null())
     return 0;
   return (new FileIO(result))->GetReference();
 }
 
 bool PPB_FileIO_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_FileIO_Proxy, msg)
+  #if !defined(OS_NACL)
     // Plugin -> host message.
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Create, OnHostMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Open, OnHostMsgOpen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Close, OnHostMsgClose)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Query, OnHostMsgQuery)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Touch, OnHostMsgTouch)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Read, OnHostMsgRead)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Write, OnHostMsgWrite)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_SetLength, OnHostMsgSetLength)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Flush, OnHostMsgFlush)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_WillWrite, OnHostMsgWillWrite)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_WillSetLength,
                         OnHostMsgWillSetLength)
-
+#endif  // !defined(OS_NACL)
     // Host -> plugin messages.
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_GeneralComplete,
                         OnPluginMsgGeneralComplete)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_OpenFileComplete,
                         OnPluginMsgOpenFileComplete)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_QueryComplete,
                         OnPluginMsgQueryComplete)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_ReadComplete,
                         OnPluginMsgReadComplete)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+#if !defined(OS_NACL)
 void PPB_FileIO_Proxy::OnHostMsgCreate(PP_Instance instance,
                                        HostResource* result) {
   thunk::EnterResourceCreation enter(instance);
   if (enter.succeeded()) {
     result->SetHostResource(instance,
                             enter.functions()->CreateFileIO(instance));
   }
 }
 
 void PPB_FileIO_Proxy::OnHostMsgOpen(const HostResource& host_resource,
@@ skipping 104 matching lines @@
 }
 
 void PPB_FileIO_Proxy::OnHostMsgWillSetLength(const HostResource& host_resource,
                                               int64_t length) {
   EnterHostFileIO enter(host_resource, callback_factory_,
                         &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost,
                         host_resource);
   if (enter.succeeded())
     enter.SetResult(enter.object()->WillSetLength(length, enter.callback()));
 }
+#endif  // !defined(OS_NACL)
 
 void PPB_FileIO_Proxy::OnPluginMsgGeneralComplete(
     const HostResource& host_resource,
     int32_t result) {
   EnterPluginFileIO enter(host_resource);
   if (enter.succeeded())
     static_cast<FileIO*>(enter.object())->ExecuteGeneralCallback(result);
 }
 
 void PPB_FileIO_Proxy::OnPluginMsgOpenFileComplete(
@@ skipping 20 matching lines @@
   EnterPluginFileIO enter(host_resource);
   if (enter.succeeded()) {
     // The result code should contain the data size if it's positive.
     DCHECK((result < 0 && data.size() == 0) ||
            result == static_cast<int32_t>(data.size()));
     static_cast<FileIO*>(enter.object())->ExecuteReadCallback(result,
                                                               data.data());
   }
 }
 
+#if !defined(OS_NACL)
 void PPB_FileIO_Proxy::GeneralCallbackCompleteInHost(
     int32_t pp_error,
     const HostResource& host_resource) {
   Send(new PpapiMsg_PPBFileIO_GeneralComplete(kApiID, host_resource, pp_error));
 }
 
 void PPB_FileIO_Proxy::OpenFileCallbackCompleteInHost(
     int32_t pp_error,
     const HostResource& host_resource) {
   Send(new PpapiMsg_PPBFileIO_OpenFileComplete(kApiID, host_resource,
@@ skipping 15 matching lines @@
     std::string* data) {
   // Only send the amount of data in the string that was actually read.
   if (pp_error >= 0) {
     DCHECK(pp_error <= static_cast<int32_t>(data->size()));
     data->resize(pp_error);
   }
   Send(new PpapiMsg_PPBFileIO_ReadComplete(kApiID, host_resource, pp_error,
                                            *data));
   delete data;
 }
+#endif  // !defined(OS_NACL)
 
 }  // namespace proxy
 }  // namespace ppapi