DirectCompositorFrameSink Uses CompositorFrameSinkSupport

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 653 matching lines @@
 
   auto compositor_frame_sink =
       vulkan_context_provider
           ? base::MakeUnique<cc::DirectCompositorFrameSink>(
                 frame_sink_id_, manager, display_.get(),
                 vulkan_context_provider)
           : base::MakeUnique<cc::DirectCompositorFrameSink>(
                 frame_sink_id_, manager, display_.get(), context_provider,
                 nullptr, BrowserGpuMemoryBufferManager::current(),
                 HostSharedBitmapManager::current());
-
+  for (auto& frame_sink_id : pending_child_frame_sink_ids_) {

[Fady Samuel, 2017/01/25 22:36:51]

This should probably go in DidInitializeCompositorFrameSink.

[Alex Z., 2017/01/26 01:33:56]

Done.

+    AddChildFrameSink(frame_sink_id);
+  }
+  pending_child_frame_sink_ids_.clear();
+  has_compositor_frame_sink_ = true;

[Fady Samuel, 2017/01/25 22:36:51]

I don't think this is necessary.

[Alex Z., 2017/01/26 01:33:56]

We need the flag to change when DirectCompositorFrameSink detaches 
from client (when we "lost" DirectCompositorFrameSink). 
compositor_frame_sink_request_pending_ remains false when that 
happens.

   display_->SetVisible(true);
   display_->Resize(size_);
   host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 cc::UIResourceId CompositorImpl::CreateUIResource(
     cc::UIResourceClient* client) {
   TRACE_EVENT0("compositor", "CompositorImpl::CreateUIResource");
   return host_->GetUIResourceManager()->CreateUIResource(client);
 }
@@ skipping 14 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(cc::FrameSinkId frame_sink_id) {
+  if (!has_compositor_frame_sink_) {

[Fady Samuel, 2017/01/25 22:36:51]

if (compositor_frame_sink_request_pending_)

[Alex Z., 2017/01/26 01:33:56]

compositor_frame_sink_request_pending_ gets flipped when a new 
request is created or the request is fulfilled. It doesn't change 
when the DirectCompositorFrameSink detaches from client (this happens 
when SetVisible(false) is called). I missed that one in this patch.

+    pending_child_frame_sink_ids_.insert(frame_sink_id);
+  } else {
+    // All pending child frame sink ids should be added upon the creation of
+    // compositor frame sink.
+    DCHECK(pending_child_frame_sink_ids_.empty());
+    ui::ContextProviderFactory::GetInstance()
+        ->GetSurfaceManager()
+        ->RegisterFrameSinkHierarchy(frame_sink_id_, frame_sink_id);
+  }
+}
+
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content