Initial error handling code

src/core/SkValidationUtils.h

Index: src/core/SkValidationUtils.h
diff --git a/src/core/SkValidationUtils.h b/src/core/SkValidationUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..f31d86ce2289936c960ff25b556baca7bf14e7b4
--- /dev/null
+++ b/src/core/SkValidationUtils.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkValidationUtils_DEFINED
+#define SkValidationUtils_DEFINED
+
+#include "SkBitmap.h"
+#include "SkXfermode.h"
+
+/** Returns true if coeff's value is in the SkXfermode::Coeff enum.
+  */
+static inline bool SkIsValidCoeff(SkXfermode::Coeff coeff) {

[mtklein, 2013/09/24 22:52:18]

I sort of want these to live with their corresponding enums.  It'll teach people
to write them by example.

I acknowledge that this somewhat contradicts my comment in SkRect about moving
all the code here.  Maybe I was wrong and all the isValid methods belong with
the types?

[sugoi1, 2013/09/25 21:15:27]

I'm not sure about this, but I don't have a strong opinion either way. I'll
follow any guideline that everyone else agrees on :)

+    return coeff >= 0 && coeff < SkXfermode::kCoeffCount;
+}
+
+/** Returns true if mode's value is in the SkXfermode::Mode enum.
+  */
+static inline bool SkIsValidMode(SkXfermode::Mode mode) {
+    return (mode >= 0) && (mode <= SkXfermode::kLastMode);
+}
+
+/** Returns true if config's value is in the SkBitmap::Config enum.
+  */
+static inline bool SkIsValidConfig(SkBitmap::Config config) {
+    return (config >= 0) && (config <= SkBitmap::kLastConfig);
+}
+
+/** Returns true if the rect's dimensions are between 0 and SK_MaxS32
+  */
+static inline bool SkIsValidRect(const SkIRect& rect) {

[mtklein, 2013/09/24 22:52:18]

This is going to be a little confusing.  Let's call it SkIsValidIRect.

That is, unless you want this to just be 

template <typename T>
bool SkIsValid(const T& t);

and then specialize

template <> bool SkIsValid(const SkIRect& irect) { ... }
template <> bool SkIsValid(const SkRect& rect) { ... }

etc.  I think we can argue for either way, though Skia does tend to follow the
old C way of dispatching by putting the type in the method name as you've got
here.  Skia's kind of crotchety like that.  We're even still suspicious of this
newfangled STL and C++98...

[sugoi1, 2013/09/25 21:15:27]

Done.
Yeah, I enjoy templates very much, but it's not really necessary to use them
here, I think. I use them mainly when there's a good use case to significantly
reduce the number of lines of code I have to write or when performance is
critical and I don't care about have the same loop 20 times, with slight
modifications, bloating the executable.

+    return rect.width() >= 0 && rect.height() >= 0;
+}
+
+/** Returns true if the rect's dimensions are between 0 and SK_ScalarMax
+  */
+static inline bool SkIsValidRect(const SkRect& rect) {
+    return !rect.isInverted() &&
+           SkScalarIsFinite(rect.width()) &&
+           SkScalarIsFinite(rect.height());
+}
+
+#endif