BASELINE: Update Chromium to 52.0.2743.76 and Ninja to 1.7.1

Change-Id: I382f51b959689505a60f8b707255ecb344f7d8b4
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

23 files changed, 494 insertions, 275 deletions

diff --git a/chromium/third_party/skia/bench/BitmapRegionDecoderBench.cpp b/chromium/third_party/skia/bench/BitmapRegionDecoderBench.cpp
index 125c4a84cf8..dd60b182961 100644
--- a/chromium/third_party/skia/bench/BitmapRegionDecoderBench.cpp
+++ b/chromium/third_party/skia/bench/BitmapRegionDecoderBench.cpp
@@ -11,34 +11,17 @@
 #include "SkOSFile.h"
 
 BitmapRegionDecoderBench::BitmapRegionDecoderBench(const char* baseName, SkData* encoded,
-        SkBitmapRegionDecoder::Strategy strategy, SkColorType colorType,
-        uint32_t sampleSize, const SkIRect& subset)
+        SkColorType colorType, uint32_t sampleSize, const SkIRect& subset)
     : fBRD(nullptr)
     , fData(SkRef(encoded))
-    , fStrategy(strategy)
     , fColorType(colorType)
     , fSampleSize(sampleSize)
     , fSubset(subset)
 {
-    // Choose a useful name for the region decoding strategy
-    const char* strategyName;
-    switch (strategy) {
-        case SkBitmapRegionDecoder::kCanvas_Strategy:
-            strategyName = "Canvas";
-            break;
-        case SkBitmapRegionDecoder::kAndroidCodec_Strategy:
-            strategyName = "AndroidCodec";
-            break;
-        default:
-            SkASSERT(false);
-            strategyName = "";
-            break;
-    }
-
     // Choose a useful name for the color type
     const char* colorName = color_type_to_str(colorType);
 
-    fName.printf("BRD_%s_%s_%s", baseName, strategyName, colorName);
+    fName.printf("BRD_%s_%s", baseName, colorName);
     if (1 != sampleSize) {
         fName.appendf("_%.3f", 1.0f / (float) sampleSize);
     }
@@ -53,7 +36,7 @@ bool BitmapRegionDecoderBench::isSuitableFor(Backend backend) {
 }
 
 void BitmapRegionDecoderBench::onDelayedSetup() {
-    fBRD.reset(SkBitmapRegionDecoder::Create(fData, fStrategy));
+    fBRD.reset(SkBitmapRegionDecoder::Create(fData, SkBitmapRegionDecoder::kAndroidCodec_Strategy));
 }
 
 void BitmapRegionDecoderBench::onDraw(int n, SkCanvas* canvas) {
diff --git a/chromium/third_party/skia/bench/BitmapRegionDecoderBench.h b/chromium/third_party/skia/bench/BitmapRegionDecoderBench.h
index 7c331aee31c..69588b24c38 100644
--- a/chromium/third_party/skia/bench/BitmapRegionDecoderBench.h
+++ b/chromium/third_party/skia/bench/BitmapRegionDecoderBench.h
@@ -18,16 +18,13 @@
 /**
  *  Benchmark Android's BitmapRegionDecoder for a particular colorType, sampleSize, and subset.
  *
- *  fStrategy determines which of various implementations is to be used.
- *
  *  nanobench.cpp handles creating benchmarks for interesting scaled subsets.  We strive to test
  *  on real use cases.
  */
 class BitmapRegionDecoderBench : public Benchmark {
 public:
     // Calls encoded->ref()
-    BitmapRegionDecoderBench(const char* basename, SkData* encoded,
-            SkBitmapRegionDecoder::Strategy strategy, SkColorType colorType,
+    BitmapRegionDecoderBench(const char* basename, SkData* encoded, SkColorType colorType,
             uint32_t sampleSize, const SkIRect& subset);
 
 protected:
@@ -40,7 +37,6 @@ private:
     SkString                                       fName;
     SkAutoTDelete<SkBitmapRegionDecoder>           fBRD;
     SkAutoTUnref<SkData>                           fData;
-    const SkBitmapRegionDecoder::Strategy          fStrategy;
     const SkColorType                              fColorType;
     const uint32_t                                 fSampleSize;
     const SkIRect                                  fSubset;
diff --git a/chromium/third_party/skia/bench/ChecksumBench.cpp b/chromium/third_party/skia/bench/ChecksumBench.cpp
index cba9572aa33..4c2ac1a3962 100644
--- a/chromium/third_party/skia/bench/ChecksumBench.cpp
+++ b/chromium/third_party/skia/bench/ChecksumBench.cpp
@@ -51,7 +51,7 @@ protected:
             case kMD5_ChecksumType: {
                 for (int i = 0; i < loops; i++) {
                     SkMD5 md5;
-                    md5.update(reinterpret_cast<uint8_t*>(fData), sizeof(fData));
+                    md5.write(fData, sizeof(fData));
                     SkMD5::Digest digest;
                     md5.finish(digest);
                 }
diff --git a/chromium/third_party/skia/bench/CmapBench.cpp b/chromium/third_party/skia/bench/CmapBench.cpp
index a2fb5065f4c..49e89bec8ca 100644
--- a/chromium/third_party/skia/bench/CmapBench.cpp
+++ b/chromium/third_party/skia/bench/CmapBench.cpp
@@ -77,7 +77,7 @@ public:
             // we're jamming values into utf8, so we must keep it legal utf8
             fText[i] = 'A' + (i & 31);
         }
-        fPaint.setTypeface(SkTypeface::RefDefault())->unref();
+        fPaint.setTypeface(SkTypeface::MakeDefault());
     }
 
 protected:
diff --git a/chromium/third_party/skia/bench/CoverageBench.cpp b/chromium/third_party/skia/bench/CoverageBench.cpp
index ebde4208a01..e1b53f879d3 100644
--- a/chromium/third_party/skia/bench/CoverageBench.cpp
+++ b/chromium/third_party/skia/bench/CoverageBench.cpp
@@ -40,7 +40,6 @@ public:
 
         fDraw.fDst      = fPixmap;
         fDraw.fMatrix   = &fIdentity;
-        fDraw.fClip     = &fRC.bwRgn();
         fDraw.fRC       = &fRC;
     }
 
diff --git a/chromium/third_party/skia/bench/DisplacementBench.cpp b/chromium/third_party/skia/bench/DisplacementBench.cpp
index 82857e630f9..9edf21476cc 100644
--- a/chromium/third_party/skia/bench/DisplacementBench.cpp
+++ b/chromium/third_party/skia/bench/DisplacementBench.cpp
@@ -18,9 +18,7 @@
 
 class DisplacementBaseBench : public Benchmark {
 public:
-    DisplacementBaseBench(bool small) :
-        fInitialized(false), fIsSmall(small) {
-    }
+    DisplacementBaseBench(bool small) : fInitialized(false), fIsSmall(small) { }
 
 protected:
     void onDelayedSetup() override {
@@ -92,8 +90,7 @@ private:
 
 class DisplacementZeroBench : public DisplacementBaseBench {
 public:
-    DisplacementZeroBench(bool small) : INHERITED(small) {
-    }
+    DisplacementZeroBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -104,9 +101,10 @@ protected:
         SkPaint paint;
         sk_sp<SkImageFilter> displ(SkImageSource::Make(fCheckerboard));
         // No displacement effect
-        paint.setImageFilter(SkDisplacementMapEffect::Create(
-            SkDisplacementMapEffect::kR_ChannelSelectorType,
-            SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ.get()))->unref();
+        paint.setImageFilter(SkDisplacementMapEffect::Make(
+                                                SkDisplacementMapEffect::kR_ChannelSelectorType,
+                                                SkDisplacementMapEffect::kG_ChannelSelectorType,
+                                                0.0f, std::move(displ), nullptr));
 
         for (int i = 0; i < loops; i++) {
             this->drawClippedBitmap(canvas, 0, 0, paint);
@@ -119,8 +117,7 @@ private:
 
 class DisplacementAlphaBench : public DisplacementBaseBench {
 public:
-    DisplacementAlphaBench(bool small) : INHERITED(small) {
-    }
+    DisplacementAlphaBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -131,11 +128,12 @@ protected:
         SkPaint paint;
         sk_sp<SkImageFilter> displ(SkImageSource::Make(fCheckerboard));
         // Displacement, with 1 alpha component (which isn't pre-multiplied)
-        paint.setImageFilter(SkDisplacementMapEffect::Create(
-            SkDisplacementMapEffect::kB_ChannelSelectorType,
-            SkDisplacementMapEffect::kA_ChannelSelectorType, 16.0f, displ.get()))->unref();
+        paint.setImageFilter(SkDisplacementMapEffect::Make(
+                                                SkDisplacementMapEffect::kB_ChannelSelectorType,
+                                                SkDisplacementMapEffect::kA_ChannelSelectorType,
+                                                16.0f, std::move(displ), nullptr));
         for (int i = 0; i < loops; i++) {
-            drawClippedBitmap(canvas, 100, 0, paint);
+            this->drawClippedBitmap(canvas, 100, 0, paint);
         }
     }
 
@@ -145,8 +143,7 @@ private:
 
 class DisplacementFullBench : public DisplacementBaseBench {
 public:
-    DisplacementFullBench(bool small) : INHERITED(small) {
-    }
+    DisplacementFullBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -157,9 +154,10 @@ protected:
         SkPaint paint;
         sk_sp<SkImageFilter> displ(SkImageSource::Make(fCheckerboard));
         // Displacement, with 2 non-alpha components
-        paint.setImageFilter(SkDisplacementMapEffect::Create(
-            SkDisplacementMapEffect::kR_ChannelSelectorType,
-            SkDisplacementMapEffect::kB_ChannelSelectorType, 32.0f, displ.get()))->unref();
+        paint.setImageFilter(SkDisplacementMapEffect::Make(
+                                                SkDisplacementMapEffect::kR_ChannelSelectorType,
+                                                SkDisplacementMapEffect::kB_ChannelSelectorType,
+                                                32.0f, std::move(displ), nullptr));
         for (int i = 0; i < loops; ++i) {
             this->drawClippedBitmap(canvas, 200, 0, paint);
         }
diff --git a/chromium/third_party/skia/bench/EncoderBench.cpp b/chromium/third_party/skia/bench/EncoderBench.cpp
new file mode 100644
index 00000000000..8a82a7cf061
--- /dev/null
+++ b/chromium/third_party/skia/bench/EncoderBench.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Benchmark.h"
+#include "Resources.h"
+#include "SkBitmap.h"
+#include "SkData.h"
+#include "SkImageEncoder.h"
+
+class EncodeBench : public Benchmark {
+public:
+    EncodeBench(const char* filename, SkImageEncoder::Type type, int quality)
+        : fFilename(filename)
+        , fType(type)
+        , fQuality(quality)
+    {
+        // Set the name of the bench
+        SkString name("Encode_");
+        name.append(filename);
+        name.append("_");
+        switch (type) {
+            case SkImageEncoder::kJPEG_Type:
+                name.append("JPEG");
+                break;
+            case SkImageEncoder::kPNG_Type:
+                name.append("PNG");
+                break;
+            case SkImageEncoder::kWEBP_Type:
+                name.append("WEBP");
+                break;
+            default:
+                name.append("Unknown");
+                break;
+        }
+        
+        fName = name;
+    }
+
+    bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
+    
+    const char* onGetName() override { return fName.c_str(); }
+    
+    void onPreDraw(SkCanvas*) override {
+#ifdef SK_DEBUG
+        bool result =
+#endif
+        GetResourceAsBitmap(fFilename, &fBitmap);
+        SkASSERT(result);
+    }
+
+    void onDraw(int loops, SkCanvas*) override {
+        for (int i = 0; i < loops; i++) {
+            SkAutoTUnref<SkData> data(SkImageEncoder::EncodeData(fBitmap, fType, fQuality));
+            SkASSERT(data);
+        }
+    }
+
+private:
+    const char*                fFilename;
+    const SkImageEncoder::Type fType;
+    const int                  fQuality;
+    SkString                   fName;
+    SkBitmap                   fBitmap;
+};
+
+
+// The Android Photos app uses a quality of 90 on JPEG encodes
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kJPEG_Type, 90));
+DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkImageEncoder::kJPEG_Type, 90));
+
+// PNG encodes are lossless so quality should be ignored
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kPNG_Type, 90));
+DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkImageEncoder::kPNG_Type, 90));
+
+// TODO: What is the appropriate quality to use to benchmark WEBP encodes?
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kWEBP_Type, 90));
+DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkImageEncoder::kWEBP_Type, 90));
diff --git a/chromium/third_party/skia/bench/GLBench.cpp b/chromium/third_party/skia/bench/GLBench.cpp
index f184d770b3d..524bfe1109a 100644
--- a/chromium/third_party/skia/bench/GLBench.cpp
+++ b/chromium/third_party/skia/bench/GLBench.cpp
@@ -56,6 +56,7 @@ void GLBench::onDraw(int loops, SkCanvas* canvas) {
         return;
     }
     this->glDraw(loops, ctx);
+    canvas->getGrContext()->resetContext();
 }
 
 GrGLuint GLBench::CompileShader(const GrGLInterface* gl, const char* shaderSrc, GrGLenum type) {
diff --git a/chromium/third_party/skia/bench/GMBench.cpp b/chromium/third_party/skia/bench/GMBench.cpp
index 57b23165302..6037a8221c2 100644
--- a/chromium/third_party/skia/bench/GMBench.cpp
+++ b/chromium/third_party/skia/bench/GMBench.cpp
@@ -22,6 +22,7 @@ bool GMBench::isSuitableFor(Backend backend) {
 }
 
 void GMBench::onDraw(int loops, SkCanvas* canvas) {
+    fGM->setMode(skiagm::GM::kBench_Mode);
     // Do we care about timing the draw of the background (once)?
     // Does the GM ever rely on drawBackground to lazily compute something?
     fGM->drawBackground(canvas);
diff --git a/chromium/third_party/skia/bench/GrResourceCacheBench.cpp b/chromium/third_party/skia/bench/GrResourceCacheBench.cpp
index 890bc960049..295a5bcec1b 100644
--- a/chromium/third_party/skia/bench/GrResourceCacheBench.cpp
+++ b/chromium/third_party/skia/bench/GrResourceCacheBench.cpp
@@ -23,8 +23,8 @@ enum {
 class BenchResource : public GrGpuResource {
 public:
     BenchResource (GrGpu* gpu)
-        : INHERITED(gpu, kCached_LifeCycle) {
-        this->registerWithCache();
+        : INHERITED(gpu) {
+        this->registerWithCache(SkBudgeted::kYes);
     }
 
     static void ComputeKey(int i, int keyData32Count, GrUniqueKey* key) {
diff --git a/chromium/third_party/skia/bench/ImageFilterDAGBench.cpp b/chromium/third_party/skia/bench/ImageFilterDAGBench.cpp
index 308b3b00378..776ee787fdf 100644
--- a/chromium/third_party/skia/bench/ImageFilterDAGBench.cpp
+++ b/chromium/third_party/skia/bench/ImageFilterDAGBench.cpp
@@ -62,10 +62,11 @@ protected:
             auto xSelector = SkDisplacementMapEffect::kR_ChannelSelectorType;
             auto ySelector = SkDisplacementMapEffect::kB_ChannelSelectorType;
             SkScalar scale = 2;
-            sk_sp<SkImageFilter> displ(SkDisplacementMapEffect::Create(xSelector, ySelector, scale,
-                                                                       blur.get(), blur.get()));
+
             SkPaint paint;
-            paint.setImageFilter(std::move(displ));
+            paint.setImageFilter(SkDisplacementMapEffect::Make(xSelector, ySelector, scale,
+                                                               blur, blur));
+
             SkRect rect = SkRect::Make(SkIRect::MakeWH(400, 400));
             canvas->drawRect(rect, paint);
         }
diff --git a/chromium/third_party/skia/bench/LightingBench.cpp b/chromium/third_party/skia/bench/LightingBench.cpp
index 2c78749d9f0..bbe0af343ca 100644
--- a/chromium/third_party/skia/bench/LightingBench.cpp
+++ b/chromium/third_party/skia/bench/LightingBench.cpp
@@ -6,7 +6,6 @@
  */
 #include "Benchmark.h"
 #include "SkCanvas.h"
-#include "SkDevice.h"
 #include "SkLightingImageFilter.h"
 #include "SkPoint3.h"
 
@@ -20,11 +19,11 @@ public:
     LightingBaseBench(bool small) : fIsSmall(small) { }
 
 protected:
-    void draw(int loops, SkCanvas* canvas, SkImageFilter* imageFilter) const {
+    void draw(int loops, SkCanvas* canvas, sk_sp<SkImageFilter> imageFilter) const {
         SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMALL) :
                               SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARGE);
         SkPaint paint;
-        paint.setImageFilter(imageFilter)->unref();
+        paint.setImageFilter(std::move(imageFilter));
         for (int i = 0; i < loops; i++) {
             canvas->drawRect(r, paint);
         }
@@ -99,8 +98,7 @@ protected:
 
 class LightingPointLitDiffuseBench : public LightingBaseBench {
 public:
-    LightingPointLitDiffuseBench(bool small) : INHERITED(small) {
-    }
+    LightingPointLitDiffuseBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -108,10 +106,11 @@ protected:
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
-        draw(loops, canvas, SkLightingImageFilter::CreatePointLitDiffuse(GetPointLocation(),
-                                                                         GetWhite(),
-                                                                         GetSurfaceScale(),
-                                                                         GetKd()));
+        draw(loops, canvas, SkLightingImageFilter::MakePointLitDiffuse(GetPointLocation(),
+                                                                       GetWhite(),
+                                                                       GetSurfaceScale(),
+                                                                       GetKd(),
+                                                                       nullptr));
     }
 
 private:
@@ -120,8 +119,7 @@ private:
 
 class LightingDistantLitDiffuseBench : public LightingBaseBench {
 public:
-    LightingDistantLitDiffuseBench(bool small) : INHERITED(small) {
-    }
+    LightingDistantLitDiffuseBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -129,10 +127,11 @@ protected:
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
-        draw(loops, canvas, SkLightingImageFilter::CreateDistantLitDiffuse(GetDistantDirection(),
-                                                                           GetWhite(),
-                                                                           GetSurfaceScale(),
-                                                                           GetKd()));
+        draw(loops, canvas, SkLightingImageFilter::MakeDistantLitDiffuse(GetDistantDirection(),
+                                                                         GetWhite(),
+                                                                         GetSurfaceScale(),
+                                                                         GetKd(),
+                                                                         nullptr));
     }
 
 private:
@@ -141,8 +140,7 @@ private:
 
 class LightingSpotLitDiffuseBench : public LightingBaseBench {
 public:
-    LightingSpotLitDiffuseBench(bool small) : INHERITED(small) {
-    }
+    LightingSpotLitDiffuseBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -150,13 +148,14 @@ protected:
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
-        draw(loops, canvas, SkLightingImageFilter::CreateSpotLitDiffuse(GetSpotLocation(),
-                                                                        GetSpotTarget(),
-                                                                        GetSpotExponent(),
-                                                                        GetCutoffAngle(),
-                                                                        GetWhite(),
-                                                                        GetSurfaceScale(),
-                                                                        GetKd()));
+        draw(loops, canvas, SkLightingImageFilter::MakeSpotLitDiffuse(GetSpotLocation(),
+                                                                       GetSpotTarget(),
+                                                                       GetSpotExponent(),
+                                                                       GetCutoffAngle(),
+                                                                       GetWhite(),
+                                                                       GetSurfaceScale(),
+                                                                       GetKd(),
+                                                                       nullptr));
     }
 
 private:
@@ -165,8 +164,7 @@ private:
 
 class LightingPointLitSpecularBench : public LightingBaseBench {
 public:
-    LightingPointLitSpecularBench(bool small) : INHERITED(small) {
-    }
+    LightingPointLitSpecularBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -174,11 +172,12 @@ protected:
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
-        draw(loops, canvas, SkLightingImageFilter::CreatePointLitSpecular(GetPointLocation(),
-                                                                          GetWhite(),
-                                                                          GetSurfaceScale(),
-                                                                          GetKs(),
-                                                                          GetShininess()));
+        draw(loops, canvas, SkLightingImageFilter::MakePointLitSpecular(GetPointLocation(),
+                                                                        GetWhite(),
+                                                                        GetSurfaceScale(),
+                                                                        GetKs(),
+                                                                        GetShininess(),
+                                                                        nullptr));
     }
 
 private:
@@ -187,8 +186,7 @@ private:
 
 class LightingDistantLitSpecularBench : public LightingBaseBench {
 public:
-    LightingDistantLitSpecularBench(bool small) : INHERITED(small) {
-    }
+    LightingDistantLitSpecularBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -196,11 +194,12 @@ protected:
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
-        draw(loops, canvas, SkLightingImageFilter::CreateDistantLitSpecular(GetDistantDirection(),
-                                                                            GetWhite(),
-                                                                            GetSurfaceScale(),
-                                                                            GetKs(),
-                                                                            GetShininess()));
+        draw(loops, canvas, SkLightingImageFilter::MakeDistantLitSpecular(GetDistantDirection(),
+                                                                          GetWhite(),
+                                                                          GetSurfaceScale(),
+                                                                          GetKs(),
+                                                                          GetShininess(),
+                                                                          nullptr));
     }
 
 private:
@@ -209,8 +208,7 @@ private:
 
 class LightingSpotLitSpecularBench : public LightingBaseBench {
 public:
-    LightingSpotLitSpecularBench(bool small) : INHERITED(small) {
-    }
+    LightingSpotLitSpecularBench(bool small) : INHERITED(small) { }
 
 protected:
     const char* onGetName() override {
@@ -218,14 +216,15 @@ protected:
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
-        draw(loops, canvas, SkLightingImageFilter::CreateSpotLitSpecular(GetSpotLocation(),
-                                                                         GetSpotTarget(),
-                                                                         GetSpotExponent(),
-                                                                         GetCutoffAngle(),
-                                                                         GetWhite(),
-                                                                         GetSurfaceScale(),
-                                                                         GetKs(),
-                                                                         GetShininess()));
+        draw(loops, canvas, SkLightingImageFilter::MakeSpotLitSpecular(GetSpotLocation(),
+                                                                       GetSpotTarget(),
+                                                                       GetSpotExponent(),
+                                                                       GetCutoffAngle(),
+                                                                       GetWhite(),
+                                                                       GetSurfaceScale(),
+                                                                       GetKs(),
+                                                                       GetShininess(),
+                                                                       nullptr));
     }
 
 private:
diff --git a/chromium/third_party/skia/bench/MatrixConvolutionBench.cpp b/chromium/third_party/skia/bench/MatrixConvolutionBench.cpp
index 05f0193ceca..3a43de863d9 100644
--- a/chromium/third_party/skia/bench/MatrixConvolutionBench.cpp
+++ b/chromium/third_party/skia/bench/MatrixConvolutionBench.cpp
@@ -11,10 +11,21 @@
 #include "SkRandom.h"
 #include "SkString.h"
 
+static const char* name(SkMatrixConvolutionImageFilter::TileMode mode) {
+    switch (mode) {
+        case SkMatrixConvolutionImageFilter::kClamp_TileMode:        return "clamp";
+        case SkMatrixConvolutionImageFilter::kRepeat_TileMode:       return "repeat";
+        case SkMatrixConvolutionImageFilter::kClampToBlack_TileMode: return "clampToBlack";
+    }
+    return "oops";
+}
+
 class MatrixConvolutionBench : public Benchmark {
 public:
     MatrixConvolutionBench(SkMatrixConvolutionImageFilter::TileMode tileMode, bool convolveAlpha)
-        : fName("matrixconvolution") {
+        : fName(SkStringPrintf("matrixconvolution_%s%s",
+                               name(tileMode),
+                               convolveAlpha ? "" : "_noConvolveAlpha")) {
         SkISize kernelSize = SkISize::Make(3, 3);
         SkScalar kernel[9] = {
             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
@@ -23,11 +34,9 @@ public:
         };
         SkScalar gain = 0.3f, bias = SkIntToScalar(100);
         SkIPoint kernelOffset = SkIPoint::Make(1, 1);
-        fFilter = SkMatrixConvolutionImageFilter::Create(kernelSize, kernel, gain, bias, kernelOffset, tileMode, convolveAlpha);
-    }
-
-    ~MatrixConvolutionBench() {
-        fFilter->unref();
+        fFilter = SkMatrixConvolutionImageFilter::Make(kernelSize, kernel, gain, bias,
+                                                       kernelOffset, tileMode, convolveAlpha,
+                                                       nullptr);
     }
 
 protected:
@@ -49,9 +58,10 @@ protected:
     }
 
 private:
-    typedef Benchmark INHERITED;
-    SkImageFilter* fFilter;
+    sk_sp<SkImageFilter> fFilter;
     SkString fName;
+
+    typedef Benchmark INHERITED;
 };
 
 DEF_BENCH( return new MatrixConvolutionBench(SkMatrixConvolutionImageFilter::kClamp_TileMode, true); )
diff --git a/chromium/third_party/skia/bench/PDFBench.cpp b/chromium/third_party/skia/bench/PDFBench.cpp
index 9da745c2806..76ee3cad0d5 100644
--- a/chromium/third_party/skia/bench/PDFBench.cpp
+++ b/chromium/third_party/skia/bench/PDFBench.cpp
@@ -17,6 +17,7 @@
 #include "SkPDFUtils.h"
 #include "SkPixmap.h"
 #include "SkRandom.h"
+#include "SkStream.h"
 
 namespace {
 struct NullWStream : public SkWStream {
@@ -181,7 +182,8 @@ struct PDFShaderBench : public Benchmark {
         SkASSERT(fShader);
         while (loops-- > 0) {
             NullWStream nullStream;
-            SkPDFDocument doc(&nullStream, nullptr, 72, nullptr);
+            SkPDFDocument doc(&nullStream, nullptr, 72,
+                              SkDocument::PDFMetadata(), nullptr, false);
             sk_sp<SkPDFObject> shader(
                     SkPDFShader::GetPDFShader(
                             &doc, 72, fShader.get(), SkMatrix::I(),
@@ -190,9 +192,26 @@ struct PDFShaderBench : public Benchmark {
     }
 };
 
+struct WStreamWriteTextBenchmark : public Benchmark {
+    std::unique_ptr<SkWStream> fWStream;
+    WStreamWriteTextBenchmark() : fWStream(new NullWStream) {}
+    const char* onGetName() override { return "WStreamWriteText"; }
+    bool isSuitableFor(Backend backend) override {
+        return backend == kNonRendering_Backend;
+    }
+    void onDraw(int loops, SkCanvas*) override {
+        while (loops-- > 0) {
+            for (int i = 1000; i-- > 0;) {
+                fWStream->writeText("HELLO SKIA!\n");
+            }
+        }
+    }
+};
+
 }  // namespace
 DEF_BENCH(return new PDFImageBench;)
 DEF_BENCH(return new PDFJpegImageBench;)
 DEF_BENCH(return new PDFCompressionBench;)
 DEF_BENCH(return new PDFScalarBench;)
 DEF_BENCH(return new PDFShaderBench;)
+DEF_BENCH(return new WStreamWriteTextBenchmark;)
diff --git a/chromium/third_party/skia/bench/SkBlend_optsBench.cpp b/chromium/third_party/skia/bench/SkBlend_optsBench.cpp
new file mode 100644
index 00000000000..9c34d49f34b
--- /dev/null
+++ b/chromium/third_party/skia/bench/SkBlend_optsBench.cpp
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <tuple>
+
+#include "Benchmark.h"
+#include "Resources.h"
+#include "SkCpu.h"
+#include "SkImage.h"
+#include "SkImage_Base.h"
+#include "SkNx.h"
+#include "SkOpts.h"
+#include "SkString.h"
+
+#define INNER_LOOPS 10
+
+namespace sk_default {
+extern void brute_force_srcover_srgb_srgb(
+    uint32_t* dst, const uint32_t* const srcStart, int ndst, const int nsrc);
+}
+
+class SrcOverVSkOptsBruteForce {
+public:
+    static SkString Name() { return SkString{"VSkOptsBruteForce"}; }
+    static bool WorksOnCpu() { return true; }
+    static void BlendN(uint32_t* dst, int count, const uint32_t* src) {
+        sk_default::brute_force_srcover_srgb_srgb(dst, src, count, count);
+    }
+};
+
+namespace sk_default {
+extern void trivial_srcover_srgb_srgb(
+    uint32_t* dst, const uint32_t* const srcStart, int ndst, const int nsrc);
+}
+
+class SrcOverVSkOptsTrivial {
+public:
+    static SkString Name() { return SkString{"VSkOptsTrivial"}; }
+    static bool WorksOnCpu() { return true; }
+    static void BlendN(uint32_t* dst, int count, const uint32_t* src) {
+        sk_default::trivial_srcover_srgb_srgb(dst, src, count, count);
+    }
+};
+
+namespace sk_default {
+extern void best_non_simd_srcover_srgb_srgb(
+    uint32_t* dst, const uint32_t* const srcStart, int ndst, const int nsrc);
+}
+
+class SrcOverVSkOptsNonSimdCore {
+public:
+    static SkString Name() { return SkString{"VSkOptsNonSimdCore"}; }
+    static bool WorksOnCpu() { return true; }
+    static void BlendN(uint32_t* dst, int count, const uint32_t* src) {
+        sk_default::best_non_simd_srcover_srgb_srgb(dst, src, count, count);
+    }
+};
+
+namespace sk_default {
+extern void srcover_srgb_srgb(
+    uint32_t* dst, const uint32_t* const srcStart, int ndst, const int nsrc);
+}
+
+class SrcOverVSkOptsDefault {
+public:
+    static SkString Name() { return SkString{"VSkOptsDefault"}; }
+    static bool WorksOnCpu() { return true; }
+    static void BlendN(uint32_t* dst, int count, const uint32_t* src) {
+        sk_default::srcover_srgb_srgb(dst, src, count, count);
+    }
+};
+
+namespace sk_sse41 {
+   extern void srcover_srgb_srgb(
+       uint32_t* dst, const uint32_t* const srcStart, int ndst, const int nsrc);
+}
+
+class SrcOverVSkOptsSSE41 {
+public:
+    static SkString Name() { return SkString{"VSkOptsSSE41"}; }
+    static bool WorksOnCpu() { return SkCpu::Supports(SkCpu::SSE41); }
+    static void BlendN(uint32_t* dst, int count, const uint32_t* src) {
+        sk_sse41::srcover_srgb_srgb(dst, src, count, count);
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename Blender>
+class LinearSrcOverBench : public Benchmark {
+public:
+    LinearSrcOverBench(const char* fileName) {
+        fName = "LinearSrcOver";
+        fName.append(fileName);
+        fName.append(Blender::Name());
+
+        sk_sp<SkImage> image = GetResourceAsImage(fileName);
+        SkBitmap bm;
+        if (!as_IB(image)->getROPixels(&bm)) {
+            SkFAIL("Could not read resource");
+        }
+        bm.peekPixels(&fPixmap);
+        fCount = fPixmap.rowBytesAsPixels();
+        fDst.reset(fCount);
+        memset(fDst.get(), 0, fPixmap.rowBytes());
+    }
+
+protected:
+    bool isSuitableFor(Backend backend) override {
+        return backend == kNonRendering_Backend && Blender::WorksOnCpu();
+    }
+    const char* onGetName() override { return fName.c_str(); }
+    void onDraw(int loops, SkCanvas*) override {
+        SkASSERT(fPixmap.colorType() == kN32_SkColorType);
+
+        const int width = fPixmap.rowBytesAsPixels();
+
+        for (int i = 0; i < loops * INNER_LOOPS; ++i) {
+            const uint32_t* src = fPixmap.addr32();
+            for (int y = 0; y < fPixmap.height(); y++) {
+                Blender::BlendN(fDst.get(), width, src);
+                src += width;
+            }
+        }
+    }
+
+    void onPostDraw(SkCanvas*) override {
+        // Make sure the compiler does not optimize away the operation.
+        volatile uint32_t v = 0;
+        for (int i = 0; i < fCount; i++) {
+            v ^= fDst[i];
+        }
+    }
+
+private:
+    int fCount;
+    SkAutoTArray<uint32_t> fDst;
+    SkString fName;
+    SkPixmap fPixmap;
+
+    typedef Benchmark INHERITED;
+};
+
+#if defined(SK_CPU_X86) && !defined(SK_BUILD_FOR_IOS)
+#define BENCHES(fileName)                                                        \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsBruteForce>(fileName); )  \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsTrivial>(fileName); )     \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsNonSimdCore>(fileName); ) \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsDefault>(fileName); )     \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsSSE41>(fileName); )
+#else
+#define BENCHES(fileName)                                                        \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsBruteForce>(fileName); )  \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsTrivial>(fileName); )     \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsNonSimdCore>(fileName); ) \
+DEF_BENCH( return new LinearSrcOverBench<SrcOverVSkOptsDefault>(fileName); )
+#endif
+
+BENCHES("yellow_rose.png")
+BENCHES("baby_tux.png")
+BENCHES("plane.png")
+BENCHES("mandrill_512.png")
+BENCHES("iconstrip.png")
diff --git a/chromium/third_party/skia/bench/SkGlyphCacheBench.cpp b/chromium/third_party/skia/bench/SkGlyphCacheBench.cpp
index 2e0429fce34..c5e40af7469 100644
--- a/chromium/third_party/skia/bench/SkGlyphCacheBench.cpp
+++ b/chromium/third_party/skia/bench/SkGlyphCacheBench.cpp
@@ -53,18 +53,15 @@ protected:
     void onDraw(int loops, SkCanvas*) override {
         size_t oldCacheLimitSize = SkGraphics::GetFontCacheLimit();
         SkGraphics::SetFontCacheLimit(fCacheSize);
-        SkTypeface* typeface = sk_tool_utils::create_portable_typeface(
-            "serif", SkTypeface::kItalic);
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setSubpixelText(true);
-        paint.setTypeface(typeface);
+        paint.setTypeface(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kItalic));
 
         for (int work = 0; work < loops; work++) {
             do_font_stuff(&paint);
         }
         SkGraphics::SetFontCacheLimit(oldCacheLimitSize);
-        SkSafeUnref(typeface);
     }
 
 private:
@@ -90,7 +87,7 @@ protected:
     void onDraw(int loops, SkCanvas*) override {
         size_t oldCacheLimitSize = SkGraphics::GetFontCacheLimit();
         SkGraphics::SetFontCacheLimit(fCacheSize);
-        SkTypeface* typefaces[] =
+        sk_sp<SkTypeface> typefaces[] =
             {sk_tool_utils::create_portable_typeface("serif", SkTypeface::kItalic),
              sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kItalic)};
 
@@ -104,8 +101,6 @@ protected:
             });
         }
         SkGraphics::SetFontCacheLimit(oldCacheLimitSize);
-        SkSafeUnref(typefaces[0]);
-        SkSafeUnref(typefaces[1]);
     }
 
 private:
diff --git a/chromium/third_party/skia/bench/SkLinearBitmapPipelineBench.cpp b/chromium/third_party/skia/bench/SkLinearBitmapPipelineBench.cpp
index f111aeea9ea..476d0152312 100644
--- a/chromium/third_party/skia/bench/SkLinearBitmapPipelineBench.cpp
+++ b/chromium/third_party/skia/bench/SkLinearBitmapPipelineBench.cpp
@@ -8,6 +8,7 @@
 #include <memory>
 #include "SkColor.h"
 #include "SkLinearBitmapPipeline.h"
+#include "SkBitmapProcShader.h"
 #include "SkPM4f.h"
 #include "Benchmark.h"
 #include "SkShader.h"
@@ -145,7 +146,7 @@ struct SkBitmapFPGeneral final : public CommonBitmapFPBenchmark {
         SkPixmap srcPixmap{fInfo, fBitmap.get(), static_cast<size_t>(4 * width)};
 
         SkLinearBitmapPipeline pipeline{
-            fInvert, filterQuality, fXTile, fYTile, 1.0f, srcPixmap};
+            fInvert, filterQuality, fXTile, fYTile, SK_ColorBLACK, srcPixmap};
 
         int count = 100;
 
@@ -193,7 +194,7 @@ struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark {
 
         SkAutoTMalloc<SkPMColor> buffer4b(width*height);
 
-        uint32_t storage[300];
+        uint32_t storage[kSkBlitterContextSize];
         const SkShader::ContextRec rec(fPaint, fM, nullptr,
                                        SkShader::ContextRec::kPMColor_DstType);
         SkASSERT(fPaint.getShader()->contextSize(rec) <= sizeof(storage));
diff --git a/chromium/third_party/skia/bench/TextBench.cpp b/chromium/third_party/skia/bench/TextBench.cpp
index 04f824c700c..a048ffd4a12 100644
--- a/chromium/third_party/skia/bench/TextBench.cpp
+++ b/chromium/third_party/skia/bench/TextBench.cpp
@@ -47,7 +47,7 @@ class TextBench : public Benchmark {
     FontQuality fFQ;
     bool        fDoPos;
     bool        fDoColorEmoji;
-    SkAutoTUnref<SkTypeface> fColorEmojiTypeface;
+    sk_sp<SkTypeface> fColorEmojiTypeface;
     SkPoint*    fPos;
 public:
     TextBench(const char text[], int ps,
@@ -71,7 +71,7 @@ protected:
     void onDelayedSetup() override {
         if (fDoColorEmoji) {
             SkASSERT(kBW == fFQ);
-            fColorEmojiTypeface.reset(GetResourceAsTypeface("/fonts/Funkster.ttf"));
+            fColorEmojiTypeface = MakeResourceAsTypeface("/fonts/Funkster.ttf");
         }
 
         if (fDoPos) {
diff --git a/chromium/third_party/skia/bench/TextBlobBench.cpp b/chromium/third_party/skia/bench/TextBlobBench.cpp
index a350e7b4c40..37bf3111191 100644
--- a/chromium/third_party/skia/bench/TextBlobBench.cpp
+++ b/chromium/third_party/skia/bench/TextBlobBench.cpp
@@ -23,13 +23,11 @@
  */
 class TextBlobBench : public Benchmark {
 public:
-    TextBlobBench()
-        : fTypeface(nullptr) {
-    }
+    TextBlobBench() {}
 
 protected:
     void onDelayedSetup() override {
-        fTypeface.reset(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal));
+        fTypeface = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal);
         // make textblob
         SkPaint paint;
         paint.setTypeface(fTypeface);
@@ -64,9 +62,9 @@ protected:
 
 private:
 
-    SkAutoTUnref<const SkTextBlob> fBlob;
-    SkTDArray<uint16_t>      fGlyphs;
-    SkAutoTUnref<SkTypeface> fTypeface;
+    SkAutoTUnref<const SkTextBlob>  fBlob;
+    SkTDArray<uint16_t>             fGlyphs;
+    sk_sp<SkTypeface>               fTypeface;
 
     typedef Benchmark INHERITED;
 };
diff --git a/chromium/third_party/skia/bench/TileImageFilterBench.cpp b/chromium/third_party/skia/bench/TileImageFilterBench.cpp
index 350b0ac2148..b9b38edd357 100644
--- a/chromium/third_party/skia/bench/TileImageFilterBench.cpp
+++ b/chromium/third_party/skia/bench/TileImageFilterBench.cpp
@@ -37,11 +37,9 @@ protected:
 
     void onDraw(int loops, SkCanvas* canvas) override {
         SkPaint paint;
-        SkAutoTUnref<SkImageFilter> tile(SkTileImageFilter::Create(
-            SkRect::MakeWH(50, 50),
-            SkRect::MakeWH(WIDTH, HEIGHT),
-            nullptr));
-        paint.setImageFilter(tile);
+        paint.setImageFilter(SkTileImageFilter::Make(SkRect::MakeWH(50, 50),
+                                                     SkRect::MakeWH(WIDTH, HEIGHT),
+                                                     nullptr));
 
         for (int i = 0; i < loops; i++) {
             if (fTileSize > 0) {
diff --git a/chromium/third_party/skia/bench/XferU64Bench.cpp b/chromium/third_party/skia/bench/XferF16Bench.cpp
index 324655b351b..6a7d27a9267 100644
--- a/chromium/third_party/skia/bench/XferU64Bench.cpp
+++ b/chromium/third_party/skia/bench/XferF16Bench.cpp
@@ -15,22 +15,21 @@
 #define INNER_LOOPS 1000
 
 // Benchmark that draws non-AA rects or AA text with an SkXfermode::Mode.
-class XferD64Bench : public Benchmark {
+class XferF16Bench : public Benchmark {
 public:
-    XferD64Bench(SkXfermode::Mode mode, const char name[], bool doN, uint32_t flags)
+    XferF16Bench(SkXfermode::Mode mode, const char name[], bool doN, uint32_t flags)
         : fDoN(doN)
         , fFlags(flags & ~USE_AA)
     {
         fXfer = SkXfermode::Make(mode);
 
-        fProc1 = SkXfermode::GetD64Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_D64Flag);
-        fProcN = SkXfermode::GetD64Proc(fXfer, fFlags);
-        fName.printf("xferu64_%s_%s_%c_%s_%s",
+        fProc1 = SkXfermode::GetF16Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_F16Flag);
+        fProcN = SkXfermode::GetF16Proc(fXfer, fFlags);
+        fName.printf("xferF16_%s_%s_%c_%s",
                      name,
                      (flags & USE_AA) ? "aa" : "bw",
                      fDoN ? 'N' : '1',
-                     (flags & SkXfermode::kSrcIsOpaque_D64Flag) ? "opaque" : "alpha",
-                     (flags & SkXfermode::kDstIsFloat16_D64Flag) ? "f16" : "u16");
+                     (flags & SkXfermode::kSrcIsOpaque_F16Flag) ? "opaque" : "alpha");
 
         for (int i = 0; i < N; ++i) {
             fSrc[i] = {{ 1, 1, 1, 1 }};
@@ -63,8 +62,8 @@ protected:
 private:
     sk_sp<SkXfermode>   fXfer;
     SkString            fName;
-    SkXfermode::D64Proc fProc1;
-    SkXfermode::D64Proc fProcN;
+    SkXfermode::F16Proc fProc1;
+    SkXfermode::F16Proc fProcN;
     const SkAlpha*      fAA;
     bool                fDoN;
     uint32_t            fFlags;
@@ -80,29 +79,17 @@ private:
 };
 
 #define F00 0
-#define F01 (SkXfermode::kSrcIsOpaque_D64Flag)
-#define F10 (SkXfermode::kDstIsFloat16_D64Flag)
-#define F11 (SkXfermode::kDstIsFloat16_D64Flag | SkXfermode::kSrcIsOpaque_D64Flag)
+#define F01 (SkXfermode::kSrcIsOpaque_F16Flag)
 
 #define MODE    SkXfermode::kSrcOver_Mode
 #define NAME    "srcover"
 
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F10 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F11 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F10); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F11); )
-
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F00 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F01 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F00); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, true,  F01); )
-
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F10 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F11 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F10); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F11); )
-
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F00 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F01 | USE_AA); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F00); )
-DEF_BENCH( return new XferD64Bench(MODE, NAME, false, F01); )
+DEF_BENCH( return new XferF16Bench(MODE, NAME, true,  F00 | USE_AA); )
+DEF_BENCH( return new XferF16Bench(MODE, NAME, true,  F01 | USE_AA); )
+DEF_BENCH( return new XferF16Bench(MODE, NAME, true,  F00); )
+DEF_BENCH( return new XferF16Bench(MODE, NAME, true,  F01); )
+
+DEF_BENCH( return new XferF16Bench(MODE, NAME, false, F00 | USE_AA); )
+DEF_BENCH( return new XferF16Bench(MODE, NAME, false, F01 | USE_AA); )
+DEF_BENCH( return new XferF16Bench(MODE, NAME, false, F00); )
+DEF_BENCH( return new XferF16Bench(MODE, NAME, false, F01); )
diff --git a/chromium/third_party/skia/bench/XfermodeBench.cpp b/chromium/third_party/skia/bench/XfermodeBench.cpp
index 829c437e092..7d00f411bd0 100644
--- a/chromium/third_party/skia/bench/XfermodeBench.cpp
+++ b/chromium/third_party/skia/bench/XfermodeBench.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Benchmark.h"
+#include "SkArithmeticMode.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
@@ -22,9 +23,8 @@ public:
         fName.printf("Xfermode_%s%s", SkXfermode::ModeName(mode), aa ? "_aa" : "");
     }
 
-    XfermodeBench(SkXfermode* xferMode, const char* name, bool aa) {
-        SkASSERT(xferMode);
-        fXfermode.reset(xferMode);
+    XfermodeBench(sk_sp<SkXfermode> xferMode, const char* name, bool aa) {
+        fXfermode = xferMode;
         fAA = aa;
         fName.printf("Xfermode_%s%s", name, aa ? "_aa" : "");
     }
@@ -135,4 +135,13 @@ BENCH(SkXfermode::kSaturation_Mode)
 BENCH(SkXfermode::kColor_Mode)
 BENCH(SkXfermode::kLuminosity_Mode)
 
+DEF_BENCH( return new XfermodeBench(SkArithmeticMode::Make(0.2f, -0.3f, 1.5f, -0.7f, false), \
+                                    "arithmetic", false); )
+DEF_BENCH( return new XfermodeBench(SkArithmeticMode::Make(0.2f, -0.3f, 1.5f, -0.7f, true), \
+                                    "arithmetic_enforce_pm", false); )
+DEF_BENCH( return new XfermodeBench(SkArithmeticMode::Make(0.2f, -0.3f, 1.5f, -0.7f, false), \
+                                    "arithmetic", true); )
+DEF_BENCH( return new XfermodeBench(SkArithmeticMode::Make(0.2f, -0.3f, 1.5f, -0.7f, true), \
+                                    "arithmetic_enforce_pm", true); )
+
 DEF_BENCH(return new XferCreateBench;)
diff --git a/chromium/third_party/skia/bench/nanobench.cpp b/chromium/third_party/skia/bench/nanobench.cpp
index 5e26b483951..4fb1ed223ab 100644
--- a/chromium/third_party/skia/bench/nanobench.cpp
+++ b/chromium/third_party/skia/bench/nanobench.cpp
@@ -58,7 +58,7 @@
     #include "GrContextFactory.h"
     #include "gl/GrGLUtil.h"
     using sk_gpu_test::GrContextFactory;
-    using sk_gpu_test::GLTestContext;
+    using sk_gpu_test::TestContext;
     SkAutoTDelete<GrContextFactory> gGrFactory;
 #endif
 
@@ -98,8 +98,6 @@ DEFINE_double(overheadGoal, 0.0001,
               "Loop until timer overhead is at most this fraction of our measurments.");
 DEFINE_double(gpuMs, 5, "Target bench time in millseconds for GPU.");
 DEFINE_int32(gpuFrameLag, 5, "If unknown, estimated maximum number of frames GPU allows to lag.");
-DEFINE_bool(gpuCompressAlphaMasks, false, "Compress masks generated from falling back to "
-                                          "software path rendering.");
 
 DEFINE_string(outResultsFile, "", "If given, write results here as JSON.");
 DEFINE_int32(maxCalibrationAttempts, 3,
@@ -157,26 +155,25 @@ bool Target::capturePixels(SkBitmap* bmp) {
 
 #if SK_SUPPORT_GPU
 struct GPUTarget : public Target {
-    explicit GPUTarget(const Config& c) : Target(c), gl(nullptr) { }
-    GLTestContext* gl;
+    explicit GPUTarget(const Config& c) : Target(c), context(nullptr) { }
+    TestContext* context;
 
     void setup() override {
-        this->gl->makeCurrent();
+        this->context->makeCurrent();
         // Make sure we're done with whatever came before.
-        GR_GL_CALL(this->gl->gl(), Finish());
+        this->context->finish();
     }
     void endTiming() override {
-        if (this->gl) {
-            GR_GL_CALL(this->gl->gl(), Flush());
-            this->gl->waitOnSyncOrSwap();
+        if (this->context) {
+            this->context->waitOnSyncOrSwap();
         }
     }
     void fence() override {
-        GR_GL_CALL(this->gl->gl(), Finish());
+        this->context->finish();
     }
 
     bool needsFrameTiming(int* maxFrameLag) const override {
-        if (!this->gl->getMaxGpuFrameLag(maxFrameLag)) {
+        if (!this->context->getMaxGpuFrameLag(maxFrameLag)) {
             // Frame lag is unknown.
             *maxFrameLag = FLAGS_gpuFrameLag;
         }
@@ -190,12 +187,12 @@ struct GPUTarget : public Target {
                                                                     this->config.ctxOptions),
                                                          SkBudgeted::kNo, info,
                                                          this->config.samples, &props);
-        this->gl = gGrFactory->getContextInfo(this->config.ctxType,
-                                              this->config.ctxOptions).fGLContext;
+        this->context = gGrFactory->getContextInfo(this->config.ctxType,
+                                                   this->config.ctxOptions).testContext();
         if (!this->surface.get()) {
             return false;
         }
-        if (!this->gl->fenceSyncSupport()) {
+        if (!this->context->fenceSyncSupport()) {
             SkDebugf("WARNING: GL context for config \"%s\" does not support fence sync. "
                      "Timings might not be accurate.\n", this->config.name.c_str());
         }
@@ -203,17 +200,21 @@ struct GPUTarget : public Target {
     }
     void fillOptions(ResultsWriter* log) override {
         const GrGLubyte* version;
-        GR_GL_CALL_RET(this->gl->gl(), version, GetString(GR_GL_VERSION));
-        log->configOption("GL_VERSION", (const char*)(version));
+        if (this->context->backend() == kOpenGL_GrBackend) {
+            const GrGLInterface* gl =
+                    reinterpret_cast<const GrGLInterface*>(this->context->backendContext());
+            GR_GL_CALL_RET(gl, version, GetString(GR_GL_VERSION));
+            log->configOption("GL_VERSION", (const char*)(version));
 
-        GR_GL_CALL_RET(this->gl->gl(), version, GetString(GR_GL_RENDERER));
-        log->configOption("GL_RENDERER", (const char*) version);
+            GR_GL_CALL_RET(gl, version, GetString(GR_GL_RENDERER));
+            log->configOption("GL_RENDERER", (const char*) version);
 
-        GR_GL_CALL_RET(this->gl->gl(), version, GetString(GR_GL_VENDOR));
-        log->configOption("GL_VENDOR", (const char*) version);
+            GR_GL_CALL_RET(gl, version, GetString(GR_GL_VENDOR));
+            log->configOption("GL_VENDOR", (const char*) version);
 
-        GR_GL_CALL_RET(this->gl->gl(), version, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
-        log->configOption("GL_SHADING_LANGUAGE_VERSION", (const char*) version);
+            GR_GL_CALL_RET(gl, version, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
+            log->configOption("GL_SHADING_LANGUAGE_VERSION", (const char*) version);
+        }
     }
 };
 
@@ -512,22 +513,15 @@ static Target* is_enabled(Benchmark* bench, const Config& config) {
     return target;
 }
 
-static bool valid_brd_bench(SkData* encoded, SkBitmapRegionDecoder::Strategy strategy,
-        SkColorType colorType, uint32_t sampleSize, uint32_t minOutputSize, int* width,
-        int* height) {
+static bool valid_brd_bench(SkData* encoded, SkColorType colorType, uint32_t sampleSize,
+        uint32_t minOutputSize, int* width, int* height) {
     SkAutoTDelete<SkBitmapRegionDecoder> brd(
-            SkBitmapRegionDecoder::Create(encoded, strategy));
+            SkBitmapRegionDecoder::Create(encoded, SkBitmapRegionDecoder::kAndroidCodec_Strategy));
     if (nullptr == brd.get()) {
         // This is indicates that subset decoding is not supported for a particular image format.
         return false;
     }
 
-    SkBitmap bitmap;
-    if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, brd->width(), brd->height()),
-            1, colorType, false)) {
-        return false;
-    }
-
     if (sampleSize * minOutputSize > (uint32_t) brd->width() || sampleSize * minOutputSize >
             (uint32_t) brd->height()) {
         // This indicates that the image is not large enough to decode a
@@ -567,7 +561,6 @@ public:
                       , fCurrentColorType(0)
                       , fCurrentAlphaType(0)
                       , fCurrentSubsetType(0)
-                      , fCurrentBRDStrategy(0)
                       , fCurrentSampleSize(0)
                       , fCurrentAnimSKP(0) {
         for (int i = 0; i < FLAGS_skps.count(); i++) {
@@ -606,7 +599,7 @@ public:
         fUseMPDs.push_back() = false;
 
         // Prepare the images for decoding
-        if (!CollectImages(&fImages)) {
+        if (!CollectImages(FLAGS_images, &fImages)) {
             exit(1);
         }
 
@@ -841,15 +834,6 @@ public:
         }
 
         // Run the BRDBenches
-        // We will benchmark multiple BRD strategies.
-        static const struct {
-            SkBitmapRegionDecoder::Strategy    fStrategy;
-            const char*                        fName;
-        } strategies[] = {
-            { SkBitmapRegionDecoder::kCanvas_Strategy,       "BRD_canvas" },
-            { SkBitmapRegionDecoder::kAndroidCodec_Strategy, "BRD_android_codec" },
-        };
-
         // We intend to create benchmarks that model the use cases in
         // android/libraries/social/tiledimage.  In this library, an image is decoded in 512x512
         // tiles.  The image can be translated freely, so the location of a tile may be anywhere in
@@ -865,78 +849,72 @@ public:
         const uint32_t brdSampleSizes[] = { 1, 2, 4, 8, 16 };
         const uint32_t minOutputSize = 512;
         for (; fCurrentBRDImage < fImages.count(); fCurrentBRDImage++) {
+            fSourceType = "image";
+            fBenchType = "BRD";
+
             const SkString& path = fImages[fCurrentBRDImage];
             if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
                 continue;
             }
-            while (fCurrentBRDStrategy < (int) SK_ARRAY_COUNT(strategies)) {
-                fSourceType = "image";
-                fBenchType = strategies[fCurrentBRDStrategy].fName;
-
-                const SkBitmapRegionDecoder::Strategy strategy =
-                        strategies[fCurrentBRDStrategy].fStrategy;
-
-                while (fCurrentColorType < fColorTypes.count()) {
-                    while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(brdSampleSizes)) {
-                        while (fCurrentSubsetType <= kLastSingle_SubsetType) {
-
-                            SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
-                            const SkColorType colorType = fColorTypes[fCurrentColorType];
-                            uint32_t sampleSize = brdSampleSizes[fCurrentSampleSize];
-                            int currentSubsetType = fCurrentSubsetType++;
-
-                            int width = 0;
-                            int height = 0;
-                            if (!valid_brd_bench(encoded.get(), strategy, colorType, sampleSize,
-                                    minOutputSize, &width, &height)) {
+
+            while (fCurrentColorType < fColorTypes.count()) {
+                while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(brdSampleSizes)) {
+                    while (fCurrentSubsetType <= kLastSingle_SubsetType) {
+
+                        SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
+                        const SkColorType colorType = fColorTypes[fCurrentColorType];
+                        uint32_t sampleSize = brdSampleSizes[fCurrentSampleSize];
+                        int currentSubsetType = fCurrentSubsetType++;
+
+                        int width = 0;
+                        int height = 0;
+                        if (!valid_brd_bench(encoded.get(), colorType, sampleSize, minOutputSize,
+                                &width, &height)) {
+                            break;
+                        }
+
+                        SkString basename = SkOSPath::Basename(path.c_str());
+                        SkIRect subset;
+                        const uint32_t subsetSize = sampleSize * minOutputSize;
+                        switch (currentSubsetType) {
+                            case kTopLeft_SubsetType:
+                                basename.append("_TopLeft");
+                                subset = SkIRect::MakeXYWH(0, 0, subsetSize, subsetSize);
+                                break;
+                            case kTopRight_SubsetType:
+                                basename.append("_TopRight");
+                                subset = SkIRect::MakeXYWH(width - subsetSize, 0, subsetSize,
+                                        subsetSize);
+                                break;
+                            case kMiddle_SubsetType:
+                                basename.append("_Middle");
+                                subset = SkIRect::MakeXYWH((width - subsetSize) / 2,
+                                        (height - subsetSize) / 2, subsetSize, subsetSize);
                                 break;
-                            }
-
-                            SkString basename = SkOSPath::Basename(path.c_str());
-                            SkIRect subset;
-                            const uint32_t subsetSize = sampleSize * minOutputSize;
-                            switch (currentSubsetType) {
-                                case kTopLeft_SubsetType:
-                                    basename.append("_TopLeft");
-                                    subset = SkIRect::MakeXYWH(0, 0, subsetSize, subsetSize);
-                                    break;
-                                case kTopRight_SubsetType:
-                                    basename.append("_TopRight");
-                                    subset = SkIRect::MakeXYWH(width - subsetSize, 0, subsetSize,
-                                            subsetSize);
-                                    break;
-                                case kMiddle_SubsetType:
-                                    basename.append("_Middle");
-                                    subset = SkIRect::MakeXYWH((width - subsetSize) / 2,
-                                            (height - subsetSize) / 2, subsetSize, subsetSize);
-                                    break;
-                                case kBottomLeft_SubsetType:
-                                    basename.append("_BottomLeft");
-                                    subset = SkIRect::MakeXYWH(0, height - subsetSize, subsetSize,
-                                            subsetSize);
-                                    break;
-                                case kBottomRight_SubsetType:
-                                    basename.append("_BottomRight");
-                                    subset = SkIRect::MakeXYWH(width - subsetSize,
-                                            height - subsetSize, subsetSize, subsetSize);
-                                    break;
-                                default:
-                                    SkASSERT(false);
-                            }
-
-                            return new BitmapRegionDecoderBench(basename.c_str(), encoded.get(),
-                                    strategy, colorType, sampleSize, subset);
+                            case kBottomLeft_SubsetType:
+                                basename.append("_BottomLeft");
+                                subset = SkIRect::MakeXYWH(0, height - subsetSize, subsetSize,
+                                        subsetSize);
+                                break;
+                            case kBottomRight_SubsetType:
+                                basename.append("_BottomRight");
+                                subset = SkIRect::MakeXYWH(width - subsetSize,
+                                        height - subsetSize, subsetSize, subsetSize);
+                                break;
+                            default:
+                                SkASSERT(false);
                         }
-                        fCurrentSubsetType = 0;
-                        fCurrentSampleSize++;
+
+                        return new BitmapRegionDecoderBench(basename.c_str(), encoded.get(),
+                                colorType, sampleSize, subset);
                     }
-                    fCurrentSampleSize = 0;
-                    fCurrentColorType++;
+                    fCurrentSubsetType = 0;
+                    fCurrentSampleSize++;
                 }
-                fCurrentColorType = 0;
-                fCurrentBRDStrategy++;
+                fCurrentSampleSize = 0;
+                fCurrentColorType++;
             }
-            fCurrentBRDStrategy = 0;
+            fCurrentColorType = 0;
         }
 
         return nullptr;
@@ -1000,7 +978,6 @@ private:
     int fCurrentColorType;
     int fCurrentAlphaType;
     int fCurrentSubsetType;
-    int fCurrentBRDStrategy;
     int fCurrentSampleSize;
     int fCurrentAnimSKP;
 };
@@ -1033,7 +1010,6 @@ int nanobench_main() {
 
 #if SK_SUPPORT_GPU
     GrContextOptions grContextOpts;
-    grContextOpts.fDrawPathToCompressedTexture = FLAGS_gpuCompressAlphaMasks;
     gGrFactory.reset(new GrContextFactory(grContextOpts));
 #endif