sync compositor: Add output_surface_id plumbing

The output_surface_id is unique for a particular renderer compositor
instance. It is used to avoid returning resources from lost context to
compositor with new context.

Plumb output_surface_id from SynchronousOutputSurface all the way
to android_webview::HardwareRenderer. To avoid having to send down
a map<id, resource list>, a simpler guarantee is to assume the
output_surface_id is increasing, so only need to return resources
of with highest output surface id and drop resources other resources.

BUG=592744

Review URL: https://codereview.chromium.org/1769913003

Cr-Commit-Position: refs/heads/master@{#382636}

4 files changed, 88 insertions, 8 deletions

diff --git a/content/public/browser/android/synchronous_compositor.cc b/content/public/browser/android/synchronous_compositor.cc
new file mode 100644
index 0000000..4e52b61
--- /dev/null
+++ b/content/public/browser/android/synchronous_compositor.cc
@@ -0,0 +1,27 @@
+// Copyright 2016 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/public/browser/android/synchronous_compositor.h"
+
+#include <utility>
+
+#include "cc/output/compositor_frame.h"
+
+namespace content {
+
+SynchronousCompositor::Frame::Frame() : output_surface_id(0u) {}
+
+SynchronousCompositor::Frame::~Frame() {}
+
+SynchronousCompositor::Frame::Frame(Frame&& rhs)
+    : output_surface_id(rhs.output_surface_id), frame(std::move(rhs.frame)) {}
+
+SynchronousCompositor::Frame& SynchronousCompositor::Frame::operator=(
+    Frame&& rhs) {
+  output_surface_id = rhs.output_surface_id;
+  frame = std::move(rhs.frame);
+  return *this;
+}
+
+}  // namespace content
diff --git a/content/public/browser/android/synchronous_compositor.h b/content/public/browser/android/synchronous_compositor.h
index e0d09d8..431e1e1 100644
--- a/content/public/browser/android/synchronous_compositor.h
+++ b/content/public/browser/android/synchronous_compositor.h
@@ -47,9 +47,24 @@ class CONTENT_EXPORT SynchronousCompositor {
   static void SetGpuService(
       scoped_refptr<gpu::InProcessCommandBuffer::Service> service);
 
+  struct Frame {
+    Frame();
+    ~Frame();
+
+    // Movable type.
+    Frame(Frame&& rhs);
+    Frame& operator=(Frame&& rhs);
+
+    uint32_t output_surface_id;
+    scoped_ptr<cc::CompositorFrame> frame;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Frame);
+  };
+
   // "On demand" hardware draw. The content is first clipped to |damage_area|,
   // then transformed through |transform|, and finally clipped to |view_size|.
-  virtual scoped_ptr<cc::CompositorFrame> DemandDrawHw(
+  virtual Frame DemandDrawHw(
       const gfx::Size& surface_size,
       const gfx::Transform& transform,
       const gfx::Rect& viewport,
@@ -59,7 +74,8 @@ class CONTENT_EXPORT SynchronousCompositor {
 
   // For delegated rendering, return resources from parent compositor to this.
   // Note that all resources must be returned before ReleaseHwDraw.
-  virtual void ReturnResources(const cc::CompositorFrameAck& frame_ack) = 0;
+  virtual void ReturnResources(uint32_t output_surface_id,
+                               const cc::CompositorFrameAck& frame_ack) = 0;
 
   // "On demand" SW draw, into the supplied canvas (observing the transform
   // and clip set there-in).
diff --git a/content/public/test/test_synchronous_compositor_android.cc b/content/public/test/test_synchronous_compositor_android.cc
index 9eff3ff..609cdf4 100644
--- a/content/public/test/test_synchronous_compositor_android.cc
+++ b/content/public/test/test_synchronous_compositor_android.cc
@@ -27,7 +27,7 @@ void TestSynchronousCompositor::SetClient(SynchronousCompositorClient* client) {
   }
 }
 
-scoped_ptr<cc::CompositorFrame> TestSynchronousCompositor::DemandDrawHw(
+SynchronousCompositor::Frame TestSynchronousCompositor::DemandDrawHw(
     const gfx::Size& surface_size,
     const gfx::Transform& transform,
     const gfx::Rect& viewport,
@@ -37,14 +37,35 @@ scoped_ptr<cc::CompositorFrame> TestSynchronousCompositor::DemandDrawHw(
   return std::move(hardware_frame_);
 }
 
+void TestSynchronousCompositor::ReturnResources(
+    uint32_t output_surface_id,
+    const cc::CompositorFrameAck& frame_ack) {
+  ReturnedResources returned_resources;
+  returned_resources.output_surface_id = output_surface_id;
+  returned_resources.resources = frame_ack.resources;
+  frame_ack_array_.push_back(returned_resources);
+}
+
+void TestSynchronousCompositor::SwapReturnedResources(FrameAckArray* array) {
+  DCHECK(array);
+  frame_ack_array_.swap(*array);
+}
+
 bool TestSynchronousCompositor::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(canvas);
   return true;
 }
 
 void TestSynchronousCompositor::SetHardwareFrame(
+    uint32_t output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
-  hardware_frame_ = std::move(frame);
+  hardware_frame_.output_surface_id = output_surface_id;
+  hardware_frame_.frame = std::move(frame);
 }
 
+TestSynchronousCompositor::ReturnedResources::ReturnedResources()
+    : output_surface_id(0u) {}
+
+TestSynchronousCompositor::ReturnedResources::~ReturnedResources() {}
+
 }  // namespace content
diff --git a/content/public/test/test_synchronous_compositor_android.h b/content/public/test/test_synchronous_compositor_android.h
index b9f0c85..613eda6 100644
--- a/content/public/test/test_synchronous_compositor_android.h
+++ b/content/public/test/test_synchronous_compositor_android.h
@@ -7,8 +7,11 @@
 
 #include <stddef.h>
 
+#include <vector>
+
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "cc/output/compositor_frame_ack.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/android/synchronous_compositor_client.h"
 
@@ -22,14 +25,15 @@ class CONTENT_EXPORT TestSynchronousCompositor : public SynchronousCompositor {
   void SetClient(SynchronousCompositorClient* client);
 
   // SynchronousCompositor overrides.
-  scoped_ptr<cc::CompositorFrame> DemandDrawHw(
+  SynchronousCompositor::Frame DemandDrawHw(
       const gfx::Size& surface_size,
       const gfx::Transform& transform,
       const gfx::Rect& viewport,
       const gfx::Rect& clip,
       const gfx::Rect& viewport_rect_for_tile_priority,
       const gfx::Transform& transform_for_tile_priority) override;
-  void ReturnResources(const cc::CompositorFrameAck& frame_ack) override {}
+  void ReturnResources(uint32_t output_surface_id,
+                       const cc::CompositorFrameAck& frame_ack) override;
   bool DemandDrawSw(SkCanvas* canvas) override;
   void SetMemoryPolicy(size_t bytes_limit) override {}
   void DidChangeRootLayerScrollOffset(
@@ -37,11 +41,23 @@ class CONTENT_EXPORT TestSynchronousCompositor : public SynchronousCompositor {
   void SetIsActive(bool is_active) override {}
   void OnComputeScroll(base::TimeTicks animate_time) override {}
 
-  void SetHardwareFrame(scoped_ptr<cc::CompositorFrame> frame);
+  void SetHardwareFrame(uint32_t output_surface_id,
+                        scoped_ptr<cc::CompositorFrame> frame);
+
+  struct ReturnedResources {
+    ReturnedResources();
+    ~ReturnedResources();
+
+    uint32_t output_surface_id;
+    cc::ReturnedResourceArray resources;
+  };
+  using FrameAckArray = std::vector<ReturnedResources>;
+  void SwapReturnedResources(FrameAckArray* array);
 
  private:
   SynchronousCompositorClient* client_;
-  scoped_ptr<cc::CompositorFrame> hardware_frame_;
+  SynchronousCompositor::Frame hardware_frame_;
+  FrameAckArray frame_ack_array_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSynchronousCompositor);
 };