Pepper: Stop using SRPC for irt_open_resource().

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>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/pickle.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner.h"
 #include "ipc/ipc_listener.h"
+#include "ipc/ipc_platform_file.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/proxy/nacl_message_scanner.h"
 
 struct NaClDesc;
 struct NaClImcTypedMsgHdr;
 struct PP_Size;
 
 namespace IPC {
 class Channel;
 struct ChannelHandle;
@@ skipping 72 matching lines @@
 
 #if defined(OS_POSIX)
   int TakeClientFileDescriptor();
 #endif
 
   // Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
+  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;
+
+  // Sets a callback to be invoked for resolving file tokens received from the
+  // renderer. When the file token is resolvded, the

[Mark Seaborn, 2014/09/05 15:43:46]

"resolved"

[teravest, 2014/09/06 02:25:15]

Done.

+  // ResolveFileTokenReplyCallback passed inside the ResolveFileTokenCallback
+  // will be invoked.
+  void set_resolve_file_token_callback(ResolveFileTokenCallback cb) {
+    resolve_file_token_cb_ = cb;
+  }
+
  private:
   friend class base::RefCountedThreadSafe<NaClIPCAdapter>;
 
   class RewrittenMessage;
 
   // This is the data that must only be accessed inside the lock. This struct
   // just separates it so it's easier to see.
   struct LockedData {
     LockedData();
     ~LockedData();
@@ skipping 26 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_;
   };
 
   virtual ~NaClIPCAdapter();
 
+  void OnFileTokenResolved(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_;
+  scoped_refptr<base::TaskRunner> main_task_runner_;
+
+  ResolveFileTokenCallback resolve_file_token_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_