Getting rid of DelegatedFrameData

content/renderer/android/synchronous_compositor_frame_sink.cc

 // Copyright 2013 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/renderer/android/synchronous_compositor_frame_sink.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 200 matching lines @@
 }
 
 static void NoOpDrawCallback() {}
 
 void SynchronousCompositorFrameSink::SubmitCompositorFrame(
     cc::CompositorFrame frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
 
   if (fallback_tick_running_) {
-    DCHECK(frame.delegated_frame_data->resource_list.empty());
+    DCHECK(frame.resource_list.empty());
     cc::ReturnedResourceArray return_resources;
     ReturnResources(return_resources);
     did_submit_frame_ = true;
     return;
   }
 
   cc::CompositorFrame submit_frame;
 
   if (in_software_draw_) {
     // The frame we send to the client is actually just the metadata. Preserve
     // the |frame| for the software path below.
     submit_frame.metadata = frame.metadata.Clone();
 
     if (root_local_frame_id_.is_null()) {
       root_local_frame_id_ = surface_id_allocator_->GenerateId();
       surface_factory_->Create(root_local_frame_id_);
       child_local_frame_id_ = surface_id_allocator_->GenerateId();
       surface_factory_->Create(child_local_frame_id_);
     }
 
     display_->SetSurfaceId(cc::SurfaceId(kFrameSinkId, root_local_frame_id_),
                            frame.metadata.device_scale_factor);
 
     // The layer compositor should be giving a frame that covers the
     // |sw_viewport_for_current_draw_| but at 0,0.
     gfx::Size child_size = sw_viewport_for_current_draw_.size();
-    DCHECK(gfx::Rect(child_size) ==
-           frame.delegated_frame_data->render_pass_list.back()->output_rect);
+    DCHECK(gfx::Rect(child_size) == frame.render_pass_list.back()->output_rect);
 
     // Make a size that covers from 0,0 and includes the area coming from the
     // layer compositor.
     gfx::Size display_size(sw_viewport_for_current_draw_.right(),
                            sw_viewport_for_current_draw_.bottom());
     display_->Resize(display_size);
 
     // The offset for the child frame relative to the origin of the canvas being
     // drawn into.
     gfx::Transform child_transform;
     child_transform.Translate(
         gfx::Vector2dF(sw_viewport_for_current_draw_.OffsetFromOrigin()));
 
     // Make a root frame that embeds the frame coming from the layer compositor
     // and positions it based on the provided viewport.
     // TODO(danakj): We could apply the transform here instead of passing it to
     // the CompositorFrameSink client too? (We'd have to do the same for
     // hardware frames in SurfacesInstance?)
     cc::CompositorFrame embed_frame;
-    embed_frame.delegated_frame_data =
-        base::MakeUnique<cc::DelegatedFrameData>();
-    embed_frame.delegated_frame_data->render_pass_list.push_back(
-        cc::RenderPass::Create());
+    embed_frame.render_pass_list.push_back(cc::RenderPass::Create());
 
     // The embedding RenderPass covers the entire Display's area.
-    const auto& embed_render_pass =
-        embed_frame.delegated_frame_data->render_pass_list.back();
+    const auto& embed_render_pass = embed_frame.render_pass_list.back();
     embed_render_pass->SetAll(cc::RenderPassId(1, 1), gfx::Rect(display_size),
                               gfx::Rect(display_size), gfx::Transform(), false);
 
     // The RenderPass has a single SurfaceDrawQuad (and SharedQuadState for it).
     auto* shared_quad_state =
         embed_render_pass->CreateAndAppendSharedQuadState();
     auto* surface_quad =
         embed_render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
     shared_quad_state->SetAll(
         child_transform, child_size, gfx::Rect(child_size),
@@ skipping 177 matching lines @@
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorFrameSink::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // Software output is synchronous and doesn't use a BeginFrameSource.
   NOTREACHED();
 }
 
 }  // namespace content