cc: ImageDecodes: handle low quality filters.

cc/tiles/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/image_decode_controller.h"
 
 #include <stdint.h>
 
+#include <functional>
+
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 namespace {
 
@@ skipping 52 matching lines @@
 
 template <typename Type>
 typename std::deque<Type>::iterator FindImage(
     std::deque<Type>* collection,
     const ImageDecodeControllerKey& key) {
   return std::find_if(collection->begin(), collection->end(),
                       [key](const Type& image) { return image.first == key; });
 }
 
 SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key) {
+  if (key.can_use_original_decode())
+    return SkSize::Make(1.f, 1.f);
+
   float x_scale =
       key.target_size().width() / static_cast<float>(key.src_rect().width());
   float y_scale =
       key.target_size().height() / static_cast<float>(key.src_rect().height());
   return SkSize::Make(x_scale, y_scale);
 }
 
 }  // namespace
 
 ImageDecodeController::ImageDecodeController()
@@ skipping 45 matching lines @@
       *task = nullptr;
     }
     return false;
   }
 
   base::AutoLock lock(lock_);
 
   // If we already have the image in cache, then we can return it.
   auto decoded_it = FindImage(&decoded_images_, key);
   bool new_image_fits_in_memory =
-      locked_images_budget_.AvailableMemoryBytes() >= key.target_bytes();
+      locked_images_budget_.AvailableMemoryBytes() >= key.locked_bytes();
   if (decoded_it != decoded_images_.end()) {
     if (decoded_it->second->is_locked() ||
         (new_image_fits_in_memory && decoded_it->second->Lock())) {
       RefImage(key);
       *task = nullptr;
       SanityCheckState(__LINE__, true);
       return true;
     }
     // If the image fits in memory, then we at least tried to lock it and
     // failed. This means that it's not valid anymore.
@@ skipping 31 matching lines @@
   SanityCheckState(__LINE__, true);
   return true;
 }
 
 void ImageDecodeController::RefImage(const ImageKey& key) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "ImageDecodeController::RefImage", "key", key.ToString());
   lock_.AssertAcquired();
   int ref = ++decoded_images_ref_counts_[key];
   if (ref == 1) {
-    DCHECK_GE(locked_images_budget_.AvailableMemoryBytes(), key.target_bytes());
-    locked_images_budget_.AddUsage(key.target_bytes());
+    DCHECK_GE(locked_images_budget_.AvailableMemoryBytes(), key.locked_bytes());
+    locked_images_budget_.AddUsage(key.locked_bytes());
   }
 }
 
 void ImageDecodeController::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, image));
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "ImageDecodeController::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) {
     decoded_images_ref_counts_.erase(ref_count_it);
-    locked_images_budget_.SubtractUsage(key.target_bytes());
+    locked_images_budget_.SubtractUsage(key.locked_bytes());
 
     auto decoded_image_it = FindImage(&decoded_images_, key);
     // If we've never decoded the image before ref reached 0, then we wouldn't
     // have it in our cache. This would happen if we canceled tasks.
     if (decoded_image_it == decoded_images_.end()) {
       SanityCheckState(__LINE__, true);
       return;
     }
     DCHECK(decoded_image_it->second->is_locked());
     decoded_image_it->second->Unlock();
@@ skipping 26 matching lines @@
     if (image_it->second->is_locked() || image_it->second->Lock()) {
       pending_image_tasks_.erase(key);
       return;
     }
     decoded_images_.erase(image_it);
   }
 
   scoped_refptr<DecodedImage> decoded_image;
   {
     base::AutoUnlock unlock(lock_);
-    decoded_image = DecodeImageInternal(key, image.image());
+    decoded_image = DecodeImageInternal(key, image);
   }
 
   // Erase the pending task from the queue, since the task won't be doing
   // anything useful after this function terminates. That is, if this image
   // needs to be decoded again, we have to create a new task.
   pending_image_tasks_.erase(key);
 
   // Abort if we failed to decode the image.
   if (!decoded_image)
     return;
@@ skipping 19 matching lines @@
       decoded_images_ref_counts_.end()) {
     decoded_image->Unlock();
   }
 
   decoded_images_.push_back(AnnotatedDecodedImage(key, decoded_image));
   SanityCheckState(__LINE__, true);
 }
 
 scoped_refptr<ImageDecodeController::DecodedImage>
 ImageDecodeController::DecodeImageInternal(const ImageKey& key,
-                                           const SkImage* image) {
+                                           const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "ImageDecodeController::DecodeImageInternal", "key",
                key.ToString());
 
