Pepper: Make pending_sync_msgs_ local to IO thread.

ppapi/proxy/nacl_message_scanner_unittest.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 "ipc/ipc_message.h"
 #include "ppapi/proxy/nacl_message_scanner.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppapi_proxy_test.h"
 #include "ppapi/proxy/serialized_handle.h"
 #include "ppapi/shared_impl/host_resource.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 const PP_Resource kInvalidResource = 0;
 const PP_Resource kFileSystem = 1;
 const PP_Resource kFileIO = 2;
 const int64_t kQuotaReservationAmount = 100;
 }
 
 class NaClMessageScannerTest : public PluginProxyTest {
  public:
   NaClMessageScannerTest() {}
 
-  uint32 FindPendingSyncMessage(
-      const NaClMessageScanner& scanner,
-      const IPC::Message& msg) {
-    int msg_id = IPC::SyncMessage::GetMessageId(msg);
-    std::map<int, uint32>::const_iterator it =
-        scanner.pending_sync_msgs_.find(msg_id);
-    // O can signal that no message was found.
-    return (it != scanner.pending_sync_msgs_.end()) ? it->second : 0;
-  }
-
   NaClMessageScanner::FileSystem* FindFileSystem(
       const NaClMessageScanner& scanner,
       PP_Resource file_system) {
     NaClMessageScanner::FileSystemMap::const_iterator it =
         scanner.file_systems_.find(file_system);
     return (it != scanner.file_systems_.end()) ? it->second : NULL;
   }
 
   NaClMessageScanner::FileIO* FindFileIO(
       const NaClMessageScanner& scanner,
       PP_Resource file_io) {
     NaClMessageScanner::FileIOMap::const_iterator it =
         scanner.files_.find(file_io);
     return (it != scanner.files_.end()) ? it->second : NULL;
   }
 
   void OpenQuotaFile(NaClMessageScanner* scanner,
                      PP_Resource file_io,
                      PP_Resource file_system) {
     std::vector<SerializedHandle> unused_handles;
     ResourceMessageReplyParams fio_reply_params(file_io, 0);
     scoped_ptr<IPC::Message> new_msg_ptr;
     scanner->ScanMessage(
-      PpapiPluginMsg_ResourceReply(
-          fio_reply_params,
-          PpapiPluginMsg_FileIO_OpenReply(file_system, 0)),
-      &unused_handles,
-      &new_msg_ptr);
+        PpapiPluginMsg_ResourceReply(
+            fio_reply_params,
+            PpapiPluginMsg_FileIO_OpenReply(file_system, 0)),
+        PpapiPluginMsg_ResourceReply::ID,
+        &unused_handles,
+        &new_msg_ptr);
     EXPECT_FALSE(new_msg_ptr);
   }
 };
 
-TEST_F(NaClMessageScannerTest, SyncMessageAndReply) {
-  NaClMessageScanner test;
-  ppapi::proxy::SerializedHandle handle(
-      ppapi::proxy::SerializedHandle::SHARED_MEMORY);
-  int id = -1;
-  IPC::Message msg =
-      PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer(
-          ppapi::API_ID_PPB_GRAPHICS_3D,
-          HostResource(),
-          4096,  // size
-          &id,
-          &handle);
-  scoped_ptr<IPC::Message> new_msg_ptr;
-  EXPECT_NE(msg.type(), FindPendingSyncMessage(test, msg));
-  test.ScanUntrustedMessage(msg, &new_msg_ptr);
-  EXPECT_FALSE(new_msg_ptr);
-  EXPECT_EQ(msg.type(), FindPendingSyncMessage(test, msg));
-
-  // TODO(bbudge) Figure out how to put together a sync reply message.
-}
-
 TEST_F(NaClMessageScannerTest, FileOpenClose) {
   NaClMessageScanner test;
   std::vector<SerializedHandle> unused_handles;
   ResourceMessageCallParams fio_call_params(kFileIO, 0);
   ResourceMessageCallParams fs_call_params(kFileSystem, 0);
   ResourceMessageReplyParams fio_reply_params(kFileIO, 0);
   ResourceMessageReplyParams fs_reply_params(kFileSystem, 0);
   scoped_ptr<IPC::Message> new_msg_ptr;
 
   EXPECT_EQ(NULL, FindFileSystem(test, kFileSystem));
   EXPECT_EQ(NULL, FindFileIO(test, kFileIO));
 
   // Open a file, not in a quota file system.
   test.ScanMessage(
       PpapiPluginMsg_ResourceReply(
           fio_reply_params,
           PpapiPluginMsg_FileIO_OpenReply(kInvalidResource, 0)),
+      PpapiPluginMsg_ResourceReply::ID,
       &unused_handles,
       &new_msg_ptr);
   EXPECT_FALSE(new_msg_ptr);
   EXPECT_FALSE(FindFileSystem(test, kFileSystem));
   EXPECT_FALSE(FindFileIO(test, kFileIO));
 
   // Open a file in a quota file system; info objects for it and its file system
   // should be created.
   OpenQuotaFile(&test, kFileIO, kFileSystem);
   NaClMessageScanner::FileSystem* fs = FindFileSystem(test, kFileSystem);
@@ skipping 72 matching lines @@
   // Receive reserved quota, and updated file sizes.
   const int64_t kNewFileSize = 10;
   FileSizeMap file_sizes;
   file_sizes[kFileIO] = kNewFileSize;
   test.ScanMessage(
       PpapiPluginMsg_ResourceReply(
           fs_reply_params,
           PpapiPluginMsg_FileSystem_ReserveQuotaReply(
               kQuotaReservationAmount,
               file_sizes)),
+      PpapiPluginMsg_ResourceReply::ID,
       &unused_handles,
       &new_msg_ptr);
   EXPECT_FALSE(new_msg_ptr);
   EXPECT_EQ(kQuotaReservationAmount, fs->reserved_quota());
   EXPECT_EQ(kNewFileSize, fio->max_written_offset());
 
   // We should be able to grow the file within quota.
   EXPECT_TRUE(fio->Grow(1));
   EXPECT_EQ(kQuotaReservationAmount - 1, fs->reserved_quota());
   EXPECT_EQ(kNewFileSize + 1, fio->max_written_offset());
@@ skipping 42 matching lines @@
   // Receive reserved quota, and updated file sizes.
   const int64_t kNewFileSize = 10;
   FileSizeMap file_sizes;
   file_sizes[kFileIO] = 0;
   test.ScanMessage(
       PpapiPluginMsg_ResourceReply(
           fs_reply_params,
           PpapiPluginMsg_FileSystem_ReserveQuotaReply(
               kQuotaReservationAmount,
               file_sizes)),
+      PpapiPluginMsg_ResourceReply::ID,
       &unused_handles,
       &new_msg_ptr);
 
   // We should be able to SetLength within quota.
   test.ScanUntrustedMessage(
       PpapiHostMsg_ResourceCall(
           fio_call_params,
           PpapiHostMsg_FileIO_SetLength(kNewFileSize)),
       &new_msg_ptr);
   EXPECT_FALSE(new_msg_ptr);
@@ skipping 16 matching lines @@
               UnpackMessage<PpapiHostMsg_FileIO_SetLength>(
                   nested_msg, &length));
   new_msg_ptr.reset();
   EXPECT_EQ(-1, length);
   EXPECT_EQ(kQuotaReservationAmount - kNewFileSize, fs->reserved_quota());
   EXPECT_EQ(kNewFileSize, fio->max_written_offset());
 }
 
 }  // namespace proxy
 }  // namespace ppapi