Bug 1342237 - remove Shader Editor Actor and Front; r=vporof
authoryulia <ystartsev@mozilla.com>
Wed, 13 Mar 2019 16:47:48 +0000
changeset 521737 be2c8c170852
parent 521736 7e2abdd135b8
child 521738 ed77ac3f5af9
push id10867
push userdvarga@mozilla.com
push dateThu, 14 Mar 2019 15:20:45 +0000
treeherdermozilla-beta@abad13547875 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersvporof
bugs1342237
milestone67.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1342237 - remove Shader Editor Actor and Front; r=vporof Depends on D14732 Differential Revision: https://phabricator.services.mozilla.com/D14734
devtools/server/actors/moz.build
devtools/server/actors/utils/actor-registry.js
devtools/server/actors/webgl.js
devtools/shared/fronts/moz.build
devtools/shared/fronts/webgl.js
devtools/shared/specs/index.js
devtools/shared/specs/moz.build
devtools/shared/specs/webgl.js
--- a/devtools/server/actors/moz.build
+++ b/devtools/server/actors/moz.build
@@ -57,17 +57,16 @@ DevToolsModules(
     'storage.js',
     'string.js',
     'styles.js',
     'stylesheets.js',
     'thread.js',
     'webaudio.js',
     'webbrowser.js',
     'webconsole.js',
-    'webgl.js',
 )
 
 with Files('animation.js'):
     BUG_COMPONENT = ('DevTools', 'Inspector: Animations')
 
 with Files('breakpoint.js'):
     BUG_COMPONENT = ('DevTools', 'Debugger')
 
@@ -92,11 +91,8 @@ with Files('storage.js'):
 with Files('stylesheets.js'):
     BUG_COMPONENT = ('DevTools', 'Style Editor')
 
 with Files('webaudio.js'):
     BUG_COMPONENT = ('DevTools', 'Web Audio Editor')
 
 with Files('webconsole.js'):
     BUG_COMPONENT = ('DevTools', 'Console')
-
-with Files('webgl.js'):
-    BUG_COMPONENT = ('DevTools', 'WebGL Shader Editor')
--- a/devtools/server/actors/utils/actor-registry.js
+++ b/devtools/server/actors/utils/actor-registry.js
@@ -158,21 +158,16 @@ const ActorRegistry = {
       constructor: "WebConsoleActor",
       type: { target: true },
     });
     this.registerModule("devtools/server/actors/inspector/inspector", {
       prefix: "inspector",
       constructor: "InspectorActor",
       type: { target: true },
     });
