chromium/third_party/blink/renderer/platform/animation/timing_function.cc

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/platform/animation/timing_function.h"

#include <algorithm>
#include "base/notreached.h"
#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
#include "ui/gfx/animation/keyframe/timing_function.h"

namespace blink {

String LinearTimingFunction::ToString() const { … }

double LinearTimingFunction::Evaluate(
    double fraction,
    TimingFunction::LimitDirection limit_direction) const { … }

void LinearTimingFunction::Range(double* min_value, double* max_value) const { … }

std::unique_ptr<gfx::TimingFunction> LinearTimingFunction::CloneToCC() const { … }

CubicBezierTimingFunction* CubicBezierTimingFunction::Preset(
    EaseType ease_type) { … }

String CubicBezierTimingFunction::ToString() const { … }

double CubicBezierTimingFunction::Evaluate(
    double fraction,
    TimingFunction::LimitDirection limit_direction) const { … }

void CubicBezierTimingFunction::Range(double* min_value,
                                      double* max_value) const { … }

std::unique_ptr<gfx::TimingFunction> CubicBezierTimingFunction::CloneToCC()
    const { … }

String StepsTimingFunction::ToString() const { … }

void StepsTimingFunction::Range(double* min_value, double* max_value) const { … }

double StepsTimingFunction::Evaluate(double fraction,
                                     LimitDirection limit_direction) const { … }

std::unique_ptr<gfx::TimingFunction> StepsTimingFunction::CloneToCC() const { … }

scoped_refptr<TimingFunction> CreateCompositorTimingFunctionFromCC(
    const gfx::TimingFunction* timing_function) { … }

// Equals operators
bool operator==(const LinearTimingFunction& lhs, const TimingFunction& rhs) { … }

bool operator==(const CubicBezierTimingFunction& lhs,
                const TimingFunction& rhs) { … }

bool operator==(const StepsTimingFunction& lhs, const TimingFunction& rhs) { … }

// The generic operator== *must* come after the
// non-generic operator== otherwise it will end up calling itself.
bool operator==(const TimingFunction& lhs, const TimingFunction& rhs) { … }

// No need to define specific operator!= as they can all come via this function.
bool operator!=(const TimingFunction& lhs, const TimingFunction& rhs) { … }

}  // namespace blink