try to speed-up maprect + round2i + contains

include/core/SkRect.h

Index: include/core/SkRect.h
diff --git a/include/core/SkRect.h b/include/core/SkRect.h
index 39cbb330f82b207cd6a508570fe41f1372353590..67080d115acb564f40b205e4dd5a0fd68e2d0724 100644
--- a/include/core/SkRect.h
+++ b/include/core/SkRect.h
@@ -10,6 +10,7 @@
 
 #include "SkPoint.h"
 #include "SkSize.h"
+#include "../private/SkNx.h"
 
 struct SkRect;
 
@@ -869,7 +870,20 @@ public:
         this->roundOut(&ir);
         return ir;
     }
-    
+
+    SkIRect round2i() const {

[msarett, 2016/07/11 12:50:06]

On Intel this disassembles to roundps and cvtt?

There is a single Intel instruction to convert float->int with rounding.  I made
an attempt to expose that here:
https://codereview.chromium.org/2134753006/

+        SkIRect dst;
+        Sk4s rd = (Sk4s::Load(&fLeft) + Sk4s(0.5)).floor();

[msarett, 2016/07/11 12:50:06]

Why call floor when the cast will floor anyway?

[mtklein, 2016/07/11 13:39:13]

We've got to make sure we're careful to distinguish the behavior of floor(),
ceil(), round(), and trunc() when dealing with these spatial types which may
contain negative values.  I think it's probably best that we add round(),
ceil(), and floor() calls to Sk4f, so that we're not left wondering whether
implementations in terms of each other are correct.

For what it's  worth, truncating from float->int is cheap and available
everywhere.  Anything else is more complicated.  Generally floor() and ceil()
and round() are going to be about this expensive and error prone:
  - truncate to integer
  - convert back to float
  - see if that result is too small or big
  - add back (wrong ? kFixupConstant : 0) to fix it up

The main caveat is that we cannot round floats to values that are representable
as floats but not integers.  The safest thing might be to never expose an API
that does float -> float rounding.

When we have SSE 4.1 or better on Intel, roundps lifts the
roundtrip-through-ints limitation, and is considerably faster.  We check
dynamically for this today, but it's unclear whether that approach is reliably
faster than the slow caveated SSE2 version.

ARMv8 added similar instructions to NEON.  On ARMv7 we always do the slow
caveated thing.

+        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