diff options
| author | ajuma@chromium.org <ajuma@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-06-25 18:49:29 +0000 |
|---|---|---|
| committer | ajuma@chromium.org <ajuma@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-06-25 18:49:29 +0000 |
| commit | ae6b1a7f60846352cc37858778d30886970f1582 (patch) | |
| tree | 63f3db7cd40160fc2f978ccb1c86f36f589a8a13 /cc | |
| parent | 5e2c4d7c13baad8a246dd1f200636235f07b38d7 (diff) | |
| download | chromium_src-ae6b1a7f60846352cc37858778d30886970f1582.zip chromium_src-ae6b1a7f60846352cc37858778d30886970f1582.tar.gz chromium_src-ae6b1a7f60846352cc37858778d30886970f1582.tar.bz2 | |
Move implementation of WebFilterOperations into cc
This moves the implementation of WebFilterOperations into cc, and
(behind an #ifdef) defines a WebFilterOperationsImpl class that
implements the WebFilterOperations interface by wrapping a
cc::FilterOperations.
With this change, cc and ui/compositor no longer need to include
WebFilterOperations.h.
BUG=181613
Review URL: https://chromiumcodereview.appspot.com/16968002
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@208531 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'cc')
37 files changed, 829 insertions, 282 deletions
@@ -12,8 +12,6 @@ include_rules = [ # DO NOT ADD ANY NEW WEBKIT HEADERS TO THIS LIST. # TODO(danakj): Drop dependencies on WebKit Platform API from cc. "+third_party/WebKit/public/platform/WebAnimationDelegate.h", - "+third_party/WebKit/public/platform/WebFilterOperation.h", - "+third_party/WebKit/public/platform/WebFilterOperations.h", "+third_party/WebKit/public/platform/WebGraphicsContext3D.h", "+third_party/WebKit/public/platform/WebGraphicsMemoryAllocation.h", "+third_party/WebKit/public/platform/WebLayerScrollClient.h", @@ -169,6 +169,10 @@ 'output/delegating_renderer.h', 'output/direct_renderer.cc', 'output/direct_renderer.h', + 'output/filter_operation.cc', + 'output/filter_operation.h', + 'output/filter_operations.cc', + 'output/filter_operations.h', 'output/geometry_binding.cc', 'output/geometry_binding.h', 'output/gl_frame_data.h', diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp index de989d5..1638143 100644 --- a/cc/cc_tests.gyp +++ b/cc/cc_tests.gyp @@ -38,6 +38,7 @@ 'layers/tiled_layer_impl_unittest.cc', 'layers/tiled_layer_unittest.cc', 'output/delegating_renderer_unittest.cc', + 'output/filter_operations_unittest.cc', 'output/gl_renderer_unittest.cc', 'output/output_surface_unittest.cc', 'output/renderer_pixeltest.cc', diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc index 6592a31..1584782 100644 --- a/cc/layers/delegated_renderer_layer_impl_unittest.cc +++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc @@ -553,9 +553,9 @@ class DelegatedRendererLayerImplTestTransform 0, // mask_resource_id child_pass_rect, // contents_changed_since_last_frame gfx::RectF(), // mask_uv_rect - WebKit::WebFilterOperations(), // filters + FilterOperations(), // filters skia::RefPtr<SkImageFilter>(), // filter - WebKit::WebFilterOperations()); // background_filters + FilterOperations()); // background_filters quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data); scoped_ptr<SolidColorDrawQuad> color_quad; @@ -955,9 +955,9 @@ class DelegatedRendererLayerImplTestClip 0, // mask_resource_id child_pass_rect, // contents_changed_since_last_frame gfx::RectF(), // mask_uv_rect - WebKit::WebFilterOperations(), // filters + FilterOperations(), // filters skia::RefPtr<SkImageFilter>(), // filter - WebKit::WebFilterOperations()); // background_filters + FilterOperations()); // background_filters quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data); scoped_ptr<SolidColorDrawQuad> color_quad; diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc index fcdbded..76cf18d 100644 --- a/cc/layers/layer.cc +++ b/cc/layers/layer.cc @@ -111,7 +111,7 @@ void Layer::SetLayerTreeHost(LayerTreeHost* host) { if (host && layer_animation_controller_->has_any_animation()) host->SetNeedsCommit(); if (host && - (!filters_.isEmpty() || !background_filters_.isEmpty() || filter_)) + (!filters_.IsEmpty() || !background_filters_.IsEmpty() || filter_)) layer_tree_host_->set_needs_filter_context(); } @@ -421,14 +421,14 @@ void Layer::SetReplicaLayer(Layer* layer) { SetNeedsFullTreeSync(); } -void Layer::SetFilters(const WebKit::WebFilterOperations& filters) { +void Layer::SetFilters(const FilterOperations& filters) { DCHECK(IsPropertyChangeAllowed()); if (filters_ == filters) return; DCHECK(!filter_); filters_ = filters; SetNeedsCommit(); - if (!filters.isEmpty() && layer_tree_host_) + if (!filters.IsEmpty() && layer_tree_host_) layer_tree_host_->set_needs_filter_context(); } @@ -436,20 +436,20 @@ void Layer::SetFilter(const skia::RefPtr<SkImageFilter>& filter) { DCHECK(IsPropertyChangeAllowed()); if (filter_.get() == filter.get()) return; - DCHECK(filters_.isEmpty()); + DCHECK(filters_.IsEmpty()); filter_ = filter; SetNeedsCommit(); if (filter && layer_tree_host_) layer_tree_host_->set_needs_filter_context(); } -void Layer::SetBackgroundFilters(const WebKit::WebFilterOperations& filters) { +void Layer::SetBackgroundFilters(const FilterOperations& filters) { DCHECK(IsPropertyChangeAllowed()); if (background_filters_ == filters) return; background_filters_ = filters; SetNeedsCommit(); - if (!filters.isEmpty() && layer_tree_host_) + if (!filters.IsEmpty() && layer_tree_host_) layer_tree_host_->set_needs_filter_context(); } diff --git a/cc/layers/layer.h b/cc/layers/layer.h index 7fc53b3..68f4a43 100644 --- a/cc/layers/layer.h +++ b/cc/layers/layer.h @@ -21,9 +21,9 @@ #include "cc/layers/layer_position_constraint.h" #include "cc/layers/paint_properties.h" #include "cc/layers/render_surface.h" +#include "cc/output/filter_operations.h" #include "cc/trees/occlusion_tracker.h" #include "skia/ext/refptr.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/core/SkColor.h" #include "third_party/skia/include/core/SkImageFilter.h" #include "ui/gfx/rect.h" @@ -118,8 +118,8 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>, bool OpacityIsAnimating() const; virtual bool OpacityCanAnimateOnImplThread() const; - void SetFilters(const WebKit::WebFilterOperations& filters); - const WebKit::WebFilterOperations& filters() const { return filters_; } + void SetFilters(const FilterOperations& filters); + const FilterOperations& filters() const { return filters_; } void SetFilter(const skia::RefPtr<SkImageFilter>& filter); skia::RefPtr<SkImageFilter> filter() const { return filter_; } @@ -127,8 +127,8 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>, // Background filters are filters applied to what is behind this layer, when // they are viewed through non-opaque regions in this layer. They are used // through the WebLayer interface, and are not exposed to HTML. - void SetBackgroundFilters(const WebKit::WebFilterOperations& filters); - const WebKit::WebFilterOperations& background_filters() const { + void SetBackgroundFilters(const FilterOperations& filters); + const FilterOperations& background_filters() const { return background_filters_; } @@ -462,8 +462,8 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>, CompositingReasons compositing_reasons_; float opacity_; skia::RefPtr<SkImageFilter> filter_; - WebKit::WebFilterOperations filters_; - WebKit::WebFilterOperations background_filters_; + FilterOperations filters_; + FilterOperations background_filters_; float anchor_point_z_; bool is_container_for_fixed_position_layers_; LayerPositionConstraint position_constraint_; diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc index 254a17f..b40579b 100644 --- a/cc/layers/layer_impl.cc +++ b/cc/layers/layer_impl.cc @@ -657,7 +657,7 @@ SkColor LayerImpl::SafeOpaqueBackgroundColor() const { return color; } -void LayerImpl::SetFilters(const WebKit::WebFilterOperations& filters) { +void LayerImpl::SetFilters(const FilterOperations& filters) { if (filters_ == filters) return; @@ -667,7 +667,7 @@ void LayerImpl::SetFilters(const WebKit::WebFilterOperations& filters) { } void LayerImpl::SetBackgroundFilters( - const WebKit::WebFilterOperations& filters) { + const FilterOperations& filters) { if (background_filters_ == filters) return; @@ -679,7 +679,7 @@ void LayerImpl::SetFilter(const skia::RefPtr<SkImageFilter>& filter) { if (filter_.get() == filter.get()) return; - DCHECK(filters_.isEmpty()); + DCHECK(filters_.IsEmpty()); filter_ = filter; NoteLayerPropertyChangedForSubtree(); } diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h index 3f2cae2..611bb7c 100644 --- a/cc/layers/layer_impl.h +++ b/cc/layers/layer_impl.h @@ -21,11 +21,11 @@ #include "cc/layers/layer_lists.h" #include "cc/layers/layer_position_constraint.h" #include "cc/layers/render_surface_impl.h" +#include "cc/output/filter_operations.h" #include "cc/quads/render_pass.h" #include "cc/quads/shared_quad_state.h" #include "cc/resources/resource_provider.h" #include "skia/ext/refptr.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/core/SkColor.h" #include "third_party/skia/include/core/SkImageFilter.h" #include "third_party/skia/include/core/SkPicture.h" @@ -152,11 +152,11 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver { // non-opaque color. Tries to return background_color(), if possible. SkColor SafeOpaqueBackgroundColor() const; - void SetFilters(const WebKit::WebFilterOperations& filters); - const WebKit::WebFilterOperations& filters() const { return filters_; } + void SetFilters(const FilterOperations& filters); + const FilterOperations& filters() const { return filters_; } - void SetBackgroundFilters(const WebKit::WebFilterOperations& filters); - const WebKit::WebFilterOperations& background_filters() const { + void SetBackgroundFilters(const FilterOperations& filters); + const FilterOperations& background_filters() const { return background_filters_; } @@ -540,8 +540,8 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver { std::string debug_name_; CompositingReasons compositing_reasons_; - WebKit::WebFilterOperations filters_; - WebKit::WebFilterOperations background_filters_; + FilterOperations filters_; + FilterOperations background_filters_; skia::RefPtr<SkImageFilter> filter_; protected: diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc index cc5e35d..a32cf3f 100644 --- a/cc/layers/layer_impl_unittest.cc +++ b/cc/layers/layer_impl_unittest.cc @@ -4,6 +4,8 @@ #include "cc/layers/layer_impl.h" +#include "cc/output/filter_operation.h" +#include "cc/output/filter_operations.h" #include "cc/test/fake_impl_proxy.h" #include "cc/test/fake_layer_tree_host_impl.h" #include "cc/test/fake_output_surface.h" @@ -11,13 +13,8 @@ #include "cc/trees/single_thread_proxy.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" -#include "third_party/WebKit/public/platform/WebFilterOperation.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/effects/SkBlurImageFilter.h" -using WebKit::WebFilterOperation; -using WebKit::WebFilterOperations; - namespace cc { namespace { @@ -100,8 +97,8 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); gfx::Transform arbitrary_transform; arbitrary_transform.Scale3d(0.1, 0.2, 0.3); - WebFilterOperations arbitrary_filters; - arbitrary_filters.append(WebFilterOperation::createOpacityFilter(0.5f)); + FilterOperations arbitrary_filters; + arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); skia::RefPtr<SkImageFilter> arbitrary_filter = skia::AdoptRef(new SkBlurImageFilter(SK_Scalar1, SK_Scalar1)); @@ -116,7 +113,7 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) { EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f)); EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPointZ(arbitrary_number)); EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters)); - EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(WebFilterOperations())); + EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations())); EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilter(arbitrary_filter)); EXECUTE_AND_VERIFY_SUBTREE_CHANGED( root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4))); @@ -213,15 +210,15 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { SkColor arbitrary_color = SkColorSetRGB(10, 20, 30); gfx::Transform arbitrary_transform; arbitrary_transform.Scale3d(0.1, 0.2, 0.3); - WebFilterOperations arbitrary_filters; - arbitrary_filters.append(WebFilterOperation::createOpacityFilter(0.5f)); + FilterOperations arbitrary_filters; + arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); skia::RefPtr<SkImageFilter> arbitrary_filter = skia::AdoptRef(new SkBlurImageFilter(SK_Scalar1, SK_Scalar1)); // Related filter functions. VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters)); - VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(WebFilterOperations())); + VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations())); VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilter(arbitrary_filter)); VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilter(arbitrary_filter)); diff --git a/cc/output/filter_operation.cc b/cc/output/filter_operation.cc new file mode 100644 index 0000000..c3a76dc --- /dev/null +++ b/cc/output/filter_operation.cc @@ -0,0 +1,66 @@ +// 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_operation.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_; + } + 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); + memset(matrix_, 0, sizeof(matrix_)); +} + +FilterOperation::FilterOperation(FilterType type, + gfx::Point offset, + float stdDeviation, + SkColor color) + : type_(type), + amount_(stdDeviation), + drop_shadow_offset_(offset), + drop_shadow_color_(color), + zoom_inset_(0) { + DCHECK_EQ(type_, DROP_SHADOW); + memset(matrix_, 0, sizeof(matrix_)); +} + +FilterOperation::FilterOperation(FilterType type, SkScalar matrix[20]) + : type_(type), + amount_(0), + drop_shadow_offset_(0, 0), + drop_shadow_color_(0), + zoom_inset_(0) { + DCHECK_EQ(type_, COLOR_MATRIX); + memcpy(matrix_, matrix, sizeof(matrix_)); +} + +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_)); +} + +} // namespace cc diff --git a/cc/output/filter_operation.h b/cc/output/filter_operation.h new file mode 100644 index 0000000..2168695 --- /dev/null +++ b/cc/output/filter_operation.h @@ -0,0 +1,176 @@ +// 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. + +#ifndef CC_OUTPUT_FILTER_OPERATION_H_ +#define CC_OUTPUT_FILTER_OPERATION_H_ + +#include "base/logging.h" +#include "cc/base/cc_export.h" +#include "third_party/skia/include/core/SkColor.h" +#include "third_party/skia/include/core/SkScalar.h" +#include "ui/gfx/point.h" + +namespace cc { + +class CC_EXPORT FilterOperation { + public: + enum FilterType { + GRAYSCALE, + SEPIA, + SATURATE, + HUE_ROTATE, + INVERT, + BRIGHTNESS, + CONTRAST, + OPACITY, + BLUR, + DROP_SHADOW, + COLOR_MATRIX, + ZOOM, + SATURATING_BRIGHTNESS, // Not used in CSS/SVG. + }; + + FilterType type() const { return type_; } + + float amount() const { + DCHECK_NE(type_, COLOR_MATRIX); + return amount_; + } + + gfx::Point drop_shadow_offset() const { + DCHECK_EQ(type_, DROP_SHADOW); + return drop_shadow_offset_; + } + + SkColor drop_shadow_color() const { + DCHECK_EQ(type_, DROP_SHADOW); + return drop_shadow_color_; + } + + const SkScalar* matrix() const { + DCHECK_EQ(type_, COLOR_MATRIX); + return matrix_; + } + + int zoom_inset() const { + DCHECK_EQ(type_, ZOOM); + return zoom_inset_; + } + + static FilterOperation CreateGrayscaleFilter(float amount) { + return FilterOperation(GRAYSCALE, amount); + } + + static FilterOperation CreateSepiaFilter(float amount) { + return FilterOperation(SEPIA, amount); + } + + static FilterOperation CreateSaturateFilter(float amount) { + return FilterOperation(SATURATE, amount); + } + + static FilterOperation CreateHueRotateFilter(float amount) { + return FilterOperation(HUE_ROTATE, amount); + } + + static FilterOperation CreateInvertFilter(float amount) { + return FilterOperation(INVERT, amount); + } + + static FilterOperation CreateBrightnessFilter(float amount) { + return FilterOperation(BRIGHTNESS, amount); + } + + static FilterOperation CreateContrastFilter(float amount) { + return FilterOperation(CONTRAST, amount); + } + + static FilterOperation CreateOpacityFilter(float amount) { + return FilterOperation(OPACITY, amount); + } + + static FilterOperation CreateBlurFilter(float amount) { + return FilterOperation(BLUR, amount); + } + + static FilterOperation CreateDropShadowFilter(gfx::Point offset, + float std_deviation, + SkColor color) { + return FilterOperation(DROP_SHADOW, offset, std_deviation, color); + } + + static FilterOperation CreateColorMatrixFilter(SkScalar matrix[20]) { + return FilterOperation(COLOR_MATRIX, matrix); + } + + static FilterOperation CreateZoomFilter(float amount, int inset) { + return FilterOperation(ZOOM, amount, inset); + } + + static FilterOperation CreateSaturatingBrightnessFilter(float amount) { + return FilterOperation(SATURATING_BRIGHTNESS, amount); + } + + bool operator==(const FilterOperation& other) const; + + bool operator!=(const FilterOperation& other) const { + return !(*this == other); + } + + // Methods for restoring a FilterOperation. + static FilterOperation CreateEmptyFilter() { + return FilterOperation(GRAYSCALE, 0.f); + } + + void set_type(FilterType type) { type_ = type; } + + void set_amount(float amount) { + DCHECK_NE(type_, COLOR_MATRIX); + amount_ = amount; + } + + void set_drop_shadow_offset(gfx::Point offset) { + DCHECK_EQ(type_, DROP_SHADOW); + drop_shadow_offset_ = offset; + } + + void set_drop_shadow_color(SkColor color) { + DCHECK_EQ(type_, DROP_SHADOW); + drop_shadow_color_ = color; + } + + void set_matrix(const SkScalar matrix[20]) { + DCHECK_EQ(type_, COLOR_MATRIX); + for (unsigned i = 0; i < 20; ++i) + matrix_[i] = matrix[i]; + } + + void set_zoom_inset(int inset) { + DCHECK_EQ(type_, ZOOM); + zoom_inset_ = inset; + } + + private: + FilterOperation(FilterType type, float amount); + + FilterOperation(FilterType type, + gfx::Point offset, + float stdDeviation, + SkColor color); + + FilterOperation(FilterType, SkScalar matrix[20]); + + FilterOperation(FilterType type, float amount, int inset); + + FilterType type_; + float amount_; + gfx::Point drop_shadow_offset_; + SkColor drop_shadow_color_; + SkScalar matrix_[20]; + int zoom_inset_; +}; + +} // namespace cc + +#endif // CC_OUTPUT_FILTER_OPERATION_H_ diff --git a/cc/output/filter_operations.cc b/cc/output/filter_operations.cc new file mode 100644 index 0000000..c722963 --- /dev/null +++ b/cc/output/filter_operations.cc @@ -0,0 +1,115 @@ +// 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() {} + +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.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]; + 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]; + switch (op.type()) { + case FilterOperation::BLUR: + case FilterOperation::DROP_SHADOW: + case FilterOperation::ZOOM: + 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::OPACITY: + case FilterOperation::BLUR: + case FilterOperation::DROP_SHADOW: + case FilterOperation::ZOOM: + return true; + case FilterOperation::COLOR_MATRIX: { + const SkScalar* matrix = op.matrix(); + return matrix[15] || matrix[16] || matrix[17] || matrix[18] != 1 || + matrix[19]; + } + default: + break; + } + } + return false; +} + +} // namespace cc diff --git a/cc/output/filter_operations.h b/cc/output/filter_operations.h new file mode 100644 index 0000000..1b48662 --- /dev/null +++ b/cc/output/filter_operations.h @@ -0,0 +1,58 @@ +// 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. + +#ifndef CC_OUTPUT_FILTER_OPERATIONS_H_ +#define CC_OUTPUT_FILTER_OPERATIONS_H_ + +#include <vector> + +#include "base/logging.h" +#include "cc/output/filter_operation.h" + +namespace cc { + +// An ordered list of filter operations. +class CC_EXPORT FilterOperations { + public: + FilterOperations(); + + FilterOperations(const FilterOperations& other); + + ~FilterOperations(); + + FilterOperations& operator=(const FilterOperations& other); + + bool operator==(const FilterOperations& other) const; + + bool operator!=(const FilterOperations& other) const { + return !(*this == other); + } + + void Append(const FilterOperation& filter); + + // Removes all filter operations. + void Clear(); + + bool IsEmpty() const; + + void GetOutsets(int* top, int* right, int* bottom, int* left) const; + bool HasFilterThatMovesPixels() const; + bool HasFilterThatAffectsOpacity() const; + + size_t size() const { + return operations_.size(); + } + + FilterOperation at(size_t index) const { + DCHECK_LT(index, size()); + return operations_[index]; + } + + private: + std::vector<FilterOperation> operations_; +}; + +} // namespace cc + +#endif // CC_OUTPUT_FILTER_OPERATIONS_H_ diff --git a/cc/output/filter_operations_unittest.cc b/cc/output/filter_operations_unittest.cc new file mode 100644 index 0000000..4f88cae --- /dev/null +++ b/cc/output/filter_operations_unittest.cc @@ -0,0 +1,142 @@ +// 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 "testing/gtest/include/gtest/gtest.h" +#include "ui/gfx/point.h" + +namespace cc { +namespace { + +TEST(FilterOperationsTest, GetOutsetsBlur) { + FilterOperations ops; + ops.Append(FilterOperation::CreateBlurFilter(20)); + int top, right, bottom, left; + top = right = bottom = left = 0; + ops.GetOutsets(&top, &right, &bottom, &left); + EXPECT_EQ(57, top); + EXPECT_EQ(57, right); + EXPECT_EQ(57, bottom); + EXPECT_EQ(57, left); +} + +TEST(FilterOperationsTest, GetOutsetsDropShadow) { + FilterOperations ops; + ops.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(3, 8), 20, 0)); + int top, right, bottom, left; + top = right = bottom = left = 0; + ops.GetOutsets(&top, &right, &bottom, &left); + EXPECT_EQ(49, top); + EXPECT_EQ(60, right); + EXPECT_EQ(65, bottom); + EXPECT_EQ(54, left); +} + +#define SAVE_RESTORE_AMOUNT(filter_name, filter_type, a) \ + { \ + FilterOperation op = FilterOperation::Create##filter_name##Filter(a); \ + EXPECT_EQ(FilterOperation::filter_type, op.type()); \ + EXPECT_EQ(a, op.amount()); \ + \ + FilterOperation op2 = FilterOperation::CreateEmptyFilter(); \ + op2.set_type(FilterOperation::filter_type); \ + \ + EXPECT_NE(a, op2.amount()); \ + \ + op2.set_amount(a); \ + \ + EXPECT_EQ(FilterOperation::filter_type, op2.type()); \ + EXPECT_EQ(a, op2.amount()); \ + } + +#define SAVE_RESTORE_OFFSET_AMOUNT_COLOR(filter_name, filter_type, a, b, c) \ + { \ + FilterOperation op = \ + FilterOperation::Create##filter_name##Filter(a, b, c); \ + EXPECT_EQ(FilterOperation::filter_type, op.type()); \ + EXPECT_EQ(a, op.drop_shadow_offset()); \ + EXPECT_EQ(b, op.amount()); \ + EXPECT_EQ(c, op.drop_shadow_color()); \ + \ + FilterOperation op2 = FilterOperation::CreateEmptyFilter(); \ + op2.set_type(FilterOperation::filter_type); \ + \ + EXPECT_NE(a, op2.drop_shadow_offset()); \ + EXPECT_NE(b, op2.amount()); \ + EXPECT_NE(c, op2.drop_shadow_color()); \ + \ + op2.set_drop_shadow_offset(a); \ + op2.set_amount(b); \ + op2.set_drop_shadow_color(c); \ + \ + EXPECT_EQ(FilterOperation::filter_type, op2.type()); \ + EXPECT_EQ(a, op2.drop_shadow_offset()); \ + EXPECT_EQ(b, op2.amount()); \ + EXPECT_EQ(c, op2.drop_shadow_color()); \ + } + +#define SAVE_RESTORE_MATRIX(filter_name, filter_type, a) \ + { \ + FilterOperation op = FilterOperation::Create##filter_name##Filter(a); \ + EXPECT_EQ(FilterOperation::filter_type, op.type()); \ + for (size_t i = 0; i < 20; ++i) \ + EXPECT_EQ(a[i], op.matrix()[i]); \ + \ + FilterOperation op2 = FilterOperation::CreateEmptyFilter(); \ + op2.set_type(FilterOperation::filter_type); \ + \ + for (size_t i = 0; i < 20; ++i) \ + EXPECT_NE(a[i], op2.matrix()[i]); \ + \ + op2.set_matrix(a); \ + \ + EXPECT_EQ(FilterOperation::filter_type, op2.type()); \ + for (size_t i = 0; i < 20; ++i) \ + EXPECT_EQ(a[i], op.matrix()[i]); \ + } + +#define SAVE_RESTORE_AMOUNT_INSET(filter_name, filter_type, a, b) \ + { \ + FilterOperation op = FilterOperation::Create##filter_name##Filter(a, b); \ + EXPECT_EQ(FilterOperation::filter_type, op.type()); \ + EXPECT_EQ(a, op.amount()); \ + EXPECT_EQ(b, op.zoom_inset()); \ + \ + FilterOperation op2 = FilterOperation::CreateEmptyFilter(); \ + op2.set_type(FilterOperation::filter_type); \ + \ + EXPECT_NE(a, op2.amount()); \ + EXPECT_NE(b, op2.zoom_inset()); \ + \ + op2.set_amount(a); \ + op2.set_zoom_inset(b); \ + \ + EXPECT_EQ(FilterOperation::filter_type, op2.type()); \ + EXPECT_EQ(a, op2.amount()); \ + EXPECT_EQ(b, op2.zoom_inset()); \ + } + +TEST(FilterOperationsTest, SaveAndRestore) { + SAVE_RESTORE_AMOUNT(Grayscale, GRAYSCALE, 0.6f); + SAVE_RESTORE_AMOUNT(Sepia, SEPIA, 0.6f); + SAVE_RESTORE_AMOUNT(Saturate, SATURATE, 0.6f); + SAVE_RESTORE_AMOUNT(HueRotate, HUE_ROTATE, 0.6f); + SAVE_RESTORE_AMOUNT(Invert, INVERT, 0.6f); + SAVE_RESTORE_AMOUNT(Brightness, BRIGHTNESS, 0.6f); + SAVE_RESTORE_AMOUNT(Contrast, CONTRAST, 0.6f); + SAVE_RESTORE_AMOUNT(Opacity, OPACITY, 0.6f); + SAVE_RESTORE_AMOUNT(Blur, BLUR, 0.6f); + SAVE_RESTORE_AMOUNT(SaturatingBrightness, SATURATING_BRIGHTNESS, 0.6f); + SAVE_RESTORE_OFFSET_AMOUNT_COLOR( + DropShadow, DROP_SHADOW, gfx::Point(3, 4), 0.4f, 0xffffff00); + + SkScalar matrix[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20}; + SAVE_RESTORE_MATRIX(ColorMatrix, COLOR_MATRIX, matrix); + + SAVE_RESTORE_AMOUNT_INSET(Zoom, ZOOM, 0.5f, 32); +} + +} // namespace +} // namespace cc diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc index 3527ed1..d7a7cea 100644 --- a/cc/output/gl_renderer.cc +++ b/cc/output/gl_renderer.cc @@ -441,9 +441,9 @@ void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame, } static inline SkBitmap ApplyFilters(GLRenderer* renderer, - const WebKit::WebFilterOperations& filters, + const FilterOperations& filters, ScopedResource* source_texture_resource) { - if (filters.isEmpty()) + if (filters.IsEmpty()) return SkBitmap(); ContextProvider* offscreen_contexts = @@ -589,8 +589,8 @@ scoped_ptr<ScopedResource> GLRenderer::DrawBackgroundFilters( // FIXME: When this algorithm changes, update // LayerTreeHost::PrioritizeTextures() accordingly. - const WebKit::WebFilterOperations& filters = quad->background_filters; - DCHECK(!filters.isEmpty()); + const FilterOperations& filters = quad->background_filters; + DCHECK(!filters.IsEmpty()); // FIXME: We only allow background filters on an opaque render surface because // other surfaces may contain translucent pixels, and the contents behind @@ -605,7 +605,7 @@ scoped_ptr<ScopedResource> GLRenderer::DrawBackgroundFilters( contents_device_transform, SharedGeometryQuad().BoundingBox())); int top, right, bottom, left; - filters.getOutsets(top, right, bottom, left); + filters.GetOutsets(&top, &right, &bottom, &left); window_rect.Inset(-left, -top, -right, -bottom); window_rect.Intersect( @@ -704,7 +704,7 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame, return; scoped_ptr<ScopedResource> background_texture; - if (!quad->background_filters.isEmpty()) { + if (!quad->background_filters.IsEmpty()) { // The pixels from the filtered background should completely replace the // current pixel values. bool disable_blending = blend_enabled(); diff --git a/cc/output/render_surface_filters.cc b/cc/output/render_surface_filters.cc index 4d7855f..e7c48bd 100644 --- a/cc/output/render_surface_filters.cc +++ b/cc/output/render_surface_filters.cc @@ -7,9 +7,9 @@ #include <algorithm> #include "base/logging.h" +#include "cc/output/filter_operation.h" +#include "cc/output/filter_operations.h" #include "skia/ext/refptr.h" -#include "third_party/WebKit/public/platform/WebFilterOperation.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/core/SkCanvas.h" #include "third_party/skia/include/effects/SkBlurImageFilter.h" #include "third_party/skia/include/effects/SkColorMatrixFilter.h" @@ -184,45 +184,45 @@ bool MatrixNeedsClamping(SkScalar matrix[20]) { || ComponentNeedsClamping(matrix+15); } -bool GetColorMatrix(const WebKit::WebFilterOperation& op, SkScalar matrix[20]) { +bool GetColorMatrix(const FilterOperation& op, SkScalar matrix[20]) { switch (op.type()) { - case WebKit::WebFilterOperation::FilterTypeBrightness: { + case FilterOperation::BRIGHTNESS: { GetBrightnessMatrix(op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeSaturatingBrightness: { + case FilterOperation::SATURATING_BRIGHTNESS: { GetSaturatingBrightnessMatrix(op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeContrast: { + case FilterOperation::CONTRAST: { GetContrastMatrix(op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeGrayscale: { + case FilterOperation::GRAYSCALE: { GetGrayscaleMatrix(1.f - op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeSepia: { + case FilterOperation::SEPIA: { GetSepiaMatrix(1.f - op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeSaturate: { + case FilterOperation::SATURATE: { GetSaturateMatrix(op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeHueRotate: { + case FilterOperation::HUE_ROTATE: { GetHueRotateMatrix(op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeInvert: { + case FilterOperation::INVERT: { GetInvertMatrix(op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeOpacity: { + case FilterOperation::OPACITY: { GetOpacityMatrix(op.amount(), matrix); return true; } - case WebKit::WebFilterOperation::FilterTypeColorMatrix: { + case FilterOperation::COLOR_MATRIX: { memcpy(matrix, op.matrix(), sizeof(SkScalar[20])); return true; } @@ -311,14 +311,14 @@ class FilterBufferState { } // namespace -WebKit::WebFilterOperations RenderSurfaceFilters::Optimize( - const WebKit::WebFilterOperations& filters) { - WebKit::WebFilterOperations new_list; +FilterOperations RenderSurfaceFilters::Optimize( + const FilterOperations& filters) { + FilterOperations new_list; SkScalar accumulated_color_matrix[20]; bool have_accumulated_color_matrix = false; for (unsigned i = 0; i < filters.size(); ++i) { - const WebKit::WebFilterOperation& op = filters.at(i); + const FilterOperation& op = filters.at(i); // If the filter is a color matrix, we may be able to combine it with // following Filter(s) that also are color matrices. @@ -344,53 +344,53 @@ WebKit::WebFilterOperations RenderSurfaceFilters::Optimize( } if (have_accumulated_color_matrix) { - new_list.append(WebKit::WebFilterOperation::createColorMatrixFilter( + new_list.Append(FilterOperation::CreateColorMatrixFilter( accumulated_color_matrix)); } have_accumulated_color_matrix = false; switch (op.type()) { - case WebKit::WebFilterOperation::FilterTypeBlur: - case WebKit::WebFilterOperation::FilterTypeDropShadow: - case WebKit::WebFilterOperation::FilterTypeZoom: - new_list.append(op); + case FilterOperation::BLUR: + case FilterOperation::DROP_SHADOW: + case FilterOperation::ZOOM: + new_list.Append(op); break; - case WebKit::WebFilterOperation::FilterTypeBrightness: - case WebKit::WebFilterOperation::FilterTypeSaturatingBrightness: - case WebKit::WebFilterOperation::FilterTypeContrast: - case WebKit::WebFilterOperation::FilterTypeGrayscale: - case WebKit::WebFilterOperation::FilterTypeSepia: - case WebKit::WebFilterOperation::FilterTypeSaturate: - case WebKit::WebFilterOperation::FilterTypeHueRotate: - case WebKit::WebFilterOperation::FilterTypeInvert: - case WebKit::WebFilterOperation::FilterTypeOpacity: - case WebKit::WebFilterOperation::FilterTypeColorMatrix: + case FilterOperation::BRIGHTNESS: + case FilterOperation::SATURATING_BRIGHTNESS: + case FilterOperation::CONTRAST: + case FilterOperation::GRAYSCALE: + case FilterOperation::SEPIA: + case FilterOperation::SATURATE: + case FilterOperation::HUE_ROTATE: + case FilterOperation::INVERT: + case FilterOperation::OPACITY: + case FilterOperation::COLOR_MATRIX: break; } } if (have_accumulated_color_matrix) { - new_list.append(WebKit::WebFilterOperation::createColorMatrixFilter( + new_list.Append(FilterOperation::CreateColorMatrixFilter( accumulated_color_matrix)); } return new_list; } -SkBitmap RenderSurfaceFilters::Apply(const WebKit::WebFilterOperations& filters, +SkBitmap RenderSurfaceFilters::Apply(const FilterOperations& filters, unsigned texture_id, gfx::SizeF size, GrContext* gr_context) { DCHECK(gr_context); - WebKit::WebFilterOperations optimized_filters = Optimize(filters); + FilterOperations optimized_filters = Optimize(filters); FilterBufferState state(gr_context, size, texture_id); if (!state.Init(optimized_filters.size())) return SkBitmap(); for (unsigned i = 0; i < optimized_filters.size(); ++i) { - const WebKit::WebFilterOperation& op = optimized_filters.at(i); + const FilterOperation& op = optimized_filters.at(i); SkCanvas* canvas = state.Canvas(); switch (op.type()) { - case WebKit::WebFilterOperation::FilterTypeColorMatrix: { + case FilterOperation::COLOR_MATRIX: { SkPaint paint; skia::RefPtr<SkColorMatrixFilter> filter = skia::AdoptRef(new SkColorMatrixFilter(op.matrix())); @@ -398,7 +398,7 @@ SkBitmap RenderSurfaceFilters::Apply(const WebKit::WebFilterOperations& filters, canvas->drawBitmap(state.Source(), 0, 0, &paint); break; } - case WebKit::WebFilterOperation::FilterTypeBlur: { + case FilterOperation::BLUR: { float std_deviation = op.amount(); skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(new SkBlurImageFilter(std_deviation, std_deviation)); @@ -407,25 +407,25 @@ SkBitmap RenderSurfaceFilters::Apply(const WebKit::WebFilterOperations& filters, canvas->drawSprite(state.Source(), 0, 0, &paint); break; } - case WebKit::WebFilterOperation::FilterTypeDropShadow: { + case FilterOperation::DROP_SHADOW: { skia::RefPtr<SkImageFilter> blur_filter = skia::AdoptRef(new SkBlurImageFilter(op.amount(), op.amount())); skia::RefPtr<SkColorFilter> color_filter = skia::AdoptRef(SkColorFilter::CreateModeFilter( - op.dropShadowColor(), SkXfermode::kSrcIn_Mode)); + op.drop_shadow_color(), SkXfermode::kSrcIn_Mode)); SkPaint paint; paint.setImageFilter(blur_filter.get()); paint.setColorFilter(color_filter.get()); paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); canvas->saveLayer(NULL, &paint); canvas->drawBitmap(state.Source(), - op.dropShadowOffset().x, - op.dropShadowOffset().y); + op.drop_shadow_offset().x(), + op.drop_shadow_offset().y()); canvas->restore(); canvas->drawBitmap(state.Source(), 0, 0); break; } - case WebKit::WebFilterOperation::FilterTypeZoom: { + case FilterOperation::ZOOM: { SkPaint paint; int width = state.Source().width(); int height = state.Source().height(); @@ -436,22 +436,22 @@ SkBitmap RenderSurfaceFilters::Apply(const WebKit::WebFilterOperations& filters, (height - (height / op.amount())) / 2.f, width / op.amount(), height / op.amount()), - op.zoomInset())); + op.zoom_inset())); paint.setImageFilter(zoom_filter.get()); canvas->saveLayer(NULL, &paint); canvas->drawBitmap(state.Source(), 0, 0); canvas->restore(); break; } - case WebKit::WebFilterOperation::FilterTypeBrightness: - case WebKit::WebFilterOperation::FilterTypeSaturatingBrightness: - case WebKit::WebFilterOperation::FilterTypeContrast: - case WebKit::WebFilterOperation::FilterTypeGrayscale: - case WebKit::WebFilterOperation::FilterTypeSepia: - case WebKit::WebFilterOperation::FilterTypeSaturate: - case WebKit::WebFilterOperation::FilterTypeHueRotate: - case WebKit::WebFilterOperation::FilterTypeInvert: - case WebKit::WebFilterOperation::FilterTypeOpacity: + case FilterOperation::BRIGHTNESS: + case FilterOperation::SATURATING_BRIGHTNESS: + case FilterOperation::CONTRAST: + case FilterOperation::GRAYSCALE: + case FilterOperation::SEPIA: + case FilterOperation::SATURATE: + case FilterOperation::HUE_ROTATE: + case FilterOperation::INVERT: + case FilterOperation::OPACITY: NOTREACHED(); break; } diff --git a/cc/output/render_surface_filters.h b/cc/output/render_surface_filters.h index 494204c..5ab78dc 100644 --- a/cc/output/render_surface_filters.h +++ b/cc/output/render_surface_filters.h @@ -16,20 +16,17 @@ namespace gfx { class SizeF; } -namespace WebKit { -class WebFilterOperations; -} - namespace cc { +class FilterOperations; + class CC_EXPORT RenderSurfaceFilters { public: - static SkBitmap Apply(const WebKit::WebFilterOperations& filters, + static SkBitmap Apply(const FilterOperations& filters, unsigned texture_id, gfx::SizeF size, GrContext* gr_context); - static WebKit::WebFilterOperations Optimize( - const WebKit::WebFilterOperations& filters); + static FilterOperations Optimize(const FilterOperations& filters); private: DISALLOW_IMPLICIT_CONSTRUCTORS(RenderSurfaceFilters); diff --git a/cc/output/render_surface_filters_unittest.cc b/cc/output/render_surface_filters_unittest.cc index 571e864..38c6cc3 100644 --- a/cc/output/render_surface_filters_unittest.cc +++ b/cc/output/render_surface_filters_unittest.cc @@ -4,137 +4,134 @@ #include "cc/output/render_surface_filters.h" +#include "cc/output/filter_operation.h" +#include "cc/output/filter_operations.h" #include "testing/gtest/include/gtest/gtest.h" -#include "third_party/WebKit/public/platform/WebFilterOperation.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" - -using WebKit::WebFilterOperation; -using WebKit::WebFilterOperations; namespace cc { namespace { // Checks whether op can be combined with a following color matrix. -bool IsCombined(const WebFilterOperation& op) { - WebFilterOperations filters; - filters.append(op); +bool IsCombined(const FilterOperation& op) { + FilterOperations filters; + filters.Append(op); // brightness(0.0f) is identity. - filters.append(WebFilterOperation::createBrightnessFilter(0.0f)); - WebFilterOperations optimized = RenderSurfaceFilters::Optimize(filters); + filters.Append(FilterOperation::CreateBrightnessFilter(0.0f)); + FilterOperations optimized = RenderSurfaceFilters::Optimize(filters); return optimized.size() == 1; } TEST(RenderSurfaceFiltersTest, TestColorMatrixFiltersCombined) { // Several filters should always combine for any amount between 0 and 1: // grayscale, saturate, invert, contrast, opacity. - EXPECT_TRUE(IsCombined(WebFilterOperation::createGrayscaleFilter(0.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateGrayscaleFilter(0.0f))); // Note that we use 0.3f to avoid "argument is truncated from 'double' to // 'float'" warnings on Windows. 0.5f is exactly representable as a float, so // there is no warning. - EXPECT_TRUE(IsCombined(WebFilterOperation::createGrayscaleFilter(0.3f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createGrayscaleFilter(0.5f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createGrayscaleFilter(1.0f))); - - EXPECT_TRUE(IsCombined(WebFilterOperation::createSaturateFilter(0.0f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createSaturateFilter(0.3f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createSaturateFilter(0.5))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createSaturateFilter(1.0f))); - - EXPECT_TRUE(IsCombined(WebFilterOperation::createInvertFilter(0.0f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createInvertFilter(0.3f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createInvertFilter(0.5))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createInvertFilter(1.0f))); - - EXPECT_TRUE(IsCombined(WebFilterOperation::createContrastFilter(0.0f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createContrastFilter(0.3f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createContrastFilter(0.5))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createContrastFilter(1.0f))); - - EXPECT_TRUE(IsCombined(WebFilterOperation::createOpacityFilter(0.0f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createOpacityFilter(0.3f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createOpacityFilter(0.5))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createOpacityFilter(1.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateGrayscaleFilter(0.3f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateGrayscaleFilter(0.5f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateGrayscaleFilter(1.0f))); + + EXPECT_TRUE(IsCombined(FilterOperation::CreateSaturateFilter(0.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateSaturateFilter(0.3f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateSaturateFilter(0.5))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateSaturateFilter(1.0f))); + + EXPECT_TRUE(IsCombined(FilterOperation::CreateInvertFilter(0.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateInvertFilter(0.3f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateInvertFilter(0.5))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateInvertFilter(1.0f))); + + EXPECT_TRUE(IsCombined(FilterOperation::CreateContrastFilter(0.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateContrastFilter(0.3f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateContrastFilter(0.5))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateContrastFilter(1.0f))); + + EXPECT_TRUE(IsCombined(FilterOperation::CreateOpacityFilter(0.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateOpacityFilter(0.3f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateOpacityFilter(0.5))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateOpacityFilter(1.0f))); // Brightness combines when amount <= 1 - EXPECT_TRUE(IsCombined(WebFilterOperation::createBrightnessFilter(0.5))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createBrightnessFilter(1.0f))); - EXPECT_FALSE(IsCombined(WebFilterOperation::createBrightnessFilter(1.5))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateBrightnessFilter(0.5))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateBrightnessFilter(1.0f))); + EXPECT_FALSE(IsCombined(FilterOperation::CreateBrightnessFilter(1.5))); // SaturatingBrightness combines only when amount == 0 EXPECT_TRUE( - IsCombined(WebFilterOperation::createSaturatingBrightnessFilter(0.0f))); + IsCombined(FilterOperation::CreateSaturatingBrightnessFilter(0.0f))); EXPECT_FALSE( - IsCombined(WebFilterOperation::createSaturatingBrightnessFilter(0.5))); + IsCombined(FilterOperation::CreateSaturatingBrightnessFilter(0.5))); EXPECT_FALSE( - IsCombined(WebFilterOperation::createSaturatingBrightnessFilter(1.0f))); + IsCombined(FilterOperation::CreateSaturatingBrightnessFilter(1.0f))); // Several filters should never combine: blur, drop-shadow. - EXPECT_FALSE(IsCombined(WebFilterOperation::createBlurFilter(3.0f))); - EXPECT_FALSE(IsCombined(WebFilterOperation::createDropShadowFilter( + EXPECT_FALSE(IsCombined(FilterOperation::CreateBlurFilter(3.0f))); + EXPECT_FALSE(IsCombined(FilterOperation::CreateDropShadowFilter( gfx::Point(2, 2), 3.0f, 0xffffffff))); // sepia and hue may or may not combine depending on the value. - EXPECT_TRUE(IsCombined(WebFilterOperation::createSepiaFilter(0.0f))); - EXPECT_FALSE(IsCombined(WebFilterOperation::createSepiaFilter(1.0f))); - EXPECT_TRUE(IsCombined(WebFilterOperation::createHueRotateFilter(0.0f))); - EXPECT_FALSE(IsCombined(WebFilterOperation::createHueRotateFilter(180.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateSepiaFilter(0.0f))); + EXPECT_FALSE(IsCombined(FilterOperation::CreateSepiaFilter(1.0f))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateHueRotateFilter(0.0f))); + EXPECT_FALSE(IsCombined(FilterOperation::CreateHueRotateFilter(180.0f))); float matrix1[20] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, }; - EXPECT_TRUE(IsCombined(WebFilterOperation::createColorMatrixFilter(matrix1))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateColorMatrixFilter(matrix1))); float matrix2[20] = { 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, }; EXPECT_FALSE( - IsCombined(WebFilterOperation::createColorMatrixFilter(matrix2))); + IsCombined(FilterOperation::CreateColorMatrixFilter(matrix2))); float matrix3[20] = { 0.25f, 0.0f, 0.0f, 0.0f, 255.0f * 0.75f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, }; - EXPECT_TRUE(IsCombined(WebFilterOperation::createColorMatrixFilter(matrix3))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateColorMatrixFilter(matrix3))); float matrix4[20] = { -0.25f, 0.75f, 0.0f, 0.0f, 255.0f * 0.25f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, }; - EXPECT_TRUE(IsCombined(WebFilterOperation::createColorMatrixFilter(matrix4))); + EXPECT_TRUE(IsCombined(FilterOperation::CreateColorMatrixFilter(matrix4))); } TEST(RenderSurfaceFiltersTest, TestOptimize) { - WebFilterOperation combines(WebFilterOperation::createBrightnessFilter(1.0f)); - WebFilterOperation doesnt_combine( - WebFilterOperation::createBrightnessFilter(1.5f)); + FilterOperation combines(FilterOperation::CreateBrightnessFilter(1.0f)); + FilterOperation doesnt_combine( + FilterOperation::CreateBrightnessFilter(1.5f)); - WebFilterOperations filters; - WebFilterOperations optimized = RenderSurfaceFilters::Optimize(filters); + FilterOperations filters; + FilterOperations optimized = RenderSurfaceFilters::Optimize(filters); EXPECT_EQ(0u, optimized.size()); - filters.append(combines); + filters.Append(combines); optimized = RenderSurfaceFilters::Optimize(filters); EXPECT_EQ(1u, optimized.size()); - filters.append(combines); + filters.Append(combines); optimized = RenderSurfaceFilters::Optimize(filters); EXPECT_EQ(1u, optimized.size()); - filters.append(doesnt_combine); + filters.Append(doesnt_combine); optimized = RenderSurfaceFilters::Optimize(filters); EXPECT_EQ(1u, optimized.size()); - filters.append(combines); + filters.Append(combines); optimized = RenderSurfaceFilters::Optimize(filters); EXPECT_EQ(2u, optimized.size()); - filters.append(doesnt_combine); + filters.Append(doesnt_combine); optimized = RenderSurfaceFilters::Optimize(filters); EXPECT_EQ(2u, optimized.size()); - filters.append(doesnt_combine); + filters.Append(doesnt_combine); optimized = RenderSurfaceFilters::Optimize(filters); EXPECT_EQ(3u, optimized.size()); } diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc index 4d3eb30..893e6a1 100644 --- a/cc/output/renderer_pixeltest.cc +++ b/cc/output/renderer_pixeltest.cc @@ -87,9 +87,9 @@ scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad( 0, // mask_resource_id rect, // contents_changed_since_last_frame gfx::RectF(), // mask_uv_rect - WebKit::WebFilterOperations(), // foreground filters + FilterOperations(), // foreground filters skia::RefPtr<SkImageFilter>(), // foreground filter - WebKit::WebFilterOperations()); // background filters + FilterOperations()); // background filters return quad.PassAs<DrawQuad>(); } @@ -416,9 +416,9 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { 0, pass_rect, gfx::RectF(), - WebKit::WebFilterOperations(), + FilterOperations(), filter, - WebKit::WebFilterOperations()); + FilterOperations()); root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); @@ -518,9 +518,9 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { 0, pass_rect, gfx::RectF(), - WebKit::WebFilterOperations(), + FilterOperations(), filter, - WebKit::WebFilterOperations()); + FilterOperations()); root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); RenderPassList pass_list; @@ -717,7 +717,7 @@ class RendererPixelTestWithBackgroundFilter 0, // mask_resource_id filter_pass_content_rect_, // contents_changed_since_last_frame gfx::RectF(), // mask_uv_rect - WebKit::WebFilterOperations(), // filters + FilterOperations(), // filters skia::RefPtr<SkImageFilter>(), // filter this->background_filters_); root_pass->quad_list.push_back(filter_pass_quad.PassAs<DrawQuad>()); @@ -779,7 +779,7 @@ class RendererPixelTestWithBackgroundFilter } RenderPassList pass_list_; - WebKit::WebFilterOperations background_filters_; + FilterOperations background_filters_; gfx::Transform filter_pass_to_target_transform_; gfx::Rect filter_pass_content_rect_; }; @@ -794,8 +794,8 @@ GLRendererPixelTestWithBackgroundFilter; // TODO(skaslev): The software renderer does not support filters yet. TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) { - this->background_filters_.append( - WebKit::WebFilterOperation::createInvertFilter(1.f)); + this->background_filters_.Append( + FilterOperation::CreateInvertFilter(1.f)); this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_); this->filter_pass_content_rect_.Inset(12, 14, 16, 18); diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc index 0c17413..671cf00 100644 --- a/cc/quads/draw_quad_unittest.cc +++ b/cc/quads/draw_quad_unittest.cc @@ -9,6 +9,7 @@ #include "base/bind.h" #include "base/compiler_specific.h" #include "cc/base/math_util.h" +#include "cc/output/filter_operations.h" #include "cc/quads/checkerboard_draw_quad.h" #include "cc/quads/debug_border_draw_quad.h" #include "cc/quads/io_surface_draw_quad.h" @@ -22,7 +23,6 @@ #include "cc/resources/picture_pile_impl.h" #include "cc/test/geometry_test_utils.h" #include "testing/gtest/include/gtest/gtest.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/effects/SkBlurImageFilter.h" #include "ui/gfx/transform.h" @@ -361,11 +361,11 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) { ResourceProvider::ResourceId mask_resource_id = 78; gfx::Rect contents_changed_since_last_frame(42, 11, 74, 24); gfx::RectF mask_u_v_rect(-45.f, -21.f, 33.f, 19.f); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(1.f)); - WebKit::WebFilterOperations background_filters; - background_filters.append( - WebKit::WebFilterOperation::createGrayscaleFilter(1.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(1.f)); + FilterOperations background_filters; + background_filters.Append( + FilterOperation::CreateGrayscaleFilter(1.f)); skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(new SkBlurImageFilter(SK_Scalar1, SK_Scalar1)); @@ -761,11 +761,11 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) { ResourceProvider::ResourceId mask_resource_id = 78; gfx::Rect contents_changed_since_last_frame(42, 11, 74, 24); gfx::RectF mask_u_v_rect(-45.f, -21.f, 33.f, 19.f); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(1.f)); - WebKit::WebFilterOperations background_filters; - background_filters.append( - WebKit::WebFilterOperation::createGrayscaleFilter(1.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(1.f)); + FilterOperations background_filters; + background_filters.Append( + FilterOperation::CreateGrayscaleFilter(1.f)); skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(new SkBlurImageFilter(SK_Scalar1, SK_Scalar1)); diff --git a/cc/quads/render_pass.h b/cc/quads/render_pass.h index f288569..da1bc9a 100644 --- a/cc/quads/render_pass.h +++ b/cc/quads/render_pass.h @@ -14,7 +14,6 @@ #include "cc/base/scoped_ptr_hash_map.h" #include "cc/base/scoped_ptr_vector.h" #include "skia/ext/refptr.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/core/SkColor.h" #include "third_party/skia/include/core/SkImageFilter.h" #include "ui/gfx/rect.h" diff --git a/cc/quads/render_pass_draw_quad.cc b/cc/quads/render_pass_draw_quad.cc index 6df60ed..ead3d79 100644 --- a/cc/quads/render_pass_draw_quad.cc +++ b/cc/quads/render_pass_draw_quad.cc @@ -37,9 +37,9 @@ void RenderPassDrawQuad::SetNew( ResourceProvider::ResourceId mask_resource_id, gfx::Rect contents_changed_since_last_frame, gfx::RectF mask_uv_rect, - const WebKit::WebFilterOperations& filters, + const FilterOperations& filters, skia::RefPtr<SkImageFilter> filter, - const WebKit::WebFilterOperations& background_filters) { + const FilterOperations& background_filters) { DCHECK_GT(render_pass_id.layer_id, 0); DCHECK_GE(render_pass_id.index, 0); @@ -63,9 +63,9 @@ void RenderPassDrawQuad::SetAll( ResourceProvider::ResourceId mask_resource_id, gfx::Rect contents_changed_since_last_frame, gfx::RectF mask_uv_rect, - const WebKit::WebFilterOperations& filters, + const FilterOperations& filters, skia::RefPtr<SkImageFilter> filter, - const WebKit::WebFilterOperations& background_filters) { + const FilterOperations& background_filters) { DCHECK_GT(render_pass_id.layer_id, 0); DCHECK_GE(render_pass_id.index, 0); diff --git a/cc/quads/render_pass_draw_quad.h b/cc/quads/render_pass_draw_quad.h index 6d67917..f0c76a9 100644 --- a/cc/quads/render_pass_draw_quad.h +++ b/cc/quads/render_pass_draw_quad.h @@ -8,10 +8,10 @@ #include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "cc/base/cc_export.h" +#include "cc/output/filter_operations.h" #include "cc/quads/draw_quad.h" #include "cc/quads/render_pass.h" #include "cc/resources/resource_provider.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" namespace cc { @@ -27,9 +27,9 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad { ResourceProvider::ResourceId mask_resource_id, gfx::Rect contents_changed_since_last_frame, gfx::RectF mask_uv_rect, - const WebKit::WebFilterOperations& filters, + const FilterOperations& filters, skia::RefPtr<SkImageFilter> filter, - const WebKit::WebFilterOperations& background_filters); + const FilterOperations& background_filters); void SetAll(const SharedQuadState* shared_quad_state, gfx::Rect rect, @@ -41,9 +41,9 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad { ResourceProvider::ResourceId mask_resource_id, gfx::Rect contents_changed_since_last_frame, gfx::RectF mask_uv_rect, - const WebKit::WebFilterOperations& filters, + const FilterOperations& filters, skia::RefPtr<SkImageFilter> filter, - const WebKit::WebFilterOperations& background_filters); + const FilterOperations& background_filters); scoped_ptr<RenderPassDrawQuad> Copy( const SharedQuadState* copied_shared_quad_state, @@ -57,13 +57,13 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad { // Deprecated post-processing filters, applied to the pixels in the render // pass' texture. - WebKit::WebFilterOperations filters; + FilterOperations filters; // Post-processing filter applied to the pixels in the render pass' texture. skia::RefPtr<SkImageFilter> filter; // Post-processing filters, applied to the pixels showing through the // background of the render pass, from behind it. - WebKit::WebFilterOperations background_filters; + FilterOperations background_filters; virtual void IterateResources(const ResourceIteratorCallback& callback) OVERRIDE; diff --git a/cc/quads/render_pass_unittest.cc b/cc/quads/render_pass_unittest.cc index fdeb4f0..b12faa8 100644 --- a/cc/quads/render_pass_unittest.cc +++ b/cc/quads/render_pass_unittest.cc @@ -11,7 +11,6 @@ #include "cc/test/geometry_test_utils.h" #include "cc/test/render_pass_test_common.h" #include "testing/gtest/include/gtest/gtest.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/effects/SkBlurImageFilter.h" #include "ui/gfx/transform.h" diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc index fc98001..238c499 100644 --- a/cc/test/render_pass_test_common.cc +++ b/cc/test/render_pass_test_common.cc @@ -119,9 +119,9 @@ void TestRenderPass::AppendOneOfEveryQuadType( resource5, rect, gfx::RectF(), - WebKit::WebFilterOperations(), + FilterOperations(), skia::RefPtr<SkImageFilter>(), - WebKit::WebFilterOperations()); + FilterOperations()); AppendQuad(render_pass_quad.PassAs<DrawQuad>()); scoped_ptr<cc::RenderPassDrawQuad> render_pass_replica_quad = @@ -133,9 +133,9 @@ void TestRenderPass::AppendOneOfEveryQuadType( resource5, rect, gfx::RectF(), - WebKit::WebFilterOperations(), + FilterOperations(), skia::RefPtr<SkImageFilter>(), - WebKit::WebFilterOperations()); + FilterOperations()); AppendQuad(render_pass_replica_quad.PassAs<DrawQuad>()); } diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc index a102de0..ef79fb5 100644 --- a/cc/test/render_pass_test_utils.cc +++ b/cc/test/render_pass_test_utils.cc @@ -85,8 +85,8 @@ void AddRenderPassQuad(TestRenderPass* to_pass, gfx::Transform(), output_rect.size(), output_rect, output_rect, false, 1); scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create(); quad->SetNew(shared_state, output_rect, contributing_pass->id, false, 0, - output_rect, gfx::RectF(), WebKit::WebFilterOperations(), - skia::RefPtr<SkImageFilter>(), WebKit::WebFilterOperations()); + output_rect, gfx::RectF(), FilterOperations(), + skia::RefPtr<SkImageFilter>(), FilterOperations()); quad_sink.Append(quad.PassAs<DrawQuad>(), &data); } @@ -106,8 +106,8 @@ void AddRenderPassQuad(TestRenderPass* to_pass, scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create(); quad->SetNew(shared_state, output_rect, contributing_pass->id, false, mask_resource_id, output_rect, gfx::RectF(), - WebKit::WebFilterOperations(), - filter, WebKit::WebFilterOperations()); + FilterOperations(), + filter, FilterOperations()); quad_sink.Append(quad.PassAs<DrawQuad>(), &data); } diff --git a/cc/trees/damage_tracker.cc b/cc/trees/damage_tracker.cc index bed82c0..64b1586 100644 --- a/cc/trees/damage_tracker.cc +++ b/cc/trees/damage_tracker.cc @@ -10,9 +10,9 @@ #include "cc/layers/heads_up_display_layer_impl.h" #include "cc/layers/layer_impl.h" #include "cc/layers/render_surface_impl.h" +#include "cc/output/filter_operations.h" #include "cc/trees/layer_tree_host_common.h" #include "cc/trees/layer_tree_impl.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" namespace cc { @@ -27,16 +27,16 @@ DamageTracker::DamageTracker() DamageTracker::~DamageTracker() {} static inline void ExpandRectWithFilters( - gfx::RectF* rect, const WebKit::WebFilterOperations& filters) { + gfx::RectF* rect, const FilterOperations& filters) { int top, right, bottom, left; - filters.getOutsets(top, right, bottom, left); + filters.GetOutsets(&top, &right, &bottom, &left); rect->Inset(-left, -top, -right, -bottom); } static inline void ExpandDamageRectInsideRectWithFilters( gfx::RectF* damage_rect, const gfx::RectF& pre_filter_rect, - const WebKit::WebFilterOperations& filters) { + const FilterOperations& filters) { gfx::RectF expanded_damage_rect = *damage_rect; ExpandRectWithFilters(&expanded_damage_rect, filters); gfx::RectF filter_rect = pre_filter_rect; @@ -52,7 +52,7 @@ void DamageTracker::UpdateDamageTrackingState( bool target_surface_property_changed_only_from_descendant, gfx::Rect target_surface_content_rect, LayerImpl* target_surface_mask_layer, - const WebKit::WebFilterOperations& filters, + const FilterOperations& filters, SkImageFilter* filter) { // // This function computes the "damage rect" of a target surface, and updates @@ -143,7 +143,7 @@ void DamageTracker::UpdateDamageTrackingState( damage_rect_for_this_update.Union(damage_from_surface_mask); damage_rect_for_this_update.Union(damage_from_leftover_rects); - if (filters.hasFilterThatMovesPixels()) { + if (filters.HasFilterThatMovesPixels()) { ExpandRectWithFilters(&damage_rect_for_this_update, filters); } else if (filter) { // TODO(senorblanco): Once SkImageFilter reports its outsets, use @@ -390,7 +390,7 @@ void DamageTracker::ExtendDamageForRenderSurface( // those pixels from the surface with only the contents of layers below this // one in them. This means we need to redraw any pixels in the surface being // used for the blur in this layer this frame. - if (layer->background_filters().hasFilterThatMovesPixels()) { + if (layer->background_filters().HasFilterThatMovesPixels()) { ExpandDamageRectInsideRectWithFilters(target_damage_rect, surface_rect_in_target_space, layer->background_filters()); diff --git a/cc/trees/damage_tracker.h b/cc/trees/damage_tracker.h index 716e573..ce72fcc 100644 --- a/cc/trees/damage_tracker.h +++ b/cc/trees/damage_tracker.h @@ -18,12 +18,9 @@ namespace gfx { class Rect; } -namespace WebKit { -class WebFilterOperations; -} - namespace cc { +class FilterOperations; class LayerImpl; class RenderSurfaceImpl; @@ -43,7 +40,7 @@ class CC_EXPORT DamageTracker { bool target_surface_property_changed_only_from_descendant, gfx::Rect target_surface_content_rect, LayerImpl* target_surface_mask_layer, - const WebKit::WebFilterOperations& filters, + const FilterOperations& filters, SkImageFilter* filter); gfx::RectF current_damage_rect() { return current_damage_rect_; } diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc index 56bf80b..d65ff20 100644 --- a/cc/trees/damage_tracker_unittest.cc +++ b/cc/trees/damage_tracker_unittest.cc @@ -6,20 +6,17 @@ #include "cc/base/math_util.h" #include "cc/layers/layer_impl.h" +#include "cc/output/filter_operation.h" +#include "cc/output/filter_operations.h" #include "cc/test/fake_impl_proxy.h" #include "cc/test/fake_layer_tree_host_impl.h" #include "cc/test/geometry_test_utils.h" #include "cc/trees/layer_tree_host_common.h" #include "cc/trees/single_thread_proxy.h" #include "testing/gtest/include/gtest/gtest.h" -#include "third_party/WebKit/public/platform/WebFilterOperation.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "third_party/skia/include/effects/SkBlurImageFilter.h" #include "ui/gfx/quad_f.h" -using WebKit::WebFilterOperation; -using WebKit::WebFilterOperations; - namespace cc { namespace { @@ -420,10 +417,10 @@ TEST_F(DamageTrackerTest, VerifyDamageForBlurredSurface) { LayerImpl* surface = root->children()[0]; LayerImpl* child = surface->children()[0]; - WebFilterOperations filters; - filters.append(WebFilterOperation::createBlurFilter(5)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(5.f)); int outset_top, outset_right, outset_bottom, outset_left; - filters.getOutsets(outset_top, outset_right, outset_bottom, outset_left); + filters.GetOutsets(&outset_top, &outset_right, &outset_bottom, &outset_left); // Setting the filter will damage the whole surface. ClearDamageForAllSurfaces(root.get()); @@ -494,10 +491,10 @@ TEST_F(DamageTrackerTest, VerifyDamageForBackgroundBlurredChild) { // Allow us to set damage on child1 too. child1->SetDrawsContent(true); - WebFilterOperations filters; - filters.append(WebFilterOperation::createBlurFilter(2)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(2.f)); int outset_top, outset_right, outset_bottom, outset_left; - filters.getOutsets(outset_top, outset_right, outset_bottom, outset_left); + filters.GetOutsets(&outset_top, &outset_right, &outset_bottom, &outset_left); // Setting the filter will damage the whole surface. ClearDamageForAllSurfaces(root.get()); @@ -1312,7 +1309,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) { false, gfx::Rect(), NULL, - WebFilterOperations(), + FilterOperations(), NULL); gfx::RectF damage_rect = diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc index 2536646..e86aaf5 100644 --- a/cc/trees/layer_tree_host.cc +++ b/cc/trees/layer_tree_host.cc @@ -866,7 +866,7 @@ size_t LayerTreeHost::CalculateMemoryForRenderSurfaces( GL_RGBA); contents_texture_bytes += bytes; - if (render_surface_layer->background_filters().isEmpty()) + if (render_surface_layer->background_filters().IsEmpty()) continue; if (bytes > max_background_texture_bytes) diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc index f4c64f9..f99a1ca 100644 --- a/cc/trees/layer_tree_host_common.cc +++ b/cc/trees/layer_tree_host_common.cc @@ -319,7 +319,7 @@ static bool SubtreeShouldRenderToSeparateSurface( } // If the layer uses a CSS filter. - if (!layer->filters().isEmpty() || !layer->background_filters().isEmpty() || + if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty() || layer->filter()) { DCHECK(!is_root); return true; @@ -1206,7 +1206,7 @@ static void CalculateDrawPropertiesInternal( // TODO(senorblanco): make this smarter for the SkImageFilter case (check // for pixel-moving filters) - if (layer->filters().hasFilterThatMovesPixels() || layer->filter()) + if (layer->filters().HasFilterThatMovesPixels() || layer->filter()) nearest_ancestor_that_moves_pixels = render_surface; // The render surface clip rect is expressed in the space where this surface diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc index 74aa4a0..fdae685 100644 --- a/cc/trees/layer_tree_host_impl_unittest.cc +++ b/cc/trees/layer_tree_host_impl_unittest.cc @@ -4892,9 +4892,9 @@ static void ConfigureRenderPassTestData(const char* test_script, 1, contents_changed_rect, gfx::RectF(0.f, 0.f, 1.f, 1.f), - WebKit::WebFilterOperations(), + FilterOperations(), skia::RefPtr<SkImageFilter>(), - WebKit::WebFilterOperations()); + FilterOperations()); render_pass->AppendQuad(quad.PassAs<DrawQuad>()); } } diff --git a/cc/trees/layer_tree_host_pixeltest_filters.cc b/cc/trees/layer_tree_host_pixeltest_filters.cc index 70b6dcd..0313830 100644 --- a/cc/trees/layer_tree_host_pixeltest_filters.cc +++ b/cc/trees/layer_tree_host_pixeltest_filters.cc @@ -26,8 +26,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlur) { background->AddChild(green); background->AddChild(blur); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(2)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(2.f)); blur->SetBackgroundFilters(filters); RunPixelTest(GL_WITH_BITMAP, @@ -51,8 +51,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOutsets) { background->AddChild(green_border); background->AddChild(blur); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(5)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(5.f)); blur->SetBackgroundFilters(filters); RunPixelTest(GL_WITH_BITMAP, @@ -89,8 +89,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOffAxis) { blur_transform.Translate(-60.0, -60.0); blur->SetTransform(blur_transform); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(2)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(2.f)); blur->SetBackgroundFilters(filters); #if defined(OS_WIN) diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc index d80373d..362e41e45 100644 --- a/cc/trees/layer_tree_host_unittest_context.cc +++ b/cc/trees/layer_tree_host_unittest_context.cc @@ -15,6 +15,7 @@ #include "cc/layers/texture_layer_impl.h" #include "cc/layers/video_layer.h" #include "cc/layers/video_layer_impl.h" +#include "cc/output/filter_operations.h" #include "cc/test/fake_content_layer.h" #include "cc/test/fake_content_layer_client.h" #include "cc/test/fake_content_layer_impl.h" @@ -34,7 +35,6 @@ #include "cc/trees/single_thread_proxy.h" #include "gpu/GLES2/gl2extchromium.h" #include "media/base/media.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" using media::VideoFrame; using WebKit::WebGraphicsContext3D; @@ -419,8 +419,8 @@ class LayerTreeHostContextTestLostContextSucceedsWithContent if (use_surface_) { content_->SetForceRenderSurface(true); // Filters require us to create an offscreen context. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(0.5f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f)); content_->SetFilters(filters); content_->SetBackgroundFilters(filters); } @@ -550,8 +550,8 @@ class LayerTreeHostContextTestOffscreenContextFails content_->SetIsDrawable(true); content_->SetForceRenderSurface(true); // Filters require us to create an offscreen context. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(0.5f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f)); content_->SetFilters(filters); content_->SetBackgroundFilters(filters); diff --git a/cc/trees/layer_tree_host_unittest_occlusion.cc b/cc/trees/layer_tree_host_unittest_occlusion.cc index ea32a9e..a723e47 100644 --- a/cc/trees/layer_tree_host_unittest_occlusion.cc +++ b/cc/trees/layer_tree_host_unittest_occlusion.cc @@ -349,8 +349,8 @@ class LayerTreeHostOcclusionTestOcclusionOpacityFilter child_transform.Rotate(90.0); child_transform.Translate(-250.0, -250.0); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createOpacityFilter(0.5)); + FilterOperations filters; + filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); // If the child layer has a filter that changes alpha values, and is below // child2, then child2 should contribute to occlusion on everything, @@ -393,8 +393,8 @@ class LayerTreeHostOcclusionTestOcclusionBlurFilter child_transform.Rotate(90.0); child_transform.Translate(-250.0, -250.0); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(10)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(10.f)); // If the child layer has a filter that moves pixels/changes alpha, and is // below child2, then child should not inherit occlusion from outside its diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc index 6babf7a..e19b4a8 100644 --- a/cc/trees/occlusion_tracker.cc +++ b/cc/trees/occlusion_tracker.cc @@ -229,7 +229,7 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::FinishedRenderTarget( if (finished_target->mask_layer() || !SurfaceOpacityKnown(surface) || surface->draw_opacity() < 1 || - finished_target->filters().hasFilterThatAffectsOpacity() || + finished_target->filters().HasFilterThatAffectsOpacity() || finished_target->filter()) { stack_.back().occlusion_from_outside_target.Clear(); stack_.back().occlusion_from_inside_target.Clear(); @@ -258,8 +258,8 @@ static void ReduceOcclusionBelowSurface(LayerType* contributing_layer, return; int outset_top, outset_right, outset_bottom, outset_left; - contributing_layer->background_filters().getOutsets( - outset_top, outset_right, outset_bottom, outset_left); + contributing_layer->background_filters().GetOutsets( + &outset_top, &outset_right, &outset_bottom, &outset_left); // The filter can move pixels from outside of the clip, so allow affected_area // to expand outside the clip. @@ -338,7 +338,7 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::LeaveToRenderTarget( gfx::Rect unoccluded_surface_rect; gfx::Rect unoccluded_replica_rect; - if (old_target->background_filters().hasFilterThatMovesPixels()) { + if (old_target->background_filters().HasFilterThatMovesPixels()) { unoccluded_surface_rect = UnoccludedContributingSurfaceContentRect( old_target, false, old_surface->content_rect(), NULL); if (old_target->has_replica()) { @@ -371,7 +371,7 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::LeaveToRenderTarget( } } - if (!old_target->background_filters().hasFilterThatMovesPixels()) + if (!old_target->background_filters().HasFilterThatMovesPixels()) return; ReduceOcclusionBelowSurface(old_target, diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc index 7cf6aa7..956b67b 100644 --- a/cc/trees/occlusion_tracker_unittest.cc +++ b/cc/trees/occlusion_tracker_unittest.cc @@ -9,6 +9,8 @@ #include "cc/debug/overdraw_metrics.h" #include "cc/layers/layer.h" #include "cc/layers/layer_impl.h" +#include "cc/output/filter_operation.h" +#include "cc/output/filter_operations.h" #include "cc/test/animation_test_common.h" #include "cc/test/fake_impl_proxy.h" #include "cc/test/fake_layer_tree_host_impl.h" @@ -18,8 +20,6 @@ #include "cc/trees/single_thread_proxy.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" -#include "third_party/WebKit/public/platform/WebFilterOperation.h" -#include "third_party/WebKit/public/platform/WebFilterOperations.h" #include "ui/gfx/transform.h" namespace cc { @@ -1621,16 +1621,16 @@ class OcclusionTrackerTestFilters : public OcclusionTrackerTest<Types> { gfx::Size(500, 500), true); - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(10.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(10.f)); blur_layer->SetFilters(filters); - filters.clear(); - filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(0.5f)); + filters.Clear(); + filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f)); opaque_layer->SetFilters(filters); - filters.clear(); - filters.append(WebKit::WebFilterOperation::createOpacityFilter(0.5f)); + filters.Clear(); + filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); opacity_layer->SetFilters(filters); this->CalcDrawEtc(parent); @@ -3571,13 +3571,14 @@ class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter true); // Filters make the layer own a surface. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(10.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(10.f)); filtered_surface->SetBackgroundFilters(filters); // Save the distance of influence for the blur effect. int outset_top, outset_right, outset_bottom, outset_left; - filters.getOutsets(outset_top, outset_right, outset_bottom, outset_left); + filters.GetOutsets( + &outset_top, &outset_right, &outset_bottom, &outset_left); this->CalcDrawEtc(parent); @@ -3754,14 +3755,15 @@ class OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice true); // Filters make the layers own surfaces. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(1.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(1.f)); filtered_surface1->SetBackgroundFilters(filters); filtered_surface2->SetBackgroundFilters(filters); // Save the distance of influence for the blur effect. int outset_top, outset_right, outset_bottom, outset_left; - filters.getOutsets(outset_top, outset_right, outset_bottom, outset_left); + filters.GetOutsets( + &outset_top, &outset_right, &outset_bottom, &outset_left); this->CalcDrawEtc(root); @@ -3861,13 +3863,14 @@ class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip // Filters make the layer own a surface. This filter is large enough that it // goes outside the bottom of the clipping_surface. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(12.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(12.f)); filtered_surface->SetBackgroundFilters(filters); // Save the distance of influence for the blur effect. int outset_top, outset_right, outset_bottom, outset_left; - filters.getOutsets(outset_top, outset_right, outset_bottom, outset_left); + filters.GetOutsets( + &outset_top, &outset_right, &outset_bottom, &outset_left); this->CalcDrawEtc(parent); @@ -4071,8 +4074,8 @@ class OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter gfx::Size()); // Filters make the layer own a surface. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(3.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(3.f)); filtered_surface->SetBackgroundFilters(filters); this->CalcDrawEtc(parent); @@ -4150,8 +4153,8 @@ class OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded true); // Filters make the layer own a surface. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(3.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(3.f)); filtered_surface->SetBackgroundFilters(filters); this->CalcDrawEtc(parent); @@ -4254,13 +4257,14 @@ class OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded true); // Filters make the layer own a surface. - WebKit::WebFilterOperations filters; - filters.append(WebKit::WebFilterOperation::createBlurFilter(3.f)); + FilterOperations filters; + filters.Append(FilterOperation::CreateBlurFilter(3.f)); filtered_surface->SetBackgroundFilters(filters); // Save the distance of influence for the blur effect. int outset_top, outset_right, outset_bottom, outset_left; - filters.getOutsets(outset_top, outset_right, outset_bottom, outset_left); + filters.GetOutsets( + &outset_top, &outset_right, &outset_bottom, &outset_left); this->CalcDrawEtc(parent); |