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

10 files changed, 688 insertions, 137 deletions

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);