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

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

ipc/chromium/src/chrome/common/child_process_host.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) 2009 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 "chrome/common/child_process_host.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/singleton.h"
 #include "base/waitable_event.h"
 #include "mozilla/ipc/ProcessChild.h"
 #include "mozilla/ipc/BrowserProcessSubThread.h"
 #include "mozilla/ipc/Transport.h"
 typedef mozilla::ipc::BrowserProcessSubThread ChromeThread;
 #include "chrome/common/ipc_logging.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/process_watcher.h"
 #include "chrome/common/result_codes.h"
 using mozilla::ipc::FileDescriptor;
 namespace {
 typedef std::list<ChildProcessHost*> ChildProcessList;
 // The NotificationTask is used to notify about plugin process connection/
 // disconnection. It is needed because the notifications in the
 // NotificationService must happen in the main thread.
 class ChildNotificationTask : public Task {
  public:
   ChildNotificationTask(
       NotificationType notification_type, ChildProcessInfo* info)
       : notification_type_(notification_type), info_(*info) { }
   virtual void Run() {
     NotificationService::current()->
         Notify(notification_type_, NotificationService::AllSources(),
                Details<ChildProcessInfo>(&info_));
   }
  private:
   NotificationType notification_type_;
   ChildProcessInfo info_;
 };
 }  // namespace
 ChildProcessHost::ChildProcessHost(ProcessType type)
     :
       ChildProcessInfo(type),
       ALLOW_THIS_IN_INITIALIZER_LIST(listener_(this)),
       opening_channel_(false),
       process_event_(NULL) {
   Singleton<ChildProcessList>::get()->push_back(this);
 }
 ChildProcessHost::~ChildProcessHost() {
   Singleton<ChildProcessList>::get()->remove(this);
   if (handle()) {
     watcher_.StopWatching();
     ProcessWatcher::EnsureProcessTerminated(handle());
 #if defined(OS_WIN)
     // Above call took ownership, so don't want WaitableEvent to assert because
     // the handle isn't valid anymore.
     process_event_->Release();
 #endif
   }
 }
 bool ChildProcessHost::CreateChannel() {
   channel_id_ = GenerateRandomChannelID(this);
   channel_.reset(new IPC::Channel(
       channel_id_, IPC::Channel::MODE_SERVER, &listener_));
   if (!channel_->Connect())
     return false;
   opening_channel_ = true;
   return true;
 }
 bool ChildProcessHost::CreateChannel(FileDescriptor& aFileDescriptor) {
   if (channel_.get()) {
     channel_->Close();
   }
   channel_.reset(mozilla::ipc::OpenDescriptor(
       aFileDescriptor, IPC::Channel::MODE_SERVER));
   channel_->set_listener(&listener_);
   if (!channel_->Connect()) {
     return false;
   }
   opening_channel_ = true;
   return true;
 }
 void ChildProcessHost::SetHandle(base::ProcessHandle process) {
 #if defined(OS_WIN)
   process_event_.reset(new base::WaitableEvent(process));
   DCHECK(!handle());
   set_handle(process);
   watcher_.StartWatching(process_event_.get(), this);
 #endif
 }
 void ChildProcessHost::InstanceCreated() {
   Notify(NotificationType::CHILD_INSTANCE_CREATED);
 }
 bool ChildProcessHost::Send(IPC::Message* msg) {
   if (!channel_.get()) {
     delete msg;
     return false;
   }
   return channel_->Send(msg);
 }
 void ChildProcessHost::Notify(NotificationType type) {
   MessageLoop* loop = ChromeThread::GetMessageLoop(ChromeThread::IO);
   if (!loop)
       loop = mozilla::ipc::ProcessChild::message_loop();
   if (!loop)
       loop = MessageLoop::current();
   loop->PostTask(
       FROM_HERE, new ChildNotificationTask(type, this));
 }
 void ChildProcessHost::OnWaitableEventSignaled(base::WaitableEvent *event) {
 #if defined(OS_WIN)
   HANDLE object = event->handle();
   DCHECK(handle());
   DCHECK_EQ(object, handle());
   bool did_crash = base::DidProcessCrash(NULL, object);
   if (did_crash) {
     // Report that this child process crashed.
     Notify(NotificationType::CHILD_PROCESS_CRASHED);
   }
   // Notify in the main loop of the disconnection.
   Notify(NotificationType::CHILD_PROCESS_HOST_DISCONNECTED);
 #endif
 }
 ChildProcessHost::ListenerHook::ListenerHook(ChildProcessHost* host)
     : host_(host) {
 }
 void ChildProcessHost::ListenerHook::OnMessageReceived(
     const IPC::Message& msg) {
 #ifdef IPC_MESSAGE_LOG_ENABLED
   IPC::Logging* logger = IPC::Logging::current();
   if (msg.type() == IPC_LOGGING_ID) {
     logger->OnReceivedLoggingMessage(msg);
     return;
   }
   if (logger->Enabled())
     logger->OnPreDispatchMessage(msg);
 #endif
   bool msg_is_ok = true;
   bool handled = false;
   if (!handled) {
       host_->OnMessageReceived(msg);
   }
   if (!msg_is_ok)
     base::KillProcess(host_->handle(), ResultCodes::KILLED_BAD_MESSAGE, false);
 #ifdef IPC_MESSAGE_LOG_ENABLED
   if (logger->Enabled())
     logger->OnPostDispatchMessage(msg, host_->channel_id_);
 #endif
 }
 void ChildProcessHost::ListenerHook::OnChannelConnected(int32_t peer_pid) {
   host_->opening_channel_ = false;
   host_->OnChannelConnected(peer_pid);
   // Notify in the main loop of the connection.
   host_->Notify(NotificationType::CHILD_PROCESS_HOST_CONNECTED);
 }
 void ChildProcessHost::ListenerHook::OnChannelError() {
   host_->opening_channel_ = false;
   host_->OnChannelError();
 }
 void ChildProcessHost::ListenerHook::GetQueuedMessages(std::queue<IPC::Message>& queue) {
   host_->GetQueuedMessages(queue);
 }
 ChildProcessHost::Iterator::Iterator() : all_(true) {
   iterator_ = Singleton<ChildProcessList>::get()->begin();
 }
 ChildProcessHost::Iterator::Iterator(ProcessType type)
     : all_(false), type_(type) {
   iterator_ = Singleton<ChildProcessList>::get()->begin();
   if (!Done() && (*iterator_)->type() != type_)
     ++(*this);
 }
 ChildProcessHost* ChildProcessHost::Iterator::operator++() {
   do {
     ++iterator_;
     if (Done())
       break;
     if (!all_ && (*iterator_)->type() != type_)
       continue;
     return *iterator_;
   } while (true);
   return NULL;
 }
 bool ChildProcessHost::Iterator::Done() {
   return iterator_ == Singleton<ChildProcessList>::get()->end();
 }

The Tor Browser / annotate

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

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