-  // Get the decoded image first (at the original scale).
-  SkImageInfo decoded_info = SkImageInfo::MakeN32Premul(
-      key.src_rect().width(), key.src_rect().height());
-  scoped_ptr<uint8_t[]> decoded_pixels;
-  {
-    TRACE_EVENT0(
-        "disabled-by-default-cc.debug",
-        "ImageDecodeController::DecodeImageInternal - allocate decoded pixels");
-    decoded_pixels.reset(
-        new uint8_t[decoded_info.minRowBytes() * decoded_info.height()]);
-  }
-  {
-    TRACE_EVENT0("disabled-by-default-cc.debug",
-                 "ImageDecodeController::DecodeImageInternal - read pixels");
-    bool result = image->readPixels(
-        decoded_info, decoded_pixels.get(), decoded_info.minRowBytes(),
-        key.src_rect().x(), key.src_rect().y(), SkImage::kAllow_CachingHint);
+  const SkImage* image = draw_image.image();
 
-    if (!result)
-      return nullptr;
+  // If we can use the original decode, then we don't need to do scaling. We can
+  // just read pixels into the final memory.
+  if (key.can_use_original_decode()) {
+    SkImageInfo decoded_info =
+        SkImageInfo::MakeN32Premul(image->width(), image->height());
+    scoped_ptr<base::DiscardableMemory> decoded_pixels;
+    {
+      TRACE_EVENT0("disabled-by-default-cc.debug",
+                   "ImageDecodeController::DecodeImageInternal - allocate "
+                   "decoded pixels");
+      decoded_pixels =
+          base::DiscardableMemoryAllocator::GetInstance()
+              ->AllocateLockedDiscardableMemory(decoded_info.minRowBytes() *
+                                                decoded_info.height());
+    }
+    {
+      TRACE_EVENT0("disabled-by-default-cc.debug",
+                   "ImageDecodeController::DecodeImageInternal - read pixels");
+      bool result = image->readPixels(decoded_info, decoded_pixels->data(),
+                                      decoded_info.minRowBytes(), 0, 0,
+                                      SkImage::kDisallow_CachingHint);
+
+      if (!result) {
+        decoded_pixels->Unlock();
+        return nullptr;
+      }
+    }
+
+    return make_scoped_refptr(new DecodedImage(
+        decoded_info, std::move(decoded_pixels), SkSize::Make(0, 0)));
   }
 
-  SkPixmap decoded_pixmap(decoded_info, decoded_pixels.get(),
-                          decoded_info.minRowBytes());
+  // If we get here, that means we couldn't use the original sized decode for
+  // whatever reason. However, in all cases we do need an original decode to
+  // either do a scale or to extract a subrect from the image. So, what we can
+  // do is construct a key that would require a full sized decode, then get that
+  // decode via GetDecodedImageForDrawInternal(), use it, and unref it. This
+  // ensures that if the original sized decode is already available in any of
+  // the caches, we reuse that. We also ensure that all the proper locking takes
+  // 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.
+  SkSize identity_scale = SkSize::Make(1.f, 1.f);
+  bool matrix_has_perspective = false;
+  bool matrix_is_decomposable = true;
+  gfx::Rect full_image_rect(image->width(), image->height());
+  DrawImage original_size_draw_image(
+      image, gfx::RectToSkIRect(full_image_rect), identity_scale,
+      kLow_SkFilterQuality, matrix_has_perspective, matrix_is_decomposable);
+  ImageKey original_size_key =
+      ImageKey::FromDrawImage(original_size_draw_image);
+  // Sanity checks.
+  DCHECK(original_size_key.can_use_original_decode());
+  DCHECK(full_image_rect.size() == original_size_key.target_size());
 
-  // Now scale the pixels into the destination 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);

[ericrk, 2016/02/11 01:21:50]

not really specific to this change - but would it work well to have
DecodedDrawImage auto call this when it goes out of scope? Or have a
ScopedDrawImage or something?

[vmpstr, 2016/02/17 21:21:03]

Yeah I have that in the ImageHijackCanvas. I figured it's not too bad here,
since there are only two exits out of the function. 

For the time being I'm trying to limit the amount of classes that I introduce,
but maybe we can revisit this later.

[ericrk, 2016/02/19 23:22:31]

sounds good.

+    return nullptr;
+  }
+
+  scoped_ptr<uint8_t[]> decoded_subrect_pixels;
+  SkPixmap decoded_pixmap;
+  bool result;
+  if (key.src_rect() == full_image_rect) {
+    result = decoded_draw_image.image()->peekPixels(&decoded_pixmap);
+  } else {
+    SkImageInfo decoded_info = SkImageInfo::MakeN32Premul(
+        key.src_rect().width(), key.src_rect().height());
+    {
+      TRACE_EVENT0("disabled-by-default-cc.debug",
+                   "ImageDecodeController::DecodeImageInternal - allocate "
+                   "decoded pixels");
+      decoded_subrect_pixels.reset(
+          new uint8_t[decoded_info.minRowBytes() * decoded_info.height()]);
+    }
+    {
+      TRACE_EVENT0("disabled-by-default-cc.debug",
+                   "ImageDecodeController::DecodeImageInternal - read pixels");
+      result =
+          image->readPixels(decoded_info, decoded_subrect_pixels.get(),
+                            decoded_info.minRowBytes(), key.src_rect().x(),
+                            key.src_rect().y(), SkImage::kDisallow_CachingHint);
+    }
+    decoded_pixmap = SkPixmap(decoded_info, decoded_subrect_pixels.get(),
+                              decoded_info.minRowBytes());
+  }
+
+  // Since the decoded_draw_image has locked memory, it should always succeed on
+  // both peekPixels and readPixels.
+  DCHECK(result);
+
+  // 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 = SkImageInfo::MakeN32Premul(
       key.target_size().width(), key.target_size().height());
   scoped_ptr<base::DiscardableMemory> scaled_pixels;
   {
     TRACE_EVENT0(
         "disabled-by-default-cc.debug",
         "ImageDecodeController::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",
                  "ImageDecodeController::DecodeImageInternal - scale pixels");
     bool result =
-        decoded_pixmap.scalePixels(scaled_pixmap, kHigh_SkFilterQuality);
+        decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
     DCHECK(result);
   }
