Miscellaneous cleanup to reduce number of includes in platform/graphics/

Source/core/platform/graphics/GraphicsContext.h

 /*
  * Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008-2009 Torch Mobile, Inc.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 10 matching lines @@
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef GraphicsContext_h
 #define GraphicsContext_h
 
-#include "core/platform/chromium/TraceEvent.h"
+#include "core/platform/graphics/AnnotationMode.h"
+#include "core/platform/graphics/CustomFontNotReadyAction.h"
 #include "core/platform/graphics/DashArray.h"
 #include "core/platform/graphics/DrawLooper.h"
 #include "core/platform/graphics/FloatRect.h"
-#include "core/platform/graphics/Font.h"
-#include "core/platform/graphics/GraphicsContextAnnotation.h"
 #include "core/platform/graphics/GraphicsContextState.h"
-#include "core/platform/graphics/ImageBuffer.h"
+#include "core/platform/graphics/Image.h"
 #include "core/platform/graphics/ImageOrientation.h"
+#include "core/platform/graphics/RoundedRect.h"
+#include "core/platform/graphics/WindRule.h"
 #include "core/platform/graphics/skia/OpaqueRegionSkia.h"
 
 #include <wtf/Noncopyable.h>
 #include <wtf/PassOwnPtr.h>
 
 class SkBitmap;
 class SkDevice;
+class SkDrawLooper;
 class SkPaint;
 class SkPath;
 class SkRRect;
 struct SkRect;
 
 namespace WebCore {
 
+class Font;
+class GraphicsContextAnnotation;
 class ImageBuffer;
 class KURL;
+class Path;
+class TextRun;
+class TextRunPaintInfo;
 
 class GraphicsContext {
     WTF_MAKE_NONCOPYABLE(GraphicsContext); WTF_MAKE_FAST_ALLOCATED;
 public:
     enum AntiAliasingMode {
         NotAntiAliased,
         AntiAliased
     };
     enum AccessMode {
         ReadOnly,
@@ skipping 28 matching lines @@
     void saveLayer(const SkRect* bounds, const SkPaint*, SkCanvas::SaveFlags = SkCanvas::kARGB_ClipLayer_SaveFlag);
     void restoreLayer();
 
     float strokeThickness() const { return m_state->m_strokeData.thickness(); }
     void setStrokeThickness(float thickness) { m_state->m_strokeData.setThickness(thickness); }
 
     StrokeStyle strokeStyle() const { return m_state->m_strokeData.style(); }
     void setStrokeStyle(StrokeStyle style) { m_state->m_strokeData.setStyle(style); }
 
     Color strokeColor() const { return m_state->m_strokeData.color(); }
-    void setStrokeColor(const Color&);
+    void setStrokeColor(const Color& color) { m_state->m_strokeData.setColor(color); }
+    SkColor effectiveStrokeColor() const;
 
     Pattern* strokePattern() const { return m_state->m_strokeData.pattern(); }
     void setStrokePattern(PassRefPtr<Pattern>);
 
     Gradient* strokeGradient() const { return m_state->m_strokeData.gradient(); }
     void setStrokeGradient(PassRefPtr<Gradient>);
 
     void setLineCap(LineCap cap) { m_state->m_strokeData.setLineCap(cap); }
     void setLineDash(const DashArray& dashes, float dashOffset) { m_state->m_strokeData.setLineDash(dashes, dashOffset); }
     void setLineJoin(LineJoin join) { m_state->m_strokeData.setLineJoin(join); }
     void setMiterLimit(float limit) { m_state->m_strokeData.setMiterLimit(limit); }
 
     WindRule fillRule() const { return m_state->m_fillRule; }
     void setFillRule(WindRule fillRule) { m_state->m_fillRule = fillRule; }
 
     Color fillColor() const { return m_state->m_fillColor; }
     void setFillColor(const Color&);
-    SkColor effectiveFillColor() const { return m_state->applyAlpha(m_state->m_fillColor.rgb()); }
+    SkColor effectiveFillColor() const;
 
     void setFillPattern(PassRefPtr<Pattern>);
     Pattern* fillPattern() const { return m_state->m_fillPattern.get(); }
 
     void setFillGradient(PassRefPtr<Gradient>);
     Gradient* fillGradient() const { return m_state->m_fillGradient.get(); }
 
     SkDrawLooper* drawLooper() const { return m_state->m_looper; }
-    SkColor effectiveStrokeColor() const { return m_state->applyAlpha(m_state->m_strokeData.color().rgb()); }
 
     int getNormalizedAlpha() const;
 
     bool getClipBounds(SkRect* bounds) const;
     const SkMatrix& getTotalMatrix() const;
     bool isPrintingDevice() const;
 
     void setShouldAntialias(bool antialias) { m_state->m_shouldAntialias = antialias; }
     bool shouldAntialias() const { return m_state->m_shouldAntialias; }
 
@@ skipping 132 matching lines @@
     void clipRoundedRect(const RoundedRect&);
     void clipOut(const IntRect& rect) { clipRect(rect, NotAntiAliased, SkRegion::kDifference_Op); }
     void clipOutRoundedRect(const RoundedRect&);
     void clipPath(const Path&, WindRule = RULE_EVENODD);
     void clipConvexPolygon(size_t numPoints, const FloatPoint*, bool antialias = true);
     void clipToImageBuffer(const ImageBuffer*, const FloatRect&);
     bool clipRect(const SkRect&, AntiAliasingMode = NotAntiAliased, SkRegion::Op = SkRegion::kIntersect_Op);
 
     void drawText(const Font&, const TextRunPaintInfo&, const FloatPoint&);
     void drawEmphasisMarks(const Font&, const TextRunPaintInfo&, const AtomicString& mark, const FloatPoint&);
-    void drawBidiText(const Font&, const TextRunPaintInfo&, const FloatPoint&, Font::CustomFontNotReadyAction = Font::DoNotPaintIfFontNotReady);
+    void drawBidiText(const Font&, const TextRunPaintInfo&, const FloatPoint&, CustomFontNotReadyAction = DoNotPaintIfFontNotReady);
     void drawHighlightForText(const Font&, const TextRun&, const FloatPoint&, int h, const Color& backgroundColor, int from = 0, int to = -1);
 
     void drawLineForText(const FloatPoint&, float width, bool printing);
     enum DocumentMarkerLineStyle {
         DocumentMarkerSpellingLineStyle,
         DocumentMarkerGrammarLineStyle
     };
     void drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle);
 
     void beginTransparencyLayer(float opacity);
@@ skipping 25 matching lines @@
 
     // This clip function is used only by <canvas> code. It allows
     // implementations to handle clipping on the canvas differently since
     // the discipline is different.
     void canvasClip(const Path&, WindRule = RULE_EVENODD);
     void clipOut(const Path&);
 
     // ---------- Transformation methods -----------------
     enum IncludeDeviceScale { DefinitelyIncludeDeviceScale, PossiblyIncludeDeviceScale };
     AffineTransform getCTM(IncludeDeviceScale includeScale = PossiblyIncludeDeviceScale) const;
-    void concatCTM(const AffineTransform& affine) { concat(affine); }
-    void setCTM(const AffineTransform& affine) { setMatrix(affine); }
-    void setMatrix(const SkMatrix&);
+    void concatCTM(const AffineTransform&);
+    void setCTM(const AffineTransform&);
 
     void scale(const FloatSize&);
     void rotate(float angleInRadians);
     void translate(const FloatSize& size) { translate(size.width(), size.height()); }
     void translate(float x, float y);
 
     // This function applies the device scale factor to the context, making the context capable of
     // acting as a base-level context for a HiDPI environment.
     void applyDeviceScaleFactor(float deviceScaleFactor) { scale(FloatSize(deviceScaleFactor, deviceScaleFactor)); }
     // ---------- End transformation methods -----------------
@@ skipping 56 matching lines @@
     // Helpers for drawing a focus ring (drawFocusRing)
     void drawOuterPath(const SkPath&, SkPaint&, int);
     void drawInnerPath(const SkPath&, SkPaint&, int);
 
     // SkCanvas wrappers.
     bool isDrawingToLayer() const { return m_canvas->isDrawingToLayer(); }
 
     bool clipPath(const SkPath&, AntiAliasingMode = NotAntiAliased, SkRegion::Op = SkRegion::kIntersect_Op);
     bool clipRRect(const SkRRect&, AntiAliasingMode = NotAntiAliased, SkRegion::Op = SkRegion::kIntersect_Op);
 
-    bool concat(const SkMatrix&);
-
     // Used when restoring and the state has an image clip. Only shows the pixels in
     // m_canvas that are also in imageBuffer.
     // The clipping rectangle is given in absolute coordinates.
     void applyClipFromImage(const SkRect&, const SkBitmap&);
 
     // common code between setupPaintFor[Filling,Stroking]
     void setupShader(SkPaint*, Gradient*, Pattern*, SkColor) const;
 
     // Apply deferred saves
     void realizeSave(SkCanvas::SaveFlags flags)
@@ skipping 44 matching lines @@
     // FIXME: Make this go away: crbug.com/236892
     bool m_updatingControlTints : 1;
     bool m_accelerated : 1;
     bool m_isCertainlyOpaque : 1;
     bool m_printing : 1;
 };
 
 } // namespace WebCore
 
 #endif // GraphicsContext_h