Fix crash with IPC_MESSAGE_LOG_ENABLED when running in single-process mode or in-process-gpu. The …

content/child/child_thread.cc

 // 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.
 
 #include "content/child/child_thread.h"
 
 #include "base/allocator/allocator_extension.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 115 matching lines @@
 
 void QuitMainThreadMessageLoop() {
   base::MessageLoop::current()->Quit();
 }
 
 #endif
 
 }  // namespace
 
 ChildThread::ChildThread()
-    : channel_connected_factory_(this) {
+    : channel_connected_factory_(this),
+      in_browser_process_(false) {
   channel_name_ = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kProcessChannelID);
   Init();
 }
 
 ChildThread::ChildThread(const std::string& channel_name)
     : channel_name_(channel_name),
-      channel_connected_factory_(this) {
+      channel_connected_factory_(this),
+      in_browser_process_(true) {
   Init();
 }
 
 void ChildThread::Init() {
   g_lazy_tls.Pointer()->Set(this);
   on_channel_error_called_ = false;
   message_loop_ = base::MessageLoop::current();
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // We must make sure to instantiate the IPC Logger *before* we create the
   // channel, otherwise we can get a callback on the IO thread which creates
   // the logger, and the logger does not like being created on the IO thread.
   IPC::Logging::GetInstance();
 #endif
   channel_.reset(
       new IPC::SyncChannel(channel_name_,
                            IPC::Channel::MODE_CLIENT,
                            this,
                            ChildProcess::current()->io_message_loop_proxy(),
                            true,
                            ChildProcess::current()->GetShutDownEvent()));
 #ifdef IPC_MESSAGE_LOG_ENABLED
-  IPC::Logging::GetInstance()->SetIPCSender(this);
+  if (!in_browser_process_)
+    IPC::Logging::GetInstance()->SetIPCSender(this);
 #endif
 
   sync_message_filter_ =
       new IPC::SyncMessageFilter(ChildProcess::current()->GetShutDownEvent());
   thread_safe_sender_ = new ThreadSafeSender(
       base::MessageLoopProxy::current().get(), sync_message_filter_.get());
 
   resource_dispatcher_.reset(new ResourceDispatcher(this));
   socket_stream_dispatcher_.reset(new SocketStreamDispatcher());
   websocket_dispatcher_.reset(new WebSocketDispatcher);
@@ skipping 100 matching lines @@
 void ChildThread::OnChannelConnected(int32 peer_pid) {
   channel_connected_factory_.InvalidateWeakPtrs();
 }
 
 void ChildThread::OnChannelError() {
   set_on_channel_error_called(true);
   base::MessageLoop::current()->Quit();
 }
 
 bool ChildThread::Send(IPC::Message* msg) {
-  DCHECK(base::MessageLoop::current() == message_loop());
+  DCHECK(in_browser_process_ || base::MessageLoop::current() == message_loop());

[jam, 2013/10/24 16:49:04]

why is this needed?

   if (!channel_) {
     delete msg;
     return false;
   }
 
   return channel_->Send(msg);
 }
 
 void ChildThread::AddRoute(int32 routing_id, IPC::Listener* listener) {
   DCHECK(base::MessageLoop::current() == message_loop());
@@ skipping 178 matching lines @@
   // inflight that would addref it.
   Send(new ChildProcessHostMsg_ShutdownRequest);
 }
 
 void ChildThread::EnsureConnected() {
   LOG(INFO) << "ChildThread::EnsureConnected()";
   base::KillProcess(base::GetCurrentProcessHandle(), 0, false);
 }
 
 }  // namespace content