/* * Copyright 2009, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following disclaimer * in the documentation and/or other materials provided with the * distribution. * * Neither the name of Google Inc. nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef O3D_COMMAND_BUFFER_COMMON_CROSS_RPC_IMC_H_ #define O3D_COMMAND_BUFFER_COMMON_CROSS_RPC_IMC_H_ #include "third_party/native_client/googleclient/native_client/src/shared/imc/nacl_imc.h" #include "base/scoped_ptr.h" #include "command_buffer/common/cross/rpc.h" namespace o3d { namespace command_buffer { class IMCSender : public RPCSendInterface { public: explicit IMCSender(nacl::HtpHandle handle) : handle_(handle) {} virtual ~IMCSender() {} // Sends a call to the server thread. This call will be dispatched by the // server thread to the RPC implementation. This call will block until the // call is processed and the return value is sent back. // Parameters: // message_id: the RPC message ID. // data: the RPC message payload. // size: the size of the data. // handles: an array of RPC handles to transmit // handle_count: the number of RPC handles in the array // Returns: // the return value of the RPC call. virtual RPCImplInterface::ReturnValue SendCall(int message_id, const void * data, size_t size, RPCHandle const *handles, size_t handle_count); private: nacl::HtpHandle handle_; }; class IMCMessageProcessor : public RPCProcessInterface { public: IMCMessageProcessor(nacl::HtpHandle handle, RPCImplInterface *impl) : handle_(handle), impl_(impl), has_message_(false), incoming_message_id_(0), incoming_message_size_(0), incoming_message_handles_(0), data_size_(0), handle_count_(0) {} virtual ~IMCMessageProcessor() {} // Processes one message, blocking if necessary until a message is available // or the server is killed. This will dispatch the received message to the // RPC implementation, and send back a response message with the return // value to the client. // Returns: // false if the server was killed. virtual bool ProcessMessage(); // Checks whether a message is available for processing - allowing to test if // ProcessMessage will block. // Returns: // true if a message is available. virtual bool HasMessage(); private: bool GetMessageIDSize(bool wait); nacl::HtpHandle handle_; RPCImplInterface *impl_; bool has_message_; int incoming_message_id_; size_t incoming_message_size_; size_t incoming_message_handles_; size_t data_size_; scoped_array<char> data_; size_t handle_count_; scoped_array<RPCHandle> handles_; }; } // namespace command_buffer } // namespace o3d #endif // O3D_COMMAND_BUFFER_COMMON_CROSS_RPC_IMC_H_