Index: chrome/nacl/nacl_ipc_adapter.h |
diff --git a/chrome/nacl/nacl_ipc_adapter.h b/chrome/nacl/nacl_ipc_adapter.h |
deleted file mode 100644 |
index c7569e6002422ca789e3db20d02c3883d2e146c4..0000000000000000000000000000000000000000 |
--- a/chrome/nacl/nacl_ipc_adapter.h |
+++ /dev/null |
@@ -1,192 +0,0 @@ |
-// 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 <map> |
-#include <queue> |
-#include <string> |
-#include <vector> |
- |
-#include "base/basictypes.h" |
-#include "base/memory/ref_counted.h" |
-#include "base/memory/scoped_ptr.h" |
-#include "base/memory/scoped_vector.h" |
-#include "base/pickle.h" |
-#include "base/shared_memory.h" |
-#include "base/synchronization/condition_variable.h" |
-#include "base/synchronization/lock.h" |
-#include "base/task_runner.h" |
-#include "ipc/ipc_listener.h" |
-#include "ppapi/c/pp_stdint.h" |
-#include "ppapi/proxy/handle_converter.h" |
- |
-struct NaClDesc; |
-struct NaClImcTypedMsgHdr; |
-struct PP_Size; |
- |
-namespace IPC { |
-class Channel; |
-struct ChannelHandle; |
-} |
- |
-namespace ppapi { |
-class HostResource; |
-} |
- |
-// Adapts a Chrome IPC channel to an IPC channel that we expose to Native |
-// Client. This provides a mapping in both directions, so when IPC messages |
-// come in from another process, we rewrite them and allow them to be received |
-// via a recvmsg-like interface in the NaCl code. When NaCl code calls sendmsg, |
-// we implement that as sending IPC messages on the channel. |
-// |
-// This object also provides the necessary logic for rewriting IPC messages. |
-// NaCl code is platform-independent and runs in a Posix-like enviroment, but |
-// some formatting in the message and the way handles are transferred varies |
-// by platform. This class bridges that gap to provide what looks like a |
-// normal platform-specific IPC implementation to Chrome, and a Posix-like |
-// version on every platform to NaCl. |
-// |
-// This object must be threadsafe since the nacl environment determines which |
-// thread every function is called on. |
-class NaClIPCAdapter : public base::RefCountedThreadSafe<NaClIPCAdapter>, |
- public IPC::Listener { |
- public: |
- // Chrome's IPC message format varies by platform, NaCl's does not. In |
- // particular, the header has some extra fields on Posix platforms. Since |
- // NaCl is a Posix environment, it gets that version of the header. This |
- // header is duplicated here so we have a cross-platform definition of the |
- // header we're exposing to NaCl. |
-#pragma pack(push, 4) |
- struct NaClMessageHeader : public Pickle::Header { |
- int32 routing; |
- uint32 type; |
- uint32 flags; |
- uint16 num_fds; |
- uint16 pad; |
- }; |
-#pragma pack(pop) |
- |
- // 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. |
- NaClIPCAdapter(const IPC::ChannelHandle& handle, base::TaskRunner* runner); |
- |
- // 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(); |
- |
- // Implementation of sendmsg. Returns the number of bytes written or -1 on |
- // failure. |
- int Send(const NaClImcTypedMsgHdr* msg); |
- |
- // Implementation of recvmsg. Returns the number of bytes read or -1 on |
- // failure. This will block until there's an error or there is data to |
- // read. |
- int BlockingReceive(NaClImcTypedMsgHdr* msg); |
- |
- // Closes the IPC channel. |
- void CloseChannel(); |
- |
- // Make a NaClDesc that refers to this NaClIPCAdapter. Note that the returned |
- // NaClDesc is reference-counted, and a reference is returned. |
- NaClDesc* MakeNaClDesc(); |
- |
-#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; |
- |
- 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(); |
- |
- // Messages that we have read off of the Chrome IPC channel that are waiting |
- // to be received by the plugin. |
- std::queue< scoped_refptr<RewrittenMessage> > to_be_received_; |
- |
- ppapi::proxy::HandleConverter handle_converter_; |
- |
- // 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_; |
- |
- 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(); |
- |
- // 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_; |
- |
- // 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_ |