Reducing code duplication between WGC3D(InProcess)CommandBufferImpl

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 <GLES2/gl2.h>
 
 #include <map>
@@ skipping 92 matching lines @@
 
 class GpuControl;
 class ScopedTransferBufferPtr;
 class TransferBufferInterface;
 
 namespace gles2 {
 
 class ImageFactory;
 class VertexArrayObjectManager;
 
+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) {
  public:
   enum MappedMemoryLimit {
     kNoLimit = MappedMemoryManager::kNoLimit,
   };
-  class ErrorMessageCallback {
-   public:
-    virtual ~ErrorMessageCallback() { }
-    virtual void OnErrorMessage(const char* msg, int id) = 0;
-  };
 
   // Stores GL state that never changes.
   struct GLES2_IMPL_EXPORT GLStaticState {
     GLStaticState();
     ~GLStaticState();
 
     struct GLES2_IMPL_EXPORT IntState {
       IntState();
       GLint max_combined_texture_image_units;
       GLint max_cube_map_texture_size;
@@ skipping 101 matching lines @@
 
   // ContextSupport implementation.
   virtual void SignalSyncPoint(uint32 sync_point,
                                const base::Closure& callback) OVERRIDE;
   virtual void SignalQuery(uint32 query,
                            const base::Closure& callback) OVERRIDE;
   virtual void SetSurfaceVisible(bool visible) OVERRIDE;
   virtual void SendManagedMemoryStats(const ManagedMemoryStats& stats)
       OVERRIDE;
 
-  void SetErrorMessageCallback(ErrorMessageCallback* callback) {
+  void SetErrorMessageCallback(
+      GLES2ImplementationErrorMessageCallback* callback) {
     error_message_callback_ = callback;
   }
 
   ShareGroup* share_group() const {
     return share_group_.get();
   }
 
   const Capabilities& capabilities() const {
     return capabilities_;
   }
@@ skipping 499 matching lines @@
   ShareGroupContextData share_group_context_data_;
 
   scoped_ptr<QueryTracker> query_tracker_;
   typedef std::map<GLuint, QueryTracker::Query*> QueryMap;
   QueryMap current_queries_;
 
   scoped_ptr<BufferTracker> buffer_tracker_;
 
   scoped_ptr<GpuMemoryBufferTracker> gpu_memory_buffer_tracker_;
 
-  ErrorMessageCallback* error_message_callback_;
+  GLES2ImplementationErrorMessageCallback* error_message_callback_;
 
   scoped_ptr<std::string> current_trace_name_;
 
   GpuControl* gpu_control_;
 
   Capabilities capabilities_;
 
   base::Closure swap_buffers_complete_callback_;
 
   base::WeakPtrFactory<GLES2Implementation> weak_ptr_factory_;
@@ skipping 31 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_