[Content suggestions] Implement fetching publishers' favicons

components/ntp_snippets/content_suggestions_service.cc

 // 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.
 
 #include "components/ntp_snippets/content_suggestions_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
+#include "components/favicon/core/large_icon_service.h"
+#include "components/favicon_base/fallback_icon_style.h"
+#include "components/favicon_base/favicon_types.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "ui/gfx/image/image.h"
 
 namespace ntp_snippets {
 
 ContentSuggestionsService::ContentSuggestionsService(
     State state,
     SigninManagerBase* signin_manager,
     history::HistoryService* history_service,
+    favicon::LargeIconService* large_icon_service,
     PrefService* pref_service,
     std::unique_ptr<CategoryRanker> category_ranker,
     std::unique_ptr<UserClassifier> user_classifier,
     std::unique_ptr<RemoteSuggestionsScheduler> remote_suggestions_scheduler)
     : state_(state),
       signin_observer_(this),
       history_service_observer_(this),
       remote_suggestions_provider_(nullptr),
+      large_icon_service_(large_icon_service),
       pref_service_(pref_service),
       remote_suggestions_scheduler_(std::move(remote_suggestions_scheduler)),
       user_classifier_(std::move(user_classifier)),
       category_ranker_(std::move(category_ranker)) {
   // Can be null in tests.
   if (signin_manager) {
     signin_observer_.Add(signin_manager);
   }
 
   if (history_service) {
@@ skipping 77 matching lines @@
   }
   providers_by_category_[suggestion_id.category()]->FetchSuggestionImage(
       suggestion_id, callback);
 }
 
 void ContentSuggestionsService::FetchSuggestionFavicon(
     const ContentSuggestion::ID& suggestion_id,
     int minimum_size_in_pixel,
     int desired_size_in_pixel,
     const ImageFetchedCallback& callback) {
-  // TODO(jkrcal): Implement.
+  // TODO(jkrcal): Allow the provider to provide (or possibly override) the URL
+  // for looking up the favicon.
+  std::vector<ContentSuggestion>* suggestions =
+      &suggestions_by_category_[suggestion_id.category()];
+  auto position =
+      std::find_if(suggestions->begin(), suggestions->end(),
+                   [&suggestion_id](const ContentSuggestion& suggestion) {
+                     return suggestion_id == suggestion.id();
+                   });
+  if (position == suggestions->end() || !large_icon_service_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, gfx::Image()));
+    return;
+  }
+
+  const GURL& publisher_url = position->url().GetWithEmptyPath();
+
+  // TODO(jkrcal): Create a general wrapper function in LargeIconService that
+  // does handle the get-from-cache-and-fallback-to-google-server functionality
+  // in one shot (for all clients that do not need to react in between).
+  large_icon_service_->GetLargeIconImageOrFallbackStyle(
+      publisher_url, minimum_size_in_pixel, desired_size_in_pixel,
+      base::Bind(&ContentSuggestionsService::OnGetFaviconFromCacheFinished,
+                 base::Unretained(this), publisher_url, minimum_size_in_pixel,
+                 desired_size_in_pixel, callback,
+                 /*continue_to_google_server=*/true),
+      &favicons_task_tracker_);
+}
+
+void ContentSuggestionsService::OnGetFaviconFromCacheFinished(
+    const GURL& publisher_url,
+    int minimum_size_in_pixel,
+    int desired_size_in_pixel,
+    const ImageFetchedCallback& callback,
+    bool continue_to_google_server,
+    const favicon_base::LargeIconImageResult& result) {
+  if (!result.image.IsEmpty()) {
+    callback.Run(result.image);
+    return;
+  }
+
+  if (!continue_to_google_server ||
+      (result.fallback_icon_style &&
+       !result.fallback_icon_style->is_default_background_color)) {
+    // We cannot download from the server if there is some small icon in the
+    // cache (resulting in non-default bakground color) or if we already did so.
+    callback.Run(gfx::Image());
+    return;
+  }
+
+  // Try to fetch the favicon from a Google favicon server.
+  large_icon_service_
+      ->GetLargeIconOrFallbackStyleFromGoogleServerSkippingLocalCache(
+          publisher_url, minimum_size_in_pixel,
+          base::Bind(
+              &ContentSuggestionsService::OnGetFaviconFromGoogleServerFinished,
+              base::Unretained(this), publisher_url, minimum_size_in_pixel,
+              desired_size_in_pixel, callback));
+}
+
+void ContentSuggestionsService::OnGetFaviconFromGoogleServerFinished(
+    const GURL& publisher_url,
+    int minimum_size_in_pixel,
+    int desired_size_in_pixel,
+    const ImageFetchedCallback& callback,
+    bool success) {
+  if (!success) {
+    callback.Run(gfx::Image());
+    return;
+  }
+
+  // Get the freshly downloaded icon from the cache.
+  large_icon_service_->GetLargeIconImageOrFallbackStyle(
+      publisher_url, minimum_size_in_pixel, desired_size_in_pixel,
+      base::Bind(&ContentSuggestionsService::OnGetFaviconFromCacheFinished,
+                 base::Unretained(this), publisher_url, minimum_size_in_pixel,
+                 desired_size_in_pixel, callback,
+                 /*continue_to_google_server=*/false),
+      &favicons_task_tracker_);
 }
 
 void ContentSuggestionsService::ClearHistory(
     base::Time begin,
     base::Time end,
     const base::Callback<bool(const GURL& url)>& filter) {
   for (const auto& provider : providers_) {
     provider->ClearHistory(begin, end, filter);
   }
   category_ranker_->ClearHistory(begin, end);
@@ skipping 392 matching lines @@
 void ContentSuggestionsService::StoreDismissedCategoriesToPrefs() {
   base::ListValue list;
   for (const auto& category_provider_pair : dismissed_providers_by_category_) {
     list.AppendInteger(category_provider_pair.first.id());
   }
 
   pref_service_->Set(prefs::kDismissedCategories, list);
 }
 
 }  // namespace ntp_snippets