[Doodle] Move image fetching from LogoBridge to DoodleService

components/doodle/doodle_service.cc

 // 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 "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)
+    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)) {
+              : 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;
+  image_fetcher_->StartOrQueueNetworkRequest(
+      image_url.spec(), image_url,
+      base::Bind(&DoodleService::ImageFetched, base::Unretained(this),
+                 callback));
+}
+
 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
@@ skipping 160 matching lines @@
     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