Push CompositorFilterOperations creation out of GraphicsLayer

third_party/WebKit/Source/platform/graphics/filters/SkiaImageFilterBuilder.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 82 matching lines @@
 }
 
 void buildSourceGraphic(FilterEffect* sourceGraphic, sk_sp<SkPicture> picture)
 {
     ASSERT(picture);
     SkRect cullRect = picture->cullRect();
     sk_sp<SkImageFilter> filter = SkPictureImageFilter::Make(std::move(picture), cullRect);
     populateSourceGraphicImageFilters(sourceGraphic, std::move(filter), sourceGraphic->operatingColorSpace());
 }
 
-void buildFilterOperations(const FilterOperations& operations, CompositorFilterOperations* filters)
+CompositorFilterOperations buildFilterOperations(const FilterOperations& operations)
 {
     ColorSpace currentColorSpace = ColorSpaceDeviceRGB;
 
+    CompositorFilterOperations filters;
     for (size_t i = 0; i < operations.size(); ++i) {
         const FilterOperation& op = *operations.at(i);
         switch (op.type()) {
         case FilterOperation::REFERENCE: {
             Filter* referenceFilter = toReferenceFilterOperation(op).getFilter();
             if (referenceFilter && referenceFilter->lastEffect()) {
                 populateSourceGraphicImageFilters(referenceFilter->getSourceGraphic(), nullptr, currentColorSpace);
 
                 FilterEffect* filterEffect = referenceFilter->lastEffect();
                 currentColorSpace = filterEffect->operatingColorSpace();
-                filters->appendReferenceFilter(SkiaImageFilterBuilder::build(filterEffect, currentColorSpace));
+                filters.appendReferenceFilter(SkiaImageFilterBuilder::build(filterEffect, currentColorSpace));
             }
             break;
         }
         case FilterOperation::GRAYSCALE:
         case FilterOperation::SEPIA:
         case FilterOperation::SATURATE:
         case FilterOperation::HUE_ROTATE: {
             float amount = toBasicColorMatrixFilterOperation(op).amount();
             switch (op.type()) {
             case FilterOperation::GRAYSCALE:
-                filters->appendGrayscaleFilter(amount);
+                filters.appendGrayscaleFilter(amount);
                 break;
             case FilterOperation::SEPIA:
-                filters->appendSepiaFilter(amount);
+                filters.appendSepiaFilter(amount);
                 break;
             case FilterOperation::SATURATE:
-                filters->appendSaturateFilter(amount);
+                filters.appendSaturateFilter(amount);
                 break;
             case FilterOperation::HUE_ROTATE:
-                filters->appendHueRotateFilter(amount);
+                filters.appendHueRotateFilter(amount);
                 break;
             default:
                 ASSERT_NOT_REACHED();
             }
             break;
         }
         case FilterOperation::INVERT:
         case FilterOperation::OPACITY:
         case FilterOperation::BRIGHTNESS:
         case FilterOperation::CONTRAST: {
             float amount = toBasicComponentTransferFilterOperation(op).amount();
             switch (op.type()) {
             case FilterOperation::INVERT:
-                filters->appendInvertFilter(amount);
+                filters.appendInvertFilter(amount);
                 break;
             case FilterOperation::OPACITY:
-                filters->appendOpacityFilter(amount);
+                filters.appendOpacityFilter(amount);
                 break;
             case FilterOperation::BRIGHTNESS:
-                filters->appendBrightnessFilter(amount);
+                filters.appendBrightnessFilter(amount);
                 break;
             case FilterOperation::CONTRAST:
-                filters->appendContrastFilter(amount);
+                filters.appendContrastFilter(amount);
                 break;
             default:
                 ASSERT_NOT_REACHED();
             }
             break;
         }
         case FilterOperation::BLUR: {
             float pixelRadius = toBlurFilterOperation(op).stdDeviation().getFloatValue();
-            filters->appendBlurFilter(pixelRadius);
+            filters.appendBlurFilter(pixelRadius);
             break;
         }
         case FilterOperation::DROP_SHADOW: {
             const DropShadowFilterOperation& drop = toDropShadowFilterOperation(op);
-            filters->appendDropShadowFilter(drop.location(), drop.stdDeviation(), drop.getColor());
+            filters.appendDropShadowFilter(drop.location(), drop.stdDeviation(), drop.getColor());
             break;
         }
         case FilterOperation::BOX_REFLECT: {
             // TODO(jbroman): Consider explaining box reflect to the compositor,
             // instead of calling this a "reference filter".
             const auto& reflection = toBoxReflectFilterOperation(op).reflection();
-            filters->appendReferenceFilter(buildBoxReflectFilter(reflection, nullptr));
+            filters.appendReferenceFilter(buildBoxReflectFilter(reflection, nullptr));
             break;
         }
         case FilterOperation::NONE:
             break;
         }
     }
     if (currentColorSpace != ColorSpaceDeviceRGB) {
         // Transform to device color space at the end of processing, if required
         sk_sp<SkImageFilter> filter = transformColorSpace(nullptr, currentColorSpace, ColorSpaceDeviceRGB);
-        filters->appendReferenceFilter(std::move(filter));
+        filters.appendReferenceFilter(std::move(filter));
     }
+    return filters;
 }
 
 sk_sp<SkImageFilter> buildBoxReflectFilter(const BoxReflection& reflection, sk_sp<SkImageFilter> input)
 {
     sk_sp<SkImageFilter> maskedInput;
     if (SkPicture* maskPicture = reflection.mask()) {
         // SkXfermodeImageFilter can choose an excessively large size if the
         // mask is smaller than the filtered contents (due to overflow).
         // http://skbug.com/5210
         SkImageFilter::CropRect cropRect(maskPicture->cullRect());
         maskedInput = SkXfermodeImageFilter::Make(
             SkXfermode::Make(SkXfermode::kSrcIn_Mode),
             SkPictureImageFilter::Make(sk_ref_sp(maskPicture)),
             input, &cropRect);
     } else {
         maskedInput = input;
     }
     sk_sp<SkImageFilter> flipImageFilter = SkImageFilter::MakeMatrixFilter(
         reflection.reflectionMatrix(), kLow_SkFilterQuality, std::move(maskedInput));
     return SkXfermodeImageFilter::Make(nullptr, std::move(flipImageFilter), std::move(input), nullptr);
 }
 
 } // namespace SkiaImageFilterBuilder
 } // namespace blink