This CL updates chrome to the latest version of skia, retrieved via DEPS, and

placed in third_party.  All relevant skia changes (for all 3 platforms) have
been upstreamed.

Most of this CL is mind-numbingly repetitive.  Things of interest are:  skia.gyp
(now points at third_party versions), DEPS, and SkUserConfig.h.  stdint.h:  Skia
now requires C99 integer types, which MSVC doesn't support natively.  I have put
typedefs in config/win/stdint.h.

Note that the new version of skia appears to render rects whose coordinates
are "backwards" (ie., x2 < x1 or y2 < y1), which were formerly culled.  There
were a couple obvious instances of this in the code which I fixed, but there may
be more.

There were ~35 layout test failures due to minor pixel differences which I
rebaselined on Windows and Linux, and 8 genuine failures related to masks and
stroked text, which I have put in text_expectations.txt and assigned to
myself.  (There was another change which broke ~1700 tests on each platform,
but I put that change behind an #ifdef for now).

R=brettw

Review URL: http://codereview.chromium.org/65012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15949 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 58 insertions, 0 deletions

diff --git a/skia/ext/SkMemory_new_handler.cpp b/skia/ext/SkMemory_new_handler.cpp
new file mode 100644
index 0000000..7e45d26
--- /dev/null
+++ b/skia/ext/SkMemory_new_handler.cpp
@@ -0,0 +1,58 @@
+#include "SkTypes.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <new>
+
+// This implementation of sk_malloc_flags() and friends is identical
+// to SkMemory_malloc.c, except that it disables the CRT's new_handler
+// during malloc(), when SK_MALLOC_THROW is not set (ie., when
+// sk_malloc_flags() would not abort on NULL).
+
+void sk_throw() {
+    SkASSERT(!"sk_throw");
+    abort();
+}
+
+void sk_out_of_memory(void) {
+    SkASSERT(!"sk_out_of_memory");
+    abort();
+}
+
+void* sk_malloc_throw(size_t size) {
+    return sk_malloc_flags(size, SK_MALLOC_THROW);
+}
+
+void* sk_realloc_throw(void* addr, size_t size) {
+    void* p = realloc(addr, size);
+    if (size == 0) {
+        return p;
+    }
+    if (p == NULL) {
+        sk_throw();
+    }
+    return p;
+}
+
+void sk_free(void* p) {
+    if (p) {
+        free(p);
+    }
+}
+
+void* sk_malloc_flags(size_t size, unsigned flags) {
+    std::new_handler old_handler;
+    if (!(flags & SK_MALLOC_THROW)) {
+      old_handler = std::set_new_handler(NULL);
+    }
+    void* p = malloc(size);
+    if (!(flags & SK_MALLOC_THROW)) {
+      std::set_new_handler(old_handler);
+    }
+    if (p == NULL) {
+        if (flags & SK_MALLOC_THROW) {
+            sk_throw();
+        }
+    }
+    return p;
+}
+