PNaCl: Use Chrome IPC to talk to the linker process, instead of SRPC

ppapi/proxy/nacl_message_scanner.cc

 // Copyright 2013 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/nacl_message_scanner.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 125 matching lines @@
   if (results->pp_resource && !results->nested_msg_callback.is_null()) {
     SerializedHandle* handle = NULL;
     if (results->handles.size() == 1)
       handle = &results->handles[0];
     results->nested_msg_callback.Run(results->pp_resource, param, handle);
   }
   if (results->new_msg)
     IPC::WriteParam(results->new_msg.get(), param);
 }
 
+template <class T>
+void ScanParam(const std::vector<T>& vec, ScanningResults* results) {
+  if (results->new_msg)
+    IPC::WriteParam(results->new_msg.get(), static_cast<int>(vec.size()));
+  for (const T& element : vec) {
+    ScanParam(element, results);
+  }
+}
+
 // Overload to match all other types. If we need to rewrite the message, write
 // the parameter.
 template <class T>
 void ScanParam(const T& param, ScanningResults* results) {
   if (results->new_msg)
     IPC::WriteParam(results->new_msg.get(), param);
 }
 
 // These just break apart the given tuple and run ScanParam over each param.
 // The idea is to scan elements in the tuple which require special handling,
@@ skipping 29 matching lines @@
   }
   bool ScanMessage(ScanningResults* results) {
     typename base::TupleTypes<typename MessageType::Schema::Param>::ValueTuple
         params;
     if (!MessageType::Read(msg_, &params))
       return false;
     ScanTuple(params, results);
     return true;
   }
 
+  bool ScanSyncMessage(ScanningResults* results) {
+    typename base::TupleTypes<typename MessageType::Schema::SendParam>
+        ::ValueTuple params;
+    if (!MessageType::ReadSendParam(msg_, &params))
+      return false;
+    // If we need to rewrite the message, write the message id first.
+    if (results->new_msg) {
+      results->new_msg->set_sync();
+      int id = IPC::SyncMessage::GetMessageId(*msg_);
+      results->new_msg->WriteInt(id);
+    }
+    ScanTuple(params, results);
+    return true;
+  }
+
   bool ScanReply(ScanningResults* results) {
     typename base::TupleTypes<typename MessageType::Schema::ReplyParam>
         ::ValueTuple params;
     if (!MessageType::ReadReplyParam(msg_, &params))
       return false;
     // If we need to rewrite the message, write the message id first.
     if (results->new_msg) {
       results->new_msg->set_reply();
       int id = IPC::SyncMessage::GetMessageId(*msg_);
       results->new_msg->WriteInt(id);
     }
     ScanTuple(params, results);
     return true;
   }
-  // TODO(dmichael): Add ScanSyncMessage for outgoing sync messages, if we ever
-  //                 need to scan those.
 
  private:
   const MessageType* msg_;
 };
 
 }  // namespace
 
 #define CASE_FOR_MESSAGE(MESSAGE_TYPE) \
       case MESSAGE_TYPE::ID: { \
         MessageScannerImpl<MESSAGE_TYPE> scanner(&msg); \
         if (rewrite_msg) \
           results.new_msg.reset( \
               new IPC::Message(msg.routing_id(), msg.type(), \
                                IPC::Message::PRIORITY_NORMAL)); \
         if (!scanner.ScanMessage(&results)) \
           return false; \
         break; \
       }
+#define CASE_FOR_SYNC_MESSAGE(MESSAGE_TYPE) \
+      case MESSAGE_TYPE::ID: { \
+        MessageScannerImpl<MESSAGE_TYPE> scanner(&msg); \
+        if (rewrite_msg) \
+          results.new_msg.reset( \
+              new IPC::Message(msg.routing_id(), msg.type(), \
+                               IPC::Message::PRIORITY_NORMAL)); \
+        if (!scanner.ScanSyncMessage(&results)) \
+          return false; \
+        break; \
+      }
 #define CASE_FOR_REPLY(MESSAGE_TYPE) \
       case MESSAGE_TYPE::ID: { \
         MessageScannerImpl<MESSAGE_TYPE> scanner(&msg); \
         if (rewrite_msg) \
           results.new_msg.reset( \
               new IPC::Message(msg.routing_id(), msg.type(), \
                                IPC::Message::PRIORITY_NORMAL)); \
         if (!scanner.ScanReply(&results)) \
           return false; \
         break; \
@@ skipping 85 matching lines @@
   // that there are no handles, we can cancel the rewriting by clearing the
   // results.new_msg pointer.
   ScanningResults results;
   results.nested_msg_callback =
       base::Bind(&NaClMessageScanner::AuditNestedMessage,
                  base::Unretained(this));
   switch (type) {
     CASE_FOR_MESSAGE(PpapiMsg_PPBAudio_NotifyAudioStreamCreated)
     CASE_FOR_MESSAGE(PpapiMsg_PPPMessaging_HandleMessage)
     CASE_FOR_MESSAGE(PpapiPluginMsg_ResourceReply)
+    CASE_FOR_SYNC_MESSAGE(PpapiMsg_PnaclTranslatorLink)
     CASE_FOR_REPLY(PpapiHostMsg_OpenResource)
     CASE_FOR_REPLY(PpapiHostMsg_PPBGraphics3D_Create)
     CASE_FOR_REPLY(PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer)
     CASE_FOR_REPLY(PpapiHostMsg_PPBImageData_CreateSimple)
     CASE_FOR_REPLY(PpapiHostMsg_ResourceSyncCall)
     CASE_FOR_REPLY(PpapiHostMsg_SharedMemory_CreateSharedMemory)
     default:
       // Do nothing for messages we don't know.
       break;
   }
@@ skipping 180 matching lines @@
             fio_it->second->SetMaxWrittenOffset(offset_it->second);
         }
       }
       break;
     }
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi