fix paths and remove dead code

core/fxge/skia/fx_skia_device.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/include/fxge/fx_ge.h"
 
 #if defined(_SKIA_SUPPORT_)
 #include "core/include/fxcodec/fx_codec.h"
 
 #include "core/fxge/agg/fx_agg_driver.h"
@@ skipping 14 matching lines @@
 static void DebugShowSkiaPath(const SkPath& path) {
 #if SHOW_SKIA_PATH
   char buffer[4096];
   sk_bzero(buffer, sizeof(buffer));
   SkMemoryWStream stream(buffer, sizeof(buffer));
   path.dump(&stream, false, false);
   printf("%s\n", buffer);
 #endif  // SHOW_SKIA_PATH
 }
 
+static void DebugShowCanvasMatrix(const SkCanvas* canvas) {
+#if SHOW_SKIA_PATH
+  SkMatrix matrix = canvas->getTotalMatrix();
+  SkScalar m[9];
+  matrix.get9(m);
+  printf("(%g,%g,%g) (%g,%g,%g) (%g,%g,%g)\n", m[0], m[1], m[2], m[3], m[4], m[5], m[6],
+         m[7], m[8]);
+#endif  // SHOW_SKIA_PATH
+}
+
 #if DRAW_SKIA_CLIP
 
 static SkPaint DebugClipPaint() {
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(SK_ColorGREEN);
   paint.setStyle(SkPaint::kStroke_Style);
   return paint;
 }
 
@@ skipping 10 matching lines @@
 #else  // DRAW_SKIA_CLIP
 
 static void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {}
 static void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {}
 
 #endif  // DRAW_SKIA_CLIP
 
 #undef SHOW_SKIA_PATH
 #undef DRAW_SKIA_CLIP
 
