SkPDF: bikeshed: use `auto` less

src/pdf/SkPDFShader.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPDFShader.h"
 
@@ skipping 635 matching lines @@
         SkPDFDocument* doc, SkScalar dpi, const SkPDFShader::State& state) {
     SkRect bbox;
     bbox.set(state.fBBox);
 
     sk_sp<SkPDFObject> luminosityShader(
             get_pdf_shader_by_state(doc, dpi, state.MakeAlphaToLuminosityState(),
                                     SkBitmap()));
 
     std::unique_ptr<SkStreamAsset> alphaStream(create_pattern_fill_content(-1, bbox));
 
-    auto resources =
+    sk_sp<SkPDFDict> resources =
         get_gradient_resource_dict(luminosityShader.get(), nullptr);
 
-    auto alphaMask = SkPDFMakeFormXObject(std::move(alphaStream),
-                                          SkPDFUtils::RectToArray(bbox),
-                                          std::move(resources),
-                                          SkMatrix::I(),
-                                          "DeviceRGB");
+    sk_sp<SkPDFObject> alphaMask =
+        SkPDFMakeFormXObject(std::move(alphaStream),
+                             SkPDFUtils::RectToArray(bbox),
+                             std::move(resources),
+                             SkMatrix::I(),
+                             "DeviceRGB");
     return SkPDFGraphicState::GetSMaskGraphicState(
             std::move(alphaMask), false,
             SkPDFGraphicState::kLuminosity_SMaskMode, doc->canon());
 }
 
 static sk_sp<SkPDFStream> make_alpha_function_shader(SkPDFDocument* doc,
                                                      SkScalar dpi,
                                                      const SkPDFShader::State& state) {
     SkRect bbox;
     bbox.set(state.fBBox);
 
     SkPDFShader::State opaqueState(state.MakeOpaqueState());
 
     sk_sp<SkPDFObject> colorShader(
             get_pdf_shader_by_state(doc, dpi, std::move(opaqueState), SkBitmap()));
     if (!colorShader) {
         return nullptr;
     }
 
     // Create resource dict with alpha graphics state as G0 and
     // pattern shader as P0, then write content stream.
-    auto alphaGs = create_smask_graphic_state(doc, dpi, state);
+    sk_sp<SkPDFObject> alphaGs = create_smask_graphic_state(doc, dpi, state);
 
-    auto resourceDict =
+    sk_sp<SkPDFDict> resourceDict =
             get_gradient_resource_dict(colorShader.get(), alphaGs.get());
 
     std::unique_ptr<SkStreamAsset> colorStream(
             create_pattern_fill_content(0, bbox));
     auto alphaFunctionShader = sk_make_sp<SkPDFStream>(std::move(colorStream));
 
     populate_tiling_pattern_dict(alphaFunctionShader->dict(), bbox,
                                  std::move(resourceDict), SkMatrix::I()); 
     return alphaFunctionShader;
 }
@@ skipping 647 matching lines @@
     }
     return false;
 }
 
 void SkPDFShader::State::allocateGradientInfoStorage() {
     fColors.reset(new SkColor[fInfo.fColorCount]);
     fStops.reset(new SkScalar[fInfo.fColorCount]);
     fInfo.fColors = fColors.get();
     fInfo.fColorOffsets = fStops.get();
 }