Relocate SK_SUPPORT_LEGACY_PICTURE_PTR

experimental/nanomsg/picture_demo.cpp

+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
 #include "nanomsg/src/nn.h"
 #include "nanomsg/src/pipeline.h"
 #include "nanomsg/src/reqrep.h"
 
 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
@@ skipping 35 matching lines @@
     };
 
     struct nn_msghdr msg;
     sk_bzero(&msg, sizeof(msg));
     msg.msg_iov    = iov;
     msg.msg_iovlen = SK_ARRAY_COUNT(iov);
 
     nn_sendmsg(socket, &msg, 0/*flags*/);
 }
 
-static SkPicture* recv_picture(int socket, PictureHeader* header) {
+static sk_sp<SkPicture> recv_picture(int socket, PictureHeader* header) {
     static const size_t hSize = sizeof(*header);  // It's easy to slip up and use sizeof(header).
 
     void* msg;
     int size = nn_recv(socket, &msg, NN_MSG, 0/*flags*/);
     SkDebugf("%d bytes", size);
 
     // msg is first a fixed-size header, then an .skp.
     memcpy(header, msg, hSize);
     SkMemoryStream stream((uint8_t*)msg + hSize, size - hSize);
-    SkPicture* pic = SkPicture::CreateFromStream(&stream);
+    sk_sp<SkPicture> pic = SkPicture::MakeFromStream(&stream);
 
     SkDebugf(" from proccess %d:", header->pid);
 
     nn_freemsg(msg);
     return pic;
 }
 
 static void client(const char* skpPath, const char* dataEndpoint) {
     // Read the .skp.
     SkAutoTUnref<const SkData> skp(SkData::NewFromFileName(skpPath));
     if (!skp) {
         SkDebugf("Couldn't read %s\n", skpPath);
         exit(1);
     }
     SkMemoryStream stream(skp->data(), skp->size());
-    SkAutoTUnref<SkPicture> picture(SkPicture::CreateFromStream(&stream));
+    sk_sp<SkPicture> picture(SkPicture::MakeFromStream(&stream));
 
     PictureHeader header;
     SkRandom rand(picture->cullRect().width() * picture->cullRect().height());
     SkScalar r = rand.nextRangeScalar(0, picture->cullRect().width()),
              b = rand.nextRangeScalar(0, picture->cullRect().height()),
              l = rand.nextRangeScalar(0, r),
              t = rand.nextRangeScalar(0, b);
     header.clip.setLTRB(l,t,r,b);
     header.matrix.setTranslate(-l, -t);
     header.matrix.postRotate(rand.nextRangeScalar(-25, 25));
@@ skipping 43 matching lines @@
     while (true) {
         int ready = poll_in(data, control);
 
         // If we got any message on the control socket, we can stop.
         if (ready == control) {
             break;
         }
 
         // We should have an .skp waiting for us on data socket.
         PictureHeader header;
-        SkAutoTUnref<SkPicture> picture(recv_picture(data, &header));
+        sk_sp<SkPicture> picture(recv_picture(data, &header));
 
         SkPaint paint;
         paint.setAlpha(header.alpha);
         paint.setXfermodeMode(header.xfermode);
 
         canvas->saveLayer(NULL, &paint);
             canvas->concat(header.matrix);
             canvas->clipRect(header.clip);
             picture->playback(canvas);
         canvas->restore();
@@ skipping 41 matching lines @@
 
         server(FLAGS_data[0], FLAGS_control[0], &canvas);
         canvas.flush();
 
         SkImageEncoder::EncodeFile(FLAGS_png[0], bitmap, SkImageEncoder::kPNG_Type, 100);
         SkDebugf("Wrote %s.\n", FLAGS_png[0]);
     }
 
     return 0;
 }