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 "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:
     default:
       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:
     default:
       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) ||
+      (to && to->type() == FilterOperation::REFERENCE)) {
+    if (progress > 0.5)

[Stephen White, 2013/07/31 19:18:51]

Heh.. I guess it's better than nothing!  :)

+      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 11 matching lines @@
         from_op.drop_shadow_color(), to_op.drop_shadow_color(), progress));
   } else if (to_op.type() == FilterOperation::ZOOM) {
     blended_filter.set_zoom_inset(std::max(
         BlendInts(from_op.zoom_inset(), to_op.zoom_inset(), progress), 0));
   }
 
   return blended_filter;
 }
 
 }  // namespace cc