Fix convex-lineonly-paths GM so it plays nice with SampleApp

gm/convex_all_line_paths.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 
 static void create_ngon(int n, SkPoint* pts, SkScalar width, SkScalar height) {
@@ skipping 10 matching lines @@
     }
 }
 
 namespace skiagm {
 
 // This GM is intended to exercise Ganesh's handling of convex line-only
 // paths
 class ConvexLineOnlyPathsGM : public GM {
 public:
     ConvexLineOnlyPathsGM() { 
-        fOffset.set(0, SkScalarHalf(kMaxPathHeight));
         this->setBGColor(0xFFFFFFFF);
     }
 
 protected:
     SkString onShortName() override { return SkString("convex-lineonly-paths"); }
     SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); }
     bool runAsBench() const override { return true; }
 
     static SkPath GetPath(int index, int offset, SkPath::Direction dir) {
         // narrow rect
@@ skipping 201 matching lines @@
         SkASSERT(dir == actualDir);
         SkRect bounds = path.getBounds();
         SkASSERT(SkScalarNearlyEqual(bounds.centerX(), 0.0f));
         SkASSERT(bounds.height() <= kMaxPathHeight);
 #endif
         return path;
     }
 
     // Draw a single path several times, shrinking it, flipping its direction
     // and changing its start vertex each time.
-    void drawPath(SkCanvas* canvas, int index) {
+    void drawPath(SkCanvas* canvas, int index, SkPoint* offset) {
 
         SkPoint center;
         {
             SkPath path = GetPath(index, 0, SkPath::kCW_Direction);
-            if (fOffset.fX+path.getBounds().width() > kGMWidth) {
-                fOffset.fX = 0;
-                fOffset.fY += kMaxPathHeight;
+            if (offset->fX+path.getBounds().width() > kGMWidth) {
+                offset->fX = 0;
+                offset->fY += kMaxPathHeight;
             }
-            center = { fOffset.fX + SkScalarHalf(path.getBounds().width()), fOffset.fY};
-            fOffset.fX += path.getBounds().width();
+            center = { offset->fX + SkScalarHalf(path.getBounds().width()), offset->fY};
+            offset->fX += path.getBounds().width();
         }
 
         const SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE };
         const SkPath::Direction dirs[2] = { SkPath::kCW_Direction, SkPath::kCCW_Direction };
         const float scales[] = { 1.0f, 0.75f, 0.5f, 0.25f, 0.1f, 0.01f, 0.001f };
 
         SkPaint paint;
         paint.setAntiAlias(true);
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(scales); ++i) {
             SkPath path = GetPath(index, (int) i, dirs[i%2]);
 
             canvas->save();
                 canvas->translate(center.fX, center.fY);
                 canvas->scale(scales[i], scales[i]);
                 paint.setColor(colors[i%2]);
                 canvas->drawPath(path, paint);
             canvas->restore();
         }
     }
 
     void onDraw(SkCanvas* canvas) override {
+        // the right edge of the last drawn path
+        SkPoint offset = { 0, SkScalarHalf(kMaxPathHeight) }; 
+
         for (int i = 0; i < kNumPaths; ++i) {
-            this->drawPath(canvas, i);
+            this->drawPath(canvas, i, &offset);
         }
 
         // Repro for crbug.com/472723 (Missing AA on portions of graphic with GPU rasterization)
         {
             canvas->translate(356.0f, 50.0f);
 
             SkPaint p;
             p.setAntiAlias(true);
 
             SkPath p1;
             p1.moveTo(60.8522949f, 364.671021f);
             p1.lineTo(59.4380493f, 364.671021f);
             p1.lineTo(385.414276f, 690.647217f);
             p1.lineTo(386.121399f, 689.940125f);
             canvas->drawPath(p1, p);
         }
     }
 
 private:
     static const int kNumPaths      = 20;
     static const int kMaxPathHeight = 100;
     static const int kGMWidth       = 512;
     static const int kGMHeight      = 512;
 
-    SkPoint fOffset;        // the right edge of the last drawn path
-
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM( return SkNEW(ConvexLineOnlyPathsGM); )
 
 }