diff --git a/gm/tileimagefilter.cpp b/gm/tileimagefilter.cpp
index dd53151..c61b655 100644
--- a/gm/tileimagefilter.cpp
+++ b/gm/tileimagefilter.cpp
@@ -52,72 +52,80 @@
         blue.setStyle(SkPaint::kStroke_Style);
 
         int x = 0, y = 0;
-        for (size_t i = 0; i < 4; i++) {
-            sk_sp<SkImage> image = (i & 0x01) ? fCheckerboard : fBitmap;
-            SkRect srcRect = SkRect::MakeXYWH(SkIntToScalar(image->width()/4),
-                                              SkIntToScalar(image->height()/4),
-                                              SkIntToScalar(image->width()/(i+1)),
-                                              SkIntToScalar(image->height()/(i+1)));
-            SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(i * 8),
-                                              SkIntToScalar(i * 4),
-                                              SkIntToScalar(image->width() - i * 12),
-                                              SkIntToScalar(image->height()) - i * 12);
-            sk_sp<SkImageFilter> tileInput(SkImageSource::Make(image));
-            sk_sp<SkImageFilter> filter(SkTileImageFilter::Make(srcRect,
-                                                                dstRect,
-                                                                std::move(tileInput)));
-            canvas->save();
-            canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
-            SkPaint paint;
-            paint.setImageFilter(std::move(filter));
-            canvas->drawImage(fBitmap.get(), 0, 0, &paint);
-            canvas->drawRect(srcRect, red);
-            canvas->drawRect(dstRect, blue);
-            canvas->restore();
-            x += image->width() + MARGIN;
-            if (x + image->width() > WIDTH) {
-                x = 0;
-                y += image->height() + MARGIN;
+
+        {
+            for (size_t i = 0; i < 4; i++) {
+                sk_sp<SkImage> image = (i & 0x01) ? fCheckerboard : fBitmap;
+                SkRect srcRect = SkRect::MakeXYWH(SkIntToScalar(image->width()/4),
+                                                  SkIntToScalar(image->height()/4),
+                                                  SkIntToScalar(image->width()/(i+1)),
+                                                  SkIntToScalar(image->height()/(i+1)));
+                SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(i * 8),
+                                                  SkIntToScalar(i * 4),
+                                                  SkIntToScalar(image->width() - i * 12),
+                                                  SkIntToScalar(image->height()) - i * 12);
+                sk_sp<SkImageFilter> tileInput(SkImageSource::Make(image));
+                sk_sp<SkImageFilter> filter(SkTileImageFilter::Make(srcRect,
+                                                                    dstRect,
+                                                                    std::move(tileInput)));
+                canvas->save();
+                canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
+                SkPaint paint;
+                paint.setImageFilter(std::move(filter));
+                canvas->drawImage(fBitmap.get(), 0, 0, &paint);
+                canvas->drawRect(srcRect, red);
+                canvas->drawRect(dstRect, blue);
+                canvas->restore();
+                x += image->width() + MARGIN;
+                if (x + image->width() > WIDTH) {
+                    x = 0;
+                    y += image->height() + MARGIN;
+                }
             }
         }
 
-        SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
-                                0, SK_Scalar1, 0, 0, 0,
-                                0, 0, SK_Scalar1, 0, 0,
-                                0, 0, 0, SK_Scalar1, 0 };
+        {
+            SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
+                                    0, SK_Scalar1, 0, 0, 0,
+                                    0, 0, SK_Scalar1, 0, 0,
+                                    0, 0, 0, SK_Scalar1, 0 };
 
-        SkRect srcRect = SkRect::MakeWH(SkIntToScalar(fBitmap->width()),
-                                        SkIntToScalar(fBitmap->height()));
-        SkRect dstRect = SkRect::MakeWH(SkIntToScalar(fBitmap->width() * 2),
-                                        SkIntToScalar(fBitmap->height() * 2));
-        sk_sp<SkImageFilter> tile(SkTileImageFilter::Make(srcRect, dstRect, nullptr));
-        sk_sp<SkColorFilter> cf(SkColorFilters::MatrixRowMajor255(matrix));
+            SkRect srcRect = SkRect::MakeWH(SkIntToScalar(fBitmap->width()),
+                                            SkIntToScalar(fBitmap->height()));
+            SkRect dstRect = SkRect::MakeWH(SkIntToScalar(fBitmap->width() * 2),
+                                            SkIntToScalar(fBitmap->height() * 2));
+            sk_sp<SkImageFilter> tile(SkTileImageFilter::Make(srcRect, dstRect, nullptr));
+            sk_sp<SkColorFilter> cf(SkColorFilters::MatrixRowMajor255(matrix));
 
-        SkPaint paint;
-        paint.setImageFilter(SkColorFilterImageFilter::Make(std::move(cf), std::move(tile)));
-        canvas->save();
-        canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
-        canvas->clipRect(dstRect);
-        canvas->saveLayer(&dstRect, &paint);
-        canvas->drawImage(fBitmap.get(), 0, 0);
-        canvas->restore();
-        canvas->drawRect(srcRect, red);
-        canvas->drawRect(dstRect, blue);
-        canvas->restore();
+            SkPaint paint;
+            paint.setImageFilter(SkColorFilterImageFilter::Make(std::move(cf), std::move(tile)));
+            canvas->save();
+            canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
+            canvas->clipRect(dstRect);
+            canvas->saveLayer(&dstRect, &paint);
+            canvas->drawImage(fBitmap.get(), 0, 0);
+            canvas->restore();
+            canvas->drawRect(srcRect, red);
+            canvas->drawRect(dstRect, blue);
+            canvas->restore();
+        }
 
