Set desired_image_size when decoding images for NTP Tile icons.

components/image_fetcher/image_fetcher_impl.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/image_fetcher/image_fetcher_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "net/base/load_flags.h"
@@ skipping 21 matching lines @@
 void ImageFetcherImpl::SetImageFetcherDelegate(ImageFetcherDelegate* delegate) {
   DCHECK(delegate);
   delegate_ = delegate;
 }
 
 void ImageFetcherImpl::SetDataUseServiceName(
     DataUseServiceName data_use_service_name) {
   image_data_fetcher_->SetDataUseServiceName(data_use_service_name);
 }
 
+void ImageFetcherImpl::SetDesiredImageFrameSize(const gfx::Size& size) {
+  desired_image_frame_size_ = size;
+}
+
 void ImageFetcherImpl::StartOrQueueNetworkRequest(
     const std::string& id,
     const GURL& image_url,
     base::Callback<void(const std::string&, const gfx::Image&)> callback) {
   // Before starting to fetch the image. Look for a request in progress for
   // |image_url|, and queue if appropriate.
   ImageRequestMap::iterator it = pending_net_requests_.find(image_url);
   if (it == pending_net_requests_.end()) {
     ImageRequest request;
     request.id = id;
@@ skipping 13 matching lines @@
 void ImageFetcherImpl::OnImageURLFetched(const GURL& image_url,
                                          const std::string& image_data,
                                          const RequestMetadata& metadata) {
   // Inform the ImageFetcherDelegate.
   if (delegate_) {
     auto it = pending_net_requests_.find(image_url);
     DCHECK(it != pending_net_requests_.end());
     delegate_->OnImageDataFetched(it->second.id, image_data);
   }
 
-  image_decoder_->DecodeImage(
-      image_data,
-      base::Bind(&ImageFetcherImpl::OnImageDecoded,
-                 base::Unretained(this), image_url));
+  image_decoder_->DecodeImage(image_data, desired_image_frame_size_,
+                              base::Bind(&ImageFetcherImpl::OnImageDecoded,
+                                         base::Unretained(this), image_url));
 }
 
 void ImageFetcherImpl::OnImageDecoded(const GURL& image_url,
                                       const gfx::Image& image) {
   // Get request for the given image_url from the request queue.
   ImageRequestMap::iterator image_iter = pending_net_requests_.find(image_url);
   DCHECK(image_iter != pending_net_requests_.end());
   ImageRequest* request = &image_iter->second;
 
   // Run all callbacks
   for (const auto& callback : request->callbacks) {
     callback.Run(request->id, image);
   }
 
   // Inform the ImageFetcherDelegate.
   if (delegate_) {
     delegate_->OnImageFetched(request->id, image);
   }
 
   // Erase the completed ImageRequest.
   pending_net_requests_.erase(image_iter);
 }
 
 }  // namespace image_fetcher