Attempt at getting GDI text to render when drawn using canvas. I added...

third_party/WebKit/WebCore/platform/graphics/skia/PlatformContextSkia.cpp

 /*
  * Copyright (c) 2008, 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:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * 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 "GraphicsContext.h"
+#include "ImageBuffer.h"
 #include "NativeImageSkia.h"
 #include "PlatformContextSkia.h"
 #include "SkiaUtils.h"
 
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
@@ skipping 35 matching lines @@
     SkPaint::Join m_lineJoin;
     SkDashPathEffect* m_dash;
 
     // Text. (See cTextFill & friends in GraphicsContext.h.)
     int m_textDrawingMode;
 
     // Helper function for applying the state's alpha value to the given input
     // color to produce a new output color.
     SkColor applyAlpha(SkColor) const;
 
+#if defined(__linux__) || PLATFORM(WIN_OS)
+    // If non-empty, the current State is clipped to this image.
+    SkBitmap m_imageBufferClip;
+    // If m_imageBufferClip is non-empty, this is the region the image is clipped to.
+    WebCore::FloatRect m_clip;
+#endif
+
 private:
     // Not supported.
     void operator=(const State&);
 };
 
 // Note: Keep theses default values in sync with GraphicsContextState.
 PlatformContextSkia::State::State()
     : m_alpha(1)
     , m_porterDuffMode(SkPorterDuff::kSrcOver_Mode)
     , m_gradient(0)
@@ skipping 42 matching lines @@
     int a = SkAlphaMul(SkColorGetA(c), s);
     return (c & 0x00FFFFFF) | (a << 24);
 }
 
 // PlatformContextSkia ---------------------------------------------------------
 
 // Danger: canvas can be NULL.
 PlatformContextSkia::PlatformContextSkia(skia::PlatformCanvas* canvas)
     : m_canvas(canvas)
     , m_stateStack(sizeof(State))
+#if PLATFORM(WIN_OS)
+    , m_drawingToImageBuffer(false)
+#endif
 {
     m_stateStack.append(State());
     m_state = &m_stateStack.last();
 #if defined(OS_LINUX)
     m_gdkskia = m_canvas ? gdk_skia_new(m_canvas) : 0;
 #endif
 }
 
 PlatformContextSkia::~PlatformContextSkia()
 {
 #if defined(OS_LINUX)
     if (m_gdkskia) {
         g_object_unref(m_gdkskia);
         m_gdkskia = 0;
     }
 #endif
 }
 
 void PlatformContextSkia::setCanvas(skia::PlatformCanvas* canvas)
 {
     m_canvas = canvas;
 }
 
+#if PLATFORM(WIN_OS)
+void PlatformContextSkia::setDrawingToImageBuffer(bool value)
+{
+    m_drawingToImageBuffer = value;
+}
+
+bool PlatformContextSkia::isDrawingToImageBuffer() const
+{
+    return m_drawingToImageBuffer;
+}
+#endif
+
 void PlatformContextSkia::save()
 {
     m_stateStack.append(*m_state);
     m_state = &m_stateStack.last();
 
     // Save our native canvas.
     canvas()->save();
 }
 
+#if defined(__linux__) || PLATFORM(WIN_OS)
+void PlatformContextSkia::beginLayerClippedToImage(const WebCore::FloatRect& rect,
+                                                   const WebCore::ImageBuffer* imageBuffer)
+{
+    // Skia doesn't support clipping to an image, so we create a layer. The next
+    // time restore is invoked the layer and |imageBuffer| are combined to
+    // create the resulting image.
+    m_state->m_clip = rect;
+    SkRect bounds = { SkFloatToScalar(rect.x()), SkFloatToScalar(rect.y()),
+                      SkFloatToScalar(rect.right()), SkFloatToScalar(rect.bottom()) };
+                      
+    canvas()->saveLayerAlpha(&bounds, 255,
+                             static_cast<SkCanvas::SaveFlags>(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag));
+    // Copy off the image as |imageBuffer| may be deleted before restore is invoked.
+    m_state->m_imageBufferClip = *(imageBuffer->context()->platformContext()->bitmap());
+}
+#endif
 void PlatformContextSkia::restore()
 {
+#if defined(__linux__) || PLATFORM(WIN_OS)
+    if (!m_state->m_imageBufferClip.empty()) {
+        applyClipFromImage(m_state->m_clip, m_state->m_imageBufferClip);
+        canvas()->restore();
+    }
+#endif
+
     m_stateStack.removeLast();
     m_state = &m_stateStack.last();
 
     // Restore our native canvas.
     canvas()->restore();
 }
 
 void PlatformContextSkia::drawRect(SkRect rect)
 {
     SkPaint paint;
@@ skipping 232 matching lines @@
 
 const SkBitmap* PlatformContextSkia::bitmap() const
 {
     return &m_canvas->getDevice()->accessBitmap(false);
 }
 
 bool PlatformContextSkia::isPrinting()
 {
     return m_canvas->getTopPlatformDevice().IsVectorial();
 }
+
+#if defined(__linux__) || PLATFORM(WIN_OS)
+void PlatformContextSkia::applyClipFromImage(const WebCore::FloatRect& rect, const SkBitmap& imageBuffer)
+{
+    // 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.setPorterDuffXfermode(SkPorterDuff::kDstIn_Mode);
+    m_canvas->drawBitmap(imageBuffer, SkFloatToScalar(rect.x()), SkFloatToScalar(rect.y()), &paint);
+}
+#endif