No longer calling DeferredTextureImageUsageParams' default ctor.

cc/tiles/gpu_image_decode_controller.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 "cc/tiles/gpu_image_decode_controller.h"
 
 #include <inttypes.h>
 
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
@@ skipping 38 matching lines @@
   return false;
 }
 
 // Returns the filter quality to use for scaling the image to upload scale. For
 // GPU raster, medium and high filter quality are identical for downscales.
 // Upload scaling is always a downscale, so cap our filter quality to medium.
 SkFilterQuality CalculateUploadScaleFilterQuality(const DrawImage& draw_image) {
   return std::min(kMedium_SkFilterQuality, draw_image.filter_quality());
 }
 
-SkImage::DeferredTextureImageUsageParams ParamsFromDrawImage(
-    const DrawImage& draw_image,
-    int upload_scale_mip_level) {
-  SkImage::DeferredTextureImageUsageParams params;
-  params.fMatrix = draw_image.matrix();
-  params.fQuality = draw_image.filter_quality();
-  params.fPreScaleMipLevel = upload_scale_mip_level;
-
-  return params;
-}
-
 // Calculate the mip level to upload-scale the image to before uploading. We use
 // mip levels rather than exact scales to increase re-use of scaled images.
 int CalculateUploadScaleMipLevel(const DrawImage& draw_image) {
   // Images which are being clipped will have color-bleeding if scaled.
   // TODO(ericrk): Investigate uploading clipped images to handle this case and
   // provide further optimization. crbug.com/620899
   if (draw_image.src_rect() != draw_image.image()->bounds())
     return 0;
 
   gfx::Size base_size(draw_image.image()->width(),
@@ skipping 856 matching lines @@
                 image_pixmap, CalculateUploadScaleFilterQuality(draw_image),
                 SkImage::kDisallow_CachingHint)) {
           backing_memory.reset();
         }
         break;
       }
       case DecodedDataMode::GPU: {
         backing_memory =
             base::DiscardableMemoryAllocator::GetInstance()
                 ->AllocateLockedDiscardableMemory(image_data->size);
-        auto params =
-            ParamsFromDrawImage(draw_image, image_data->upload_scale_mip_level);
+        auto params = SkImage::DeferredTextureImageUsageParams(
+            draw_image.matrix(), draw_image.filter_quality(),
+            image_data->upload_scale_mip_level);
         if (!draw_image.image()->getDeferredTextureImageData(
                 *context_threadsafe_proxy_.get(), &params, 1,
                 backing_memory->data())) {
           backing_memory.reset();
         }
         break;
       }
     }
   }
 
@@ skipping 66 matching lines @@
   if (!image_data->upload.image())
     image_data->upload.SetImage(std::move(uploaded_image));
 }
 
 scoped_refptr<GpuImageDecodeController::ImageData>
 GpuImageDecodeController::CreateImageData(const DrawImage& draw_image) {
   lock_.AssertAcquired();
 
   DecodedDataMode mode;
   int upload_scale_mip_level = CalculateUploadScaleMipLevel(draw_image);
-  SkImage::DeferredTextureImageUsageParams params =
-      ParamsFromDrawImage(draw_image, upload_scale_mip_level);
+  auto params = SkImage::DeferredTextureImageUsageParams(
+      draw_image.matrix(), draw_image.filter_quality(), upload_scale_mip_level);
   size_t data_size = draw_image.image()->getDeferredTextureImageData(
       *context_threadsafe_proxy_.get(), &params, 1, nullptr);
 
   if (data_size == 0) {
     // Can't upload image, too large or other failure. Try to use SW fallback.
     SkImageInfo image_info =
         CreateImageInfoForDrawImage(draw_image, upload_scale_mip_level);
     data_size = image_info.getSafeSize(image_info.minRowBytes());
     mode = DecodedDataMode::CPU;
   } else {
@@ skipping 83 matching lines @@
 bool GpuImageDecodeController::DiscardableIsLockedForTesting(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   auto found = persistent_cache_.Peek(image.image()->uniqueID());
   DCHECK(found != persistent_cache_.end());
   ImageData* image_data = found->second.get();
   return image_data->decode.is_locked();
 }
 
 }  // namespace cc