-static SkPath BuildPath(const CFX_PathData* pPathData,
-                        const CFX_Matrix* pObject2Device) {
+static SkPath BuildPath(const CFX_PathData* pPathData) {
   SkPath skPath;
   const CFX_PathData* pFPath = pPathData;
   int nPoints = pFPath->GetPointCount();
   FX_PATHPOINT* pPoints = pFPath->GetPoints();
   for (int i = 0; i < nPoints; i++) {
     FX_FLOAT x = pPoints[i].m_PointX;
     FX_FLOAT y = pPoints[i].m_PointY;
-    if (pObject2Device)
-      pObject2Device->Transform(x, y);
     int point_type = pPoints[i].m_Flag & FXPT_TYPE;
     if (point_type == FXPT_MOVETO) {
       skPath.moveTo(x, y);
     } else if (point_type == FXPT_LINETO) {
       skPath.lineTo(x, y);
     } else if (point_type == FXPT_BEZIERTO) {
       FX_FLOAT x2 = pPoints[i + 1].m_PointX, y2 = pPoints[i + 1].m_PointY;
       FX_FLOAT x3 = pPoints[i + 2].m_PointX, y3 = pPoints[i + 2].m_PointY;
-      if (pObject2Device) {
-        pObject2Device->Transform(x2, y2);
-        pObject2Device->Transform(x3, y3);
-      }
       skPath.cubicTo(x, y, x2, y2, x3, y3);
       i += 2;
     }
     if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE)
       skPath.close();
   }
   return skPath;
 }
 
 // convert a stroking path to scanlines
 void CFX_SkiaDeviceDriver::PaintStroke(SkPaint* spaint,
-                                       const CFX_GraphStateData* pGraphState) {
+                                       const CFX_GraphStateData* pGraphState,
+                                       const SkMatrix& matrix) {
   SkPaint::Cap cap;
   switch (pGraphState->m_LineCap) {
     case CFX_GraphStateData::LineCapRound:
       cap = SkPaint::kRound_Cap;
       break;
     case CFX_GraphStateData::LineCapSquare:
       cap = SkPaint::kSquare_Cap;
       break;
     default:
       cap = SkPaint::kButt_Cap;
       break;
   }
   SkPaint::Join join;
   switch (pGraphState->m_LineJoin) {
     case CFX_GraphStateData::LineJoinRound:
       join = SkPaint::kRound_Join;
       break;
     case CFX_GraphStateData::LineJoinBevel:
       join = SkPaint::kBevel_Join;
       break;
     default:
       join = SkPaint::kMiter_Join;
       break;
   }
-  FX_FLOAT width = pGraphState->m_LineWidth;
-
+  SkMatrix inverse;
+  if (!matrix.invert(&inverse)) {
+    return;  // give up if the matrix is degenerate, and not invertable
+  }

[dsinclair, 2016/03/17 14:39:31]

nit: no {}'s on single line body

[caryclark, 2016/03/17 15:52:51]

Done.

+  inverse.set(SkMatrix::kMTransX, 0);
+  inverse.set(SkMatrix::kMTransY, 0);
+  SkVector deviceUnits[2] = {{0, 1}, {1, 0}};
+  inverse.mapPoints(deviceUnits, SK_ARRAY_COUNT(deviceUnits));
+  FX_FLOAT width = SkTMax(pGraphState->m_LineWidth,
+                          SkTMin(deviceUnits[0].length(), deviceUnits[1].length()));
   if (pGraphState->m_DashArray) {
     int count = (pGraphState->m_DashCount + 1) / 2;
     SkScalar* intervals = FX_Alloc2D(SkScalar, count, sizeof(SkScalar));
     // Set dash pattern
     for (int i = 0; i < count; i++) {
       FX_FLOAT on = pGraphState->m_DashArray[i * 2];
       if (on <= 0.000001f)
         on = 1.f / 10;
       FX_FLOAT off = i * 2 + 1 == pGraphState->m_DashCount
                          ? on
@@ skipping 49 matching lines @@
   m_pCanvas = m_pRecorder->getRecordingCanvas();
   m_ditherBits = 0;
 }
 
 CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver() {
   if (!m_pRecorder)
     delete m_pCanvas;
   delete m_pAggDriver;
 }
 
+static SkMatrix ToSkMatrix(const CFX_Matrix& m) {
+    SkMatrix skMatrix;
+    skMatrix.setAll(m.a, m.b, m.e, m.c, m.d, m.f, 0, 0, 1);
+    return skMatrix;
+}
+
+// use when pdf's y-axis points up insead of down
+static SkMatrix ToFlippedSkMatrix(const CFX_Matrix& m) {
+    SkMatrix skMatrix;
+    skMatrix.setAll(m.a, m.b, m.e, -m.c, -m.d, m.f, 0, 0, 1);
+    return skMatrix;
+}
+
 FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars,
                                              const FXTEXT_CHARPOS* pCharPos,
                                              CFX_Font* pFont,
                                              CFX_FontCache* pCache,
                                              const CFX_Matrix* pObject2Device,
                                              FX_FLOAT font_size,
                                              FX_DWORD color,
                                              int alpha_flag,
                                              void* pIccTransform) {
   SkAutoTUnref<SkTypeface> typeface(SkTypeface::CreateFromStream(
       new SkMemoryStream(pFont->GetFontData(), pFont->GetSize())));
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(color);
   paint.setTypeface(typeface);
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint.setTextSize(font_size);
   m_pCanvas->save();
-  SkMatrix skMatrix;
-  const CFX_Matrix& m = *pObject2Device;
-  // note that PDF's y-axis goes up; Skia's y-axis goes down
-  skMatrix.setAll(m.a, m.b, m.e, -m.c, -m.d, m.f, 0, 0, 1);
+  SkMatrix skMatrix = ToFlippedSkMatrix(*pObject2Device);
   m_pCanvas->concat(skMatrix);
   for (int index = 0; index < nChars; ++index) {
     const FXTEXT_CHARPOS& cp = pCharPos[index];
     uint16_t glyph = (uint16_t)cp.m_GlyphIndex;
     m_pCanvas->drawText(&glyph, 2, cp.m_OriginX, cp.m_OriginY, paint);
   }
   m_pCanvas->restore();
   return TRUE;
 }
 
@@ skipping 14 matching lines @@
       return FXRC_GET_BITS | FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE |
              FXRC_BLEND_MODE | FXRC_SOFT_CLIP | FXRC_ALPHA_OUTPUT;
     case FXDC_DITHER_BITS:
       return m_ditherBits;
   }
   return 0;
 }
 
 void CFX_SkiaDeviceDriver::SaveState() {
   m_pCanvas->save();
-  if (m_pAggDriver)
-    m_pAggDriver->SaveState();
 }
 
 void CFX_SkiaDeviceDriver::RestoreState(FX_BOOL bKeepSaved) {
-  if (m_pAggDriver)
-    m_pAggDriver->RestoreState(bKeepSaved);
   m_pCanvas->restore();
   if (bKeepSaved)
     m_pCanvas->save();
 }
 
