Update SkPMFloat API a bit.

src/core/SkPMFloat.h

 #ifndef SkPM_DEFINED
 #define SkPM_DEFINED
 
 #include "SkTypes.h"
 #include "SkColor.h"
 #include "Sk4x.h"
 
-// A pre-multiplied color storing each component as a float in the range [0, 255].
+// A pre-multiplied color storing each component in the same order as SkPMColor,
+// but as a float in the range [0, 255].
 class SK_STRUCT_ALIGN(16) SkPMFloat {
 public:
+    explicit SkPMFloat(SkPMColor);

[reed1, 2015/03/04 16:00:38]

I'm not sure if constructors are "safer" than factories, since the constructor
can't "name" its parameters. Can we try adding factories for these as well, and
then see how people used it?

e.g.

static SkPMFloat NewFromPMColor(...);
static SkPMFloat NewARGB(float ...)
(or other names/variants)

[mtklein, 2015/03/04 18:16:00]

Done.

+    SkPMFloat(float a, float r, float g, float b) {
+        // TODO: faster when specialized?
+        fColor[SK_A32_SHIFT / 8] = a;
+        fColor[SK_R32_SHIFT / 8] = r;
+        fColor[SK_G32_SHIFT / 8] = g;
+        fColor[SK_B32_SHIFT / 8] = b;
+        SkASSERT(this->isValid());
+    }
+
     // Normal POD copies and do-nothing initialization.
     SkPMFloat()                            = default;
     SkPMFloat(const SkPMFloat&)            = default;
     SkPMFloat& operator=(const SkPMFloat&) = default;
 
     // Freely autoconvert between SkPMFloat and Sk4f.
     /*implicit*/ SkPMFloat(const Sk4f& fs) { fs.storeAligned(fColor); }
     /*implicit*/ operator Sk4f() const { return Sk4f::LoadAligned(fColor); }
 
     float a() const { return fColor[SK_A32_SHIFT / 8]; }
     float r() const { return fColor[SK_R32_SHIFT / 8]; }
     float g() const { return fColor[SK_G32_SHIFT / 8]; }
     float b() const { return fColor[SK_B32_SHIFT / 8]; }
 
-    void setA(float val) { fColor[SK_A32_SHIFT / 8] = val; }
-    void setR(float val) { fColor[SK_R32_SHIFT / 8] = val; }
-    void setG(float val) { fColor[SK_G32_SHIFT / 8] = val; }
-    void setB(float val) { fColor[SK_B32_SHIFT / 8] = val; }
-
-    void set(SkPMColor);
-
     // get() and clamped() round component values to the nearest integer.
     SkPMColor     get() const;  // May SkASSERT(this->isValid()).  Some implementations may clamp.
     SkPMColor clamped() const;  // Will clamp all values to [0, 255].  Then may assert isValid().
 
     bool isValid() const {
         return this->a() >= 0 && this->a() <= 255
             && this->r() >= 0 && this->r() <= this->a()
             && this->g() >= 0 && this->g() <= this->a()
             && this->b() >= 0 && this->b() <= this->a();
     }
 
 private:
-    // We mirror SkPMColor order only to make set()/get()/clamped() as fast as possible.
     float fColor[4];
 };
 
 #if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
     #include "../opts/SkPMFloat_SSE2.h"
 #elif defined(__ARM_NEON__)
     #include "../opts/SkPMFloat_neon.h"
 #else
     #include "../opts/SkPMFloat_none.h"
 #endif
 
 #endif//SkPM_DEFINED