SkPDF: clean up uses of deprecated calls in other SkPDF classes

src/pdf/SkPDFGraphicState.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 "SkData.h"
 #include "SkLazyPtr.h"
 #include "SkPDFCanon.h"
@@ skipping 125 matching lines @@
     domainAndRange->appendInt(1);
 
     static const char psInvert[] = "{1 exch sub}";
     // Do not copy the trailing '\0' into the SkData.
     SkAutoTUnref<SkData> psInvertStream(
             SkData::NewWithoutCopy(psInvert, strlen(psInvert)));
 
     SkPDFStream* invertFunction = SkNEW_ARGS(
             SkPDFStream, (psInvertStream.get()));
     invertFunction->insertInt("FunctionType", 4);
-    invertFunction->insert("Domain", domainAndRange.get());
-    invertFunction->insert("Range", domainAndRange.get());
+    invertFunction->insertObject("Domain", SkRef(domainAndRange.get()));
+    invertFunction->insertObject("Range", domainAndRange.detach());
     return invertFunction;
 }
 
 template <typename T> void unref(T* ptr) { ptr->unref(); }
 }  // namespace
 
 SK_DECLARE_STATIC_LAZY_PTR(SkPDFObject,
                            invertFunction,
                            create_invert_function,
                            unref<SkPDFObject>);
 
 // static
 SkPDFDict* SkPDFGraphicState::GetSMaskGraphicState(SkPDFFormXObject* sMask,
                                                    bool invert,
                                                    SkPDFSMaskMode sMaskMode) {
     // The practical chances of using the same mask more than once are unlikely
     // enough that it's not worth canonicalizing.
     SkAutoTUnref<SkPDFDict> sMaskDict(new SkPDFDict("Mask"));
     if (sMaskMode == kAlpha_SMaskMode) {
         sMaskDict->insertName("S", "Alpha");
     } else if (sMaskMode == kLuminosity_SMaskMode) {
         sMaskDict->insertName("S", "Luminosity");
     }
-    sMaskDict->insert("G", new SkPDFObjRef(sMask))->unref();
+    sMaskDict->insertObjRef("G", SkRef(sMask));
     if (invert) {
-        sMaskDict->insert("TR", new SkPDFObjRef(invertFunction.get()))->unref();
+        sMaskDict->insertObjRef("TR", SkRef(invertFunction.get()));
     }
 
     SkPDFDict* result = new SkPDFDict("ExtGState");
-    result->insert("SMask", sMaskDict.get());
+    result->insertObject("SMask", sMaskDict.detach());
     return result;
 }
 
 namespace {
 SkPDFDict* create_no_smask_graphic_state() {
     SkPDFDict* noSMaskGS = new SkPDFDict("ExtGState");
     noSMaskGS->insertName("SMask", "None");
     return noSMaskGS;
 }
 } // namespace
 SK_DECLARE_STATIC_LAZY_PTR(SkPDFDict,
                            noSMaskGraphicState,
                            create_no_smask_graphic_state,
                            unref<SkPDFDict>);
 
 // static
 SkPDFDict* SkPDFGraphicState::GetNoSMaskGraphicState() {
     return SkRef(noSMaskGraphicState.get());
 }
 
 void SkPDFGraphicState::emitObject(SkWStream* stream,
                                    const SkPDFObjNumMap& objNumMap,
                                    const SkPDFSubstituteMap& substitutes) {
     SkAutoTUnref<SkPDFDict> dict(SkNEW_ARGS(SkPDFDict, ("ExtGState")));
     dict->insertName("Type", "ExtGState");
 
-    SkAutoTUnref<SkPDFScalar> alpha(new SkPDFScalar(SkScalarDiv(fAlpha, 0xFF)));
-    dict->insert("CA", alpha.get());
-    dict->insert("ca", alpha.get());
+    SkScalar alpha = SkScalarDiv(fAlpha, 0xFF);
+    dict->insertScalar("CA", alpha);
+    dict->insertScalar("ca", alpha);
 
     SkPaint::Cap strokeCap = (SkPaint::Cap)fStrokeCap;
     SkPaint::Join strokeJoin = (SkPaint::Join)fStrokeJoin;
     SkXfermode::Mode xferMode = (SkXfermode::Mode)fMode;
 
     SK_COMPILE_ASSERT(SkPaint::kButt_Cap == 0, paint_cap_mismatch);
     SK_COMPILE_ASSERT(SkPaint::kRound_Cap == 1, paint_cap_mismatch);
     SK_COMPILE_ASSERT(SkPaint::kSquare_Cap == 2, paint_cap_mismatch);
     SK_COMPILE_ASSERT(SkPaint::kCapCount == 3, paint_cap_mismatch);
     SkASSERT(strokeCap >= 0 && strokeCap <= 2);
     dict->insertInt("LC", strokeCap);
 
     SK_COMPILE_ASSERT(SkPaint::kMiter_Join == 0, paint_join_mismatch);
     SK_COMPILE_ASSERT(SkPaint::kRound_Join == 1, paint_join_mismatch);
     SK_COMPILE_ASSERT(SkPaint::kBevel_Join == 2, paint_join_mismatch);
     SK_COMPILE_ASSERT(SkPaint::kJoinCount == 3, paint_join_mismatch);
     SkASSERT(strokeJoin >= 0 && strokeJoin <= 2);
     dict->insertInt("LJ", strokeJoin);
 
     dict->insertScalar("LW", fStrokeWidth);
     dict->insertScalar("ML", fStrokeMiter);
-    // SA = Auto stroke adjustment.
-    dict->insert("SA", new SkPDFBool(true))->unref();
+    dict->insertBool("SA", true);  // SA = Auto stroke adjustment.
     dict->insertName("BM", as_blend_mode(xferMode));
     dict->emitObject(stream, objNumMap, substitutes);
 }