Merge gpu_trace_event back into base/debug/trace_event

gpu/command_buffer/client/gles2_implementation.cc

 // Copyright (c) 2011 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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 #include <GLES2/gles2_command_buffer.h>
 #include "../client/mapped_memory.h"
 #include "../common/gles2_cmd_utils.h"
 #include "../common/id_allocator.h"
-#include "gpu/common/gpu_trace_event.h"
+#include "../common/trace_event.h"
 
 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 // A 32-bit and 64-bit compatible way of converting a pointer to a GLuint.
 static GLuint ToGLuint(const void* ptr) {
@@ skipping 461 matching lines @@
 #endif
 }
 
 GLES2Implementation::~GLES2Implementation() {
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   DeleteBuffers(arraysize(reserved_ids_), &reserved_ids_[0]);
 #endif
 }
 
 void GLES2Implementation::WaitForCmd() {
-  GPU_TRACE_EVENT0("gpu", "GLES2::WaitForCmd");
+  TRACE_EVENT0("gpu", "GLES2::WaitForCmd");
   helper_->CommandBufferHelper::Finish();
 }
 
 GLenum GLES2Implementation::GetError() {
   return GetGLError();
 }
 
 GLenum GLES2Implementation::GetGLError() {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetGLError");
+  TRACE_EVENT0("gpu", "GLES2::GetGLError");
   // Check the GL error first, then our wrapped error.
   typedef gles2::GetError::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = GL_NO_ERROR;
   helper_->GetError(result_shm_id(), result_shm_offset());
   WaitForCmd();
   GLenum error = *result;
   if (error == GL_NO_ERROR && error_bits_ != 0) {
     for (uint32 mask = 1; mask != 0; mask = mask << 1) {
       if ((error_bits_ & mask) != 0) {
@@ skipping 12 matching lines @@
 
 void GLES2Implementation::SetGLError(GLenum error, const char* msg) {
   if (msg) {
     last_error_ = msg;
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
 void GLES2Implementation::GetBucketContents(uint32 bucket_id,
                                             std::vector<int8>* data) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetBucketContents");
+  TRACE_EVENT0("gpu", "GLES2::GetBucketContents");
   GPU_DCHECK(data);
   typedef cmd::GetBucketSize::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = 0;
   helper_->GetBucketSize(bucket_id, result_shm_id(), result_shm_offset());
   WaitForCmd();
   uint32 size = *result;
   data->resize(size);
   if (size > 0u) {
     uint32 max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
@@ skipping 120 matching lines @@
 
 void GLES2Implementation::Flush() {
   // Insert the cmd to call glFlush
   helper_->Flush();
   // Flush our command buffer
   // (tell the service to execute up to the flush cmd.)
   helper_->CommandBufferHelper::Flush();
 }
 
 void GLES2Implementation::Finish() {
-  GPU_TRACE_EVENT0("gpu", "GLES2::Finish");
+  TRACE_EVENT0("gpu", "GLES2::Finish");
   // Insert the cmd to call glFinish
   helper_->Finish();
   // Finish our command buffer
   // (tell the service to execute up to the Finish cmd and wait for it to
   // execute.)
   helper_->CommandBufferHelper::Finish();
 }
 
 void GLES2Implementation::SwapBuffers() {
   // Wait if this would add too many swap buffers.
@@ skipping 19 matching lines @@
     swap_buffers_tokens_.pop();
   }
   helper_->CopyTextureToParentTextureCHROMIUM(client_child_id,
       client_parent_id);
   swap_buffers_tokens_.push(helper_->InsertToken());
   Flush();
 }
 
 void GLES2Implementation::GenSharedIdsCHROMIUM(
   GLuint namespace_id, GLuint id_offset, GLsizei n, GLuint* ids) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GenSharedIdsCHROMIUM");
+  TRACE_EVENT0("gpu", "GLES2::GenSharedIdsCHROMIUM");
   GLint* id_buffer = transfer_buffer_.AllocTyped<GLint>(n);
   helper_->GenSharedIdsCHROMIUM(namespace_id, id_offset, n,
                         transfer_buffer_id_,
                         transfer_buffer_.GetOffset(id_buffer));
   WaitForCmd();
   memcpy(ids, id_buffer, sizeof(*ids) * n);
   transfer_buffer_.FreePendingToken(id_buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::DeleteSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::DeleteSharedIdsCHROMIUM");
+  TRACE_EVENT0("gpu", "GLES2::DeleteSharedIdsCHROMIUM");
   GLint* id_buffer = transfer_buffer_.AllocTyped<GLint>(n);
   memcpy(id_buffer, ids, sizeof(*ids) * n);
   helper_->DeleteSharedIdsCHROMIUM(namespace_id, n,
                            transfer_buffer_id_,
                            transfer_buffer_.GetOffset(id_buffer));
   WaitForCmd();
   transfer_buffer_.FreePendingToken(id_buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::RegisterSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::RegisterSharedIdsCHROMIUM");
+  TRACE_EVENT0("gpu", "GLES2::RegisterSharedIdsCHROMIUM");
   GLint* id_buffer = transfer_buffer_.AllocTyped<GLint>(n);
   memcpy(id_buffer, ids, sizeof(*ids) * n);
   helper_->RegisterSharedIdsCHROMIUM(namespace_id, n,
                              transfer_buffer_id_,
                              transfer_buffer_.GetOffset(id_buffer));
   WaitForCmd();
   transfer_buffer_.FreePendingToken(id_buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::BindAttribLocation(
   GLuint program, GLuint index, const char* name) {
   SetBucketAsString(kResultBucketId, name);
   helper_->BindAttribLocationBucket(program, index, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 void GLES2Implementation::GetVertexAttribPointerv(
     GLuint index, GLenum pname, void** ptr) {
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   // If it's a client side buffer the client has the data.
   if (client_side_buffer_helper_->GetAttribPointer(index, pname, ptr)) {
     return;
   }
 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetVertexAttribPointerv");
+  TRACE_EVENT0("gpu", "GLES2::GetVertexAttribPointerv");
   typedef gles2::GetVertexAttribPointerv::Result Result;
   Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetVertexAttribPointerv(
     index, pname, result_shm_id(), result_shm_offset());
   WaitForCmd();
   result->CopyResult(ptr);
 }
 
 GLint GLES2Implementation::GetAttribLocation(
     GLuint program, const char* name) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetAttribLocation");
+  TRACE_EVENT0("gpu", "GLES2::GetAttribLocation");
   typedef GetAttribLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetAttribLocationBucket(program, kResultBucketId,
                                    result_shm_id(), result_shm_offset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
 
 GLint GLES2Implementation::GetUniformLocation(
     GLuint program, const char* name) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetUniformLocation");
+  TRACE_EVENT0("gpu", "GLES2::GetUniformLocation");
   typedef GetUniformLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetUniformLocationBucket(program, kResultBucketId,
                                     result_shm_id(), result_shm_offset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
@@ skipping 290 matching lines @@
   }
 }
 
 void GLES2Implementation::GetActiveAttrib(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   if (bufsize < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib: bufsize < 0");
     return;
   }
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetActiveAttrib");
+  TRACE_EVENT0("gpu", "GLES2::GetActiveAttrib");
   // Clear the bucket so if we the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   typedef gles2::GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(result_buffer_);
   // Set as failed so if the command fails we'll recover.
   result->success = false;
   helper_->GetActiveAttrib(program, index, kResultBucketId,
                            result_shm_id(), result_shm_offset());
   WaitForCmd();
   if (result->success) {
@@ skipping 20 matching lines @@
   }
 }
 
 void GLES2Implementation::GetActiveUniform(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   if (bufsize < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveUniform: bufsize < 0");
     return;
   }
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetActiveUniform");
+  TRACE_EVENT0("gpu", "GLES2::GetActiveUniform");
   // Clear the bucket so if we the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   typedef gles2::GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(result_buffer_);
   // Set as failed so if the command fails we'll recover.
   result->success = false;
   helper_->GetActiveUniform(program, index, kResultBucketId,
                             result_shm_id(), result_shm_offset());
   WaitForCmd();
   if (result->success) {
@@ skipping 19 matching lines @@
     }
   }
 }
 
 void GLES2Implementation::GetAttachedShaders(
     GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
   if (maxcount < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetAttachedShaders: maxcount < 0");
     return;
   }
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetAttachedShaders");
+  TRACE_EVENT0("gpu", "GLES2::GetAttachedShaders");
   typedef gles2::GetAttachedShaders::Result Result;
   uint32 size = Result::ComputeSize(maxcount);
   Result* result = transfer_buffer_.AllocTyped<Result>(size);
   result->SetNumResults(0);
   helper_->GetAttachedShaders(
     program,
     transfer_buffer_id_,
     transfer_buffer_.GetOffset(result),
     size);
   int32 token = helper_->InsertToken();
   WaitForCmd();
   if (count) {
     *count = result->GetNumResults();
   }
   result->CopyResult(shaders);
   transfer_buffer_.FreePendingToken(result, token);
 }
 
 void GLES2Implementation::GetShaderPrecisionFormat(
     GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetShaderPrecisionFormat");
+  TRACE_EVENT0("gpu", "GLES2::GetShaderPrecisionFormat");
   typedef gles2::GetShaderPrecisionFormat::Result Result;
   Result* result = static_cast<Result*>(result_buffer_);
   result->success = false;
   helper_->GetShaderPrecisionFormat(
     shadertype, precisiontype, result_shm_id(), result_shm_offset());
   WaitForCmd();
   if (result->success) {
     if (range) {
       range[0] = result->min_range;
       range[1] = result->max_range;
@@ skipping 31 matching lines @@
           string_set.insert(str);
       GPU_DCHECK(insert_result.second);
       result = insert_result.first->c_str();
     }
   }
   return reinterpret_cast<const GLubyte*>(result);
 }
 
 void GLES2Implementation::GetUniformfv(
     GLuint program, GLint location, GLfloat* params) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetUniformfv");
+  TRACE_EVENT0("gpu", "GLES2::GetUniformfv");
   typedef gles2::GetUniformfv::Result Result;
   Result* result = static_cast<Result*>(result_buffer_);
   result->SetNumResults(0);
   helper_->GetUniformfv(
       program, location, result_shm_id(), result_shm_offset());
   WaitForCmd();
   result->CopyResult(params);
 }
 
 void GLES2Implementation::GetUniformiv(
     GLuint program, GLint location, GLint* params) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetUniformiv");
+  TRACE_EVENT0("gpu", "GLES2::GetUniformiv");
   typedef gles2::GetUniformiv::Result Result;
   Result* result = static_cast<Result*>(result_buffer_);
   result->SetNumResults(0);
   helper_->GetUniformiv(
       program, location, result_shm_id(), result_shm_offset());
   WaitForCmd();
   static_cast<gles2::GetUniformfv::Result*>(result_buffer_)->CopyResult(params);
 }
 
 void GLES2Implementation::ReadPixels(
     GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
     GLenum type, void* pixels) {
   if (width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions < 0");
     return;
   }
   if (width == 0 || height == 0) {
     return;
   }
 
   // glReadPixel pads the size of each row of pixels by an amount specified by
   // glPixelStorei. So, we have to take that into account both in the fact that
   // the pixels returned from the ReadPixel command will include that padding
   // and that when we copy the results to the user's buffer we need to not
   // write those padding bytes but leave them as they are.
 
-  GPU_TRACE_EVENT0("gpu", "GLES2::ReadPixels");
+  TRACE_EVENT0("gpu", "GLES2::ReadPixels");
   typedef gles2::ReadPixels::Result Result;
   Result* result = static_cast<Result*>(result_buffer_);
   int8* dest = reinterpret_cast<int8*>(pixels);
   GLsizeiptr max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
   uint32 temp_size;
   if (!GLES2Util::ComputeImageDataSize(
       width, 1, format, type, pack_alignment_, &temp_size)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: size too large.");
     return;
   }
@@ skipping 219 matching lines @@
 
 void GLES2Implementation::GetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   uint32 value = 0;
   if (GetVertexAttribHelper(index, pname, &value)) {
     *params = static_cast<float>(value);
     return;
   }
 #endif
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetVertexAttribfv");
+  TRACE_EVENT0("gpu", "GLES2::GetVertexAttribfv");
   typedef GetVertexAttribfv::Result Result;
   Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetVertexAttribfv(
       index, pname, result_shm_id(), result_shm_offset());
   WaitForCmd();
   result->CopyResult(params);
 }
 
 void GLES2Implementation::GetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   uint32 value = 0;
   if (GetVertexAttribHelper(index, pname, &value)) {
     *params = value;
     return;
   }
 #endif
-  GPU_TRACE_EVENT0("gpu", "GLES2::GetVertexAttribiv");
+  TRACE_EVENT0("gpu", "GLES2::GetVertexAttribiv");
   typedef GetVertexAttribiv::Result Result;
   Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetVertexAttribiv(
       index, pname, result_shm_id(), result_shm_offset());
   WaitForCmd();
   result->CopyResult(params);
 }
 
 GLboolean GLES2Implementation::CommandBufferEnableCHROMIUM(
     const char* feature) {
-  GPU_TRACE_EVENT0("gpu", "GLES2::CommandBufferEnableCHROMIUM");
+  TRACE_EVENT0("gpu", "GLES2::CommandBufferEnableCHROMIUM");
   typedef CommandBufferEnableCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = 0;
   SetBucketAsCString(kResultBucketId, feature);
   helper_->CommandBufferEnableCHROMIUM(
       kResultBucketId, result_shm_id(), result_shm_offset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
@@ skipping 125 matching lines @@
 }
 
 void GLES2Implementation::RequestExtensionCHROMIUM(const char* extension) {
   SetBucketAsCString(kResultBucketId, extension);
   helper_->RequestExtensionCHROMIUM(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 }  // namespace gles2
 }  // namespace gpu