Add support for converting cc::FilterOperations into an SkImageFilter

cc/output/filter_operation.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 <algorithm>
 
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/output/filter_operation.h"
 #include "third_party/skia/include/core/SkMath.h"
 
 namespace cc {
 
 bool FilterOperation::operator==(const FilterOperation& other) const {
   if (type_ != other.type_)
     return false;
   if (type_ == COLOR_MATRIX)
     return !memcmp(matrix_, other.matrix_, sizeof(matrix_));
   if (type_ == DROP_SHADOW) {
     return amount_ == other.amount_ &&
            drop_shadow_offset_ == other.drop_shadow_offset_ &&
            drop_shadow_color_ == other.drop_shadow_color_;
   }
+  if (type_ == REFERENCE)
+    return image_filter_.get() == other.image_filter_.get();
   return amount_ == other.amount_;
 }
 
 FilterOperation::FilterOperation(FilterType type, float amount)
     : type_(type),
       amount_(amount),
       drop_shadow_offset_(0, 0),
       drop_shadow_color_(0),
       zoom_inset_(0) {
   DCHECK_NE(type_, DROP_SHADOW);
   DCHECK_NE(type_, COLOR_MATRIX);
+  DCHECK_NE(type_, REFERENCE);
   memset(matrix_, 0, sizeof(matrix_));
 }
 
 FilterOperation::FilterOperation(FilterType type,
                                  gfx::Point offset,
                                  float stdDeviation,
                                  SkColor color)
     : type_(type),
       amount_(stdDeviation),
       drop_shadow_offset_(offset),
@@ skipping 16 matching lines @@
 FilterOperation::FilterOperation(FilterType type, float amount, int inset)
     : type_(type),
       amount_(amount),
       drop_shadow_offset_(0, 0),
       drop_shadow_color_(0),
       zoom_inset_(inset) {
   DCHECK_EQ(type_, ZOOM);
   memset(matrix_, 0, sizeof(matrix_));
 }
 
+FilterOperation::FilterOperation(
+    FilterType type,
+    const skia::RefPtr<SkImageFilter>& image_filter)
+    : type_(type),
+      amount_(0),
+      drop_shadow_offset_(0, 0),
+      drop_shadow_color_(0),
+      image_filter_(image_filter),
+      zoom_inset_(0) {
+  DCHECK_EQ(type_, REFERENCE);
+  DCHECK(image_filter.get());
+  memset(matrix_, 0, sizeof(matrix_));
+}
+
+FilterOperation::FilterOperation(const FilterOperation& other)
+    : type_(other.type_),
+      amount_(other.amount_),
+      drop_shadow_offset_(other.drop_shadow_offset_),
+      drop_shadow_color_(other.drop_shadow_color_),
+      image_filter_(other.image_filter_),
+      zoom_inset_(other.zoom_inset_) {
+  memcpy(matrix_, other.matrix_, sizeof(matrix_));
+}
+
+FilterOperation::~FilterOperation() {
+}
+
 // TODO(ajuma): Define a version of ui::Tween::ValueBetween for floats, and use
 // that instead.
 static float BlendFloats(float from, float to, double progress) {
   return from * (1.0 - progress) + to * progress;
 }
 
 static int BlendInts(int from, int to, double progress) {
   return static_cast<int>(
       MathUtil::Round(from * (1.0 - progress) + to * progress));
 }
@@ skipping 59 matching lines @@
     case FilterOperation::COLOR_MATRIX: {
       SkScalar matrix[20];
       memset(matrix, 0, 20 * sizeof(SkScalar));
       matrix[0] = matrix[6] = matrix[12] = matrix[18] = 1.f;
       return FilterOperation::CreateColorMatrixFilter(matrix);
     }
     case FilterOperation::ZOOM:
       return FilterOperation::CreateZoomFilter(1.f, 0);
     case FilterOperation::SATURATING_BRIGHTNESS:
       return FilterOperation::CreateSaturatingBrightnessFilter(0.f);
+    case FilterOperation::REFERENCE:
+      NOTREACHED();

[danakj, 2013/09/09 22:04:50]

Can't create an image filter that does nothing?

[ajuma, 2013/09/10 21:17:58]

Done.

+      return FilterOperation::CreateEmptyFilter();
   }
   NOTREACHED();
   return FilterOperation::CreateEmptyFilter();
 }
 
 static float ClampAmountForFilterType(float amount,
                                       FilterOperation::FilterType type) {
   switch (type) {
     case FilterOperation::GRAYSCALE:
     case FilterOperation::SEPIA:
     case FilterOperation::INVERT:
     case FilterOperation::OPACITY:
       return MathUtil::ClampToRange(amount, 0.f, 1.f);
     case FilterOperation::SATURATE:
     case FilterOperation::BRIGHTNESS:
     case FilterOperation::CONTRAST:
     case FilterOperation::BLUR:
     case FilterOperation::DROP_SHADOW:
       return std::max(amount, 0.f);
     case FilterOperation::ZOOM:
       return std::max(amount, 1.f);
     case FilterOperation::HUE_ROTATE:
     case FilterOperation::SATURATING_BRIGHTNESS:
       return amount;
     case FilterOperation::COLOR_MATRIX:
+    case FilterOperation::REFERENCE:
       NOTREACHED();
       return amount;
   }
   NOTREACHED();
   return amount;
 }
 
 // static
 FilterOperation FilterOperation::Blend(const FilterOperation* from,
                                        const FilterOperation* to,
                                        double progress) {
   FilterOperation blended_filter = FilterOperation::CreateEmptyFilter();
 
   if (!from && !to)
     return blended_filter;
 
+  if ((from && from->type() == FilterOperation::REFERENCE) ||

[danakj, 2013/09/09 22:04:50]

If the two types differ, you might get the |to| or |from| operation. But line
236 says you shouldn't. It seems like implementing CreateNoOpFilter would help
keep this function more clear and consistent, allowing you to move this stuff
down further after the earlyouts.

[ajuma, 2013/09/10 21:17:58]

Done.

+      (to && to->type() == FilterOperation::REFERENCE)) {
+    if (progress > 0.5)
+      return to ? *to : blended_filter;
+    else
+      return from ? *from : blended_filter;
+  }
+
   const FilterOperation& from_op = from ? *from : CreateNoOpFilter(to->type());
   const FilterOperation& to_op = to ? *to : CreateNoOpFilter(from->type());
 
   if (from_op.type() != to_op.type())
     return blended_filter;
 
   DCHECK(to_op.type() != FilterOperation::COLOR_MATRIX);
   blended_filter.set_type(to_op.type());
 
   blended_filter.set_amount(ClampAmountForFilterType(
@@ skipping 42 matching lines @@
       scoped_ptr<ListValue> matrix(new ListValue);
       for (size_t i = 0; i < arraysize(matrix_); ++i)
         matrix->AppendDouble(matrix_[i]);
       value->Set("matrix", matrix.release());
       break;
     }
     case FilterOperation::ZOOM:
       value->SetDouble("amount", amount_);
       value->SetDouble("inset", zoom_inset_);
       break;
+    case FilterOperation::REFERENCE:
+      break;

[danakj, 2013/09/09 22:04:50]

Is there any data about the filter you can give here? How about countInputs()?
And canFilterImageGPU()?

[ajuma, 2013/09/10 21:17:58]

Done.

   }
   return value.PassAs<base::Value>();
 }
 
 }  // namespace cc