Add/remove surface references via MojoCompositorFrameSink.

services/ui/ws/frame_generator.cc

 // Copyright 2016 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 "services/ui/ws/frame_generator.h"
 
+#include <utility>
+
 #include "base/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
-#include "cc/surfaces/surface_id.h"
 #include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_delegate.h"
 
 namespace ui {
 
 namespace ws {
 
 FrameGenerator::FrameGenerator(FrameGeneratorDelegate* delegate,
                                ServerWindow* root_window)
     : delegate_(delegate),
       root_window_(root_window),
-      top_level_root_surface_id_(
-          cc::FrameSinkId(0, 0),
-          cc::LocalFrameId(0, base::UnguessableToken::Create())),
       binding_(this),
       weak_factory_(this) {
   DCHECK(delegate_);
 }
 
 FrameGenerator::~FrameGenerator() {
-  RemoveDeadSurfaceReferences();
   RemoveAllSurfaceReferences();
   // Invalidate WeakPtrs now to avoid callbacks back into the
   // FrameGenerator during destruction of |compositor_frame_sink_|.
   weak_factory_.InvalidateWeakPtrs();
   compositor_frame_sink_.reset();
 }
 
 void FrameGenerator::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget) {
   DCHECK_NE(gfx::kNullAcceleratedWidget, widget);
   cc::mojom::MojoCompositorFrameSinkRequest request =
       mojo::GetProxy(&compositor_frame_sink_);
   root_window_->CreateCompositorFrameSink(
       mojom::CompositorFrameSinkType::DEFAULT, widget, std::move(request),
       binding_.CreateInterfacePtrAndBind());
   // TODO(fsamuel): This means we're always requesting a new BeginFrame signal
   // even when we don't need it. Once surface ID propagation work is done,
   // this will not be necessary because FrameGenerator will only need a
   // BeginFrame if the window manager changes.
   compositor_frame_sink_->SetNeedsBeginFrame(true);
 }
 
 void FrameGenerator::OnSurfaceCreated(const cc::SurfaceId& surface_id,
                                       ServerWindow* window) {
   DCHECK(surface_id.is_valid());
 
-  // TODO(kylechar): Adding surface references should be synchronized with
-  // SubmitCompositorFrame().
-
   auto iter = active_references_.find(surface_id.frame_sink_id());
   if (iter == active_references_.end()) {
     AddFirstReference(surface_id, window);
     return;
   }
 
-  SurfaceReference& ref = iter->second;
-  DCHECK_EQ(surface_id.frame_sink_id(), ref.child_id.frame_sink_id());
+  cc::SurfaceReference& ref = iter->second;
 
   // This shouldn't be called multiple times for the same SurfaceId.
-  DCHECK_NE(surface_id.local_frame_id(), ref.child_id.local_frame_id());
+  DCHECK_EQ(surface_id.frame_sink_id(), ref.child_id().frame_sink_id());
+  DCHECK_NE(surface_id.local_frame_id(), ref.child_id().local_frame_id());
 
-  // Add a reference from parent to new surface first.
-  GetDisplayCompositor()->AddSurfaceReference(ref.parent_id, surface_id);
+  // Old reference will be removed when the next CompositorFrame is submitted.
+  dead_references_.push_back(ref);
+  cc::SurfaceId old_surface_id = ref.child_id();
+
+  // New surface reference is recorded and will be added at end of this method.
+  ref = cc::SurfaceReference(ref.parent_id(), surface_id);
+  new_references_.push_back(ref);
 
   // If the display root surface has changed, update all references to embedded
   // surfaces. For example, this would happen when the display resolution or
   // zoom level changes.
   if (!window->parent())
-    AddNewParentReferences(ref.child_id, surface_id);
+    AddNewParentReferences(old_surface_id, surface_id);
 
-  // Move the existing reference to list of references to remove after we submit
-  // the next CompositorFrame. Update local reference cache to be the new
-  // reference. If this is the display root surface then removing this reference
-  // will recursively remove any references it held.
-  dead_references_.push_back(ref);
-  ref.child_id = surface_id;
+  SendAddSurfaceReferences();
 }
 
 void FrameGenerator::DidReceiveCompositorFrameAck() {}
 
 void FrameGenerator::OnBeginFrame(const cc::BeginFrameArgs& begin_frame_arags) {
   if (!root_window_->visible())
     return;
 
   // TODO(fsamuel): We should add a trace for generating a top level frame.
   cc::CompositorFrame frame(GenerateCompositorFrame(root_window_->bounds()));
 
   if (compositor_frame_sink_) {
     gfx::Size frame_size = last_submitted_frame_size_;
     if (!frame.render_pass_list.empty())
       frame_size = frame.render_pass_list[0]->output_rect.size();
     if (!local_frame_id_.is_valid() || frame_size != last_submitted_frame_size_)
       local_frame_id_ = id_allocator_.GenerateId();
     compositor_frame_sink_->SubmitCompositorFrame(local_frame_id_,
                                                   std::move(frame));
     last_submitted_frame_size_ = frame_size;
 
     // Remove dead references after we submit a frame. This has to happen after
     // the frame is submitted otherwise we could end up deleting a surface that
     // is still embedded in the last frame.
-    // TODO(kylechar): This should be synchronized with SubmitCompositorFrame().
-    RemoveDeadSurfaceReferences();
+    SendRemoveSurfaceReferences();
   }
 }
 
 void FrameGenerator::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
   // Nothing to do here because FrameGenerator CompositorFrames don't reference
   // any resources.
 }
 
 cc::CompositorFrame FrameGenerator::GenerateCompositorFrame(
@@ skipping 101 matching lines @@
     auto* quad = pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
     quad->SetAll(sqs, bounds_at_origin /* rect */,
                  gfx::Rect() /* opaque_rect */,
                  bounds_at_origin /* visible_rect */, true /* needs_blending*/,
                  underlay_surface_id);
   }
 }
 
 cc::SurfaceId FrameGenerator::FindParentSurfaceId(ServerWindow* window) {
   if (window == root_window_)
-    return top_level_root_surface_id_;
+    return root_window_->delegate()->GetRootSurfaceId();
 
   // The root window holds the parent SurfaceId. This SurfaceId will have an
   // invalid LocalFrameId before FrameGenerator has submitted a CompositorFrame.
   // After the first frame is submitted it will always be a valid SurfaceId.
   return root_window_->compositor_frame_sink_manager()->GetLatestSurfaceId(
       mojom::CompositorFrameSinkType::DEFAULT);
 }
 
 void FrameGenerator::AddSurfaceReference(const cc::SurfaceId& parent_id,
                                          const cc::SurfaceId& child_id) {
-  if (parent_id == top_level_root_surface_id_)
-    GetDisplayCompositor()->AddRootSurfaceReference(child_id);
-  else
-    GetDisplayCompositor()->AddSurfaceReference(parent_id, child_id);
+  DCHECK_NE(parent_id, child_id);
 
   // Add new reference from parent to surface, plus add reference to local
   // cache.
-  active_references_[child_id.frame_sink_id()] =
-      SurfaceReference({parent_id, child_id});
+  cc::SurfaceReference ref(parent_id, child_id);
+  active_references_[child_id.frame_sink_id()] = ref;
+  new_references_.push_back(ref);
 }
 
 void FrameGenerator::AddFirstReference(const cc::SurfaceId& surface_id,
                                        ServerWindow* window) {
   cc::SurfaceId parent_id = FindParentSurfaceId(window);
 
-  if (parent_id == top_level_root_surface_id_ || parent_id.is_valid()) {
+  if (window == root_window_ || parent_id.is_valid()) {
     AddSurfaceReference(parent_id, surface_id);
 
     // For the first display root surface, add references to any child surfaces
     // that were created before it.
-    if (parent_id == top_level_root_surface_id_) {
+    if (window == root_window_) {
       for (auto& child_surface_id : waiting_for_references_)
         AddSurfaceReference(surface_id, child_surface_id);
       waiting_for_references_.clear();
     }
+
+    SendAddSurfaceReferences();
   } else {
     // This isn't the display root surface and display root surface hasn't
     // submitted a CF yet. We can't add a reference to an unknown SurfaceId.
     waiting_for_references_.push_back(surface_id);
   }
 
   // Observe |window| so that we can remove references when it's destroyed.
   Add(window);
 }
 
 void FrameGenerator::AddNewParentReferences(
     const cc::SurfaceId& old_surface_id,
     const cc::SurfaceId& new_surface_id) {
-  DCHECK(old_surface_id.frame_sink_id() == new_surface_id.frame_sink_id());
+  DCHECK_EQ(old_surface_id.frame_sink_id(), new_surface_id.frame_sink_id());
 
-  cc::mojom::DisplayCompositor* display_compositor = GetDisplayCompositor();
   for (auto& map_entry : active_references_) {
-    SurfaceReference& ref = map_entry.second;
-    if (ref.parent_id == old_surface_id) {
-      display_compositor->AddSurfaceReference(new_surface_id, ref.child_id);
-      ref.parent_id = new_surface_id;
+    cc::SurfaceReference& ref = map_entry.second;
+    if (ref.parent_id() == old_surface_id) {
+      ref = cc::SurfaceReference(new_surface_id, ref.child_id());
+      new_references_.push_back(ref);
     }
   }
 }
 
-void FrameGenerator::RemoveDeadSurfaceReferences() {
+void FrameGenerator::SendAddSurfaceReferences() {
+  if (new_references_.empty())
+    return;
+
+  compositor_frame_sink_->AddSurfaceReferences(new_references_);
+  new_references_.clear();
+}
+
+void FrameGenerator::SendRemoveSurfaceReferences() {
   if (dead_references_.empty())
     return;
 
-  cc::mojom::DisplayCompositor* display_compositor = GetDisplayCompositor();
-  for (auto& ref : dead_references_) {
-    if (ref.parent_id == top_level_root_surface_id_)
-      display_compositor->RemoveRootSurfaceReference(ref.child_id);
-    else
-      display_compositor->RemoveSurfaceReference(ref.parent_id, ref.child_id);
-  }
+  compositor_frame_sink_->RemoveSurfaceReferences(dead_references_);
   dead_references_.clear();
 }
 
 void FrameGenerator::RemoveFrameSinkReference(
     const cc::FrameSinkId& frame_sink_id) {
   auto it = active_references_.find(frame_sink_id);
   if (it == active_references_.end())
     return;
   dead_references_.push_back(it->second);
   active_references_.erase(it);
 }
 
 void FrameGenerator::RemoveAllSurfaceReferences() {
-  // TODO(kylechar): Remove multiple surfaces with one IPC call.
-  cc::mojom::DisplayCompositor* display_compositor = GetDisplayCompositor();
-  for (auto& map_entry : active_references_) {
-    const SurfaceReference& ref = map_entry.second;
-    display_compositor->RemoveSurfaceReference(ref.parent_id, ref.child_id);
-  }
+  for (auto& map_entry : active_references_)
+    dead_references_.push_back(map_entry.second);
   active_references_.clear();
-}
-
-cc::mojom::DisplayCompositor* FrameGenerator::GetDisplayCompositor() {
-  return root_window_->delegate()->GetDisplayCompositor();
+  SendRemoveSurfaceReferences();
 }
 
 void FrameGenerator::OnWindowDestroying(ServerWindow* window) {
   Remove(window);
   ServerWindowCompositorFrameSinkManager* compositor_frame_sink_manager =
       window->compositor_frame_sink_manager();
   // If FrameGenerator was observing |window|, then that means it had a
   // CompositorFrame at some point in time and should have a
   // ServerWindowCompositorFrameSinkManager.
   DCHECK(compositor_frame_sink_manager);
 
   cc::SurfaceId default_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::DEFAULT);
   if (default_surface_id.is_valid())
     RemoveFrameSinkReference(default_surface_id.frame_sink_id());
 
   cc::SurfaceId underlay_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::UNDERLAY);
   if (underlay_surface_id.is_valid())
     RemoveFrameSinkReference(underlay_surface_id.frame_sink_id());
 }
 
 }  // namespace ws
 
 }  // namespace ui