SkValue: improve SkFromValue<T> implementation

src/core/SkValue.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 <unordered_map>
 #include <vector>
 
@@ skipping 117 matching lines @@
 SkData* SkValue::bytes() const {
     SkASSERT(this->isData());
     return fBytes;
 }
 
 void SkValue::set(SkValue::Key k, SkValue v) {
     SkASSERT(this->isObject());
     fObject->set(k, std::move(v));
 }
 
+const SkValue* SkValue::get(Key k) const {
+    SkASSERT(this->isObject());
+    return fObject->get(k);
+}
+
 void SkValue::foreach(std::function<void(Key, const SkValue&)> fn) const {
     SkASSERT(this->isObject());
     fObject->foreach(fn);
 }
 
 size_t SkValue::length() const {
     SkASSERT(Array == fType);
     return fArray->length();
 }
 
@@ skipping 27 matching lines @@
     SkASSERT(0 == (reinterpret_cast<uintptr_t>(data->bytes()) & (sizeof(T)-1)));
     return val;
 }
 
 SkValue SkValue::FromU16s(SkData* d) { return FromTs<uint16_t>(U16s, d); }
 SkValue SkValue::FromU32s(SkData* d) { return FromTs<uint32_t>(U32s, d); }
 SkValue SkValue::FromF32s(SkData* d) { return FromTs<   float>(F32s, d); }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#define REQUIRE(cond) do { if (!(cond)) { SkASSERT(false); return false; } } while (false)
+
 template<> SkValue SkToValue<SkMatrix>(const SkMatrix& mat) {
     auto val = SkValue::Object(SkValue::Matrix);
     for (int i = 0; i < 9; ++i) {
         if (mat[i] != SkMatrix::I()[i]) {
             val.set(i, SkValue::FromF32(mat[i]));
         }
     }
     return val;
 }
 
+template<> bool SkFromValue<float>(const SkValue& val, float* f) {
+    REQUIRE(val.type() == SkValue::F32);
+    *f = val.f32();
+    return true;
+}
+
 template<> bool SkFromValue<SkMatrix>(const SkValue& val, SkMatrix* m){
-    SkASSERT(val.type() == SkValue::Matrix);
-    if (val.type() != SkValue::Matrix) {
-        return false;
+    REQUIRE(val.type() == SkValue::Matrix);
+
+    *m = SkMatrix::I();
+    for (int i = 0; i < 9; i++) {
+        if (auto v = val.get(i)) {
+            REQUIRE(SkFromValue(*v, &(*m)[i]));
+        }
     }
-    *m = SkMatrix::I();
-    bool good = true;
-    auto fn = [&](SkValue::Key key, const SkValue& v) {
-        if (key < 9) {
-            if (v.type() != SkValue::F32) {
-                SkASSERT(false);
-                good = false;
-            } else {
-                (*m)[key] = v.f32();
-            }
-        } else {
-            SkASSERT(false);
-            good = false;
-        }
-    };
-    val.foreach(fn);
-    return good;
+    return true;
 }
+
+#undef REQUIRE