RefCounted types should not have public destructors, chromeos edition

content/browser/renderer_host/image_transport_client_linux.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 "content/browser/renderer_host/image_transport_client.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xcomposite.h>
 
 #include "base/debug/trace_event.h"
@@ skipping 31 matching lines @@
 }
 
 class ImageTransportClientEGL : public ImageTransportClient {
  public:
   ImageTransportClientEGL(ImageTransportFactory* factory, const gfx::Size& size)
       : ImageTransportClient(true, size),
         factory_(factory),
         image_(NULL) {
   }
 
-  virtual ~ImageTransportClientEGL() {
-    scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
-    if (image_)
-      eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), image_);
-    unsigned int texture = texture_id();
-    if (texture)
-      glDeleteTextures(1, &texture);
-    glFlush();
-  }
-
-  virtual bool Initialize(uint64* surface_handle) {
+  virtual bool Initialize(uint64* surface_handle) OVERRIDE {
     scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
     image_ = eglCreateImageKHR(
         gfx::GLSurfaceEGL::GetHardwareDisplay(), EGL_NO_CONTEXT,
         EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<void*>(*surface_handle), NULL);
     if (!image_)
       return false;
     set_texture_id(CreateTexture());
     glBindTexture(GL_TEXTURE_2D, texture_id());
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image_);
     glFlush();
     return true;
   }
 
-  virtual void Update() { }
-  virtual TransportDIB::Handle Handle() const {
+  virtual void Update() OVERRIDE {}
+  virtual TransportDIB::Handle Handle() const OVERRIDE {
     return TransportDIB::DefaultHandleValue();
   }
 
+ protected:
+  virtual ~ImageTransportClientEGL() {
+    scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
+    if (image_)
+      eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), image_);
+    unsigned int texture = texture_id();
+    if (texture)
+      glDeleteTextures(1, &texture);
+    glFlush();
+  }
+
  private:
   ImageTransportFactory* factory_;
   EGLImageKHR image_;
 };
 
 class ImageTransportClientGLX : public ImageTransportClient {
  public:
   ImageTransportClientGLX(ImageTransportFactory* factory, const gfx::Size& size)
       : ImageTransportClient(false, size),
         factory_(factory),
         pixmap_(0),
         glx_pixmap_(0),
         acquired_(false) {
   }
 
-  virtual ~ImageTransportClientGLX() {
-    scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
-    Display* dpy = base::MessagePumpForUI::GetDefaultXDisplay();
-    if (glx_pixmap_) {
-      if (acquired_)
-        glXReleaseTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT);
-      glXDestroyGLXPixmap(dpy, glx_pixmap_);
-    }
-    if (pixmap_)
-      XFreePixmap(dpy, pixmap_);
-    unsigned int texture = texture_id();
-    if (texture)
-      glDeleteTextures(1, &texture);
-    glFlush();
-  }
-
-  virtual bool Initialize(uint64* surface_handle) {
+  virtual bool Initialize(uint64* surface_handle) OVERRIDE {
     TRACE_EVENT0("renderer_host", "ImageTransportClientGLX::Initialize");
     Display* dpy = base::MessagePumpForUI::GetDefaultXDisplay();
 
     scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
     if (!InitializeOneOff(dpy))
       return false;
 
     // Create pixmap from window.
     // We receive a window here rather than a pixmap directly because drivers
     // require (or required) that the pixmap used to create the GL texture be
     // created in the same process as the texture.
     pixmap_ = XCompositeNameWindowPixmap(dpy, *surface_handle);
 
     const int pixmapAttribs[] = {
       GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
       GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
       0
     };
 
     glx_pixmap_ = glXCreatePixmap(dpy, fbconfig_.Get(), pixmap_, pixmapAttribs);
 
     set_texture_id(CreateTexture());
     glFlush();
     return true;
   }
 
-  virtual void Update() {
+  virtual void Update() OVERRIDE {
     TRACE_EVENT0("renderer_host", "ImageTransportClientGLX::Update");
     Display* dpy = base::MessagePumpForUI::GetDefaultXDisplay();
     scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
     glBindTexture(GL_TEXTURE_2D, texture_id());
     if (acquired_)
       glXReleaseTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT);
     glXBindTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT, NULL);
     acquired_ = true;
     glFlush();
   }
 
