Revert of Add initial implementation of GrShape and GrStyle classes and tests

src/gpu/GrShape.h

-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrShape_DEFINED
-#define GrShape_DEFINED
-
-#include "GrStyle.h"
-#include "SkPath.h"
-#include "SkRRect.h"
-#include "SkTemplates.h"
-#include "SkTLazy.h"
-
-/**
- * Represents a geometric shape (rrect or path) and the GrStyle that it should be rendered with.
- * It is possible to apply the style to the GrShape to produce a new GrShape where the geometry
- * reflects the styling information (e.g. is stroked). It is also possible to apply just the
- * path effect from the style. In this case the resulting shape will include any remaining
- * stroking information that is to be applied after the path effect.
- *
- * Shapes can produce keys that represent only the geometry information, not the style. Note that
- * when styling information is applied to produce a new shape then the style has been converted
- * to geometric information and is included in the new shape's key. When the same style is applied
- * to two shapes that reflect the same underlying geometry the computed keys of the stylized shapes
- * will be the same.
- *
- * Currently this can only be constructed from a rrect, though it can become a path by applying
- * style to the geometry. The idea is to expand this to cover most or all of the geometries that
- * have SkCanvas::draw APIs.
- */
-class GrShape {
-public:
-    GrShape() : fType(Type::kEmpty) {}
-
-    explicit GrShape(const SkRRect& rrect) : fType(Type::kRRect), fRRect(rrect) {}
-    explicit GrShape(const SkRect& rect) : fType(Type::kRRect), fRRect(SkRRect::MakeRect(rect)) {}
-
-    GrShape(const SkRRect& rrect, const GrStyle& style)
-        : fType(Type::kRRect)
-        , fRRect(rrect)
-        , fStyle(style) {}
-
-    GrShape(const SkRect& rect, const GrStyle& style)
-        : fType(Type::kRRect)
-        , fRRect(SkRRect::MakeRect(rect))
-        , fStyle(style) {}
-
-    GrShape(const SkRRect& rrect, const SkPaint& paint)
-        : fType(Type::kRRect)
-        , fRRect(rrect)
-        , fStyle(paint) {}
-
-    GrShape(const SkRect& rect, const SkPaint& paint)
-        : fType(Type::kRRect)
-        , fRRect(SkRRect::MakeRect(rect))
-        , fStyle(paint) {}
-
-    GrShape(const GrShape&);
-    GrShape& operator=(const GrShape& that);
-
-    ~GrShape() {
-        if (Type::kPath == fType) {
-            fPath.reset();
-        }
-    }
-
-    const GrStyle& style() const { return fStyle; }
-
-    /**
-     * Returns a GrShape where the shape's geometry fully reflects the original shape's GrStyle.
-     * The GrStyle of the returned shape will either be fill or hairline.
-     */
-    GrShape applyFullStyle() { return GrShape(*this, false); }
-
-    /**
-     * Similar to above but applies only the path effect. Path effects take the original geometry
-     * and fill/stroking information and compute a new geometry and residual fill/stroking
-     * information to be applied. The path effect's output geometry and stroking will be captured
-     * in the returned GrShape.
-     */
-    GrShape applyPathEffect() { return GrShape(*this, true); }
-
-    bool asRRect(SkRRect* rrect) const {
-        if (Type::kRRect != fType) {
-            return false;
-        }
-        if (rrect) {
-            *rrect = fRRect;
-        }
-        return true;
-    }
-
-    void asPath(SkPath* out) const {
-        switch (fType) {
-            case Type::kRRect:
-                out->reset();
-                out->addRRect(fRRect);
-                break;
-            case Type::kPath:
-                *out = *fPath.get();
-                break;
-            case Type::kEmpty:
-                out->reset();
-                break;
-        }
-    }
-
-    /**
-     * Gets the size of the key for the shape represented by this GrShape (ignoring its styling).
-     * A negative value is returned if the shape has no key (shouldn't be cached).
-     */
-    int unstyledKeySize() const;
-
-    /**
-     * Writes unstyledKeySize() bytes into the provided pointer. Assumes that there is enough
-     * space allocated for the key and that unstyledKeySize() does not return a negative value
-     * for this shape.
-     */
-    void writeUnstyledKey(uint32_t* key) const;
-
-private:
-    /**
-     * Computes the key length for a GrStyle. The return will be negative if it cannot be turned
-     * into a key.
-     */
-    static int StyleKeySize(const GrStyle& , bool stopAfterPE);
-
-    /**
-     * Writes a unique key for the style into the provided buffer. This function assumes the buffer
-     * has room for at least StyleKeySize() values. It assumes that StyleKeySize() returns a
-     * positive value for the style and stopAfterPE param. This is written so that the key for just
-     * dash application followed by the key for the remaining SkStrokeRec is the same as the
-     * key for applying dashing and SkStrokeRec all at once.
-     */
-    static void StyleKey(uint32_t*, const GrStyle&, bool stopAfterPE);
-
-    /** Constructor used by Apply* functions */
-    GrShape(const GrShape& parentShape, bool stopAfterPE);
-
-    /**
-     * Determines the key we should inherit from the input shape's geometry and style when
-     * we are applying the style to create a new shape.
-     */
-    void setInheritedKey(const GrShape& parentShape, bool stopAfterPE);
-
-    enum class Type {
-        kEmpty,
-        kRRect,
-        kPath,
-    } fType;
-
-    SkRRect                     fRRect;
-    SkTLazy<SkPath>             fPath;
-    GrStyle                     fStyle;
-    SkAutoSTArray<8, uint32_t>  fInheritedKey;
-};
-#endif