try to speed-up maprect + round2i + contains

include/core/SkRect.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRect_DEFINED
 #define SkRect_DEFINED
 
 #include "SkPoint.h"
 #include "SkSize.h"
+#include "../private/SkNx.h"
 
 struct SkRect;
 
 /** \struct SkIRect
 
     SkIRect holds four 32 bit integer coordinates for a rectangle
 */
 struct SK_API SkIRect {
     int32_t fLeft, fTop, fRight, fBottom;
 
@@ skipping 839 matching lines @@
         this->round(&ir);
         return ir;
     }
     
     //! Returns the result of calling roundOut(&dst)
     SkIRect roundOut() const {
         SkIRect ir;
         this->roundOut(&ir);
         return ir;
     }
-    
+
+    SkIRect round2i() const {
+        SkIRect dst;
+        Sk4s rd = (Sk4s::Load(&fLeft) + Sk4s(0.5)).floor();

[mtklein, 2016/07/11 17:28:34]

I can see at least three different methods of rounding which agree for most
numbers, but differ when rounding x = N.5f, for various N.

1) floorf(x + 0.5f)  (round to nearest, breaking .5 towards +inf)
2) roundf(x)         (round to nearest, breaking .5 away from zero)
3) nearbyintf(x)     (round to nearest, breaking .5 towards even)

Do we care about what happens on the .5 border?  When we do have instructions to
implement these functions, those instructions implement roundf(x), floorf(x),
ceilf(x), and nearbyintf(x) directly, but floorf(x+0.5f) requires two steps. 
That's true for both x86 and ARMv8.

[reed1, 2016/07/11 19:03:54]

For coordinates (cpu and gpu), we need a direction that is invariant for all
values. Towards +inf is nice in that it is the same as our fixed-point behavior
(x + 0x8000 >> 16). I think we can only use #1 for coordinates.

+        SkNx_cast<int32_t>(rd).store(&dst.fLeft);
+        return dst;
+    }
+
+    SkRect round2s() const {
+        SkRect dst;
+        (Sk4s::Load(&fLeft) + Sk4s(0.5)).floor().store(&dst.fLeft);
+        return dst;
+    }
+
     /**
      *  Swap top/bottom or left/right if there are flipped (i.e. if width()
      *  or height() would have returned a negative value.) This should be called
      *  if the edges are computed separately, and may have crossed over each
      *  other. When this returns, left <= right && top <= bottom
      */
     void sort() {
         if (fLeft > fRight) {
             SkTSwap<SkScalar>(fLeft, fRight);
         }
@@ skipping 13 matching lines @@
     void dumpHex() const { this->dump(true); }
 };
 
 inline bool SkIRect::contains(const SkRect& r) const {
     return  !r.isEmpty() && !this->isEmpty() &&     // check for empties
             (SkScalar)fLeft <= r.fLeft && (SkScalar)fTop <= r.fTop &&
             (SkScalar)fRight >= r.fRight && (SkScalar)fBottom >= r.fBottom;
 }
 
 #endif