Rename WebKit namespace to blink (part 3)

content/browser/aura/gpu_process_transport_factory.cc

 // Copyright (c) 2013 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/aura/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 37 matching lines @@
   int surface_id;
   scoped_ptr<CompositorSwapClient> swap_client;
 #if defined(OS_WIN)
   scoped_ptr<AcceleratedSurface> accelerated_surface;
 #endif
   scoped_refptr<ReflectorImpl> reflector;
 };
 
 class OwnedTexture : public ui::Texture, ImageTransportFactoryObserver {
  public:
-  OwnedTexture(WebKit::WebGraphicsContext3D* host_context,
+  OwnedTexture(blink::WebGraphicsContext3D* host_context,
                const gfx::Size& size,
                float device_scale_factor,
                unsigned int texture_id)
       : ui::Texture(true, size, device_scale_factor),
         host_context_(host_context),
         texture_id_(texture_id) {
     ImageTransportFactory::GetInstance()->AddObserver(this);
   }
 
   // ui::Texture overrides:
   virtual unsigned int PrepareTexture() OVERRIDE {
     if (!host_context_ || host_context_->isContextLost())
       return 0u;
     return texture_id_;
   }
 
-  virtual WebKit::WebGraphicsContext3D* HostContext3D() OVERRIDE {
+  virtual blink::WebGraphicsContext3D* HostContext3D() OVERRIDE {
     return host_context_;
   }
 
   // ImageTransportFactory overrides:
   virtual void OnLostResources() OVERRIDE {
     DeleteTexture();
     host_context_ = NULL;
   }
 
  protected:
   virtual ~OwnedTexture() {
     ImageTransportFactory::GetInstance()->RemoveObserver(this);
     DeleteTexture();
   }
 
  protected:
   void DeleteTexture() {
     if (texture_id_) {
       host_context_->deleteTexture(texture_id_);
       texture_id_ = 0;
     }
   }
 
   // The OnLostResources() callback will happen before this context
   // pointer is destroyed.
-  WebKit::WebGraphicsContext3D* host_context_;
+  blink::WebGraphicsContext3D* host_context_;
   unsigned texture_id_;
 
   DISALLOW_COPY_AND_ASSIGN(OwnedTexture);
 };
 
 class ImageTransportClientTexture : public OwnedTexture {
  public:
   ImageTransportClientTexture(
-      WebKit::WebGraphicsContext3D* host_context,
+      blink::WebGraphicsContext3D* host_context,
       float device_scale_factor)
       : OwnedTexture(host_context,
                      gfx::Size(0, 0),
                      device_scale_factor,
                      host_context->createTexture()) {
   }
 
   virtual void Consume(const std::string& mailbox_name,
                        const gfx::Size& new_size) OVERRIDE {
     DCHECK(mailbox_name.size() == GL_MAILBOX_SIZE_CHROMIUM);
@@ skipping 369 matching lines @@
 
   return data;
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 GpuProcessTransportFactory::CreateContextCommon(
     const base::WeakPtr<WebGraphicsContext3DSwapBuffersClient>& swap_client,
     int surface_id) {
   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
-  WebKit::WebGraphicsContext3D::Attributes attrs;
+  blink::WebGraphicsContext3D::Attributes attrs;
   attrs.shareResources = true;
   attrs.depth = false;
   attrs.stencil = false;
   attrs.antialias = false;
   attrs.noAutomaticFlushes = true;
   scoped_refptr<GpuChannelHost> gpu_channel_host(
       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE));
   if (!gpu_channel_host)
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
@@ skipping 37 matching lines @@
                     observer_list_,
                     OnLostResources());
 
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_offscreen_compositor_contexts = NULL;
   lost_shared_main_thread_contexts  = NULL;
 }
 
 }  // namespace content