sync compositor: Add output_surface_id

android_webview/browser/hardware_renderer.cc

Index: android_webview/browser/hardware_renderer.cc
diff --git a/android_webview/browser/hardware_renderer.cc b/android_webview/browser/hardware_renderer.cc
index aab7f168ec11225241bb2bb0aa53096668a76bb1..f0a4f85d988b9046b70e63958b6ff2be6932fcc2 100644
--- a/android_webview/browser/hardware_renderer.cc
+++ b/android_webview/browser/hardware_renderer.cc
@@ -38,7 +38,9 @@ HardwareRenderer::HardwareRenderer(SharedRendererState* state)
     : shared_renderer_state_(state),
       last_egl_context_(eglGetCurrentContext()),
       gl_surface_(new AwGLSurface),
-      compositor_id_(0),  // Valid compositor id starts at 1.
+      compositor_id_(0u),  // Valid compositor id starts at 1.
+      last_committed_output_surface_id_(0u),
+      last_submitted_output_surface_id_(0u),
       output_surface_(NULL) {
   DCHECK(last_egl_context_);
 
@@ -86,6 +88,7 @@ void HardwareRenderer::CommitFrame() {
   if (!child_frame.get())
     return;
 
+  last_committed_output_surface_id_ = child_frame->output_surface_id;
   ReturnResourcesInChildFrame();
   child_frame_ = std::move(child_frame);
   DCHECK(child_frame_->frame.get());
@@ -110,7 +113,8 @@ void HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info,
   // kModeProcess. Instead, submit the frame in "kModeDraw" stage to avoid
   // unnecessary kModeProcess.
   if (child_frame_.get() && child_frame_->frame.get()) {
-    if (compositor_id_ != child_frame_->compositor_id) {
+    if (compositor_id_ != child_frame_->compositor_id ||
+        last_submitted_output_surface_id_ != child_frame_->output_surface_id) {
       if (!root_id_.is_null())
         surface_factory_->Destroy(root_id_);
       if (!child_id_.is_null())
@@ -122,6 +126,7 @@ void HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info,
       // This will return all the resources to the previous compositor.
       surface_factory_.reset();
       compositor_id_ = child_frame_->compositor_id;
+      last_submitted_output_surface_id_ = child_frame_->output_surface_id;
       surface_factory_.reset(
           new cc::SurfaceFactory(surface_manager_.get(), this));
     }
@@ -223,7 +228,8 @@ void HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info,
 
 void HardwareRenderer::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
-  ReturnResourcesToCompositor(resources, compositor_id_);
+  ReturnResourcesToCompositor(resources, compositor_id_,
+                              last_submitted_output_surface_id_);

[no sievers, 2016/03/21 19:56:12]

Regarding using |last_submitted_output_surface_id_| is that really true that
we'll never commit but not draw, or skip a frame or so?

[boliu, 2016/03/21 21:35:49]

It totally is *not* true. CommitFrame can get called twice, and both times
committing new frames, but there is no DrawGL (ie submit) in between them.

That's why this is the submitted id rather than committed id.

Let's say:
Commit id 0 frame 0
Submit id 0 frame 0
Commit id 1 frame 0
Commit id 1 frame 1

At this point, "id 1 frame 0" will be returned from ReturnResourcesInChildFrame.

Submit id 1 frame 1

At this point, "id 0 frame 0" will be dropped here.

[no sievers, 2016/03/21 21:59:54]

Ah right, makes sense. But it's a bit hard to follow. Just wondering - would it
make things easier to follow if SharedRendererState would track the surface id
for which it's currently collecting resources?

[boliu, 2016/03/21 22:10:30]

Oh I totally tried that first. It's more complex this doing it here imo. So
options I considered:

1) SRS keep a map of maps:
compositor_id -> output_surface_id -> resources
too complex

2) SRS keep a map of compositor_id -> struct {output_surface_id, resources}
This doesn't work because SwapReturnedResourcesOnUI swaps the whole map, so the
output_surface_id info is lost. And fixing that is complex.

3) Add parallel compositor_id -> current output_surface_id map.
Then SRS will need to pay attention to compositor lifetimes, which is ugly.

 }
 
 void HardwareRenderer::SetBeginFrameSource(
@@ -246,15 +252,20 @@ void HardwareRenderer::ReturnResourcesInChildFrame() {
     // The child frame's compositor id is not necessarily same as
     // compositor_id_.
     ReturnResourcesToCompositor(resources_to_return,
-                                child_frame_->compositor_id);
+                                child_frame_->compositor_id,
+                                child_frame_->output_surface_id);
   }
   child_frame_.reset();
 }
 
 void HardwareRenderer::ReturnResourcesToCompositor(
     const cc::ReturnedResourceArray& resources,
-    uint32_t compositor_id) {
-  shared_renderer_state_->InsertReturnedResourcesOnRT(resources, compositor_id);
+    uint32_t compositor_id,
+    uint32_t output_surface_id) {
+  if (output_surface_id != last_committed_output_surface_id_)
+    return;
+  shared_renderer_state_->InsertReturnedResourcesOnRT(resources, compositor_id,
+                                                      output_surface_id);
 }
 
 }  // namespace android_webview