Removing blink::prefix

Source/core/html/canvas/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 478 matching lines @@
 
     ~ScopedFramebufferRestorer()
     {
         m_context->restoreCurrentFramebuffer();
     }
 
 private:
     RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
-class WebGLRenderingContextLostCallback final : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextLostCallback>, public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback {
+class WebGLRenderingContextLostCallback final : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextLostCallback>, public WebGraphicsContext3D::WebGraphicsContextLostCallback {
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(WebGLRenderingContextLostCallback);
 public:
     static PassOwnPtrWillBeRawPtr<WebGLRenderingContextLostCallback> create(WebGLRenderingContextBase* context)
     {
         return adoptPtrWillBeNoop(new WebGLRenderingContextLostCallback(context));
     }
 
     virtual ~WebGLRenderingContextLostCallback() { }
 
     virtual void onContextLost() { m_context->forceLostContext(WebGLRenderingContextBase::RealLostContext, WebGLRenderingContextBase::Auto); }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_context);
     }
 
 private:
     explicit WebGLRenderingContextLostCallback(WebGLRenderingContextBase* context)
         : m_context(context) { }
 
     RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
-class WebGLRenderingContextErrorMessageCallback final : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextErrorMessageCallback>, public blink::WebGraphicsContext3D::WebGraphicsErrorMessageCallback {
+class WebGLRenderingContextErrorMessageCallback final : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextErrorMessageCallback>, public WebGraphicsContext3D::WebGraphicsErrorMessageCallback {
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(WebGLRenderingContextErrorMessageCallback);
 public:
     static PassOwnPtrWillBeRawPtr<WebGLRenderingContextErrorMessageCallback> create(WebGLRenderingContextBase* context)
     {
         return adoptPtrWillBeNoop(new WebGLRenderingContextErrorMessageCallback(context));
     }
 
     virtual ~WebGLRenderingContextErrorMessageCallback() { }
 
-    virtual void onErrorMessage(const blink::WebString& message, blink::WGC3Dint)
+    virtual void onErrorMessage(const WebString& message, WGC3Dint)
     {
         if (m_context->m_synthesizedErrorsToConsole)
             m_context->printGLErrorToConsole(message);
         InspectorInstrumentation::didFireWebGLErrorOrWarning(m_context->canvas(), message);
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_context);
     }
 
 private:
     explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContextBase* context)
         : m_context(context) { }
 
     RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
-PassOwnPtr<blink::WebGraphicsContext3D> WebGLRenderingContextBase::createWebGraphicsContext3D(HTMLCanvasElement* canvas, WebGLContextAttributes attributes, unsigned webGLVersion)
+PassOwnPtr<WebGraphicsContext3D> WebGLRenderingContextBase::createWebGraphicsContext3D(HTMLCanvasElement* canvas, WebGLContextAttributes attributes, unsigned webGLVersion)
 {
     Document& document = canvas->document();
     LocalFrame* frame = document.frame();
     if (!frame) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
     Settings* settings = frame->settings();
 
     // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
     // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
     if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled())) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
 
-    blink::WebGraphicsContext3D::Attributes wgc3dAttributes = toWebGraphicsContext3DAttributes(attributes, document.topDocument().url().string(), settings, webGLVersion);
-    blink::WebGLInfo glInfo;
-    OwnPtr<blink::WebGraphicsContext3D> context = adoptPtr(blink::Platform::current()->createOffscreenGraphicsContext3D(wgc3dAttributes, 0, &glInfo));
+    WebGraphicsContext3D::Attributes wgc3dAttributes = toWebGraphicsContext3DAttributes(attributes, document.topDocument().url().string(), settings, webGLVersion);
+    WebGLInfo glInfo;
+    OwnPtr<WebGraphicsContext3D> context = adoptPtr(Platform::current()->createOffscreenGraphicsContext3D(wgc3dAttributes, 0, &glInfo));
     if (!context || shouldFailContextCreationForTesting) {
         shouldFailContextCreationForTesting = false;
         String statusMessage;
         if (!glInfo.contextInfoCollectionFailure.isEmpty()) {
             statusMessage.append("Could not create a WebGL context. ");
             statusMessage.append(glInfo.contextInfoCollectionFailure);
             String vendorId = String::number(glInfo.vendorId);
             String deviceId = String::number(glInfo.deviceId);
             if (vendorId.isEmpty())
                 statusMessage.append("VendorId = Not Available");
@@ skipping 30 matching lines @@
     }
 
     return context.release();
 }
 
 void WebGLRenderingContextBase::forceNextWebGLContextCreationToFail()
 {
     shouldFailContextCreationForTesting = true;
 }
 
-WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, PassOwnPtr<blink::WebGraphicsContext3D> context, const WebGLContextAttributes& requestedAttributes)
+WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, PassOwnPtr<WebGraphicsContext3D> context, const WebGLContextAttributes& requestedAttributes)
     : CanvasRenderingContext(passedCanvas)
     , m_contextLostMode(NotLostContext)
     , m_autoRecoveryMethod(Manual)
     , m_dispatchContextLostEventTimer(this, &WebGLRenderingContextBase::dispatchContextLostEvent)
     , m_restoreAllowed(false)
     , m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext)
     , m_generatedImageCache(4)
     , m_requestedAttributes(requestedAttributes)
     , m_synthesizedErrorsToConsole(true)
     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
@@ skipping 16 matching lines @@
 #if ENABLE(OILPAN)
     m_sharedWebGraphicsContext3D = WebGLSharedWebGraphicsContext3D::create(buffer.release());
 #else
     m_drawingBuffer = buffer.release();
 #endif
 
     drawingBuffer()->bind();
     setupFlags();
 }
 
-PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(PassOwnPtr<blink::WebGraphicsContext3D> context)
+PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(PassOwnPtr<WebGraphicsContext3D> context)
 {
-    blink::WebGraphicsContext3D::Attributes attrs;
+    WebGraphicsContext3D::Attributes attrs;
     attrs.alpha = m_requestedAttributes.alpha();
     attrs.depth = m_requestedAttributes.depth();
     attrs.stencil = m_requestedAttributes.stencil();
     attrs.antialias = m_requestedAttributes.antialias();
     attrs.premultipliedAlpha = m_requestedAttributes.premultipliedAlpha();
     DrawingBuffer::PreserveDrawingBuffer preserve = m_requestedAttributes.preserveDrawingBuffer() ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
     return DrawingBuffer::create(context, clampedCanvasSize(), preserve, attrs);
 }
 
 void WebGLRenderingContextBase::initializeNewContext()
@@ skipping 1438 matching lines @@
     if (needToResetMinFilter)
         webContext()->texParameteri(target, GL_TEXTURE_MIN_FILTER, tex->getMinFilter());
 #endif
     tex->generateMipmapLevelInfo();
 }
 
 PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveAttrib", program))
         return nullptr;
