Fix GpuChannelHost destruction races.

content/common/gpu/client/gpu_channel_host.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/common/gpu/client/gpu_channel_host.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 34 matching lines @@
   channel_.reset(new IPC::SyncChannel(
       channel_handle, IPC::Channel::MODE_CLIENT, NULL,
       io_loop, true,
       factory_->GetShutDownEvent()));
 
   sync_filter_ = new IPC::SyncMessageFilter(
       factory_->GetShutDownEvent());
 
   channel_->AddFilter(sync_filter_.get());
 
-  channel_filter_ = new MessageFilter(this);
+  channel_filter_ = new MessageFilter(AsWeakPtr(), factory_);
 
   // Install the filter last, because we intercept all leftover
   // messages.
   channel_->AddFilter(channel_filter_.get());
 
   // It is safe to send IPC messages before the channel completes the connection
   // and receives the hello message from the GPU process. The messages get
   // cached.
   state_ = kConnected;
 }
@@ skipping 243 matching lines @@
                             names.end());
 }
 
 int32 GpuChannelHost::ReserveTransferBufferId() {
   return next_transfer_buffer_id_.GetNext();
 }
 
 GpuChannelHost::~GpuChannelHost() {}
 
 
-GpuChannelHost::MessageFilter::MessageFilter(GpuChannelHost* parent)
-    : parent_(parent) {
+GpuChannelHost::MessageFilter::MessageFilter(
+    base::WeakPtr<GpuChannelHost> parent,
+    GpuChannelHostFactory* factory)
+    : parent_(parent),
+      factory_(factory) {
 }
 
 GpuChannelHost::MessageFilter::~MessageFilter() {}
 
 void GpuChannelHost::MessageFilter::AddRoute(
     int route_id,
     base::WeakPtr<IPC::Listener> listener,
     scoped_refptr<MessageLoopProxy> loop) {
-  DCHECK(parent_->factory_->IsIOThread());
+  DCHECK(factory_->IsIOThread());
   DCHECK(listeners_.find(route_id) == listeners_.end());
   GpuListenerInfo info;
   info.listener = listener;
   info.loop = loop;
   listeners_[route_id] = info;
 }
 
 void GpuChannelHost::MessageFilter::RemoveRoute(int route_id) {
-  DCHECK(parent_->factory_->IsIOThread());
+  DCHECK(factory_->IsIOThread());
   ListenerMap::iterator it = listeners_.find(route_id);
   if (it != listeners_.end())
     listeners_.erase(it);
 }
 
 bool GpuChannelHost::MessageFilter::OnMessageReceived(
     const IPC::Message& message) {
-  DCHECK(parent_->factory_->IsIOThread());
+  DCHECK(factory_->IsIOThread());
 
   // Never handle sync message replies or we will deadlock here.
   if (message.is_reply())
     return false;
 
   if (message.routing_id() == MSG_ROUTING_CONTROL) {
-    MessageLoop* main_loop = parent_->factory_->GetMainLoop();
+    MessageLoop* main_loop = factory_->GetMainLoop();
     main_loop->PostTask(FROM_HERE,
                         base::Bind(&GpuChannelHost::OnMessageReceived,
                                    parent_,
                                    message));
     return true;
   }
 
   ListenerMap::iterator it = listeners_.find(message.routing_id());
 
   if (it != listeners_.end()) {
     const GpuListenerInfo& info = it->second;
     info.loop->PostTask(
         FROM_HERE,
         base::Bind(
             base::IgnoreResult(&IPC::Listener::OnMessageReceived),
             info.listener,
             message));
   }
 
   return true;
 }
 
 void GpuChannelHost::MessageFilter::OnChannelError() {
-  DCHECK(parent_->factory_->IsIOThread());
+  DCHECK(factory_->IsIOThread());
 
   // Post the task to signal the GpuChannelHost before the proxies. That way, if
   // they themselves post a task to recreate the context, they will not try to
   // re-use this channel host before it has a chance to mark itself lost.
-  MessageLoop* main_loop = parent_->factory_->GetMainLoop();
+  MessageLoop* main_loop = factory_->GetMainLoop();
   main_loop->PostTask(FROM_HERE,
                       base::Bind(&GpuChannelHost::OnChannelError, parent_));
   // Inform all the proxies that an error has occurred. This will be reported
   // via OpenGL as a lost context.
   for (ListenerMap::iterator it = listeners_.begin();
        it != listeners_.end();
        it++) {
     const GpuListenerInfo& info = it->second;
     info.loop->PostTask(
         FROM_HERE,
         base::Bind(&IPC::Listener::OnChannelError, info.listener));
   }
 
   listeners_.clear();
 }
 
 }  // namespace content