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

ppapi/proxy/ppb_instance_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_instance_proxy.h"
 
 #include "build/build_config.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/c/pp_var.h"
@@ skipping 79 matching lines @@
     &CreateInstanceProxy,
   };
   return &info;
 }
 
 bool PPB_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
   // Prevent the dispatcher from going away during a call to ExecuteScript.
   // This must happen OUTSIDE of ExecuteScript since the SerializedVars use
   // the dispatcher upon return of the function (converting the
   // SerializedVarReturnValue/OutParam to a SerializedVar in the destructor).
+#if !defined(OS_NACL)
   ScopedModuleReference death_grip(dispatcher());
+#endif
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Instance_Proxy, msg)
+#if !defined(OS_NACL)
     // Plugin -> Host messages.
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetWindowObject,
                         OnHostMsgGetWindowObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetOwnerElementObject,
                         OnHostMsgGetOwnerElementObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
                         OnHostMsgBindGraphics)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
                         OnHostMsgIsFullFrame)
     IPC_MESSAGE_HANDLER(
@@ skipping 25 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetCursor,
                         OnHostMsgSetCursor)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTextInputType,
                         OnHostMsgSetTextInputType)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateCaretPosition,
                         OnHostMsgUpdateCaretPosition)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_CancelCompositionText,
                         OnHostMsgCancelCompositionText)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateSurroundingText,
                         OnHostMsgUpdateSurroundingText)
+#endif  // !defined(OS_NACL)
+    // This message is needed to implement PPB_Testing_Dev.
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
                         OnHostMsgGetDocumentURL)
-
 #if !defined(OS_NACL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
                         OnHostMsgResolveRelativeToDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
                         OnHostMsgDocumentCanRequest)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
                         OnHostMsgDocumentCanAccessDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
                         OnHostMsgGetPluginInstanceURL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_NeedKey,
@@ skipping 615 matching lines @@
 }
 
 void PPB_Instance_Proxy::UpdateSurroundingText(PP_Instance instance,
                                                const char* text,
                                                uint32_t caret,
                                                uint32_t anchor) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_UpdateSurroundingText(
       API_ID_PPB_INSTANCE, instance, text, caret, anchor));
 }
 
+#if !defined(OS_NACL)
 void PPB_Instance_Proxy::OnHostMsgGetWindowObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.functions()->GetWindowObject(instance));
 }
 
 void PPB_Instance_Proxy::OnHostMsgGetOwnerElementObject(
     PP_Instance instance,
@@ skipping 123 matching lines @@
   EnterInstanceNoLock enter(instance, cb.pp_completion_callback());
   if (enter.succeeded())
     enter.SetResult(enter.functions()->LockMouse(instance, enter.callback()));
 }
 
 void PPB_Instance_Proxy::OnHostMsgUnlockMouse(PP_Instance instance) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->UnlockMouse(instance);
 }
+#endif  // !defined(OS_NACL)
 
 void PPB_Instance_Proxy::OnHostMsgGetDocumentURL(
     PP_Instance instance,
     PP_URLComponents_Dev* components,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     PP_Var document_url = enter.functions()->GetDocumentURL(instance,
                                                             components);
     result.Return(dispatcher(), document_url);
@@ skipping 164 matching lines @@
     PP_Resource audio_frames,
     const std::string& serialized_block_info) {
   PP_DecryptedBlockInfo block_info;
   if (!DeserializeBlockInfo(serialized_block_info, &block_info))
     return;
 
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->DeliverSamples(instance, audio_frames, &block_info);
 }
-#endif  // !defined(OS_NACL)
 
 void  PPB_Instance_Proxy::OnHostMsgSetCursor(
     PP_Instance instance,
     int32_t type,
     const ppapi::HostResource& custom_image,
     const PP_Point& hot_spot) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->SetCursor(
         instance, static_cast<PP_MouseCursor_Type>(type),
@@ skipping 27 matching lines @@
     PP_Instance instance,
     const std::string& text,
     uint32_t caret,
     uint32_t anchor) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->UpdateSurroundingText(instance, text.c_str(), caret,
                                              anchor);
   }
 }
+#endif  // !defined(OS_NACL)
 
 void PPB_Instance_Proxy::OnPluginMsgMouseLockComplete(PP_Instance instance,
                                                       int32_t result) {
   // Save the mouse callback on the instance data.
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return;  // Instance was probably deleted.
   if (!TrackedCallback::IsPending(data->mouse_lock_callback)) {
     NOTREACHED();
     return;
   }
   data->mouse_lock_callback->Run(result);
 }
 
+#if !defined(OS_NACL)
 void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
                                                  PP_Instance instance) {
   dispatcher()->Send(new PpapiMsg_PPBInstance_MouseLockComplete(
       API_ID_PPB_INSTANCE, instance, result));
 }
+#endif  // !defined(OS_NACL)
 
 void PPB_Instance_Proxy::CancelAnyPendingRequestSurroundingText(
     PP_Instance instance) {
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return;  // Instance was probably deleted.
   data->should_do_request_surrounding_text = false;
 }
 
 }  // namespace proxy
 }  // namespace ppapi