blink: Remove unused or rarely used methods from WebGraphicsContext3D

third_party/WebKit/public/platform/WebGraphicsContext3D.h

 /*
  * Copyright (C) 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 123 matching lines @@
         virtual ~WebGraphicsErrorMessageCallback() { }
     };
 
     // This destructor needs to be public so that using classes can destroy instances if initialization fails.
     virtual ~WebGraphicsContext3D() { }
 
     // Each flush or finish is assigned an unique ID. The larger
     // the ID number, the more recently the context has been flushed.
     virtual uint32_t lastFlushID() { return 0; }
 
-    // Resizes the region into which this WebGraphicsContext3D is drawing.
-    virtual void reshapeWithScaleFactor(int width, int height, float scaleFactor) { }

[Ken Russell (switch to Gerrit), 2016/03/16 00:18:22]

I think some test code will need to be deleted to handle the removal of this
method.

[danakj, 2016/03/16 00:19:28]

I can find no calls to it with grep (outside of cc tests which are unrelated).
Where are you thinking?

[Ken Russell (switch to Gerrit), 2016/03/16 00:29:55]

Yes, it was the cc/ tests I found via codesearch. I see your point about the
containing class being unrelated. Never mind.

-
-    // GL_CHROMIUM_setVisibility - Changes the visibility of the backbuffer
-    virtual void setVisibilityCHROMIUM(bool visible) = 0;
-
     // GL_EXT_discard_framebuffer - makes specified attachments of currently bound framebuffer undefined.
     virtual void discardFramebufferEXT(WGC3Denum target, WGC3Dsizei numAttachments, const WGC3Denum* attachments) { }
 
-    // GL_CHROMIUM_discard_backbuffer - controls allocation/deallocation of the back buffer.
-    virtual void discardBackbufferCHROMIUM() { }
-    virtual void ensureBackbufferCHROMIUM() { }
-
     virtual WGC3Duint64 insertFenceSyncCHROMIUM() { return 0; }
     virtual bool genSyncTokenCHROMIUM(WGC3Duint64, WGC3Dbyte*) { return false; }
     virtual void waitSyncTokenCHROMIUM(const WGC3Dbyte*) {}
 
-    // Copies the contents of the off-screen render target used by the WebGL
-    // context to the corresponding texture used by the compositor.
-    virtual void prepareTexture() = 0;
-
-    // GL_CHROMIUM_post_sub_buffer - Copies part of the back buffer to the front buffer.
-    virtual void postSubBufferCHROMIUM(int x, int y, int width, int height) = 0;
-
     // Synthesizes an OpenGL error which will be returned from a
     // later call to getError. This is used to emulate OpenGL ES
     // 2.0 behavior on the desktop and to enforce additional error
     // checking mandated by WebGL.
     //
     // Per the behavior of glGetError, this stores at most one
     // instance of any given error, and returns them from calls to
     // getError in the order they were added.
     virtual void synthesizeGLError(WGC3Denum) = 0;
 
-    // GL_CHROMIUM_map_sub
-    virtual void* mapBufferSubDataCHROMIUM(WGC3Denum target, WGC3Dintptr offset, WGC3Dsizeiptr size, WGC3Denum access) = 0;
-    virtual void unmapBufferSubDataCHROMIUM(const void*) = 0;
-    virtual void* mapTexSubImage2DCHROMIUM(WGC3Denum target, WGC3Dint level, WGC3Dint xoffset, WGC3Dint yoffset, WGC3Dsizei width, WGC3Dsizei height, WGC3Denum format, WGC3Denum type, WGC3Denum access) = 0;
-    virtual void unmapTexSubImage2DCHROMIUM(const void*) = 0;
-
     // GL_CHROMIUM_request_extension
     virtual WebString getRequestableExtensionsCHROMIUM() = 0;
     virtual void requestExtensionCHROMIUM(const char*) = 0;
 
     // GL_CHROMIUM_framebuffer_multisample
     virtual void blitFramebufferCHROMIUM(WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1, WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1, WGC3Dbitfield mask, WGC3Denum filter) = 0;
     virtual void renderbufferStorageMultisampleCHROMIUM(WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height) = 0;
 
-    // GL_CHROMIUM_lose_context
-    virtual void loseContextCHROMIUM(WGC3Denum current, WGC3Denum other) { }
-
     // The entry points below map directly to the OpenGL ES 2.0 API.
     // See: http://www.khronos.org/registry/gles/
     // and: http://www.khronos.org/opengles/sdk/docs/man/
     virtual void activeTexture(WGC3Denum texture) = 0;
     virtual void attachShader(WebGLId program, WebGLId shader) = 0;
     virtual void bindAttribLocation(WebGLId program, WGC3Duint index, const WGC3Dchar* name) = 0;
     virtual void bindBuffer(WGC3Denum target, WebGLId buffer) = 0;
     virtual void bindFramebuffer(WGC3Denum target, WebGLId framebuffer) = 0;
     virtual void bindRenderbuffer(WGC3Denum target, WebGLId renderbuffer) = 0;
     virtual void bindTexture(WGC3Denum target, WebGLId texture) = 0;
@@ skipping 72 matching lines @@
     virtual WGC3Dboolean isRenderbuffer(WebGLId renderbuffer) = 0;
     virtual WGC3Dboolean isShader(WebGLId shader) = 0;
     virtual WGC3Dboolean isTexture(WebGLId texture) = 0;
     virtual void lineWidth(WGC3Dfloat) = 0;
     virtual void linkProgram(WebGLId program) = 0;
     virtual void pixelStorei(WGC3Denum pname, WGC3Dint param) = 0;
     virtual void polygonOffset(WGC3Dfloat factor, WGC3Dfloat units) = 0;
 
     virtual void readPixels(WGC3Dint x, WGC3Dint y, WGC3Dsizei width, WGC3Dsizei height, WGC3Denum format, WGC3Denum type, void* pixels) = 0;
 
-    virtual void releaseShaderCompiler() = 0;
-
     virtual void renderbufferStorage(WGC3Denum target, WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height) = 0;
     virtual void sampleCoverage(WGC3Dclampf value, WGC3Dboolean invert) = 0;
     virtual void scissor(WGC3Dint x, WGC3Dint y, WGC3Dsizei width, WGC3Dsizei height) = 0;
     virtual void shaderSource(WebGLId shader, const WGC3Dchar* string) = 0;
     virtual void stencilFunc(WGC3Denum func, WGC3Dint ref, WGC3Duint mask) = 0;
     virtual void stencilFuncSeparate(WGC3Denum face, WGC3Denum func, WGC3Dint ref, WGC3Duint mask) = 0;
     virtual void stencilMask(WGC3Duint mask) = 0;
     virtual void stencilMaskSeparate(WGC3Denum face, WGC3Duint mask) = 0;
     virtual void stencilOp(WGC3Denum fail, WGC3Denum zfail, WGC3Denum zpass) = 0;
     virtual void stencilOpSeparate(WGC3Denum face, WGC3Denum fail, WGC3Denum zfail, WGC3Denum zpass) = 0;
@@ skipping 52 matching lines @@
     virtual void deleteTexture(WebGLId) = 0;
 
     virtual WebGLId createProgram() = 0;
     virtual WebGLId createShader(WGC3Denum) = 0;
 
     virtual void deleteShader(WebGLId) = 0;
     virtual void deleteProgram(WebGLId) = 0;
 
     virtual void setContextLostCallback(WebGraphicsContextLostCallback* callback) { }
     virtual void setErrorMessageCallback(WebGraphicsErrorMessageCallback* callback) { }
-    // GL_ARB_robustness
-    //
-    // This entry point must provide slightly different semantics than
-    // the GL_ARB_robustness extension; specifically, the lost context
-    // state is sticky, rather than reported only once.
-    virtual WGC3Denum getGraphicsResetStatusARB() { return 0; /* GL_NO_ERROR */ }
 
     virtual WebString getTranslatedShaderSourceANGLE(WebGLId shader) = 0;
 
     // GL_CHROMIUM_screen_space_antialiasing
     virtual void applyScreenSpaceAntialiasingCHROMIUM() { }
 
