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

gpu/command_buffer/client/gl_in_process_context.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/command_buffer/client/gl_in_process_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 49 matching lines @@
                   GLInProcessContext* share_context,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const gpu::gles2::ContextCreationAttribHelper& attribs,
                   gfx::GpuPreference gpu_preference,
                   const scoped_refptr<InProcessCommandBuffer::Service>& service,
                   GpuMemoryBufferManager* gpu_memory_buffer_manager,
                   ImageFactory* image_factory);
 
   // GLInProcessContext implementation:
+  void SetContextLostCallback(const base::Closure& callback) override;
   gles2::GLES2Implementation* GetImplementation() override;
   size_t GetMappedMemoryLimit() override;
   void SetLock(base::Lock* lock) override;
 
 #if defined(OS_ANDROID)
   scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
       uint32_t stream_id) override;
   uint32_t CreateStreamTexture(uint32_t texture_id) override;
 #endif
 
  private:
   void Destroy();
+  void OnContextLost();
   void OnSignalSyncPoint(const base::Closure& callback);
 
   scoped_ptr<gles2::GLES2CmdHelper> gles2_helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
   scoped_ptr<gles2::GLES2Implementation> gles2_implementation_;
   scoped_ptr<InProcessCommandBuffer> command_buffer_;
 
   const GLInProcessContextSharedMemoryLimits mem_limits_;
+  base::Closure context_lost_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContextImpl);
 };
 
 GLInProcessContextImpl::GLInProcessContextImpl(
     const GLInProcessContextSharedMemoryLimits& mem_limits)
     : mem_limits_(mem_limits) {}
 
 GLInProcessContextImpl::~GLInProcessContextImpl() {
   Destroy();
 }
 
 gles2::GLES2Implementation* GLInProcessContextImpl::GetImplementation() {
   return gles2_implementation_.get();
 }
 
 size_t GLInProcessContextImpl::GetMappedMemoryLimit() {
   return mem_limits_.mapped_memory_reclaim_limit;
 }
 
 void GLInProcessContextImpl::SetLock(base::Lock* lock) {
   NOTREACHED();
 }
 
+void GLInProcessContextImpl::SetContextLostCallback(
+    const base::Closure& callback) {
+  context_lost_callback_ = callback;
+}
+
+void GLInProcessContextImpl::OnContextLost() {
+  if (!context_lost_callback_.is_null())
+    context_lost_callback_.Run();
+}
+
 bool GLInProcessContextImpl::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     GLInProcessContext* share_context,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const gles2::ContextCreationAttribHelper& attribs,
     gfx::GpuPreference gpu_preference,
     const scoped_refptr<InProcessCommandBuffer::Service>& service,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   std::vector<int32_t> attrib_vector;
   attribs.Serialize(&attrib_vector);
 
+  base::Closure wrapped_callback =
+      base::Bind(&GLInProcessContextImpl::OnContextLost, AsWeakPtr());
   command_buffer_.reset(new InProcessCommandBuffer(service));
 
   scoped_refptr<gles2::ShareGroup> share_group;
   InProcessCommandBuffer* share_command_buffer = nullptr;
   if (share_context) {
     GLInProcessContextImpl* impl =
         static_cast<GLInProcessContextImpl*>(share_context);
     share_group = impl->gles2_implementation_->share_group();
     share_command_buffer = impl->command_buffer_.get();
     DCHECK(share_group);
     DCHECK(share_command_buffer);
   }
 
   if (!command_buffer_->Initialize(surface,
                                    is_offscreen,
                                    window,
                                    size,
                                    attrib_vector,
                                    gpu_preference,
+                                   wrapped_callback,
                                    share_command_buffer,
                                    gpu_memory_buffer_manager,
                                    image_factory)) {
     DLOG(ERROR) << "Failed to initialize InProcessCommmandBuffer";
     return false;
   }
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
   if (!gles2_helper_->Initialize(mem_limits_.command_buffer_size)) {
@@ skipping 99 matching lines @@
                            gpu_preference,
                            service,
                            gpu_memory_buffer_manager,
                            image_factory))
     return NULL;
 
   return context.release();
 }
 
 }  // namespace gpu