Don't log decode task umas for trivial tasks

These are throwing off our reporting metrics, and aren't interesting to
record.

Bug: 978225
Change-Id: I78882e53f32acd74e2cf8513b72774e8e7312b8c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1674785
Commit-Queue: Eric Karl <ericrk@chromium.org>
Reviewed-by: Madeleine Barowsky <mbarowsky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#678491}

cc/base/devtools_instrumentation.cc

@@ -43,6 +43,9 @@ ScopedImageDecodeTask::ScopedImageDecodeTask(const void* image_ptr,
 ScopedImageDecodeTask::~ScopedImageDecodeTask() {
   TRACE_EVENT_END0(internal::CategoryName::kTimeline,
                    internal::kImageDecodeTask);
+  if (suppress_metrics_)
+    return;
+
   base::TimeDelta duration = base::TimeTicks::Now() - start_time_;
   switch (task_type_) {
     case kInRaster:

cc/base/devtools_instrumentation.h

@@ -76,10 +76,15 @@ class CC_BASE_EXPORT ScopedImageDecodeTask {
 
   ScopedImageDecodeTask& operator=(const ScopedImageDecodeTask&) = delete;
 
+  // Prevents logging duration metrics. Used in cases where a task performed
+  // uninteresting work or was terminated early.
+  void SuppressMetrics() { suppress_metrics_ = true; }
+
  private:
   const DecodeType decode_type_;
   const TaskType task_type_;
   const base::TimeTicks start_time_;
+  bool suppress_metrics_ = false;
 };
 
 class CC_BASE_EXPORT ScopedLayerTreeTask {

cc/tiles/software_image_decode_cache.cc

@@ -76,7 +76,12 @@ class SoftwareImageDecodeTaskImpl : public TileTask {
         paint_image_.GetSkImage().get(),
         devtools_instrumentation::ScopedImageDecodeTask::kSoftware,
         ImageDecodeCache::ToScopedTaskType(tracing_info_.task_type));
-    cache_->DecodeImageInTask(image_key_, paint_image_, task_type_);
+    SoftwareImageDecodeCache::TaskProcessingResult result =
+        cache_->DecodeImageInTask(image_key_, paint_image_, task_type_);
+
+    // Do not log timing UMAs if we did not perform a full decode.
+    if (result != SoftwareImageDecodeCache::TaskProcessingResult::kFullDecode)
+      image_decode_task.SuppressMetrics();
   }
 
   // Overridden from TileTask:
@@ -300,9 +305,10 @@ void SoftwareImageDecodeCache::UnrefImage(const CacheKey& key) {
   }
 }
 
-void SoftwareImageDecodeCache::DecodeImageInTask(const CacheKey& key,
-                                                 const PaintImage& paint_image,
-                                                 DecodeTaskType task_type) {
+SoftwareImageDecodeCache::TaskProcessingResult
+SoftwareImageDecodeCache::DecodeImageInTask(const CacheKey& key,
+                                            const PaintImage& paint_image,
+                                            DecodeTaskType task_type) {
   TRACE_EVENT1("cc,benchmark", "SoftwareImageDecodeCache::DecodeImageInTask",
                "key", key.ToString());
   base::AutoLock lock(lock_);
@@ -316,14 +322,16 @@ void SoftwareImageDecodeCache::DecodeImageInTask(const CacheKey& key,
   DCHECK_GT(cache_entry->ref_count, 0);
   DCHECK(cache_entry->is_budgeted);
 
-  DecodeImageIfNecessary(key, paint_image, cache_entry);
+  TaskProcessingResult result =
+      DecodeImageIfNecessary(key, paint_image, cache_entry);
   DCHECK(cache_entry->decode_failed || cache_entry->is_locked);
+  return result;
 }
 
-void SoftwareImageDecodeCache::DecodeImageIfNecessary(
-    const CacheKey& key,
-    const PaintImage& paint_image,
-    CacheEntry* entry) {
+SoftwareImageDecodeCache::TaskProcessingResult
+SoftwareImageDecodeCache::DecodeImageIfNecessary(const CacheKey& key,
+                                                 const PaintImage& paint_image,
+                                                 CacheEntry* entry) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "SoftwareImageDecodeCache::DecodeImageIfNecessary", "key",
                key.ToString());
@@ -334,18 +342,18 @@ void SoftwareImageDecodeCache::DecodeImageIfNecessary(
     entry->decode_failed = true;
 
   if (entry->decode_failed)
-    return;
+    return TaskProcessingResult::kCancelled;
 
   if (entry->memory) {
     if (entry->is_locked)
-      return;
+      return TaskProcessingResult::kLockOnly;
 
     bool lock_succeeded = entry->Lock();
     // TODO(vmpstr): Deprecate the prepaint split, since it doesn't matter.
     RecordLockExistingCachedImageHistogram(TilePriority::NOW, lock_succeeded);
 
     if (lock_succeeded)
-      return;
+      return TaskProcessingResult::kLockOnly;
   }
 
   std::unique_ptr<CacheEntry> local_cache_entry;
@@ -437,7 +445,7 @@ void SoftwareImageDecodeCache::DecodeImageIfNecessary(
 
   if (!local_cache_entry) {
     entry->decode_failed = true;
-    return;
+    return TaskProcessingResult::kCancelled;
   }
 
   // Just in case someone else did this already, just unlock our work.
@@ -455,6 +463,8 @@ void SoftwareImageDecodeCache::DecodeImageIfNecessary(
     local_cache_entry->MoveImageMemoryTo(entry);
     DCHECK(entry->is_locked);
   }
+
+  return TaskProcessingResult::kFullDecode;
 }
 
 base::Optional<SoftwareImageDecodeCache::CacheKey>

cc/tiles/software_image_decode_cache.h

@@ -32,6 +32,10 @@ class CC_EXPORT SoftwareImageDecodeCache
 
   enum class DecodeTaskType { USE_IN_RASTER_TASKS, USE_OUT_OF_RASTER_TASKS };
 
+  // Identifies whether a decode task performed decode work, or was fulfilled /
+  // failed trivially.
+  enum class TaskProcessingResult { kFullDecode, kLockOnly, kCancelled };
+
   SoftwareImageDecodeCache(SkColorType color_type,
                            size_t locked_memory_limit_bytes,
                            PaintImage::GeneratorClientId generator_client_id);
@@ -56,9 +60,9 @@ class CC_EXPORT SoftwareImageDecodeCache
 
   // Decode the given image and store it in the cache. This is only called by an
   // image decode task from a worker thread.
-  void DecodeImageInTask(const CacheKey& key,
-                         const PaintImage& paint_image,
-                         DecodeTaskType task_type);
+  TaskProcessingResult DecodeImageInTask(const CacheKey& key,
+                                         const PaintImage& paint_image,
+                                         DecodeTaskType task_type);
 
   void OnImageDecodeTaskCompleted(const CacheKey& key,
                                   DecodeTaskType task_type);
@@ -123,9 +127,9 @@ class CC_EXPORT SoftwareImageDecodeCache
 
   CacheEntry* AddCacheEntry(const CacheKey& key);
 
-  void DecodeImageIfNecessary(const CacheKey& key,
-                              const PaintImage& paint_image,
-                              CacheEntry* cache_entry);
+  TaskProcessingResult DecodeImageIfNecessary(const CacheKey& key,
+                                              const PaintImage& paint_image,
+                                              CacheEntry* cache_entry);
   void AddBudgetForImage(const CacheKey& key, CacheEntry* entry);
   void RemoveBudgetForImage(const CacheKey& key, CacheEntry* entry);
   base::Optional<CacheKey> FindCachedCandidate(const CacheKey& key);