Pepper: Make pending_sync_msgs_ local to IO thread.

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 273 matching lines @@
   for (FileIOMap::iterator it = files_.begin(); it != files_.end(); ++it)
     delete it->second;
 }
 
 // Windows IPC differs from POSIX in that native handles are serialized in the
 // message body, rather than passed in a separate FileDescriptorSet. Therefore,
 // on Windows, any message containing handles must be rewritten in the POSIX
 // format before we can send it to the NaCl plugin.
 bool NaClMessageScanner::ScanMessage(
     const IPC::Message& msg,
+    uint32_t type,

[dmichael (off chromium), 2014/08/18 20:06:09]

This parameter would be pretty confusing I think to somebody new to this class.
I think it needs a comment that for normal messages it matches msg.id(), but it
will be the id of the original message if this is a sync reply. Or something.

     std::vector<SerializedHandle>* handles,
     scoped_ptr<IPC::Message>* new_msg_ptr) {
   DCHECK(handles);
   DCHECK(handles->empty());
   DCHECK(new_msg_ptr);
   DCHECK(!new_msg_ptr->get());
 
   bool rewrite_msg =
 #if defined(OS_WIN)
       true;
 #else
       false;
 #endif
 
   // We can't always tell from the message ID if rewriting is needed. Therefore,
   // scan any message types that might contain a handle. If we later determine
   // 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 (msg.type()) {
+  switch (type) {
     CASE_FOR_MESSAGE(PpapiMsg_PPBAudio_NotifyAudioStreamCreated)
     CASE_FOR_MESSAGE(PpapiMsg_PPPMessaging_HandleMessage)
     CASE_FOR_MESSAGE(PpapiPluginMsg_ResourceReply)
-    case IPC_REPLY_ID: {
-      int id = IPC::SyncMessage::GetMessageId(msg);
-      PendingSyncMsgMap::iterator iter(pending_sync_msgs_.find(id));
-      if (iter == pending_sync_msgs_.end()) {
-        NOTREACHED();
-        return false;
-      }
-      uint32_t type = iter->second;
-      pending_sync_msgs_.erase(iter);
-      switch (type) {
-        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;
-      }
-      break;
-    }
+    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
   // found, don't return the rewritten message either. This must be changed if
   // we ever add new param types that also require rewriting.
   if (!results.handles.empty()) {
     handles->swap(results.handles);
     *new_msg_ptr = results.new_msg.Pass();
   }
   return true;
 }
 
 void NaClMessageScanner::ScanUntrustedMessage(
     const IPC::Message& untrusted_msg,
     scoped_ptr<IPC::Message>* new_msg_ptr) {
-  if (untrusted_msg.is_sync())
-    RegisterSyncMessageForReply(untrusted_msg);
-
   // Audit FileIO and FileSystem messages to ensure that the plugin doesn't
   // exceed its file quota. If we find the message is malformed, just pass it
   // through - we only care about well formed messages to the host.
   if (untrusted_msg.type() == PpapiHostMsg_ResourceCall::ID) {
     ResourceMessageCallParams params;
     IPC::Message nested_msg;
     if (!UnpackMessage<PpapiHostMsg_ResourceCall>(
             untrusted_msg, &params, &nested_msg))
       return;
 
@@ skipping 95 matching lines @@
         if (fs_it != file_systems_.end()) {
           delete fs_it->second;
           file_systems_.erase(fs_it);
         }
         break;
       }
     }
   }
 }
 
-void NaClMessageScanner::RegisterSyncMessageForReply(const IPC::Message& msg) {
-  int msg_id = IPC::SyncMessage::GetMessageId(msg);
-  DCHECK(pending_sync_msgs_.find(msg_id) == pending_sync_msgs_.end());
-
-  pending_sync_msgs_[msg_id] = msg.type();
-}
-
 NaClMessageScanner::FileIO* NaClMessageScanner::GetFile(
     PP_Resource file_io) {
   FileIOMap::iterator it = files_.find(file_io);
   DCHECK(it != files_.end());
   return it->second;
 }
 
 void NaClMessageScanner::AuditNestedMessage(PP_Resource resource,
                                             const IPC::Message& msg,
                                             SerializedHandle* handle) {
@@ skipping 41 matching lines @@
             fio_it->second->SetMaxWrittenOffset(offset_it->second);
         }
       }
       break;
     }
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi