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