Implement canvas's globalCompositeOperation lighter properly....

skia/effects/SkBlurMask.cpp

 /* libs/graphics/effects/SkBlurMask.cpp
 **
 ** Copyright 2006, The Android Open Source Project
 **
 ** Licensed under the Apache License, Version 2.0 (the "License"); 
 ** you may not use this file except in compliance with the License. 
 ** You may obtain a copy of the License at 
 **
 **     http://www.apache.org/licenses/LICENSE-2.0 
 **
@@ skipping 216 matching lines @@
     int ry = rx;    // only do square blur for now
 
     dst->fBounds.set(src.fBounds.fLeft - rx, src.fBounds.fTop - ry,
                         src.fBounds.fRight + rx, src.fBounds.fBottom + ry);
     dst->fRowBytes = SkToU16(dst->fBounds.width());
     dst->fFormat = SkMask::kA8_Format;
     dst->fImage = NULL;
 
     if (src.fImage)
     {
+        size_t dstSize = dst->computeImageSize();
+        if (0 == dstSize) {
+            return false;   // too big to allocate, abort
+        }
+
         int             sw = src.fBounds.width();
         int             sh = src.fBounds.height();
         const uint8_t*  sp = src.fImage;
-        uint8_t*        dp = SkMask::AllocImage(dst->computeImageSize());
+        uint8_t*        dp = SkMask::AllocImage(dstSize);
 
         SkAutoTCallVProc<uint8_t, SkMask_FreeImage> autoCall(dp);
 
         // build the blurry destination
         {
             SkAutoTMalloc<uint32_t> storage(sw * sh);
             uint32_t*               sumBuffer = storage.get();
 
             build_sum_buffer(sumBuffer, sw, sh, sp, src.fRowBytes);
             if (outer_weight == 255)
                 apply_kernel(dp, rx, ry, sumBuffer, sw, sh);
             else
                 apply_kernel_interp(dp, rx, ry, sumBuffer, sw, sh, outer_weight);
         }
 
         dst->fImage = dp;
         // if need be, alloc the "real" dst (same size as src) and copy/merge
         // the blur into it (applying the src)
         if (style == kInner_Style)
         {
-            dst->fImage = SkMask::AllocImage(src.computeImageSize());
+            size_t srcSize = src.computeImageSize();
+            if (0 == srcSize) {
+                return false;   // too big to allocate, abort
+            }
+            dst->fImage = SkMask::AllocImage(srcSize);
             merge_src_with_blur(dst->fImage, sp, sw, sh,
                                 dp + rx + ry*dst->fBounds.width(),
                                 dst->fBounds.width());
             SkMask::FreeImage(dp);
         }
         else if (style != kNormal_Style)
         {
             clamp_with_orig(dp + rx + ry*dst->fBounds.width(),
                             dst->fBounds.width(),
                             sp, sw, sh,
@@ skipping 51 matching lines @@
 
     for (int i = 0; i < 256; i++)
     {
         int square = i * i;
         int linear = i * 255;
         int n = SkAlphaBlend(square, linear, scale);
         gamma[i] = SkToU8(n * div255 >> 16);
     }
 }
 #endif