Improve metrics for display list canvas fallback reason

third_party/WebKit/Source/modules/webgl/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 4844 matching lines @@
   // TODO(crbug.com/622958): Implement GPU-to-GPU path for WebGL 2 and more
   // internal formats.
   if (functionID == TexSubImage2D &&
       (isWebGL2OrHigher() || extensionEnabled(OESTextureFloatName) ||
        extensionEnabled(OESTextureHalfFloatName) ||
        extensionEnabled(EXTsRGBName)))
     return false;
   return true;
 }
 
+SnapshotReason WebGLRenderingContextBase::functionIDToSnapshotReason(
+    TexImageFunctionID id) {
+  switch (id) {
+    case TexImage2D:
+      return SnapshotReasonWebGLTexImage2D;
+    case TexSubImage2D:
+      return SnapshotReasonWebGLTexSubImage2D;
+    case TexImage3D:
+      return SnapshotReasonWebGLTexImage3D;
+    case TexSubImage3D:
+      return SnapshotReasonWebGLTexSubImage3D;
+  }
+  NOTREACHED();
+  return SnapshotReasonUnknown;
+}
+
 void WebGLRenderingContextBase::texImageCanvasByGPU(
+    TexImageFunctionID functionID,
     HTMLCanvasElement* canvas,
     GLuint targetTexture,
     GLenum targetInternalformat,
     GLenum targetType,
     GLint targetLevel,
     GLint xoffset,
     GLint yoffset,
     const IntRect& sourceSubRectangle) {
   if (!canvas->is3D()) {
     ImageBuffer* buffer = canvas->buffer();
     if (buffer &&
         !buffer->copyToPlatformTexture(
-            contextGL(), targetTexture, targetInternalformat, targetType,
-            targetLevel, m_unpackPremultiplyAlpha, m_unpackFlipY,
-            IntPoint(xoffset, yoffset), sourceSubRectangle)) {
+            functionIDToSnapshotReason(functionID), contextGL(), targetTexture,
+            targetInternalformat, targetType, targetLevel,
+            m_unpackPremultiplyAlpha, m_unpackFlipY, IntPoint(xoffset, yoffset),
+            sourceSubRectangle)) {
       NOTREACHED();
     }
   } else {
     WebGLRenderingContextBase* gl =
         toWebGLRenderingContextBase(canvas->renderingContext());
     ScopedTexture2DRestorer restorer(gl);
     if (!gl->drawingBuffer()->copyToPlatformTexture(
             contextGL(), targetTexture, targetInternalformat, targetType,
             targetLevel, m_unpackPremultiplyAlpha, !m_unpackFlipY,
             IntPoint(xoffset, yoffset), sourceSubRectangle, BackBuffer)) {
       NOTREACHED();
     }
   }
 }
 
 void WebGLRenderingContextBase::texImageByGPU(
-    TexImageByGPUType functionType,
+    TexImageFunctionID functionID,
     WebGLTexture* texture,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     CanvasImageSource* image,
     const IntRect& sourceSubRectangle) {
   DCHECK(image->isCanvasElement() || image->isImageBitmap());
   int width = sourceSubRectangle.width();
   int height = sourceSubRectangle.height();
 
   ScopedTexture2DRestorer restorer(this);
 
   GLuint targetTexture = texture->object();
   GLenum targetType = type;
   GLenum targetInternalformat = internalformat;
   GLint targetLevel = level;
   bool possibleDirectCopy = false;
-  if (functionType == TexImage2DByGPU) {
+  if (functionID == TexImage2D) {
     possibleDirectCopy = Extensions3DUtil::canUseCopyTextureCHROMIUM(
         target, internalformat, type, level);
   }
 
   GLint copyXOffset = xoffset;
   GLint copyYOffset = yoffset;
 
   // if direct copy is not possible, create a temporary texture and then copy
   // from canvas to temporary texture to target texture.
   if (!possibleDirectCopy) {
@@ skipping 10 matching lines @@
                                GL_CLAMP_TO_EDGE);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                                GL_CLAMP_TO_EDGE);
     contextGL()->TexImage2D(GL_TEXTURE_2D, 0, targetInternalformat, width,
                             height, 0, GL_RGBA, targetType, 0);
     copyXOffset = 0;
     copyYOffset = 0;
   }
 
   if (image->isCanvasElement()) {
-    texImageCanvasByGPU(static_cast<HTMLCanvasElement*>(image), targetTexture,
-                        targetInternalformat, targetType, targetLevel,
-                        copyXOffset, copyYOffset, sourceSubRectangle);
+    texImageCanvasByGPU(functionID, static_cast<HTMLCanvasElement*>(image),
+                        targetTexture, targetInternalformat, targetType,
+                        targetLevel, copyXOffset, copyYOffset,
+                        sourceSubRectangle);
   } else {
     texImageBitmapByGPU(static_cast<ImageBitmap*>(image), targetTexture,
                         targetInternalformat, targetType, targetLevel,
                         !m_unpackFlipY);
   }
 
   if (!possibleDirectCopy) {
     GLuint tmpFBO;
     contextGL()->GenFramebuffers(1, &tmpFBO);
     contextGL()->BindFramebuffer(GL_FRAMEBUFFER, tmpFBO);
     contextGL()->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                       GL_TEXTURE_2D, targetTexture, 0);
     contextGL()->BindTexture(texture->getTarget(), texture->object());
-    if (functionType == TexImage2DByGPU) {
+    if (functionID == TexImage2D) {
       contextGL()->CopyTexSubImage2D(target, level, 0, 0, 0, 0, width, height);
-    } else if (functionType == TexSubImage2DByGPU) {
+    } else if (functionID == TexSubImage2D) {
       contextGL()->CopyTexSubImage2D(target, level, xoffset, yoffset, 0, 0,
                                      width, height);
-    } else if (functionType == TexSubImage3DByGPU) {
+    } else if (functionID == TexSubImage3D) {
       contextGL()->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset,
                                      0, 0, width, height);
     }
     contextGL()->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                       GL_TEXTURE_2D, 0, 0);
     restoreCurrentFramebuffer();
     contextGL()->DeleteFramebuffers(1, &tmpFBO);
     contextGL()->DeleteTextures(1, &targetTexture);
   }
 }
@@ skipping 45 matching lines @@
     // texImageByGPU relies on copyTextureCHROMIUM which doesn't support
     // float/integer/sRGB internal format.
     // TODO(crbug.com/622958): relax the constrains if copyTextureCHROMIUM is
     // upgraded to handle more formats.
     if (!canvas->renderingContext() ||
         !canvas->renderingContext()->isAccelerated() ||
         !canUseTexImageByGPU(functionID, internalformat, type)) {
       // 2D canvas has only FrontBuffer.
       texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
                    zoffset, format, type,
-                   canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
+                   canvas
+                       ->copiedImage(FrontBuffer, PreferAcceleration,
+                                     functionIDToSnapshotReason(functionID))
+                       .get(),
                    WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
                    m_unpackPremultiplyAlpha, sourceSubRectangle, 1, 0);
       return;
     }
 
     // The GPU-GPU copy path uses the Y-up coordinate system.
     IntRect adjustedSourceSubRectangle = sourceSubRectangle;
     if (!m_unpackFlipY) {
       adjustedSourceSubRectangle.setY(canvas->height() -
                                       adjustedSourceSubRectangle.maxY());
     }
 
     if (functionID == TexImage2D) {
       texImage2DBase(target, level, internalformat, sourceSubRectangle.width(),
                      sourceSubRectangle.height(), 0, format, type, 0);
-      texImageByGPU(TexImage2DByGPU, texture, target, level, internalformat,
-                    type, 0, 0, 0, canvas, adjustedSourceSubRectangle);
+      texImageByGPU(functionID, texture, target, level, internalformat, type, 0,
+                    0, 0, canvas, adjustedSourceSubRectangle);
     } else {
-      texImageByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type,
-                    xoffset, yoffset, 0, canvas, adjustedSourceSubRectangle);
+      texImageByGPU(functionID, texture, target, level, GL_RGBA, type, xoffset,
+                    yoffset, 0, canvas, adjustedSourceSubRectangle);
     }
   } else {
     // 3D functions.
 
     // TODO(zmo): Implement GPU-to-GPU copy path (crbug.com/612542).
     // Note that code will also be needed to copy to layers of 3D
     // textures, and elements of 2D texture arrays.
-    texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
-                 zoffset, format, type,
-                 canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
-                 WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
-                 m_unpackPremultiplyAlpha, sourceSubRectangle, depth,
-                 unpackImageHeight);
+    texImageImpl(
+        functionID, target, level, internalformat, xoffset, yoffset, zoffset,
+        format, type, canvas
+                          ->copiedImage(FrontBuffer, PreferAcceleration,
+                                        functionIDToSnapshotReason(functionID))
+                          .get(),
+        WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
+        m_unpackPremultiplyAlpha, sourceSubRectangle, depth, unpackImageHeight);
   }
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLCanvasElement* canvas,
                                            ExceptionState& exceptionState) {
@@ skipping 87 matching lines @@
 
         // This is a straight GPU-GPU copy, any necessary color space conversion
         // was handled in the paintCurrentFrameInContext() call.
 
         // Note that copyToPlatformTexture no longer allocates the destination
         // texture.
         texImage2DBase(target, level, internalformat, video->videoWidth(),
                        video->videoHeight(), 0, format, type, nullptr);
 
         if (imageBuffer->copyToPlatformTexture(
-                contextGL(), texture->object(), internalformat, type, level,
+                functionIDToSnapshotReason(functionID), contextGL(),
+                texture->object(), internalformat, type, level,
                 m_unpackPremultiplyAlpha, m_unpackFlipY, IntPoint(0, 0),
                 IntRect(0, 0, video->videoWidth(), video->videoHeight()))) {
           return;
         }
       }
     }
   }
 
   if (sourceImageRectIsDefault) {
     // Try using optimized CPU-GPU path for some formats: e.g. Y16 and Y8. It
@@ skipping 88 matching lines @@
   ASSERT(bitmap->bitmapImage());
 
   // TODO(kbr): make this work for sub-rectangles of ImageBitmaps.
   if (functionID != TexSubImage3D && functionID != TexImage3D &&
       bitmap->isAccelerated() &&
       canUseTexImageByGPU(functionID, internalformat, type) &&
       !selectingSubRectangle) {
     if (functionID == TexImage2D) {
       texImage2DBase(target, level, internalformat, width, height, 0, format,
                      type, 0);
-      texImageByGPU(TexImage2DByGPU, texture, target, level, internalformat,
-                    type, 0, 0, 0, bitmap, sourceSubRect);
+      texImageByGPU(functionID, texture, target, level, internalformat, type, 0,
+                    0, 0, bitmap, sourceSubRect);
     } else if (functionID == TexSubImage2D) {
-      texImageByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type,
-                    xoffset, yoffset, 0, bitmap, sourceSubRect);
+      texImageByGPU(functionID, texture, target, level, GL_RGBA, type, xoffset,
+                    yoffset, 0, bitmap, sourceSubRect);
     }
     return;
   }
   sk_sp<SkImage> skImage = bitmap->bitmapImage()->imageForCurrentFrame();
   SkPixmap pixmap;
   uint8_t* pixelDataPtr = nullptr;
   RefPtr<Uint8Array> pixelData;
   // In the case where an ImageBitmap is not texture backed, peekPixels() always
   // succeed.  However, when it is texture backed and !canUseTexImageByGPU, we
   // do a GPU read back.
@@ skipping 2441 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink