cc: Add UMA for tracking decode duration for out of raster decodes.

cc/base/devtools_instrumentation.h

 // Copyright 2013 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.
 
 #ifndef CC_BASE_DEVTOOLS_INSTRUMENTATION_H_
 #define CC_BASE_DEVTOOLS_INSTRUMENTATION_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 39 matching lines @@
   ~ScopedLayerTask() { TRACE_EVENT_END0(internal::kCategory, event_name_); }
 
  private:
   const char* event_name_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedLayerTask);
 };
 
 class CC_BASE_EXPORT ScopedImageDecodeTask {
  public:
-  enum Type { SOFTWARE, GPU };
+  enum DecodeType { kSoftware, kGpu };
+  enum TaskType { kInRaster, kOutOfRaster };
 
-  ScopedImageDecodeTask(const void* imagePtr, Type type)
-      : type_(type), start_time_(base::TimeTicks::Now()) {
+  ScopedImageDecodeTask(const void* image_ptr,
+                        DecodeType type,
+                        TaskType task_type)
+      : type_(type),

[vmpstr, 2017/06/01 21:40:56]

nit: decode_type_(decode_type)

[Khushal, 2017/06/01 23:45:09]

Done.

+        task_type_(task_type),
+        start_time_(base::TimeTicks::Now()) {
     TRACE_EVENT_BEGIN1(internal::kCategory, internal::kImageDecodeTask,
                        internal::kPixelRefId,
-                       reinterpret_cast<uint64_t>(imagePtr));
+                       reinterpret_cast<uint64_t>(image_ptr));
   }
   ~ScopedImageDecodeTask() {
     TRACE_EVENT_END0(internal::kCategory, internal::kImageDecodeTask);
     base::TimeDelta duration = base::TimeTicks::Now() - start_time_;
-    switch (type_) {
-      case SOFTWARE:
-        UMA_HISTOGRAM_COUNTS_1M("Renderer4.ImageDecodeTaskDurationUs.Software",
-                                duration.InMicroseconds());
+    switch (task_type_) {
+      case kInRaster:
+        switch (type_) {
+          case kSoftware:
+            UMA_HISTOGRAM_COUNTS_1M(
+                "Renderer4.ImageDecodeTaskDurationUs.Software",
+                duration.InMicroseconds());
+            break;
+          case kGpu:
+            UMA_HISTOGRAM_COUNTS_1M("Renderer4.ImageDecodeTaskDurationUs.Gpu",
+                                    duration.InMicroseconds());
+            break;
+        }
         break;
-      case GPU:
-        UMA_HISTOGRAM_COUNTS_1M("Renderer4.ImageDecodeTaskDurationUs.Gpu",
-                                duration.InMicroseconds());
+      case kOutOfRaster:
+        switch (type_) {
+          case kSoftware:
+            UMA_HISTOGRAM_COUNTS_1M(
+                "Renderer4.ImageDecodeTaskDurationUs.OutOfRaster.Software",
+                duration.InMicroseconds());
+            break;
+          case kGpu:
+            UMA_HISTOGRAM_COUNTS_1M(
+                "Renderer4.ImageDecodeTaskDurationUs.OutOfRaster.Gpu",
+                duration.InMicroseconds());
+            break;
+        }
         break;
     }
   }
 
  private:
-  const Type type_;
+  const DecodeType type_;
+  const TaskType task_type_;
   const base::TimeTicks start_time_;
   DISALLOW_COPY_AND_ASSIGN(ScopedImageDecodeTask);
 };
 
 class CC_BASE_EXPORT ScopedLayerTreeTask {
  public:
   ScopedLayerTreeTask(const char* event_name,
                       int layer_id,
                       int layer_tree_host_id)
       : event_name_(event_name) {
@@ skipping 87 matching lines @@
   TRACE_EVENT_INSTANT2(
       internal::kCategoryFrame, internal::kNeedsBeginFrameChanged,
       TRACE_EVENT_SCOPE_THREAD, internal::kLayerTreeId, layer_tree_host_id,
       internal::kData, NeedsBeginFrameData(new_value));
 }
 
 }  // namespace devtools_instrumentation
 }  // namespace cc
 
 #endif  // CC_BASE_DEVTOOLS_INSTRUMENTATION_H_