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 117 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_SynchronizeRendererState,
                         PopulateCommonParams)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_ComputeScroll, OnComputeScroll)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawHw,
-                                    DemandDrawHw)
+    //    IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawHw,
+    //                                    DemandDrawHw)
+    IPC_MESSAGE_HANDLER(CompositorMsg_DemandDrawHw, DemandDrawhw)
+
     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) {
@@ skipping 12 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.
-    SendDemandDrawHwReply(cc::CompositorFrame(), 0u, reply_message);
+    //
+    /* Instead of sending the sync reply, send an async message. */
+    //    SendDemandDrawHwReply(cc::CompositorFrame(), 1u, reply_message);
+    SyncCompositorCommonRendererParams params;

[boliu, 2016/07/24 17:33:54]

this change should be done in SendDemandDrawHwReply

[ojars, 2016/07/28 22:53:55]

Done.

+    PolutateCommonParams(&params);
+    Send(new CompositorHostMessage_Frame(routing_id, params, output_surface_id,
+                                         frame));
     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_);
@@ skipping 146 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