cc: Add four new histograms for gpu image decode/upload usage tracking.

cc/tiles/gpu_image_decode_controller.cc

 // 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 "cc/tiles/gpu_image_decode_controller.h"
 
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/raster/tile_task.h"
 #include "cc/resources/resource_format_utils.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu_image_decode_controller.h"
@@ skipping 110 matching lines @@
 
  private:
   GpuImageDecodeController* controller_;
   DrawImage image_;
   const ImageDecodeController::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageUploadTaskImpl);
 };
 
 GpuImageDecodeController::DecodedImageData::DecodedImageData() = default;
-GpuImageDecodeController::DecodedImageData::~DecodedImageData() = default;
+GpuImageDecodeController::DecodedImageData::~DecodedImageData() {
+  ResetData();
+}
 
 bool GpuImageDecodeController::DecodedImageData::Lock() {
   DCHECK(!is_locked_);
   is_locked_ = data_->Lock();
+  if (is_locked_)
+    ++usage_stats_.lock_count;
   return is_locked_;
 }
 
 void GpuImageDecodeController::DecodedImageData::Unlock() {
   DCHECK(is_locked_);
   data_->Unlock();
+  if (usage_stats_.lock_count == 1)
+    usage_stats_.first_lock_wasted = !usage_stats_.used;
   is_locked_ = false;
 }
 
 void GpuImageDecodeController::DecodedImageData::SetLockedData(
     std::unique_ptr<base::DiscardableMemory> data) {
   DCHECK(!is_locked_);
+  DCHECK(data);
+  DCHECK(!data_);
   data_ = std::move(data);
   is_locked_ = true;
 }
 
 void GpuImageDecodeController::DecodedImageData::ResetData() {
   DCHECK(!is_locked_);
+  if (data_)
+    ReportUsageStats();
   data_ = nullptr;
+  usage_stats_ = UsageStats();
+}
+
+void GpuImageDecodeController::DecodedImageData::ReportUsageStats() const {
+  // lock_count | used  | result state
+  // ===========+=======+==================
+  //  1         | false | WASTED_ONCE
+  //  1         | true  | USED_ONCE
+  //  >1        | false | WASTED_RELOCKED
+  //  >1        | true  | USED_RELOCKED
+  // Note that it's important not to reorder the following enums, since the
+  // numerical values are used in the histogram code.
+  enum State : int {
+    DECODED_IMAGE_STATE_WASTED_ONCE,
+    DECODED_IMAGE_STATE_USED_ONCE,
+    DECODED_IMAGE_STATE_WASTED_RELOCKED,
+    DECODED_IMAGE_STATE_USED_RELOCKED,
+    DECODED_IMAGE_STATE_COUNT
+  } state = DECODED_IMAGE_STATE_WASTED_ONCE;
+
+  if (usage_stats_.lock_count == 1) {
+    if (usage_stats_.used)
+      state = DECODED_IMAGE_STATE_USED_ONCE;
+    else
+      state = DECODED_IMAGE_STATE_WASTED_ONCE;
+  } else {
+    if (usage_stats_.used)
+      state = DECODED_IMAGE_STATE_USED_RELOCKED;
+    else
+      state = DECODED_IMAGE_STATE_WASTED_RELOCKED;
+  }
+
+  UMA_HISTOGRAM_ENUMERATION("Renderer4.GpuImageDecodeState", state,
+                            DECODED_IMAGE_STATE_COUNT);
+  UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageDecodeState.FirstLockWasted",
+                        usage_stats_.first_lock_wasted);
 }
 
 GpuImageDecodeController::UploadedImageData::UploadedImageData() = default;
-GpuImageDecodeController::UploadedImageData::~UploadedImageData() = default;
+GpuImageDecodeController::UploadedImageData::~UploadedImageData() {
+  SetImage(nullptr);
+}
 
 void GpuImageDecodeController::UploadedImageData::SetImage(
     sk_sp<SkImage> image) {
+  DCHECK(!image_ || !image);
+  if (image_) {
+    ReportUsageStats();
+    usage_stats_ = UsageStats();
+  }
   image_ = std::move(image);
 }
 
+void GpuImageDecodeController::UploadedImageData::ReportUsageStats() const {
+  UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageUploadState.Used",
+                        usage_stats_.used);
+  UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageUploadState.FirstRefWasted",
+                        usage_stats_.first_ref_wasted);
+}
+
 GpuImageDecodeController::ImageData::ImageData(DecodedDataMode mode,
                                                size_t size)
     : mode(mode), size(size) {}
 
 GpuImageDecodeController::ImageData::~ImageData() = default;
 
 GpuImageDecodeController::GpuImageDecodeController(ContextProvider* context,
                                                    ResourceFormat decode_format,
                                                    size_t max_gpu_image_bytes)
     : format_(decode_format),
@@ skipping 152 matching lines @@
 
   // We may or may not need to decode and upload the image we've found, the
   // following functions early-out to if we already decoded.
   DecodeImageIfNecessary(draw_image, image_data);
   UploadImageIfNecessary(draw_image, image_data);
   // Unref the image decode, but not the image. The image ref will be released
   // in DrawWithImageFinished.
   UnrefImageDecode(draw_image);
 
   sk_sp<SkImage> image = image_data->upload.image();
+  image_data->upload.mark_used();
   DCHECK(image || image_data->decode.decode_failure);
 
   DecodedDrawImage decoded_draw_image(std::move(image),
                                       draw_image.filter_quality());
   decoded_draw_image.set_at_raster_decode(image_data->is_at_raster);
   return decoded_draw_image;
 }
 
 void GpuImageDecodeController::DrawWithImageFinished(
     const DrawImage& draw_image,
@@ skipping 197 matching lines @@
   ++found->second->upload.ref_count;
   RefCountChanged(found->second.get());
 }
 
 void GpuImageDecodeController::UnrefImageInternal(const DrawImage& draw_image) {
   lock_.AssertAcquired();
   auto found = image_data_.Peek(draw_image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   DCHECK_GT(found->second->upload.ref_count, 0u);
   --found->second->upload.ref_count;
+  if (found->second->upload.ref_count == 0)
+    found->second->upload.notify_ref_reached_zero();
   RefCountChanged(found->second.get());
 }
 
 // Called any time an image or decode ref count changes. Takes care of any
 // necessary memory budget book-keeping and cleanup.
 void GpuImageDecodeController::RefCountChanged(ImageData* image_data) {
   lock_.AssertAcquired();
 
   bool has_any_refs =
       image_data->upload.ref_count > 0 || image_data->decode.ref_count > 0;
@@ skipping 247 matching lines @@
         break;
       }
       case DecodedDataMode::GPU: {
         uploaded_image = SkImage::MakeFromDeferredTextureImageData(
             context_->GrContext(), image_data->decode.data()->data(),
             SkBudgeted::kNo);
         break;
       }
     }
   }
+  image_data->decode.mark_used();
   DCHECK(uploaded_image);
 
   // At-raster may have decoded this while we were unlocked. If so, ignore our
   // result.
   if (!image_data->upload.image())
     image_data->upload.SetImage(std::move(uploaded_image));
 }
 
 std::unique_ptr<GpuImageDecodeController::ImageData>
 GpuImageDecodeController::CreateImageData(const DrawImage& draw_image) {
@@ skipping 42 matching lines @@
 bool GpuImageDecodeController::DiscardableIsLockedForTesting(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   auto found = image_data_.Peek(image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   ImageData* image_data = found->second.get();
   return image_data->decode.is_locked();
 }
 
 }  // namespace cc