Pepper: Stop using SRPC for irt_open_resource().

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 <vector>
 #include "base/bind.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
@@ skipping 33 matching lines @@
   // so when we audit the nested message, we know which resource it is for.
   PP_Resource pp_resource;
   // Callback to receive the nested message in a resource message or reply.
   base::Callback<void(PP_Resource, const IPC::Message&, SerializedHandle*)>
       nested_msg_callback;
 };
 
 void WriteHandle(int handle_index,
                  const SerializedHandle& handle,
                  IPC::Message* msg) {
   SerializedHandle::WriteHeader(handle.header(), msg);

[Mark Seaborn, 2014/09/08 16:26:53]

BTW, this has a return valid that isn't checked here.  Would this only fail on
out-of-memory?

[teravest, 2014/09/08 20:25:28]

I inspected SerializedHandle::WriteHeader and found the following underlying
calls to Pickle:
  WriteInt
  WriteUInt32
which, on inspection, appear to always return true.

 
-  // Now write the handle itself in POSIX style.
-  msg->WriteBool(true);  // valid == true
-  msg->WriteInt(handle_index);
+  if (handle.type() != SerializedHandle::INVALID) {

[Mark Seaborn, 2014/09/08 16:26:52]

Where is the corresponding reader for this format?  I can't find what reads the
"valid" field.

[teravest, 2014/09/08 20:25:27]

The valid field is read out here:
https://code.google.com/p/chromium/codesearch#chromium/src/ipc/ipc_message_ut...

I've added a comment to specify where the read side is.

+    // Now write the handle itself in POSIX style.
+    msg->WriteBool(true);  // valid == true
+    msg->WriteInt(handle_index);
+  }
 }
 
 // Define overloads for each kind of message parameter that requires special
 // handling. See ScanTuple for how these get used.
 
 // Overload to match SerializedHandle.
 void ScanParam(const SerializedHandle& handle, ScanningResults* results) {
   results->handles.push_back(handle);
   if (results->new_msg)
     WriteHandle(results->handle_index++, handle, results->new_msg.get());
@@ skipping 242 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_REPLY(PpapiHostMsg_OpenResource)
     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;
   }
 
   // Only messages containing handles need to be rewritten. If no handles are
@@ skipping 178 matching lines @@
             fio_it->second->SetMaxWrittenOffset(offset_it->second);
         }
       }
       break;
     }
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi