Make lost context and error message callbacks on GpuControl go to client

gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.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/blink/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #include <utility>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
@@ skipping 50 matching lines @@
         bool is_offscreen,
         gfx::AcceleratedWidget window)
     : attributes_(attributes),
       share_resources_(share_resources),
       is_offscreen_(is_offscreen),
       window_(window),
       context_(std::move(context)) {}
 
 WebGraphicsContext3DInProcessCommandBufferImpl::
     ~WebGraphicsContext3DInProcessCommandBufferImpl() {
+  if (real_gl_) {
+    real_gl_->SetErrorMessageCallback(
+        base::Callback<void(const char*, int32_t)>());
+    real_gl_->SetLostContextCallback(base::Closure());
+  }
 }
 
 size_t WebGraphicsContext3DInProcessCommandBufferImpl::GetMappedMemoryLimit() {
   return context_->GetMappedMemoryLimit();
 }
 
 bool WebGraphicsContext3DInProcessCommandBufferImpl::MaybeInitializeGL() {
   if (initialized_)
     return true;
 
   if (initialize_failed_)
     return false;
 
   if (!context_) {
     // TODO(kbr): More work will be needed in this implementation to
     // properly support GPU switching. Like in the out-of-process
     // command buffer implementation, all previously created contexts
     // will need to be lost either when the first context requesting the
     // discrete GPU is created, or the last one is destroyed.
     gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
     context_.reset(GLInProcessContext::Create(
         NULL,                                          /* service */
         NULL,                                          /* surface */
         is_offscreen_, window_, gfx::Size(1, 1), NULL, /* share_context */
         share_resources_, attributes_, gpu_preference,
         ::gpu::GLInProcessContextSharedMemoryLimits(), nullptr, nullptr));
   }
 
-  if (context_) {
-    base::Closure context_lost_callback = base::Bind(
-        &WebGraphicsContext3DInProcessCommandBufferImpl::OnContextLost,
-        base::Unretained(this));
-    context_->SetContextLostCallback(context_lost_callback);
-  } else {
+  if (!context_) {
     initialize_failed_ = true;
     return false;
   }
 
   real_gl_ = context_->GetImplementation();
   SetGLInterface(real_gl_);
 
+  real_gl_->SetErrorMessageCallback(base::Bind(
+      // This method is in WebGraphicsContext3DImpl.
+      &WebGraphicsContext3DInProcessCommandBufferImpl::OnErrorMessage,

[danakj, 2016/04/06 02:14:15]

I started setting this here, but I don't think this can actually be called, as
the InProcessCommandBuffer doesn't call its GpuControlClient at all for errors.
So.. idk I could leave this out.

+      // The callback is unset in the destructor.
+      base::Unretained(this)));
+  real_gl_->SetLostContextCallback(
+      base::Bind(&WebGraphicsContext3DInProcessCommandBufferImpl::OnContextLost,
+                 // The callback is unset in the destructor.
+                 base::Unretained(this)));
+
   real_gl_->TraceBeginCHROMIUM("WebGraphicsContext3D",
                                "InProcessContext");
 
   initialized_ = true;
   return true;
 }
 
 bool
 WebGraphicsContext3DInProcessCommandBufferImpl::InitializeOnCurrentThread() {
   if (!MaybeInitializeGL())
@@ skipping 12 matching lines @@
   return real_gl_;
 }
 
 void WebGraphicsContext3DInProcessCommandBufferImpl::OnContextLost() {
   if (context_lost_callback_) {
     context_lost_callback_->onContextLost();
   }
 }
 
 }  // namespace gpu_blink