diff --git a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkEdgeBuilder.cpp b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkEdgeBuilder.cpp
index 853f5409fc..998f358cd4 100644
--- a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkEdgeBuilder.cpp
+++ b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkEdgeBuilder.cpp
@@ -359,12 +359,19 @@ static void handle_quad(SkEdgeBuilder* builder, const SkPoint pts[3]) {
 
 int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
                          bool canCullToTheRight, EdgeType edgeType) {
+    FILE *fout = fopen("/tmp/stacklog", "a+");
+    fprintf(fout, "%s(path@0x%X, iclip@0x%X, shiftUp=%d, canCullToTheRight=%d, edgeType=%d)\n", __PRETTY_FUNCTION__, &path, iclip, shiftUp, canCullToTheRight, edgeType);
+    if (iclip)
+        fprintf(fout, "%s iclip: fLeft=%d fTop=%d fRight=%d fBottom=%d\n", __FUNCTION__, iclip->fLeft, iclip->fTop, iclip->fRight, iclip->fBottom);
+    fclose(fout);
+
     fAlloc.reset();
     fList.reset();
     fShiftUp = shiftUp;
     fEdgeType = edgeType;
 
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks()) {
+        fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s calling buildPoly\n", __FUNCTION__); fclose(fout);
         return this->buildPoly(path, iclip, shiftUp, canCullToTheRight);
     }
 
@@ -374,6 +381,7 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s &pts[5]=%p\n", __FUNCTION__, &pts[5]); fclose(fout);
 
     if (iclip) {
         SkRect clip;
@@ -384,20 +392,24 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
             switch (verb) {
                 case SkPath::kMove_Verb:
                 case SkPath::kClose_Verb:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s iclip, SkPath::kMove_Verb,kClose_Verb\n", __FUNCTION__); fclose(fout);
                     // we ignore these, and just get the whole segment from
                     // the corresponding line/quad/cubic verbs
                     break;
                 case SkPath::kLine_Verb:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s iclip, SkPath::kLine_Verb\n", __FUNCTION__); fclose(fout);
                     if (clipper.clipLine(pts[0], pts[1], clip)) {
                         this->addClipper(&clipper);
                     }
                     break;
                 case SkPath::kQuad_Verb:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s iclip, SkPath::kQuad_Verb\n", __FUNCTION__); fclose(fout);
                     if (clipper.clipQuad(pts, clip)) {
                         this->addClipper(&clipper);
                     }
                     break;
                 case SkPath::kConic_Verb: {
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s iclip, SkPath::kConic_Verb\n", __FUNCTION__); fclose(fout);
                     const SkPoint* quadPts = quadder.computeQuads(
                                           pts, iter.conicWeight(), conicTol);
                     for (int i = 0; i < quadder.countQuads(); ++i) {
@@ -408,11 +420,13 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
                     }
                 } break;
                 case SkPath::kCubic_Verb:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s iclip, SkPath::kCubic_Verb\n", __FUNCTION__); fclose(fout);
                     if (clipper.clipCubic(pts, clip)) {
                         this->addClipper(&clipper);
                     }
                     break;
                 default:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s iclip, unexpected verb\n", __FUNCTION__); fclose(fout);
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
@@ -422,17 +436,21 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
             switch (verb) {
                 case SkPath::kMove_Verb:
                 case SkPath::kClose_Verb:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s no iclip, SkPath::kMove_Verb,kClose_Verb\n", __FUNCTION__); fclose(fout);
                     // we ignore these, and just get the whole segment from
                     // the corresponding line/quad/cubic verbs
                     break;
                 case SkPath::kLine_Verb:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s no iclip, SkPath::kLine_Verb\n", __FUNCTION__); fclose(fout);
                     this->addLine(pts);
                     break;
                 case SkPath::kQuad_Verb: {
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s no iclip, SkPath::kQuad_Verb\n", __FUNCTION__); fclose(fout);
                     handle_quad(this, pts);
                     break;
                 }
                 case SkPath::kConic_Verb: {
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s no iclip, SkPath::kConic_Verb\n", __FUNCTION__); fclose(fout);
                     const SkPoint* quadPts = quadder.computeQuads(
                                           pts, iter.conicWeight(), conicTol);
                     for (int i = 0; i < quadder.countQuads(); ++i) {
@@ -442,23 +460,28 @@ int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, int shiftUp,
                 } break;
                 case SkPath::kCubic_Verb: {
                     if (fEdgeType == kBezier) {
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s no iclip, SkPath::kCubic_Verb kBezier\n", __FUNCTION__); fclose(fout);
                         this->addCubic(pts);
                         break;
                     }
                     SkPoint monoY[10];
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s &monoY[11]=%p\n", __FUNCTION__, &monoY[11]); fclose(fout);
                     int n = SkChopCubicAtYExtrema(pts, monoY);
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s no iclip, SkPath::kCubic_Verb SkChopCubicAtYExtrema returns %d\n", __FUNCTION__, n); fclose(fout);
                     for (int i = 0; i <= n; i++) {
                         this->addCubic(&monoY[i * 3]);
                     }
                     break;
                 }
                 default:
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s no iclip, unexpected verb\n", __FUNCTION__); fclose(fout);
                     SkDEBUGFAIL("unexpected verb");
                     break;
             }
         }
     }
     fEdgeList = fList.begin();
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s returning %d with fEdgeList=0x%X\n", __FUNCTION__, fIsFinite ? fList.count() : 0, fEdgeList); fclose(fout);
     return fIsFinite ? fList.count() : 0;
 }
 
diff --git a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkGeometry.cpp b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkGeometry.cpp
index ace8a7d4d8..26f0df5b16 100644
--- a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkGeometry.cpp
+++ b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkGeometry.cpp
@@ -415,8 +415,10 @@ void SkChopCubicAt(const SkPoint src[4], SkPoint dst[7], SkScalar t) {
     }
  */
 
+#include <stdio.h>
 void SkChopCubicAt(const SkPoint src[4], SkPoint dst[],
                    const SkScalar tValues[], int roots) {
+    FILE *fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s roots=%d\n", __FUNCTION__, roots); fclose(fout);
 #ifdef SK_DEBUG
     {
         for (int i = 0; i < roots - 1; i++)
@@ -430,6 +432,7 @@ void SkChopCubicAt(const SkPoint src[4], SkPoint dst[],
 
     if (dst) {
         if (roots == 0) { // nothing to chop
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s memcpy(%p, %p, %d)\n", __FUNCTION__, dst, src, 4*sizeof(SkPoint)); fclose(fout);
             memcpy(dst, src, 4*sizeof(SkPoint));
         } else {
             SkScalar    t = tValues[0];
@@ -443,12 +446,14 @@ void SkChopCubicAt(const SkPoint src[4], SkPoint dst[],
 
                 dst += 3;
                 // have src point to the remaining cubic (after the chop)
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s memcpy(%p, %p, %d)\n", __FUNCTION__, tmp, dst, 4 * sizeof(SkPoint)); fclose(fout);
                 memcpy(tmp, dst, 4 * sizeof(SkPoint));
                 src = tmp;
 
                 // watch out in case the renormalized t isn't in range
                 if (!valid_unit_divide(tValues[i+1] - tValues[i],
                                        SK_Scalar1 - tValues[i], &t)) {
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s degenerate cubic &dst[6]=%p, &dst[7]=%p\n", __FUNCTION__, &dst[6], &dst[7]); fclose(fout);
                     // if we can't, just create a degenerate cubic
                     dst[4] = dst[5] = dst[6] = src[3];
                     break;
@@ -463,6 +468,7 @@ void SkChopCubicAtHalf(const SkPoint src[4], SkPoint dst[7]) {
 }
 
 static void flatten_double_cubic_extrema(SkScalar coords[14]) {
+    FILE *fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s(%p), &coords[9]=0x%X \n", __FUNCTION__, coords, &coords[9]); fclose(fout);
     coords[4] = coords[8] = coords[6];
 }
 
@@ -476,9 +482,12 @@ static void flatten_double_cubic_extrema(SkScalar coords[14]) {
 */
 int SkChopCubicAtYExtrema(const SkPoint src[4], SkPoint dst[10]) {
     SkScalar    tValues[2];
+    FILE *fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s src[0..3].fY= %f, %f, %f, %f\n", __FUNCTION__, src[0].fY, src[1].fY, src[2].fY, src[3].fY); fclose(fout);
+
     int         roots = SkFindCubicExtrema(src[0].fY, src[1].fY, src[2].fY,
                                            src[3].fY, tValues);
 
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s roots=%d\n", __FUNCTION__, roots); fclose(fout);
     SkChopCubicAt(src, dst, tValues, roots);
     if (dst && roots > 0) {
         // we do some cleanup to ensure our Y extrema are flat
diff --git a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_AntiPath.cpp b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_AntiPath.cpp
index 13ca3c8b9a..906232f45b 100644
--- a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_AntiPath.cpp
+++ b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_AntiPath.cpp
@@ -488,8 +488,11 @@ static inline void saturated_add(uint8_t* ptr, U8CPU add) {
 // minimum count before we want to setup an inner loop, adding 4-at-a-time
 #define MIN_COUNT_FOR_QUAD_LOOP  16
 
+#include <execinfo.h>
+#include <stdio.h>
 static void add_aa_span(uint8_t* alpha, U8CPU startAlpha, int middleCount,
                         U8CPU stopAlpha, U8CPU maxValue) {
+label: FILE *fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s@%p(alpha@%p=%u,startAlpha=0x%X,middleCount=%d,stopAlpha=0x%X,maxValue=0x%X)\n", __FUNCTION__, &&label, alpha, *alpha, startAlpha, middleCount, stopAlpha, maxValue); fclose(fout);
     SkASSERT(middleCount >= 0);
 
     saturated_add(alpha, startAlpha);
@@ -503,6 +506,10 @@ static void add_aa_span(uint8_t* alpha, U8CPU startAlpha, int middleCount,
             middleCount -= 1;
         }
 
+    static void *backtrace_before[64], *backtrace_after[64];
+    unsigned calldepth_before, calldepth_after;
+    calldepth_before = backtrace(backtrace_before, sizeof(backtrace_before)/sizeof(backtrace_before[0]));
+
         int bigCount = middleCount >> 2;
         uint32_t* qptr = reinterpret_cast<uint32_t*>(alpha);
         uint32_t qval = quadplicate_byte(maxValue);
@@ -510,6 +517,24 @@ static void add_aa_span(uint8_t* alpha, U8CPU startAlpha, int middleCount,
             *qptr++ += qval;
         } while (--bigCount > 0);
 
+    calldepth_after = backtrace(backtrace_after, sizeof(backtrace_after)/sizeof(backtrace_after[0]));
+    if (calldepth_before != calldepth_after || memcmp(backtrace_before, backtrace_after, calldepth_before * sizeof(void *))) {
+        FILE *fout = fopen("/tmp/stacklog", "a+");
+        fprintf(fout, "add_aa_span: calldepth_before %u, calldepth_after %u!\n", calldepth_before, calldepth_after);
+        fprintf(fout, "add_aa_span: backtrace_before [0..7] 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
+                        backtrace_before[0], backtrace_before[1], backtrace_before[2], backtrace_before[3],
+                        backtrace_before[4], backtrace_before[5], backtrace_before[6], backtrace_before[7]);
+        fprintf(fout, "add_aa_span: backtrace_after  [0..7] 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X\n",
+                        backtrace_after[0], backtrace_after[1], backtrace_after[2], backtrace_after[3],
+                        backtrace_after[4], backtrace_after[5], backtrace_after[6], backtrace_after[7]);
+        fprintf(fout, "add_aa_span differences: (middleCount=%u): ", middleCount);
+        for (int i = 0; i < calldepth_before; i++)
+            if (backtrace_before[i] != backtrace_after[i])
+                fprintf(fout, "[%u] 0x%X!=0x%X, ", i, backtrace_before[i], backtrace_after[i]);
+        fprintf(fout, "\n\n");
+        fclose(fout);
+    }
+
         middleCount &= 3;
         alpha = reinterpret_cast<uint8_t*> (qptr);
         // fall through to the following while-loop
@@ -527,7 +552,9 @@ static void add_aa_span(uint8_t* alpha, U8CPU startAlpha, int middleCount,
     saturated_add(alpha, stopAlpha);
 }
 
+#include <stdio.h>
 void MaskSuperBlitter::blitH(int x, int y, int width) {
+label: FILE *fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s@%p(x=%d,y=%d,width=%d)\n", __FUNCTION__, &&label, x, y, width); fclose(fout);
     int iy = (y >> SHIFT);
 
     SkASSERT(iy >= fMask.fBounds.fTop && iy < fMask.fBounds.fBottom);
@@ -685,10 +712,17 @@ static bool ShouldUseAAA(const SkPath& path) {
     return path.countPoints() < SkTMax(bounds.width(), bounds.height()) / 2 - 10;
 }
 
+#include <stdio.h>
 void SkScan::SAAFillPath(const SkPath& path, SkBlitter* blitter, const SkIRect& ir,
                   const SkIRect& clipBounds, bool forceRLE) {
     bool containedInClip = clipBounds.contains(ir);
     bool isInverse = path.isInverseFillType();
+    FILE *fout = fopen("/tmp/stacklog", "a+");
+    fprintf(fout, "%s@%p(path@0x%X, blitter@0x%X, ir@0x%X, clipBounds@0x%X, forceRLE=0x%X)\n", __FUNCTION__, SkScan::SAAFillPath, &path, blitter, &ir, &clipBounds, forceRLE);
+    fprintf(fout, "ir        -> left=%d, top=%d, right=%d, bottom=%d\n", ir.left(), ir.top(), ir.right(), ir.bottom());
+    fprintf(fout, "clipBounds-> left=%d, top=%d, right=%d, bottom=%d\n", clipBounds.left(), clipBounds.top(), clipBounds.right(), clipBounds.bottom());
+    fprintf(fout, "containedInClip=%u, isInverse=%u\n", containedInClip, isInverse);
+    fclose(fout);
 
     // MaskSuperBlitter can't handle drawing outside of ir, so we can't use it
     // if we're an inverse filltype
diff --git a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_Path.cpp b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_Path.cpp
index eaaa5c9b62..52f32277b4 100644
--- a/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_Path.cpp
+++ b/qtwebengine/src/3rdparty/chromium/third_party/skia/src/core/SkScan_Path.cpp
@@ -220,7 +220,9 @@ static bool update_edge(SkEdge* edge, int last_y) {
     } while (0)
 
 // Needs Y to only change once (looser than convex in X)
+#include <stdio.h>
 static void walk_simple_edges(SkEdge* prevHead, SkBlitter* blitter, int start_y, int stop_y) {
+    FILE *fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s@%p(prevHead@0x%X,blitter@0x%X,start_y=%d,stop_y=%d)\n", __FUNCTION__, walk_simple_edges, prevHead, blitter, start_y, stop_y); fclose(fout);
     validate_sort(prevHead->fNext);
 
     SkEdge* leftE = prevHead->fNext;
@@ -237,6 +239,7 @@ static void walk_simple_edges(SkEdge* prevHead, SkBlitter* blitter, int start_y,
 #endif
     ASSERT_RETURN(local_top >= start_y);
 
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s: leftE@%p, riteE@%p, currE@%p, local_top=%d\n", __FUNCTION__, leftE, riteE, currE, local_top); fclose(fout);
     while (local_top < stop_y) {
         SkASSERT(leftE->fFirstY <= stop_y);
         SkASSERT(riteE->fFirstY <= stop_y);
@@ -251,6 +254,7 @@ static void walk_simple_edges(SkEdge* prevHead, SkBlitter* blitter, int start_y,
         SkFixed dRite = riteE->fDX;
         int count = local_bot - local_top;
         ASSERT_RETURN(count >= 0);
+    fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s: leftE->fLastY=%d, riteE->fLastY=%d, local_bot=%d, left=%g, dLeft=%g, rite=%g, dRite=%g, count=%d\n", __FUNCTION__, leftE->fLastY, riteE->fLastY, local_bot, SkFixedToFloat(left), SkFixedToFloat(dLeft), SkFixedToFloat(rite), SkFixedToFloat(dRite), count); fclose(fout);
 
         if (0 == (dLeft | dRite)) {
             int L = SkFixedRoundToInt(left);
@@ -385,21 +389,32 @@ static bool operator<(const SkEdge& a, const SkEdge& b) {
 }
 
 static SkEdge* sort_edges(SkEdge* list[], int count, SkEdge** last) {
+    FILE *fout = fopen("/tmp/stacklog", "a+");
+    for (int i = 0; i < count; i++)
+        fprintf(fout, "%s[%d] @%p  firstY:%d lastY:%d x:%g dx:%g w:%d fNext:%p fPrev:%p\n", __FUNCTION__, i, list[i], list[i]->fFirstY, list[i]->fLastY, SkFixedToFloat(list[i]->fX), SkFixedToFloat(list[i]->fDX), list[i]->fWinding, list[i]->fNext, list[i]->fPrev);
+    fprintf(fout, "%s now calling SkTQSort()...\n", __FUNCTION__);
+
     SkTQSort(list, list + count - 1);
 
     // now make the edges linked in sorted order
     for (int i = 1; i < count; i++) {
         list[i - 1]->fNext = list[i];
         list[i]->fPrev = list[i - 1];
+        fprintf(fout, "%s @%p  firstY:%d lastY:%d x:%g dx:%g w:%d fNext:%p fPrev:%p\n", __FUNCTION__, list[i - 1], list[i - 1]->fFirstY, list[i - 1]->fLastY, SkFixedToFloat(list[i - 1]->fX), SkFixedToFloat(list[i - 1]->fDX), list[i - 1]->fWinding, list[i - 1]->fNext, list[i - 1]->fPrev);
     }
+    fprintf(fout, "%s @%p  firstY:%d lastY:%d x:%g dx:%g w:%d fNext:%p fPrev:%p\n", __FUNCTION__, list[count - 1], list[count - 1]->fFirstY, list[count - 1]->fLastY, SkFixedToFloat(list[count - 1]->fX), SkFixedToFloat(list[count - 1]->fDX), list[count - 1]->fWinding, list[count - 1]->fNext, list[count - 1]->fPrev);
+    fprintf(fout, "%s returns %p\n", __FUNCTION__, list[count - 1]);
+    fclose(fout);
 
     *last = list[count - 1];
     return list[0];
 }
 
 // clipRect has not been shifted up
+#include <stdio.h>
 void sk_fill_path(const SkPath& path, const SkIRect& clipRect, SkBlitter* blitter,
                   int start_y, int stop_y, int shiftEdgesUp, bool pathContainedInClip) {
+    FILE *fout = fopen("/tmp/stacklog", "a+"); fprintf(fout, "%s@%p(path@0x%X, clipRect@0x%X, blitter@0x%X, start_y=%d, stop_y=%d, shiftEdgesUp=%d, pathContainedInClip=0x%X)\n", __FUNCTION__, sk_fill_path, &path, &clipRect, blitter, start_y, stop_y, shiftEdgesUp, pathContainedInClip); fclose(fout);
     SkASSERT(blitter);
 
     SkIRect shiftedClip = clipRect;
@@ -456,6 +471,13 @@ void sk_fill_path(const SkPath& path, const SkIRect& clipRect, SkBlitter* blitte
 
     start_y = SkLeftShift(start_y, shiftEdgesUp);
     stop_y = SkLeftShift(stop_y, shiftEdgesUp);
+
+    fout = fopen("/tmp/stacklog", "a+");
+    fprintf(fout, "%s: start_y=%d, stop_y=%d, count=%d, path.isInverseFillType()=%d, path.isConvex()=%d\n", __FUNCTION__, start_y, stop_y, count, path.isInverseFillType(), path.isConvex());
+    fprintf(fout, "%s: headEdge firstY:%d lastY:%d x:%g dx:%g w:%d\n", __FUNCTION__, headEdge.fFirstY, headEdge.fLastY, SkFixedToFloat(headEdge.fX), SkFixedToFloat(headEdge.fDX), headEdge.fWinding);
+    fprintf(fout, "%s: tailEdge firstY:%d lastY:%d x:%g dx:%g w:%d\n", __FUNCTION__, tailEdge.fFirstY, tailEdge.fLastY, SkFixedToFloat(tailEdge.fX), SkFixedToFloat(tailEdge.fDX), tailEdge.fWinding);
+    fclose(fout);
+
     if (!pathContainedInClip && start_y < shiftedClip.fTop) {
         start_y = shiftedClip.fTop;
     }
