cc: Stop calling DetachFromClient if bind failed.

content/renderer/gpu/renderer_compositor_frame_sink.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/renderer/gpu/renderer_compositor_frame_sink.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 70 matching lines @@
   compositor_frame_sink_proxy_ = new RendererCompositorFrameSinkProxy(this);
   compositor_frame_sink_filter_handler_ =
       base::Bind(&RendererCompositorFrameSinkProxy::OnMessageReceived,
                  compositor_frame_sink_proxy_);
   compositor_frame_sink_filter_->AddHandlerOnCompositorThread(
       routing_id_, compositor_frame_sink_filter_handler_);
   return true;
 }
 
 void RendererCompositorFrameSink::DetachFromClient() {
-  if (!HasClient())
-    return;
   client_->SetBeginFrameSource(nullptr);
   // Destroy the begin frame source on the same thread it was bound on.
   // The CompositorFrameSink itself is destroyed on the main thread.
   begin_frame_source_ = nullptr;
+  compositor_frame_sink_proxy_->ClearCompositorFrameSink();
+  compositor_frame_sink_filter_->RemoveHandlerOnCompositorThread(
+      routing_id_, compositor_frame_sink_filter_handler_);
 
-  if (compositor_frame_sink_proxy_) {
-    compositor_frame_sink_proxy_->ClearCompositorFrameSink();
-    compositor_frame_sink_filter_->RemoveHandlerOnCompositorThread(
-        routing_id_, compositor_frame_sink_filter_handler_);
-  }
   cc::CompositorFrameSink::DetachFromClient();
 }
 
 void RendererCompositorFrameSink::SwapBuffers(cc::CompositorFrame frame) {
   {
     std::unique_ptr<FrameSwapMessageQueue::SendMessageScope>
         send_message_scope =
             frame_swap_message_queue_->AcquireSendMessageScope();
     std::vector<std::unique_ptr<IPC::Message>> messages;
     std::vector<IPC::Message> messages_to_deliver_with_frame;
     frame_swap_message_queue_->DrainMessages(&messages);
     FrameSwapMessageQueue::TransferMessages(&messages,
                                             &messages_to_deliver_with_frame);
     Send(new ViewHostMsg_SwapCompositorFrame(routing_id_,
                                              compositor_frame_sink_id_, frame,
                                              messages_to_deliver_with_frame));
     // ~send_message_scope.
   }
 }
 
 void RendererCompositorFrameSink::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(client_thread_checker_.CalledOnValidThread());
-  if (!HasClient())

[danakj, 2016/10/10 22:13:03]

This looks "interesting" but AFAICT
DetachFromClient->RemoveHandlerOnCompositorThread implies that this method will
not be called again, as the message filter uses the map (on this same thread) to
find this class to call OnMessageReceived but it'll be removed from it.

-    return;
   IPC_BEGIN_MESSAGE_MAP(RendererCompositorFrameSink, message)
     IPC_MESSAGE_HANDLER(ViewMsg_ReclaimCompositorResources,
                         OnReclaimCompositorResources);
   IPC_END_MESSAGE_MAP()
 }
 
 void RendererCompositorFrameSink::OnReclaimCompositorResources(
     uint32_t compositor_frame_sink_id,
     bool is_swap_ack,
     const cc::ReturnedResourceArray& resources) {
   // Ignore message if it's a stale one coming from a different output surface
   // (e.g. after a lost context).
   if (compositor_frame_sink_id != compositor_frame_sink_id_)
     return;
   client_->ReclaimResources(resources);
   if (is_swap_ack)
     client_->DidSwapBuffersComplete();
 }
 
 bool RendererCompositorFrameSink::Send(IPC::Message* message) {
   return message_sender_->Send(message);
 }
 
 }  // namespace content