Pass clip to context

src/gpu/GrBitmapTextContext.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBitmapTextContext.h"
 #include "GrAtlas.h"
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 52 matching lines @@
 
 GrBitmapTextContext* GrBitmapTextContext::Create(GrContext* context,
                                                  const SkDeviceProperties& props) {
     return SkNEW_ARGS(GrBitmapTextContext, (context, props));
 }
 
 bool GrBitmapTextContext::canDraw(const SkPaint& paint, const SkMatrix& viewMatrix) {
     return !SkDraw::ShouldDrawTextAsPaths(paint, viewMatrix);
 }
 
-inline void GrBitmapTextContext::init(GrRenderTarget* rt, const GrPaint& paint,
-                                      const SkPaint& skPaint) {
-    GrTextContext::init(rt, paint, skPaint);
+inline void GrBitmapTextContext::init(GrRenderTarget* rt, const GrClip& clip,
+                                      const GrPaint& paint, const SkPaint& skPaint) {
+    GrTextContext::init(rt, clip, paint, skPaint);
 
     fStrike = NULL;
 
     fCurrTexture = NULL;
     fCurrVertex = 0;
 
     fVertices = NULL;
     fAllocVertexCount = 0;
     fTotalVertexCount = 0;
 }
 
-void GrBitmapTextContext::onDrawText(GrRenderTarget* rt, const GrPaint& paint,
-                                     const SkPaint& skPaint,
+void GrBitmapTextContext::onDrawText(GrRenderTarget* rt, const GrClip& clip,
+                                     const GrPaint& paint, const SkPaint& skPaint,
                                      const SkMatrix& viewMatrix,
                                      const char text[], size_t byteLength,
                                      SkScalar x, SkScalar y) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0 /*|| fRC->isEmpty()*/) {
         return;
     }
 
-    this->init(rt, paint, skPaint);
+    this->init(rt, clip, paint, skPaint);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache    autoCache(fSkPaint, &fDeviceProperties, &viewMatrix);
     SkGlyphCache*       cache = autoCache.getCache();
     GrFontScaler*       fontScaler = GetGrFontScaler(cache);
 
     // transform our starting point
     {
         SkPoint loc;
@@ skipping 67 matching lines @@
                               fontScaler);
         }
 
         fx += glyph.fAdvanceX;
         fy += glyph.fAdvanceY;
     }
 
     this->finish();
 }
 
-void GrBitmapTextContext::onDrawPosText(GrRenderTarget* rt, const GrPaint& paint,
-                                        const SkPaint& skPaint,
+void GrBitmapTextContext::onDrawPosText(GrRenderTarget* rt, const GrClip& clip,
+                                        const GrPaint& paint, const SkPaint& skPaint,
                                         const SkMatrix& viewMatrix,
                                         const char text[], size_t byteLength,
                                         const SkScalar pos[], int scalarsPerPosition,
                                         const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != NULL);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     // nothing to draw
     if (text == NULL || byteLength == 0/* || fRC->isEmpty()*/) {
         return;
     }
 
-    this->init(rt, paint, skPaint);
+    this->init(rt, clip, paint, skPaint);
 
     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 
     SkAutoGlyphCache    autoCache(fSkPaint, &fDeviceProperties, &viewMatrix);
     SkGlyphCache*       cache = autoCache.getCache();
     GrFontScaler*       fontScaler = GetGrFontScaler(cache);
 
     // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix, but for
     // performance reasons we just invert here instead
     if (!viewMatrix.invert(&fLocalMatrix)) {
@@ skipping 236 matching lines @@
 
         // flush any accumulated draws before drawing this glyph as a path.
         this->flush();
 
         SkMatrix translate;
         translate.setTranslate(SkFixedToScalar(vx - SkIntToFixed(glyph->fBounds.fLeft)),
                                SkFixedToScalar(vy - SkIntToFixed(glyph->fBounds.fTop)));
         SkPath tmpPath(*glyph->fPath);
         tmpPath.transform(translate);
         GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
-        fContext->drawPath(fRenderTarget, fPaint, SkMatrix::I(), tmpPath, strokeInfo);
+        fContext->drawPath(fRenderTarget, fClip, fPaint, SkMatrix::I(), tmpPath, strokeInfo);
 
         // remove this glyph from the vertices we need to allocate
         fTotalVertexCount -= kVerticesPerGlyph;
         return;
     }
 
     SkASSERT(glyph->fPlot);
     GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken();
     glyph->fPlot->setDrawToken(drawToken);
 
@@ skipping 154 matching lines @@
     }
 }
 
 inline void GrBitmapTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }