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

Source/core/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 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.
  */
 
 #include "config.h"
 #include "core/platform/graphics/GraphicsContext.h"
 
+#include "core/platform/chromium/TraceEvent.h"
 #include "core/platform/graphics/BitmapImage.h"
+#include "core/platform/graphics/Font.h"
 #include "core/platform/graphics/Gradient.h"
+#include "core/platform/graphics/GraphicsContextAnnotation.h"
 #include "core/platform/graphics/ImageBuffer.h"
 #include "core/platform/graphics/IntRect.h"
+#include "core/platform/graphics/Path.h"
+#include "core/platform/graphics/Pattern.h"
 #include "core/platform/graphics/RoundedRect.h"
+#include "core/platform/graphics/TextRun.h"
 #include "core/platform/graphics/TextRunIterator.h"
 #include "core/platform/graphics/skia/SkiaUtils.h"
 #include "core/platform/text/BidiResolver.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
+#include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/effects/SkBlurMaskFilter.h"
 #include "third_party/skia/include/effects/SkCornerPathEffect.h"
 #include "weborigin/KURL.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 #if OS(DARWIN)
 #include <ApplicationServices/ApplicationServices.h>
 #endif
 
 using namespace std;
 
 namespace WebCore {
 
+// Helper function for applying the state's alpha value to the given input
+// color to produce a new output color.
+static SkColor applyAlpha(SkColor c, float alpha)
+{
+    int s = roundf(alpha * 256);
+    if (s >= 256)
+        return c;
+    if (s < 0)
+        return 0;
+
+    int a = SkAlphaMul(SkColorGetA(c), s);
+    return (c & 0x00FFFFFF) | (a << 24);
+}
+
 struct GraphicsContext::DeferredSaveState {
     DeferredSaveState(unsigned mask, int count) : m_flags(mask), m_restoreCount(count) { }
 
     unsigned m_flags;
     int m_restoreCount;
 };
 
 GraphicsContext::GraphicsContext(SkCanvas* canvas)
     : m_canvas(canvas)
     , m_deferredSaveFlags(0)
@@ skipping 125 matching lines @@
         return;
 
     canvas()->endCommentGroup();
 
     ASSERT(m_annotationCount > 0);
 #if !ASSERT_DISABLED
     --m_annotationCount;
 #endif
 }
 
-void GraphicsContext::setStrokeColor(const Color& color)
+SkColor GraphicsContext::effectiveStrokeColor() const
 {
-    m_state->m_strokeData.setColor(color);
-    m_state->m_strokeData.clearGradient();
-    m_state->m_strokeData.clearPattern();
+    return applyAlpha(m_state->m_strokeData.color().rgb(), m_state->m_alpha);
 }
 
 void GraphicsContext::setStrokePattern(PassRefPtr<Pattern> pattern)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(pattern);
     if (!pattern) {
         setStrokeColor(Color::black);
         return;
     }
-    m_state->m_strokeData.clearGradient();
     m_state->m_strokeData.setPattern(pattern);
 }
 
 void GraphicsContext::setStrokeGradient(PassRefPtr<Gradient> gradient)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(gradient);
     if (!gradient) {
         setStrokeColor(Color::black);
         return;
     }
     m_state->m_strokeData.setGradient(gradient);
-    m_state->m_strokeData.clearPattern();
 }
 
 void GraphicsContext::setFillColor(const Color& color)
 {
     m_state->m_fillColor = color;
     m_state->m_fillGradient.clear();
     m_state->m_fillPattern.clear();
 }
 
+SkColor GraphicsContext::effectiveFillColor() const
+{
+    return applyAlpha(m_state->m_fillColor.rgb(), m_state->m_alpha);
+}
+
 void GraphicsContext::setFillPattern(PassRefPtr<Pattern> pattern)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(pattern);
     if (!pattern) {
         setFillColor(Color::black);
         return;
     }
@@ skipping 116 matching lines @@
 }
 
 bool GraphicsContext::readPixels(SkBitmap* bitmap, int x, int y, SkCanvas::Config8888 config8888)
 {
     if (paintingDisabled())
         return false;
 
     return m_canvas->readPixels(bitmap, x, y, config8888);
 }
 
-void GraphicsContext::setMatrix(const SkMatrix& matrix)
+void GraphicsContext::setCTM(const AffineTransform& transform)
 {
     if (paintingDisabled())
         return;
 
     realizeSave(SkCanvas::kMatrix_SaveFlag);
-
-    m_canvas->setMatrix(matrix);
+    m_canvas->setMatrix(transform);
 }
 
-bool GraphicsContext::concat(const SkMatrix& matrix)
+void GraphicsContext::concatCTM(const AffineTransform& transform)
 {
     if (paintingDisabled())
-        return false;
+        return;
 
     realizeSave(SkCanvas::kMatrix_SaveFlag);
-
-    return m_canvas->concat(matrix);
+    m_canvas->concat(transform);
 }
 
 void GraphicsContext::beginTransparencyLayer(float opacity)
 {
     if (paintingDisabled())
         return;
 
     // We need the "alpha" layer flag here because the base layer is opaque
     // (the surface of the page) but layers on top may have transparent parts.
     // Without explicitly setting the alpha flag, the layer will inherit the
@@ skipping 505 matching lines @@
 }
 
 void GraphicsContext::drawEmphasisMarks(const Font& font, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point)
 {
     if (paintingDisabled())
         return;
 
     font.drawEmphasisMarks(this, runInfo, mark, point);
 }
 
-void GraphicsContext::drawBidiText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point, Font::CustomFontNotReadyAction customFontNotReadyAction)
+void GraphicsContext::drawBidiText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point, CustomFontNotReadyAction customFontNotReadyAction)
 {
     if (paintingDisabled())
         return;
 
     // sub-run painting is not supported for Bidi text.
     const TextRun& run = runInfo.run;
     ASSERT((runInfo.from == 0) && (runInfo.to == run.length()));
     BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
     bidiResolver.setStatus(BidiStatus(run.direction(), run.directionalOverride()));
     bidiResolver.setPositionIgnoringNestedIsolates(TextRunIterator(&run, 0));
@@ skipping 930 matching lines @@
 
     if (grad) {
         shader = grad->shader();
         color = SK_ColorBLACK;
     } else if (pat) {
         shader = pat->shader();
         color = SK_ColorBLACK;
         paint->setFilterBitmap(imageInterpolationQuality() != InterpolationNone);
     }
 
-    paint->setColor(m_state->applyAlpha(color));
+    paint->setColor(applyAlpha(color, m_state->m_alpha));
     paint->setShader(shader);
 }
 
 
 void GraphicsContext::applyClipFromImage(const SkRect& rect, const SkBitmap& imageBuffer)
 {
     if (paintingDisabled())
         return;
 
     // NOTE: this assumes the image mask contains opaque black for the portions that are to be shown, as such we
     // only look at the alpha when compositing. I'm not 100% sure this is what WebKit expects for image clipping.
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
     realizeSave(SkCanvas::kMatrixClip_SaveFlag);
     m_canvas->save(SkCanvas::kMatrix_SaveFlag);
     m_canvas->resetMatrix();
     m_canvas->drawBitmapRect(imageBuffer, 0, rect, &paint);
     m_canvas->restore();
 }
 
 void GraphicsContext::didDrawTextInRect(const SkRect& textRect)
 {
     if (m_trackTextRegion) {
         TRACE_EVENT0("skia", "PlatformContextSkia::trackTextRegion");
         m_textRegion.join(textRect);
     }
 }
 
 }