Make cc::CompositorFrames movable [Part 2 of 2]

cc/surfaces/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 "cc/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 189 matching lines @@
 void Display::DidLoseOutputSurface() {
   if (scheduler_)
     scheduler_->OutputSurfaceLost();
   // WARNING: The client may delete the Display in this method call. Do not
   // make any additional references to members after this call.
   client_->DisplayOutputSurfaceLost();
 }
 
 void Display::UpdateRootSurfaceResourcesLocked() {
   Surface* surface = surface_manager_->GetSurfaceForId(current_surface_id_);
-  bool root_surface_resources_locked = !surface || !surface->GetEligibleFrame();
+  bool root_surface_resources_locked =
+      !surface || !surface->GetEligibleFrame().delegated_frame_data;
   if (scheduler_)
     scheduler_->SetRootSurfaceResourcesLocked(root_surface_resources_locked);
 }
 
 bool Display::DrawAndSwap() {
   TRACE_EVENT0("cc", "Display::DrawAndSwap");
 
   if (current_surface_id_.is_null()) {
     TRACE_EVENT_INSTANT0("cc", "No root surface.", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   InitializeRenderer();
   if (!output_surface_) {
     TRACE_EVENT_INSTANT0("cc", "No output surface", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  std::unique_ptr<CompositorFrame> frame =
-      aggregator_->Aggregate(current_surface_id_);
-  if (!frame) {
+  CompositorFrame frame = aggregator_->Aggregate(current_surface_id_);
+  if (!frame.delegated_frame_data) {
     TRACE_EVENT_INSTANT0("cc", "Empty aggregated frame.",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   // Run callbacks early to allow pipelining.
   for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
     Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
     if (surface)
       surface->RunDrawCallbacks(SurfaceDrawStatus::DRAWN);
   }
 
-  DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
+  DelegatedFrameData* frame_data = frame.delegated_frame_data.get();
 
-  frame->metadata.latency_info.insert(frame->metadata.latency_info.end(),
-                                      stored_latency_info_.begin(),
-                                      stored_latency_info_.end());
+  frame.metadata.latency_info.insert(frame.metadata.latency_info.end(),
+                                     stored_latency_info_.begin(),
+                                     stored_latency_info_.end());
   stored_latency_info_.clear();
   bool have_copy_requests = false;
   for (const auto& pass : frame_data->render_pass_list) {
     have_copy_requests |= !pass->copy_requests.empty();
   }
 
   gfx::Size surface_size;
   bool have_damage = false;
   if (!frame_data->render_pass_list.empty()) {
     RenderPass& last_render_pass = *frame_data->render_pass_list.back();
@@ skipping 34 matching lines @@
     renderer_->DrawFrame(&frame_data->render_pass_list, device_scale_factor_,
                          device_viewport_rect, device_clip_rect,
                          disable_picture_quad_image_filtering);
   } else {
     TRACE_EVENT_INSTANT0("cc", "Draw skipped.", TRACE_EVENT_SCOPE_THREAD);
   }
 
   bool should_swap = should_draw && size_matches;
   if (should_swap) {
     swapped_since_resize_ = true;
-    for (auto& latency : frame->metadata.latency_info) {
+    for (auto& latency : frame.metadata.latency_info) {
       TRACE_EVENT_WITH_FLOW1("input,benchmark", "LatencyInfo.Flow",
           TRACE_ID_DONT_MANGLE(latency.trace_id()),
           TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
           "step", "Display::DrawAndSwap");
     }
     benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
-    renderer_->SwapBuffers(std::move(frame->metadata));
+    renderer_->SwapBuffers(std::move(frame.metadata));
   } else {
     if (have_damage && !size_matches)
       aggregator_->SetFullDamageForSurface(current_surface_id_);
     TRACE_EVENT_INSTANT0("cc", "Swap skipped.", TRACE_EVENT_SCOPE_THREAD);
     stored_latency_info_.insert(stored_latency_info_.end(),
-                                frame->metadata.latency_info.begin(),
-                                frame->metadata.latency_info.end());
+                                frame.metadata.latency_info.begin(),
+                                frame.metadata.latency_info.end());
     DidSwapBuffers();
     DidSwapBuffersComplete();
   }
 
   return true;
 }
 
 void Display::DidSwapBuffers() {
   if (scheduler_)
     scheduler_->DidSwapBuffers();
@@ skipping 58 matching lines @@
 void Display::SetFullRootLayerDamage() {
   if (aggregator_ && !current_surface_id_.is_null())
     aggregator_->SetFullDamageForSurface(current_surface_id_);
 }
 
 void Display::OnSurfaceDamaged(SurfaceId surface_id, bool* changed) {
   if (aggregator_ &&
       aggregator_->previous_contained_surfaces().count(surface_id)) {
     Surface* surface = surface_manager_->GetSurfaceForId(surface_id);
     if (surface) {
-      const CompositorFrame* current_frame = surface->GetEligibleFrame();
-      if (!current_frame || !current_frame->delegated_frame_data ||
-          !current_frame->delegated_frame_data->resource_list.size()) {
+      const CompositorFrame& current_frame = surface->GetEligibleFrame();
+      if (!current_frame.delegated_frame_data ||
+          !current_frame.delegated_frame_data->resource_list.size()) {
         aggregator_->ReleaseResources(surface_id);
       }
     }
     if (scheduler_)
       scheduler_->SurfaceDamaged(surface_id);
     *changed = true;
   } else if (surface_id == current_surface_id_) {
     if (scheduler_)
       scheduler_->SurfaceDamaged(surface_id);
     *changed = true;
   }
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
 SurfaceId Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 }  // namespace cc