-  virtual TransportDIB::Handle Handle() const {
+  virtual TransportDIB::Handle Handle() const OVERRIDE {
     return TransportDIB::DefaultHandleValue();
   }
 
+ protected:
+  virtual ~ImageTransportClientGLX() {
+    scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
+    Display* dpy = base::MessagePumpForUI::GetDefaultXDisplay();
+    if (glx_pixmap_) {
+      if (acquired_)
+        glXReleaseTexImageEXT(dpy, glx_pixmap_, GLX_FRONT_LEFT_EXT);
+      glXDestroyGLXPixmap(dpy, glx_pixmap_);
+    }
+    if (pixmap_)
+      XFreePixmap(dpy, pixmap_);
+    unsigned int texture = texture_id();
+    if (texture)
+      glDeleteTextures(1, &texture);
+    glFlush();
+  }
+
  private:
   static bool InitializeOneOff(Display* dpy) {
     static bool initialized = false;
     if (initialized)
       return true;
 
     int event_base, error_base;
     if (XCompositeQueryExtension(dpy, &event_base, &error_base)) {
       int major = 0, minor = 2;
       XCompositeQueryVersion(dpy, &major, &minor);
@@ skipping 65 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 class ImageTransportClientOSMesa : public ImageTransportClient {
  public:
   ImageTransportClientOSMesa(ImageTransportFactory* factory,
                              const gfx::Size& size)
       : ImageTransportClient(false, size),
         factory_(factory) {
   }
 
-  virtual ~ImageTransportClientOSMesa() {
-    unsigned int texture = texture_id();
-    if (texture) {
-      scoped_ptr<gfx::ScopedMakeCurrent> bind(
-          factory_->GetScopedMakeCurrent());
-      glDeleteTextures(1, &texture);
-      glFlush();
-    }
-  }
-
-  virtual bool Initialize(uint64* surface_handle) {
+  virtual bool Initialize(uint64* surface_handle) OVERRIDE {
     // We expect to make the handle here, so don't want the other end giving us
     // one.
     DCHECK_EQ(*surface_handle, static_cast<uint64>(0));
 
     // It's possible that this ID gneration could clash with IDs from other
     // AcceleratedSurfaceContainerTouch* objects, however we should never have
     // ids active from more than one type at the same time, so we have free
     // reign of the id namespace.
     *surface_handle = next_handle_++;
 
     shared_mem_.reset(
         TransportDIB::Create(size().GetArea() * 4,  // GL_RGBA=4 B/px
         *surface_handle));
     if (!shared_mem_.get())
       return false;
 
     scoped_ptr<gfx::ScopedMakeCurrent> bind(factory_->GetScopedMakeCurrent());
     set_texture_id(CreateTexture());
     glFlush();
     return true;
   }
 
-  virtual void Update() {
+  virtual void Update() OVERRIDE {
     glBindTexture(GL_TEXTURE_2D, texture_id());
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
                  size().width(), size().height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, shared_mem_->memory());
     glFlush();
   }
 
-  virtual TransportDIB::Handle Handle() const { return shared_mem_->handle(); }
+  virtual TransportDIB::Handle Handle() const OVERRIDE {
+    return shared_mem_->handle();
+  }
+
+ protected:
+  virtual ~ImageTransportClientOSMesa() {
+    unsigned int texture = texture_id();
+    if (texture) {
+      scoped_ptr<gfx::ScopedMakeCurrent> bind(
+          factory_->GetScopedMakeCurrent());
+      glDeleteTextures(1, &texture);
+      glFlush();
+    }
+  }
 
  private:
   ImageTransportFactory* factory_;
   scoped_ptr<TransportDIB> shared_mem_;
   static uint32 next_handle_;
 };
 uint32 ImageTransportClientOSMesa::next_handle_ = 0;
 
 }  // anonymous namespace
 
 ImageTransportClient* ImageTransportClient::Create(
     ImageTransportFactory* factory,
     const gfx::Size& size) {
   switch (gfx::GetGLImplementation()) {
     case gfx::kGLImplementationOSMesaGL:
       return new ImageTransportClientOSMesa(factory, size);
     case gfx::kGLImplementationDesktopGL:
       return new ImageTransportClientGLX(factory, size);
     case gfx::kGLImplementationEGLGLES2:
       return new ImageTransportClientEGL(factory, size);
     default:
       NOTREACHED();
       return NULL;
   }
 }