Fix overly restrictive PaintOp blend mode validation

It's valid to use extended blend modes in PaintFlags, just not on
DrawColor.  Oops.

Bug: 737629
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I0796d31a9688685d58e5efb3a07f5eb5c270184d
Reviewed-on: https://chromium-review.googlesource.com/589815
Commit-Queue: enne <enne@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#490734}

cc/paint/paint_op_buffer.cc

@@ -840,7 +840,7 @@ PaintOp* DrawColorOp::Deserialize(const void* input,
                                   size_t output_size) {
   DrawColorOp* op =
       SimpleDeserialize<DrawColorOp>(input, input_size, output, output_size);
-  return op && IsValidSkBlendMode(op->mode) ? op : nullptr;
+  return op && IsValidDrawColorSkBlendMode(op->mode) ? op : nullptr;
 }
 
 PaintOp* DrawDRRectOp::Deserialize(const void* input,

cc/paint/paint_op_buffer.h

@@ -154,11 +154,18 @@ class CC_PAINT_EXPORT PaintOp {
   // memory buffers and so don't have their destructors run automatically.
   void DestroyThis();
 
-  static bool IsValidSkBlendMode(SkBlendMode mode) {
+  // DrawColor is more restrictive on the blend modes that can be used.
+  static bool IsValidDrawColorSkBlendMode(SkBlendMode mode) {
     return static_cast<uint32_t>(mode) <=
            static_cast<uint32_t>(SkBlendMode::kLastCoeffMode);
   }
 
+  // PaintFlags can have more complex blend modes than DrawColor.
+  static bool IsValidPaintFlagsSkBlendMode(SkBlendMode mode) {
+    return static_cast<uint32_t>(mode) <=
+           static_cast<uint32_t>(SkBlendMode::kLastMode);
+  }
+
   static bool IsValidSkClipOp(SkClipOp op) {
     return static_cast<uint32_t>(op) <=
            static_cast<uint32_t>(SkClipOp::kMax_EnumValue);

cc/paint/paint_op_buffer_unittest.cc

@@ -2295,10 +2295,12 @@ TEST(PaintOpBufferTest, ValidateSkBlendMode) {
 
   // Successful first two ops.
   buffer.push<DrawColorOp>(SK_ColorMAGENTA, SkBlendMode::kDstIn);
-  buffer.push<DrawRectOp>(test_rects[0], test_flags[0]);
+  PaintFlags good_flags = test_flags[0];
+  good_flags.setBlendMode(SkBlendMode::kColorBurn);
+  buffer.push<DrawRectOp>(test_rects[0], good_flags);
 
   // Modes that are not supported by drawColor or SkPaint.
-  SkBlendMode bad_modes[] = {
+  SkBlendMode bad_modes_for_draw_color[] = {
       SkBlendMode::kOverlay,
       SkBlendMode::kDarken,
       SkBlendMode::kLighten,
@@ -2318,11 +2320,19 @@ TEST(PaintOpBufferTest, ValidateSkBlendMode) {
       static_cast<SkBlendMode>(static_cast<uint32_t>(~0)),
   };
 
-  for (size_t i = 0; i < arraysize(bad_modes); ++i) {
-    buffer.push<DrawColorOp>(SK_ColorMAGENTA, bad_modes[i]);
+  SkBlendMode bad_modes_for_flags[] = {
+      static_cast<SkBlendMode>(static_cast<uint32_t>(SkBlendMode::kLastMode) +
+                               1),
+      static_cast<SkBlendMode>(static_cast<uint32_t>(~0)),
+  };
+
+  for (size_t i = 0; i < arraysize(bad_modes_for_draw_color); ++i) {
+    buffer.push<DrawColorOp>(SK_ColorMAGENTA, bad_modes_for_draw_color[i]);
+  }
 
+  for (size_t i = 0; i < arraysize(bad_modes_for_flags); ++i) {
     PaintFlags flags = test_flags[i % test_flags.size()];
-    flags.setBlendMode(bad_modes[i]);
+    flags.setBlendMode(bad_modes_for_flags[i]);
     buffer.push<DrawRectOp>(test_rects[i % test_rects.size()], flags);
   }
 

cc/paint/paint_op_reader.cc

@@ -121,7 +121,7 @@ void PaintOpReader::Read(PaintFlags* flags) {
   Read(&flags->width_);
   Read(&flags->miter_limit_);
   ReadSimple(&flags->blend_mode_);
-  if (!PaintOp::IsValidSkBlendMode(flags->getBlendMode()))
+  if (!PaintOp::IsValidPaintFlagsSkBlendMode(flags->getBlendMode()))
     valid_ = false;
   ReadSimple(&flags->bitfields_uint_);