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#include "ipc/ipc_export.h"
11
12namespace IPC {
13namespace 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.
27class ChannelReader {
28 public:
29  explicit ChannelReader(Listener* listener);
30  virtual ~ChannelReader();
31
32  void set_listener(Listener* listener) { listener_ = listener; }
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
46  // Returns true if the given message is internal to the IPC implementation,
47  // like the "hello" message sent on channel set-up.
48  bool IsInternalMessage(const Message& m);
49
50  // Returns true if the given message is an Hello message
51  // sent on channel set-up.
52  bool IsHelloMessage(const Message& m);
53
54 protected:
55  enum ReadState { READ_SUCCEEDED, READ_FAILED, READ_PENDING };
56
57  Listener* listener() const { return listener_; }
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
84  // Handles internal messages, like the hello message sent on channel startup.
85  virtual void HandleInternalMessage(const Message& msg) = 0;
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
94  Listener* listener_;
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_
111