Revert of CHECK that the RendererCompositorFrameSink has been detached

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 62 matching lines @@
               : base::MakeUnique<cc::ExternalBeginFrameSource>(this)),
       routing_id_(routing_id),
       sink_client_binding_(this) {
   DCHECK(compositor_frame_sink_filter_);
   DCHECK(frame_swap_message_queue_);
   DCHECK(message_sender_);
   thread_checker_.DetachFromThread();
   EstablishMojoConnection();
 }
 
-RendererCompositorFrameSink::~RendererCompositorFrameSink() {
-  // TODO(crbug.com/702764): If not detached then IPC messages would crash
-  // after this class is destroyed.
-  CHECK(!bound_);
-}
+RendererCompositorFrameSink::~RendererCompositorFrameSink() = default;
 
 bool RendererCompositorFrameSink::BindToClient(
     cc::CompositorFrameSinkClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!cc::CompositorFrameSink::BindToClient(client))
     return false;
 
   sink_.Bind(std::move(sink_ptr_info_));
   sink_client_binding_.Bind(std::move(sink_client_request_));
 
   if (synthetic_begin_frame_source_)
     client_->SetBeginFrameSource(synthetic_begin_frame_source_.get());
   else
     client_->SetBeginFrameSource(external_begin_frame_source_.get());
 
   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_);
-
-  bound_ = true;
   return true;
 }
 
 void RendererCompositorFrameSink::DetachFromClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   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.
   external_begin_frame_source_ = nullptr;
   synthetic_begin_frame_source_ = nullptr;
   compositor_frame_sink_proxy_->ClearCompositorFrameSink();
   compositor_frame_sink_filter_->RemoveHandlerOnCompositorThread(
       routing_id_, compositor_frame_sink_filter_handler_);
   sink_.reset();
   sink_client_binding_.Close();
   cc::CompositorFrameSink::DetachFromClient();
-  bound_ = false;
 }
 
 void RendererCompositorFrameSink::SubmitCompositorFrame(
     cc::CompositorFrame frame) {
   // We should only submit CompositorFrames with valid BeginFrameAcks.
   DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber,
             frame.metadata.begin_frame_ack.sequence_number);
   if (ShouldAllocateNewLocalSurfaceId(frame))
     local_surface_id_ = id_allocator_.GenerateId();
   UpdateFrameData(frame);
@@ skipping 113 matching lines @@
   cc::mojom::MojoCompositorFrameSinkRequest sink_request =
       mojo::MakeRequest(&sink);
   cc::mojom::MojoCompositorFrameSinkClientPtr sink_client;
   sink_client_request_ = mojo::MakeRequest(&sink_client);
   RenderThreadImpl::current()->GetFrameSinkProvider()->CreateForWidget(
       routing_id_, std::move(sink_request), std::move(sink_client));
   sink_ptr_info_ = sink.PassInterface();
 }
 
 }  // namespace content