SFI NaCl: Batch-open resource files

components/nacl/loader/nacl_ipc_adapter.h

 // 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.
 
 #ifndef CHROME_NACL_NACL_IPC_ADAPTER_H_
 #define CHROME_NACL_NACL_IPC_ADAPTER_H_
 
 #include <map>
 #include <queue>
 #include <string>
@@ skipping 62 matching lines @@
 #pragma pack(pop)
 
   typedef base::Callback<void(IPC::PlatformFileForTransit, base::FilePath)>
       ResolveFileTokenReplyCallback;
 
   typedef base::Callback<void(uint64_t,  // file_token_lo
                               uint64_t,  // file_token_hi
                               ResolveFileTokenReplyCallback)>
       ResolveFileTokenCallback;
 
+  typedef base::Callback<void(const IPC::Message&,
+                              IPC::PlatformFileForTransit,
+                              base::FilePath)> OpenResourceReplyCallback;
+
+  typedef base::Callback<bool(const IPC::Message&,
+                              const std::string&,  // key
+                              OpenResourceReplyCallback)> OpenResourceCallback;
+
   // Creates an adapter, using the thread associated with the given task
   // runner for posting messages. In normal use, the task runner will post to
   // the I/O thread of the process.
   //
   // If you use this constructor, you MUST call ConnectChannel after the
   // NaClIPCAdapter is constructed, or the NaClIPCAdapter's channel will not be
   // connected.
   //
   // |resolve_file_token_cb| is an optional callback to be invoked for
   // resolving file tokens received from the renderer. When the file token
   // is resolved, the ResolveFileTokenReplyCallback passed inside the
-  // ResolveFileTokenCallback will be invoked.
+  // ResolveFileTokenCallback will be invoked. |open_resource_cb| is also an
+  // optional callback to be invoked for intercepting open_resource IRT calls.
+  // |open_resource_cb| may immediately call a OpenResourceReplyCallback
+  // function to send a pre-opened resource descriptor to the untrusted side.
+  // OpenResourceCallback returns true when OpenResourceReplyCallback is called.
   NaClIPCAdapter(
       const IPC::ChannelHandle& handle,
       base::TaskRunner* runner,
-      ResolveFileTokenCallback resolve_file_token_cb);
+      ResolveFileTokenCallback resolve_file_token_cb,
+      OpenResourceCallback open_resource_cb);
 
   // Initializes with a given channel that's already created for testing
   // purposes. This function will take ownership of the given channel.
   NaClIPCAdapter(scoped_ptr<IPC::Channel> channel, base::TaskRunner* runner);
 
   // Connect the channel. This must be called after the constructor that accepts
   // an IPC::ChannelHandle, and causes the Channel to be connected on the IO
   // thread.
   void ConnectChannel();
 
@@ skipping 61 matching lines @@
 
     // When we send a synchronous message (from untrusted to trusted), we store
     // its type here, so that later we can associate the reply with its type
     // for scanning.
     typedef std::map<int, uint32> PendingSyncMsgMap;
     PendingSyncMsgMap pending_sync_msgs_;
   };
 
   ~NaClIPCAdapter() override;
 
-  void OnFileTokenResolved(const IPC::Message& orig_msg,
-                           IPC::PlatformFileForTransit ipc_fd,
-                           base::FilePath file_path);
+  void SaveOpenResourceMessage(const IPC::Message& orig_msg,
+                               IPC::PlatformFileForTransit ipc_fd,
+                               base::FilePath file_path);
 
   bool RewriteMessage(const IPC::Message& msg, uint32_t type);
 
   // 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,
                    RewrittenMessage* rewritten_message);
 
   base::Lock lock_;
   base::ConditionVariable cond_var_;
 
   scoped_refptr<base::TaskRunner> task_runner_;
 
   ResolveFileTokenCallback resolve_file_token_cb_;
+  OpenResourceCallback open_resource_cb_;
 
   // 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);
 };
 
 // Export TranslatePepperFileReadWriteOpenFlags for testing.
 int TranslatePepperFileReadWriteOpenFlagsForTesting(int32_t pp_open_flags);
 
 #endif  // CHROME_NACL_NACL_IPC_ADAPTER_H_