Linux/ChromeOS Chromium style checker cleanup, content/ edition.

content/browser/renderer_host/image_transport_factory.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_factory.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 190 matching lines @@
 class CompositorSwapClient
     : public base::SupportsWeakPtr<CompositorSwapClient>,
       public WebGraphicsContext3DSwapBuffersClient {
  public:
   CompositorSwapClient(ui::Compositor* compositor,
                        GpuProcessTransportFactory* factory)
       : compositor_(compositor),
         factory_(factory) {
   }
 
-  ~CompositorSwapClient() {
+  virtual ~CompositorSwapClient() {
   }
 
   virtual void OnViewContextSwapBuffersPosted() OVERRIDE {
     compositor_->OnSwapBuffersPosted();
   }
 
   virtual void OnViewContextSwapBuffersComplete() OVERRIDE {
     compositor_->OnSwapBuffersComplete();
   }
 
@@ skipping 205 matching lines @@
     handle.parent_client_id = shared_context_->GetChannelID();
 
     return handle;
   }
 
   virtual void DestroySharedSurfaceHandle(
       gfx::GLSurfaceHandle surface) OVERRIDE {
   }
 
   virtual scoped_refptr<ui::Texture> CreateTransportClient(
-      float device_scale_factor) {
+      float device_scale_factor) OVERRIDE {
     if (!shared_context_.get())
         return NULL;
     scoped_refptr<ImageTransportClientTexture> image(
         new ImageTransportClientTexture(shared_context_.get(),
                                         device_scale_factor));
     return image;
   }
 
   virtual scoped_refptr<ui::Texture> CreateOwnedTexture(
       const gfx::Size& size,
       float device_scale_factor,
       unsigned int texture_id) OVERRIDE {
     if (!shared_context_.get())
         return NULL;
     scoped_refptr<OwnedTexture> image(
         new OwnedTexture(shared_context_.get(), size, device_scale_factor,
                          texture_id));
     return image;
   }
 
-  virtual GLHelper* GetGLHelper() {
+  virtual GLHelper* GetGLHelper() OVERRIDE {
     if (!gl_helper_.get()) {
       CreateSharedContextLazy();
       WebKit::WebGraphicsContext3D* context_for_thread =
           CreateOffscreenContext();
       if (!context_for_thread)
         return NULL;
       gl_helper_.reset(new GLHelper(shared_context_.get(),
                                     context_for_thread));
     }
     return gl_helper_.get();
   }
 
   virtual uint32 InsertSyncPoint() OVERRIDE {
     if (!shared_context_.get())
       return 0;
     return shared_context_->insertSyncPoint();
   }
 
-  virtual void AddObserver(ImageTransportFactoryObserver* observer) {
+  virtual void AddObserver(ImageTransportFactoryObserver* observer) OVERRIDE {
     observer_list_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(ImageTransportFactoryObserver* observer) {
+  virtual void RemoveObserver(
+      ImageTransportFactoryObserver* observer) OVERRIDE {
     observer_list_.RemoveObserver(observer);
   }
 
   // WebGraphicsContextLostCallback implementation, called for the shared
   // context.
   virtual void onContextLost() {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&GpuProcessTransportFactory::OnLostSharedContext,
                    callback_factory_.GetWeakPtr()));
@@ skipping 145 matching lines @@
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }
 
 }  // namespace content