Remove parts of //cc we aren't using

cc/input/page_scale_animation.cc

Index: cc/input/page_scale_animation.cc
diff --git a/cc/input/page_scale_animation.cc b/cc/input/page_scale_animation.cc
deleted file mode 100644
index 111502b95cd34762d6defc8ba8481139e463f2ef..0000000000000000000000000000000000000000
--- a/cc/input/page_scale_animation.cc
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright 2012 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/input/page_scale_animation.h"
-
-#include <math.h>
-
-#include "base/logging.h"
-#include "cc/animation/timing_function.h"
-#include "ui/gfx/geometry/point_f.h"
-#include "ui/gfx/geometry/rect_f.h"
-#include "ui/gfx/geometry/vector2d_conversions.h"
-
-namespace {
-
-// This takes a viewport-relative vector and returns a vector whose values are
-// between 0 and 1, representing the percentage position within the viewport.
-gfx::Vector2dF NormalizeFromViewport(const gfx::Vector2dF& denormalized,
-                                     const gfx::SizeF& viewport_size) {
-  return gfx::ScaleVector2d(denormalized,
-                            1.f / viewport_size.width(),
-                            1.f / viewport_size.height());
-}
-
-gfx::Vector2dF DenormalizeToViewport(const gfx::Vector2dF& normalized,
-                                     const gfx::SizeF& viewport_size) {
-  return gfx::ScaleVector2d(normalized,
-                            viewport_size.width(),
-                            viewport_size.height());
-}
-
-gfx::Vector2dF InterpolateBetween(const gfx::Vector2dF& start,
-                                  const gfx::Vector2dF& end,
-                                  float interp) {
-  return start + gfx::ScaleVector2d(end - start, interp);
-}
-
-}  // namespace
-
-namespace cc {
-
-using base::TimeTicks;
-using base::TimeDelta;
-
-scoped_ptr<PageScaleAnimation> PageScaleAnimation::Create(
-    const gfx::Vector2dF& start_scroll_offset,
-    float start_page_scale_factor,
-    const gfx::SizeF& viewport_size,
-    const gfx::SizeF& root_layer_size,
-    scoped_ptr<TimingFunction> timing_function) {
-  return make_scoped_ptr(new PageScaleAnimation(start_scroll_offset,
-                                                start_page_scale_factor,
-                                                viewport_size,
-                                                root_layer_size,
-                                                timing_function.Pass()));
-}
-
-PageScaleAnimation::PageScaleAnimation(
-    const gfx::Vector2dF& start_scroll_offset,
-    float start_page_scale_factor,
-    const gfx::SizeF& viewport_size,
-    const gfx::SizeF& root_layer_size,
-    scoped_ptr<TimingFunction> timing_function)
-    : start_page_scale_factor_(start_page_scale_factor),
-      target_page_scale_factor_(0.f),
-      start_scroll_offset_(start_scroll_offset),
-      start_anchor_(),
-      target_anchor_(),
-      viewport_size_(viewport_size),
-      root_layer_size_(root_layer_size),
-      timing_function_(timing_function.Pass()) {
-}
-
-PageScaleAnimation::~PageScaleAnimation() {}
-
-void PageScaleAnimation::ZoomTo(const gfx::Vector2dF& target_scroll_offset,
-                                float target_page_scale_factor,
-                                double duration) {
-  target_page_scale_factor_ = target_page_scale_factor;
-  target_scroll_offset_ = target_scroll_offset;
-  ClampTargetScrollOffset();
-  duration_ = TimeDelta::FromSecondsD(duration);
-
-  if (start_page_scale_factor_ == target_page_scale_factor) {
-    start_anchor_ = start_scroll_offset_;
-    target_anchor_ = target_scroll_offset;
-    return;
-  }
-
-  // For uniform-looking zooming, infer an anchor from the start and target
-  // viewport rects.
-  InferTargetAnchorFromScrollOffsets();
-  start_anchor_ = target_anchor_;
-}
-
-void PageScaleAnimation::ZoomWithAnchor(const gfx::Vector2dF& anchor,
-                                        float target_page_scale_factor,
-                                        double duration) {
-  start_anchor_ = anchor;
-  target_page_scale_factor_ = target_page_scale_factor;
-  duration_ = TimeDelta::FromSecondsD(duration);
-
-  // We start zooming out from the anchor tapped by the user. But if
-  // the target scale is impossible to attain without hitting the root layer
-  // edges, then infer an anchor that doesn't collide with the edges.
-  // We will interpolate between the two anchors during the animation.
-  InferTargetScrollOffsetFromStartAnchor();
-  ClampTargetScrollOffset();
-
-  if (start_page_scale_factor_ == target_page_scale_factor_) {
-    target_anchor_ = start_anchor_;
-    return;
-  }
-  InferTargetAnchorFromScrollOffsets();
-}
-
-void PageScaleAnimation::InferTargetScrollOffsetFromStartAnchor() {
-  gfx::Vector2dF normalized = NormalizeFromViewport(
-      start_anchor_ - start_scroll_offset_, StartViewportSize());
-  target_scroll_offset_ =
-      start_anchor_ - DenormalizeToViewport(normalized, TargetViewportSize());
-}
-
-void PageScaleAnimation::InferTargetAnchorFromScrollOffsets() {
-  // The anchor is the point which is at the same normalized relative position
-  // within both start viewport rect and target viewport rect. For example, a
-  // zoom-in double-tap to a perfectly centered rect will have normalized
-  // anchor (0.5, 0.5), while one to a rect touching the bottom-right of the
-  // screen will have normalized anchor (1.0, 1.0). In other words, it obeys
-  // the equations:
-  // anchor = start_size * normalized + start_offset
-  // anchor = target_size * normalized + target_offset
-  // where both anchor and normalized begin as unknowns. Solving
-  // for the normalized, we get the following:
-  float width_scale =
-      1.f / (TargetViewportSize().width() - StartViewportSize().width());
-  float height_scale =
-      1.f / (TargetViewportSize().height() - StartViewportSize().height());
-  gfx::Vector2dF normalized = gfx::ScaleVector2d(
-      start_scroll_offset_ - target_scroll_offset_, width_scale, height_scale);
-  target_anchor_ =
-      target_scroll_offset_ + DenormalizeToViewport(normalized,
-                                                    TargetViewportSize());
-}
-
-void PageScaleAnimation::ClampTargetScrollOffset() {
-  gfx::Vector2dF max_scroll_offset =
-      gfx::RectF(root_layer_size_).bottom_right() -
-      gfx::RectF(TargetViewportSize()).bottom_right();
-  target_scroll_offset_.SetToMax(gfx::Vector2dF());
-  target_scroll_offset_.SetToMin(max_scroll_offset);
-}
-
-gfx::SizeF PageScaleAnimation::StartViewportSize() const {
-  return gfx::ScaleSize(viewport_size_, 1.f / start_page_scale_factor_);
-}
-
-gfx::SizeF PageScaleAnimation::TargetViewportSize() const {
-  return gfx::ScaleSize(viewport_size_, 1.f / target_page_scale_factor_);
-}
-
-gfx::SizeF PageScaleAnimation::ViewportSizeAt(float interp) const {
-  return gfx::ScaleSize(viewport_size_, 1.f / PageScaleFactorAt(interp));
-}
-
-bool PageScaleAnimation::IsAnimationStarted() const {
-  return start_time_ > base::TimeTicks();
-}
-
-void PageScaleAnimation::StartAnimation(base::TimeTicks time) {
-  DCHECK(start_time_.is_null());
-  start_time_ = time;
-}
-
-gfx::Vector2dF PageScaleAnimation::ScrollOffsetAtTime(
-    base::TimeTicks time) const {
-  DCHECK(!start_time_.is_null());
-  return ScrollOffsetAt(InterpAtTime(time));
-}
-
-float PageScaleAnimation::PageScaleFactorAtTime(base::TimeTicks time) const {
-  DCHECK(!start_time_.is_null());
-  return PageScaleFactorAt(InterpAtTime(time));
-}
-
-bool PageScaleAnimation::IsAnimationCompleteAtTime(base::TimeTicks time) const {
-  DCHECK(!start_time_.is_null());
-  return time >= end_time();
-}
-
-float PageScaleAnimation::InterpAtTime(base::TimeTicks monotonic_time) const {
-  DCHECK(!start_time_.is_null());
-  DCHECK(monotonic_time >= start_time_);
-  if (IsAnimationCompleteAtTime(monotonic_time))
-    return 1.f;
-  const double normalized_time =
-      (monotonic_time - start_time_).InSecondsF() / duration_.InSecondsF();
-  return timing_function_->GetValue(normalized_time);
-}
-
-gfx::Vector2dF PageScaleAnimation::ScrollOffsetAt(float interp) const {
-  if (interp <= 0.f)
-    return start_scroll_offset_;
-  if (interp >= 1.f)
-    return target_scroll_offset_;
-
-  return AnchorAt(interp) - ViewportRelativeAnchorAt(interp);
-}
-
-gfx::Vector2dF PageScaleAnimation::AnchorAt(float interp) const {
-  // Interpolate from start to target anchor in absolute space.
-  return InterpolateBetween(start_anchor_, target_anchor_, interp);
-}
-
-gfx::Vector2dF PageScaleAnimation::ViewportRelativeAnchorAt(
-    float interp) const {
-  // Interpolate from start to target anchor in normalized space.
-  gfx::Vector2dF start_normalized =
-      NormalizeFromViewport(start_anchor_ - start_scroll_offset_,
-                            StartViewportSize());
-  gfx::Vector2dF target_normalized =
-      NormalizeFromViewport(target_anchor_ - target_scroll_offset_,
-                            TargetViewportSize());
-  gfx::Vector2dF interp_normalized =
-      InterpolateBetween(start_normalized, target_normalized, interp);
-
-  return DenormalizeToViewport(interp_normalized, ViewportSizeAt(interp));
-}
-
-float PageScaleAnimation::PageScaleFactorAt(float interp) const {
-  if (interp <= 0.f)
-    return start_page_scale_factor_;
-  if (interp >= 1.f)
-    return target_page_scale_factor_;
-
-  // Linearly interpolate the magnitude in log scale.
-  float diff = target_page_scale_factor_ / start_page_scale_factor_;
-  float log_diff = log(diff);
-  log_diff *= interp;
-  diff = exp(log_diff);
-  return start_page_scale_factor_ * diff;
-}
-
-}  // namespace cc