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

--1:000000000000
+:7c03461cafec
+// Copyright (c) 2006-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.
+#include "base/message_loop.h"
+#include "base/thread.h"
+#include "chrome/common/ipc_channel_proxy.h"
+#include "chrome/common/ipc_logging.h"
+#include "chrome/common/ipc_message_utils.h"
+namespace IPC {
+//-----------------------------------------------------------------------------
+ChannelProxy::Context::Context(Channel::Listener* listener,
+MessageFilter* filter,
+MessageLoop* ipc_message_loop)
+: listener_message_loop_(MessageLoop::current()),
+listener_(listener),
+ipc_message_loop_(ipc_message_loop),
+channel_(NULL),
+peer_pid_(0),
+channel_connected_called_(false) {
+if (filter)
+filters_.push_back(filter);
+}
+void ChannelProxy::Context::CreateChannel(const std::wstring& id,
+const Channel::Mode& mode) {
+DCHECK(channel_ == NULL);
+channel_id_ = id;
+channel_ = new Channel(id, mode, this);
+}
+bool ChannelProxy::Context::TryFilters(const Message& message) {
+#ifdef IPC_MESSAGE_LOG_ENABLED
+Logging* logger = Logging::current();
+if (logger->Enabled())
+logger->OnPreDispatchMessage(message);
+#endif
+for (size_t i = 0; i < filters_.size(); ++i) {
+if (filters_[i]->OnMessageReceived(message)) {
+#ifdef IPC_MESSAGE_LOG_ENABLED
+if (logger->Enabled())
+logger->OnPostDispatchMessage(message, channel_id_);
+#endif
+return true;
+}
+}
+return false;
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnMessageReceived(const Message& message) {
+// First give a chance to the filters to process this message.
+if (!TryFilters(message))
+OnMessageReceivedNoFilter(message);
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnMessageReceivedNoFilter(const Message& message) {
+// NOTE: This code relies on the listener's message loop not going away while
+// this thread is active.  That should be a reasonable assumption, but it
+// feels risky.  We may want to invent some more indirect way of referring to
+// a MessageLoop if this becomes a problem.
+listener_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+this, &Context::OnDispatchMessage, message));
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnChannelConnected(int32_t peer_pid) {
+peer_pid_ = peer_pid;
+for (size_t i = 0; i < filters_.size(); ++i)
+filters_[i]->OnChannelConnected(peer_pid);
+// See above comment about using listener_message_loop_ here.
+listener_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+this, &Context::OnDispatchConnected));
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnChannelError() {
+for (size_t i = 0; i < filters_.size(); ++i)
+filters_[i]->OnChannelError();
+// See above comment about using listener_message_loop_ here.
+listener_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+this, &Context::OnDispatchError));
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnChannelOpened() {
+DCHECK(channel_ != NULL);
+// Assume a reference to ourselves on behalf of this thread.  This reference
+// will be released when we are closed.
+AddRef();
+if (!channel_->Connect()) {
+OnChannelError();
+return;
+}
+for (size_t i = 0; i < filters_.size(); ++i)
+filters_[i]->OnFilterAdded(channel_);
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnChannelClosed() {
+// It's okay for IPC::ChannelProxy::Close to be called more than once, which
+// would result in this branch being taken.
+if (!channel_)
+return;
+for (size_t i = 0; i < filters_.size(); ++i) {
+filters_[i]->OnChannelClosing();
+filters_[i]->OnFilterRemoved();
+}
+// We don't need the filters anymore.
+filters_.clear();
+delete channel_;
+channel_ = NULL;
+// Balance with the reference taken during startup.  This may result in
+// self-destruction.
+Release();
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnSendMessage(Message* message) {
+if (!channel_->Send(message))
+OnChannelError();
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnAddFilter(MessageFilter* filter) {
+filters_.push_back(filter);
+// If the channel has already been created, then we need to send this message
+// so that the filter gets access to the Channel.
+if (channel_)
+filter->OnFilterAdded(channel_);
+// Balances the AddRef in ChannelProxy::AddFilter.
+filter->Release();
+}
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::OnRemoveFilter(MessageFilter* filter) {
+for (size_t i = 0; i < filters_.size(); ++i) {
+if (filters_[i].get() == filter) {
+filter->OnFilterRemoved();
+filters_.erase(filters_.begin() + i);
+return;
+}
+}
+NOTREACHED() << "filter to be removed not found";
+}
+// Called on the listener's thread
+void ChannelProxy::Context::OnDispatchMessage(const Message& message) {
+if (!listener_)
+return;
+OnDispatchConnected();
+#ifdef IPC_MESSAGE_LOG_ENABLED
+Logging* logger = Logging::current();
+if (message.type() == IPC_LOGGING_ID) {
+logger->OnReceivedLoggingMessage(message);
+return;
+}
+if (logger->Enabled())
+logger->OnPreDispatchMessage(message);
+#endif
+listener_->OnMessageReceived(message);
+#ifdef IPC_MESSAGE_LOG_ENABLED
+if (logger->Enabled())
+logger->OnPostDispatchMessage(message, channel_id_);
+#endif
+}
+// Called on the listener's thread
+void ChannelProxy::Context::OnDispatchConnected() {
+if (channel_connected_called_)
+return;
+channel_connected_called_ = true;
+if (listener_)
+listener_->OnChannelConnected(peer_pid_);
+}
+// Called on the listener's thread
+void ChannelProxy::Context::OnDispatchError() {
+if (listener_)
+listener_->OnChannelError();
+}
+//-----------------------------------------------------------------------------
+ChannelProxy::ChannelProxy(const std::wstring& channel_id, Channel::Mode mode,
+Channel::Listener* listener, MessageFilter* filter,
+MessageLoop* ipc_thread)
+: context_(new Context(listener, filter, ipc_thread)) {
+Init(channel_id, mode, ipc_thread, true);
+}
+ChannelProxy::ChannelProxy(const std::wstring& channel_id, Channel::Mode mode,
+MessageLoop* ipc_thread, Context* context,
+bool create_pipe_now)
+: context_(context) {
+Init(channel_id, mode, ipc_thread, create_pipe_now);
+}
+void ChannelProxy::Init(const std::wstring& channel_id, Channel::Mode mode,
+MessageLoop* ipc_thread_loop, bool create_pipe_now) {
+if (create_pipe_now) {
+// Create the channel immediately.  This effectively sets up the
+// low-level pipe so that the client can connect.  Without creating
+// the pipe immediately, it is possible for a listener to attempt
+// to connect and get an error since the pipe doesn't exist yet.
+context_->CreateChannel(channel_id, mode);
+} else {
+#if defined(OS_POSIX)
+// TODO(playmobil): On POSIX, IPC::Channel uses a socketpair(), one side of
+// which needs to be mapped into the child process' address space.
+// To know the value of the client side FD we need to have already
+// created a socketpair which currently occurs in IPC::Channel's
+// constructor.
+// If we lazilly construct the IPC::Channel then the caller has no way
+// of knowing the FD #.
+//
+// We can solve this either by having the Channel's creation launch the
+// subprocess itself or by creating the socketpair() externally.
+NOTIMPLEMENTED();
+#endif  // defined(OS_POSIX)
+context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+context_.get(), &Context::CreateChannel, channel_id, mode));
+}
+// complete initialization on the background thread
+context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+context_.get(), &Context::OnChannelOpened));
+}
+void ChannelProxy::Close() {
+// Clear the backpointer to the listener so that any pending calls to
+// Context::OnDispatchMessage or OnDispatchError will be ignored.  It is
+// possible that the channel could be closed while it is receiving messages!
+context_->Clear();
+if (context_->ipc_message_loop()) {
+context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+context_.get(), &Context::OnChannelClosed));
+}
+}
+bool ChannelProxy::Send(Message* message) {
+#ifdef IPC_MESSAGE_LOG_ENABLED
+Logging::current()->OnSendMessage(message, context_->channel_id());
+#endif
+context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+context_.get(), &Context::OnSendMessage, message));
+return true;
+}
+void ChannelProxy::AddFilter(MessageFilter* filter) {
+// We want to addref the filter to prevent it from
+// being destroyed before the OnAddFilter call is invoked.
+filter->AddRef();
+context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+context_.get(), &Context::OnAddFilter, filter));
+}
+void ChannelProxy::RemoveFilter(MessageFilter* filter) {
+context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+context_.get(), &Context::OnRemoveFilter, filter));
+}
+#if defined(OS_POSIX)
+// See the TODO regarding lazy initialization of the channel in
+// ChannelProxy::Init().
+// We assume that IPC::Channel::GetClientFileDescriptorMapping() is thread-safe.
+void ChannelProxy::GetClientFileDescriptorMapping(int *src_fd,
+int *dest_fd) const {
+Channel *channel = context_.get()->channel_;
+DCHECK(channel); // Channel must have been created first.
+channel->GetClientFileDescriptorMapping(src_fd, dest_fd);
+}
+#endif
+//-----------------------------------------------------------------------------
+}  // namespace IPC

The Tor Browser / file comparison

comparison: ipc/chromium/src/chrome/common/ipc_channel_proxy.cc

ipc/chromium/src/chrome/common/ipc_channel_proxy.cc