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(uint64_t,  // file_token_lo
+                              uint64_t,  // file_token_hi
+                              base::Callback<void(IPC::PlatformFileForTransit,
+                                                  base::FilePath)>)>

[dmichael (off chromium), 2014/08/27 20:49:14]

nit: Maybe a typedef for the internal one might make it more self-documenting?
ResolveFileTokenResponse or something

[teravest, 2014/09/04 22:13:30]

Done.

+      ResolveFileTokenCallback;
+
+  void set_resolve_file_token_callback(ResolveFileTokenCallback cb) {
+    resolve_file_token_cb_ = cb;
+  }

[dmichael (off chromium), 2014/08/27 20:49:14]

Somewhere in here it might make sense to document what this class will do with
the given callback and what it requires for the nested callback. E.g., when the
callback is invoked, it should respond later by calling the
ResolveFileTokenResponse callback via PostTask on the same thread. (vs some
other thread or calling while the outer callback is on the stack).

[teravest, 2014/09/04 22:13:30]

Done.

+
  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_