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 101 matching lines @@
   manager_->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
 }
 
 void ImageTransportHelper::SendUpdateVSyncParameters(
       base::TimeTicks timebase, base::TimeDelta interval) {
   manager_->Send(new GpuHostMsg_UpdateVSyncParameters(stub_->surface_id(),
                                                       timebase,
                                                       interval));
 }
 
-void ImageTransportHelper::SwapBuffersCompleted(
-    const std::vector<ui::LatencyInfo>& latency_info) {
-  stub_->SwapBuffersCompleted(latency_info);
+void ImageTransportHelper::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);
+  }
+
+  stub_->SwapBuffersCompleted(latency_info_);
+  latency_info_.clear();
 }
 
 void ImageTransportHelper::SetPreemptByFlag(
     scoped_refptr<gpu::PreemptionFlag> preemption_flag) {
   stub_->channel()->SetPreemptByFlag(preemption_flag);
 }
 
 bool ImageTransportHelper::MakeCurrent() {
   gpu::gles2::GLES2Decoder* decoder = Decoder();
   if (!decoder)
@@ skipping 37 matching lines @@
   surface_->OnResize(size, scale_factor);
 
 #if defined(OS_ANDROID)
   manager_->gpu_memory_manager()->ScheduleManage(
       GpuMemoryManager::kScheduleManageNow);
 #endif
 }
 
 void ImageTransportHelper::SetLatencyInfo(
     const std::vector<ui::LatencyInfo>& latency_info) {
-  surface_->SetLatencyInfo(latency_info);

[piman, 2014/12/22 20:53:15]

Why this change? I don't understand...
It will break cases where |surface_| is not a PassThroughImageTransportSurface
(e.g. mac's ImageTransportSurfaceFBO).

Why not keeping the code where it is, but taking a WeakPtr on the
PassThroughImageTransportSurface?

[kalyank, 2014/12/23 09:12:32]

ImageTransportSurfaceAndroid inherits base::SupportsWeakPtr and
NullTransportSurface (NullTransportSurface inherits
PassThroughImageTransportSurface) . This was causing an issue, I tried changing
so that ImageTransportSurfaceAndroid doesn't inherit base::SupportsWeakPtr, but
it obviously complains in line 107 image_transport_surface_android.cc "
../../base/bind_internal.h:882:18: error: cannot initialize a parameter of type
'content::ImageTransportSurfaceAndroid *' with an rvalue of type
'content::PassThroughImageTransportSurface *'
    runnable.Run(weak_ptr.get());
"

Any suggestions ?

[kalyank, 2014/12/23 11:22:42]

Added ImageTransportHelperAndroid, which will be used by
ImageTransportSurfaceAndroid to handle callbacks.

+  for (size_t i = 0; i < latency_info.size(); i++)
+    latency_info_.push_back(latency_info[i]);
 }
 
 PassThroughImageTransportSurface::PassThroughImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     gfx::GLSurface* surface)
     : GLSurfaceAdapter(surface),
       did_set_swap_interval_(false) {
   helper_.reset(new ImageTransportHelper(this,
                                          manager,
                                          stub,
                                          gfx::kNullPluginWindow));
 }
 
 bool PassThroughImageTransportSurface::Initialize() {
   // The surface is assumed to have already been initialized.
   return helper_->Initialize();
 }
 
 void PassThroughImageTransportSurface::Destroy() {
   GLSurfaceAdapter::Destroy();
 }
 
 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]);
+  helper_->SetLatencyInfo(latency_info);
 }
 
 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;
+  // We use WeakPtr here to avoid manual management of life time of an instance
+  // of this class. Callback will not be called once the instance of this class
+  // is destroyed. However, this also means that the callback can be run on
+  // GPUMainThread only.
+  return gfx::GLSurfaceAdapter::SwapBuffersAsync(
+      base::Bind(&ImageTransportHelper::SwapBuffersCallBack,
+          helper_->AsWeakPtr()));
 }
 
 bool PassThroughImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   SendVSyncUpdateIfAvailable();
-  bool result = gfx::GLSurfaceAdapter::PostSubBuffer(x, y, width, height);
-  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;
+  // We use WeakPtr here to avoid manual management of life time of an instance
+  // of this class. Callback will not be called once the instance of this class
+  // is destroyed. However, this also means that the callback can be run on
+  // GPUMainThread only.
+  return gfx::GLSurfaceAdapter::PostSubBufferAsync(x, y, width, height,
+      base::Bind(&ImageTransportHelper::SwapBuffersCallBack,
+          helper_->AsWeakPtr()));
 }
 
 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