OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #ifndef IPC_IPC_MESSAGE_PIPE_READER_H_ |
| 6 #define IPC_IPC_MESSAGE_PIPE_READER_H_ |
| 7 |
| 8 #include <vector> |
| 9 |
| 10 #include "base/memory/scoped_ptr.h" |
| 11 #include "mojo/public/c/environment/async_waiter.h" |
| 12 #include "mojo/public/cpp/system/core.h" |
| 13 |
| 14 namespace IPC { |
| 15 namespace internal { |
| 16 |
| 17 // A helper class to handle bytestream directly over mojo::MessagePipe |
| 18 // in template-method pattern. MessagePipeReader manages the lifetime |
| 19 // of given MessagePipe and participates the event loop, and |
| 20 // read the stream and call the client when it is ready. |
| 21 // |
| 22 // Each client has to: |
| 23 // |
| 24 // * Provide a subclass implemenation of a specific use of a MessagePipe |
| 25 // and implement callbacks. |
| 26 // * Create the subclass instance with a MessagePipeHandle. |
| 27 // The constructor automatically start listening on the pipe. |
| 28 // |
| 29 // MessageReader has to be used in IO thread. It isn't thread-safe. |
| 30 // |
| 31 class MessagePipeReader { |
| 32 public: |
| 33 // Delay the object deletion using the current message loop. |
| 34 // This is intended to used by MessagePipeReader owners. |
| 35 class DelayedDeleter { |
| 36 public: |
| 37 typedef base::DefaultDeleter<MessagePipeReader> DefaultType; |
| 38 |
| 39 static void DeleteNow(MessagePipeReader* ptr) { delete ptr; } |
| 40 |
| 41 DelayedDeleter() {} |
| 42 DelayedDeleter(const DefaultType&) {} |
| 43 DelayedDeleter& operator=(const DefaultType&) { return *this; } |
| 44 |
| 45 void operator()(MessagePipeReader* ptr) const; |
| 46 }; |
| 47 |
| 48 explicit MessagePipeReader(mojo::ScopedMessagePipeHandle handle); |
| 49 virtual ~MessagePipeReader(); |
| 50 |
| 51 MojoHandle handle() const { return pipe_.get().value(); } |
| 52 |
| 53 // Returns received bytes. |
| 54 const std::vector<char>& data_buffer() const { |
| 55 return data_buffer_; |
| 56 } |
| 57 |
| 58 // Delegate received handles ownership. The subclass should take the |
| 59 // ownership over in its OnMessageReceived(). They will leak otherwise. |
| 60 void TakeHandleBuffer(std::vector<MojoHandle>* handle_buffer) { |
| 61 handle_buffer_.swap(*handle_buffer); |
| 62 } |
| 63 |
| 64 // Close and destroy the MessagePipe. |
| 65 void Close(); |
| 66 // Close the mesage pipe with notifying the client with the error. |
| 67 void CloseWithError(MojoResult error); |
| 68 // Return true if the MessagePipe is alive. |
| 69 bool IsValid() { return pipe_.is_valid(); } |
| 70 |
| 71 // |
| 72 // The client have to implment these callback to get the readiness |
| 73 // event from the reader |
| 74 // |
| 75 virtual void OnMessageReceived() = 0; |
| 76 virtual void OnPipeClosed() = 0; |
| 77 virtual void OnPipeError(MojoResult error) = 0; |
| 78 |
| 79 private: |
| 80 static void InvokePipeIsReady(void* closure, MojoResult result); |
| 81 |
| 82 MojoResult ReadMessageBytes(); |
| 83 void PipeIsReady(MojoResult wait_result); |
| 84 void StartWaiting(); |
| 85 void StopWaiting(); |
| 86 |
| 87 std::vector<char> data_buffer_; |
| 88 std::vector<MojoHandle> handle_buffer_; |
| 89 MojoAsyncWaitID pipe_wait_id_; |
| 90 mojo::ScopedMessagePipeHandle pipe_; |
| 91 |
| 92 DISALLOW_COPY_AND_ASSIGN(MessagePipeReader); |
| 93 }; |
| 94 |
| 95 } // namespace internal |
| 96 } // namespace IPC |
| 97 |
| 98 #endif // IPC_IPC_MESSAGE_PIPE_READER_H_ |
OLD | NEW |