reconfigure dont-clip-to-layer gm to not have transparent pixels in its final output

gm/aaclip.cpp

 /*
  * Copyright 2011 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"
 #include "SkCanvas.h"
 #include "SkPath.h"
@@ skipping 10 matching lines @@
  *  layer's bounds. Thus when a draw occurs, it can (depending on "where" it is) draw into the layer
  *  and/or draw onto the surrounding portions of the canvas, or both.
  *
  *  This GM has a 100x100 rectangle (r), which its going to draw. However first it creates a layer
  *  with this flag covering 1/2 of the rectangle (upper half). Then it draws the rect in SRC mode.
  *
  *  The portion of the draw that intersects the layer should see the SRC draw, apply it to the layer
  *  and then during restore, it will SRC_OVER that layer onto the canvas (SRC_OVER since the layer
  *  has no paint, so it gets the default xfermode during restore).
  *
+ *  Note: when we talk about drawing directly into the "canvas", in fact we are drawing into an
+ *        "outer" layer we created (filled with red). This is a testing detail, so that our final
+ *        output image is itself opaque, otherwise we make it harder to view the GM as a PNG.
+ *
  *  The portion of the draw below the layer draws directly into the canvas. Since it is in SRC mode,
- *  it will wrote 0x80 to the canvas' alpha, making it appear darker when shown in the window.
- *  The portion in the layer, will end up SRC_OVERing the 0x80 layer pixels onto the canvas, so
- *  they will appear lighter (since the canvas was erased to white initially).
+ *  it will write 0x80 to the canvas' alpha, overwriting the "red", which then gets blended with
+ *  the GM's white background.
  *
- *  Thus the expected result is the upper half to be light-blue w/ 0xFF for its alpha, and
- *  the lower half to be darker blue with 0x80 for its alpha.
+ *  The portion in the layer, will end up SRC_OVERing the 0x80 layer pixels onto the canvas' red
+ *  pixels, making magenta.
+ *
+ *  Thus the expected result is the upper half to be magenta 0xFF7F0080, and the lower half to be
+ *  light blue 0xFF7F7FFF.
  */
 DEF_SIMPLE_GM(dont_clip_to_layer, canvas, 120, 120) {
-    SkRect r { 10, 10, 110, 110 };
+    const SkRect r { 10, 10, 110, 110 };
+
+    // Wrap the entire test inside a red layer, so we don't punch the actual gm's alpha with
+    // kSrc_Mode, which makes it hard to view (we like our GMs to have opaque pixels).
+    canvas->saveLayer(&r, nullptr);
+    canvas->drawColor(SK_ColorRED);
+
     SkRect r0 = SkRect::MakeXYWH(r.left(), r.top(), r.width(), r.height()/2);
 
     SkCanvas::SaveLayerRec rec;
     rec.fPaint = nullptr;
     rec.fBounds = &r0;
     rec.fBackdrop = nullptr;
     rec.fSaveLayerFlags = 1 << 31;//SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag;
     canvas->saveLayer(rec);
     do_draw(canvas, r);
     canvas->restore();
+
+    canvas->restore();  // red-layer
 }
 
 /** Draw a 2px border around the target, then red behind the target;
     set the clip to match the target, then draw >> the target in blue.
 */
 
 static void draw(SkCanvas* canvas, SkRect& target, int x, int y) {
     SkPaint borderPaint;
     borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0));
     borderPaint.setAntiAlias(true);
@@ skipping 234 matching lines @@
         canvas->translate(80, 10);
         this->drawAndClip(canvas, fVPath, 200, 0);
         canvas->translate(0, 200);
         this->drawAndClip(canvas, fHPath, 200, 0);
     }
 
 private:
     typedef skiagm::GM INHERITED;
 };
 DEF_GM(return new ClipCubicGM;)