initialize trace_event hooks in angle on gpu startup

ui/gl/gl_implementation_win.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 <vector>
 
 #include "base/at_exit.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/debug/trace_event.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/native_library.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/windows_version.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_egl_api_implementation.h"
 #include "ui/gl/gl_gl_api_implementation.h"
@@ skipping 30 matching lines @@
   if (!library) {
     library = base::LoadNativeLibrary(module_path.Append(name), NULL);
     if (!library) {
       DVLOG(1) << name << " not found.";
       return false;
     }
   }
   return true;
 }
 
+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);
+}
+
+typedef const unsigned char* (*GetCategoryEnabledFlagFunc)(const char* name);
+typedef void (*AddTraceEventFunc)(char phase,
+                                  const unsigned char* categoryGroupEnabled,
+                                  const char* name,
+                                  unsigned long long id,
+                                  int numArgs,
+                                  const char** argNames,
+                                  const unsigned char* argTypes,
+                                  const unsigned long long* argValues,
+                                  unsigned char flags);
+typedef void (*SetTraceFunctionPointersFunc)(
+    GetCategoryEnabledFlagFunc get_category_enabled_flag,
+    AddTraceEventFunc add_trace_event_func);
+
 }  // namespace
 
 void GetAllowedGLImplementations(std::vector<GLImplementation>* impls) {
   impls->push_back(kGLImplementationEGLGLES2);
   impls->push_back(kGLImplementationDesktopGL);
   impls->push_back(kGLImplementationOSMesaGL);
 }
 
 bool InitializeGLBindings(GLImplementation implementation) {
   // Prevent reinitialization with a different implementation. Once the gpu
@@ skipping 89 matching lines @@
         base::UnloadNativeLibrary(gles_library);
         return false;
       }
 
 #if defined(ENABLE_SWIFTSHADER)
       if (using_swift_shader) {
         SetupSoftwareRenderer(gles_library);
       }
 #endif
 
+      if (!using_swift_shader) {
+        SetTraceFunctionPointersFunc set_trace_function_pointers =
+            reinterpret_cast<SetTraceFunctionPointersFunc>(
+                base::GetFunctionPointerFromNativeLibrary(
+                    gles_library, "SetTraceFunctionPointers"));
+        if (set_trace_function_pointers) {
+          set_trace_function_pointers(&AngleGetTraceCategoryEnabledFlag,
+                                      &AngleAddTraceEvent);
+        }
+      }
+
       GLGetProcAddressProc get_proc_address =
           reinterpret_cast<GLGetProcAddressProc>(
               base::GetFunctionPointerFromNativeLibrary(
                   egl_library, "eglGetProcAddress"));
       if (!get_proc_address) {
         LOG(ERROR) << "eglGetProcAddress not found.";
         base::UnloadNativeLibrary(egl_library);
         base::UnloadNativeLibrary(gles_library);
         return false;
       }
@@ skipping 100 matching lines @@
       return GetGLWindowSystemBindingInfoWGL(info);
     case kGLImplementationEGLGLES2:
       return GetGLWindowSystemBindingInfoEGL(info);
     default:
       return false;
   }
   return false;
 }
 
 }  // namespace gfx