The Tor Browser: comparison ipc/chromium/src/chrome/common/ipc_channel

--1:000000000000
+:977816683572
+// Copyright (c) 2008 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 CHROME_COMMON_IPC_CHANNEL_POSIX_H_
+#define CHROME_COMMON_IPC_CHANNEL_POSIX_H_
+#include "chrome/common/ipc_channel.h"
+#include <sys/socket.h>  // for CMSG macros
+#include <queue>
+#include <string>
+#include <vector>
+#include <list>
+#include "base/message_loop.h"
+#include "chrome/common/file_descriptor_set_posix.h"
+namespace IPC {
+// An implementation of ChannelImpl for POSIX systems that works via
+// socketpairs.  See the .cc file for an overview of the implementation.
+class Channel::ChannelImpl : public MessageLoopForIO::Watcher {
+public:
+// Mirror methods of Channel, see ipc_channel.h for description.
+ChannelImpl(const std::wstring& channel_id, Mode mode, Listener* listener);
+ChannelImpl(int fd, Mode mode, Listener* listener);
+~ChannelImpl() { Close(); }
+bool Connect();
+void Close();
+Listener* set_listener(Listener* listener) {
+Listener* old = listener_;
+listener_ = listener;
+return old;
+}
+bool Send(Message* message);
+void GetClientFileDescriptorMapping(int *src_fd, int *dest_fd) const;
+void ResetFileDescriptor(int fd);
+int GetFileDescriptor() const {
+return pipe_;
+}
+void CloseClientFileDescriptor();
+// See the comment in ipc_channel.h for info on Unsound_IsClosed() and
+// Unsound_NumQueuedMessages().
+bool Unsound_IsClosed() const;
+uint32_t Unsound_NumQueuedMessages() const;
+private:
+void Init(Mode mode, Listener* listener);
+bool CreatePipe(const std::wstring& channel_id, Mode mode);
+bool EnqueueHelloMessage();
+bool ProcessIncomingMessages();
+bool ProcessOutgoingMessages();
+// MessageLoopForIO::Watcher implementation.
+virtual void OnFileCanReadWithoutBlocking(int fd);
+virtual void OnFileCanWriteWithoutBlocking(int fd);
+#if defined(OS_MACOSX)
+void CloseDescriptors(uint32_t pending_fd_id);
+#endif
+void OutputQueuePush(Message* msg);
+void OutputQueuePop();
+Mode mode_;
+// After accepting one client connection on our server socket we want to
+// stop listening.
+MessageLoopForIO::FileDescriptorWatcher server_listen_connection_watcher_;
+MessageLoopForIO::FileDescriptorWatcher read_watcher_;
+MessageLoopForIO::FileDescriptorWatcher write_watcher_;
+// Indicates whether we're currently blocked waiting for a write to complete.
+bool is_blocked_on_write_;
+// If sending a message blocks then we use this variable
+// to keep track of where we are.
+size_t message_send_bytes_written_;
+// If the kTestingChannelID flag is specified, we use a FIFO instead of
+// a socketpair().
+bool uses_fifo_;
+int server_listen_pipe_;
+int pipe_;
+int client_pipe_;  // The client end of our socketpair().
+// The "name" of our pipe.  On Windows this is the global identifier for
+// the pipe.  On POSIX it's used as a key in a local map of file descriptors.
+std::string pipe_name_;
+Listener* listener_;
+// Messages to be sent are queued here.
+std::queue<Message*> output_queue_;
+// We read from the pipe into this buffer
+char input_buf_[Channel::kReadBufferSize];
+enum {
+// We assume a worst case: kReadBufferSize bytes of messages, where each
+// message has no payload and a full complement of descriptors.
+MAX_READ_FDS = (Channel::kReadBufferSize / sizeof(IPC::Message::Header)) *
+FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE
+};
+// This is a control message buffer large enough to hold kMaxReadFDs
+#if defined(OS_MACOSX) || defined(OS_NETBSD)
+// TODO(agl): OSX appears to have non-constant CMSG macros!
+char input_cmsg_buf_[1024];
+#else
+char input_cmsg_buf_[CMSG_SPACE(sizeof(int) * MAX_READ_FDS)];
+#endif
+// Large messages that span multiple pipe buffers, get built-up using
+// this buffer.
+std::string input_overflow_buf_;
+std::vector<int> input_overflow_fds_;
+// In server-mode, we have to wait for the client to connect before we
+// can begin reading.  We make use of the input_state_ when performing
+// the connect operation in overlapped mode.
+bool waiting_connect_;
+// This flag is set when processing incoming messages.  It is used to
+// avoid recursing through ProcessIncomingMessages, which could cause
+// problems.  TODO(darin): make this unnecessary
+bool processing_incoming_;
+// This flag is set after we've closed the channel.
+bool closed_;
+#if defined(OS_MACOSX)
+struct PendingDescriptors {
+uint32_t id;
+scoped_refptr<FileDescriptorSet> fds;
+PendingDescriptors() : id(0) { }
+PendingDescriptors(uint32_t id, FileDescriptorSet *fds)
+: id(id),
+fds(fds)
+{ }
+};
+std::list<PendingDescriptors> pending_fds_;
+// A generation ID for RECEIVED_FD messages.
+uint32_t last_pending_fd_id_;
+#endif
+// This variable is updated so it matches output_queue_.size(), except we can
+// read output_queue_length_ from any thread (if we're OK getting an
+// occasional out-of-date or bogus value).  We use output_queue_length_ to
+// implement Unsound_NumQueuedMessages.
+size_t output_queue_length_;
+ScopedRunnableMethodFactory<ChannelImpl> factory_;
+DISALLOW_COPY_AND_ASSIGN(ChannelImpl);
+};
+}  // namespace IPC
+#endif  // CHROME_COMMON_IPC_CHANNEL_POSIX_H_

The Tor Browser / file comparison

comparison: ipc/chromium/src/chrome/common/ipc_channel_posix.h

ipc/chromium/src/chrome/common/ipc_channel_posix.h