cc: Images: Add more information to image decode controller DCHECKs

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 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/software_image_decode_controller.h"
 
 #include <stdint.h>
 
 #include <functional>
 
@@ skipping 249 matching lines @@
 }
 
 void SoftwareImageDecodeController::UnrefImage(const DrawImage& image) {
   // When we unref the image, there are several situations we need to consider:
   // 1. The ref did not reach 0, which means we have to keep the image locked.
   // 2. The ref reached 0, we should unlock it.
   //   2a. The image isn't in the locked cache because we didn't get to decode
   //       it yet (or failed to decode it).
   //   2b. Unlock the image but keep it in list.
   const ImageKey& key = ImageKey::FromDrawImage(image);
-  DCHECK(CanHandleImage(key));
+  DCHECK(CanHandleImage(key)) << key.ToString();
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::UnrefImage", "key",
                key.ToString());
 
   base::AutoLock lock(lock_);
   auto ref_count_it = decoded_images_ref_counts_.find(key);
   DCHECK(ref_count_it != decoded_images_ref_counts_.end());
 
   --ref_count_it->second;
   if (ref_count_it->second == 0) {
@@ skipping 139 matching lines @@
   // place. If, on the other hand, the decode was not available,
   // GetDecodedImageForDrawInternal() would decode the image, and unreffing it
   // later ensures that we will store the discardable memory unlocked in the
   // cache to be used by future requests.
   gfx::Rect full_image_rect(image->width(), image->height());
   DrawImage original_size_draw_image(image, gfx::RectToSkIRect(full_image_rect),
                                      kNone_SkFilterQuality, SkMatrix::I());
   ImageKey original_size_key =
       ImageKey::FromDrawImage(original_size_draw_image);
   // Sanity checks.
-  DCHECK(original_size_key.can_use_original_decode());
+  DCHECK(original_size_key.can_use_original_decode())
+      << original_size_key.ToString();
   DCHECK(full_image_rect.size() == original_size_key.target_size());
 
   auto decoded_draw_image = GetDecodedImageForDrawInternal(
       original_size_key, original_size_draw_image);
   if (!decoded_draw_image.image()) {
     DrawWithImageFinished(original_size_draw_image, decoded_draw_image);
     return nullptr;
   }
 
   SkPixmap decoded_pixmap;
   bool result = decoded_draw_image.image()->peekPixels(&decoded_pixmap);
-  DCHECK(result);
+  DCHECK(result) << key.ToString();
   if (key.src_rect() != full_image_rect) {
     result = decoded_pixmap.extractSubset(&decoded_pixmap,
                                           gfx::RectToSkIRect(key.src_rect()));
-    DCHECK(result);
+    DCHECK(result) << key.ToString();
   }
 
   // Now we have a decoded_pixmap which represents the src_rect at the
   // original scale. All we need to do is scale it.
   DCHECK(!key.target_size().IsEmpty());
   SkImageInfo scaled_info = CreateImageInfo(
       key.target_size().width(), key.target_size().height(), format_);
   scoped_ptr<base::DiscardableMemory> scaled_pixels;
   {
     TRACE_EVENT0(
         "disabled-by-default-cc.debug",
         "SoftwareImageDecodeController::DecodeImageInternal - allocate "
         "scaled pixels");
     scaled_pixels = base::DiscardableMemoryAllocator::GetInstance()
                         ->AllocateLockedDiscardableMemory(
                             scaled_info.minRowBytes() * scaled_info.height());
   }
   SkPixmap scaled_pixmap(scaled_info, scaled_pixels->data(),
                          scaled_info.minRowBytes());
   // TODO(vmpstr): Start handling more than just high filter quality.
   DCHECK_EQ(kHigh_SkFilterQuality, key.filter_quality());
   {
     TRACE_EVENT0(
         "disabled-by-default-cc.debug",
         "SoftwareImageDecodeController::DecodeImageInternal - scale pixels");
     bool result =
         decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
-    DCHECK(result);
+    DCHECK(result) << key.ToString();
   }
 
   // Release the original sized decode. Any other intermediate result to release
   // would be the subrect memory. However, that's in a scoped_ptr and will be
   // deleted automatically when we return.
   DrawWithImageFinished(original_size_draw_image, decoded_draw_image);
 
   return make_scoped_ptr(
       new DecodedImage(scaled_info, std::move(scaled_pixels),
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y())));
@@ skipping 405 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc