Implement GPU occluded blur mask filter

bench/BlurOccludedRRectBench.cpp

 /*
  * 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 "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
@@ skipping 17 matching lines @@
     void onDraw(int loops, SkCanvas* canvas) override {
         for (int l = 0; l < loops; ++l) {
             canvas->clear(0xFFFAFAFA);
 
             SkPaint opaque;
             opaque.setAntiAlias(true);
             opaque.setColor(SK_ColorWHITE);
 
             const SkRect r = SkRect::MakeWH(480, 230);
             const SkRRect rr = SkRRect::MakeRectXY(r, 8, 8);
-            //SkRect occRect = sk_tool_utils::compute_central_occluder(rr);
+            SkRect occRect = sk_tool_utils::compute_central_occluder(rr);
 
             for (int i = 0; i < 2; ++i) {
                 canvas->save();
 
                 canvas->translate(i*502.0f+20, 10.0f);
 
                 for (int j = 0; j < 8; ++j) {
                     canvas->save();
 
                         canvas->translate(0.0f, j*256.0f);
 
                         SkPaint firstBlur;
                         firstBlur.setAntiAlias(true);
                         firstBlur.setColor(0x09000000);
                         firstBlur.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
-                                                                       2.5f));
-                                                                       //, occRect));
+                                                                       2.5f,
+                                                                       occRect));
 
                         canvas->drawRRect(rr, firstBlur);
 
                         canvas->save();
                             canvas->translate(1.5f, 1.5f);
 
                             SkPaint secondBlur;
                             secondBlur.setAntiAlias(true);
                             secondBlur.setColor(0x30000000);
                             secondBlur.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
-                                                                            6.0f));
-                                                                            //, occRect));
+                                                                            6.0f,
+                                                                            occRect));
 
                             canvas->drawRRect(rr, secondBlur);
 
                         canvas->restore();
 
                         canvas->drawRRect(rr, opaque);
 
                     canvas->restore();
                 }
 
                 canvas->restore();
             }
         }
     }
 
 private:
     typedef Benchmark INHERITED;
 };
 
 DEF_BENCH(return new BlurOccludedRRectBench();)