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

ipc/chromium/src/chrome/common/ipc_channel_proxy.cc@6474c204b198 (annotated)

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

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // 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 / annotate

ipc/chromium/src/chrome/common/ipc_channel_proxy.cc@6474c204b198 (annotated)

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