gpu: Fix AsyncSwapBuffer tracing.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 908 matching lines @@
       GLint border);
 
   // Wrapper for SwapBuffers.
   void DoSwapBuffers();
 
   // Wrapper for SwapBuffersWithBoundsCHROMIUM.
   void DoSwapBuffersWithBoundsCHROMIUM(GLsizei count,
                                        const volatile GLint* rects);
 
   // Callback for async SwapBuffers.
+  void FinishAsyncSwapBuffers(gfx::SwapResult result);
   void FinishSwapBuffers(gfx::SwapResult result);
 
   void DoCommitOverlayPlanes();
 
   // Wrapper for SwapInterval.
   void DoSwapInterval(int interval);
 
   // Wrapper for CopyTexSubImage2D.
   void DoCopyTexSubImage2D(
       GLenum target,
@@ skipping 1425 matching lines @@
   int commands_to_process_;
 
   bool has_robustness_extension_;
   error::ContextLostReason context_lost_reason_;
   bool context_was_lost_;
   bool reset_by_robustness_extension_;
   bool supports_post_sub_buffer_;
   bool supports_swap_buffers_with_bounds_;
   bool supports_commit_overlay_planes_;
   bool supports_async_swap_;
+  uint32_t next_async_swap_id_ = 1;
+  uint32_t pending_swaps_ = 0;
   bool supports_dc_layers_ = false;
 
   // These flags are used to override the state of the shared feature_info_
   // member.  Because the same FeatureInfo instance may be shared among many
   // contexts, the assumptions on the availablity of extensions in WebGL
   // contexts may be broken.  These flags override the shared state to preserve
   // WebGL semantics.
   bool derivatives_explicitly_enabled_;
   bool frag_depth_explicitly_enabled_;
   bool draw_buffers_explicitly_enabled_;
@@ skipping 9493 matching lines @@
     bool is_offscreen = !!offscreen_target_frame_buffer_.get();
     ScopedFramebufferBinder binder(this, GetBoundDrawFramebufferServiceId());
     gpu_state_tracer_->TakeSnapshotWithCurrentFramebuffer(
         is_offscreen ? offscreen_size_ : surface_->GetSize());
   }
 
   ClearScheduleCALayerState();
   ClearScheduleDCLayerState();
 
   if (supports_async_swap_) {
-    TRACE_EVENT_ASYNC_BEGIN0("cc", "GLES2DecoderImpl::AsyncSwapBuffers", this);
+    DCHECK_LT(pending_swaps_, 2u);
+    uint32_t async_swap_id = next_async_swap_id_++;
+    ++pending_swaps_;
+    TRACE_EVENT_ASYNC_BEGIN0("gpu", "AsyncSwapBuffers", async_swap_id);
+
     surface_->PostSubBufferAsync(
         c.x, c.y, c.width, c.height,
-        base::Bind(&GLES2DecoderImpl::FinishSwapBuffers,
+        base::Bind(&GLES2DecoderImpl::FinishAsyncSwapBuffers,
                    base::AsWeakPtr(this)));
   } else {
     FinishSwapBuffers(surface_->PostSubBuffer(c.x, c.y, c.width, c.height));
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleScheduleOverlayPlaneCHROMIUM(
     uint32_t immediate_data_size,
@@ skipping 3597 matching lines @@
             offscreen_saved_color_texture_.get());
       }
 
       // Ensure the side effects of the copy are visible to the parent
       // context. There is no need to do this for ANGLE because it uses a
       // single D3D device for all contexts.
       if (!gl_version_info().is_angle)
         glFlush();
     }
   } else if (supports_async_swap_) {
-    TRACE_EVENT_ASYNC_BEGIN0("cc", "GLES2DecoderImpl::AsyncSwapBuffers", this);
-    surface_->SwapBuffersAsync(base::Bind(&GLES2DecoderImpl::FinishSwapBuffers,
-                                          base::AsWeakPtr(this)));
+    DCHECK_LT(pending_swaps_, 2u);
+    uint32_t async_swap_id = next_async_swap_id_++;
+    ++pending_swaps_;
+    TRACE_EVENT_ASYNC_BEGIN0("gpu", "AsyncSwapBuffers", async_swap_id);
+
+    surface_->SwapBuffersAsync(base::Bind(
+        &GLES2DecoderImpl::FinishAsyncSwapBuffers, base::AsWeakPtr(this)));
   } else {
     FinishSwapBuffers(surface_->SwapBuffers());
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
+void GLES2DecoderImpl::FinishAsyncSwapBuffers(gfx::SwapResult result) {
+  DCHECK(pending_swaps_);

[reveman, 2017/03/27 14:21:22]

nit: DCHECK_NE(pending_swaps_, 0u)

[Daniele Castagna, 2017/03/27 16:11:10]

Changed to DCHECK_NE(0u, pending_swaps_).

+  uint32_t async_swap_id = next_async_swap_id_ - pending_swaps_;
+  --pending_swaps_;
+  TRACE_EVENT_ASYNC_END0("gpu", "AsyncSwapBuffers", async_swap_id);
+
+  FinishSwapBuffers(result);
+}
+
 void GLES2DecoderImpl::FinishSwapBuffers(gfx::SwapResult result) {
   if (result == gfx::SwapResult::SWAP_FAILED) {
     LOG(ERROR) << "Context lost because SwapBuffers failed.";
     if (!CheckResetStatus()) {
       MarkContextLost(error::kUnknown);
       group_->LoseContexts(error::kUnknown);
     }
   }
   ++swaps_since_resize_;
   if (swaps_since_resize_ == 1 && surface_->BuffersFlipped()) {
     // The second buffer after a resize is new and needs to be cleared to
     // known values.
     backbuffer_needs_clear_bits_ |= GL_COLOR_BUFFER_BIT;
   }
-
-  if (supports_async_swap_) {
-    TRACE_EVENT_ASYNC_END0("cc", "GLES2DecoderImpl::AsyncSwapBuffers", this);
-  }
 }
 
 void GLES2DecoderImpl::DoCommitOverlayPlanes() {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCommitOverlayPlanes");
   if (!supports_commit_overlay_planes_) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCommitOverlayPlanes",
                        "command not supported by surface");
     return;
   }
   ClearScheduleCALayerState();
@@ skipping 3965 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu