Make OffscreenCanvas histogram thread safe

third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/OffscreenCanvasFrameDispatcherImpl.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "platform/CrossThreadFunctional.h"
@@ skipping 263 matching lines @@
   const bool nearestNeighbor = false;
   quad->SetAll(sqs, bounds, bounds, bounds, needsBlending, resource.id,
                gfx::Size(), premultipliedAlpha, uvTopLeft, uvBottomRight,
                SK_ColorTRANSPARENT, vertexOpacity, yflipped, nearestNeighbor,
                false);
 
   frame.render_pass_list.push_back(std::move(pass));
 
   double elapsedTime = WTF::monotonicallyIncreasingTime() - commitStartTime;
 
-  // TODO(crbug.com/663916): The off-main-thread metrics are commented-out
-  // because they cause thread check errors (static variable accessed in many
-  // threads)
   switch (commitType) {
     case CommitGPUCanvasGPUCompositing:
       if (isMainThread()) {
         DEFINE_STATIC_LOCAL(
             CustomCountHistogram, commitGPUCanvasGPUCompositingMainTimer,
             ("Blink.Canvas.OffscreenCommit.GPUCanvasGPUCompositingMain", 0,
              10000000, 50));
         commitGPUCanvasGPUCompositingMainTimer.count(elapsedTime * 1000000.0);
-      } /* else {
-        DEFINE_STATIC_LOCAL(
+      } else {
+        DEFINE_THREAD_SAFE_STATIC_LOCAL(
             CustomCountHistogram, commitGPUCanvasGPUCompositingWorkerTimer,
-            ("Blink.Canvas.OffscreenCommit.GPUCanvasGPUCompositingWorker", 0,
-             10000000, 50));
+            new CustomCountHistogram(
+                "Blink.Canvas.OffscreenCommit.GPUCanvasGPUCompositingWorker", 0,
+                10000000, 50));
         commitGPUCanvasGPUCompositingWorkerTimer.count(elapsedTime * 1000000.0);
-      } */
+      }
       break;
     case CommitGPUCanvasSoftwareCompositing:
       if (isMainThread()) {
         DEFINE_STATIC_LOCAL(
             CustomCountHistogram, commitGPUCanvasSoftwareCompositingMainTimer,
             ("Blink.Canvas.OffscreenCommit.GPUCanvasSoftwareCompositingMain", 0,
              10000000, 50));
         commitGPUCanvasSoftwareCompositingMainTimer.count(elapsedTime *
                                                           1000000.0);
-      } /* else {
-        DEFINE_STATIC_LOCAL(
+      } else {
+        DEFINE_THREAD_SAFE_STATIC_LOCAL(
             CustomCountHistogram, commitGPUCanvasSoftwareCompositingWorkerTimer,
-            ("Blink.Canvas.OffscreenCommit.GPUCanvasSoftwareCompositingWorker",
-             0, 10000000, 50));
+            new CustomCountHistogram("Blink.Canvas.OffscreenCommit."
+                                     "GPUCanvasSoftwareCompositingWorker",
+                                     0, 10000000, 50));
         commitGPUCanvasSoftwareCompositingWorkerTimer.count(elapsedTime *
                                                             1000000.0);
-      } */
+      }
       break;
     case CommitSoftwareCanvasGPUCompositing:
       if (isMainThread()) {
         DEFINE_STATIC_LOCAL(
             CustomCountHistogram, commitSoftwareCanvasGPUCompositingMainTimer,
             ("Blink.Canvas.OffscreenCommit.SoftwareCanvasGPUCompositingMain", 0,
              10000000, 50));
         commitSoftwareCanvasGPUCompositingMainTimer.count(elapsedTime *
                                                           1000000.0);
-      } /* else {
-        DEFINE_STATIC_LOCAL(
+      } else {
+        DEFINE_THREAD_SAFE_STATIC_LOCAL(
             CustomCountHistogram, commitSoftwareCanvasGPUCompositingWorkerTimer,
-            ("Blink.Canvas.OffscreenCommit.SoftwareCanvasGPUCompositingWorker",
-             0, 10000000, 50));
+            new CustomCountHistogram("Blink.Canvas.OffscreenCommit."
+                                     "SoftwareCanvasGPUCompositingWorker",
+                                     0, 10000000, 50));
         commitSoftwareCanvasGPUCompositingWorkerTimer.count(elapsedTime *
                                                             1000000.0);
-      } */
+      }
       break;
     case CommitSoftwareCanvasSoftwareCompositing:
       if (isMainThread()) {
         DEFINE_STATIC_LOCAL(CustomCountHistogram,
                             commitSoftwareCanvasSoftwareCompositingMainTimer,
                             ("Blink.Canvas.OffscreenCommit."
                              "SoftwareCanvasSoftwareCompositingMain",
                              0, 10000000, 50));
         commitSoftwareCanvasSoftwareCompositingMainTimer.count(elapsedTime *
                                                                1000000.0);
-      } /* else {
-        DEFINE_STATIC_LOCAL(CustomCountHistogram,
-                            commitSoftwareCanvasSoftwareCompositingWorkerTimer,
-                            ("Blink.Canvas.OffscreenCommit."
-                             "SoftwareCanvasSoftwareCompositingWorker",
-                             0, 10000000, 50));
+      } else {
+        DEFINE_THREAD_SAFE_STATIC_LOCAL(
+            CustomCountHistogram,
+            commitSoftwareCanvasSoftwareCompositingWorkerTimer,
+            new CustomCountHistogram("Blink.Canvas.OffscreenCommit."
+                                     "SoftwareCanvasSoftwareCompositingWorker",
+                                     0, 10000000, 50));
         commitSoftwareCanvasSoftwareCompositingWorkerTimer.count(elapsedTime *
                                                                  1000000.0);
-      } */
+      }
       break;
     case OffscreenCanvasCommitTypeCount:
       NOTREACHED();
   }
 
   m_sink->SubmitCompositorFrame(std::move(frame));
 }
 
 void OffscreenCanvasFrameDispatcherImpl::DidReceiveCompositorFrameAck() {
   // TODO(fsamuel): Implement this.
@@ skipping 29 matching lines @@
 }
 
 bool OffscreenCanvasFrameDispatcherImpl::verifyImageSize(
     const IntSize imageSize) {
   if (imageSize.width() == m_width && imageSize.height() == m_height)
     return true;
   return false;
 }
 
 }  // namespace blink