-void CFX_SkiaDeviceDriver::SetClipMask(
-    agg::rasterizer_scanline_aa& rasterizer) {
-  if (m_pAggDriver)
-    m_pAggDriver->SetClipMask(rasterizer);
-}
-
 FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(
     const CFX_PathData* pPathData,     // path info
     const CFX_Matrix* pObject2Device,  // flips object's y-axis
     int fill_mode                      // fill mode, WINDING or ALTERNATE
     ) {
   if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
     CFX_FloatRect rectf;
     if (pPathData->IsRect(pObject2Device, &rectf)) {
       rectf.Intersect(
           CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH),
                         (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
       // note that PDF's y-axis goes up; Skia's y-axis goes down
       SkRect skClipRect =
           SkRect::MakeLTRB(rectf.left, rectf.bottom, rectf.right, rectf.top);
       DebugDrawSkiaClipRect(m_pCanvas, skClipRect);
       m_pCanvas->clipRect(skClipRect);
       return TRUE;
     }
   }
-  SkPath skClipPath = BuildPath(pPathData, pObject2Device);
+  SkPath skClipPath = BuildPath(pPathData);
   skClipPath.setFillType((fill_mode & 3) == FXFILL_WINDING
                              ? SkPath::kWinding_FillType
                              : SkPath::kEvenOdd_FillType);
+  SkMatrix skMatrix = ToSkMatrix(*pObject2Device);
+  skClipPath.transform(skMatrix);
   DebugShowSkiaPath(skClipPath);
   DebugDrawSkiaClipPath(m_pCanvas, skClipPath);
   m_pCanvas->clipPath(skClipPath);
 
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,         // path info
     const CFX_Matrix* pObject2Device,      // optional transformation
     const CFX_GraphStateData* pGraphState  // graphic state, for pen attributes
     ) {
   // build path data
-  SkPath skPath = BuildPath(pPathData, NULL);
+  SkPath skPath = BuildPath(pPathData);
   skPath.setFillType(SkPath::kWinding_FillType);
 
+  SkMatrix skMatrix = ToSkMatrix(*pObject2Device);
   SkPaint spaint;
-  PaintStroke(&spaint, pGraphState);
+  PaintStroke(&spaint, pGraphState, skMatrix);
   SkPath dst_path;
   spaint.getFillPath(skPath, &dst_path);
+  dst_path.transform(skMatrix);
   DebugDrawSkiaClipPath(m_pCanvas, dst_path);
   m_pCanvas->clipPath(dst_path);
   return TRUE;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizer(
-    agg::rasterizer_scanline_aa& rasterizer,
-    FX_DWORD color,
-    FX_BOOL bFullCover,
-    FX_BOOL bGroupKnockout,
-    int alpha_flag,
-    void* pIccTransform) {
-  return m_pAggDriver &&
-         m_pAggDriver->RenderRasterizer(rasterizer, color, bFullCover,
-                                        bGroupKnockout, alpha_flag,
-                                        pIccTransform);
-}
-
 FX_BOOL CFX_SkiaDeviceDriver::DrawPath(
     const CFX_PathData* pPathData,          // path info
     const CFX_Matrix* pObject2Device,       // optional transformation
     const CFX_GraphStateData* pGraphState,  // graphic state, for pen attributes
     FX_DWORD fill_color,                    // fill color
     FX_DWORD stroke_color,                  // stroke color
     int fill_mode,  // fill mode, WINDING or ALTERNATE. 0 for not filled
     int alpha_flag,
     void* pIccTransform,
     int blend_type) {
   SkIRect rect;
   rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH),
            GetDeviceCaps(FXDC_PIXEL_HEIGHT));