-    // GL_CHROMIUM_iosurface
-    virtual void texImageIOSurface2DCHROMIUM(WGC3Denum target, WGC3Dint width, WGC3Dint height, WGC3Duint ioSurfaceId, WGC3Duint plane) { }
-
     // GL_EXT_texture_storage
     virtual void texStorage2DEXT(WGC3Denum target, WGC3Dint levels, WGC3Duint internalformat,
                                  WGC3Dint width, WGC3Dint height) { }
 
     // GL_EXT_occlusion_query
     virtual WebGLId createQueryEXT() { return 0; }
     virtual void deleteQueryEXT(WebGLId query) { }
     virtual WGC3Dboolean isQueryEXT(WebGLId query) { return false; }
     virtual void beginQueryEXT(WGC3Denum target, WebGLId query) { }
     virtual void endQueryEXT(WGC3Denum target) { }
     virtual void getQueryivEXT(WGC3Denum target, WGC3Denum pname, WGC3Dint* params) { }
     virtual void getQueryObjectuivEXT(WebGLId query, WGC3Denum pname, WGC3Duint* params) { }
 
     // GL_EXT_disjoint_timer_query
     virtual void queryCounterEXT(WebGLId query, WGC3Denum target) {}
     virtual void getQueryObjectui64vEXT(WebGLId query, WGC3Denum pname, WGC3Duint64* params) {}
 
-    // GL_CHROMIUM_bind_uniform_location
-    virtual void bindUniformLocationCHROMIUM(WebGLId program, WGC3Dint location, const WGC3Dchar* uniform) { }
-
     // GL_CHROMIUM_copy_texture
     virtual void copyTextureCHROMIUM(WGC3Duint sourceId,
         WGC3Duint destId, WGC3Denum internalFormat, WGC3Denum destType,
         WGC3Dboolean unpackFlipY, WGC3Dboolean unpackPremultiplyAlpha, WGC3Dboolean unpackUnmultiplyAlpha) { }
     virtual void copySubTextureCHROMIUM(WGC3Duint sourceId,
         WGC3Duint destId, WGC3Dint xoffset, WGC3Dint yoffset, WGC3Dint x,
         WGC3Dint y, WGC3Dsizei width, WGC3Dsizei height,
         WGC3Dboolean unpackFlipY, WGC3Dboolean unpackPremultiplyAlpha, WGC3Dboolean unpackUnmultiplyAlpha) { }
 
