Getting rid of DelegatedFrameData

Note: From now on, the concept of "null" compositor frame (a compositor frame with a null delegated frame data) is gone. You should use base::Optional<CompositorFrame> instead.

BUG=653741

Review-Url: https://codereview.chromium.org/2449853004
Cr-Commit-Position: refs/heads/master@{#428591}

android_webview/browser/browser_view_renderer.cc

@@ -309,8 +309,8 @@ void BrowserViewRenderer::ReturnUnusedResource(
     return;
 
   cc::ReturnedResourceArray resources;
-  cc::TransferableResource::ReturnResources(
-      child_frame->frame->delegated_frame_data->resource_list, &resources);
+  cc::TransferableResource::ReturnResources(child_frame->frame->resource_list,
+                                            &resources);
   content::SynchronousCompositor* compositor =
       FindCompositor(child_frame->compositor_id);
   if (compositor && !resources.empty())

android_webview/browser/hardware_renderer.cc

@@ -123,8 +123,7 @@ void HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info) {
         std::move(child_frame_->frame);
 
     gfx::Size frame_size =
-        child_compositor_frame->delegated_frame_data->render_pass_list.back()
-            ->output_rect.size();
+        child_compositor_frame->render_pass_list.back()->output_rect.size();
     bool size_changed = frame_size != frame_size_;
     frame_size_ = frame_size;
     if (child_id_.is_null() || size_changed) {
@@ -176,10 +175,7 @@ void HardwareRenderer::DestroySurface() {
   DCHECK(surface_factory_);
 
   // Submit an empty frame to force any existing resources to be returned.
-  cc::CompositorFrame empty_frame;
-  empty_frame.delegated_frame_data =
-      base::WrapUnique(new cc::DelegatedFrameData);
-  surface_factory_->SubmitCompositorFrame(child_id_, std::move(empty_frame),
+  surface_factory_->SubmitCompositorFrame(child_id_, cc::CompositorFrame(),
                                           cc::SurfaceFactory::DrawCallback());
 
   surfaces_->RemoveChildId(cc::SurfaceId(frame_sink_id_, child_id_));
@@ -202,8 +198,7 @@ void HardwareRenderer::ReturnResourcesInChildFrame() {
   if (child_frame_.get() && child_frame_->frame.get()) {
     cc::ReturnedResourceArray resources_to_return;
     cc::TransferableResource::ReturnResources(
-        child_frame_->frame->delegated_frame_data->resource_list,
-        &resources_to_return);
+        child_frame_->frame->resource_list, &resources_to_return);
 
     // The child frame's compositor id is not necessarily same as
     // compositor_id_.

android_webview/browser/surfaces_instance.cc

@@ -133,11 +133,8 @@ void SurfacesInstance::DrawAndSwap(const gfx::Size& viewport,
   surface_quad->SetNew(quad_state, gfx::Rect(quad_state->quad_layer_bounds),
                        gfx::Rect(quad_state->quad_layer_bounds), child_id);
 
-  std::unique_ptr<cc::DelegatedFrameData> delegated_frame(
-      new cc::DelegatedFrameData);
-  delegated_frame->render_pass_list.push_back(std::move(render_pass));
   cc::CompositorFrame frame;
-  frame.delegated_frame_data = std::move(delegated_frame);
+  frame.render_pass_list.push_back(std::move(render_pass));
   frame.metadata.referenced_surfaces = child_ids_;
 
   if (root_id_.is_null()) {
@@ -170,8 +167,6 @@ void SurfacesInstance::RemoveChildId(const cc::SurfaceId& child_id) {
 
 void SurfacesInstance::SetEmptyRootFrame() {
   cc::CompositorFrame empty_frame;
-  empty_frame.delegated_frame_data =
-      base::WrapUnique(new cc::DelegatedFrameData);
   empty_frame.metadata.referenced_surfaces = child_ids_;
   surface_factory_->SubmitCompositorFrame(root_id_, std::move(empty_frame),
                                           cc::SurfaceFactory::DrawCallback());

android_webview/browser/test/rendering_test.cc

@@ -112,13 +112,11 @@ content::SynchronousCompositor* RenderingTest::ActiveCompositor() const {
 std::unique_ptr<cc::CompositorFrame> RenderingTest::ConstructEmptyFrame() {
   std::unique_ptr<cc::CompositorFrame> compositor_frame(
       new cc::CompositorFrame);
-  std::unique_ptr<cc::DelegatedFrameData> frame(new cc::DelegatedFrameData);
   std::unique_ptr<cc::RenderPass> root_pass(cc::RenderPass::Create());
   gfx::Rect viewport(browser_view_renderer_->size());
   root_pass->SetNew(cc::RenderPassId(1, 1), viewport, viewport,
                     gfx::Transform());
-  frame->render_pass_list.push_back(std::move(root_pass));
-  compositor_frame->delegated_frame_data = std::move(frame);
+  compositor_frame->render_pass_list.push_back(std::move(root_pass));
   return compositor_frame;
 }
 
@@ -127,7 +125,7 @@ std::unique_ptr<cc::CompositorFrame> RenderingTest::ConstructFrame(
   std::unique_ptr<cc::CompositorFrame> compositor_frame(ConstructEmptyFrame());
   cc::TransferableResource resource;
   resource.id = resource_id;
-  compositor_frame->delegated_frame_data->resource_list.push_back(resource);
+  compositor_frame->resource_list.push_back(resource);
   return compositor_frame;
 }
 

blimp/client/core/compositor/blimp_compositor.cc

@@ -262,8 +262,7 @@ void BlimpCompositor::SubmitCompositorFrame(cc::CompositorFrame frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
-  cc::RenderPass* root_pass =
-      frame.delegated_frame_data->render_pass_list.back().get();
+  cc::RenderPass* root_pass = frame.render_pass_list.back().get();
   gfx::Size surface_size = root_pass->output_rect.size();
 
   if (local_frame_id_.is_null() || current_surface_size_ != surface_size) {

cc/BUILD.gn

@@ -237,8 +237,6 @@ component("cc") {
     "output/copy_output_request.h",
     "output/copy_output_result.cc",
     "output/copy_output_result.h",
-    "output/delegated_frame_data.cc",
-    "output/delegated_frame_data.h",
     "output/direct_renderer.cc",
     "output/direct_renderer.h",
     "output/dynamic_geometry_binding.cc",

cc/ipc/cc_param_traits.cc

@@ -671,62 +671,9 @@ void ParamTraits<cc::SurfaceId>::Log(const param_type& p, std::string* l) {
   l->append(")");
 }
 
-namespace {
-enum CompositorFrameType {
-  NO_FRAME,
-  DELEGATED_FRAME,
-};
-}
-
 void ParamTraits<cc::CompositorFrame>::Write(base::Pickle* m,
                                              const param_type& p) {
   WriteParam(m, p.metadata);
-  if (p.delegated_frame_data) {
-    WriteParam(m, static_cast<int>(DELEGATED_FRAME));
-    WriteParam(m, *p.delegated_frame_data);
-  } else {
-    WriteParam(m, static_cast<int>(NO_FRAME));
-  }
-}
-
-bool ParamTraits<cc::CompositorFrame>::Read(const base::Pickle* m,
-                                            base::PickleIterator* iter,
-                                            param_type* p) {
-  if (!ReadParam(m, iter, &p->metadata))
-    return false;
-
-  int compositor_frame_type;
-  if (!ReadParam(m, iter, &compositor_frame_type))
-    return false;
-
-  switch (compositor_frame_type) {
-    case DELEGATED_FRAME:
-      p->delegated_frame_data.reset(new cc::DelegatedFrameData());
-      if (!ReadParam(m, iter, p->delegated_frame_data.get()))
-        return false;
-      break;
-    case NO_FRAME:
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-
-void ParamTraits<cc::CompositorFrame>::Log(const param_type& p,
-                                           std::string* l) {
-  l->append("CompositorFrame(");
-  LogParam(p.metadata, l);
-  l->append(", ");
-  if (p.delegated_frame_data)
-    LogParam(*p.delegated_frame_data, l);
-  l->append(")");
-}
-
-void ParamTraits<cc::DelegatedFrameData>::Write(base::Pickle* m,
-                                                const param_type& p) {
-  DCHECK_NE(0u, p.render_pass_list.size());
-
   size_t to_reserve = 0u;
   to_reserve += p.resource_list.size() * sizeof(cc::TransferableResource);
   for (const auto& pass : p.render_pass_list) {
@@ -745,9 +692,12 @@ void ParamTraits<cc::DelegatedFrameData>::Write(base::Pickle* m,
   }
 }
 
-bool ParamTraits<cc::DelegatedFrameData>::Read(const base::Pickle* m,
-                                               base::PickleIterator* iter,
-                                               param_type* p) {
+bool ParamTraits<cc::CompositorFrame>::Read(const base::Pickle* m,
+                                            base::PickleIterator* iter,
+                                            param_type* p) {
+  if (!ReadParam(m, iter, &p->metadata))
+    return false;
+
   const size_t kMaxRenderPasses = 10000;
   const size_t kMaxSharedQuadStateListSize = 100000;
   const size_t kMaxQuadListSize = 1000000;
@@ -757,7 +707,7 @@ bool ParamTraits<cc::DelegatedFrameData>::Read(const base::Pickle* m,
   uint32_t num_render_passes;
   if (!ReadParam(m, iter, &p->resource_list) ||
       !ReadParam(m, iter, &num_render_passes) ||
-      num_render_passes > kMaxRenderPasses || num_render_passes == 0)
+      num_render_passes > kMaxRenderPasses)
     return false;
   for (uint32_t i = 0; i < num_render_passes; ++i) {
     uint32_t quad_list_size;
@@ -785,12 +735,15 @@ bool ParamTraits<cc::DelegatedFrameData>::Read(const base::Pickle* m,
     pass_set.insert(render_pass->id);
     p->render_pass_list.push_back(std::move(render_pass));
   }
+
   return true;
 }
 
-void ParamTraits<cc::DelegatedFrameData>::Log(const param_type& p,
-                                              std::string* l) {
-  l->append("DelegatedFrameData(");
+void ParamTraits<cc::CompositorFrame>::Log(const param_type& p,
+                                           std::string* l) {
+  l->append("CompositorFrame(");
+  LogParam(p.metadata, l);
+  l->append(", ");
   LogParam(p.resource_list, l);
   l->append(", [");
   for (size_t i = 0; i < p.render_pass_list.size(); ++i) {

cc/ipc/cc_param_traits.h

@@ -113,16 +113,6 @@ struct CC_IPC_EXPORT ParamTraits<cc::CompositorFrame> {
   static void Log(const param_type& p, std::string* l);
 };
 
-template <>
-struct CC_IPC_EXPORT ParamTraits<cc::DelegatedFrameData> {
-  typedef cc::DelegatedFrameData param_type;
-  static void Write(base::Pickle* m, const param_type& p);
-  static bool Read(const base::Pickle* m,
-                   base::PickleIterator* iter,
-                   param_type* p);
-  static void Log(const param_type& p, std::string* l);
-};
-
 template <>
 struct CC_IPC_EXPORT ParamTraits<cc::DrawQuad::Resources> {
   typedef cc::DrawQuad::Resources param_type;

cc/ipc/cc_param_traits_unittest.cc

@@ -21,7 +21,7 @@
 #include "base/file_descriptor_posix.h"
 #endif
 
-using cc::DelegatedFrameData;
+using cc::CompositorFrame;
 using cc::DebugBorderDrawQuad;
 using cc::DrawQuad;
 using cc::FilterOperation;
@@ -430,16 +430,15 @@ TEST_F(CCParamTraitsTest, AllQuads) {
     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in);
   }
 
-  DelegatedFrameData frame_in;
+  CompositorFrame frame_in;
   frame_in.render_pass_list.push_back(std::move(child_pass_in));
   frame_in.render_pass_list.push_back(std::move(pass_in));
 
-  IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
+  IPC::ParamTraits<CompositorFrame>::Write(&msg, frame_in);
 
-  DelegatedFrameData frame_out;
+  CompositorFrame frame_out;
   base::PickleIterator iter(msg);
-  EXPECT_TRUE(
-      IPC::ParamTraits<DelegatedFrameData>::Read(&msg, &iter, &frame_out));
+  EXPECT_TRUE(IPC::ParamTraits<CompositorFrame>::Read(&msg, &iter, &frame_out));
 
   // Make sure the out and cmp RenderPasses match.
   std::unique_ptr<RenderPass> child_pass_out =
@@ -523,16 +522,15 @@ TEST_F(CCParamTraitsTest, UnusedSharedQuadStates) {
   ASSERT_EQ(5u, pass_in->shared_quad_state_list.size());
   ASSERT_EQ(2u, pass_in->quad_list.size());
 
-  DelegatedFrameData frame_in;
+  CompositorFrame frame_in;
   frame_in.render_pass_list.push_back(std::move(pass_in));
 
   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
-  IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
+  IPC::ParamTraits<CompositorFrame>::Write(&msg, frame_in);
 
-  DelegatedFrameData frame_out;
+  CompositorFrame frame_out;
   base::PickleIterator iter(msg);
-  EXPECT_TRUE(
-      IPC::ParamTraits<DelegatedFrameData>::Read(&msg, &iter, &frame_out));
+  EXPECT_TRUE(IPC::ParamTraits<CompositorFrame>::Read(&msg, &iter, &frame_out));
 
   std::unique_ptr<RenderPass> pass_out =
       std::move(frame_out.render_pass_list[0]);
@@ -596,17 +594,16 @@ TEST_F(CCParamTraitsTest, Resources) {
   renderpass_in->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
                         gfx::Transform());
 
-  DelegatedFrameData frame_in;
+  CompositorFrame frame_in;
   frame_in.resource_list.push_back(arbitrary_resource1);
   frame_in.resource_list.push_back(arbitrary_resource2);
   frame_in.render_pass_list.push_back(std::move(renderpass_in));
 
-  IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
+  IPC::ParamTraits<CompositorFrame>::Write(&msg, frame_in);
 
-  DelegatedFrameData frame_out;
+  CompositorFrame frame_out;
   base::PickleIterator iter(msg);
-  EXPECT_TRUE(
-      IPC::ParamTraits<DelegatedFrameData>::Read(&msg, &iter, &frame_out));
+  EXPECT_TRUE(IPC::ParamTraits<CompositorFrame>::Read(&msg, &iter, &frame_out));
 
   ASSERT_EQ(2u, frame_out.resource_list.size());
   Compare(arbitrary_resource1, frame_out.resource_list[0]);

cc/ipc/cc_serialization_perftest.cc

@@ -198,7 +198,6 @@ class CCSerializationPerfTest : public testing::Test {
                                      uint32_t num_passes,
                                      UseSingleSharedQuadState single_sqs) {
     CompositorFrame frame;
-    frame.delegated_frame_data.reset(new DelegatedFrameData);
 
     for (uint32_t i = 0; i < num_passes; ++i) {
       std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
@@ -214,8 +213,7 @@ class CCSerializationPerfTest : public testing::Test {
         quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
                      SK_ColorRED, kForceAntiAliasingOff);
       }
-      frame.delegated_frame_data->render_pass_list.push_back(
-          std::move(render_pass));
+      frame.render_pass_list.push_back(std::move(render_pass));
     }
     RunTest(test_name, std::move(frame));
   }

cc/ipc/compositor_frame_struct_traits.cc

@@ -17,9 +17,8 @@ bool StructTraits<cc::mojom::CompositorFrameDataView,
   if (!data.ReadMetadata(&out->metadata))
     return false;
 
-  out->delegated_frame_data.reset(new cc::DelegatedFrameData());
-  return data.ReadResources(&out->delegated_frame_data->resource_list) &&
-         data.ReadPasses(&out->delegated_frame_data->render_pass_list);
+  return data.ReadResources(&out->resource_list) &&
+         data.ReadPasses(&out->render_pass_list);
 }
 
 }  // namespace mojo

cc/ipc/compositor_frame_struct_traits.h

@@ -19,11 +19,11 @@ struct StructTraits<cc::mojom::CompositorFrameDataView, cc::CompositorFrame> {
 
   static const cc::TransferableResourceArray& resources(
       const cc::CompositorFrame& input) {
-    return input.delegated_frame_data->resource_list;
+    return input.resource_list;
   }
 
   static const cc::RenderPassList& passes(const cc::CompositorFrame& input) {
-    return input.delegated_frame_data->render_pass_list;
+    return input.render_pass_list;
   }
 
   static bool Read(cc::mojom::CompositorFrameDataView data,

cc/ipc/struct_traits_unittest.cc

@@ -195,10 +195,8 @@ TEST_F(StructTraitsTest, CompositorFrame) {
   input.metadata.root_scroll_offset = root_scroll_offset;
   input.metadata.page_scale_factor = page_scale_factor;
   input.metadata.scrollable_viewport_size = scrollable_viewport_size;
-  input.delegated_frame_data.reset(new DelegatedFrameData);
-  input.delegated_frame_data->render_pass_list.push_back(
-      std::move(render_pass));
-  input.delegated_frame_data->resource_list.push_back(resource);
+  input.render_pass_list.push_back(std::move(render_pass));
+  input.resource_list.push_back(resource);
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   CompositorFrame output;
@@ -209,18 +207,15 @@ TEST_F(StructTraitsTest, CompositorFrame) {
   EXPECT_EQ(page_scale_factor, output.metadata.page_scale_factor);
   EXPECT_EQ(scrollable_viewport_size, output.metadata.scrollable_viewport_size);
 
-  EXPECT_NE(nullptr, output.delegated_frame_data);
-  ASSERT_EQ(1u, output.delegated_frame_data->resource_list.size());
-  TransferableResource out_resource =
-      output.delegated_frame_data->resource_list[0];
+  ASSERT_EQ(1u, output.resource_list.size());
+  TransferableResource out_resource = output.resource_list[0];
   EXPECT_EQ(tr_id, out_resource.id);
   EXPECT_EQ(tr_format, out_resource.format);
   EXPECT_EQ(tr_filter, out_resource.filter);
   EXPECT_EQ(tr_size, out_resource.size);
 
-  EXPECT_EQ(1u, output.delegated_frame_data->render_pass_list.size());
-  const RenderPass* out_render_pass =
-      output.delegated_frame_data->render_pass_list[0].get();
+  EXPECT_EQ(1u, output.render_pass_list.size());
+  const RenderPass* out_render_pass = output.render_pass_list[0].get();
   ASSERT_EQ(2u, out_render_pass->quad_list.size());
   ASSERT_EQ(1u, out_render_pass->shared_quad_state_list.size());
 

cc/output/compositor_frame.cc

@@ -13,5 +13,4 @@ CompositorFrame::CompositorFrame(CompositorFrame&& other) = default;
 CompositorFrame::~CompositorFrame() {}
 
 CompositorFrame& CompositorFrame::operator=(CompositorFrame&& other) = default;
-
 }  // namespace cc