components/doodle/doodle_service.cc - codesearch/chromium/src - Git at Google

 // Copyright 2017 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/doodle/doodle_service.h"

 #include <utility>

 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/doodle/pref_names.h"
 #include "components/image_fetcher/core/image_fetcher.h"
 #include "components/image_fetcher/core/request_metadata.h"
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "ui/gfx/image/image.h"

 namespace doodle {

 namespace {

 // The maximum time-to-live we'll accept; any larger values will be clamped to
 // this one. This is a last resort in case the server sends bad data.
 const int64_t kMaxTimeToLiveSecs = 30 * 24 * 60 * 60;  // 30 days

 // The default value for DoodleService::min_refresh_interval_.
 const int64_t kDefaultMinRefreshIntervalSecs = 15 * 60;  // 15 minutes

 // The maximum number of bytes to allow in a doodle image. This limits the
 // downloaded data to an amount that real images are unlikely to exceed. It is a
 // safeguard against server-side errors.
 const int64_t kMaxImageDownloadBytes = 1024 * 1024;

 }  // namespace

 // static
 void DoodleService::RegisterProfilePrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterDictionaryPref(
       prefs::kCachedConfig, base::MakeUnique<base::DictionaryValue>(),
       PrefRegistry::LOSSY_PREF);
   pref_registry->RegisterInt64Pref(prefs::kCachedConfigExpiry, 0,
                                    PrefRegistry::LOSSY_PREF);
 }

 DoodleService::DoodleService(
     PrefService* pref_service,
     std::unique_ptr<DoodleFetcher> fetcher,
     std::unique_ptr<base::OneShotTimer> expiry_timer,
     std::unique_ptr<base::Clock> clock,
     std::unique_ptr<base::TickClock> tick_clock,
     base::Optional<base::TimeDelta> override_min_refresh_interval,
     std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher)
     : pref_service_(pref_service),
       fetcher_(std::move(fetcher)),
       expiry_timer_(std::move(expiry_timer)),
       clock_(std::move(clock)),
       tick_clock_(std::move(tick_clock)),
       min_refresh_interval_(
           override_min_refresh_interval.has_value()
               ? override_min_refresh_interval.value()
               : base::TimeDelta::FromSeconds(kDefaultMinRefreshIntervalSecs)),
       image_fetcher_(std::move(image_fetcher)) {
   DCHECK(pref_service_);
   DCHECK(fetcher_);
   DCHECK(expiry_timer_);
   DCHECK(clock_);
   DCHECK(tick_clock_);
   DCHECK(image_fetcher_);

   image_fetcher_->SetImageDownloadLimit(kMaxImageDownloadBytes);
   image_fetcher_->SetDataUseServiceName(
       data_use_measurement::DataUseUserData::DOODLE);

   base::Time expiry_date = base::Time::FromInternalValue(
       pref_service_->GetInt64(prefs::kCachedConfigExpiry));
   base::Optional<DoodleConfig> config = DoodleConfig::FromDictionary(
       *pref_service_->GetDictionary(prefs::kCachedConfig), base::nullopt);
   DoodleState state =
       config.has_value() ? DoodleState::AVAILABLE : DoodleState::NO_DOODLE;
   HandleNewConfig(state, expiry_date - clock_->Now(), config);

   // If we don't have a cached doodle, immediately start a fetch, so that the
   // first NTP will get it quicker.
   if (state == DoodleState::NO_DOODLE) {
     Refresh();
   }
 }

 DoodleService::~DoodleService() = default;

 void DoodleService::Shutdown() {}

 void DoodleService::GetImage(const ImageCallback& callback) {
   if (!cached_config_.has_value()) {
     callback.Run(gfx::Image());
     return;
   }

   // If there is a CTA image, that means the main image is animated. Show the
   // non-animated CTA image first, and load the animated one only when the
   // user requests it.
   bool has_cta = cached_config_->large_cta_image.has_value();
   const GURL& image_url = has_cta ? cached_config_->large_cta_image->url
                                   : cached_config_->large_image.url;
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("doodle_service", R"(
         semantics {
           sender: "Doodle Service"
           description:
             "Downloads the Doodle image if Google is the configured search "
             "provider."
           trigger: "Displaying the new tab page on Android."
           data: "None."
           destination: GOOGLE_OWNED_SERVICE
         }
         policy {
           cookies_allowed: false
           setting:
             "Choosing a non-Google search engine in Chromium settings under "
             "'Search Engine' disables this feature."
           chrome_policy {
             DefaultSearchProviderEnabled {
               policy_options {mode: MANDATORY}
               DefaultSearchProviderEnabled: false
             }
           }
         })");
   image_fetcher_->StartOrQueueNetworkRequest(
       image_url.spec(), image_url,
       base::Bind(&DoodleService::ImageFetched, base::Unretained(this),
                  callback),
       traffic_annotation);
 }

 void DoodleService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }

 void DoodleService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }

 void DoodleService::Refresh() {
   // If we're already waiting for a fetch, don't start another one. The
   // observers will get notified when the ongoing fetch returns.
   if (fetcher_->IsFetchInProgress()) {
     return;
   }

   base::TimeTicks now_ticks = tick_clock_->NowTicks();
   // Check if we have passed the minimum refresh interval.
   base::TimeDelta time_since_fetch = now_ticks - last_successful_fetch_;
   if (time_since_fetch < min_refresh_interval_) {
     RecordDownloadMetrics(OUTCOME_REFRESH_INTERVAL_NOT_PASSED,
                           base::TimeDelta());
     for (auto& observer : observers_) {
       observer.OnDoodleConfigRevalidated(/*from_cache=*/true);
     }
     return;
   }

   fetcher_->FetchDoodle(base::BindOnce(&DoodleService::DoodleFetched,
                                        base::Unretained(this), now_ticks));
 }

 // static
 bool DoodleService::DownloadOutcomeIsSuccess(DownloadOutcome outcome) {
   switch (outcome) {
     case OUTCOME_NEW_DOODLE:
     case OUTCOME_REVALIDATED_DOODLE:
     case OUTCOME_CHANGED_DOODLE:
     case OUTCOME_NO_DOODLE:
       return true;
     case OUTCOME_EXPIRED:
     case OUTCOME_DOWNLOAD_ERROR:
     case OUTCOME_PARSING_ERROR:
     case OUTCOME_REFRESH_INTERVAL_NOT_PASSED:
       return false;
     case OUTCOME_COUNT:
       NOTREACHED();
   }
   return false;
 }

 // static
 void DoodleService::RecordDownloadMetrics(DownloadOutcome outcome,
                                           base::TimeDelta download_time) {
   UMA_HISTOGRAM_ENUMERATION("Doodle.ConfigDownloadOutcome", outcome,
                             OUTCOME_COUNT);

   if (DownloadOutcomeIsSuccess(outcome)) {
     UMA_HISTOGRAM_MEDIUM_TIMES("Doodle.ConfigDownloadTime", download_time);
   }
 }

 // static
 DoodleService::DownloadOutcome DoodleService::DetermineDownloadOutcome(
     const base::Optional<DoodleConfig>& old_config,
     const base::Optional<DoodleConfig>& new_config,
     DoodleState state,
     bool expired) {
   // First, handle error cases: *_ERROR or EXPIRED override other outcomes.
   switch (state) {
     case DoodleState::AVAILABLE:
       if (expired) {
         return OUTCOME_EXPIRED;
       }
       break;

     case DoodleState::NO_DOODLE:
       break;

     case DoodleState::DOWNLOAD_ERROR:
       return OUTCOME_DOWNLOAD_ERROR;

     case DoodleState::PARSING_ERROR:
       return OUTCOME_PARSING_ERROR;
   }

   if (!new_config.has_value()) {
     return OUTCOME_NO_DOODLE;
   }
   if (!old_config.has_value()) {
     return OUTCOME_NEW_DOODLE;
   }
   if (old_config.value() != new_config.value()) {
     return OUTCOME_CHANGED_DOODLE;
   }
   return OUTCOME_REVALIDATED_DOODLE;
 }

 void DoodleService::DoodleFetched(
     base::TimeTicks start_time,
     DoodleState state,
     base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& doodle_config) {
   base::TimeTicks now_ticks = tick_clock_->NowTicks();
   DownloadOutcome outcome = HandleNewConfig(state, time_to_live, doodle_config);
   if (DownloadOutcomeIsSuccess(outcome)) {
     last_successful_fetch_ = now_ticks;
   }
   base::TimeDelta download_time = now_ticks - start_time;
   RecordDownloadMetrics(outcome, download_time);
 }

 DoodleService::DownloadOutcome DoodleService::HandleNewConfig(
     DoodleState state,
     base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& doodle_config) {
   // Clamp the time-to-live to some reasonable maximum.
   if (time_to_live.InSeconds() > kMaxTimeToLiveSecs) {
     time_to_live = base::TimeDelta::FromSeconds(kMaxTimeToLiveSecs);
     DLOG(WARNING) << "Clamping TTL to " << kMaxTimeToLiveSecs << " seconds!";
   }

   // Handle the case where the new config is already expired.
   bool expired = time_to_live <= base::TimeDelta();
   const base::Optional<DoodleConfig>& new_config =
       expired ? base::nullopt : doodle_config;

   // Determine the download outcome *before* updating the cached config.
   DownloadOutcome outcome =
       DetermineDownloadOutcome(cached_config_, new_config, state, expired);

   // Note that this checks both for existence changes as well as changes of the
   // configs themselves.
   if (cached_config_ != new_config) {
     UpdateCachedConfig(time_to_live, new_config);

     for (auto& observer : observers_) {
       observer.OnDoodleConfigUpdated(cached_config_);
     }
   } else {
     for (auto& observer : observers_) {
       observer.OnDoodleConfigRevalidated(/*from_cache=*/false);
     }
   }

   // Even if the configs are identical, the time-to-live might have changed.
   // (Re-)schedule the cache expiry.
   if (cached_config_.has_value()) {
     expiry_timer_->Start(
         FROM_HERE, time_to_live,
         base::Bind(&DoodleService::DoodleExpired, base::Unretained(this)));
   } else {
     expiry_timer_->Stop();
   }

   return outcome;
 }

 void DoodleService::UpdateCachedConfig(
     base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& new_config) {
   DCHECK(cached_config_ != new_config);

   cached_config_ = new_config;

   if (cached_config_.has_value()) {
     pref_service_->Set(prefs::kCachedConfig, *cached_config_->ToDictionary());
     base::Time expiry_date = clock_->Now() + time_to_live;
     pref_service_->SetInt64(prefs::kCachedConfigExpiry,
                             expiry_date.ToInternalValue());
   } else {
     pref_service_->ClearPref(prefs::kCachedConfig);
     pref_service_->ClearPref(prefs::kCachedConfigExpiry);
   }
 }

 void DoodleService::DoodleExpired() {
   DCHECK(cached_config_.has_value());
   HandleNewConfig(DoodleState::NO_DOODLE, base::TimeDelta(), base::nullopt);
 }

 void DoodleService::ImageFetched(
     const ImageCallback& callback,
     const std::string& id,
     const gfx::Image& image,
     const image_fetcher::RequestMetadata& metadata) {
   if (image.IsEmpty()) {
     DLOG(WARNING) << "Failed to download doodle image";
   } else {
     // TODO(treib): Rename this to "Doodle.*" after we've decided what to do
     // about crbug.com/719513.
     UMA_HISTOGRAM_BOOLEAN("NewTabPage.LogoImageDownloaded",
                           metadata.from_http_cache);
   }

   callback.Run(image);
 }

 }  // namespace doodle
	// Copyright 2017 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/doodle/doodle_service.h"

	#include <utility>

	#include "base/bind.h"
	#include "base/memory/ptr_util.h"
	#include "base/metrics/histogram_macros.h"
	#include "base/values.h"
	#include "components/data_use_measurement/core/data_use_user_data.h"
	#include "components/doodle/pref_names.h"
	#include "components/image_fetcher/core/image_fetcher.h"
	#include "components/image_fetcher/core/request_metadata.h"
	#include "components/prefs/pref_registry.h"
	#include "components/prefs/pref_registry_simple.h"
	#include "components/prefs/pref_service.h"
	#include "net/traffic_annotation/network_traffic_annotation.h"
	#include "ui/gfx/image/image.h"

	namespace doodle {

	namespace {

	// The maximum time-to-live we'll accept; any larger values will be clamped to
	// this one. This is a last resort in case the server sends bad data.
	const int64_t kMaxTimeToLiveSecs = 30 * 24 * 60 * 60; // 30 days

	// The default value for DoodleService::min_refresh_interval_.
	const int64_t kDefaultMinRefreshIntervalSecs = 15 * 60; // 15 minutes

	// The maximum number of bytes to allow in a doodle image. This limits the
	// downloaded data to an amount that real images are unlikely to exceed. It is a
	// safeguard against server-side errors.
	const int64_t kMaxImageDownloadBytes = 1024 * 1024;

	} // namespace

	// static
	void DoodleService::RegisterProfilePrefs(PrefRegistrySimple* pref_registry) {
	pref_registry->RegisterDictionaryPref(
	prefs::kCachedConfig, base::MakeUnique<base::DictionaryValue>(),
	PrefRegistry::LOSSY_PREF);
	pref_registry->RegisterInt64Pref(prefs::kCachedConfigExpiry, 0,
	PrefRegistry::LOSSY_PREF);
	}

	DoodleService::DoodleService(
	PrefService* pref_service,
	std::unique_ptr<DoodleFetcher> fetcher,
	std::unique_ptr<base::OneShotTimer> expiry_timer,
	std::unique_ptr<base::Clock> clock,
	std::unique_ptr<base::TickClock> tick_clock,
	base::Optional<base::TimeDelta> override_min_refresh_interval,
	std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher)
	: pref_service_(pref_service),
	fetcher_(std::move(fetcher)),
	expiry_timer_(std::move(expiry_timer)),
	clock_(std::move(clock)),
	tick_clock_(std::move(tick_clock)),
	min_refresh_interval_(
	override_min_refresh_interval.has_value()
	? override_min_refresh_interval.value()
	: base::TimeDelta::FromSeconds(kDefaultMinRefreshIntervalSecs)),
	image_fetcher_(std::move(image_fetcher)) {
	DCHECK(pref_service_);
	DCHECK(fetcher_);
	DCHECK(expiry_timer_);
	DCHECK(clock_);
	DCHECK(tick_clock_);
	DCHECK(image_fetcher_);

	image_fetcher_->SetImageDownloadLimit(kMaxImageDownloadBytes);
	image_fetcher_->SetDataUseServiceName(
	data_use_measurement::DataUseUserData::DOODLE);

	base::Time expiry_date = base::Time::FromInternalValue(
	pref_service_->GetInt64(prefs::kCachedConfigExpiry));
	base::Optional<DoodleConfig> config = DoodleConfig::FromDictionary(
	*pref_service_->GetDictionary(prefs::kCachedConfig), base::nullopt);
	DoodleState state =
	config.has_value() ? DoodleState::AVAILABLE : DoodleState::NO_DOODLE;
	HandleNewConfig(state, expiry_date - clock_->Now(), config);

	// If we don't have a cached doodle, immediately start a fetch, so that the
	// first NTP will get it quicker.
	if (state == DoodleState::NO_DOODLE) {
	Refresh();
	}
	}

	DoodleService::~DoodleService() = default;

	void DoodleService::Shutdown() {}

	void DoodleService::GetImage(const ImageCallback& callback) {
	if (!cached_config_.has_value()) {
	callback.Run(gfx::Image());
	return;
	}

	// If there is a CTA image, that means the main image is animated. Show the
	// non-animated CTA image first, and load the animated one only when the
	// user requests it.
	bool has_cta = cached_config_->large_cta_image.has_value();
	const GURL& image_url = has_cta ? cached_config_->large_cta_image->url
	: cached_config_->large_image.url;
	net::NetworkTrafficAnnotationTag traffic_annotation =
	net::DefineNetworkTrafficAnnotation("doodle_service", R"(
	semantics {
	sender: "Doodle Service"
	description:
	"Downloads the Doodle image if Google is the configured search "
	"provider."
	trigger: "Displaying the new tab page on Android."
	data: "None."
	destination: GOOGLE_OWNED_SERVICE
	}
	policy {
	cookies_allowed: false
	setting:
	"Choosing a non-Google search engine in Chromium settings under "
	"'Search Engine' disables this feature."
	chrome_policy {
	DefaultSearchProviderEnabled {
	policy_options {mode: MANDATORY}
	DefaultSearchProviderEnabled: false
	}
	}
	})");
	image_fetcher_->StartOrQueueNetworkRequest(
	image_url.spec(), image_url,
	base::Bind(&DoodleService::ImageFetched, base::Unretained(this),
	callback),
	traffic_annotation);
	}

	void DoodleService::AddObserver(Observer* observer) {
	observers_.AddObserver(observer);
	}

	void DoodleService::RemoveObserver(Observer* observer) {
	observers_.RemoveObserver(observer);
	}

	void DoodleService::Refresh() {
	// If we're already waiting for a fetch, don't start another one. The
	// observers will get notified when the ongoing fetch returns.
	if (fetcher_->IsFetchInProgress()) {
	return;
	}

	base::TimeTicks now_ticks = tick_clock_->NowTicks();
	// Check if we have passed the minimum refresh interval.
	base::TimeDelta time_since_fetch = now_ticks - last_successful_fetch_;
	if (time_since_fetch < min_refresh_interval_) {
	RecordDownloadMetrics(OUTCOME_REFRESH_INTERVAL_NOT_PASSED,
	base::TimeDelta());
	for (auto& observer : observers_) {
	observer.OnDoodleConfigRevalidated(/from_cache=/true);
	}
	return;
	}

	fetcher_->FetchDoodle(base::BindOnce(&DoodleService::DoodleFetched,
	base::Unretained(this), now_ticks));
	}

	// static
	bool DoodleService::DownloadOutcomeIsSuccess(DownloadOutcome outcome) {
	switch (outcome) {
	case OUTCOME_NEW_DOODLE:
	case OUTCOME_REVALIDATED_DOODLE:
	case OUTCOME_CHANGED_DOODLE:
	case OUTCOME_NO_DOODLE:
	return true;
	case OUTCOME_EXPIRED:
	case OUTCOME_DOWNLOAD_ERROR:
	case OUTCOME_PARSING_ERROR:
	case OUTCOME_REFRESH_INTERVAL_NOT_PASSED:
	return false;
	case OUTCOME_COUNT:
	NOTREACHED();
	}
	return false;
	}

	// static
	void DoodleService::RecordDownloadMetrics(DownloadOutcome outcome,
	base::TimeDelta download_time) {
	UMA_HISTOGRAM_ENUMERATION("Doodle.ConfigDownloadOutcome", outcome,
	OUTCOME_COUNT);

	if (DownloadOutcomeIsSuccess(outcome)) {
	UMA_HISTOGRAM_MEDIUM_TIMES("Doodle.ConfigDownloadTime", download_time);
	}
	}

	// static
	DoodleService::DownloadOutcome DoodleService::DetermineDownloadOutcome(
	const base::Optional<DoodleConfig>& old_config,
	const base::Optional<DoodleConfig>& new_config,
	DoodleState state,
	bool expired) {
	// First, handle error cases: *_ERROR or EXPIRED override other outcomes.
	switch (state) {
	case DoodleState::AVAILABLE:
	if (expired) {
	return OUTCOME_EXPIRED;
	}
	break;

	case DoodleState::NO_DOODLE:
	break;

	case DoodleState::DOWNLOAD_ERROR:
	return OUTCOME_DOWNLOAD_ERROR;

	case DoodleState::PARSING_ERROR:
	return OUTCOME_PARSING_ERROR;
	}

	if (!new_config.has_value()) {
	return OUTCOME_NO_DOODLE;
	}
	if (!old_config.has_value()) {
	return OUTCOME_NEW_DOODLE;
	}
	if (old_config.value() != new_config.value()) {
	return OUTCOME_CHANGED_DOODLE;
	}
	return OUTCOME_REVALIDATED_DOODLE;
	}

	void DoodleService::DoodleFetched(
	base::TimeTicks start_time,
	DoodleState state,
	base::TimeDelta time_to_live,
	const base::Optional<DoodleConfig>& doodle_config) {
	base::TimeTicks now_ticks = tick_clock_->NowTicks();
	DownloadOutcome outcome = HandleNewConfig(state, time_to_live, doodle_config);
	if (DownloadOutcomeIsSuccess(outcome)) {
	last_successful_fetch_ = now_ticks;
	}
	base::TimeDelta download_time = now_ticks - start_time;
	RecordDownloadMetrics(outcome, download_time);
	}

	DoodleService::DownloadOutcome DoodleService::HandleNewConfig(
	DoodleState state,
	base::TimeDelta time_to_live,
	const base::Optional<DoodleConfig>& doodle_config) {
	// Clamp the time-to-live to some reasonable maximum.
	if (time_to_live.InSeconds() > kMaxTimeToLiveSecs) {
	time_to_live = base::TimeDelta::FromSeconds(kMaxTimeToLiveSecs);
	DLOG(WARNING) << "Clamping TTL to " << kMaxTimeToLiveSecs << " seconds!";
	}

	// Handle the case where the new config is already expired.
	bool expired = time_to_live <= base::TimeDelta();
	const base::Optional<DoodleConfig>& new_config =
	expired ? base::nullopt : doodle_config;

	// Determine the download outcome before updating the cached config.
	DownloadOutcome outcome =
	DetermineDownloadOutcome(cached_config_, new_config, state, expired);

	// Note that this checks both for existence changes as well as changes of the
	// configs themselves.
	if (cached_config_ != new_config) {
	UpdateCachedConfig(time_to_live, new_config);

	for (auto& observer : observers_) {
	observer.OnDoodleConfigUpdated(cached_config_);
	}
	} else {
	for (auto& observer : observers_) {
	observer.OnDoodleConfigRevalidated(/from_cache=/false);
	}
	}

	// Even if the configs are identical, the time-to-live might have changed.
	// (Re-)schedule the cache expiry.
	if (cached_config_.has_value()) {
	expiry_timer_->Start(
	FROM_HERE, time_to_live,
	base::Bind(&DoodleService::DoodleExpired, base::Unretained(this)));
	} else {
	expiry_timer_->Stop();
	}

	return outcome;
	}

	void DoodleService::UpdateCachedConfig(
	base::TimeDelta time_to_live,
	const base::Optional<DoodleConfig>& new_config) {
	DCHECK(cached_config_ != new_config);

	cached_config_ = new_config;

	if (cached_config_.has_value()) {
	pref_service_->Set(prefs::kCachedConfig, *cached_config_->ToDictionary());
	base::Time expiry_date = clock_->Now() + time_to_live;
	pref_service_->SetInt64(prefs::kCachedConfigExpiry,
	expiry_date.ToInternalValue());
	} else {
	pref_service_->ClearPref(prefs::kCachedConfig);
	pref_service_->ClearPref(prefs::kCachedConfigExpiry);
	}
	}

	void DoodleService::DoodleExpired() {
	DCHECK(cached_config_.has_value());
	HandleNewConfig(DoodleState::NO_DOODLE, base::TimeDelta(), base::nullopt);
	}

	void DoodleService::ImageFetched(
	const ImageCallback& callback,
	const std::string& id,
	const gfx::Image& image,
	const image_fetcher::RequestMetadata& metadata) {
	if (image.IsEmpty()) {
	DLOG(WARNING) << "Failed to download doodle image";
	} else {
	// TODO(treib): Rename this to "Doodle.*" after we've decided what to do
	// about crbug.com/719513.
	UMA_HISTOGRAM_BOOLEAN("NewTabPage.LogoImageDownloaded",
	metadata.from_http_cache);
	}

	callback.Run(image);
	}

	} // namespace doodle