-    blink::WebGraphicsContext3D::ActiveInfo info;
+    WebGraphicsContext3D::ActiveInfo info;
     if (!webContext()->getActiveAttrib(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
 PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniform", program))
         return nullptr;
-    blink::WebGraphicsContext3D::ActiveInfo info;
+    WebGraphicsContext3D::ActiveInfo info;
     if (!webContext()->getActiveUniform(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
 Nullable<WillBeHeapVector<RefPtrWillBeMember<WebGLShader>>> WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
         return nullptr;
 
@@ skipping 68 matching lines @@
     }
 }
 
 void WebGLRenderingContextBase::getContextAttributes(Nullable<WebGLContextAttributes>& result)
 {
     if (isContextLost())
         return;
     result.set(m_requestedAttributes);
     // Some requested attributes may not be honored, so we need to query the underlying
     // context/drawing buffer and adjust accordingly.
-    blink::WebGraphicsContext3D::Attributes attrs = drawingBuffer()->getActualAttributes();
+    WebGraphicsContext3D::Attributes attrs = drawingBuffer()->getActualAttributes();
     if (m_requestedAttributes.depth() && !attrs.depth)
         result.get().setDepth(false);
     if (m_requestedAttributes.stencil() && !attrs.stencil)
         result.get().setStencil(false);
     result.get().setAntialias(drawingBuffer()->multisample());
 }
 
 GLenum WebGLRenderingContextBase::getError()
 {
     if (m_lostContextErrors.size()) {
@@ skipping 577 matching lines @@
     if (!uniformLocation || uniformLocation->program() != program) {
         synthesizeGLError(GL_INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");
         return ScriptValue::createNull(scriptState);
     }
     GLint location = uniformLocation->location();
 
     // FIXME: make this more efficient using WebGLUniformLocation and caching types in it
     GLint activeUniforms = 0;
     webContext()->getProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORMS, &activeUniforms);
     for (GLint i = 0; i < activeUniforms; i++) {
-        blink::WebGraphicsContext3D::ActiveInfo info;
+        WebGraphicsContext3D::ActiveInfo info;
         if (!webContext()->getActiveUniform(objectOrZero(program), i, info))
             return ScriptValue::createNull(scriptState);
         String name = info.name;
         StringBuilder nameBuilder;
         // Strip "[0]" from the name if it's an array.
         if (info.size > 1 && name.endsWith("[0]"))
             info.name = name.left(name.length() - 3);
         // If it's an array, we need to iterate through each element, appending "[index]" to the name.
         for (GLint index = 0; index < info.size; ++index) {
             nameBuilder.clear();
@@ skipping 464 matching lines @@
         break;
     case GL_HALF_FLOAT_OES:
         expectedViewType = DOMArrayBufferView::TypeUint16;
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "readPixels", "invalid type");
         return;
     }
     if (format != GL_RGBA || type != GL_UNSIGNED_BYTE) {
         // Check against the implementation color read format and type.
-        blink::WGC3Dint implFormat = 0, implType = 0;
+        WGC3Dint implFormat = 0, implType = 0;
         webContext()->getIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &implFormat);
         webContext()->getIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &implType);
         if (!implFormat || !implType || format != static_cast<GLenum>(implFormat) || type != static_cast<GLenum>(implType)) {
             synthesizeGLError(GL_INVALID_OPERATION, "readPixels", "format/type not RGBA/UNSIGNED_BYTE or implementation-defined values");
             return;
         }
     }
     // Validate array type against pixel type.
     if (pixels->type() != expectedViewType) {
         synthesizeGLError(GL_INVALID_OPERATION, "readPixels", "ArrayBufferView was the wrong type for the pixel format");
@@ skipping 1322 matching lines @@
     if (!m_restoreAllowed) {
         if (m_contextLostMode == WebGLLoseContextLostContext)
             synthesizeGLError(GL_INVALID_OPERATION, "restoreContext", "context restoration not allowed");
         return;
     }
 
     if (!m_restoreTimer.isActive())
         m_restoreTimer.startOneShot(0, FROM_HERE);
 }
 
-blink::WebLayer* WebGLRenderingContextBase::platformLayer() const
+WebLayer* WebGLRenderingContextBase::platformLayer() const
 {
     return isContextLost() ? 0 : drawingBuffer()->platformLayer();
 }
 
 void WebGLRenderingContextBase::setFilterQuality(SkFilterQuality filterQuality)
 {
     if (!isContextLost() && drawingBuffer()) {
         drawingBuffer()->setFilterQuality(filterQuality);
     }
 }
@@ skipping 1211 matching lines @@
     // If the context was lost due to RealLostContext, we need to destroy the old DrawingBuffer before creating new DrawingBuffer to ensure resource budget enough.
     if (drawingBuffer()) {
 #if ENABLE(OILPAN)
         m_sharedWebGraphicsContext3D->dispose();
 #else
         m_drawingBuffer->beginDestruction();
         m_drawingBuffer.clear();
 #endif
     }
 
-    blink::WebGraphicsContext3D::Attributes attributes = toWebGraphicsContext3DAttributes(m_requestedAttributes, canvas()->document().topDocument().url().string(), settings, version());
-    OwnPtr<blink::WebGraphicsContext3D> context = adoptPtr(blink::Platform::current()->createOffscreenGraphicsContext3D(attributes, 0));
+    WebGraphicsContext3D::Attributes attributes = toWebGraphicsContext3DAttributes(m_requestedAttributes, canvas()->document().topDocument().url().string(), settings, version());
+    OwnPtr<WebGraphicsContext3D> context = adoptPtr(Platform::current()->createOffscreenGraphicsContext3D(attributes, 0));
     RefPtr<DrawingBuffer> buffer;
     if (context) {
         // Construct a new drawing buffer with the new WebGraphicsContext3D.
         buffer = createDrawingBuffer(context.release());
         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
     if (!buffer) {
         if (m_contextLostMode == RealLostContext) {
             m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts, FROM_HERE);
         } else {
@@ skipping 296 matching lines @@
     return m_sharedWebGraphicsContext3D ? m_sharedWebGraphicsContext3D->drawingBuffer() : 0;
 }
 #else
 DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
 {
     return m_drawingBuffer.get();
 }
 #endif
 
 } // namespace blink