-    this.registerModule("devtools/server/actors/webgl", {
-      prefix: "webgl",
-      constructor: "WebGLActor",
-      type: { target: true },
-    });
     this.registerModule("devtools/server/actors/webaudio", {
       prefix: "webaudio",
       constructor: "WebAudioActor",
       type: { target: true },
     });
     this.registerModule("devtools/server/actors/stylesheets", {
       prefix: "styleSheets",
       constructor: "StyleSheetsActor",
deleted file mode 100644
--- a/devtools/server/actors/webgl.js
+++ /dev/null
@@ -1,1343 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-"use strict";
-
-/* global XPCNativeWrapper */
-
-const {Cu} = require("chrome");
-const EventEmitter = require("devtools/shared/event-emitter");
-const defer = require("devtools/shared/defer");
-const protocol = require("devtools/shared/protocol");
-const { ContentObserver } = require("devtools/shared/content-observer");
-const {
-  shaderSpec,
-  programSpec,
-  webGLSpec,
-} = require("devtools/shared/specs/webgl");
-
-const WEBGL_CONTEXT_NAMES = ["webgl", "experimental-webgl", "moz-webgl"];
-
-// These traits are bit masks. Make sure they're powers of 2.
-const PROGRAM_DEFAULT_TRAITS = 0;
-const PROGRAM_BLACKBOX_TRAIT = 1;
-const PROGRAM_HIGHLIGHT_TRAIT = 2;
-
-/**
- * A WebGL Shader contributing to building a WebGL Program.
- * You can either retrieve, or compile the source of a shader, which will
- * automatically inflict the necessary changes to the WebGL state.
- */
-var ShaderActor = protocol.ActorClassWithSpec(shaderSpec, {
-  /**
-   * Create the shader actor.
-   *
-   * @param DebuggerServerConnection conn
-   *        The server connection.
-   * @param WebGLProgram program
-   *        The WebGL program being linked.
-   * @param WebGLShader shader
-   *        The cooresponding vertex or fragment shader.
-   * @param WebGLProxy proxy
-   *        The proxy methods for the WebGL context owning this shader.
-   */
-  initialize: function(conn, program, shader, proxy) {
-    protocol.Actor.prototype.initialize.call(this, conn);
-    this.program = program;
-    this.shader = shader;
-    this.text = proxy.getShaderSource(shader);
-    this.linkedProxy = proxy;
-  },
-
-  /**
-   * Gets the source code for this shader.
-   */
-  getText: function() {
-    return this.text;
-  },
-
-  /**
-   * Sets and compiles new source code for this shader.
-   */
-  compile: function(text) {
-    // Get the shader and corresponding program to change via the WebGL proxy.
-    const { linkedProxy: proxy, shader, program } = this;
-
-    // Get the new shader source to inject.
-    const oldText = this.text;
-    const newText = text;
-
-    // Overwrite the shader's source.
-    const error = proxy.compileShader(program, shader, this.text = newText);
-
-    // If something went wrong, revert to the previous shader.
-    if (error.compile || error.link) {
-      proxy.compileShader(program, shader, this.text = oldText);
-      return error;
-    }
-    return undefined;
-  },
-});
-
-/**
- * A WebGL program is composed (at the moment, analogue to OpenGL ES 2.0)
- * of two shaders: a vertex shader and a fragment shader.
- */
-var ProgramActor = protocol.ActorClassWithSpec(programSpec, {
-  /**
-   * Create the program actor.
-   *
-   * @param DebuggerServerConnection conn
-   *        The server connection.
-   * @param WebGLProgram program
-   *        The WebGL program being linked.
-   * @param WebGLShader[] shaders
-   *        The WebGL program's cooresponding vertex and fragment shaders.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context owning this program.
-   * @param WebGLProxy proxy
-   *        The proxy methods for the WebGL context owning this program.
-   */
-  initialize: function(conn, [program, shaders, cache, proxy]) {
-    protocol.Actor.prototype.initialize.call(this, conn);
-    this._shaderActorsCache = { vertex: null, fragment: null };
-    this.program = program;
-    this.shaders = shaders;
-    this.linkedCache = cache;
-    this.linkedProxy = proxy;
-  },
-
-  get ownerWindow() {
-    return this.linkedCache.ownerWindow;
-  },
-
-  get ownerContext() {
-    return this.linkedCache.ownerContext;
-  },
-
-  /**
-   * Gets the vertex shader linked to this program. This method guarantees
-   * a single actor instance per shader.
-   */
-  getVertexShader: function() {
-    return this._getShaderActor("vertex");
-  },
-
-  /**
-   * Gets the fragment shader linked to this program. This method guarantees
-   * a single actor instance per shader.
-   */
-  getFragmentShader: function() {
-    return this._getShaderActor("fragment");
-  },
-
-  /**
-   * Highlights any geometry rendered using this program.
-   */
-  highlight: function(tint) {
-    this.linkedProxy.highlightTint = tint;
-    this.linkedCache.setProgramTrait(this.program, PROGRAM_HIGHLIGHT_TRAIT);
-  },
-
-  /**
-   * Allows geometry to be rendered normally using this program.
-   */
-  unhighlight: function() {
-    this.linkedCache.unsetProgramTrait(this.program, PROGRAM_HIGHLIGHT_TRAIT);
-  },
-
-  /**
-   * Prevents any geometry from being rendered using this program.
-   */
-  blackbox: function() {
-    this.linkedCache.setProgramTrait(this.program, PROGRAM_BLACKBOX_TRAIT);
-  },
-
-  /**
-   * Allows geometry to be rendered using this program.
-   */
-  unblackbox: function() {
-    this.linkedCache.unsetProgramTrait(this.program, PROGRAM_BLACKBOX_TRAIT);
-  },
-
-  /**
-   * Returns a cached ShaderActor instance based on the required shader type.
-   *
-   * @param string type
-   *        Either "vertex" or "fragment".
-   * @return ShaderActor
-   *         The respective shader actor instance.
-   */
-  _getShaderActor: function(type) {
-    if (this._shaderActorsCache[type]) {
-      return this._shaderActorsCache[type];
-    }
-    const proxy = this.linkedProxy;
-    const shader = proxy.getShaderOfType(this.shaders, type);
-    const shaderActor = new ShaderActor(this.conn, this.program, shader, proxy);
-    this._shaderActorsCache[type] = shaderActor;
-    return this._shaderActorsCache[type];
-  },
-});
-
-/**
- * The WebGL Actor handles simple interaction with a WebGL context via a few
- * high-level methods. After instantiating this actor, you'll need to set it
- * up by calling setup().
- */
-exports.WebGLActor = protocol.ActorClassWithSpec(webGLSpec, {
-  initialize: function(conn, targetActor) {
-    protocol.Actor.prototype.initialize.call(this, conn);
-    this.targetActor = targetActor;
-    this._onGlobalCreated = this._onGlobalCreated.bind(this);
-    this._onGlobalDestroyed = this._onGlobalDestroyed.bind(this);
-    this._onProgramLinked = this._onProgramLinked.bind(this);
-  },
-  destroy: function(conn) {
-    protocol.Actor.prototype.destroy.call(this, conn);
-    this.finalize();
-  },
-
-  /**
-   * Starts waiting for the current target actor's document global to be
-   * created, in order to instrument the Canvas context and become
-   * aware of everything the content does WebGL-wise.
-   *
-   * See ContentObserver and WebGLInstrumenter for more details.
-   */
-  setup: function({ reload }) {
-    if (this._initialized) {
-      return;
-    }
-    this._initialized = true;
-
-    this._programActorsCache = [];
-    this._webglObserver = new WebGLObserver();
-
-    this.targetActor.on("window-ready", this._onGlobalCreated);
-    this.targetActor.on("window-destroyed", this._onGlobalDestroyed);
-    EventEmitter.on(this._webglObserver, "program-linked", this._onProgramLinked);
-
-    if (reload) {
-      this.targetActor.window.location.reload();
-    }
-  },
-
-  /**
-   * Stops listening for document global changes and puts this actor
-   * to hibernation. This method is called automatically just before the
-   * actor is destroyed.
-   */
-  finalize: function() {
-    if (!this._initialized) {
-      return;
-    }
-    this._initialized = false;
-
-    this.targetActor.off("window-ready", this._onGlobalCreated);
-    this.targetActor.off("window-destroyed", this._onGlobalDestroyed);
-    EventEmitter.off(this._webglObserver, "program-linked", this._onProgramLinked);
-
-    this._programActorsCache = null;
-    this._contentObserver = null;
-    this._webglObserver = null;
-  },
-
-  /**
-   * Gets an array of cached program actors for the current target actor's window.
-   * This is useful for dealing with bfcache, when no new programs are linked.
-   */
-  getPrograms: function() {
-    const id = ContentObserver.GetInnerWindowID(this.targetActor.window);
-    return this._programActorsCache.filter(e => e.ownerWindow == id);
-  },
-
-  /**
-   * Waits for one frame via `requestAnimationFrame` on the target actor's window.
-   * Used in tests.
-   */
-  waitForFrame: function() {
-    const deferred = defer();
-    this.targetActor.window.requestAnimationFrame(deferred.resolve);
-    return deferred.promise;
-  },
-
-  /**
-   * Gets a pixel's RGBA value from a context specified by selector
-   * and the coordinates of the pixel in question.
-   * Currently only used in tests.
-   *
-   * @param string selector
-   *        A string selector to select the canvas in question from the DOM.
-   * @param Object position
-   *        An object with an `x` and `y` property indicating coordinates of
-   *        the pixel being inspected.
-   * @return Object
-   *        An object containing `r`, `g`, `b`, and `a` properties of the pixel.
-   */
-  getPixel: function({ selector, position }) {
-    const { x, y } = position;
-    const canvas = this.targetActor.window.document.querySelector(selector);
-    const context = XPCNativeWrapper.unwrap(canvas.getContext("webgl"));
-    const { proxy } = this._webglObserver.for(context);
-    const height = canvas.height;
-
-    let buffer = new this.targetActor.window.Uint8Array(4);
-    buffer = XPCNativeWrapper.unwrap(buffer);
-
-    proxy.readPixels(
-      x, height - y - 1, 1, 1, context.RGBA, context.UNSIGNED_BYTE, buffer
-    );
-
-    return { r: buffer[0], g: buffer[1], b: buffer[2], a: buffer[3] };
-  },
-
-  /**
-   * Gets an array of all cached program actors belonging to all windows.
-   * This should only be used for tests.
-   */
-  _getAllPrograms: function() {
-    return this._programActorsCache;
-  },
-
-  /**
-   * Invoked whenever the current target actor's document global is created.
-   */
-  _onGlobalCreated: function({id, window, isTopLevel}) {
-    if (isTopLevel) {
-      WebGLInstrumenter.handle(window, this._webglObserver);
-      this.emit("global-created", id);
-    }
-  },
-
-  /**
-   * Invoked whenever the current target actor's inner window is destroyed.
-   */
-  _onGlobalDestroyed: function({id, isTopLevel, isFrozen}) {
-    if (isTopLevel && !isFrozen) {
-      removeFromArray(this._programActorsCache, e => e.ownerWindow == id);
-      this._webglObserver.unregisterContextsForWindow(id);
-      this.emit("global-destroyed", id);
-    }
-  },
-
-  /**
-   * Invoked whenever an observed WebGL context links a program.
-   */
-  _onProgramLinked: function(...args) {
-    const programActor = new ProgramActor(this.conn, args);
-    this._programActorsCache.push(programActor);
-    this.emit("program-linked", programActor);
-  },
-});
-
-/**
- * Instruments a HTMLCanvasElement with the appropriate inspection methods.
- */
-var WebGLInstrumenter = {
-  /**
-   * Overrides the getContext method in the HTMLCanvasElement prototype.
-   *
-   * @param nsIDOMWindow window
-   *        The window to perform the instrumentation in.
-   * @param WebGLObserver observer
-   *        The observer watching function calls in the context.
-   */
-  handle: function(window, observer) {
-    const self = this;
-
-    const id = ContentObserver.GetInnerWindowID(window);
-    const canvasElem = XPCNativeWrapper.unwrap(window.HTMLCanvasElement);
-    const canvasPrototype = canvasElem.prototype;
-    const originalGetContext = canvasPrototype.getContext;
-
-    /**
-     * Returns a drawing context on the canvas, or null if the context ID is
-     * not supported. This override creates an observer for the targeted context
-     * type and instruments specific functions in the targeted context instance.
-     */
-    canvasPrototype.getContext = function(name, options) {
-      // Make sure a context was able to be created.
-      const context = originalGetContext.call(this, name, options);
-      if (!context) {
-        return context;
-      }
-      // Make sure a WebGL (not a 2D) context will be instrumented.
-      if (!WEBGL_CONTEXT_NAMES.includes(name)) {
-        return context;
-      }
-      // Repeated calls to 'getContext' return the same instance, no need to
-      // instrument everything again.
-      if (observer.for(context)) {
-        return context;
-      }
-
-      // Create a separate state storage for this context.
-      observer.registerContextForWindow(id, context);
-
-      // Link our observer to the new WebGL context methods.
-      for (const { timing, callback, functions } of self._methods) {
-        for (const func of functions) {
-          self._instrument(observer, context, func, callback, timing);
-        }
-      }
-
-      // Return the decorated context back to the content consumer, which
-      // will continue using it normally.
-      return context;
-    };
-  },
-
-  /**
-   * Overrides a specific method in a HTMLCanvasElement context.
-   *
-   * @param WebGLObserver observer
-   *        The observer watching function calls in the context.
-   * @param WebGLRenderingContext context
-   *        The targeted WebGL context instance.
-   * @param string funcName
-   *        The function to override.
-   * @param array callbackName [optional]
-   *        The two callback function names in the observer, corresponding to
-   *        the "before" and "after" invocation times. If unspecified, they will
-   *        default to the name of the function to override.
-   * @param number timing [optional]
-   *        When to issue the callback in relation to the actual context
-   *        function call. Availalble values are -1 for "before" (default)
-   *        1 for "after" and 0 for "before and after".
-   */
-  _instrument: function(observer, context, funcName, callbackName = [], timing = -1) {
-    const { cache, proxy } = observer.for(context);
-    const originalFunc = context[funcName];
-    const beforeFuncName = callbackName[0] || funcName;
-    const afterFuncName = callbackName[1] || callbackName[0] || funcName;
-
-    context[funcName] = function(...glArgs) {
-      if (timing <= 0 && !observer.suppressHandlers) {
-        const glBreak = observer[beforeFuncName](glArgs, cache, proxy);
-        if (glBreak) {
-          return undefined;
-        }
-      }
-
-      // Invoking .apply on an unxrayed content function doesn't work, because
-      // the arguments array is inaccessible to it. Get Xrays back.
-      const glResult = Cu.waiveXrays(Cu.unwaiveXrays(originalFunc).apply(this, glArgs));
-
-      if (timing >= 0 && !observer.suppressHandlers) {
-        const glBreak = observer[afterFuncName](glArgs, glResult, cache, proxy);
-        if (glBreak) {
-          return undefined;
-        }
-      }
-
-      return glResult;
-    };
-  },
-
-  /**
-   * Override mappings for WebGL methods.
-   */
-  _methods: [{
-    // after
-    timing: 1,
-    functions: [
-      "linkProgram", "getAttribLocation", "getUniformLocation",
-    ],
-  }, {
-    // before
-    timing: -1,
-    callback: [
-      "toggleVertexAttribArray",
-    ],
-    functions: [
-      "enableVertexAttribArray", "disableVertexAttribArray",
-    ],
-  }, {
-    // before
-    timing: -1,
-    callback: [
-      "attribute_",
-    ],
-    functions: [
-      "vertexAttrib1f", "vertexAttrib2f", "vertexAttrib3f", "vertexAttrib4f",
-      "vertexAttrib1fv", "vertexAttrib2fv", "vertexAttrib3fv", "vertexAttrib4fv",
-      "vertexAttribPointer",
-    ],
-  }, {
-    // before
-    timing: -1,
-    callback: [
-      "uniform_",
-    ],
-    functions: [
-      "uniform1i", "uniform2i", "uniform3i", "uniform4i",
-      "uniform1f", "uniform2f", "uniform3f", "uniform4f",
-      "uniform1iv", "uniform2iv", "uniform3iv", "uniform4iv",
-      "uniform1fv", "uniform2fv", "uniform3fv", "uniform4fv",
-      "uniformMatrix2fv", "uniformMatrix3fv", "uniformMatrix4fv",
-    ],
-  }, {
-    // before
-    timing: -1,
-    functions: [
-      "useProgram", "enable", "disable", "blendColor",
-      "blendEquation", "blendEquationSeparate",
-      "blendFunc", "blendFuncSeparate",
-    ],
-  }, {
-    // before and after
-    timing: 0,
-    callback: [
-      "beforeDraw_", "afterDraw_",
-    ],
-    functions: [
-      "drawArrays", "drawElements",
-    ],
-  }],
-  // TODO: It'd be a good idea to handle other functions as well:
-  //   - getActiveUniform
-  //   - getUniform
-  //   - getActiveAttrib
-  //   - getVertexAttrib
-};
-
-/**
- * An observer that captures a WebGL context's method calls.
- */
-function WebGLObserver() {
-  this._contexts = new Map();
-}
-
-WebGLObserver.prototype = {
-  _contexts: null,
-
-  /**
-   * Creates a WebGLCache and a WebGLProxy for the specified window and context.
-   *
-   * @param number id
-   *        The id of the window containing the WebGL context.
-   * @param WebGLRenderingContext context
-   *        The WebGL context used in the cache and proxy instances.
-   */
-  registerContextForWindow: function(id, context) {
-    const cache = new WebGLCache(id, context);
-    const proxy = new WebGLProxy(id, context, cache, this);
-    cache.refreshState(proxy);
-
-    this._contexts.set(context, {
-      ownerWindow: id,
-      cache: cache,
-      proxy: proxy,
-    });
-  },
-
-  /**
-   * Removes all WebGLCache and WebGLProxy instances for a particular window.
-   *
-   * @param number id
-   *        The id of the window containing the WebGL context.
-   */
-  unregisterContextsForWindow: function(id) {
-    removeFromMap(this._contexts, e => e.ownerWindow == id);
-  },
-
-  /**
-   * Gets the WebGLCache and WebGLProxy instances for a particular context.
-   *
-   * @param WebGLRenderingContext context
-   *        The WebGL context used in the cache and proxy instances.
-   * @return object
-   *         An object containing the corresponding { cache, proxy } instances.
-   */
-  for: function(context) {
-    return this._contexts.get(context);
-  },
-
-  /**
-   * Set this flag to true to stop observing any context function calls.
-   */
-  suppressHandlers: false,
-
-  /**
-   * Called immediately *after* 'linkProgram' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param void glResult
-   *        The returned value of the original function call.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   * @param WebGLProxy proxy
-   *        The proxy methods for the WebGL context initiating this call.
-   */
-  linkProgram: function(glArgs, glResult, cache, proxy) {
-    const program = glArgs[0];
-    const shaders = proxy.getAttachedShaders(program);
-    cache.addProgram(program, PROGRAM_DEFAULT_TRAITS);
-    EventEmitter.emit(this, "program-linked", program, shaders, cache, proxy);
-  },
-
-  /**
-   * Called immediately *after* 'getAttribLocation' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param GLint glResult
-   *        The returned value of the original function call.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  getAttribLocation: function(glArgs, glResult, cache) {
-    // Make sure the attribute's value is legal before caching.
-    if (glResult < 0) {
-      return;
-    }
-    const [program, name] = glArgs;
-    cache.addAttribute(program, name, glResult);
-  },
-
-  /**
-   * Called immediately *after* 'getUniformLocation' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLUniformLocation glResult
-   *        The returned value of the original function call.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  getUniformLocation: function(glArgs, glResult, cache) {
-    // Make sure the uniform's value is legal before caching.
-    if (!glResult) {
-      return;
-    }
-    const [program, name] = glArgs;
-    cache.addUniform(program, name, glResult);
-  },
-
-  /**
-   * Called immediately *before* 'enableVertexAttribArray' or
-   * 'disableVertexAttribArray'is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  toggleVertexAttribArray: function(glArgs, cache) {
-    glArgs[0] = cache.getCurrentAttributeLocation(glArgs[0]);
-    // Return true to break original function call.
-    return glArgs[0] < 0;
-  },
-
-  /**
-   * Called immediately *before* 'attribute_' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  attribute_: function(glArgs, cache) {
-    glArgs[0] = cache.getCurrentAttributeLocation(glArgs[0]);
-    // Return true to break original function call.
-    return glArgs[0] < 0;
-  },
-
-  /**
-   * Called immediately *before* 'uniform_' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  uniform_: function(glArgs, cache) {
-    glArgs[0] = cache.getCurrentUniformLocation(glArgs[0]);
-    // Return true to break original function call.
-    return !glArgs[0];
-  },
-
-  /**
-   * Called immediately *before* 'useProgram' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  useProgram: function(glArgs, cache) {
-    // Manually keeping a cache and not using gl.getParameter(CURRENT_PROGRAM)
-    // because gl.get* functions are slow as potatoes.
-    cache.currentProgram = glArgs[0];
-  },
-
-  /**
-   * Called immediately *before* 'enable' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  enable: function(glArgs, cache) {
-    cache.currentState[glArgs[0]] = true;
-  },
-
-  /**
-   * Called immediately *before* 'disable' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  disable: function(glArgs, cache) {
-    cache.currentState[glArgs[0]] = false;
-  },
-
-  /**
-   * Called immediately *before* 'blendColor' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  blendColor: function(glArgs, cache) {
-    const blendColor = cache.currentState.blendColor;
-    blendColor[0] = glArgs[0];
-    blendColor[1] = glArgs[1];
-    blendColor[2] = glArgs[2];
-    blendColor[3] = glArgs[3];
-  },
-
-  /**
-   * Called immediately *before* 'blendEquation' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  blendEquation: function(glArgs, cache) {
-    const state = cache.currentState;
-    state.blendEquationRgb = state.blendEquationAlpha = glArgs[0];
-  },
-
-  /**
-   * Called immediately *before* 'blendEquationSeparate' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  blendEquationSeparate: function(glArgs, cache) {
-    const state = cache.currentState;
-    state.blendEquationRgb = glArgs[0];
-    state.blendEquationAlpha = glArgs[1];
-  },
-
-  /**
-   * Called immediately *before* 'blendFunc' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  blendFunc: function(glArgs, cache) {
-    const state = cache.currentState;
-    state.blendSrcRgb = state.blendSrcAlpha = glArgs[0];
-    state.blendDstRgb = state.blendDstAlpha = glArgs[1];
-  },
-
-  /**
-   * Called immediately *before* 'blendFuncSeparate' is requested in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   */
-  blendFuncSeparate: function(glArgs, cache) {
-    const state = cache.currentState;
-    state.blendSrcRgb = glArgs[0];
-    state.blendDstRgb = glArgs[1];
-    state.blendSrcAlpha = glArgs[2];
-    state.blendDstAlpha = glArgs[3];
-  },
-
-  /**
-   * Called immediately *before* 'drawArrays' or 'drawElements' is requested
-   * in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   * @param WebGLProxy proxy
-   *        The proxy methods for the WebGL context initiating this call.
-   */
-  beforeDraw_: function(glArgs, cache, proxy) {
-    const traits = cache.currentProgramTraits;
-
-    // Handle program blackboxing.
-    if (traits & PROGRAM_BLACKBOX_TRAIT) {
-      // Return true to break original function call.
-      return true;
-    }
-    // Handle program highlighting.
-    if (traits & PROGRAM_HIGHLIGHT_TRAIT) {
-      proxy.enableHighlighting();
-    }
-
-    return false;
-  },
-
-  /**
-   * Called immediately *after* 'drawArrays' or 'drawElements' is requested
-   * in the context.
-   *
-   * @param array glArgs
-   *        Overridable arguments with which the function is called.
-   * @param void glResult
-   *        The returned value of the original function call.
-   * @param WebGLCache cache
-   *        The state storage for the WebGL context initiating this call.
-   * @param WebGLProxy proxy
-   *        The proxy methods for the WebGL context initiating this call.
-   */
-  afterDraw_: function(glArgs, glResult, cache, proxy) {
-    const traits = cache.currentProgramTraits;
-
-    // Handle program highlighting.
-    if (traits & PROGRAM_HIGHLIGHT_TRAIT) {
-      proxy.disableHighlighting();
-    }
-  },
-};
-
-/**
- * A mechanism for storing a single WebGL context's state, programs, shaders,
- * attributes or uniforms.
- *
- * @param number id
- *        The id of the window containing the WebGL context.
- * @param WebGLRenderingContext context
- *        The WebGL context for which the state is stored.
- */
-function WebGLCache(id, context) {
-  this._id = id;
-  this._gl = context;
-  this._programs = new Map();
-  this.currentState = {};
-}
-
-WebGLCache.prototype = {
-  _id: 0,
-  _gl: null,
-  _programs: null,
-  _currentProgramInfo: null,
-  _currentAttributesMap: null,
-  _currentUniformsMap: null,
-
-  get ownerWindow() {
-    return this._id;
-  },
-
-  get ownerContext() {
-    return this._gl;
-  },
-
-  /**
-   * A collection of flags or properties representing the context's state.
-   * Implemented as an object hash and not a Map instance because keys are
-   * always either strings or numbers.
-   */
-  currentState: null,
-
-  /**
-   * Populates the current state with values retrieved from the context.
-   *
-   * @param WebGLProxy proxy
-   *        The proxy methods for the WebGL context owning the state.
-   */
-  refreshState: function(proxy) {
-    const gl = this._gl;
-    const s = this.currentState;
-
-    // Populate only with the necessary parameters. Not all default WebGL
-    // state values are required.
-    s[gl.BLEND] = proxy.isEnabled("BLEND");
-    s.blendColor = proxy.getParameter("BLEND_COLOR");
-    s.blendEquationRgb = proxy.getParameter("BLEND_EQUATION_RGB");
-    s.blendEquationAlpha = proxy.getParameter("BLEND_EQUATION_ALPHA");
-    s.blendSrcRgb = proxy.getParameter("BLEND_SRC_RGB");
-    s.blendSrcAlpha = proxy.getParameter("BLEND_SRC_ALPHA");
-    s.blendDstRgb = proxy.getParameter("BLEND_DST_RGB");
-    s.blendDstAlpha = proxy.getParameter("BLEND_DST_ALPHA");
-  },
-
-  /**
-   * Adds a program to the cache.
-   *
-   * @param WebGLProgram program
-   *        The shader for which the traits are to be cached.
-   * @param number traits
-   *        A default properties mask set for the program.
-   */
-  addProgram: function(program, traits) {
-    this._programs.set(program, {
-      traits: traits,
-      // keys are GLints (numbers)
-      attributes: [],
-      // keys are WebGLUniformLocations (objects)
-      uniforms: new Map(),
-    });
-  },
-
-  /**
-   * Adds a specific trait to a program. The effect of such properties is
-   * determined by the consumer of this cache.
-   *
-   * @param WebGLProgram program
-   *        The program to add the trait to.
-   * @param number trait
-   *        The property added to the program.
-   */
-  setProgramTrait: function(program, trait) {
-    this._programs.get(program).traits |= trait;
-  },
-
-  /**
-   * Removes a specific trait from a program.
-   *
-   * @param WebGLProgram program
-   *        The program to remove the trait from.
-   * @param number trait
-   *        The property removed from the program.
-   */
-  unsetProgramTrait: function(program, trait) {
-    this._programs.get(program).traits &= ~trait;
-  },
-
-  /**
-   * Sets the currently used program in the context.
-   * @param WebGLProgram program
-   */
-  set currentProgram(program) {
-    const programInfo = this._programs.get(program);
-    if (programInfo == null) {
-      return;
-    }
-    this._currentProgramInfo = programInfo;
-    this._currentAttributesMap = programInfo.attributes;
-    this._currentUniformsMap = programInfo.uniforms;
-  },
-
-  /**
-   * Gets the traits for the currently used program.
-   * @return number
-   */
-  get currentProgramTraits() {
-    return this._currentProgramInfo.traits;
-  },
-
-  /**
-   * Adds an attribute to the cache.
-   *
-   * @param WebGLProgram program
-   *        The program for which the attribute is bound.
-   * @param string name
-   *        The attribute name.
-   * @param GLint value
-   *        The attribute value.
-   */
-  addAttribute: function(program, name, value) {
-    this._programs.get(program).attributes[value] = {
-      name: name,
-      value: value,
-    };
-  },
-
-  /**
-   * Adds a uniform to the cache.
-   *
-   * @param WebGLProgram program
-   *        The program for which the uniform is bound.
-   * @param string name
-   *        The uniform name.
-   * @param WebGLUniformLocation value
-   *        The uniform value.
-   */
-  addUniform: function(program, name, value) {
-    this._programs.get(program).uniforms.set(new XPCNativeWrapper(value), {
-      name: name,
-      value: value,
-    });
-  },
-
-  /**
-   * Updates the attribute locations for a specific program.
-   * This is necessary, for example, when the shader is relinked and all the
-   * attribute locations become obsolete.
-   *
-   * @param WebGLProgram program
-   *        The program for which the attributes need updating.
-   */
-  updateAttributesForProgram: function(program) {
-    const attributes = this._programs.get(program).attributes;
-    for (const attribute of attributes) {
-      attribute.value = this._gl.getAttribLocation(program, attribute.name);
-    }
-  },
-
-  /**
-   * Updates the uniform locations for a specific program.
-   * This is necessary, for example, when the shader is relinked and all the
-   * uniform locations become obsolete.
-   *
-   * @param WebGLProgram program
-   *        The program for which the uniforms need updating.
-   */
-  updateUniformsForProgram: function(program) {
-    const uniforms = this._programs.get(program).uniforms;
-    for (const [, uniform] of uniforms) {
-      uniform.value = this._gl.getUniformLocation(program, uniform.name);
-    }
-  },
-
-  /**
-   * Gets the actual attribute location in a specific program.
-   * When relinked, all the attribute locations become obsolete and are updated
-   * in the cache. This method returns the (current) real attribute location.
-   *
-   * @param GLint initialValue
-   *        The initial attribute value.
-   * @return GLint
-   *         The current attribute value, or the initial value if it's already
-   *         up to date with its corresponding program.
-   */
-  getCurrentAttributeLocation: function(initialValue) {
-    const attributes = this._currentAttributesMap;
-    const currentInfo = attributes ? attributes[initialValue] : null;
-    return currentInfo ? currentInfo.value : initialValue;
-  },
-
-  /**
-   * Gets the actual uniform location in a specific program.
-   * When relinked, all the uniform locations become obsolete and are updated
-   * in the cache. This method returns the (current) real uniform location.
-   *
-   * @param WebGLUniformLocation initialValue
-   *        The initial uniform value.
-   * @return WebGLUniformLocation
-   *         The current uniform value, or the initial value if it's already
-   *         up to date with its corresponding program.
-   */
-  getCurrentUniformLocation: function(initialValue) {
-    const uniforms = this._currentUniformsMap;
-    const currentInfo = uniforms ? uniforms.get(initialValue) : null;
-    return currentInfo ? currentInfo.value : initialValue;
-  },
-};
-
-/**
- * A mechanism for injecting or qureying state into/from a single WebGL context.
- *
- * Any interaction with a WebGL context should go through this proxy.
- * Otherwise, the corresponding observer would register the calls as coming
- * from content, which is usually not desirable. Infinite call stacks are bad.
- *
- * @param number id
- *        The id of the window containing the WebGL context.
- * @param WebGLRenderingContext context
- *        The WebGL context used for the proxy methods.
- * @param WebGLCache cache
- *        The state storage for the corresponding context.
- * @param WebGLObserver observer
- *        The observer watching function calls in the corresponding context.
- */
-function WebGLProxy(id, context, cache, observer) {
-  this._id = id;
-  this._gl = context;
-  this._cache = cache;
-  this._observer = observer;
-
-  const exports = [
-    "isEnabled",
-    "getParameter",
-    "getAttachedShaders",
-    "getShaderSource",
-    "getShaderOfType",
-    "compileShader",
-    "enableHighlighting",
-    "disableHighlighting",
-    "readPixels",
-  ];
-  exports.forEach(e => {
-    this[e] = (...args) => this._call(e, args);
-  });
-}
-
-WebGLProxy.prototype = {
-  _id: 0,
-  _gl: null,
-  _cache: null,
-  _observer: null,
-
-  get ownerWindow() {
-    return this._id;
-  },
-  get ownerContext() {
-    return this._gl;
-  },
-
-  /**
-   * Test whether a WebGL capability is enabled.
-   *
-   * @param string name
-   *        The WebGL capability name, for example "BLEND".
-   * @return boolean
-   *         True if enabled, false otherwise.
-   */
-  _isEnabled: function(name) {
-    return this._gl.isEnabled(this._gl[name]);
-  },
-
-  /**
-   * Returns the value for the specified WebGL parameter name.
-   *
-   * @param string name
-   *        The WebGL parameter name, for example "BLEND_COLOR".
-   * @return any
-   *         The corresponding parameter's value.
-   */
-  _getParameter: function(name) {
-    return this._gl.getParameter(this._gl[name]);
-  },
-
-  /**
-   * Returns the renderbuffer property value for the specified WebGL parameter.
-   * If no renderbuffer binding is available, null is returned.
-   *
-   * @param string name
-   *        The WebGL parameter name, for example "BLEND_COLOR".
-   * @return any
-   *         The corresponding parameter's value.
-   */
-  _getRenderbufferParameter: function(name) {
-    if (!this._getParameter("RENDERBUFFER_BINDING")) {
-      return null;
-    }
-    const gl = this._gl;
-    return gl.getRenderbufferParameter(gl.RENDERBUFFER, gl[name]);
-  },
-
-  /**
-   * Returns the framebuffer property value for the specified WebGL parameter.
-   * If no framebuffer binding is available, null is returned.
-   *
-   * @param string type
-   *        The framebuffer object attachment point, for example "COLOR_ATTACHMENT0".
-   * @param string name
-   *        The WebGL parameter name, for example "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME".
-   *        If unspecified, defaults to "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE".
-   * @return any
-   *         The corresponding parameter's value.
-   */
-  _getFramebufferAttachmentParameter(type, name = "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE") {
-    if (!this._getParameter("FRAMEBUFFER_BINDING")) {
-      return null;
-    }
-    const gl = this._gl;
-    return gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl[type], gl[name]);
-  },
-
-  /**
-   * Returns the shader objects attached to a program object.
-   *
-   * @param WebGLProgram program
-   *        The program for which to retrieve the attached shaders.
-   * @return array
-   *         The attached vertex and fragment shaders.
-   */
-  _getAttachedShaders: function(program) {
-    return this._gl.getAttachedShaders(program);
-  },
-
-  /**
-   * Returns the source code string from a shader object.
-   *
-   * @param WebGLShader shader
-   *        The shader for which to retrieve the source code.
-   * @return string
-   *         The shader's source code.
-   */
-  _getShaderSource: function(shader) {
-    return this._gl.getShaderSource(shader);
-  },
-
-  /**
-   * Finds a shader of the specified type in a list.
-   *
-   * @param WebGLShader[] shaders
-   *        The shaders for which to check the type.
-   * @param string type
-   *        Either "vertex" or "fragment".
-   * @return WebGLShader | null
-   *         The shader of the specified type, or null if nothing is found.
-   */
-  _getShaderOfType: function(shaders, type) {
-    const gl = this._gl;
-    const shaderTypeEnum = {
-      vertex: gl.VERTEX_SHADER,
-      fragment: gl.FRAGMENT_SHADER,
-    }[type];
-
-    for (const shader of shaders) {
-      if (gl.getShaderParameter(shader, gl.SHADER_TYPE) == shaderTypeEnum) {
-        return shader;
-      }
-    }
-    return null;
-  },
-
-  /**
-   * Changes a shader's source code and relinks the respective program.
-   *
-   * @param WebGLProgram program
-   *        The program who's linked shader is to be modified.
-   * @param WebGLShader shader
-   *        The shader to be modified.
-   * @param string text
-   *        The new shader source code.
-   * @return object
-   *         An object containing the compilation and linking status.
-   */
-  _compileShader: function(program, shader, text) {
-    const gl = this._gl;
-    gl.shaderSource(shader, text);
-    gl.compileShader(shader);
-    gl.linkProgram(program);
-
-    const error = { compile: "", link: "" };
-
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-      error.compile = gl.getShaderInfoLog(shader);
-    }
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-      error.link = gl.getShaderInfoLog(shader);
-    }
-
-    this._cache.updateAttributesForProgram(program);
-    this._cache.updateUniformsForProgram(program);
-
-    return error;
-  },
-
-  /**
-   * Enables color blending based on the geometry highlight tint.
-   */
-  _enableHighlighting: function() {
-    const gl = this._gl;
-
-    // Avoid changing the blending params when "rendering to texture".
-
-    // Check drawing to a custom framebuffer bound to the default renderbuffer.
-    const hasFramebuffer = this._getParameter("FRAMEBUFFER_BINDING");
-    const hasRenderbuffer = this._getParameter("RENDERBUFFER_BINDING");
-    if (hasFramebuffer && !hasRenderbuffer) {
-      return;
-    }
-
-    // Check drawing to a depth or stencil component of the framebuffer.
-    const writesDepth = this._getFramebufferAttachmentParameter("DEPTH_ATTACHMENT");
-    const writesStencil = this._getFramebufferAttachmentParameter("STENCIL_ATTACHMENT");
-    if (writesDepth || writesStencil) {
-      return;
-    }
-
-    // Non-premultiplied alpha blending based on a predefined constant color.
-    // Simply using gl.colorMask won't work, because we want non-tinted colors
-    // to be drawn as black, not ignored.
-    gl.enable(gl.BLEND);
-    gl.blendColor.apply(gl, this.highlightTint);
-    gl.blendEquation(gl.FUNC_ADD);
-    gl.blendFunc(gl.CONSTANT_COLOR, gl.ONE_MINUS_SRC_ALPHA, gl.CONSTANT_COLOR, gl.ZERO);
-    this.wasHighlighting = true;
-  },
-
-  /**
-   * Disables color blending based on the geometry highlight tint, by
-   * reverting the corresponding params back to their original values.
-   */
-  _disableHighlighting: function() {
-    const gl = this._gl;
-    const s = this._cache.currentState;
-
-    gl[s[gl.BLEND] ? "enable" : "disable"](gl.BLEND);
-    gl.blendColor.apply(gl, s.blendColor);
-    gl.blendEquationSeparate(s.blendEquationRgb, s.blendEquationAlpha);
-    gl.blendFuncSeparate(s.blendSrcRgb, s.blendDstRgb, s.blendSrcAlpha, s.blendDstAlpha);
-  },
-
-  /**
-   * Returns the pixel values at the position specified on the canvas.
-   */
-  _readPixels: function(x, y, w, h, format, type, buffer) {
-    this._gl.readPixels(x, y, w, h, format, type, buffer);
-  },
-
-  /**
-   * The color tint used for highlighting geometry.
-   * @see _enableHighlighting and _disableHighlighting.
-   */
-  highlightTint: [0, 0, 0, 0],
-
-  /**
-   * Executes a function in this object.
-   *
-   * This method makes sure that any handlers in the context observer are
-   * suppressed, hence stopping observing any context function calls.
-   *
-   * @param string funcName
-   *        The function to call.
-   * @param array args
-   *        An array of arguments.
-   * @return any
-   *         The called function result.
-   */
-  _call: function(funcName, args) {
-    const prevState = this._observer.suppressHandlers;
-
-    this._observer.suppressHandlers = true;
-    const result = this["_" + funcName].apply(this, args);
-    this._observer.suppressHandlers = prevState;
-
-    return result;
-  },
-};
-
-// Utility functions.
-
-function removeFromMap(map, predicate) {
-  for (const [key, value] of map) {
-    if (predicate(value)) {
-      map.delete(key);
-    }
-  }
-}
-
-function removeFromArray(array, predicate) {
-  for (let i = 0; i < array.length;) {
-    if (predicate(array[i])) {
-      array.splice(i, 1);
-    } else {
-      i++;
-    }
-  }
-}
--- a/devtools/shared/fronts/moz.build
+++ b/devtools/shared/fronts/moz.build
@@ -36,10 +36,9 @@ DevToolsModules(
     'root.js',
     'screenshot.js',
     'storage.js',
     'string.js',
     'styles.js',
     'stylesheets.js',
     'webaudio.js',
     'webconsole.js',
-    'webgl.js'
 )
deleted file mode 100644
--- a/devtools/shared/fronts/webgl.js
+++ /dev/null
@@ -1,44 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-"use strict";
-
-const {
-  shaderSpec,
-  programSpec,
-  webGLSpec,
-} = require("devtools/shared/specs/webgl");
-const { FrontClassWithSpec, registerFront } = require("devtools/shared/protocol");
-
-/**
- * The corresponding Front object for the ShaderActor.
- */
-class ShaderFront extends FrontClassWithSpec(shaderSpec) {
-}
-
-exports.ShaderFront = ShaderFront;
-registerFront(ShaderFront);
-
-/**
- * The corresponding Front object for the ProgramActor.
- */
-class ProgramFront extends FrontClassWithSpec(programSpec) {
-}
-
-exports.ProgramFront = ProgramFront;
-registerFront(ProgramFront);
-
-/**
- * The corresponding Front object for the WebGLActor.
- */
-class WebGLFront extends FrontClassWithSpec(webGLSpec) {
-  constructor(client) {
-    super(client);
-
-    // Attribute name from which to retrieve the actorID out of the target actor's form
-    this.formAttributeName = "webglActor";
-  }
-}
-
-exports.WebGLFront = WebGLFront;
-registerFront(WebGLFront);
--- a/devtools/shared/specs/index.js
+++ b/devtools/shared/specs/index.js
@@ -269,21 +269,16 @@ const Types = exports.__TypesForTests = 
     front: "devtools/shared/fronts/webaudio",
   },
   {
     types: ["console"],
     spec: "devtools/shared/specs/webconsole",
     front: "devtools/shared/fronts/webconsole",
   },
   {
-    types: ["gl-shader", "gl-program", "webgl"],
-    spec: "devtools/shared/specs/webgl",
-    front: "devtools/shared/fronts/webgl",
-  },
-  {
     types: ["pushSubscription"],
     spec: "devtools/shared/specs/worker/push-subscription",
     front: "devtools/shared/fronts/worker/push-subscription",
   },
   {
     types: ["serviceWorker"],
     spec: "devtools/shared/specs/worker/service-worker",
     front: "devtools/shared/fronts/worker/service-worker",
--- a/devtools/shared/specs/moz.build
+++ b/devtools/shared/specs/moz.build
@@ -48,10 +48,9 @@ DevToolsModules(
     'string.js',
     'styles.js',
     'stylesheets.js',
     'symbol-iterator.js',
     'symbol.js',
     'timeline.js',
     'webaudio.js',
     'webconsole.js',
-    'webgl.js',
 )
deleted file mode 100644
--- a/devtools/shared/specs/webgl.js
+++ /dev/null
@@ -1,101 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-"use strict";
-
-const {Arg, Option, RetVal, generateActorSpec} = require("devtools/shared/protocol");
-
-const shaderSpec = generateActorSpec({
-  typeName: "gl-shader",
-
-  methods: {
-    getText: {
-      response: { text: RetVal("string") },
-    },
-    compile: {
-      request: { text: Arg(0, "string") },
-      response: { error: RetVal("nullable:json") },
-    },
-  },
-});
-
-exports.shaderSpec = shaderSpec;
-
-const programSpec = generateActorSpec({
-  typeName: "gl-program",
-
-  methods: {
-    getVertexShader: {
-      response: { shader: RetVal("gl-shader") },
-    },
-    getFragmentShader: {
-      response: { shader: RetVal("gl-shader") },
-    },
-    highlight: {
-      request: { tint: Arg(0, "array:number") },
-      oneway: true,
-    },
-    unhighlight: {
-      oneway: true,
-    },
-    blackbox: {
-      oneway: true,
-    },
-    unblackbox: {
-      oneway: true,
-    },
-  },
-});
-
-exports.programSpec = programSpec;
-
-const webGLSpec = generateActorSpec({
-  typeName: "webgl",
-
-  /**
-   * Events emitted by this actor. The "program-linked" event is fired every
-   * time a WebGL program was linked with its respective two shaders.
-   */
-  events: {
-    "program-linked": {
-      type: "programLinked",
-      program: Arg(0, "gl-program"),
-    },
-    "global-destroyed": {
-      type: "globalDestroyed",
-      program: Arg(0, "number"),
-    },
-    "global-created": {
-      type: "globalCreated",
-      program: Arg(0, "number"),
-    },
-  },
-
-  methods: {
-    setup: {
-      request: { reload: Option(0, "boolean") },
-      oneway: true,
-    },
-    finalize: {
-      oneway: true,
-    },
-    getPrograms: {
-      response: { programs: RetVal("array:gl-program") },
-    },
-    waitForFrame: {
-      response: { success: RetVal("nullable:json") },
-    },
-    getPixel: {
-      request: {
-        selector: Option(0, "string"),
-        position: Option(0, "json"),
-      },
-      response: { pixels: RetVal("json") },
-    },
-    _getAllPrograms: {
-      response: { programs: RetVal("array:gl-program") },
-    },
-  },
-});
-
-exports.webGLSpec = webGLSpec;