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 105 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()));
 }
 
+void PPB_FileIO_Proxy::GeneralCallbackCompleteInHost(

[brettw, 2012/10/11 18:05:50]

I like to keep the header and .cc ordering the same. And I like to keep the IPC
message handlers separate from the other stuff. Maybe for these cases we should
just have two blocks of ifdefs rather than trying to move some of the host
functions to the middle of the IPC handlers.

[bbudge, 2012/10/11 18:46:02]

Done for all files where methods were moved.

+    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,
+                                               pp_error));
+}
+
+void PPB_FileIO_Proxy::QueryCallbackCompleteInHost(
+    int32_t pp_error,
+    const HostResource& host_resource,
+    PP_FileInfo* info) {
+  Send(new PpapiMsg_PPBFileIO_QueryComplete(kApiID, host_resource, pp_error,
+                                            *info));
+  delete info;
+}
+
+void PPB_FileIO_Proxy::ReadCallbackCompleteInHost(
+    int32_t pp_error,
+    const HostResource& host_resource,
+    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)
+
 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(
     const HostResource& host_resource,
@@ skipping 19 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());
   }
 }
 
-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,
-                                               pp_error));
-}
-
-void PPB_FileIO_Proxy::QueryCallbackCompleteInHost(
-    int32_t pp_error,
-    const HostResource& host_resource,
-    PP_FileInfo* info) {
-  Send(new PpapiMsg_PPBFileIO_QueryComplete(kApiID, host_resource, pp_error,
-                                            *info));
-  delete info;
-}
-
-void PPB_FileIO_Proxy::ReadCallbackCompleteInHost(
-    int32_t pp_error,
-    const HostResource& host_resource,
-    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;
-}
-
 }  // namespace proxy
 }  // namespace ppapi