WebView: Immediately ack and return resources for fallback ticks.

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 <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 179 matching lines @@
   // Intentional no-op: surface size is controlled by the embedder.
 }
 
 static void NoOpDrawCallback(cc::SurfaceDrawStatus s) {}
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
 
+  client_->DidSwapBuffers();

[boliu, 2016/07/07 21:30:31]

sync_client_->SwapBuffers sends the reply of the synchronous IPC to unblock the
UI thread, I don't know how expensive DidSwapBuffers, but probably better to not
have this here for regular draws.

+
+  if (fallback_tick_running_) {
+    client_->DidSwapBuffersComplete();
+    cc::ReturnedResourceArray return_resources;
+    cc::TransferableResource::ReturnResources(
+        frame.delegated_frame_data->resource_list, &return_resources);
+    ReturnResources(return_resources);

[boliu, 2016/07/07 21:30:31]

again, can we skip this and just DCHECK there are no resources?

[danakj, 2016/07/07 22:08:34]

DCHECKing empty, but still sending back the ack to the OutputSurface client.

+    return;
+  }
+
   cc::CompositorFrame swap_frame;
 
   if (in_software_draw_) {
     // The frame we send to the client is actually just the metadata. Preserve
     // the |frame| for the software path below.
     swap_frame.metadata = frame.metadata.Clone();
 
     if (delegated_surface_id_.is_null()) {
       delegated_surface_id_ = surface_id_allocator_->GenerateId();
       surface_factory_->Create(delegated_surface_id_);
     }
 
     display_->SetSurfaceId(delegated_surface_id_,
                            frame.metadata.device_scale_factor);
 
     gfx::Size frame_size =
         frame.delegated_frame_data->render_pass_list.back()->output_rect.size();
     display_->Resize(frame_size);
 
     surface_factory_->SubmitCompositorFrame(
         delegated_surface_id_, std::move(frame), base::Bind(&NoOpDrawCallback));
     display_->DrawAndSwap();
   } else {
+    // For hardware draws we send the whole frame to the client so it can draw
+    // the content in it.
     swap_frame = std::move(frame);
   }
 
-  if (!fallback_tick_running_) {
-    sync_client_->SwapBuffers(output_surface_id_, std::move(swap_frame));
-    DeliverMessages();
-  }
-  client_->DidSwapBuffers();
+  sync_client_->SwapBuffers(output_surface_id_, std::move(swap_frame));
+  DeliverMessages();
   did_swap_ = true;
 }
 
 void SynchronousCompositorOutputSurface::CancelFallbackTick() {
   fallback_tick_.Cancel();
   fallback_tick_pending_ = false;
 }
 
 void SynchronousCompositorOutputSurface::FallbackTickFired() {
   DCHECK(CalledOnValidThread());
@@ skipping 152 matching lines @@
   client_->ReclaimResources(&ack);
 }
 
 void SynchronousCompositorOutputSurface::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // Software output is synchronous and doesn't use a BeginFrameSource.
   NOTREACHED();
 }
 
 }  // namespace content