GL: Initialize trace bindings for WGL/GLX/EGL

This CL makes several changes:
* Creates Trace{WGL,GLX,EGL}Api when --enable-service-tracing is passed. They
  were previously never used.
* Moves creation of {Trace,Log}*Api to a lower level, so that
  --enable-gpu-service-{tracing,logging} works with tests, too.
* Avoids creating Log*Api when --enable-gpu-service-logging is not passed.
* Adds GlImplementationWrapper to remove some duplicated code.

R=kbr,rjkroege
BUG=None

Change-Id: Icddb2927ff43cb4b6481e5e2b62745bee2cf4445
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1951489
Commit-Queue: Thomas Anderson <thomasanderson@chromium.org>
Auto-Submit: Thomas Anderson <thomasanderson@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Cr-Commit-Position: refs/heads/master@{#723161}

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc

@@ -2430,7 +2430,7 @@ void GLES2DecoderPassthroughTestBase::SetUp() {
 
   gl::init::InitializeStaticGLBindingsImplementation(
       gl::kGLImplementationEGLANGLE, false);
-  gl::init::InitializeGLOneOffPlatformImplementation(false, false, false, true);
+  gl::init::InitializeGLOneOffPlatformImplementation(false, false, true);
 
   scoped_refptr<gles2::FeatureInfo> feature_info = new gles2::FeatureInfo();
   group_ = new gles2::ContextGroup(

gpu/command_buffer/service/image_reader_gl_owner_unittest.cc

@@ -36,8 +36,7 @@ class ImageReaderGLOwnerTest : public testing::Test {
 
     gl::init::InitializeStaticGLBindingsImplementation(
         gl::kGLImplementationEGLGLES2, false);
-    gl::init::InitializeGLOneOffPlatformImplementation(false, false, false,
-                                                       true);
+    gl::init::InitializeGLOneOffPlatformImplementation(false, false, true);
 
     surface_ = new gl::PbufferGLSurfaceEGL(gfx::Size(320, 240));
     surface_->Initialize();

gpu/command_buffer/service/surface_texture_gl_owner_unittest.cc

@@ -36,8 +36,7 @@ class SurfaceTextureGLOwnerTest : public testing::Test {
   void SetUp() override {
     gl::init::InitializeStaticGLBindingsImplementation(
         gl::kGLImplementationEGLGLES2, false);
-    gl::init::InitializeGLOneOffPlatformImplementation(false, false, false,
-                                                       true);
+    gl::init::InitializeGLOneOffPlatformImplementation(false, false, true);
 
     surface_ = new gl::PbufferGLSurfaceEGL(gfx::Size(320, 240));
     surface_->Initialize();

gpu/command_buffer/tests/fuzzer_main.cc

@@ -322,15 +322,15 @@ class CommandBufferSetup {
 
     CHECK(gl::init::InitializeStaticGLBindingsImplementation(
         gl::kGLImplementationEGLANGLE, false));
-    CHECK(gl::init::InitializeGLOneOffPlatformImplementation(false, false,
-                                                             false, true));
+    CHECK(
+        gl::init::InitializeGLOneOffPlatformImplementation(false, false, true));
 #elif defined(GPU_FUZZER_USE_SWIFTSHADER)
     command_line->AppendSwitchASCII(switches::kUseGL,
                                     gl::kGLImplementationSwiftShaderName);
     CHECK(gl::init::InitializeStaticGLBindingsImplementation(
         gl::kGLImplementationSwiftShaderGL, false));
-    CHECK(gl::init::InitializeGLOneOffPlatformImplementation(false, false,
-                                                             false, true));
+    CHECK(
+        gl::init::InitializeGLOneOffPlatformImplementation(false, false, true));
 #elif defined(GPU_FUZZER_USE_STUB)
     gl::GLSurfaceTestSupport::InitializeOneOffWithStubBindings();
     // Because the context depends on configuration bits, we want to recreate

gpu/command_buffer/tests/gl_test_utils.cc

@@ -45,7 +45,6 @@ bool GLTestHelper::InitializeGL(gl::GLImplementation gl_impl) {
 
     if (!gl::init::InitializeGLOneOffPlatformImplementation(
             false,  // fallback_to_software_gl
-            false,  // gpu_service_logging
             false,  // disable_gl_drawing
             false   // init_extensions
             )) {

media/gpu/android/codec_image_unittest.cc

@@ -51,8 +51,7 @@ class CodecImageTest : public testing::Test {
 
     gl::init::InitializeStaticGLBindingsImplementation(
         gl::kGLImplementationEGLGLES2, false);
-    gl::init::InitializeGLOneOffPlatformImplementation(false, false, false,
-                                                       false);
+    gl::init::InitializeGLOneOffPlatformImplementation(false, false, false);
 
     surface_ = new gl::PbufferGLSurfaceEGL(gfx::Size(320, 240));
     surface_->Initialize();

ui/gl/BUILD.gn

@@ -109,6 +109,7 @@ jumbo_component("gl") {
     "gl_image_stub.h",
     "gl_implementation.cc",
     "gl_implementation.h",
+    "gl_implementation_wrapper.h",
     "gl_share_group.cc",
     "gl_share_group.h",
     "gl_state_restorer.cc",

ui/gl/gl_context.cc

@@ -133,17 +133,17 @@ void GLContext::SetUnbindFboOnMakeCurrent() {
 
 std::string GLContext::GetGLVersion() {
   DCHECK(IsCurrent(nullptr));
-  DCHECK(gl_api_ != nullptr);
-  const char* version =
-      reinterpret_cast<const char*>(gl_api_->glGetStringFn(GL_VERSION));
+  DCHECK(gl_api_wrapper_);
+  const char* version = reinterpret_cast<const char*>(
+      gl_api_wrapper_->api()->glGetStringFn(GL_VERSION));
   return std::string(version ? version : "");
 }
 
 std::string GLContext::GetGLRenderer() {
   DCHECK(IsCurrent(nullptr));
-  DCHECK(gl_api_ != nullptr);
-  const char* renderer =
-      reinterpret_cast<const char*>(gl_api_->glGetStringFn(GL_RENDERER));
+  DCHECK(gl_api_wrapper_);
+  const char* renderer = reinterpret_cast<const char*>(
+      gl_api_wrapper_->api()->glGetStringFn(GL_RENDERER));
   return std::string(renderer ? renderer : "");
 }
 
@@ -157,23 +157,13 @@ CurrentGL* GLContext::GetCurrentGL() {
     driver_gl_ = std::make_unique<DriverGL>();
     driver_gl_->InitializeStaticBindings();
 
-    gl_api_.reset(CreateGLApi(driver_gl_.get()));
-    GLApi* final_api = gl_api_.get();
-
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kEnableGPUServiceTracing)) {
-      trace_gl_api_ = std::make_unique<TraceGLApi>(final_api);
-      final_api = trace_gl_api_.get();
-    }
-
-    if (GetDebugGLBindingsInitializedGL()) {
-      log_gl_api_ = std::make_unique<LogGLApi>(final_api);
-      final_api = log_gl_api_.get();
-    }
+    auto gl_api = base::WrapUnique<GLApi>(CreateGLApi(driver_gl_.get()));
+    gl_api_wrapper_ =
+        std::make_unique<GL_IMPL_WRAPPER_TYPE(GL)>(std::move(gl_api));
 
     current_gl_ = std::make_unique<CurrentGL>();
     current_gl_->Driver = driver_gl_.get();
-    current_gl_->Api = final_api;
+    current_gl_->Api = gl_api_wrapper_->api();
     current_gl_->Version = version_info_.get();
 
     static_bindings_initialized_ = true;

ui/gl/gl_context.h

@@ -17,6 +17,7 @@
 #include "build/build_config.h"
 #include "ui/gfx/extension_set.h"
 #include "ui/gl/gl_export.h"
+#include "ui/gl/gl_implementation_wrapper.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_state_restorer.h"
 #include "ui/gl/gl_workarounds.h"
@@ -256,7 +257,7 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
 
   virtual void ResetExtensions() = 0;
 
-  GLApi* gl_api() { return gl_api_.get(); }
+  GLApi* gl_api() { return gl_api_wrapper_->api(); }
 
 #if defined(OS_MACOSX)
   // Child classes are responsible for calling DestroyBackpressureFences during
@@ -285,9 +286,8 @@ class GL_EXPORT GLContext : public base::RefCounted<GLContext> {
   bool static_bindings_initialized_ = false;
   bool dynamic_bindings_initialized_ = false;
   std::unique_ptr<DriverGL> driver_gl_;
-  std::unique_ptr<GLApi> gl_api_;
-  std::unique_ptr<TraceGLApi> trace_gl_api_;
-  std::unique_ptr<LogGLApi> log_gl_api_;
+
+  std::unique_ptr<GL_IMPL_WRAPPER_TYPE(GL)> gl_api_wrapper_;
   std::unique_ptr<CurrentGL> current_gl_;
 
   // Copy of the real API (if one was created) for dynamic initialization

ui/gl/gl_egl_api_implementation.cc

@@ -4,43 +4,32 @@
 
 #include "ui/gl/gl_egl_api_implementation.h"
 
-#include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_implementation_wrapper.h"
 #include "ui/gl/gl_surface_egl.h"
 
 namespace gl {
 
-RealEGLApi* g_real_egl = nullptr;
-LogEGLApi* g_log_egl = nullptr;
+GL_IMPL_WRAPPER_TYPE(EGL) * g_egl_wrapper = nullptr;
 
 void InitializeStaticGLBindingsEGL() {
   g_driver_egl.InitializeStaticBindings();
-  if (!g_real_egl) {
-    g_real_egl = new RealEGLApi();
+  if (!g_egl_wrapper) {
+    auto real_api = std::make_unique<RealEGLApi>();
+    real_api->Initialize(&g_driver_egl);
+    g_egl_wrapper = new GL_IMPL_WRAPPER_TYPE(EGL)(std::move(real_api));
   }
-  g_real_egl->Initialize(&g_driver_egl);
-  g_current_egl_context = g_real_egl;
-}
 
-void InitializeLogGLBindingsEGL() {
-  if (!g_log_egl) {
-    g_log_egl = new LogEGLApi(g_real_egl);
-  }
-  g_current_egl_context = g_log_egl;
+  g_current_egl_context = g_egl_wrapper->api();
 }
 
 void ClearBindingsEGL() {
-  if (g_log_egl) {
-    delete g_log_egl;
-    g_log_egl = nullptr;
-  }
-  if (g_real_egl) {
-    delete g_real_egl;
-    g_real_egl = nullptr;
-  }
+  delete g_egl_wrapper;
+  g_egl_wrapper = nullptr;
+
   g_current_egl_context = nullptr;
   g_driver_egl.ClearBindings();
 }

ui/gl/gl_egl_api_implementation.h

@@ -18,7 +18,6 @@ namespace gl {
 struct GLWindowSystemBindingInfo;
 
 GL_EXPORT void InitializeStaticGLBindingsEGL();
-GL_EXPORT void InitializeLogGLBindingsEGL();
 GL_EXPORT void ClearBindingsEGL();
 GL_EXPORT bool GetGLWindowSystemBindingInfoEGL(GLWindowSystemBindingInfo* info);
 GL_EXPORT void SetDisabledExtensionsEGL(const std::string& disabled_extensions);

ui/gl/gl_gl_api_implementation.cc

@@ -26,9 +26,6 @@ static CurrentGL* g_no_context_current_gl = nullptr;
 // TODO: Consider adding a new GLApi that no-ops these functions
 static bool g_null_draw_bindings_enabled = false;
 
-// If the GL debug bindings are enabled.
-static bool g_log_bindings_enabled = false;
-
 namespace {
 
 // TODO(epenner): Could the above function be merged into GetInternalFormat and
@@ -229,14 +226,6 @@ void ClearBindingsGL() {
   }
 }
 
-void InitializeLogGLBindingsGL() {
-  g_log_bindings_enabled = true;
-}
-
-bool GetDebugGLBindingsInitializedGL() {
-  return g_log_bindings_enabled;
-}
-
 bool SetNullDrawGLBindingsEnabled(bool enabled) {
   bool old_value = g_null_draw_bindings_enabled;
   g_null_draw_bindings_enabled = enabled;

ui/gl/gl_gl_api_implementation.h

@@ -23,9 +23,6 @@ GL_EXPORT GLenum GetInternalFormat(const GLVersionInfo* version,
 GL_EXPORT void InitializeStaticGLBindingsGL();
 GL_EXPORT void ClearBindingsGL();
 
-GL_EXPORT void InitializeLogGLBindingsGL();
-bool GetDebugGLBindingsInitializedGL();
-
 bool SetNullDrawGLBindingsEnabled(bool enabled);
 bool GetNullDrawBindingsEnabled();
 

ui/gl/gl_glx_api_implementation.cc

@@ -4,45 +4,34 @@
 
 #include "ui/gl/gl_glx_api_implementation.h"
 
-#include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_implementation_wrapper.h"
 #include "ui/gl/gl_surface_glx.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gl {
 
-RealGLXApi* g_real_glx;
-LogGLXApi* g_log_glx;
+GL_IMPL_WRAPPER_TYPE(GLX) * g_glx_wrapper = nullptr;
 
 void InitializeStaticGLBindingsGLX() {
   g_driver_glx.InitializeStaticBindings();
-  if (!g_real_glx) {
-    g_real_glx = new RealGLXApi();
+  if (!g_glx_wrapper) {
+    auto real_api = std::make_unique<RealGLXApi>();
+    real_api->Initialize(&g_driver_glx);
+    g_glx_wrapper = new GL_IMPL_WRAPPER_TYPE(GLX)(std::move(real_api));
   }
-  g_real_glx->Initialize(&g_driver_glx);
-  g_current_glx_context = g_real_glx;
-}
 
-void InitializeLogGLBindingsGLX() {
-  if (!g_log_glx) {
-    g_log_glx = new LogGLXApi(g_real_glx);
-  }
-  g_current_glx_context = g_log_glx;
+  g_current_glx_context = g_glx_wrapper->api();
 }
 
 void ClearBindingsGLX() {
-  if (g_log_glx) {
-    delete g_log_glx;
-    g_log_glx = nullptr;
-  }
-  if (g_real_glx) {
-    delete g_real_glx;
-    g_real_glx = nullptr;
-  }
+  delete g_glx_wrapper;
+  g_glx_wrapper = nullptr;
+
   g_current_glx_context = nullptr;
   g_driver_glx.ClearBindings();
 }

ui/gl/gl_glx_api_implementation.h

@@ -18,7 +18,6 @@ struct GLVersionInfo;
 struct GLWindowSystemBindingInfo;
 
 GL_EXPORT void InitializeStaticGLBindingsGLX();
-GL_EXPORT void InitializeLogGLBindingsGLX();
 GL_EXPORT void ClearBindingsGLX();
 GL_EXPORT bool GetGLWindowSystemBindingInfoGLX(const GLVersionInfo& gl_info,
                                                GLWindowSystemBindingInfo* info);

ui/gl/gl_implementation_wrapper.h

+// Copyright 2019 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.
+
+#ifndef UI_GL_GL_IMPLEMENTATION_WRAPPER_H_
+#define UI_GL_GL_IMPLEMENTATION_WRAPPER_H_
+
+#include <memory>
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "ui/gl/gl_switches.h"
+
+#define GL_IMPL_WRAPPER_TYPE(name) \
+  GLImplementationWrapper<name##Api, Trace##name##Api, Log##name##Api>
+
+namespace gl {
+
+// Wraps a GLApi with its tracing and logging variants when the corresponding
+// command line flags are passed.
+template <class GLImplApi, class GLTraceImplApi, class GLLogImplApi>
+class GLImplementationWrapper {
+ public:
+  GLImplementationWrapper(std::unique_ptr<GLImplApi> real_gl)
+      : real_gl_(std::move(real_gl)) {
+    gl_api_ = real_gl_.get();
+
+    static bool enable_tracing =
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableGPUServiceTracing);
+    if (enable_tracing) {
+      trace_gl_ = std::make_unique<GLTraceImplApi>(gl_api_);
+      gl_api_ = trace_gl_.get();
+    }
+
+    static bool enable_logging =
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableGPUServiceLogging);
+    if (enable_logging) {
+      log_gl_ = std::make_unique<GLLogImplApi>(gl_api_);
+      gl_api_ = log_gl_.get();
+    }
+  }
+
+  ~GLImplementationWrapper() = default;
+
+  GLImplApi* api() { return gl_api_; }
+
+ private:
+  std::unique_ptr<GLImplApi> real_gl_;
+  std::unique_ptr<GLTraceImplApi> trace_gl_;
+  std::unique_ptr<GLLogImplApi> log_gl_;
+  GLImplApi* gl_api_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(GLImplementationWrapper);
+};
+
+}  // namespace gl
+
+#endif  // UI_GL_GL_IMPLEMENTATION_WRAPPER_H_

ui/gl/gl_wgl_api_implementation.cc

@@ -9,38 +9,30 @@
 #include "base/strings/string_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_implementation_wrapper.h"
 #include "ui/gl/gl_surface_wgl.h"
 
 namespace gl {
 
 RealWGLApi* g_real_wgl = nullptr;
-LogWGLApi* g_log_wgl = nullptr;
+
+GL_IMPL_WRAPPER_TYPE(WGL) * g_wgl_wrapper = nullptr;
 
 void InitializeStaticGLBindingsWGL() {
   g_driver_wgl.InitializeStaticBindings();
-  if (!g_real_wgl) {
-    g_real_wgl = new RealWGLApi();
+  if (!g_wgl_wrapper) {
+    auto real_api = std::make_unique<RealWGLApi>();
+    real_api->Initialize(&g_driver_wgl);
+    g_wgl_wrapper = new GL_IMPL_WRAPPER_TYPE(WGL)(std::move(real_api));
   }
-  g_real_wgl->Initialize(&g_driver_wgl);
-  g_current_wgl_context = g_real_wgl;
-}
 
-void InitializeLogGLBindingsWGL() {
-  if (!g_log_wgl) {
-    g_log_wgl = new LogWGLApi(g_real_wgl);
-  }
-  g_current_wgl_context = g_log_wgl;
+  g_current_wgl_context = g_wgl_wrapper->api();
 }
 
 void ClearBindingsWGL() {
-  if (g_log_wgl) {
-    delete g_log_wgl;
-    g_log_wgl = nullptr;
-  }
-  if (g_real_wgl) {
-    delete g_real_wgl;
-    g_real_wgl = nullptr;
-  }
+  delete g_wgl_wrapper;
+  g_wgl_wrapper = nullptr;
+
   g_current_wgl_context = nullptr;
   g_driver_wgl.ClearBindings();
 }

ui/gl/gl_wgl_api_implementation.h

@@ -17,7 +17,6 @@ namespace gl {
 struct GLWindowSystemBindingInfo;
 
 GL_EXPORT void InitializeStaticGLBindingsWGL();
-GL_EXPORT void InitializeLogGLBindingsWGL();
 GL_EXPORT void ClearBindingsWGL();
 GL_EXPORT bool GetGLWindowSystemBindingInfoWGL(GLWindowSystemBindingInfo* info);
 GL_EXPORT void SetDisabledExtensionsWGL(const std::string& disabled_extensions);

ui/gl/init/gl_factory.cc

@@ -102,12 +102,10 @@ bool InitializeGLOneOffPlatformHelper(bool init_extensions) {
 
   bool fallback_to_software_gl = ShouldFallbackToSoftwareGL();
   const base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
-  bool gpu_service_logging = cmd->HasSwitch(switches::kEnableGPUServiceLogging);
   bool disable_gl_drawing = cmd->HasSwitch(switches::kDisableGLDrawingForTests);
 
   return InitializeGLOneOffPlatformImplementation(
-      fallback_to_software_gl, gpu_service_logging, disable_gl_drawing,
-      init_extensions);
+      fallback_to_software_gl, disable_gl_drawing, init_extensions);
 }
 
 }  // namespace
@@ -171,7 +169,6 @@ bool InitializeStaticGLBindingsImplementation(GLImplementation impl,
 }
 
 bool InitializeGLOneOffPlatformImplementation(bool fallback_to_software_gl,
-                                              bool gpu_service_logging,
                                               bool disable_gl_drawing,
                                               bool init_extensions) {
   if (GetGLImplementation() == GetSoftwareGLImplementation())
@@ -193,8 +190,6 @@ bool InitializeGLOneOffPlatformImplementation(bool fallback_to_software_gl,
   if (initialized) {
     DVLOG(1) << "Using " << GetGLImplementationName(GetGLImplementation())
              << " GL implementation.";
-    if (gpu_service_logging)
-      InitializeLogGLBindings();
     if (disable_gl_drawing)
       InitializeNullDrawGLBindings();
   }

ui/gl/init/gl_factory.h

@@ -57,7 +57,6 @@ GL_INIT_EXPORT bool InitializeStaticGLBindingsImplementation(
 // successfully.
 GL_INIT_EXPORT bool InitializeGLOneOffPlatformImplementation(
     bool fallback_to_software_gl,
-    bool gpu_service_logging,
     bool disable_gl_drawing,
     bool init_extensions);
 

ui/gl/init/gl_initializer.h

@@ -22,9 +22,6 @@ bool InitializeGLOneOffPlatform();
 // Initializes a particular GL implementation.
 bool InitializeStaticGLBindings(GLImplementation implementation);
 
-// Initializes debug logging wrappers for GL bindings.
-void InitializeLogGLBindings();
-
 // Clears GL bindings for all implementations supported by platform.
 void ShutdownGLPlatform();
 

ui/gl/init/gl_initializer_android.cc

@@ -126,11 +126,6 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   return false;
 }
 
-void InitializeLogGLBindings() {
-  InitializeLogGLBindingsEGL();
-  InitializeLogGLBindingsGL();
-}
-
 void ShutdownGLPlatform() {
   GLSurfaceEGL::ShutdownOneOff();
   ClearBindingsEGL();

ui/gl/init/gl_initializer_mac.cc

@@ -223,10 +223,6 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   return false;
 }
 
-void InitializeLogGLBindings() {
-  InitializeLogGLBindingsGL();
-}
-
 void ShutdownGLPlatform() {
   ClearBindingsGL();
 #if defined(USE_EGL)

ui/gl/init/gl_initializer_ozone.cc

@@ -51,15 +51,6 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   return false;
 }
 
-void InitializeLogGLBindings() {
-  if (HasGLOzone()) {
-    GetGLOzone()->InitializeLogGLBindings();
-    return;
-  }
-
-  InitializeLogGLBindingsGL();
-}
-
 void ShutdownGLPlatform() {
   if (HasGLOzone()) {
     GetGLOzone()->ShutdownGL();

ui/gl/init/gl_initializer_win.cc

@@ -236,12 +236,6 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   return false;
 }
 
-void InitializeLogGLBindings() {
-  InitializeLogGLBindingsEGL();
-  InitializeLogGLBindingsGL();
-  InitializeLogGLBindingsWGL();
-}
-
 void ShutdownGLPlatform() {
   GLSurfaceEGL::ShutdownOneOff();
   ClearBindingsEGL();

ui/gl/init/gl_initializer_x11.cc

@@ -193,12 +193,6 @@ bool InitializeStaticGLBindings(GLImplementation implementation) {
   return false;
 }
 
-void InitializeLogGLBindings() {
-  InitializeLogGLBindingsEGL();
-  InitializeLogGLBindingsGL();
-  InitializeLogGLBindingsGLX();
-}
-
 void ShutdownGLPlatform() {
   GLSurfaceEGL::ShutdownOneOff();
   GLSurfaceGLX::ShutdownOneOff();

ui/gl/test/gl_surface_test_support.cc

@@ -74,14 +74,12 @@ void InitializeOneOffHelper(bool init_extensions) {
       << "kUseGL has not effect in tests";
 
   bool fallback_to_software_gl = false;
-  bool gpu_service_logging = false;
   bool disable_gl_drawing = true;
 
   CHECK(gl::init::InitializeStaticGLBindingsImplementation(
       impl, fallback_to_software_gl));
   CHECK(gl::init::InitializeGLOneOffPlatformImplementation(
-      fallback_to_software_gl, gpu_service_logging, disable_gl_drawing,
-      init_extensions));
+      fallback_to_software_gl, disable_gl_drawing, init_extensions));
 }
 }  // namespace
 
@@ -106,13 +104,12 @@ void GLSurfaceTestSupport::InitializeOneOffImplementation(
   // bindings in different ways.
   init::ShutdownGL(false);
 
-  bool gpu_service_logging = false;
   bool disable_gl_drawing = false;
 
   CHECK(gl::init::InitializeStaticGLBindingsImplementation(
       impl, fallback_to_software_gl));
   CHECK(gl::init::InitializeGLOneOffPlatformImplementation(
-      fallback_to_software_gl, gpu_service_logging, disable_gl_drawing, true));
+      fallback_to_software_gl, disable_gl_drawing, true));
 }
 
 // static

ui/ozone/common/gl_ozone_egl.cc

@@ -35,11 +35,6 @@ bool GLOzoneEGL::InitializeStaticGLBindings(
   return true;
 }
 
-void GLOzoneEGL::InitializeLogGLBindings() {
-  gl::InitializeLogGLBindingsGL();
-  gl::InitializeLogGLBindingsEGL();
-}
-
 void GLOzoneEGL::SetDisabledExtensionsPlatform(
     const std::string& disabled_extensions) {
   gl::SetDisabledExtensionsEGL(disabled_extensions);

ui/ozone/common/gl_ozone_egl.h

@@ -22,7 +22,6 @@ class GLOzoneEGL : public GLOzone {
   // GLOzone:
   bool InitializeGLOneOffPlatform() override;
   bool InitializeStaticGLBindings(gl::GLImplementation implementation) override;
-  void InitializeLogGLBindings() override;
   void SetDisabledExtensionsPlatform(
       const std::string& disabled_extensions) override;
   bool InitializeExtensionSettingsOneOffPlatform() override;

ui/ozone/platform/x11/gl_ozone_glx.cc

@@ -67,11 +67,6 @@ bool GLOzoneGLX::InitializeStaticGLBindings(
   return true;
 }
 
-void GLOzoneGLX::InitializeLogGLBindings() {
-  gl::InitializeLogGLBindingsGL();
-  gl::InitializeLogGLBindingsGLX();
-}
-
 void GLOzoneGLX::SetDisabledExtensionsPlatform(
     const std::string& disabled_extensions) {
   gl::SetDisabledExtensionsGLX(disabled_extensions);

ui/ozone/platform/x11/gl_ozone_glx.h

@@ -18,7 +18,6 @@ class GLOzoneGLX : public GLOzone {
 
   bool InitializeGLOneOffPlatform() override;
   bool InitializeStaticGLBindings(gl::GLImplementation implementation) override;
-  void InitializeLogGLBindings() override;
   void SetDisabledExtensionsPlatform(
       const std::string& disabled_extensions) override;
   bool InitializeExtensionSettingsOneOffPlatform() override;

ui/ozone/public/gl_ozone.h

@@ -40,9 +40,6 @@ class COMPONENT_EXPORT(OZONE_BASE) GLOzone {
   // Performs any one off initialization for GL implementation.
   virtual bool InitializeGLOneOffPlatform() = 0;
 
-  // Initializes static debug GL bindings.
-  virtual void InitializeLogGLBindings() = 0;
-
   // Disables the specified extensions in the window system bindings,
   // e.g., GLX, EGL, etc. This is part of the GPU driver bug workarounds
   // mechanism.