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

gpu/command_buffer/client/gles2_implementation.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "gpu/command_buffer/client/buffer_tracker.h"
 #include "gpu/command_buffer/client/client_context_state.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_impl_export.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
-#include "gpu/command_buffer/client/gpu_control_client.h"
 #include "gpu/command_buffer/client/mapped_memory.h"
 #include "gpu/command_buffer/client/ref_counted.h"
 #include "gpu/command_buffer/client/share_group.h"
 #include "gpu/command_buffer/common/capabilities.h"
 #include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 
 #if !defined(NDEBUG) && !defined(__native_client__) && !defined(GLES2_CONFORMANCE_TESTS)  // NOLINT
   #if defined(GLES2_INLINE_OPTIMIZATION)
     // TODO(gman): Replace with macros that work with inline optmization.
@@ skipping 65 matching lines @@
 class IdAllocator;
 class ScopedTransferBufferPtr;
 class TransferBufferInterface;
 
 namespace gles2 {
 
 class GLES2CmdHelper;
 class VertexArrayObjectManager;
 class QueryTracker;
 
+class GLES2ImplementationErrorMessageCallback {
+ public:
+  virtual ~GLES2ImplementationErrorMessageCallback() { }
+  virtual void OnErrorMessage(const char* msg, int id) = 0;
+};
+
 // This class emulates GLES2 over command buffers. It can be used by a client
 // program so that the program does not need deal with shared memory and command
 // buffer management. See gl2_lib.h.  Note that there is a performance gain to
 // be had by changing your code to use command buffers directly by using the
 // GLES2CmdHelper but that entails changing your code to use and deal with
 // shared memory and synchronization issues.
 class GLES2_IMPL_EXPORT GLES2Implementation
     : NON_EXPORTED_BASE(public GLES2Interface),
       NON_EXPORTED_BASE(public ContextSupport),
-      NON_EXPORTED_BASE(public GpuControlClient),
       NON_EXPORTED_BASE(public base::trace_event::MemoryDumpProvider) {
  public:
   enum MappedMemoryLimit {
     kNoLimit = MappedMemoryManager::kNoLimit,
   };
 
   // Stores GL state that never changes.
   struct GLES2_IMPL_EXPORT GLStaticState {
     GLStaticState();
     ~GLStaticState();
@@ skipping 67 matching lines @@
   void Swap() override;
   void PartialSwapBuffers(const gfx::Rect& sub_buffer) override;
   void CommitOverlayPlanes() override;
   void ScheduleOverlayPlane(int plane_z_order,
                             gfx::OverlayTransform plane_transform,
                             unsigned overlay_texture_id,
                             const gfx::Rect& display_bounds,
                             const gfx::RectF& uv_rect) override;
   uint64_t ShareGroupTracingGUID() const override;
 
-  void SetErrorMessageCallback(
-      const base::Callback<void(const char*, int32_t)>& callback);
-  void SetLostContextCallback(const base::Closure& callback);
-
   void GetProgramInfoCHROMIUMHelper(GLuint program,
                                     std::vector<int8_t>* result);
   GLint GetAttribLocationHelper(GLuint program, const char* name);
   GLint GetUniformLocationHelper(GLuint program, const char* name);
   GLint GetFragDataIndexEXTHelper(GLuint program, const char* name);
   GLint GetFragDataLocationHelper(GLuint program, const char* name);
   bool GetActiveAttribHelper(
       GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
       GLint* size, GLenum* type, char* name);
   bool GetActiveUniformHelper(
@@ skipping 31 matching lines @@
   // ContextSupport implementation.
   void SignalSyncToken(const gpu::SyncToken& sync_token,
                        const base::Closure& callback) override;
   void SignalQuery(uint32_t query, const base::Closure& callback) override;
   void SetAggressivelyFreeResources(bool aggressively_free_resources) override;
 
   // base::trace_event::MemoryDumpProvider implementation.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
+  void SetErrorMessageCallback(
+      GLES2ImplementationErrorMessageCallback* callback) {
+    error_message_callback_ = callback;
+  }
+
   ShareGroup* share_group() const {
     return share_group_.get();
   }
 
   const Capabilities& capabilities() const {
     return capabilities_;
   }
 
   GpuControl* gpu_control() {
     return gpu_control_;
@@ skipping 129 matching lines @@
    private:
     GLES2Implementation* gles2_implementation_;
   };
 
   // Gets the value of the result.
   template <typename T>
   T GetResultAs() {
     return static_cast<T>(GetResultBuffer());
   }
 
-  // GpuControlClient implementation.
-  void OnGpuControlLostContext() final;
-  void OnGpuControlErrorMessage(const char* message, int32_t id) final;
-
   void* GetResultBuffer();
   int32_t GetResultShmId();
   uint32_t GetResultShmOffset();
 
   bool IsChromiumFramebufferMultisampleAvailable();
 
   bool IsExtensionAvailableHelper(
       const char* extension, ExtensionStatus* status);
 
   // Gets the GLError through our wrapper.
@@ skipping 387 matching lines @@
   scoped_ptr<MappedMemoryManager> mapped_memory_;
 
   scoped_refptr<ShareGroup> share_group_;
   ShareGroupContextData share_group_context_data_;
 
   scoped_ptr<QueryTracker> query_tracker_;
   scoped_ptr<IdAllocator> query_id_allocator_;
 
   scoped_ptr<BufferTracker> buffer_tracker_;
 
-  base::Callback<void(const char*, int32_t)> error_message_callback_;
-  base::Closure lost_context_callback_;
-#if DCHECK_IS_ON()
-  bool lost_context_ = false;
-#endif
+  GLES2ImplementationErrorMessageCallback* error_message_callback_;
 
   int current_trace_stack_;
 
   GpuControl* gpu_control_;
 
   Capabilities capabilities_;
 
   // Flag to indicate whether the implementation can retain resources, or
   // whether it should aggressively free them.
   bool aggressively_free_resources_;
@@ skipping 48 matching lines @@
 
 inline bool GLES2Implementation::GetTexParameterivHelper(
     GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_