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

content/renderer/android/synchronous_compositor_proxy.cc

 // Copyright 2015 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_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "cc/ipc/cc_param_traits.h"
@@ skipping 149 matching lines @@
     base::AutoReset<IPC::Message*> scoped_hardware_draw_reply(
         &hardware_draw_reply_, reply_message);
     output_surface_->DemandDrawHw(params.surface_size, params.transform,
                                   params.viewport, params.clip,
                                   params.viewport_rect_for_tile_priority,
                                   params.transform_for_tile_priority);
   }
 
   if (inside_receive_) {
     // Did not swap.
-    cc::CompositorFrame empty_frame;
-    SendDemandDrawHwReply(&empty_frame, 0u, reply_message);
+    std::unique_ptr<cc::CompositorFrame> empty_frame(
+        cc::CompositorFrame::Create());
+    SendDemandDrawHwReply(std::move(empty_frame), 0u, reply_message);
     inside_receive_ = false;
   }
 }
 
-void SynchronousCompositorProxy::SwapBuffersHw(uint32_t output_surface_id,
-                                               cc::CompositorFrame* frame) {
+void SynchronousCompositorProxy::SwapBuffersHw(
+    uint32_t output_surface_id,
+    std::unique_ptr<cc::CompositorFrame> frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_);
-  DCHECK(frame);
-  SendDemandDrawHwReply(frame, output_surface_id, hardware_draw_reply_);
+  DCHECK(frame.get());

[danakj, 2016/06/23 20:34:41]

no .get() needed. unique_ptr is testable

+  SendDemandDrawHwReply(std::move(frame), output_surface_id,
+                        hardware_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawHwReply(
-    cc::CompositorFrame* frame,
+    std::unique_ptr<cc::CompositorFrame> frame,
     uint32_t output_surface_id,
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
   SyncCompositorMsg_DemandDrawHw::WriteReplyParams(
-      reply_message, common_renderer_params, output_surface_id, *frame);
+      reply_message, common_renderer_params, output_surface_id, frame);
   Send(reply_message);
 }
 
 struct SynchronousCompositorProxy::SharedMemoryWithSize {
   base::SharedMemory shm;
   const size_t buffer_size;
   bool zeroed;
 
   SharedMemoryWithSize(base::SharedMemoryHandle shm_handle, size_t buffer_size)
       : shm(shm_handle, false), buffer_size(buffer_size), zeroed(true) {}
@@ skipping 42 matching lines @@
     if (use_in_process_zero_copy_software_draw_) {
       DCHECK(sk_canvas_for_draw);
       output_surface_->DemandDrawSw(sk_canvas_for_draw);
     } else {
       DCHECK(!sk_canvas_for_draw);
       DoDemandDrawSw(params);
     }
   }
   if (inside_receive_) {
     // Did not swap.
-    cc::CompositorFrame empty_frame;
-    SendDemandDrawSwReply(false, &empty_frame, reply_message);
+    std::unique_ptr<cc::CompositorFrame> empty_frame(
+        cc::CompositorFrame::Create());
+    SendDemandDrawSwReply(false, std::move(empty_frame), reply_message);
     inside_receive_ = false;
   }
 }
 
 void SynchronousCompositorProxy::DoDemandDrawSw(
     const SyncCompositorDemandDrawSwParams& params) {
   DCHECK(output_surface_);
   DCHECK(software_draw_shm_->zeroed);
   software_draw_shm_->zeroed = false;
 
   SkImageInfo info =
       SkImageInfo::MakeN32Premul(params.size.width(), params.size.height());
   size_t stride = info.minRowBytes();
   size_t buffer_size = info.getSafeSize(stride);
   DCHECK_EQ(software_draw_shm_->buffer_size, buffer_size);
 
   SkBitmap bitmap;
   if (!bitmap.installPixels(info, software_draw_shm_->shm.memory(), stride))
     return;
   SkCanvas canvas(bitmap);
   canvas.setMatrix(params.transform.matrix());
   canvas.setClipRegion(SkRegion(gfx::RectToSkIRect(params.clip)));
 
   output_surface_->DemandDrawSw(&canvas);
 }
 
-void SynchronousCompositorProxy::SwapBuffersSw(cc::CompositorFrame* frame) {
+void SynchronousCompositorProxy::SwapBuffersSw(
+    std::unique_ptr<cc::CompositorFrame> frame) {
   DCHECK(inside_receive_);
   DCHECK(software_draw_reply_);
   DCHECK(frame);
-  SendDemandDrawSwReply(true, frame, software_draw_reply_);
+  SendDemandDrawSwReply(true, std::move(frame), software_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawSwReply(
     bool success,
-    cc::CompositorFrame* frame,
+    std::unique_ptr<cc::CompositorFrame> frame,
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
   SyncCompositorMsg_DemandDrawSw::WriteReplyParams(
-      reply_message, success, common_renderer_params, *frame);
+      reply_message, success, common_renderer_params, frame);
   Send(reply_message);
 }
 
-void SynchronousCompositorProxy::SwapBuffers(uint32_t output_surface_id,
-                                             cc::CompositorFrame* frame) {
+void SynchronousCompositorProxy::SwapBuffers(
+    uint32_t output_surface_id,
+    std::unique_ptr<cc::CompositorFrame> frame) {
   DCHECK(hardware_draw_reply_ || software_draw_reply_);
   DCHECK(!(hardware_draw_reply_ && software_draw_reply_));
   if (hardware_draw_reply_) {
-    SwapBuffersHw(output_surface_id, frame);
+    SwapBuffersHw(output_surface_id, std::move(frame));
   } else if (software_draw_reply_) {
-    SwapBuffersSw(frame);
+    SwapBuffersSw(std::move(frame));
   }
 }
 
 void SynchronousCompositorProxy::OnComputeScroll(
     base::TimeTicks animation_time) {
   if (need_animate_scroll_) {
     need_animate_scroll_ = false;
     input_handler_proxy_->SynchronouslyAnimate(animation_time);
   }
 }
@@ skipping 10 matching lines @@
 
 void SynchronousCompositorProxy::SetScroll(
     const gfx::ScrollOffset& new_total_scroll_offset) {
   if (total_scroll_offset_ == new_total_scroll_offset)
     return;
   total_scroll_offset_ = new_total_scroll_offset;
   input_handler_proxy_->SynchronouslySetRootScrollOffset(total_scroll_offset_);
 }
 
 }  // namespace content