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

ppapi/proxy/ppb_url_loader_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_url_loader_proxy.h"
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
@@ skipping 30 matching lines @@
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // The maximum size we'll read into the plugin without being explicitly
 // asked for a larger buffer.
 const int32_t kMaxReadBufferSize = 16777216;  // 16MB
 
+#if !defined(OS_NACL)
 // Called in the renderer when the byte counts have changed. We send a message
 // to the plugin to synchronize its counts so it can respond to status polls
 // from the plugin.
 void UpdateResourceLoadStatus(PP_Instance pp_instance,
                               PP_Resource pp_resource,
                               int64 bytes_sent,
                               int64 total_bytes_to_be_sent,
                               int64 bytes_received,
                               int64 total_bytes_to_be_received) {
-#if !defined(OS_NACL)
   Dispatcher* dispatcher = HostDispatcher::GetForInstance(pp_instance);
   if (!dispatcher)
     return;
 
   PPBURLLoader_UpdateProgress_Params params;
   params.instance = pp_instance;
   params.resource.SetHostResource(pp_instance, pp_resource);
   params.bytes_sent = bytes_sent;
   params.total_bytes_to_be_sent = total_bytes_to_be_sent;
   params.bytes_received = bytes_received;
   params.total_bytes_to_be_received = total_bytes_to_be_received;
   dispatcher->Send(new PpapiMsg_PPBURLLoader_UpdateProgress(
       API_ID_PPB_URL_LOADER, params));
-#endif
 }
+#endif  // !defined(OS_NACL)
 
 InterfaceProxy* CreateURLLoaderProxy(Dispatcher* dispatcher) {
   return new PPB_URLLoader_Proxy(dispatcher);
 }
 
 }  // namespace
 
 // URLLoader -------------------------------------------------------------------
 
 class URLLoader : public Resource, public PPB_URLLoader_API {
@@ skipping 319 matching lines @@
   dispatcher->Send(new PpapiHostMsg_PPBURLLoader_Create(
       API_ID_PPB_URL_LOADER, pp_instance, &result));
   if (result.is_null())
     return 0;
   return PPB_URLLoader_Proxy::TrackPluginResource(result);
 }
 
 bool PPB_URLLoader_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_URLLoader_Proxy, msg)
+#if !defined(OS_NACL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_Create,
                         OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_Open,
                         OnMsgOpen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_FollowRedirect,
                         OnMsgFollowRedirect)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_GetResponseInfo,
                         OnMsgGetResponseInfo)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_ReadResponseBody,
                         OnMsgReadResponseBody)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_FinishStreamingToFile,
                         OnMsgFinishStreamingToFile)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_Close,
                         OnMsgClose)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBURLLoader_GrantUniversalAccess,
                         OnMsgGrantUniversalAccess)
+#endif  // !defined(OS_NACL)
+
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBURLLoader_UpdateProgress,
                         OnMsgUpdateProgress)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBURLLoader_ReadResponseBody_Ack,
                         OnMsgReadResponseBodyAck)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBURLLoader_CallbackComplete,
                         OnMsgCallbackComplete)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
+#if !defined(OS_NACL)
 void PPB_URLLoader_Proxy::PrepareURLLoaderForSendingToPlugin(
     PP_Resource resource) {
   // So the plugin can query load status, we need to register our status
   // callback before sending any URLLoader to the plugin.
   EnterResourceNoLock<PPB_URLLoader_API> enter(resource, false);
   if (enter.succeeded())
     enter.object()->SetStatusCallback(&UpdateResourceLoadStatus);
   else
     NOTREACHED();  // Only called internally, resource should be valid.
 }
@@ skipping 93 matching lines @@
   if (enter.succeeded())
     enter.object()->Close();
 }
 
 void PPB_URLLoader_Proxy::OnMsgGrantUniversalAccess(
     const HostResource& loader) {
   EnterHostFromHostResource<PPB_URLLoader_API> enter(loader);
   if (enter.succeeded())
     enter.object()->GrantUniversalAccess();
 }
+#endif  // !defined(OS_NACL)
 
 // Called in the Plugin.
 void PPB_URLLoader_Proxy::OnMsgUpdateProgress(
     const PPBURLLoader_UpdateProgress_Params& params) {
   EnterPluginFromHostResource<PPB_URLLoader_API> enter(params.resource);
   if (enter.succeeded())
     static_cast<URLLoader*>(enter.object())->UpdateProgress(params);
 }
 
 // Called in the Plugin.
@@ skipping 29 matching lines @@
 
 // Called in the plugin.
 void PPB_URLLoader_Proxy::OnMsgCallbackComplete(
     const HostResource& host_resource,
     int32_t result) {
   EnterPluginFromHostResource<PPB_URLLoader_API> enter(host_resource);
   if (enter.succeeded())
     static_cast<URLLoader*>(enter.object())->CallbackComplete(result);
 }
 
+#if !defined(OS_NACL)
 void PPB_URLLoader_Proxy::OnReadCallback(int32_t result,
                                          IPC::Message* message) {
   int32_t bytes_read = 0;
   if (result > 0)
     bytes_read = result;  // Positive results indicate bytes read.
 
   message->TrimWriteData(bytes_read);
   message->WriteInt(result);
 
   dispatcher()->Send(message);
 }
 
 void PPB_URLLoader_Proxy::OnCallback(int32_t result,
                                      const HostResource& resource) {
   dispatcher()->Send(new PpapiMsg_PPBURLLoader_CallbackComplete(
       API_ID_PPB_URL_LOADER, resource, result));
 }
+#endif  // !defined(OS_NACL)
 
 }  // namespace proxy
 }  // namespace ppapi