-    // GL_CHROMIUM_shallow_flush
-    virtual void shallowFlushCHROMIUM() { }
-    virtual void shallowFinishCHROMIUM() { }
-
     // GL_CHROMIUM_subscribe_uniform
     virtual void genValuebuffersCHROMIUM(WGC3Dsizei count, WebGLId* ids) { }
     virtual WebGLId createValuebufferCHROMIUM() { return 0; }
     virtual void deleteValuebuffersCHROMIUM(WGC3Dsizei count, WebGLId* ids) { }
     virtual void deleteValuebufferCHROMIUM(WebGLId) { }
     virtual WGC3Dboolean isValuebufferCHROMIUM(WebGLId renderbuffer) { return false; }
     virtual void bindValuebufferCHROMIUM(WGC3Denum target, WebGLId valuebuffer) { }
     virtual void subscribeValueCHROMIUM(WGC3Denum target, WGC3Denum subscription) { }
     virtual void populateSubscribedValuesCHROMIUM(WGC3Denum target) { }
     virtual void uniformValuebufferCHROMIUM(WGC3Dint location, WGC3Denum target, WGC3Denum subscription) { }
 
     // GL_CHROMIUM_texture_mailbox
     virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) { }
     virtual void produceTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox) { }
     virtual void produceTextureDirectCHROMIUM(WebGLId texture, WGC3Denum target, const WGC3Dbyte* mailbox) { }
 
-    virtual void consumeTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox) { }
     virtual WebGLId createAndConsumeTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox) { return 0; }
 
     // GL_EXT_debug_marker
-    virtual void insertEventMarkerEXT(const WGC3Dchar* marker) { }
     virtual void pushGroupMarkerEXT(const WGC3Dchar* marker) { }
-    virtual void popGroupMarkerEXT(void) { }
-
-    // GL_CHROMIUM_trace_marker
-    virtual void traceBeginCHROMIUM(const WGC3Dchar* category, const WGC3Dchar* trace) { }
-    virtual void traceEndCHROMIUM() { }
 
     // GL_OES_vertex_array_object
     virtual WebGLId createVertexArrayOES() { return 0; }
     virtual void deleteVertexArrayOES(WebGLId array) { }
     virtual WGC3Dboolean isVertexArrayOES(WebGLId array) { return false; }
     virtual void bindVertexArrayOES(WebGLId array) { }
 
     // GL_CHROMIUM_texture_from_image
     virtual void bindTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint imageId) { }
     virtual void releaseTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint imageId) { }
 
-    // GL_CHROMIUM_pixel_transfer_buffer_object
-    virtual void* mapBufferCHROMIUM(WGC3Denum target, WGC3Denum access) { return nullptr; }
-    virtual WGC3Dboolean unmapBufferCHROMIUM(WGC3Denum target) { return false; }
-
-    // GL_CHROMIUM_async_pixel_transfers
-    virtual void asyncTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint level, WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height, WGC3Dint border, WGC3Denum format, WGC3Denum type, const void* pixels) { }
-    virtual void asyncTexSubImage2DCHROMIUM(WGC3Denum target, WGC3Dint level, WGC3Dint xoffset, WGC3Dint yoffset, WGC3Dsizei width, WGC3Dsizei height, WGC3Denum format, WGC3Denum type, const void* pixels) { }
-    virtual void waitAsyncTexImage2DCHROMIUM(WGC3Denum) { }
-
     // GL_EXT_draw_buffers
     virtual void drawBuffersEXT(WGC3Dsizei n, const WGC3Denum* bufs) { }
 
     // GL_CHROMIUM_image
     virtual void destroyImageCHROMIUM(WGC3Duint imageId) { }
 
     // GL_CHROMIUM_gpu_memory_buffer_image
     virtual WGC3Duint createGpuMemoryBufferImageCHROMIUM(WGC3Dsizei width, WGC3Dsizei height, WGC3Denum internalformat, WGC3Denum usage) { return 0; }
 
     // GL_ANGLE_instanced_arrays
@@ skipping 89 matching lines @@
     virtual void vertexAttribIPointer(WGC3Duint index, WGC3Dint size, WGC3Denum type, WGC3Dsizei stride, WGC3Dintptr pointer) { }
     virtual void waitSync(WGC3Dsync sync, WGC3Dbitfield flags, WGC3Duint64 timeout) { }
 
     // Prefer getting a GLES2Interface off WebGraphicsContext3DProvider if possible, and avoid using WebGraphicsContext3D at all.
     virtual gpu::gles2::GLES2Interface* getGLES2Interface() = 0;
 };
 
 } // namespace blink
 
 #endif