Adding status to swap complete

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/trace_event/trace_event.h"
@@ skipping 169 matching lines @@
 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]);
 }
 
-bool PassThroughImageTransportSurface::SwapBuffers() {
+gfx::SwapResult PassThroughImageTransportSurface::SwapBuffers() {
   // GetVsyncValues before SwapBuffers to work around Mali driver bug:
   // crbug.com/223558.
   SendVSyncUpdateIfAvailable();
 
   base::TimeTicks swap_time = base::TimeTicks::Now();
   for (auto& latency : latency_info_) {
     latency.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0, 0, swap_time, 1);
   }
 
   // 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
   // the calling thread only.
   std::vector<ui::LatencyInfo>* latency_info_ptr =
       new std::vector<ui::LatencyInfo>();
   latency_info_ptr->swap(latency_info_);
   return gfx::GLSurfaceAdapter::SwapBuffersAsync(base::Bind(
-      &PassThroughImageTransportSurface::SwapBuffersCallBack,
-      weak_ptr_factory_.GetWeakPtr(), base::Owned(latency_info_ptr)));
+             &PassThroughImageTransportSurface::SwapBuffersCallBack,
+             weak_ptr_factory_.GetWeakPtr(), base::Owned(latency_info_ptr)))
+             ? gfx::SwapResult::SWAP_ACK
+             : gfx::SwapResult::SWAP_FAILED;
 }
 
-bool PassThroughImageTransportSurface::PostSubBuffer(
-    int x, int y, int width, int height) {
+gfx::SwapResult PassThroughImageTransportSurface::PostSubBuffer(int x,
+                                                                int y,
+                                                                int width,
+                                                                int height) {
   SendVSyncUpdateIfAvailable();
 
   base::TimeTicks swap_time = base::TimeTicks::Now();
   for (auto& latency : latency_info_) {
     latency.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0, 0, swap_time, 1);
   }
 
   // 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
   // the calling thread only.
   std::vector<ui::LatencyInfo>* latency_info_ptr =
       new std::vector<ui::LatencyInfo>();
   latency_info_ptr->swap(latency_info_);
   return gfx::GLSurfaceAdapter::PostSubBufferAsync(
-      x, y, width, height,
-      base::Bind(&PassThroughImageTransportSurface::SwapBuffersCallBack,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(latency_info_ptr)));
+             x, y, width, height,
+             base::Bind(&PassThroughImageTransportSurface::SwapBuffersCallBack,
+                        weak_ptr_factory_.GetWeakPtr(),
+                        base::Owned(latency_info_ptr)))
+             ? gfx::SwapResult::SWAP_ACK
+             : gfx::SwapResult::SWAP_FAILED;
 }
 
 void PassThroughImageTransportSurface::SwapBuffersCallBack(
-    std::vector<ui::LatencyInfo>* latency_info_ptr) {
+    std::vector<ui::LatencyInfo>* latency_info_ptr,
+    gfx::SwapResult result) {
   base::TimeTicks swap_ack_time = base::TimeTicks::Now();
   for (auto& latency : *latency_info_ptr) {
     latency.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0, 0,
         swap_ack_time, 1);
   }
 
-  helper_->stub()->SendSwapBuffersCompleted(*latency_info_ptr);
+  helper_->stub()->SendSwapBuffersCompleted(*latency_info_ptr, 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(&GpuCommandBufferStub::SendUpdateVSyncParameters,
                    helper_->stub()->AsWeakPtr()));
   }
 }
 
 }  // namespace content