Switching to base::Optional<CompositorFrame> in Android's synchronous compositor IPC messages

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 170 matching lines @@
           &hardware_draw_reply_, reply_message);
       compositor_frame_sink_->DemandDrawHw(
           params.viewport_size, params.viewport_rect_for_tile_priority,
           params.transform_for_tile_priority);
     }
   }
 
   if (inside_receive_) {
     // Did not swap.
     if (!reply_message) {
-      SendDemandDrawHwReplyAsync(cc::CompositorFrame(), 0u);
+      SendDemandDrawHwReplyAsync(cc::CompositorFrame(), 0u, false);
     } else {
-      SendDemandDrawHwReply(cc::CompositorFrame(), 0u, reply_message);
+      SendDemandDrawHwReply(cc::CompositorFrame(), 0u, false, reply_message);
     }
     inside_receive_ = false;
   }
 }
 
 void SynchronousCompositorProxy::SubmitCompositorFrameHwAsync(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_async_);
-  SendDemandDrawHwReplyAsync(std::move(frame), compositor_frame_sink_id);
+  SendDemandDrawHwReplyAsync(std::move(frame), compositor_frame_sink_id, true);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SubmitCompositorFrameHw(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_);
-  SendDemandDrawHwReply(std::move(frame), compositor_frame_sink_id,
+  SendDemandDrawHwReply(std::move(frame), compositor_frame_sink_id, true,
                         hardware_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawHwReplyAsync(
     cc::CompositorFrame frame,
-    uint32_t compositor_frame_sink_id) {
-  Send(new SyncCompositorHostMsg_ReturnFrame(routing_id_,
-                                             compositor_frame_sink_id, frame));
+    uint32_t compositor_frame_sink_id,
+    bool has_swapped) {
+  Send(new SyncCompositorHostMsg_ReturnFrame(
+      routing_id_, compositor_frame_sink_id, frame, has_swapped));
 }
 
 void SynchronousCompositorProxy::SendDemandDrawHwReply(
     cc::CompositorFrame frame,
     uint32_t compositor_frame_sink_id,
+    bool has_swapped,
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
   SyncCompositorMsg_DemandDrawHw::WriteReplyParams(
-      reply_message, common_renderer_params, compositor_frame_sink_id, frame);
+      reply_message, common_renderer_params, compositor_frame_sink_id, frame,
+      has_swapped);
   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 133 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