Revert "Change clear() to respect the clip"

src/gpu/GrLayerHoister.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 "GrLayerCache.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
@@ skipping 216 matching lines @@
 
 void GrLayerHoister::DrawLayersToAtlas(GrContext* context,
                                        const SkTDArray<GrHoistedLayer>& atlased) {
     if (atlased.count() > 0) {
         // All the atlased layers are rendered into the same GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         atlased[0].fLayer->texture()->asRenderTarget(), NULL));
 
         SkCanvas* atlasCanvas = surface->getCanvas();
 
+        SkPaint clearPaint;
+        clearPaint.setColor(SK_ColorTRANSPARENT);
+        clearPaint.setXfermode(SkXfermode::Create(SkXfermode::kSrc_Mode))->unref();
+
         for (int i = 0; i < atlased.count(); ++i) {
             const GrCachedLayer* layer = atlased[i].fLayer;
             const SkPicture* pict = atlased[i].fPicture;
             const SkIPoint offset = atlased[i].fOffset;
             SkDEBUGCODE(const SkPaint* layerPaint = layer->paint();)
 
             SkASSERT(!layerPaint || !layerPaint->getImageFilter());
 
             atlasCanvas->save();
 
             // Add a rect clip to make sure the rendering doesn't
             // extend beyond the boundaries of the atlased sub-rect
             SkRect bound = SkRect::MakeXYWH(SkIntToScalar(layer->rect().fLeft),
                                             SkIntToScalar(layer->rect().fTop),
                                             SkIntToScalar(layer->rect().width()),
                                             SkIntToScalar(layer->rect().height()));
             atlasCanvas->clipRect(bound);
-            atlasCanvas->clear(0);
+
+            // Since 'clear' doesn't respect the clip we need to draw a rect
+            atlasCanvas->drawRect(bound, clearPaint);
 
             // '-offset' maps the layer's top/left to the origin.
             // Since this layer is atlased, the top/left corner needs
             // to be offset to the correct location in the backing texture.
             SkMatrix initialCTM;
             initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY));
             initialCTM.preTranslate(bound.fLeft, bound.fTop);
             initialCTM.preConcat(atlased[i].fPreMat);
 
             atlasCanvas->setMatrix(initialCTM);
             atlasCanvas->concat(atlased[i].fLocalMat);
 
             SkRecordPartialDraw(*pict->fRecord.get(), atlasCanvas,
                                 pict->drawablePicts(), pict->drawableCount(),
-                                layer->start() + 1, layer->stop(), initialCTM);
+                                bound, layer->start() + 1, layer->stop(), initialCTM);
 
             atlasCanvas->restore();
         }
 
         atlasCanvas->flush();
     }
 }
 
 void GrLayerHoister::DrawLayers(GrContext* context, const SkTDArray<GrHoistedLayer>& layers) {
     for (int i = 0; i < layers.count(); ++i) {
@@ skipping 10 matching lines @@
         SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop);
 
         // Add a rect clip to make sure the rendering doesn't
         // extend beyond the boundaries of the layer
         SkRect bound = SkRect::MakeXYWH(SkIntToScalar(layer->rect().fLeft),
                                         SkIntToScalar(layer->rect().fTop),
                                         SkIntToScalar(layer->rect().width()),
                                         SkIntToScalar(layer->rect().height()));
 
         layerCanvas->clipRect(bound);
+
         layerCanvas->clear(SK_ColorTRANSPARENT);
 
         SkMatrix initialCTM;
         initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY));
         initialCTM.preConcat(layers[i].fPreMat);
 
         layerCanvas->setMatrix(initialCTM);
         layerCanvas->concat(layers[i].fLocalMat);
 
         SkRecordPartialDraw(*pict->fRecord.get(), layerCanvas,
                             pict->drawablePicts(), pict->drawableCount(),
-                            layer->start()+1, layer->stop(), initialCTM);
+                            bound, layer->start()+1, layer->stop(), initialCTM);
 
         layerCanvas->flush();
     }
 }
 
 void GrLayerHoister::UnlockLayers(GrContext* context,
                                   const SkTDArray<GrHoistedLayer>& layers) {
     GrLayerCache* layerCache = context->getLayerCache();
 
     for (int i = 0; i < layers.count(); ++i) {
         layerCache->removeUse(layers[i].fLayer);
     }
 
     SkDEBUGCODE(layerCache->validate();)
 }
 
 void GrLayerHoister::PurgeCache(GrContext* context) {
 #if !GR_CACHE_HOISTED_LAYERS
     GrLayerCache* layerCache = context->getLayerCache();
 
     // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     layerCache->purgeAll();
 #endif
 }