Rename WebKit namespace to blink (part 5)

webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.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 WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_
 #define WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "ui/gfx/native_widget_types.h"
 #include "webkit/common/gpu/webkit_gpu_export.h"
 
 namespace gpu {
 class ContextSupport;
 
 namespace gles2 {
 class GLES2Implementation;
 }
 }
 
-using WebKit::WebGLId;
+using blink::WebGLId;
 
-using WebKit::WGC3Dbyte;
-using WebKit::WGC3Dchar;
-using WebKit::WGC3Denum;
-using WebKit::WGC3Dboolean;
-using WebKit::WGC3Dbitfield;
-using WebKit::WGC3Dint;
-using WebKit::WGC3Dsizei;
-using WebKit::WGC3Duint;
-using WebKit::WGC3Dfloat;
-using WebKit::WGC3Dclampf;
-using WebKit::WGC3Dintptr;
-using WebKit::WGC3Dsizeiptr;
+using blink::WGC3Dbyte;
+using blink::WGC3Dchar;
+using blink::WGC3Denum;
+using blink::WGC3Dboolean;
+using blink::WGC3Dbitfield;
+using blink::WGC3Dint;
+using blink::WGC3Dsizei;
+using blink::WGC3Duint;
+using blink::WGC3Dfloat;
+using blink::WGC3Dclampf;
+using blink::WGC3Dintptr;
+using blink::WGC3Dsizeiptr;
 
 namespace gpu {
 class GLInProcessContext;
 struct GLInProcessContextAttribs;
 }
 
 namespace webkit {
 namespace gpu {
 
 class WEBKIT_GPU_EXPORT WebGraphicsContext3DInProcessCommandBufferImpl
-    : public NON_EXPORTED_BASE(WebKit::WebGraphicsContext3D) {
+    : public NON_EXPORTED_BASE(blink::WebGraphicsContext3D) {
  public:
   static scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
       CreateViewContext(
-          const WebKit::WebGraphicsContext3D::Attributes& attributes,
+          const blink::WebGraphicsContext3D::Attributes& attributes,
           gfx::AcceleratedWidget window);
 
   static scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
       CreateOffscreenContext(
-          const WebKit::WebGraphicsContext3D::Attributes& attributes);
+          const blink::WebGraphicsContext3D::Attributes& attributes);
 
   static scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
       WrapContext(
           scoped_ptr< ::gpu::GLInProcessContext> context,
-          const WebKit::WebGraphicsContext3D::Attributes& attributes);
+          const blink::WebGraphicsContext3D::Attributes& attributes);
 
   virtual ~WebGraphicsContext3DInProcessCommandBufferImpl();
 
   // Convert WebGL context creation attributes into GLInProcessContext / EGL
   // size requests.
   static void ConvertAttributes(
-      const WebKit::WebGraphicsContext3D::Attributes& attributes,
+      const blink::WebGraphicsContext3D::Attributes& attributes,
       ::gpu::GLInProcessContextAttribs* output_attribs);
 
   //----------------------------------------------------------------------
   // WebGraphicsContext3D methods
   virtual bool makeContextCurrent();
 
   virtual uint32_t lastFlushID();
 
   virtual void reshapeWithScaleFactor(int width, int height, float scaleFactor);
 
@@ skipping 126 matching lines @@
 
   virtual void getFramebufferAttachmentParameteriv(WGC3Denum target,
                                                    WGC3Denum attachment,
                                                    WGC3Denum pname,
                                                    WGC3Dint* value);
 
   virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value);
 
   virtual void getProgramiv(WebGLId program, WGC3Denum pname, WGC3Dint* value);
 
-  virtual WebKit::WebString getProgramInfoLog(WebGLId program);
+  virtual blink::WebString getProgramInfoLog(WebGLId program);
 
   virtual void getRenderbufferParameteriv(WGC3Denum target,
                                           WGC3Denum pname,
                                           WGC3Dint* value);
 
   virtual void getShaderiv(WebGLId shader, WGC3Denum pname, WGC3Dint* value);
 
-  virtual WebKit::WebString getShaderInfoLog(WebGLId shader);
+  virtual blink::WebString getShaderInfoLog(WebGLId shader);
 
   virtual void getShaderPrecisionFormat(WGC3Denum shadertype,
                                         WGC3Denum precisiontype,
                                         WGC3Dint* range,
                                         WGC3Dint* precision);
 
-  virtual WebKit::WebString getShaderSource(WebGLId shader);
-  virtual WebKit::WebString getString(WGC3Denum name);
+  virtual blink::WebString getShaderSource(WebGLId shader);
+  virtual blink::WebString getString(WGC3Denum name);
 
   virtual void getTexParameterfv(WGC3Denum target,
                                  WGC3Denum pname,
                                  WGC3Dfloat* value);
   virtual void getTexParameteriv(WGC3Denum target,
                                  WGC3Denum pname,
                                  WGC3Dint* value);
 
   virtual void getUniformfv(WebGLId program,
                             WGC3Dint location,
@@ skipping 200 matching lines @@
                                      WGC3Dsizei numAttachments,
                                      const WGC3Denum* attachments);
   virtual void discardBackbufferCHROMIUM();
   virtual void ensureBackbufferCHROMIUM();
 
   virtual void copyTextureToParentTextureCHROMIUM(
       WebGLId texture, WebGLId parentTexture);
 
   virtual void rateLimitOffscreenContextCHROMIUM();
 
-  virtual WebKit::WebString getRequestableExtensionsCHROMIUM();
+  virtual blink::WebString getRequestableExtensionsCHROMIUM();
   virtual void requestExtensionCHROMIUM(const char*);
 
   virtual void blitFramebufferCHROMIUM(
       WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1,
       WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1,
       WGC3Dbitfield mask, WGC3Denum filter);
   virtual void renderbufferStorageMultisampleCHROMIUM(
       WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat,
       WGC3Dsizei width, WGC3Dsizei height);
 
-  virtual WebKit::WebString getTranslatedShaderSourceANGLE(WebGLId shader);
+  virtual blink::WebString getTranslatedShaderSourceANGLE(WebGLId shader);
 
   virtual void setContextLostCallback(
       WebGraphicsContext3D::WebGraphicsContextLostCallback* callback);
   virtual WGC3Denum getGraphicsResetStatusARB();
 
   virtual void texImageIOSurface2DCHROMIUM(
       WGC3Denum target, WGC3Dint width, WGC3Dint height,
       WGC3Duint ioSurfaceId, WGC3Duint plane);
 
   virtual void bindTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint imageId);
@@ skipping 75 matching lines @@
 
   virtual void loseContextCHROMIUM(WGC3Denum current, WGC3Denum other);
 
   virtual GrGLInterface* createGrGLInterface();
 
   ::gpu::ContextSupport* GetContextSupport();
 
  private:
   WebGraphicsContext3DInProcessCommandBufferImpl(
       scoped_ptr< ::gpu::GLInProcessContext> context,
-      const WebKit::WebGraphicsContext3D::Attributes& attributes,
+      const blink::WebGraphicsContext3D::Attributes& attributes,
       bool is_offscreen,
       gfx::AcceleratedWidget window);
 
   // SwapBuffers callback.
   void OnSwapBuffersComplete();
   virtual void OnContextLost();
 
   bool MaybeInitializeGL();
 
   // Used to try to find bugs in code that calls gl directly through the gl api
   // instead of going through WebGraphicsContext3D.
   void ClearContext();
 
   bool is_offscreen_;
   // Only used when not offscreen.
   gfx::AcceleratedWidget window_;
 
   bool initialized_;
   bool initialize_failed_;
 
   // The context we use for OpenGL rendering.
   scoped_ptr< ::gpu::GLInProcessContext> context_;
   // The GLES2Implementation we use for OpenGL rendering.
   ::gpu::gles2::GLES2Implementation* gl_;
 
   WebGraphicsContext3D::WebGraphicsContextLostCallback* context_lost_callback_;
   WGC3Denum context_lost_reason_;
 
-  WebKit::WebGraphicsContext3D::Attributes attributes_;
+  blink::WebGraphicsContext3D::Attributes attributes_;
 
   // Errors raised by synthesizeGLError().
   std::vector<WGC3Denum> synthetic_errors_;
 
   uint32_t flush_id_;
 };
 
 }  // namespace gpu
 }  // namespace webkit
 
 #endif  // WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_