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

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 143 matching lines @@
 #if defined(OS_NACL)
           0),
 #else
           // Do not use more than 5% of extra shared memory, and do not
           // use any extra for memory contrained devices (<=1GB).
           base::SysInfo::AmountOfPhysicalMemory() > 1024 * 1024 * 1024
               ? base::saturated_cast<uint32_t>(
                     base::SysInfo::AmountOfPhysicalMemory() / 20)
               : 0),
 #endif
-      error_message_callback_(NULL),
       current_trace_stack_(0),
       gpu_control_(gpu_control),
       capabilities_(gpu_control->GetCapabilities()),
       aggressively_free_resources_(false),
       cached_extension_string_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(helper);
   DCHECK(transfer_buffer);
   DCHECK(gpu_control);
 
@@ skipping 19 matching lines @@
 bool GLES2Implementation::Initialize(
     unsigned int starting_transfer_buffer_size,
     unsigned int min_transfer_buffer_size,
     unsigned int max_transfer_buffer_size,
     unsigned int mapped_memory_limit) {
   TRACE_EVENT0("gpu", "GLES2Implementation::Initialize");
   DCHECK_GE(starting_transfer_buffer_size, min_transfer_buffer_size);
   DCHECK_LE(starting_transfer_buffer_size, max_transfer_buffer_size);
   DCHECK_GE(min_transfer_buffer_size, kStartingOffset);
 
+  gpu_control_->SetGpuControlClient(this);
+
   if (!transfer_buffer_->Initialize(
       starting_transfer_buffer_size,
       kStartingOffset,
       min_transfer_buffer_size,
       max_transfer_buffer_size,
       kAlignment,
       kSizeToFlush)) {
     return false;
   }
 
@@ skipping 78 matching lines @@
   // called but not the UnmapBuffer() pair.
   ClearMappedBufferRangeMap();
 
   // Release any per-context data in share group.
   share_group_->FreeContext(this);
 
   buffer_tracker_.reset();
 
   // Make sure the commands make it the service.
   WaitForCmd();
+
+  // The gpu_control_ outlives this class, so clear the client on it before we
+  // self-destruct.
+  gpu_control_->SetGpuControlClient(nullptr);
 }
 
 GLES2CmdHelper* GLES2Implementation::helper() const {
   return helper_;
 }
 
 IdHandlerInterface* GLES2Implementation::GetIdHandler(int namespace_id) const {
   return share_group_->GetIdHandler(namespace_id);
 }
 
@@ skipping 230 matching lines @@
 
 void GLES2Implementation::SetGLError(
     GLenum error, const char* function_name, const char* msg) {
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] Client Synthesized Error: "
                  << GLES2Util::GetStringError(error) << ": "
                  << function_name << ": " << msg);
   FailGLError(error);
   if (msg) {
     last_error_ = msg;
   }
-  if (error_message_callback_) {
+  if (!error_message_callback_.is_null()) {
     std::string temp(GLES2Util::GetStringError(error)  + " : " +
                      function_name + ": " + (msg ? msg : ""));
-    error_message_callback_->OnErrorMessage(temp.c_str(), 0);
+    error_message_callback_.Run(temp.c_str(), 0);
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 
   if (error == GL_OUT_OF_MEMORY && lose_context_when_out_of_memory_) {
     helper_->LoseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                  GL_UNKNOWN_CONTEXT_RESET_ARB);
   }
 }
 
 void GLES2Implementation::SetGLErrorInvalidEnum(
@@ skipping 5245 matching lines @@
   }
   buffer->set_mapped(false);
   CheckGLError();
   return true;
 }
 
 uint64_t GLES2Implementation::ShareGroupTracingGUID() const {
   return share_group_->TracingGUID();
 }
 
+void GLES2Implementation::SetErrorMessageCallback(
+    const base::Callback<void(const char*, int32_t)>& callback) {
+  error_message_callback_ = callback;
+}
+
+void GLES2Implementation::SetLostContextCallback(
+    const base::Closure& callback) {
+  lost_context_callback_ = callback;
+}
+
+void GLES2Implementation::OnGpuControlLostContext() {
+#if DCHECK_IS_ON()
+  // This should never occur more than once.
+  DCHECK(!lost_context_);
+  lost_context_ = true;
+#endif
+  if (!lost_context_callback_.is_null())
+    lost_context_callback_.Run();
+}
+
+void GLES2Implementation::OnGpuControlErrorMessage(const char* message,
+                                                   int32_t id) {
+  if (!error_message_callback_.is_null())
+    error_message_callback_.Run(message, id);
+}
+
 GLuint64 GLES2Implementation::InsertFenceSyncCHROMIUM() {
   const uint64_t release = gpu_control_->GenerateFenceSyncRelease();
   helper_->InsertFenceSyncCHROMIUM(release);
   return release;
 }
 
 void GLES2Implementation::GenSyncTokenCHROMIUM(GLuint64 fence_sync,
                                                GLbyte* sync_token) {
   if (!sync_token) {
     SetGLError(GL_INVALID_VALUE, "glGenSyncTokenCHROMIUM", "empty sync_token");
@@ skipping 1015 matching lines @@
   cached_extensions_.clear();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu