Change NaClIPCAdapter to save translated descriptors to the rewritten message.

chrome/nacl/nacl_ipc_adapter.h

 // 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.
 
 #ifndef CHROME_NACL_NACL_IPC_ADAPTER_H_
 #define CHROME_NACL_NACL_IPC_ADAPTER_H_
 
 #include <queue>
 #include <string>
 
@@ skipping 108 matching lines @@
 
     // Data that we've queued from the plugin to send, but doesn't consist of a
     // full message yet. The calling code can break apart the message into
     // smaller pieces, and we need to send the message to the other process in
     // one chunk.
     //
     // The IPC channel always starts a new send() at the beginning of each
     // message, so we don't need to worry about arbitrary message boundaries.
     std::string to_be_sent_;
 
-    // Wrapped descriptors and handles for transfer to untrusted code.
-    ScopedVector<nacl::DescWrapper> nacl_descs_;
-
     bool channel_closed_;
   };
 
   // This is the data that must only be accessed on the I/O thread (as defined
   // by TaskRunner). This struct just separates it so it's easier to see.
   struct IOThreadData {
     IOThreadData();
     ~IOThreadData();
 
     scoped_ptr<IPC::Channel> channel_;
   };
 
   virtual ~NaClIPCAdapter();
 
-  // Reads up to the given amount of data. Returns 0 if nothing is waiting.
-  int LockedReceive(char* output_buffer, size_t output_buffer_size);
+  // Returns 0 if nothing is waiting.
+  int LockedReceive(NaClImcTypedMsgHdr* msg);
 
   // Sends a message that we know has been completed to the Chrome process.
   bool SendCompleteMessage(const char* buffer, size_t buffer_len);
 
   // Clears the LockedData.to_be_sent_ structure in a way to make sure that
   // the memory is deleted. std::string can sometimes hold onto the buffer
   // for future use which we don't want.
   void ClearToBeSent();
 
   void ConnectChannelOnIOThread();
   void CloseChannelOnIOThread();
   void SendMessageOnIOThread(scoped_ptr<IPC::Message> message);
 
   // Saves the message to forward to NaCl. This method assumes that the caller
   // holds the lock for locked_data_.
-  void SaveMessage(const IPC::Message& message);
+  void SaveMessage(const IPC::Message& message,
+                   RewrittenMessage* rewritten_message);
 
   base::Lock lock_;
   base::ConditionVariable cond_var_;
 
   scoped_refptr<base::TaskRunner> task_runner_;
 
   // To be accessed inside of lock_ only.
   LockedData locked_data_;
 
   // To be accessed on the I/O thread (via task runner) only.
   IOThreadData io_thread_data_;
 
   DISALLOW_COPY_AND_ASSIGN(NaClIPCAdapter);
 };
 
 #endif  // CHROME_NACL_NACL_IPC_ADAPTER_H_