OnDrawHardware() implementation with async 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 17 matching lines @@
     : routing_id_(routing_id),
       sender_(sender),
       input_handler_proxy_(input_handler_proxy),
       use_in_process_zero_copy_software_draw_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kSingleProcess)),
       output_surface_(nullptr),
       inside_receive_(false),
       hardware_draw_reply_(nullptr),
       software_draw_reply_(nullptr),
+      hardware_draw_reply_async_(false),
       version_(0u),
       page_scale_factor_(0.f),
       min_page_scale_factor_(0.f),
       max_page_scale_factor_(0.f),
       need_animate_scroll_(false),
       need_invalidate_count_(0u),
       did_activate_pending_tree_count_(0u) {
   DCHECK(input_handler_proxy_);
   input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(this);
 }
@@ skipping 80 matching lines @@
 
 void SynchronousCompositorProxy::OnMessageReceived(
     const IPC::Message& message) {
   if (output_surface_ && output_surface_->OnMessageReceived(message))
     return;
 
   IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorProxy, message)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_ComputeScroll, OnComputeScroll)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawHw,
                                     DemandDrawHw)
+    IPC_MESSAGE_HANDLER(CompositorMsg_DemandDrawHw, DemandDrawHw_Async)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetSharedMemory, SetSharedMemory)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_ZeroSharedMemory, ZeroSharedMemory)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawSw,
                                     DemandDrawSw)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_ZoomBy, SynchronouslyZoomBy)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetScroll, SetScroll)
   IPC_END_MESSAGE_MAP()
 }
 
 bool SynchronousCompositorProxy::Send(IPC::Message* message) {
   return sender_->Send(message);
 }
 
+void SynchronousCompositorProxy::DemandDrawHw_Async(

[boliu, 2016/08/11 19:23:40]

this is mostly identical to DemandDrawHw so should merge them, ie both should
just call a private helper method that does the work

[ojars, 2016/08/23 02:15:42]

Done.

+    const SyncCompositorDemandDrawHwParams& params) {
+  //    const SyncCompositorDemandDrawHwParams& params,
+  //    IPC::Message* reply_message) {
+  DCHECK(!inside_receive_);
+  inside_receive_ = true;
+
+  //  SyncCompositorCommonRendererParams common_renderer_params;
+  //  PopulateCommonParams(&common_renderer_params);
+  //  CompositorMsg_DemandDrawHw::WriteReplyParams(
+  //      reply_message, common_renderer_params);
+  //  Send(reply_message);
+
+  if (output_surface_) {
+    base::AutoReset<bool> scoped_hardware_draw_reply_async(
+        &hardware_draw_reply_async_, true);
+    output_surface_->DemandDrawHw(params.viewport_size,
+                                  params.viewport_rect_for_tile_priority,
+                                  params.transform_for_tile_priority);
+  }
+
+  if (inside_receive_) {
+    // Did not swap.
+    SendDemandDrawHwReply_Async(cc::CompositorFrame(), 0u);
+    inside_receive_ = false;
+  }
+}
+
 void SynchronousCompositorProxy::DemandDrawHw(
     const SyncCompositorDemandDrawHwParams& params,
     IPC::Message* reply_message) {
   DCHECK(!inside_receive_);
   DCHECK(reply_message);
 
   inside_receive_ = true;
 
   if (output_surface_) {
     base::AutoReset<IPC::Message*> scoped_hardware_draw_reply(
         &hardware_draw_reply_, reply_message);
     output_surface_->DemandDrawHw(params.viewport_size,
                                   params.viewport_rect_for_tile_priority,
                                   params.transform_for_tile_priority);
   }
 
   if (inside_receive_) {
     // Did not swap.
     SendDemandDrawHwReply(cc::CompositorFrame(), 0u, reply_message);
     inside_receive_ = false;
   }
 }
 
+void SynchronousCompositorProxy::SwapBuffersHw_Async(
+    uint32_t output_surface_id,
+    cc::CompositorFrame frame) {
+  DCHECK(inside_receive_);
+  DCHECK(hardware_draw_reply_async_);
+  SendDemandDrawHwReply_Async(std::move(frame), output_surface_id);
+  inside_receive_ = false;
+}
+
 void SynchronousCompositorProxy::SwapBuffersHw(uint32_t output_surface_id,
                                                cc::CompositorFrame frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_);
   SendDemandDrawHwReply(std::move(frame), output_surface_id,
                         hardware_draw_reply_);
   inside_receive_ = false;
 }
 
+void SynchronousCompositorProxy::SendDemandDrawHwReply_Async(
+    cc::CompositorFrame frame,
+    uint32_t output_surface_id) {
+  Send(new CompositorHostMsg_Frame(routing_id_, output_surface_id, frame));
+}
+
 void SynchronousCompositorProxy::SendDemandDrawHwReply(
     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);
   Send(reply_message);
 }
@@ skipping 97 matching lines @@
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
   SyncCompositorMsg_DemandDrawSw::WriteReplyParams(
       reply_message, success, common_renderer_params, frame);
   Send(reply_message);
 }
 
 void SynchronousCompositorProxy::SwapBuffers(uint32_t output_surface_id,
                                              cc::CompositorFrame frame) {
-  DCHECK(hardware_draw_reply_ || software_draw_reply_);
-  DCHECK(!(hardware_draw_reply_ && software_draw_reply_));
-  if (hardware_draw_reply_) {
+  DCHECK(hardware_draw_reply_async_ || hardware_draw_reply_ ||
+         software_draw_reply_);
+  DCHECK(!((hardware_draw_reply_ || hardware_draw_reply_async_) &&
+           software_draw_reply_));

[boliu, 2016/08/11 19:23:40]

the DCHECKs were for exactly one of these things being set, this second one
doesn't do that anymore, in particular allows both the hardware draw ones to be
set at the same time

[ojars, 2016/08/23 02:15:42]

Done.

+  if (hardware_draw_reply_async_) {
+    SwapBuffersHw_Async(output_surface_id, std::move(frame));
+  } else if (hardware_draw_reply_) {
     SwapBuffersHw(output_surface_id, std::move(frame));
   } else if (software_draw_reply_) {
     SwapBuffersSw(std::move(frame));
   }
 }
 
 void SynchronousCompositorProxy::OnComputeScroll(
     base::TimeTicks animation_time) {
   if (need_animate_scroll_) {
     need_animate_scroll_ = false;
@@ skipping 13 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