| Index: cc/output/filter_operations.cc
|
| diff --git a/cc/output/filter_operations.cc b/cc/output/filter_operations.cc
|
| deleted file mode 100644
|
| index dc18a228d168a8283826459aa05ada8bf3a493c0..0000000000000000000000000000000000000000
|
| --- a/cc/output/filter_operations.cc
|
| +++ /dev/null
|
| @@ -1,256 +0,0 @@
|
| -// 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 "cc/output/filter_operations.h"
|
| -
|
| -#include <stddef.h>
|
| -
|
| -#include <cmath>
|
| -#include <numeric>
|
| -
|
| -#include "base/trace_event/trace_event_argument.h"
|
| -#include "base/values.h"
|
| -#include "cc/output/filter_operation.h"
|
| -#include "ui/gfx/geometry/rect.h"
|
| -
|
| -namespace cc {
|
| -
|
| -FilterOperations::FilterOperations() {}
|
| -
|
| -FilterOperations::FilterOperations(const FilterOperations& other)
|
| - : operations_(other.operations_) {}
|
| -
|
| -FilterOperations::FilterOperations(std::vector<FilterOperation>&& operations)
|
| - : operations_(std::move(operations)) {}
|
| -
|
| -FilterOperations::~FilterOperations() {}
|
| -
|
| -FilterOperations& FilterOperations::operator=(const FilterOperations& other) {
|
| - operations_ = other.operations_;
|
| - return *this;
|
| -}
|
| -
|
| -FilterOperations& FilterOperations::operator=(FilterOperations&& other) {
|
| - operations_ = std::move(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) {
|
| - // Corresponds to MapStdDeviation in filter_operation.cc.
|
| - return std_deviation * 3;
|
| -}
|
| -
|
| -gfx::Rect FilterOperations::MapRect(const gfx::Rect& rect,
|
| - const SkMatrix& matrix) const {
|
| - auto accumulate_rect = [matrix](const gfx::Rect& rect,
|
| - const FilterOperation& op) {
|
| - return op.MapRect(rect, matrix);
|
| - };
|
| - return std::accumulate(operations_.begin(), operations_.end(), rect,
|
| - accumulate_rect);
|
| -}
|
| -
|
| -gfx::Rect FilterOperations::MapRectReverse(const gfx::Rect& rect,
|
| - const SkMatrix& matrix) const {
|
| - auto accumulate_rect = [&matrix](const gfx::Rect& rect,
|
| - const FilterOperation& op) {
|
| - return op.MapRectReverse(rect, matrix);
|
| - };
|
| - return std::accumulate(operations_.rbegin(), operations_.rend(), rect,
|
| - accumulate_rect);
|
| -}
|
| -
|
| -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];
|
| - // TODO(hendrikw): We should refactor some of this. See crbug.com/523534.
|
| - if (op.type() == FilterOperation::REFERENCE) {
|
| - if (!op.image_filter())
|
| - continue;
|
| - SkIRect src = SkIRect::MakeWH(0, 0);
|
| - SkIRect dst = op.image_filter()->filterBounds(src, SkMatrix::I());
|
| - *top += std::max(0, -dst.top());
|
| - *right += std::max(0, dst.right());
|
| - *bottom += std::max(0, dst.bottom());
|
| - *left += std::max(0, -dst.left());
|
| - } else {
|
| - 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 += std::max(0, spread - op.drop_shadow_offset().y());
|
| - *right += std::max(0, spread + op.drop_shadow_offset().x());
|
| - *bottom += std::max(0, spread + op.drop_shadow_offset().y());
|
| - *left += std::max(0, 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::BLUR:
|
| - case FilterOperation::DROP_SHADOW:
|
| - case FilterOperation::ZOOM:
|
| - return true;
|
| - case FilterOperation::REFERENCE:
|
| - // TODO(hendrikw): SkImageFilter needs a function that tells us if the
|
| - // filter can move pixels. See crbug.com/523538.
|
| - 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:
|
| - case FilterOperation::ALPHA_THRESHOLD:
|
| - break;
|
| - }
|
| - }
|
| - return false;
|
| -}
|
| -
|
| -bool FilterOperations::HasFilterThatAffectsOpacity() const {
|
| - for (size_t i = 0; i < operations_.size(); ++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:
|
| - case FilterOperation::ALPHA_THRESHOLD:
|
| - 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 {
|
| - if (HasReferenceFilter() || from.HasReferenceFilter())
|
| - return *this;
|
| -
|
| - bool from_is_longer = from.size() > size();
|
| -
|
| - size_t shorter_size, longer_size;
|
| - if (size() == from.size()) {
|
| - shorter_size = longer_size = size();
|
| - } else if (from_is_longer) {
|
| - longer_size = from.size();
|
| - shorter_size = size();
|
| - } else {
|
| - longer_size = size();
|
| - shorter_size = from.size();
|
| - }
|
| -
|
| - for (size_t i = 0; i < shorter_size; i++) {
|
| - if (from.at(i).type() != at(i).type())
|
| - return *this;
|
| - }
|
| -
|
| - FilterOperations blended_filters;
|
| - for (size_t i = 0; i < shorter_size; i++) {
|
| - blended_filters.Append(
|
| - FilterOperation::Blend(&from.at(i), &at(i), progress));
|
| - }
|
| -
|
| - if (from_is_longer) {
|
| - for (size_t i = shorter_size; i < longer_size; i++) {
|
| - blended_filters.Append(
|
| - FilterOperation::Blend(&from.at(i), NULL, progress));
|
| - }
|
| - } else {
|
| - for (size_t i = shorter_size; i < longer_size; i++)
|
| - blended_filters.Append(FilterOperation::Blend(NULL, &at(i), progress));
|
| - }
|
| -
|
| - return blended_filters;
|
| -}
|
| -
|
| -void FilterOperations::AsValueInto(
|
| - base::trace_event::TracedValue* value) const {
|
| - for (size_t i = 0; i < operations_.size(); ++i) {
|
| - value->BeginDictionary();
|
| - operations_[i].AsValueInto(value);
|
| - value->EndDictionary();
|
| - }
|
| -}
|
| -
|
| -std::string FilterOperations::ToString() const {
|
| - base::trace_event::TracedValue value;
|
| - value.BeginArray("FilterOperations");
|
| - AsValueInto(&value);
|
| - value.EndArray();
|
| - return value.ToString();
|
| -}
|
| -
|
| -} // namespace cc
|
|
|