initialize trace_event hooks in angle on gpu startup

content/gpu/gpu_main.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 <stdlib.h>
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 20 matching lines @@
 #include "gpu/config/gpu_info_collector.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #include "content/common/gpu/media/dxva_video_decode_accelerator.h"
 #include "sandbox/win/src/sandbox.h"
+#include "third_party/angle_dx11/src/common/event_tracer.h"
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
 #include "content/common/gpu/media/exynos_video_decode_accelerator.h"
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #endif
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"
 #endif
 
@@ skipping 21 matching lines @@
                                  const char* file, int line,
                                  size_t message_start,
                                  const std::string& str) {
   std::string header = str.substr(0, message_start);
   std::string message = str.substr(message_start);
   deferred_messages.Get().push(new GpuHostMsg_OnLogMessage(
       severity, header, message));
   return false;
 }
 
+const unsigned char* AngleGetTraceCategoryEnabledFlag(const char* name) {
+  return TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(name);
+}
+
+void AngleAddTraceEvent(char phase,
+                        const unsigned char* category_group_enabled,
+                        const char* name,
+                        unsigned long long id,
+                        int num_args,
+                        const char** arg_names,
+                        const unsigned char* arg_types,
+                        const unsigned long long* arg_values,
+                        unsigned char flags) {
+  TRACE_EVENT_API_ADD_TRACE_EVENT(phase,
+                                  category_group_enabled,
+                                  name,
+                                  id,
+                                  num_args,
+                                  arg_names,
+                                  arg_types,
+                                  arg_values,
+                                  NULL,
+                                  flags);
+}
+
 }  // namespace anonymous
 
 // Main function for starting the Gpu process.
 int GpuMain(const MainFunctionParams& parameters) {
   TRACE_EVENT0("gpu", "GpuMain");
   base::debug::TraceLog::GetInstance()->SetProcessName("GPU Process");
   base::debug::TraceLog::GetInstance()->SetProcessSortIndex(
       kTraceEventGpuProcessSortIndex);
+  gl::SetTraceFunctionPointers(&AngleGetTraceCategoryEnabledFlag,

[apatrick_chromium, 2013/08/12 19:34:13]

Does this really work? ANGLE is dynamically loaded. Also what if we're using
OpenGL or Mesa instead of ANGLE? Also, what about platforms other than Windows?

+                               &AngleAddTraceEvent);
 
   const CommandLine& command_line = parameters.command_line;
   if (command_line.HasSwitch(switches::kGpuStartupDialog)) {
     ChildProcess::WaitForDebugger("Gpu");
   }
 
   base::Time start_time = base::Time::Now();
 
   bool in_browser_process = command_line.HasSwitch(switches::kSingleProcess) ||
                             command_line.HasSwitch(switches::kInProcessGPU);
@@ skipping 326 matching lines @@
     return true;
   }
 
   return false;
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace.
 
 }  // namespace content