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

cc/paint/filter_operation.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
-#include "cc/output/filter_operation.h"
+#include "cc/paint/filter_operation.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.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_;
   }
   if (type_ == REFERENCE) {
     return image_filter_.get() == other.image_filter_.get();
   }
   if (type_ == ALPHA_THRESHOLD) {
-    return region_ == other.region_ &&
-        amount_ == other.amount_ &&
-        outer_threshold_ == other.outer_threshold_;
+    return region_ == other.region_ && amount_ == other.amount_ &&
+           outer_threshold_ == other.outer_threshold_;
   }
   return amount_ == other.amount_;
 }
 
 FilterOperation::FilterOperation() : FilterOperation(GRAYSCALE, 0.f) {}
 
 FilterOperation::FilterOperation(FilterType type, float amount)
     : type_(type),
       amount_(amount),
       outer_threshold_(0),
@@ skipping 75 matching lines @@
       amount_(other.amount_),
       outer_threshold_(other.outer_threshold_),
       drop_shadow_offset_(other.drop_shadow_offset_),
       drop_shadow_color_(other.drop_shadow_color_),
       image_filter_(other.image_filter_),
       zoom_inset_(other.zoom_inset_),
       region_(other.region_) {
   memcpy(matrix_, other.matrix_, sizeof(matrix_));
 }
 
