Move cc::DisplayItemList and related classes into cc/paint/

cc/output/filter_operations.cc

Index: cc/output/filter_operations.cc
diff --git a/cc/output/filter_operations.cc b/cc/output/filter_operations.cc
deleted file mode 100644
index dc18a228d168a8283826459aa05ada8bf3a493c0..0000000000000000000000000000000000000000
--- a/cc/output/filter_operations.cc
+++ /dev/null
@@ -1,256 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "cc/output/filter_operations.h"
-
-#include <stddef.h>
-
-#include <cmath>
-#include <numeric>
-
-#include "base/trace_event/trace_event_argument.h"
-#include "base/values.h"
-#include "cc/output/filter_operation.h"
-#include "ui/gfx/geometry/rect.h"
-
-namespace cc {
-
-FilterOperations::FilterOperations() {}
-
-FilterOperations::FilterOperations(const FilterOperations& other)
-    : operations_(other.operations_) {}
-
-FilterOperations::FilterOperations(std::vector<FilterOperation>&& operations)
-    : operations_(std::move(operations)) {}
-
-FilterOperations::~FilterOperations() {}
-
-FilterOperations& FilterOperations::operator=(const FilterOperations& other) {
-  operations_ = other.operations_;
-  return *this;
-}
-
-FilterOperations& FilterOperations::operator=(FilterOperations&& other) {
-  operations_ = std::move(other.operations_);
-  return *this;
-}
-
-bool FilterOperations::operator==(const FilterOperations& other) const {
-  if (other.size() != size())
-    return false;
-  for (size_t i = 0; i < size(); ++i) {
-    if (other.at(i) != at(i))
-      return false;
-  }
-  return true;
-}
-
-void FilterOperations::Append(const FilterOperation& filter) {
-  operations_.push_back(filter);
-}
-
-void FilterOperations::Clear() {
-  operations_.clear();
-}
-
-bool FilterOperations::IsEmpty() const {
-  return operations_.empty();
-}
-
-static int SpreadForStdDeviation(float std_deviation) {
-  // Corresponds to MapStdDeviation in filter_operation.cc.
-  return std_deviation * 3;
-}
-
-gfx::Rect FilterOperations::MapRect(const gfx::Rect& rect,
-                                    const SkMatrix& matrix) const {
-  auto accumulate_rect = [matrix](const gfx::Rect& rect,
-                                  const FilterOperation& op) {
-    return op.MapRect(rect, matrix);
-  };
-  return std::accumulate(operations_.begin(), operations_.end(), rect,
-                         accumulate_rect);
-}
-
-gfx::Rect FilterOperations::MapRectReverse(const gfx::Rect& rect,
-                                           const SkMatrix& matrix) const {
-  auto accumulate_rect = [&matrix](const gfx::Rect& rect,
-                                   const FilterOperation& op) {
-    return op.MapRectReverse(rect, matrix);
-  };
-  return std::accumulate(operations_.rbegin(), operations_.rend(), rect,
-                         accumulate_rect);
-}
-
-void FilterOperations::GetOutsets(int* top,
-                                  int* right,
-                                  int* bottom,
-                                  int* left) const {
-  *top = *right = *bottom = *left = 0;
-  for (size_t i = 0; i < operations_.size(); ++i) {
-    const FilterOperation& op = operations_[i];
-    // TODO(hendrikw): We should refactor some of this. See crbug.com/523534.
-    if (op.type() == FilterOperation::REFERENCE) {
-      if (!op.image_filter())
-        continue;
-      SkIRect src = SkIRect::MakeWH(0, 0);
-      SkIRect dst = op.image_filter()->filterBounds(src, SkMatrix::I());
-      *top += std::max(0, -dst.top());
-      *right += std::max(0, dst.right());
-      *bottom += std::max(0, dst.bottom());
-      *left += std::max(0, -dst.left());
-    } else {
-      if (op.type() == FilterOperation::BLUR ||
-          op.type() == FilterOperation::DROP_SHADOW) {
-        int spread = SpreadForStdDeviation(op.amount());
-        if (op.type() == FilterOperation::BLUR) {
-          *top += spread;
-          *right += spread;
-          *bottom += spread;
-          *left += spread;
-        } else {
-          *top += std::max(0, spread - op.drop_shadow_offset().y());
-          *right += std::max(0, spread + op.drop_shadow_offset().x());
-          *bottom += std::max(0, spread + op.drop_shadow_offset().y());
-          *left += std::max(0, spread - op.drop_shadow_offset().x());
-        }
-      }
-    }
-  }
-}
-
-bool FilterOperations::HasFilterThatMovesPixels() const {
-  for (size_t i = 0; i < operations_.size(); ++i) {
-    const FilterOperation& op = operations_[i];
-    switch (op.type()) {
-      case FilterOperation::BLUR:
-      case FilterOperation::DROP_SHADOW:
-      case FilterOperation::ZOOM:
-        return true;
-      case FilterOperation::REFERENCE:
-        // TODO(hendrikw): SkImageFilter needs a function that tells us if the
-        // filter can move pixels. See crbug.com/523538.
-        return true;
-      case FilterOperation::OPACITY:
-      case FilterOperation::COLOR_MATRIX:
-      case FilterOperation::GRAYSCALE:
-      case FilterOperation::SEPIA:
-      case FilterOperation::SATURATE:
-      case FilterOperation::HUE_ROTATE:
-      case FilterOperation::INVERT:
-      case FilterOperation::BRIGHTNESS:
-      case FilterOperation::CONTRAST:
-      case FilterOperation::SATURATING_BRIGHTNESS:
-      case FilterOperation::ALPHA_THRESHOLD:
-        break;
-    }
-  }
-  return false;
-}
-
-bool FilterOperations::HasFilterThatAffectsOpacity() const {
-  for (size_t i = 0; i < operations_.size(); ++i) {
-    const FilterOperation& op = operations_[i];
-    // TODO(ajuma): Make this smarter for reference filters. Once SkImageFilter
-    // can report affectsOpacity(), call that.
-    switch (op.type()) {
-      case FilterOperation::OPACITY:
-      case FilterOperation::BLUR:
-      case FilterOperation::DROP_SHADOW:
-      case FilterOperation::ZOOM:
-      case FilterOperation::REFERENCE:
-      case FilterOperation::ALPHA_THRESHOLD:
-        return true;
-      case FilterOperation::COLOR_MATRIX: {
-        const SkScalar* matrix = op.matrix();
-        if (matrix[15] ||
-            matrix[16] ||
-            matrix[17] ||
-            matrix[18] != 1 ||
-            matrix[19])
-          return true;
-        break;
-      }
-      case FilterOperation::GRAYSCALE:
-      case FilterOperation::SEPIA:
-      case FilterOperation::SATURATE:
-      case FilterOperation::HUE_ROTATE:
-      case FilterOperation::INVERT:
-      case FilterOperation::BRIGHTNESS:
-      case FilterOperation::CONTRAST:
-      case FilterOperation::SATURATING_BRIGHTNESS:
-        break;
-    }
-  }
-  return false;
-}
-
-bool FilterOperations::HasReferenceFilter() const {
-  for (size_t i = 0; i < operations_.size(); ++i) {
-    if (operations_[i].type() == FilterOperation::REFERENCE)
-      return true;
-  }
-  return false;
-}
-
-FilterOperations FilterOperations::Blend(const FilterOperations& from,
-                                         double progress) const {
-  if (HasReferenceFilter() || from.HasReferenceFilter())
-    return *this;
-
-  bool from_is_longer = from.size() > size();
-
-  size_t shorter_size, longer_size;
-  if (size() == from.size()) {
-    shorter_size = longer_size = size();
-  } else if  (from_is_longer) {
-    longer_size = from.size();
-    shorter_size = size();
-  } else {
-    longer_size = size();
-    shorter_size = from.size();
-  }
-
-  for (size_t i = 0; i < shorter_size; i++) {
-    if (from.at(i).type() != at(i).type())
-      return *this;
-  }
-
-  FilterOperations blended_filters;
-  for (size_t i = 0; i < shorter_size; i++) {
-    blended_filters.Append(
-        FilterOperation::Blend(&from.at(i), &at(i), progress));
-  }
-
-  if (from_is_longer) {
-    for (size_t i = shorter_size; i < longer_size; i++) {
-      blended_filters.Append(
-          FilterOperation::Blend(&from.at(i), NULL, progress));
-    }
-  } else {
-    for (size_t i = shorter_size; i < longer_size; i++)
-      blended_filters.Append(FilterOperation::Blend(NULL, &at(i), progress));
-  }
-
-  return blended_filters;
-}
-
-void FilterOperations::AsValueInto(
-    base::trace_event::TracedValue* value) const {
-  for (size_t i = 0; i < operations_.size(); ++i) {
-    value->BeginDictionary();
-    operations_[i].AsValueInto(value);
-    value->EndDictionary();
-  }
-}
-
-std::string FilterOperations::ToString() const {
-  base::trace_event::TracedValue value;
-  value.BeginArray("FilterOperations");
-  AsValueInto(&value);
-  value.EndArray();
-  return value.ToString();
-}
-
-}  // namespace cc