Add AddChildFrameSink() and RemoveChildFrameSink() To WindowAndroidCompositor

content/browser/renderer_host/compositor_impl_android.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/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 448 matching lines @@
     DCHECK(host_->IsVisible());
 
     // Make a best effort to try to complete pending readbacks.
     // TODO(crbug.com/637035): Consider doing this in a better way,
     // ideally with the guarantee of readbacks completing.
     if (display_.get() && HavePendingReadbacks())
       display_->ForceImmediateDrawAndSwapIfPossible();
 
     host_->SetVisible(false);
     host_->ReleaseCompositorFrameSink();
+    has_compositor_frame_sink_ = false;
     pending_swapbuffers_ = 0;
     display_.reset();
   } else {
     host_->SetVisible(true);
     if (compositor_frame_sink_request_pending_)
       HandlePendingCompositorFrameSinkRequest();
   }
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
@@ skipping 46 matching lines @@
 void CompositorImpl::RequestNewCompositorFrameSink() {
   DCHECK(!compositor_frame_sink_request_pending_)
       << "Output Surface Request is already pending?";
 
   compositor_frame_sink_request_pending_ = true;
   HandlePendingCompositorFrameSinkRequest();
 }
 
 void CompositorImpl::DidInitializeCompositorFrameSink() {
   compositor_frame_sink_request_pending_ = false;
+  has_compositor_frame_sink_ = true;
+  for (auto& frame_sink_id : pending_child_frame_sink_ids_)
+    AddChildFrameSink(frame_sink_id);
+
+  pending_child_frame_sink_ids_.clear();
 }
 
 void CompositorImpl::DidFailToInitializeCompositorFrameSink() {
   // The context is bound/initialized before handing it to the
   // CompositorFrameSink.
   NOTREACHED();
 }
 
 void CompositorImpl::HandlePendingCompositorFrameSinkRequest() {
   DCHECK(compositor_frame_sink_request_pending_);
@@ skipping 154 matching lines @@
 
 void CompositorImpl::DidReceiveCompositorFrameAck() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidReceiveCompositorFrameAck");
   DCHECK_GT(pending_swapbuffers_, 0U);
   pending_swapbuffers_--;
   client_->OnSwapBuffersCompleted(pending_swapbuffers_);
 }
 
 void CompositorImpl::DidLoseCompositorFrameSink() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidLoseCompositorFrameSink");
+  has_compositor_frame_sink_ = false;
   client_->OnSwapBuffersCompleted(0);
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   readback_layer_tree_->AddChild(layer);
 }
 
 void CompositorImpl::RequestCopyOfOutputOnRootLayer(
     std::unique_ptr<cc::CopyOutputRequest> request) {
   root_window_->GetLayer()->RequestCopyOfOutput(std::move(request));
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->IsVisible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 cc::FrameSinkId CompositorImpl::GetFrameSinkId() {
   return frame_sink_id_;
 }
 
+void CompositorImpl::AddChildFrameSink(const cc::FrameSinkId& frame_sink_id) {
+  if (has_compositor_frame_sink_) {
+    ui::ContextProviderFactory::GetInstance()
+        ->GetSurfaceManager()
+        ->RegisterFrameSinkHierarchy(frame_sink_id_, frame_sink_id);
+  } else {
+    pending_child_frame_sink_ids_.insert(frame_sink_id);
+  }
+}
+
+void CompositorImpl::RemoveChildFrameSink(
+    const cc::FrameSinkId& frame_sink_id) {
+  auto it = pending_child_frame_sink_ids_.find(frame_sink_id);
+  if (it != pending_child_frame_sink_ids_.end()) {
+    pending_child_frame_sink_ids_.erase(it);
+    return;
+  }
+  ui::ContextProviderFactory::GetInstance()
+      ->GetSurfaceManager()
+      ->UnregisterFrameSinkHierarchy(frame_sink_id_, frame_sink_id);
+}
+
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content