-        canvas->translate(0, SkIntToScalar(100));
+        // test that the crop rect properly applies to the tile image filter
+        {
+            canvas->translate(0, SkIntToScalar(100));
 
-        srcRect = SkRect::MakeXYWH(0, 0, 50, 50);
-        dstRect = SkRect::MakeXYWH(0, 0, 100, 100);
-        SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(5, 5, 40, 40));
-        sk_sp<SkColorFilter> greenCF = SkColorFilters::Blend(SK_ColorGREEN, SkBlendMode::kSrc);
-        sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Make(std::move(greenCF),
-                                                                  nullptr,
-                                                                  &cropRect));
-        tile = SkTileImageFilter::Make(srcRect, dstRect, std::move(green));
-        paint.setColor(SK_ColorRED);
-        paint.setImageFilter(std::move(tile));
-        canvas->drawRect(dstRect, paint);
+            SkRect srcRect = SkRect::MakeXYWH(0, 0, 50, 50);
+            SkRect dstRect = SkRect::MakeXYWH(0, 0, 100, 100);
+            SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(5, 5, 40, 40));
+            sk_sp<SkColorFilter> greenCF = SkColorFilters::Blend(SK_ColorGREEN, SkBlendMode::kSrc);
+            sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Make(std::move(greenCF),
+                                                                      nullptr,
+                                                                      &cropRect));
+            SkPaint paint;
+            paint.setColor(SK_ColorRED);
+            paint.setImageFilter(SkTileImageFilter::Make(srcRect, dstRect, std::move(green)));
+            canvas->drawRect(dstRect, paint);
+        }
     }
 private:
     sk_sp<SkImage> fBitmap, fCheckerboard;
diff --git a/src/gpu/GrFragmentProcessor.h b/src/gpu/GrFragmentProcessor.h
index fb8126e..96c578c 100644
--- a/src/gpu/GrFragmentProcessor.h
+++ b/src/gpu/GrFragmentProcessor.h
@@ -285,8 +285,8 @@
     }
 
     GrFragmentProcessor(ClassID classID, OptimizationFlags optimizationFlags)
-    : INHERITED(classID)
-    , fFlags(optimizationFlags) {
+            : INHERITED(classID)
+            , fFlags(optimizationFlags) {
         SkASSERT((fFlags & ~kAll_OptimizationFlags) == 0);
     }
 
diff --git a/src/gpu/GrResourceAllocator.cpp b/src/gpu/GrResourceAllocator.cpp
index 2142b06..396372c 100644
--- a/src/gpu/GrResourceAllocator.cpp
+++ b/src/gpu/GrResourceAllocator.cpp
@@ -37,7 +37,6 @@
     fProxy->priv().assign(std::move(s));
 }
 
-
 void GrResourceAllocator::markEndOfOpList(int opListIndex) {
     SkASSERT(!fAssigned);      // We shouldn't be adding any opLists after (or during) assignment
 
@@ -286,7 +285,7 @@
 }
 
 // Remove any intervals that end before the current index. Return their GrSurfaces
-// to the free pool.
+// to the free pool if possible.
 void GrResourceAllocator::expire(unsigned int curIndex) {
     while (!fActiveIntvls.empty() && fActiveIntvls.peekHead()->end() < curIndex) {
         Interval* temp = fActiveIntvls.popHead();
diff --git a/src/gpu/GrResourceAllocator.h b/src/gpu/GrResourceAllocator.h
index fabaf00..7958eca 100644
--- a/src/gpu/GrResourceAllocator.h
+++ b/src/gpu/GrResourceAllocator.h
@@ -120,9 +120,10 @@
 #endif
         }
 
+        // Used when recycling an interval
         void resetTo(GrSurfaceProxy* proxy, unsigned int start, unsigned int end) {
             SkASSERT(proxy);
-            SkASSERT(!fNext);
+            SkASSERT(!fProxy && !fNext);
 
             fProxy = proxy;
             fProxyID = proxy->uniqueID().asUInt();
diff --git a/tests/LazyProxyTest.cpp b/tests/LazyProxyTest.cpp
index 6dcfb2b..cacc6fc 100644
--- a/tests/LazyProxyTest.cpp
+++ b/tests/LazyProxyTest.cpp
@@ -111,7 +111,13 @@
         const char* name() const override { return "LazyProxyTest::Op"; }
         FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
         GrProcessorSet::Analysis finalize(
-                const GrCaps&, const GrAppliedClip*, GrFSAAType, GrClampType) override {
+                const GrCaps&, const GrAppliedClip* clip, GrFSAAType, GrClampType) override {
+            if (clip) {
+                for (int i = 0; i < clip->numClipCoverageFragmentProcessors(); ++i) {
+                    const GrFragmentProcessor* clipFP = clip->clipCoverageFragmentProcessor(i);
+                    clipFP->markPendingExecution();
+                }
+            }
             return GrProcessorSet::EmptySetAnalysis();
         }
         void onPrepare(GrOpFlushState*) override {}