+
+  // 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_refptr(
       new DecodedImage(scaled_info, std::move(scaled_pixels),
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y())));
 }
 
 DecodedDrawImage ImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1("disabled-by-default-cc.debug",
-               "ImageDecodeController::GetDecodedImageAndRef", "key",
+               "ImageDecodeController::GetDecodedImageForDraw", "key",
                key.ToString());
   if (!CanHandleImage(key, draw_image))
     return DecodedDrawImage(draw_image.image(), draw_image.filter_quality());
 
   // If the target size is empty, we can skip this image draw.
   if (key.target_size().IsEmpty())
     return DecodedDrawImage(nullptr, kNone_SkFilterQuality);
 
+  return GetDecodedImageForDrawInternal(key, draw_image);
+}
+
+DecodedDrawImage ImageDecodeController::GetDecodedImageForDrawInternal(
+    const ImageKey& key,
+    const DrawImage& draw_image) {
+  TRACE_EVENT1("disabled-by-default-cc.debug",
+               "ImageDecodeController::GetDecodedImageForDrawInternal", "key",
+               key.ToString());
   base::AutoLock lock(lock_);
   auto decoded_images_it = FindImage(&decoded_images_, key);
   // If we found the image and it's locked, then return it. If it's not locked,
   // erase it from the cache since it might be put into the at-raster cache.
   scoped_refptr<DecodedImage> decoded_image;
   if (decoded_images_it != decoded_images_.end()) {
     decoded_image = decoded_images_it->second;
     if (decoded_image->is_locked()) {
       RefImage(key);
       SanityCheckState(__LINE__, true);
       return DecodedDrawImage(decoded_image->image(),
                               decoded_image->src_rect_offset(),
                               GetScaleAdjustment(key), kLow_SkFilterQuality);
     } else {
       decoded_images_.erase(decoded_images_it);
     }
   }
 
   // See if another thread already decoded this image at raster time. If so, we
   // can just use that result directly.
   auto at_raster_images_it = FindImage(&at_raster_decoded_images_, key);
   if (at_raster_images_it != at_raster_decoded_images_.end()) {
     DCHECK(at_raster_images_it->second->is_locked());
     RefAtRasterImage(key);
     SanityCheckState(__LINE__, true);
+    const scoped_refptr<DecodedImage>& at_raster_decoded_image =
+        at_raster_images_it->second;
     auto decoded_draw_image =
-        DecodedDrawImage(at_raster_images_it->second->image(),
-                         at_raster_images_it->second->src_rect_offset(),
+        DecodedDrawImage(at_raster_decoded_image->image(),
+                         at_raster_decoded_image->src_rect_offset(),
                          GetScaleAdjustment(key), kLow_SkFilterQuality);
     decoded_draw_image.set_at_raster_decode(true);
     return decoded_draw_image;
   }
 
   // Now we know that we don't have a locked image, and we seem to be the first
   // thread encountering this image (that might not be true, since other threads
   // might be decoding it already). This means that we need to decode the image
   // assuming we can't lock the one we found in the cache.
   bool check_at_raster_cache = false;
   if (!decoded_image || !decoded_image->Lock()) {
     // Note that we have to release the lock, since this lock is also accessed
     // on the compositor thread. This means holding on to the lock might stall
     // the compositor thread for the duration of the decode!
     base::AutoUnlock unlock(lock_);
-    decoded_image = DecodeImageInternal(key, draw_image.image());
+    decoded_image = DecodeImageInternal(key, draw_image);
 
     // Skip the image if we couldn't decode it.
     if (!decoded_image)
       return DecodedDrawImage(nullptr, kNone_SkFilterQuality);
     check_at_raster_cache = true;
   }
 
   // While we unlocked the lock, it could be the case that another thread
   // already decoded this already and put it in the at-raster cache. Look it up
   // first.
@@ skipping 106 matching lines @@
   // TODO(vmpstr): Handle GPU rasterization.
   if (is_using_gpu_rasterization_)
     return false;
   if (!CanHandleFilterQuality(key.filter_quality()))
     return false;
   return true;
 }
 
 bool ImageDecodeController::CanHandleFilterQuality(
     SkFilterQuality filter_quality) {
-  // We don't need to handle low quality filters.
-  if (filter_quality == kLow_SkFilterQuality ||
-      filter_quality == kNone_SkFilterQuality) {
-    return false;
-  }
-
   // TODO(vmpstr): We need to start caching mipmaps for medium quality and
   // caching the interpolated values from those. For now, we don't have this.
-  if (filter_quality == kMedium_SkFilterQuality)
-    return false;
-  DCHECK(filter_quality == kHigh_SkFilterQuality);
-  return true;
+  return filter_quality != kMedium_SkFilterQuality;
 }
 
 void ImageDecodeController::ReduceCacheUsage() {
   TRACE_EVENT0("cc", "ImageDecodeController::ReduceCacheUsage");
   base::AutoLock lock(lock_);
   size_t num_to_remove = (decoded_images_.size() > kMaxItemsInCache)
                              ? (decoded_images_.size() - kMaxItemsInCache)
                              : 0;
   for (auto it = decoded_images_.begin();
        num_to_remove != 0 && it != decoded_images_.end();) {
@@ skipping 38 matching lines @@
 void ImageDecodeController::SanityCheckState(int line, bool lock_acquired) {
 #if DCHECK_IS_ON()
   if (!lock_acquired) {
     base::AutoLock lock(lock_);
     SanityCheckState(line, true);
     return;
   }
 
   MemoryBudget budget(kLockedMemoryLimitBytes);
   for (const auto& annotated_image : decoded_images_) {
-    auto ref_it = decoded_images_ref_counts_.find(annotated_image.first);
+    DCHECK_EQ(1, std::count_if(
+                     decoded_images_.begin(), decoded_images_.end(),
+                     [&annotated_image](const AnnotatedDecodedImage& image) {
+                       return image.first == annotated_image.first;
+                     }))
+        << line;
+    auto key = annotated_image.first;
+    auto ref_it = decoded_images_ref_counts_.find(key);
     if (annotated_image.second->is_locked()) {
-      budget.AddUsage(annotated_image.first.target_bytes());
+      budget.AddUsage(annotated_image.first.locked_bytes());
       DCHECK(ref_it != decoded_images_ref_counts_.end()) << line;
     } else {
       DCHECK(ref_it == decoded_images_ref_counts_.end() ||
              pending_image_tasks_.find(annotated_image.first) !=
                  pending_image_tasks_.end())
           << line;
     }
   }
   DCHECK_GE(budget.AvailableMemoryBytes(),
             locked_images_budget_.AvailableMemoryBytes())
@@ skipping 38 matching lines @@
 
   // Drop from medium to low if the matrix we applied wasn't decomposable or if
   // we're enlarging the image in both dimensions.
   if (quality == kMedium_SkFilterQuality) {
     if (!image.matrix_is_decomposable() ||
         (scale.width() >= 1.f && scale.height() >= 1.f)) {
       quality = kLow_SkFilterQuality;
     }
   }
 
-  return ImageDecodeControllerKey(image.image()->uniqueID(),
-                                  gfx::SkIRectToRect(image.src_rect()),
-                                  target_size, quality);
+  gfx::Rect src_rect = gfx::SkIRectToRect(image.src_rect());
+  gfx::Size full_image_size(image.image()->width(), image.image()->height());
+  gfx::Rect full_image_rect(full_image_size);
+  bool scale_needs_caching =
+      quality != kLow_SkFilterQuality && quality != kNone_SkFilterQuality;
+  bool is_full_image_rect = full_image_rect == src_rect;
+  bool scale_is_required = src_rect.width() != target_size.width() ||
+                           src_rect.height() != target_size.height();
+  bool can_use_original_decode =

[ericrk, 2016/02/11 01:21:50]

nit: does it make more sense to call it "needs_caching" not
"scale_needs_caching" - it's weird that "scale_needs_caching" can be true when
scale_is_required is false...

[vmpstr, 2016/02/17 21:21:03]

Hmm well if scale is not required, then scale_needs_caching is false, because
the filter quality would be low. It's a bit weird for me to call it
needs_caching, because the low filter quality (ie the original decode) might
need caching, but not the scaled version... hence scale_needs_caching.. Wdyt?

[ericrk, 2016/02/19 23:22:31]

Wouldn't a high quality image without scaling set scale_needs_caching to true
and scale_is_required_to false? Might just be missing another factor here.

Not a big deal though :D

+      !scale_needs_caching && (is_full_image_rect || !scale_is_required);
+  // If we're going to use the original decode, then the target size should be
+  // the full image size, since that will allow for proper memory accounting.
+  if (can_use_original_decode)
+    target_size = full_image_size;
+
+  return ImageDecodeControllerKey(image.image()->uniqueID(), src_rect,
+                                  target_size, quality,
+                                  can_use_original_decode);
 }
 
 ImageDecodeControllerKey::ImageDecodeControllerKey(
     uint32_t image_id,
     const gfx::Rect& src_rect,
     const gfx::Size& target_size,
-    SkFilterQuality filter_quality)
+    SkFilterQuality filter_quality,
+    bool can_use_original_decode)
     : image_id_(image_id),
       src_rect_(src_rect),
       target_size_(target_size),
-      filter_quality_(filter_quality) {}
+      filter_quality_(filter_quality),
+      can_use_original_decode_(can_use_original_decode) {
+  if (can_use_original_decode_) {
+    hash_ = std::hash<uint32_t>()(image_id_);
+  } else {
+    // TODO(vmpstr): This is a mess. Maybe it's faster to just search the vector
+    // always (forwards or backwards to account for LRU).
+    uint64_t src_rect_hash = base::HashInts(
+        static_cast<uint64_t>(base::HashInts(src_rect_.x(), src_rect_.y())),
+        static_cast<uint64_t>(
+            base::HashInts(src_rect_.width(), src_rect_.height())));
+
+    uint64_t target_size_hash =
+        base::HashInts(target_size_.width(), target_size_.height());
+
+    hash_ = base::HashInts(base::HashInts(src_rect_hash, target_size_hash),
+                           base::HashInts(image_id_, filter_quality_));
+  }
+}
 
 std::string ImageDecodeControllerKey::ToString() const {
   std::ostringstream str;
   str << "id[" << image_id_ << "] src_rect[" << src_rect_.x() << ","
       << src_rect_.y() << " " << src_rect_.width() << "x" << src_rect_.height()
       << "] target_size[" << target_size_.width() << "x"
-      << target_size_.height() << "] filter_quality[" << filter_quality_ << "]";
+      << target_size_.height() << "] filter_quality[" << filter_quality_
+      << "] can_use_original_decode [" << can_use_original_decode_ << "] hash ["
+      << hash_ << "]";
   return str.str();
 }
 
 // DecodedImage
 ImageDecodeController::DecodedImage::DecodedImage(
     const SkImageInfo& info,
     scoped_ptr<base::DiscardableMemory> memory,
     const SkSize& src_rect_offset)
     : locked_(true),
       image_info_(info),
@@ skipping 43 matching lines @@
 
 void ImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t ImageDecodeController::MemoryBudget::GetCurrentUsageSafe() const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc