Mus: Delete unused Mandoline Surfaces code

components/mus/ws/platform_display.cc

 // Copyright 2014 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 "components/mus/ws/platform_display.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "cc/ipc/quads.mojom.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 32 matching lines @@
 #elif defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace mus {
 
 namespace ws {
 namespace {
 
 // DrawWindowTree recursively visits ServerWindows, creating a SurfaceDrawQuad
-// for each that lacks one. A ServerWindow may hold a CompositorFrame that
-// references other ServerWindows in SurfaceDrawQuads. We should not create new
-// SurfaceDrawQuads for these |referenced_window_ids|. Instead,
-// cc::SurfaceAggregator will do the heavy lifting here by expanding those
-// references to generate one top-level display CompositorFrame.
+// for each that lacks one.
 void DrawWindowTree(cc::RenderPass* pass,
                     ServerWindow* window,
                     const gfx::Vector2d& parent_to_root_origin_offset,
-                    float opacity,
-                    std::set<WindowId>* referenced_window_ids) {
+                    float opacity) {
   if (!window->visible())
     return;
 
   ServerWindowSurface* default_surface =
       window->surface_manager() ? window->surface_manager()->GetDefaultSurface()
                                 : nullptr;
 
-  if (default_surface) {
-    // Accumulate referenced windows in each ServerWindow's CompositorFrame.
-    referenced_window_ids->insert(
-        default_surface->referenced_window_ids().begin(),
-        default_surface->referenced_window_ids().end());
-  }
-
   const gfx::Rect absolute_bounds =
       window->bounds() + parent_to_root_origin_offset;
   std::vector<ServerWindow*> children(window->GetChildren());
   // TODO(rjkroege, fsamuel): Make sure we're handling alpha correctly.
   const float combined_opacity = opacity * window->opacity();
   for (auto it = children.rbegin(); it != children.rend(); ++it) {
     DrawWindowTree(pass, *it, absolute_bounds.OffsetFromOrigin(),
-                   combined_opacity, referenced_window_ids);
+                   combined_opacity);
   }
 
   if (!window->surface_manager() || !window->surface_manager()->ShouldDraw())
     return;
 
-  // If an ancestor has already referenced this window, then we do not need
-  // to create a SurfaceDrawQuad for it.
-  const bool draw_default_surface =
-      default_surface && (referenced_window_ids->count(window->id()) == 0);
-
   ServerWindowSurface* underlay_surface =
       window->surface_manager()->GetUnderlaySurface();
-  if (!draw_default_surface && !underlay_surface)
+  if (!default_surface && !underlay_surface)
     return;
 
-  if (draw_default_surface) {
+  if (default_surface) {
     gfx::Transform quad_to_target_transform;
     quad_to_target_transform.Translate(absolute_bounds.x(),
                                        absolute_bounds.y());
 
     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,
@@ skipping 208 matching lines @@
   metrics_.device_scale_factor = device_scale_factor;
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
 std::unique_ptr<cc::CompositorFrame>
 DefaultPlatformDisplay::GenerateCompositorFrame() {
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
   render_pass->damage_rect = dirty_rect_;
   render_pass->output_rect = gfx::Rect(metrics_.size_in_pixels);
 
-  std::set<WindowId> referenced_window_ids;
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
-                 1.0f, &referenced_window_ids);
+                 1.0f);
 
   std::unique_ptr<cc::DelegatedFrameData> frame_data(
       new cc::DelegatedFrameData);
   frame_data->device_scale_factor = metrics_.device_scale_factor;
   frame_data->render_pass_list.push_back(std::move(render_pass));
 
   std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   frame->delegated_frame_data = std::move(frame_data);
   return frame;
 }
@@ skipping 80 matching lines @@
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> output_request) {
   if (display_compositor_)
     display_compositor_->RequestCopyOfOutput(std::move(output_request));
 }
 
 }  // namespace ws
 
 }  // namespace mus