Add support for converting cc::FilterOperations into an SkImageFilter

cc/output/filter_operations.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cmath>
 
 #include "cc/output/filter_operations.h"
 
 #include "base/values.h"
 #include "cc/output/filter_operation.h"
@@ skipping 41 matching lines @@
   float d = floorf(std_deviation * 3.f * sqrt(8.f * atan(1.f)) / 4.f + 0.5f);
   return static_cast<int>(ceilf(d * 3.f / 2.f));
 }
 
 void FilterOperations::GetOutsets(int* top,
                                   int* right,
                                   int* bottom,
                                   int* left) const {
   *top = *right = *bottom = *left = 0;
   for (size_t i = 0; i < operations_.size(); ++i) {
-    const FilterOperation op = operations_[i];
+    const FilterOperation& op = operations_[i];
+    // TODO(ajuma): Add support for reference filters once SkImageFilter
+    // reports its outsets.
+    DCHECK(op.type() != FilterOperation::REFERENCE);
     if (op.type() == FilterOperation::BLUR ||
         op.type() == FilterOperation::DROP_SHADOW) {
       int spread = SpreadForStdDeviation(op.amount());
       if (op.type() == FilterOperation::BLUR) {
         *top += spread;
         *right += spread;
         *bottom += spread;
         *left += spread;
       } else {
         *top += spread - op.drop_shadow_offset().y();
         *right += spread + op.drop_shadow_offset().x();
         *bottom += spread + op.drop_shadow_offset().y();
         *left += spread - op.drop_shadow_offset().x();
       }
     }
   }
 }
 
 bool FilterOperations::HasFilterThatMovesPixels() const {
   for (size_t i = 0; i < operations_.size(); ++i) {
-    const FilterOperation op = operations_[i];
+    const FilterOperation& op = operations_[i];
+    // TODO(ajuma): Add support for reference filters once SkImageFilter
+    // reports its outsets.
+    DCHECK(op.type() != FilterOperation::REFERENCE);

[enne (OOO), 2013/09/11 17:57:24]

This is a little awkward to DCHECK here because it means that calling code has
some subtlety (e.g. in layer_tree_host_common.cc) that they have to check for
HasReferenceFilter first before checking HasFilterThatMovesPixels.  I think it'd
be better to remove this DCHECK entirely.

[danakj, 2013/09/11 18:01:55]

I'd agree if the damage tracker didn't use invalid data when
HasFilterThatMovesPixels is true for a reference filter.. what do you think of
that?

[enne (OOO), 2013/09/11 18:06:33]

So DCHECK in GetOutsets, but don't DCHECK here?

[danakj, 2013/09/11 18:18:17]

Hm, ya okay. I hadn't considered that originally. That's a good idea. SGTM
thanks

[ajuma, 2013/09/11 18:24:56]

Done.

     switch (op.type()) {
       case FilterOperation::BLUR:
       case FilterOperation::DROP_SHADOW:
       case FilterOperation::ZOOM:
+      case FilterOperation::REFERENCE:
         return true;
       case FilterOperation::OPACITY:
       case FilterOperation::COLOR_MATRIX:
       case FilterOperation::GRAYSCALE:
       case FilterOperation::SEPIA:
       case FilterOperation::SATURATE:
       case FilterOperation::HUE_ROTATE:
       case FilterOperation::INVERT:
       case FilterOperation::BRIGHTNESS:
       case FilterOperation::CONTRAST:
       case FilterOperation::SATURATING_BRIGHTNESS:
         break;
     }
   }
   return false;
 }
 
 bool FilterOperations::HasFilterThatAffectsOpacity() const {
   for (size_t i = 0; i < operations_.size(); ++i) {
-    const FilterOperation op = operations_[i];
+    const FilterOperation& op = operations_[i];
+    // TODO(ajuma): Make this smarter for reference filters. Once SkImageFilter
+    // can report affectsOpacity(), call that.
     switch (op.type()) {
       case FilterOperation::OPACITY:
       case FilterOperation::BLUR:
       case FilterOperation::DROP_SHADOW:
       case FilterOperation::ZOOM:
+      case FilterOperation::REFERENCE:
         return true;
       case FilterOperation::COLOR_MATRIX: {
         const SkScalar* matrix = op.matrix();
         if (matrix[15] ||
             matrix[16] ||
             matrix[17] ||
             matrix[18] != 1 ||
             matrix[19])
           return true;
         break;
       }
       case FilterOperation::GRAYSCALE:
       case FilterOperation::SEPIA:
       case FilterOperation::SATURATE:
       case FilterOperation::HUE_ROTATE:
       case FilterOperation::INVERT:
       case FilterOperation::BRIGHTNESS:
       case FilterOperation::CONTRAST:
       case FilterOperation::SATURATING_BRIGHTNESS:
         break;
     }
   }
   return false;
 }
 
+bool FilterOperations::HasReferenceFilter() const {
+  for (size_t i = 0; i < operations_.size(); ++i) {
+    if (operations_[i].type() == FilterOperation::REFERENCE)
+      return true;
+  }
+  return false;
+}
+
 FilterOperations FilterOperations::Blend(const FilterOperations& from,
                                          double progress) const {
   FilterOperations blended_filters;
   if (from.size() == 0) {
     for (size_t i = 0; i < size(); i++)
       blended_filters.Append(FilterOperation::Blend(NULL, &at(i), progress));
     return blended_filters;
   }
 
   if (size() == 0) {
@@ skipping 21 matching lines @@
 }
 
 scoped_ptr<base::Value> FilterOperations::AsValue() const {
   scoped_ptr<base::ListValue> value(new ListValue);
   for (size_t i = 0; i < operations_.size(); ++i)
     value->Append(operations_[i].AsValue().release());
   return value.PassAs<base::Value>();
 }
 
 }  // namespace cc