sync compositor: Add output_surface_id

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 "content/common/android/sync_compositor_messages.h"
@@ skipping 200 matching lines @@
         &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, reply_message);
+    SendDemandDrawHwReply(&empty_frame, 0u, reply_message);
     inside_receive_ = false;
   } else {
     DeliverMessages();
   }
 }
 
-void SynchronousCompositorProxy::SwapBuffersHw(cc::CompositorFrame* frame) {
+void SynchronousCompositorProxy::SwapBuffersHw(uint32_t output_surface_id,
+                                               cc::CompositorFrame* frame) {
   DCHECK(inside_receive_);
   DCHECK(hardware_draw_reply_);
   DCHECK(frame);
-  SendDemandDrawHwReply(frame, hardware_draw_reply_);
+  SendDemandDrawHwReply(frame, output_surface_id, hardware_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawHwReply(
     cc::CompositorFrame* frame,
+    uint32_t output_surface_id,
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
-  // Not using WriteParams because cc::CompositorFrame is not copy-able.
-  IPC::ParamTraits<SyncCompositorCommonRendererParams>::Write(
-      reply_message, common_renderer_params);
-  IPC::ParamTraits<cc::CompositorFrame>::Write(reply_message, *frame);
+  SyncCompositorMsg_DemandDrawHw::WriteReplyParams(
+      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 96 matching lines @@
   SendDemandDrawSwReply(true, frame, software_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawSwReply(
     bool success,
     cc::CompositorFrame* frame,
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
-  // Not using WriteParams because cc::CompositorFrame is not copy-able.
-  IPC::ParamTraits<bool>::Write(reply_message, success);
-  IPC::ParamTraits<SyncCompositorCommonRendererParams>::Write(
-      reply_message, common_renderer_params);
-  IPC::ParamTraits<cc::CompositorFrame>::Write(reply_message, *frame);
+  SyncCompositorMsg_DemandDrawSw::WriteReplyParams(
+      reply_message, success, common_renderer_params, *frame);
   Send(reply_message);
 }
 
-void SynchronousCompositorProxy::SwapBuffers(cc::CompositorFrame* frame) {
+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_) {
-    SwapBuffersHw(frame);
+    SwapBuffersHw(output_surface_id, frame);
   } else if (software_draw_reply_) {
     SwapBuffersSw(frame);
   }
 }
 
 void SynchronousCompositorProxy::OnComputeScroll(
     const SyncCompositorCommonBrowserParams& common_params,
     base::TimeTicks animation_time) {
   ProcessCommonParams(common_params);
   if (need_animate_scroll_) {
@@ skipping 18 matching lines @@
   }
   if (common_params.update_root_scroll_offset &&
       total_scroll_offset_ != common_params.root_scroll_offset) {
     total_scroll_offset_ = common_params.root_scroll_offset;
     input_handler_proxy_->SynchronouslySetRootScrollOffset(
         total_scroll_offset_);
   }
   begin_frame_source_->SetBeginFrameSourcePaused(
       common_params.begin_frame_source_paused);
   if (!common_params.ack.resources.empty()) {
-    output_surface_->ReturnResources(common_params.ack);
+    output_surface_->ReturnResources(
+        common_params.output_surface_id_for_returned_resources,
+        common_params.ack);
   }
 }
 
 }  // namespace content