-FilterOperation::~FilterOperation() {
-}
+FilterOperation::~FilterOperation() {}
 
 static FilterOperation CreateNoOpFilter(FilterOperation::FilterType type) {
   switch (type) {
     case FilterOperation::GRAYSCALE:
       return FilterOperation::CreateGrayscaleFilter(0.f);
     case FilterOperation::SEPIA:
       return FilterOperation::CreateSepiaFilter(0.f);
     case FilterOperation::SATURATE:
       return FilterOperation::CreateSaturateFilter(1.f);
     case FilterOperation::HUE_ROTATE:
       return FilterOperation::CreateHueRotateFilter(0.f);
     case FilterOperation::INVERT:
       return FilterOperation::CreateInvertFilter(0.f);
     case FilterOperation::BRIGHTNESS:
       return FilterOperation::CreateBrightnessFilter(1.f);
     case FilterOperation::CONTRAST:
       return FilterOperation::CreateContrastFilter(1.f);
     case FilterOperation::OPACITY:
       return FilterOperation::CreateOpacityFilter(1.f);
     case FilterOperation::BLUR:
       return FilterOperation::CreateBlurFilter(0.f);
     case FilterOperation::DROP_SHADOW:
-      return FilterOperation::CreateDropShadowFilter(
-          gfx::Point(0, 0), 0.f, SK_ColorTRANSPARENT);
+      return FilterOperation::CreateDropShadowFilter(gfx::Point(0, 0), 0.f,
+                                                     SK_ColorTRANSPARENT);
     case FilterOperation::COLOR_MATRIX: {
       SkScalar matrix[20];
       memset(matrix, 0, 20 * sizeof(SkScalar));
       matrix[0] = matrix[6] = matrix[12] = matrix[18] = 1.f;
       return FilterOperation::CreateColorMatrixFilter(matrix);
     }
     case FilterOperation::ZOOM:
       return FilterOperation::CreateZoomFilter(1.f, 0);
     case FilterOperation::SATURATING_BRIGHTNESS:
       return FilterOperation::CreateSaturatingBrightnessFilter(0.f);
@@ skipping 59 matching lines @@
     else
       blended_filter.set_image_filter(from_op.image_filter());
     return blended_filter;
   }
 
   blended_filter.set_amount(ClampAmountForFilterType(
       gfx::Tween::FloatValueBetween(progress, from_op.amount(), to_op.amount()),
       to_op.type()));
 
   if (to_op.type() == FilterOperation::DROP_SHADOW) {
-    gfx::Point blended_offset(
-        gfx::Tween::LinearIntValueBetween(progress,
-                                          from_op.drop_shadow_offset().x(),
-                                          to_op.drop_shadow_offset().x()),
-        gfx::Tween::LinearIntValueBetween(progress,
-                                          from_op.drop_shadow_offset().y(),
-                                          to_op.drop_shadow_offset().y()));
+    gfx::Point blended_offset(gfx::Tween::LinearIntValueBetween(
+                                  progress, from_op.drop_shadow_offset().x(),
+                                  to_op.drop_shadow_offset().x()),
+                              gfx::Tween::LinearIntValueBetween(
+                                  progress, from_op.drop_shadow_offset().y(),
+                                  to_op.drop_shadow_offset().y()));
     blended_filter.set_drop_shadow_offset(blended_offset);
     blended_filter.set_drop_shadow_color(gfx::Tween::ColorValueBetween(
         progress, from_op.drop_shadow_color(), to_op.drop_shadow_color()));
   } else if (to_op.type() == FilterOperation::ZOOM) {
     blended_filter.set_zoom_inset(
         std::max(gfx::Tween::LinearIntValueBetween(
                      progress, from_op.zoom_inset(), to_op.zoom_inset()),
                  0));
   } else if (to_op.type() == FilterOperation::ALPHA_THRESHOLD) {
     blended_filter.set_outer_threshold(ClampAmountForFilterType(
-            gfx::Tween::FloatValueBetween(progress,
-                                          from_op.outer_threshold(),
-                                          to_op.outer_threshold()),
-            to_op.type()));
+        gfx::Tween::FloatValueBetween(progress, from_op.outer_threshold(),
+                                      to_op.outer_threshold()),
+        to_op.type()));
     blended_filter.set_region(to_op.region());
   }
 
   return blended_filter;
 }
 
 void FilterOperation::AsValueInto(base::trace_event::TracedValue* value) const {
   value->SetInteger("type", type_);
   switch (type_) {
     case FilterOperation::GRAYSCALE:
@@ skipping 27 matching lines @@
     case FilterOperation::REFERENCE: {
       int count_inputs = 0;
       if (image_filter_) {
         count_inputs = image_filter_->countInputs();
       }
       value->SetBoolean("is_null", !image_filter_);
       value->SetInteger("count_inputs", count_inputs);
       break;
     }
     case FilterOperation::ALPHA_THRESHOLD: {
-        value->SetDouble("inner_threshold", amount_);
-        value->SetDouble("outer_threshold", outer_threshold_);
-        std::unique_ptr<base::ListValue> region_value(new base::ListValue());
-        value->BeginArray("region");
-        for (SkRegion::Iterator it(region_); !it.done(); it.next()) {
-          value->AppendInteger(it.rect().x());
-          value->AppendInteger(it.rect().y());
-          value->AppendInteger(it.rect().width());
-          value->AppendInteger(it.rect().height());
-        }
-        value->EndArray();
+      value->SetDouble("inner_threshold", amount_);
+      value->SetDouble("outer_threshold", outer_threshold_);
+      std::unique_ptr<base::ListValue> region_value(new base::ListValue());
+      value->BeginArray("region");
+      for (SkRegion::Iterator it(region_); !it.done(); it.next()) {
+        value->AppendInteger(it.rect().x());
+        value->AppendInteger(it.rect().y());
+        value->AppendInteger(it.rect().width());
+        value->AppendInteger(it.rect().height());
       }
-      break;
+      value->EndArray();
+    } break;
   }
 }
 
 namespace {
 
 SkVector MapStdDeviation(float std_deviation, const SkMatrix& matrix) {
   // Corresponds to SpreadForStdDeviation in filter_operations.cc.
   SkVector sigma = SkVector::Make(std_deviation, std_deviation);
   matrix.mapVectors(&sigma, 1);
   return sigma * SkIntToScalar(3);
@@ skipping 49 matching lines @@
                          SkImageFilter::kForward_MapDirection);
 }
 
 gfx::Rect FilterOperation::MapRectReverse(const gfx::Rect& rect,
                                           const SkMatrix& matrix) const {
   return MapRectInternal(*this, rect, matrix,
                          SkImageFilter::kReverse_MapDirection);
 }
 
 }  // namespace cc