Add support to delay sending SwapbufferAck as needed.

content/common/gpu/image_transport_surface.cc

 // Copyright (c) 2012 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/common/gpu/image_transport_surface.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 195 matching lines @@
 void PassThroughImageTransportSurface::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++)
     latency_info_.push_back(latency_info[i]);
 }
 
 bool PassThroughImageTransportSurface::SwapBuffers() {
   // GetVsyncValues before SwapBuffers to work around Mali driver bug:
   // crbug.com/223558.
   SendVSyncUpdateIfAvailable();
-  bool result = gfx::GLSurfaceAdapter::SwapBuffers();
-  for (size_t i = 0; i < latency_info_.size(); i++) {
-    latency_info_[i].AddLatencyNumber(
-        ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
-  }
-
-  helper_->SwapBuffersCompleted(latency_info_);
-  latency_info_.clear();
-  return result;
+  return gfx::GLSurfaceAdapter::SwapBuffersAsync(
+      base::Bind(&PassThroughImageTransportSurface::SwapBuffersCallBack,
+          base::Unretained(this)));

[piman, 2014/12/19 04:10:36]

Why is Unretained safe? Can you add a comment?

[kalyank, 2014/12/19 08:43:03]

Weakptr has a requirement that the callback be posted on same sequenced thread
and with Unretained it's Manual life time management. After a second thought,
Weakptr  looks a better choice with an added restriction here that the callback
needs to be run in Gpu main thread ?

[piman, 2014/12/19 20:32:54]

Right, that's a strong requirement. It wouldn't be ok to call
PassThroughImageTransportSurface::SwapBuffersCallBack on an arbitrary thread.

Weakptr is fine. Unretained is possible if we can ensure that the lifetime of
|this| outlives the callback - i.e. all implementations of GLSurface need to be
able to guarantee that.

 }
 
 bool PassThroughImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   SendVSyncUpdateIfAvailable();
-  bool result = gfx::GLSurfaceAdapter::PostSubBuffer(x, y, width, height);
+  return gfx::GLSurfaceAdapter::PostSubBufferAsync(x, y, width, height,
+      base::Bind(&PassThroughImageTransportSurface::SwapBuffersCallBack,
+          base::Unretained(this)));

[piman, 2014/12/19 04:10:36]

same thing here wrt Unretained.

+}
+
+void PassThroughImageTransportSurface::SwapBuffersCallBack() {
   for (size_t i = 0; i < latency_info_.size(); i++) {
     latency_info_[i].AddLatencyNumber(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0);
   }
 
   helper_->SwapBuffersCompleted(latency_info_);
   latency_info_.clear();
-  return result;
 }
 
 bool PassThroughImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (!did_set_swap_interval_) {
     ImageTransportHelper::SetSwapInterval(context);
     did_set_swap_interval_ = true;
   }
   return true;
 }
 
@@ skipping 22 matching lines @@
 void PassThroughImageTransportSurface::SendVSyncUpdateIfAvailable() {
   gfx::VSyncProvider* vsync_provider = GetVSyncProvider();
   if (vsync_provider) {
     vsync_provider->GetVSyncParameters(
       base::Bind(&ImageTransportHelper::SendUpdateVSyncParameters,
                  helper_->AsWeakPtr()));
   }
 }
 
 }  // namespace content