sync compositor: Add output_surface_id

android_webview/browser/hardware_renderer.cc

 // Copyright 2014 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 "android_webview/browser/hardware_renderer.h"
 
 #include <utility>
 
 #include "android_webview/browser/aw_gl_surface.h"
 #include "android_webview/browser/aw_render_thread_context_provider.h"
@@ skipping 20 matching lines @@
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace android_webview {
 
 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_);
 
   cc::RendererSettings settings;
 
   // Should be kept in sync with compositor_impl_android.cc.
   settings.allow_antialiasing = false;
   settings.highp_threshold_min = 2048;
 
   // Webview does not own the surface so should not clear it.
@@ skipping 27 matching lines @@
 }
 
 void HardwareRenderer::CommitFrame() {
   TRACE_EVENT0("android_webview", "CommitFrame");
   scroll_offset_ = shared_renderer_state_->GetScrollOffsetOnRT();
   scoped_ptr<ChildFrame> child_frame =
       shared_renderer_state_->PassCompositorFrameOnRT();
   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());
   DCHECK(!child_frame_->frame->gl_frame_data);
 }
 
 void HardwareRenderer::DrawGL(AwDrawGLInfo* draw_info,
                               const ScopedAppGLStateRestore& gl_state) {
   TRACE_EVENT0("android_webview", "HardwareRenderer::DrawGL");
 
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   DCHECK(current_context) << "DrawGL called without EGLContext";
 
   // TODO(boliu): Handle context loss.
   if (last_egl_context_ != current_context)
     DLOG(WARNING) << "EGLContextChanged";
 
   // SurfaceFactory::SubmitCompositorFrame might call glFlush. So calling it
   // during "kModeSync" stage (which does not allow GL) might result in extra
   // 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())
         surface_factory_->Destroy(child_id_);
 
       root_id_ = cc::SurfaceId();
       child_id_ = cc::SurfaceId();
 
       // 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));
     }
 
     scoped_ptr<cc::CompositorFrame> child_compositor_frame =
         std::move(child_frame_->frame);
 
     // On Android we put our browser layers in physical pixels and set our
     // browser CC device_scale_factor to 1, so suppress the transform between
     // DIP and pixels.
@@ skipping 81 matching lines @@
     output_surface_ = output_surface_holder.get();
     display_->Initialize(std::move(output_surface_holder), nullptr);
   }
   output_surface_->SetGLState(gl_state);
   display_->SetExternalClip(clip);
   display_->DrawAndSwap();
 }
 
 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(
     cc::BeginFrameSource* begin_frame_source) {
   // TODO(tansell): Hook this up.
 }
 
 void HardwareRenderer::SetBackingFrameBufferObject(
     int framebuffer_binding_ext) {
   gl_surface_->SetBackingFrameBufferObject(framebuffer_binding_ext);
 }
 
 void HardwareRenderer::ReturnResourcesInChildFrame() {
   if (child_frame_.get() && child_frame_->frame.get()) {
     cc::ReturnedResourceArray resources_to_return;
     cc::TransferableResource::ReturnResources(
         child_frame_->frame->delegated_frame_data->resource_list,
         &resources_to_return);
 
     // 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