Make GMs aware of what tool they're being run in.

src/gpu/effects/GrConvexPolyEffect.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 "GrConvexPolyEffect.h"
 
 #include "gl/GrGLEffect.h"
@@ skipping 79 matching lines @@
 
 GrGLEffect::EffectKey GrGLConvexPolyEffect::GenKey(const GrDrawEffect& drawEffect,
                                                    const GrGLCaps&) {
     const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>();
     GR_STATIC_ASSERT(GrConvexPolyEffect::kEdgeTypeCnt <= 4);
     return (cpe.getEdgeCount() << 2) | cpe.getEdgeType();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrEffectRef* GrConvexPolyEffect::Create(EdgeType type, const SkPath& path) {
+GrEffectRef* GrConvexPolyEffect::Create(EdgeType type, const SkPath& path, const SkVector* offset) {
     if (path.getSegmentMasks() != SkPath::kLine_SegmentMask ||
         !path.isConvex() ||
         path.isInverseFillType()) {
         return NULL;
     }
 
     if (path.countPoints() > kMaxEdges) {
         return NULL;
     }
 
     SkPoint pts[kMaxEdges];
     SkScalar edges[3 * kMaxEdges];
 
     SkPath::Direction dir;
     SkAssertResult(path.cheapComputeDirection(&dir));
 
+    SkVector t;
+    if (NULL == offset) {
+        t.set(0, 0);
+    } else {
+        t = *offset;
+    }
+
     int count = path.getPoints(pts, kMaxEdges);
     int n = 0;
     for (int lastPt = count - 1, i = 0; i < count; lastPt = i++) {
         if (pts[lastPt] != pts[i]) {
             SkVector v = pts[i] - pts[lastPt];
             v.normalize();
             if (SkPath::kCCW_Direction == dir) {
                 edges[3 * n] = v.fY;
                 edges[3 * n + 1] = -v.fX;
             } else {
                 edges[3 * n] = -v.fY;
                 edges[3 * n + 1] = v.fX;
             }
-            edges[3 * n + 2] = -(edges[3 * n] * pts[i].fX + edges[3 * n + 1] * pts[i].fY);
+            SkPoint p = pts[i] + t;
+            edges[3 * n + 2] = -(edges[3 * n] * p.fX + edges[3 * n + 1] * p.fY);
             ++n;
         }
     }
     return Create(type, n, edges);
 }
 
 GrConvexPolyEffect::~GrConvexPolyEffect() {}
 
 void GrConvexPolyEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     *validFlags = 0;
@@ skipping 34 matching lines @@
                                             GrTexture*[]) {
     EdgeType edgeType = static_cast<EdgeType>(random->nextULessThan(kEdgeTypeCnt));
     int count = random->nextULessThan(kMaxEdges) + 1;
     SkScalar edges[kMaxEdges * 3];
     for (int i = 0; i < 3 * count; ++i) {
         edges[i] = random->nextSScalar1();
     }
 
     return GrConvexPolyEffect::Create(edgeType, count, edges);
 }