Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(427)

Unified Diff: ipc/ipc_channel_reader.h

Issue 9570001: Separate out the platform-independent parts of Channel reading. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 8 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « ipc/ipc_channel_posix.cc ('k') | ipc/ipc_channel_reader.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ipc/ipc_channel_reader.h
diff --git a/ipc/ipc_channel_reader.h b/ipc/ipc_channel_reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..192ca2dd97b70046023b8f51c25b5a8f918860b8
--- /dev/null
+++ b/ipc/ipc_channel_reader.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef IPC_IPC_CHANNEL_READER_H_
+#define IPC_IPC_CHANNEL_READER_H_
+
+#include "base/basictypes.h"
+#include "ipc/ipc_channel.h"
+
+namespace IPC {
+namespace internal {
+
+// This class provides common pipe reading functionality for the
+// platform-specific IPC channel implementations.
+//
+// It does the common input buffer management and message dispatch, while the
+// platform-specific parts provide the pipe management through a virtual
+// interface implemented on a per-platform basis.
+//
+// Note that there is no "writer" corresponding to this because the code for
+// writing to the channel is much simpler and has very little common
+// functionality that would benefit from being factored out. If we add
+// something like that in the future, it would be more appropriate to add it
+// here (and rename appropriately) rather than writing a different class.
+class ChannelReader {
+ public:
+ explicit ChannelReader(Channel::Listener* listener);
+ virtual ~ChannelReader();
+
+ void set_listener(Channel::Listener* listener) { listener_ = listener; }
+
+ // Call to process messages received from the IPC connection and dispatch
+ // them. Returns false on channel error. True indicates that everything
+ // succeeded, although there may not have been any messages processed.
+ bool ProcessIncomingMessages();
+
+ // Handles asynchronously read data.
+ //
+ // Optionally call this after returning READ_PENDING from ReadData to
+ // indicate that buffer was filled with the given number of bytes of
+ // data. See ReadData for more.
+ bool AsyncReadComplete(int bytes_read);
+
+ // Returns true if the given message is the "hello" message sent on channel
+ // set-up.
+ bool IsHelloMessage(const Message& m) const;
+
+ protected:
+ enum ReadState { READ_SUCCEEDED, READ_FAILED, READ_PENDING };
+
+ Channel::Listener* listener() const { return listener_; }
+
+ // Populates the given buffer with data from the pipe.
+ //
+ // Returns the state of the read. On READ_SUCCESS, the number of bytes
+ // read will be placed into |*bytes_read| (which can be less than the
+ // buffer size). On READ_FAILED, the channel will be closed.
+ //
+ // If the return value is READ_PENDING, it means that there was no data
+ // ready for reading. The implementation is then responsible for either
+ // calling AsyncReadComplete with the number of bytes read into the
+ // buffer, or ProcessIncomingMessages to try the read again (depending
+ // on whether the platform's async I/O is "try again" or "write
+ // asynchronously into your buffer").
+ virtual ReadState ReadData(char* buffer, int buffer_len, int* bytes_read) = 0;
+
+ // Loads the required file desciptors into the given message. Returns true
+ // on success. False means a fatal channel error.
+ //
+ // This will read from the input_fds_ and read more handles from the FD
+ // pipe if necessary.
+ virtual bool WillDispatchInputMessage(Message* msg) = 0;
+
+ // Performs post-dispatch checks. Called when all input buffers are empty,
+ // though there could be more data ready to be read from the OS.
+ virtual bool DidEmptyInputBuffers() = 0;
+
+ // Handles the first message sent over the pipe which contains setup info.
+ virtual void HandleHelloMessage(const Message& msg) = 0;
+
+ private:
+ // Takes the given data received from the IPC channel and dispatches any
+ // fully completed messages.
+ //
+ // Returns true on success. False means channel error.
+ bool DispatchInputData(const char* input_data, int input_data_len);
+
+ Channel::Listener* listener_;
+
+ // We read from the pipe into this buffer. Managed by DispatchInputData, do
+ // not access directly outside that function.
+ char input_buf_[Channel::kReadBufferSize];
+
+ // Large messages that span multiple pipe buffers, get built-up using
+ // this buffer.
+ std::string input_overflow_buf_;
+
+ DISALLOW_COPY_AND_ASSIGN(ChannelReader);
+};
+
+} // namespace internal
+} // namespace IPC
+
+#endif // IPC_IPC_CHANNEL_READER_H_
« no previous file with comments | « ipc/ipc_channel_posix.cc ('k') | ipc/ipc_channel_reader.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698