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

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 240 matching lines @@
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
   if (ime)
     ime->SetImeVisibility(visible);
 }
 
 void DefaultPlatformDisplay::Draw() {
   if (!delegate_->GetRootWindow()->visible())
     return;
 
   // TODO(fsamuel): We should add a trace for generating a top level frame.
-  std::unique_ptr<cc::CompositorFrame> frame(GenerateCompositorFrame());
+  cc::CompositorFrame frame(GenerateCompositorFrame());
   frame_pending_ = true;
   if (display_compositor_) {
     display_compositor_->SubmitCompositorFrame(
         std::move(frame), base::Bind(&DefaultPlatformDisplay::DidDraw,
                                      weak_factory_.GetWeakPtr()));
   }
   dirty_rect_ = gfx::Rect();
 }
 
 void DefaultPlatformDisplay::DidDraw(cc::SurfaceDrawStatus status) {
@@ skipping 28 matching lines @@
   if (metrics_.size_in_pixels == size &&
       metrics_.device_scale_factor == device_scale_factor)
     return;
 
   ViewportMetrics old_metrics = metrics_;
   metrics_.size_in_pixels = size;
   metrics_.device_scale_factor = device_scale_factor;
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
-std::unique_ptr<cc::CompositorFrame>
-DefaultPlatformDisplay::GenerateCompositorFrame() {
+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);
 
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
                  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);
+  cc::CompositorFrame frame;
+  frame.delegated_frame_data = std::move(frame_data);
   return frame;
 }
 
 void DefaultPlatformDisplay::OnBoundsChanged(const gfx::Rect& new_bounds) {
   UpdateMetrics(new_bounds.size(), metrics_.device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnDamageRect(const gfx::Rect& damaged_region) {
   dirty_rect_.Union(damaged_region);
   WantToDraw();
@@ skipping 72 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