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

cc/tiles/gpu_image_decode_controller.h

 // 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.
 
 #ifndef CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
 #define CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
 
 #include <memory>
 #include <unordered_map>
 #include <vector>
@@ skipping 93 matching lines @@
     DecodedImageData();
     ~DecodedImageData();
 
     bool is_locked() const { return is_locked_; }
     bool Lock();
     void Unlock();
     void SetLockedData(std::unique_ptr<base::DiscardableMemory> data);
     void ResetData();
     base::DiscardableMemory* data() const { return data_.get(); }
 
+    void mark_used() { usage_stats_.used = true; }
+
     // May be null if image not yet decoded.
     uint32_t ref_count = 0;
     // Set to true if the image was corrupt and could not be decoded.
     bool decode_failure = false;
 
    private:
+    struct UsageStats {
+      int lock_count = 1;
+      bool used = false;
+      bool first_lock_wasted = false;
+    };
+
+    void ReportUsageStats() const;
+
     std::unique_ptr<base::DiscardableMemory> data_;
     bool is_locked_ = false;
+    UsageStats usage_stats_;
   };
 
   // Stores the GPU-side image and supporting fields.
   struct UploadedImageData {
     UploadedImageData();
     ~UploadedImageData();
 
     void SetImage(sk_sp<SkImage> image);
     const sk_sp<SkImage>& image() const { return image_; }
 
+    void mark_used() { usage_stats_.used = true; }
+    void notify_ref_reached_zero() {
+      if (++usage_stats_.ref_reached_zero_count == 1)
+        usage_stats_.first_ref_wasted = !usage_stats_.used;
+    }
+
     // True if the image is counting against our memory limits.
     bool budgeted = false;
     uint32_t ref_count = 0;
 
    private:
+    struct UsageStats {
+      bool used = false;
+      bool first_ref_wasted = false;
+      int ref_reached_zero_count = 0;
+    };
+
+    void ReportUsageStats() const;
+
     // May be null if image not yet uploaded / prepared.
     sk_sp<SkImage> image_;
+    UsageStats usage_stats_;
   };
 
   struct ImageData {
     ImageData(DecodedDataMode mode, size_t size);
     ~ImageData();
 
     const DecodedDataMode mode;
     const size_t size;
     bool is_at_raster = false;
 
@@ skipping 59 matching lines @@
 
   // We can't release GPU backed SkImages without holding the context lock,
   // so we add them to this list and defer deletion until the next time the lock
   // is held.
   std::vector<sk_sp<SkImage>> images_pending_deletion_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_