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(base::Optional<cc::CompositorFrame>(), 0u);

[boliu, 2016/10/27 19:52:16]

would nullptr work here?

     } else {
-      SendDemandDrawHwReply(cc::CompositorFrame(), 0u, reply_message);
+      SendDemandDrawHwReply(base::Optional<cc::CompositorFrame>(), 0u,
+                            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);
   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,
                         hardware_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawHwReplyAsync(
-    cc::CompositorFrame frame,
+    base::Optional<cc::CompositorFrame> frame,
     uint32_t compositor_frame_sink_id) {
   Send(new SyncCompositorHostMsg_ReturnFrame(routing_id_,
                                              compositor_frame_sink_id, frame));
 }
 
 void SynchronousCompositorProxy::SendDemandDrawHwReply(
-    cc::CompositorFrame frame,
+    base::Optional<cc::CompositorFrame> frame,
     uint32_t compositor_frame_sink_id,
     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);
   Send(reply_message);
 }
 
 struct SynchronousCompositorProxy::SharedMemoryWithSize {
@@ skipping 139 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