Revert of 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 112 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());
 
-  DrawWindow(render_pass.get(), delegate_->GetActiveRootWindow());
+  DrawWindowTree(render_pass.get(), root_window_, gfx::Vector2d(), 1.0f);
 
   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));
   }
   frame.metadata.device_scale_factor = device_scale_factor_;
 
   return frame;
 }
 
-void FrameGenerator::DrawWindow(cc::RenderPass* pass, ServerWindow* window) {
+void FrameGenerator::DrawWindowTree(
+    cc::RenderPass* pass,
+    ServerWindow* window,
+    const gfx::Vector2d& parent_to_root_origin_offset,
+    float opacity) {
   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 (!default_surface_id.is_valid())
+  if (!underlay_surface_id.is_valid() && !default_surface_id.is_valid())
     return;
 
-  gfx::Transform quad_to_target_transform;
-  quad_to_target_transform.Translate(window->bounds().x(),
-                                     window->bounds().y());
+  if (default_surface_id.is_valid()) {
+    gfx::Transform quad_to_target_transform;
+    quad_to_target_transform.Translate(absolute_bounds.x(),
+                                       absolute_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 */,
-      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);
+    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);
+  }
 }
 
 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