Reduce jank from favicon downscaling.

components/favicon/core/favicon_service.cc

 // Copyright (c) 2012 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/core/favicon_service.h"
 
 #include <stddef.h>
 #include <cmath>
 #include <utility>
 
 #include "base/hash.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/trace_event/trace_event.h"
 #include "components/favicon/core/favicon_client.h"
 #include "components/favicon_base/favicon_util.h"
 #include "components/favicon_base/select_favicon_frames.h"
 #include "components/history/core/browser/history_service.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image_skia.h"
 #include "url/gurl.h"
 
@@ skipping 38 matching lines @@
 void FaviconService::FaviconResultsCallbackRunner(
     const favicon_base::FaviconResultsCallback& callback,
     const std::vector<favicon_base::FaviconRawBitmapResult>* results) {
   callback.Run(*results);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImage(
     const GURL& icon_url,
     const favicon_base::FaviconImageCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetFaviconImage");
   favicon_base::FaviconResultsCallback callback_runner =
       base::Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults,
                  base::Unretained(this), callback, gfx::kFaviconSize);
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     return history_service_->GetFavicons(
         icon_urls,
         favicon_base::FAVICON,
         GetPixelSizesForFaviconScales(gfx::kFaviconSize),
         callback_runner,
         tracker);
   }
   return RunWithEmptyResultAsync(callback_runner, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetRawFavicon(
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     int desired_size_in_pixel,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetRawFavicon");
   favicon_base::FaviconResultsCallback callback_runner =
       base::Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
                  base::Unretained(this), callback, desired_size_in_pixel);
 
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     std::vector<int> desired_sizes_in_pixel;
     desired_sizes_in_pixel.push_back(desired_size_in_pixel);
 
     return history_service_->GetFavicons(
         icon_urls, icon_type, desired_sizes_in_pixel, callback_runner, tracker);
   }
   return RunWithEmptyResultAsync(callback_runner, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFavicon(
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     int desired_size_in_dip,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetFavicon");
   if (history_service_) {
     std::vector<GURL> icon_urls;
     icon_urls.push_back(icon_url);
     return history_service_->GetFavicons(
         icon_urls,
         icon_type,
         GetPixelSizesForFaviconScales(desired_size_in_dip),
         callback,
         tracker);
   }
   return RunWithEmptyResultAsync(callback, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconImageForPageURL(
     const GURL& page_url,
     const favicon_base::FaviconImageCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetFaviconImageForPageURL");
   return GetFaviconForPageURLImpl(
       page_url, favicon_base::FAVICON,
       GetPixelSizesForFaviconScales(gfx::kFaviconSize),
       base::Bind(&FaviconService::RunFaviconImageCallbackWithBitmapResults,
                  base::Unretained(this), callback, gfx::kFaviconSize),
       tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetRawFaviconForPageURL(
     const GURL& page_url,
     int icon_types,
     int desired_size_in_pixel,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetRawFaviconForPageURL");
   std::vector<int> desired_sizes_in_pixel;
   desired_sizes_in_pixel.push_back(desired_size_in_pixel);
   return GetFaviconForPageURLImpl(
       page_url, icon_types, desired_sizes_in_pixel,
       base::Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
                  base::Unretained(this), callback, desired_size_in_pixel),
       tracker);
 }
 
 base::CancelableTaskTracker::TaskId
 FaviconService::GetLargestRawFaviconForPageURL(
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetLargestRawFaviconForPageURL");
   favicon_base::FaviconResultsCallback favicon_results_callback =
       base::Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
                  base::Unretained(this), callback, 0);
   if (favicon_client_ && favicon_client_->IsNativeApplicationURL(page_url)) {
     std::vector<int> desired_sizes_in_pixel;
     desired_sizes_in_pixel.push_back(0);
     return favicon_client_->GetFaviconForNativeApplicationURL(
         page_url, desired_sizes_in_pixel, favicon_results_callback, tracker);
   }
   if (history_service_) {
     return history_service_->GetLargestFaviconForURL(page_url, icon_types,
         minimum_size_in_pixels, callback, tracker);
   }
   return RunWithEmptyResultAsync(favicon_results_callback, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetFaviconForPageURL(
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     const favicon_base::FaviconResultsCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetFaviconForPageURL");
   return GetFaviconForPageURLImpl(
       page_url,
       icon_types,
       GetPixelSizesForFaviconScales(desired_size_in_dip),
       callback,
       tracker);
 }
 
 base::CancelableTaskTracker::TaskId
 FaviconService::UpdateFaviconMappingsAndFetch(
@@ skipping 12 matching lines @@
         callback,
         tracker);
   }
   return RunWithEmptyResultAsync(callback, tracker);
 }
 
 base::CancelableTaskTracker::TaskId FaviconService::GetLargestRawFaviconForID(
     favicon_base::FaviconID favicon_id,
     const favicon_base::FaviconRawBitmapCallback& callback,
     base::CancelableTaskTracker* tracker) {
+  TRACE_EVENT0("browser", "FaviconService::GetLargestRawFaviconForID");
   // Use 0 as |desired_size| to get the largest bitmap for |favicon_id| without
   // any resizing.
   int desired_size = 0;
   favicon_base::FaviconResultsCallback callback_runner =
       base::Bind(&FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults,
                  base::Unretained(this), callback, desired_size);
 
   if (history_service_) {
     return history_service_->GetFaviconForID(
         favicon_id, desired_size, callback_runner, tracker);
@@ skipping 80 matching lines @@
                                                tracker);
   }
   return RunWithEmptyResultAsync(callback, tracker);
 }
 
 void FaviconService::RunFaviconImageCallbackWithBitmapResults(
     const favicon_base::FaviconImageCallback& callback,
     int desired_size_in_dip,
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
+  TRACE_EVENT0("browser",
+               "FaviconService::RunFaviconImageCallbackWithBitmapResults");
   favicon_base::FaviconImageResult image_result;
   image_result.image = favicon_base::SelectFaviconFramesFromPNGs(
       favicon_bitmap_results,
       favicon_base::GetFaviconScales(),
       desired_size_in_dip);
   favicon_base::SetFaviconColorSpace(&image_result.image);
 
   image_result.icon_url = image_result.image.IsEmpty() ?
       GURL() : favicon_bitmap_results[0].icon_url;
   callback.Run(image_result);
 }
 
 void FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults(
     const favicon_base::FaviconRawBitmapCallback& callback,
     int desired_size_in_pixel,
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
-  if (favicon_bitmap_results.empty() || !favicon_bitmap_results[0].is_valid()) {
-    callback.Run(favicon_base::FaviconRawBitmapResult());
-    return;
-  }
-
-  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) {
-    callback.Run(bitmap_result);
-    return;
-  }
-
-  // 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) {
-    callback.Run(bitmap_result);
-    return;
-  }
-
-  // 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)) {
-    callback.Run(favicon_base::FaviconRawBitmapResult());
-    return;
-  }
-
-  bitmap_result.bitmap_data = base::RefCountedBytes::TakeVector(
-      &resized_bitmap_data);
-  callback.Run(bitmap_result);
+  TRACE_EVENT0("browser",
+               "FaviconService::RunFaviconRawBitmapCallbackWithBitmapResults");
+  callback.Run(
+      ResizeFaviconBitmapResult(favicon_bitmap_results, desired_size_in_pixel));

[sky, 2016/09/07 23:28:22]

Why do we need this in both HistoryBackend and here? Won't HistoryBackend cover
this?

[aelias_OOO_until_Jul13, 2016/09/08 01:33:08]

The sticking point is that favicon_client_->GetFaviconForNativeApplicationURL(),
not HistoryBackend, wind up producing the input for this callback on Chrome for
iOS.  And in general, HistoryBackend seems to have the contract of providing
best-effort reasonable results rather than a strong guarantee of a size.  So I'm
thinking of this like I'm improving quality of the output of HistoryBackend, but
this method is the hard backstop guaranteeing output of a particular size for
correctness.

 }
 
 }  // namespace favicon