Mustash: Ensure surfaces submitted to Mus by WM and embedders contain Surfaces with embeded content.

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"
@@ skipping 111 matching lines @@
   // TODO(fsamuel, staraz): Implement this.
 }
 
 cc::CompositorFrame FrameGenerator::GenerateCompositorFrame(
     const gfx::Rect& output_rect) {
   const int render_pass_id = 1;
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
   render_pass->SetNew(render_pass_id, output_rect, output_rect,
                       gfx::Transform());
 
-  DrawWindowTree(render_pass.get(), root_window_, gfx::Vector2d(), 1.0f);
+  DrawWindow(render_pass.get(), delegate_->GetActiveRootWindow());
 
   cc::CompositorFrame frame;
   frame.render_pass_list.push_back(std::move(render_pass));
   if (delegate_->IsInHighContrastMode()) {
     std::unique_ptr<cc::RenderPass> invert_pass = cc::RenderPass::Create();
     invert_pass->SetNew(2, output_rect, output_rect, gfx::Transform());
     cc::SharedQuadState* shared_state =
         invert_pass->CreateAndAppendSharedQuadState();
     shared_state->SetAll(gfx::Transform(), output_rect.size(), output_rect,
                          output_rect, false, 1.f, SkBlendMode::kSrcOver, 0);
     auto* quad = invert_pass->CreateAndAppendDrawQuad<cc::RenderPassDrawQuad>();
     render_pass->filters.Append(cc::FilterOperation::CreateInvertFilter(1.f));
     quad->SetNew(shared_state, output_rect, output_rect, render_pass_id,
                  0 /* mask_resource_id */, gfx::Vector2dF() /* mask_uv_scale */,
                  gfx::Size() /* mask_texture_size */,
                  gfx::Vector2dF() /* filters_scale */,
                  gfx::PointF() /* filters_origin */);
     frame.render_pass_list.push_back(std::move(invert_pass));
   }
 
   return frame;
 }
 
-void FrameGenerator::DrawWindowTree(
-    cc::RenderPass* pass,
-    ServerWindow* window,
-    const gfx::Vector2d& parent_to_root_origin_offset,
-    float opacity) {
+void FrameGenerator::DrawWindow(cc::RenderPass* pass, ServerWindow* window) {
   if (!window->visible())
     return;
 
-  const gfx::Rect absolute_bounds =
-      window->bounds() + parent_to_root_origin_offset;
-  const ServerWindow::Windows& children = window->children();
-  const float combined_opacity = opacity * window->opacity();
-  for (ServerWindow* child : base::Reversed(children)) {
-    DrawWindowTree(pass, child, absolute_bounds.OffsetFromOrigin(),
-                   combined_opacity);
-  }
-
   if (!window->compositor_frame_sink_manager() ||
       !window->compositor_frame_sink_manager()->ShouldDraw())
     return;
 
-  cc::SurfaceId underlay_surface_id =
-      window->compositor_frame_sink_manager()->GetLatestSurfaceId(
-          mojom::CompositorFrameSinkType::UNDERLAY);
   cc::SurfaceId default_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::DEFAULT);
 
-  if (!underlay_surface_id.is_valid() && !default_surface_id.is_valid())
+  if (!default_surface_id.is_valid())
     return;
 
-  if (default_surface_id.is_valid()) {
-    gfx::Transform quad_to_target_transform;
-    quad_to_target_transform.Translate(absolute_bounds.x(),
-                                       absolute_bounds.y());
+  gfx::Transform quad_to_target_transform;
+  quad_to_target_transform.Translate(window->bounds().x(),
+                                     window->bounds().y());
 
-    cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
+  cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
 
-    const gfx::Rect bounds_at_origin(window->bounds().size());
-    // TODO(fsamuel): These clipping and visible rects are incorrect. They need
-    // to be populated from CompositorFrame structs.
-    sqs->SetAll(
-        quad_to_target_transform, bounds_at_origin.size() /* layer_bounds */,
-        bounds_at_origin /* visible_layer_bounds */,
-        bounds_at_origin /* clip_rect */, false /* is_clipped */,
-        combined_opacity, SkBlendMode::kSrcOver, 0 /* sorting-context_id */);
-    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*/,
-                 default_surface_id);
-  }
-  if (underlay_surface_id.is_valid()) {
-    const gfx::Rect underlay_absolute_bounds =
-        absolute_bounds - window->underlay_offset();
-    gfx::Transform quad_to_target_transform;
-    quad_to_target_transform.Translate(underlay_absolute_bounds.x(),
-                                       underlay_absolute_bounds.y());
-    cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
-    const gfx::Rect bounds_at_origin(
-        window->compositor_frame_sink_manager()->GetLatestFrameSize(
-            mojom::CompositorFrameSinkType::UNDERLAY));
-    sqs->SetAll(
-        quad_to_target_transform, bounds_at_origin.size() /* layer_bounds */,
-        bounds_at_origin /* visible_layer_bounds */,
-        bounds_at_origin /* clip_rect */, false /* is_clipped */,
-        combined_opacity, SkBlendMode::kSrcOver, 0 /* sorting-context_id */);
-
-    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);
-  }
+  const gfx::Rect bounds_at_origin(window->bounds().size());
+  // TODO(fsamuel): These clipping and visible rects are incorrect. They need
+  // to be populated from CompositorFrame structs.
+  sqs->SetAll(
+      quad_to_target_transform, bounds_at_origin.size() /* layer_bounds */,
+      bounds_at_origin /* visible_layer_bounds */,
+      bounds_at_origin /* clip_rect */, false /* is_clipped */,
+      1.0f /* opacity */, SkBlendMode::kSrcOver, 0 /* sorting-context_id */);
+  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*/,
+               default_surface_id);
 }
 
 cc::SurfaceId FrameGenerator::FindParentSurfaceId(ServerWindow* window) {
   if (window == root_window_)
     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(
@@ skipping 100 matching lines @@
   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