Move implementation of WebFilterOperations into cc

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_operation.h"
+#include "cc/output/filter_operations.h"
+
+namespace cc {
+
+FilterOperations::FilterOperations() {
+}

[jamesr, 2013/06/18 23:08:52]

this can go on the previous line with no space between the "{}"s

[ajuma, 2013/06/19 17:08:30]

Done.

+
+FilterOperations::FilterOperations(const FilterOperations& other)
+    : operations_(other.operations_) {
+}
+
+FilterOperations::~FilterOperations() {
+}
+
+FilterOperations& FilterOperations::operator=(const FilterOperations& other) {
+  operations_ = other.operations_;
+  return *this;
+}
+
+bool FilterOperations::operator==(const FilterOperations& other) const {
+  if (other.size() != size())
+    return false;
+  for (size_t i = 0; i < size(); ++i) {
+    if (other.at(i) != at(i))
+      return false;
+  }
+  return true;
+}
+
+void FilterOperations::Append(const FilterOperation& filter) {
+  operations_.push_back(filter);
+}
+
+void FilterOperations::Clear() {
+  operations_.clear();
+}
+
+bool FilterOperations::IsEmpty() const {
+  return operations_.empty();
+}
+
+static int SpreadForStdDeviation(float std_deviation) {
+  // https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html#feGaussianBlurElement
+  // provides this approximation for evaluating a gaussian blur by a triple box
+  // filter.
+  float d = floorf(std_deviation * 3 * sqrt(8.f * atan(1.f)) / 4 + 0.5);
+  return static_cast<int>(ceilf(d * 3 / 2));
+}
+
+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];
+    if (op.type() == FilterOperation::FilterTypeBlur ||
+        op.type() == FilterOperation::FilterTypeDropShadow) {
+      int spread = SpreadForStdDeviation(op.amount());
+      if (op.type() == FilterOperation::FilterTypeBlur) {
+        *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];
+    switch (op.type()) {
+      case FilterOperation::FilterTypeBlur:
+      case FilterOperation::FilterTypeDropShadow:
+      case FilterOperation::FilterTypeZoom:
+        return true;
+      default:
+        break;
+    }
+  }
+  return false;
+}
+
+bool FilterOperations::HasFilterThatAffectsOpacity() const {
+  for (size_t i = 0; i < operations_.size(); ++i) {
+    const FilterOperation op = operations_[i];
+    switch (op.type()) {
+      case FilterOperation::FilterTypeOpacity:
+      case FilterOperation::FilterTypeBlur:
+      case FilterOperation::FilterTypeDropShadow:
+      case FilterOperation::FilterTypeZoom:
+        return true;
+      case FilterOperation::FilterTypeColorMatrix: {
+        const SkScalar* matrix = op.matrix();
+        return matrix[15] || matrix[16] || matrix[17] || matrix[18] != 1 ||
+               matrix[19];

[ajuma, 2013/06/18 14:56:32]

This early return seems wrong, since it means we can return false here even if
later filters in the sequence do affect opacity. Not sure if I should fix this
here or in a follow-up (to avoid introducing behavior changes in this CL).

+      }
+      default:
+        break;
+    }
+  }
+  return false;
+}
+
+}  // namespace cc