Reduce jank from favicon downscaling.

components/favicon_base/favicon_util.cc

 // Copyright 2014 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 "components/favicon_base/favicon_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 
+#include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/favicon_base/favicon_types.h"
 #include "components/favicon_base/select_favicon_frames.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_png_rep.h"
 #include "ui/gfx/image/image_skia.h"
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include "base/mac/mac_util.h"
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
 namespace favicon_base {
 namespace {
 
 // Creates image reps of DIP size |favicon_size| for the subset of
 // |favicon_scales| for which the image reps can be created without resizing
 // or decoding the bitmap data.
 std::vector<gfx::ImagePNGRep> SelectFaviconFramesFromPNGsWithoutResizing(
     const std::vector<favicon_base::FaviconRawBitmapResult>& png_data,
     const std::vector<float>& favicon_scales,
     int favicon_size) {
+  TRACE_EVENT0("browser",
+               "FaviconUtil::SelectFaviconFramesFromPNGsWithoutResizing");
   std::vector<gfx::ImagePNGRep> png_reps;
   if (png_data.empty())
     return png_reps;
 
   // A |favicon_size| of 0 indicates that the largest frame is desired.
   if (favicon_size == 0) {
     int maximum_area = 0;
     scoped_refptr<base::RefCountedMemory> best_candidate;
     for (size_t i = 0; i < png_data.size(); ++i) {
       int area = png_data[i].pixel_size.GetArea();
@@ skipping 110 matching lines @@
 void SetFaviconColorSpace(gfx::Image* image) {
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   image->SetSourceColorSpace(base::mac::GetSystemColorSpace());
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 }
 
 gfx::Image SelectFaviconFramesFromPNGs(
     const std::vector<favicon_base::FaviconRawBitmapResult>& png_data,
     const std::vector<float>& favicon_scales,
     int favicon_size) {
+  TRACE_EVENT0("browser", "FaviconUtil::SelectFaviconFramesFromPNGs");
+
   // Create image reps for as many scales as possible without resizing
   // the bitmap data or decoding it. FaviconHandler stores already resized
   // favicons into history so no additional resizing should be needed in the
   // common case.
   // Creating the gfx::Image from |png_data| without resizing or decoding if
   // possible is important because:
   // - Sync does a byte-to-byte comparison of gfx::Image::As1xPNGBytes() to
   //   the data it put into the database in order to determine whether any
   //   updates should be pushed to sync.
   // - The decoding occurs on the UI thread and the decoding can be a
@@ skipping 59 matching lines @@
             false,
             &png_bytes->data())) {
       png_reps.push_back(
           gfx::ImagePNGRep(png_bytes, resized_image_skia_reps[i].scale()));
     }
   }
 
   return gfx::Image(png_reps);
 }
 
+favicon_base::FaviconRawBitmapResult ResizeFaviconBitmapResult(
+    const std::vector<favicon_base::FaviconRawBitmapResult>&
+        favicon_bitmap_results,
+    int desired_size_in_pixel) {
+  TRACE_EVENT0("browser", "FaviconUtil::ResizeFaviconBitmapResult");
+
+  if (favicon_bitmap_results.empty() || !favicon_bitmap_results[0].is_valid())
+    return favicon_base::FaviconRawBitmapResult();
+
+  favicon_base::FaviconRawBitmapResult bitmap_result =
+      favicon_bitmap_results[0];
+
+  // If the desired size is 0, SelectFaviconFrames() will return the largest
+  // bitmap without doing any resizing. As |favicon_bitmap_results| has bitmap
+  // data for a single bitmap, return it and avoid an unnecessary decode.
+  if (desired_size_in_pixel == 0)
+    return bitmap_result;
+
+  // If history bitmap is already desired pixel size, return early.
+  if (bitmap_result.pixel_size.width() == desired_size_in_pixel &&
+      bitmap_result.pixel_size.height() == desired_size_in_pixel)
+    return bitmap_result;
+
+  // Convert raw bytes to SkBitmap, resize via SelectFaviconFrames(), then
+  // convert back.
+  std::vector<float> desired_favicon_scales;
+  desired_favicon_scales.push_back(1.0f);
+
+  gfx::Image resized_image = favicon_base::SelectFaviconFramesFromPNGs(
+      favicon_bitmap_results, desired_favicon_scales, desired_size_in_pixel);
+
+  std::vector<unsigned char> resized_bitmap_data;
+  if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_image.AsBitmap(), false,
+                                         &resized_bitmap_data)) {
+    return favicon_base::FaviconRawBitmapResult();
+  }
+
+  bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector(
+      &resized_bitmap_data);
+  bitmap_result.pixel_size =
+      gfx::Size(desired_size_in_pixel, desired_size_in_pixel);
+
+  return bitmap_result;
+}
+
 }  // namespace favicon_base