brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 1 | // Copyright (c) 2012 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_CHANNEL_READER_H_ |
| 6 | #define IPC_IPC_CHANNEL_READER_H_ |
| 7 | |
| 8 | #include "base/basictypes.h" |
| 9 | #include "ipc/ipc_channel.h" |
morrita@chromium.org | 15996aa | 2014-08-05 08:44:17 +0900 | [diff] [blame] | 10 | #include "ipc/ipc_export.h" |
brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 11 | |
| 12 | namespace IPC { |
| 13 | namespace internal { |
| 14 | |
| 15 | // This class provides common pipe reading functionality for the |
| 16 | // platform-specific IPC channel implementations. |
| 17 | // |
| 18 | // It does the common input buffer management and message dispatch, while the |
| 19 | // platform-specific parts provide the pipe management through a virtual |
| 20 | // interface implemented on a per-platform basis. |
| 21 | // |
| 22 | // Note that there is no "writer" corresponding to this because the code for |
| 23 | // writing to the channel is much simpler and has very little common |
| 24 | // functionality that would benefit from being factored out. If we add |
| 25 | // something like that in the future, it would be more appropriate to add it |
| 26 | // here (and rename appropriately) rather than writing a different class. |
| 27 | class ChannelReader { |
| 28 | public: |
brettw@chromium.org | f947ed0 | 2012-06-12 07:35:26 +0900 | [diff] [blame] | 29 | explicit ChannelReader(Listener* listener); |
brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 30 | virtual ~ChannelReader(); |
| 31 | |
brettw@chromium.org | f947ed0 | 2012-06-12 07:35:26 +0900 | [diff] [blame] | 32 | void set_listener(Listener* listener) { listener_ = listener; } |
brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 33 | |
| 34 | // Call to process messages received from the IPC connection and dispatch |
| 35 | // them. Returns false on channel error. True indicates that everything |
| 36 | // succeeded, although there may not have been any messages processed. |
| 37 | bool ProcessIncomingMessages(); |
| 38 | |
| 39 | // Handles asynchronously read data. |
| 40 | // |
| 41 | // Optionally call this after returning READ_PENDING from ReadData to |
| 42 | // indicate that buffer was filled with the given number of bytes of |
| 43 | // data. See ReadData for more. |
| 44 | bool AsyncReadComplete(int bytes_read); |
| 45 | |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 46 | // Returns true if the given message is internal to the IPC implementation, |
| 47 | // like the "hello" message sent on channel set-up. |
morrita@chromium.org | 15996aa | 2014-08-05 08:44:17 +0900 | [diff] [blame] | 48 | bool IsInternalMessage(const Message& m); |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 49 | |
| 50 | // Returns true if the given message is an Hello message |
| 51 | // sent on channel set-up. |
morrita@chromium.org | 15996aa | 2014-08-05 08:44:17 +0900 | [diff] [blame] | 52 | bool IsHelloMessage(const Message& m); |
brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 53 | |
| 54 | protected: |
| 55 | enum ReadState { READ_SUCCEEDED, READ_FAILED, READ_PENDING }; |
| 56 | |
brettw@chromium.org | f947ed0 | 2012-06-12 07:35:26 +0900 | [diff] [blame] | 57 | Listener* listener() const { return listener_; } |
brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 58 | |
| 59 | // Populates the given buffer with data from the pipe. |
| 60 | // |
| 61 | // Returns the state of the read. On READ_SUCCESS, the number of bytes |
| 62 | // read will be placed into |*bytes_read| (which can be less than the |
| 63 | // buffer size). On READ_FAILED, the channel will be closed. |
| 64 | // |
| 65 | // If the return value is READ_PENDING, it means that there was no data |
| 66 | // ready for reading. The implementation is then responsible for either |
| 67 | // calling AsyncReadComplete with the number of bytes read into the |
| 68 | // buffer, or ProcessIncomingMessages to try the read again (depending |
| 69 | // on whether the platform's async I/O is "try again" or "write |
| 70 | // asynchronously into your buffer"). |
| 71 | virtual ReadState ReadData(char* buffer, int buffer_len, int* bytes_read) = 0; |
| 72 | |
| 73 | // Loads the required file desciptors into the given message. Returns true |
| 74 | // on success. False means a fatal channel error. |
| 75 | // |
| 76 | // This will read from the input_fds_ and read more handles from the FD |
| 77 | // pipe if necessary. |
| 78 | virtual bool WillDispatchInputMessage(Message* msg) = 0; |
| 79 | |
| 80 | // Performs post-dispatch checks. Called when all input buffers are empty, |
| 81 | // though there could be more data ready to be read from the OS. |
| 82 | virtual bool DidEmptyInputBuffers() = 0; |
| 83 | |
hubbe@chromium.org | 683920d | 2013-10-15 09:07:00 +0900 | [diff] [blame] | 84 | // Handles internal messages, like the hello message sent on channel startup. |
| 85 | virtual void HandleInternalMessage(const Message& msg) = 0; |
brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 86 | |
| 87 | private: |
| 88 | // Takes the given data received from the IPC channel and dispatches any |
| 89 | // fully completed messages. |
| 90 | // |
| 91 | // Returns true on success. False means channel error. |
| 92 | bool DispatchInputData(const char* input_data, int input_data_len); |
| 93 | |
brettw@chromium.org | f947ed0 | 2012-06-12 07:35:26 +0900 | [diff] [blame] | 94 | Listener* listener_; |
brettw@chromium.org | 0e9d0a1 | 2012-03-08 21:30:28 +0900 | [diff] [blame] | 95 | |
| 96 | // We read from the pipe into this buffer. Managed by DispatchInputData, do |
| 97 | // not access directly outside that function. |
| 98 | char input_buf_[Channel::kReadBufferSize]; |
| 99 | |
| 100 | // Large messages that span multiple pipe buffers, get built-up using |
| 101 | // this buffer. |
| 102 | std::string input_overflow_buf_; |
| 103 | |
| 104 | DISALLOW_COPY_AND_ASSIGN(ChannelReader); |
| 105 | }; |
| 106 | |
| 107 | } // namespace internal |
| 108 | } // namespace IPC |
| 109 | |
| 110 | #endif // IPC_IPC_CHANNEL_READER_H_ |