-  SkPath skPath = BuildPath(pPathData, pObject2Device);
+  SkPath skPath = BuildPath(pPathData);
   SkPaint spaint;
   spaint.setAntiAlias(true);
+  m_pCanvas->save();
+  SkMatrix skMatrix = ToSkMatrix(*pObject2Device);
+  m_pCanvas->concat(skMatrix);
   if ((fill_mode & 3) && fill_color) {
     skPath.setFillType((fill_mode & 3) == FXFILL_WINDING
                            ? SkPath::kWinding_FillType
                            : SkPath::kEvenOdd_FillType);
 
     spaint.setStyle(SkPaint::kFill_Style);
     spaint.setColor(fill_color);
     m_pCanvas->drawPath(skPath, spaint);
   }
   int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag)
                          ? FXGETFLAG_ALPHA_STROKE(alpha_flag)
                          : FXARGB_A(stroke_color);
 
   if (pGraphState && stroke_alpha) {
     spaint.setColor(stroke_color);
-    PaintStroke(&spaint, pGraphState);
+    PaintStroke(&spaint, pGraphState, skMatrix);
+    DebugShowSkiaPath(skPath);
+    DebugShowCanvasMatrix(m_pCanvas);
     m_pCanvas->drawPath(skPath, spaint);
   }
-
+  m_pCanvas->restore();
   return TRUE;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::SetPixel(int x,
-                                       int y,
-                                       FX_DWORD color,
-                                       int alpha_flag,
-                                       void* pIccTransform) {
-  return m_pAggDriver &&
-         m_pAggDriver->SetPixel(x, y, color, alpha_flag, pIccTransform);
-}
-
 FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect,
                                        FX_DWORD fill_color,
                                        int alpha_flag,
                                        void* pIccTransform,
                                        int blend_type) {
   SkPaint spaint;
   spaint.setAntiAlias(true);
   spaint.setColor(fill_color);
 
   m_pCanvas->drawRect(
@@ skipping 120 matching lines @@
   m_pCanvas->concat(skMatrix);
   const CFX_Matrix& m = *pMatrix;
   // note that PDF's y-axis goes up; Skia's y-axis goes down
   if (landscape)
     skMatrix.setAll(-m.a, -m.b, m.e, m.c, m.d, m.f, 0, 0, 1);
   else
     skMatrix.setAll(m.a, m.b, 0, -m.c, -m.d, 0, 0, 0, 1);
   m_pCanvas->concat(skMatrix);
   SkPaint paint;
   paint.setAntiAlias(true);
-  paint.setFilterQuality(kLow_SkFilterQuality);
+  paint.setFilterQuality(kHigh_SkFilterQuality);
   m_pCanvas->drawBitmap(skBitmap, 0, 0, &paint);
   m_pCanvas->restore();
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
   return m_pAggDriver && m_pAggDriver->ContinueDIBits(pHandle, pPause);
 }
 
 void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle) {
@@ skipping 48 matching lines @@
   SetDeviceDriver(pDriver);
   return TRUE;
 }
 
 CFX_SkiaDevice::~CFX_SkiaDevice() {
   if (m_bOwnedBitmap && GetBitmap())
     delete GetBitmap();
 }
 
 #endif