sync compositor: Add output_surface_id

content/renderer/android/synchronous_compositor_output_surface.cc

 // Copyright 2013 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_output_surface.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 46 matching lines @@
   SynchronousCompositorOutputSurface* surface_;
   SkCanvas null_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareDevice);
 };
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
     const scoped_refptr<cc::ContextProvider>& context_provider,
     const scoped_refptr<cc::ContextProvider>& worker_context_provider,
     int routing_id,
+    uint32_t output_surface_id,
     SynchronousCompositorRegistry* registry,
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::OutputSurface(
           context_provider,
           worker_context_provider,
           scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
       routing_id_(routing_id),
+      output_surface_id_(output_surface_id),
       registry_(registry),
       registered_(false),
       sync_client_(nullptr),
       current_sw_canvas_(nullptr),
       memory_policy_(0u),
       did_swap_(false),
       frame_swap_message_queue_(frame_swap_message_queue),
       fallback_tick_pending_(false),
       fallback_tick_running_(false) {
   thread_checker_.DetachFromThread();
@@ skipping 42 matching lines @@
                                                  float scale_factor,
                                                  bool has_alpha) {
   // Intentional no-op: surface size is controlled by the embedder.
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame* frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
   if (!fallback_tick_running_)
-    sync_client_->SwapBuffers(frame);
+    sync_client_->SwapBuffers(output_surface_id_, frame);
   client_->DidSwapBuffers();
   did_swap_ = true;
 }
 
 void SynchronousCompositorOutputSurface::CancelFallbackTick() {
   fallback_tick_.Cancel();
   fallback_tick_pending_ = false;
 }
 
 void SynchronousCompositorOutputSurface::FallbackTickFired() {
@@ skipping 73 matching lines @@
   gfx::Transform adjusted_transform = transform;
   adjusted_transform.matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
   did_swap_ = false;
   client_->OnDraw(adjusted_transform, viewport, clip, software_draw);
 
   if (did_swap_)
     client_->DidSwapBuffersComplete();
 }
 
 void SynchronousCompositorOutputSurface::ReturnResources(
+    uint32_t output_surface_id,
     const cc::CompositorFrameAck& frame_ack) {
-  ReclaimResources(&frame_ack);
+  if (output_surface_id_ == output_surface_id)
+    ReclaimResources(&frame_ack);
 }
 
 void SynchronousCompositorOutputSurface::SetMemoryPolicy(size_t bytes_limit) {
   DCHECK(CalledOnValidThread());
   bool became_zero = memory_policy_.bytes_limit_when_visible && !bytes_limit;
   bool became_non_zero =
       !memory_policy_.bytes_limit_when_visible && bytes_limit;
   memory_policy_.bytes_limit_when_visible = bytes_limit;
   memory_policy_.num_resources_limit = kNumResourcesLimit;
 
@@ skipping 23 matching lines @@
   scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
       frame_swap_message_queue_->AcquireSendMessageScope();
   frame_swap_message_queue_->DrainMessages(messages);
 }
 
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace content