content/browser/android/edge_effect.cc - platform/external/chromium_org - Git at Google

 // Copyright (c) 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 "content/browser/android/edge_effect.h"

 #include "cc/layers/layer.h"

 namespace content {

 namespace {

 enum State {
   STATE_IDLE = 0,
   STATE_PULL,
   STATE_ABSORB,
   STATE_RECEDE,
   STATE_PULL_DECAY
 };

 // Time it will take the effect to fully recede in ms
 const int kRecedeTime = 1000;

 // Time it will take before a pulled glow begins receding in ms
 const int kPullTime = 167;

 // Time it will take in ms for a pulled glow to decay before release
 const int kPullDecayTime = 1000;

 const float kMaxAlpha = 1.f;
 const float kHeldEdgeScaleY = .5f;

 const float kMaxGlowHeight = 4.f;

 const float kPullGlowBegin = 1.f;
 const float kPullEdgeBegin = 0.6f;

 // Min/max velocity that will be absorbed
 const float kMinVelocity = 100.f;
 const float kMaxVelocity = 10000.f;

 const float kEpsilon = 0.001f;

 const float kGlowHeightToWidthRatio = 0.25f;

 // How much dragging should effect the height of the edge image.
 // Number determined by user testing.
 const int kPullDistanceEdgeFactor = 7;

 // How much dragging should effect the height of the glow image.
 // Number determined by user testing.
 const int kPullDistanceGlowFactor = 7;
 const float kPullDistanceAlphaGlowFactor = 1.1f;

 const int kVelocityEdgeFactor = 8;
 const int kVelocityGlowFactor = 12;

 template <typename T>
 T Lerp(T a, T b, T t) {
   return a + (b - a) * t;
 }

 template <typename T>
 T Clamp(T value, T low, T high) {
    return value < low ? low : (value > high ? high : value);
 }

 template <typename T>
 T Damp(T input, T factor) {
   T result;
   if (factor == 1) {
     result = 1 - (1 - input) * (1 - input);
   } else {
     result = 1 - std::pow(1 - input, 2 * factor);
   }
   return result;
 }

 gfx::Transform ComputeTransform(EdgeEffect::Edge edge,
                                 const gfx::SizeF& window_size,
                                 int offset,
                                 int height) {
   // Edge effects that require rotation are translated to the center about which
   // the layer should be rotated to align with the corresponding edge.
   switch (edge) {
     case EdgeEffect::EDGE_TOP:
       return gfx::Transform(1, 0, 0, 1, 0, offset);
     case EdgeEffect::EDGE_LEFT:
       return gfx::Transform(0, 1, -1, 0,
                             (-window_size.height() + height) / 2.f + offset,
                             (window_size.height() - height) / 2.f);
     case EdgeEffect::EDGE_BOTTOM:
       return gfx::Transform(-1, 0, 0, -1,
                             0, window_size.height() - height + offset);
     case EdgeEffect::EDGE_RIGHT:
       return gfx::Transform(0, -1, 1, 0,
           (-window_size.height() - height) / 2.f + window_size.width() + offset,
           (window_size.height() - height) / 2.f);
     default:
       NOTREACHED() << "Invalid edge: " << edge;
       return gfx::Transform();
   };
 }

 gfx::Size ComputeBounds(EdgeEffect::Edge edge,
                         const gfx::SizeF& window_size,
                         int height) {
   switch (edge) {
     case EdgeEffect::EDGE_TOP:
     case EdgeEffect::EDGE_BOTTOM:
       return gfx::Size(window_size.width(), height);
     case EdgeEffect::EDGE_LEFT:
     case EdgeEffect::EDGE_RIGHT:
       return gfx::Size(window_size.height(), height);
     default:
       NOTREACHED() << "Invalid edge: " << edge;
       return gfx::Size();
   };
 }

 void DisableLayer(cc::Layer* layer) {
   DCHECK(layer);
   layer->SetIsDrawable(false);
   layer->SetTransform(gfx::Transform());
   layer->SetOpacity(1.f);
 }

 void UpdateLayer(cc::Layer* layer,
                  EdgeEffect::Edge edge,
                  const gfx::SizeF& window_size,
                  int offset,
                  int height,
                  float opacity) {
   DCHECK(layer);
   layer->SetIsDrawable(true);
   gfx::Size bounds = ComputeBounds(edge, window_size, height);
   layer->SetTransformOrigin(
       gfx::Point3F(bounds.width() * 0.5f, bounds.height() * 0.5f, 0));
   layer->SetTransform(ComputeTransform(edge, window_size, offset, height));
   layer->SetBounds(bounds);
   layer->SetOpacity(Clamp(opacity, 0.f, 1.f));
 }

 } // namespace

 EdgeEffect::EdgeEffect(scoped_refptr<cc::Layer> edge,
                        scoped_refptr<cc::Layer> glow)
   : edge_(edge)
   , glow_(glow)
   , edge_alpha_(0)
   , edge_scale_y_(0)
   , glow_alpha_(0)
   , glow_scale_y_(0)
   , edge_alpha_start_(0)
   , edge_alpha_finish_(0)
   , edge_scale_y_start_(0)
   , edge_scale_y_finish_(0)
   , glow_alpha_start_(0)
   , glow_alpha_finish_(0)
   , glow_scale_y_start_(0)
   , glow_scale_y_finish_(0)
   , state_(STATE_IDLE)
   , pull_distance_(0) {
   // Prevent the provided layers from drawing until the effect is activated.
   DisableLayer(edge_.get());
   DisableLayer(glow_.get());
 }

 EdgeEffect::~EdgeEffect() { }

 bool EdgeEffect::IsFinished() const {
   return state_ == STATE_IDLE;
 }

 void EdgeEffect::Finish() {
   DisableLayer(edge_.get());
   DisableLayer(glow_.get());
   pull_distance_ = 0;
   state_ = STATE_IDLE;
 }

 void EdgeEffect::Pull(base::TimeTicks current_time, float delta_distance) {
   if (state_ == STATE_PULL_DECAY && current_time - start_time_ < duration_) {
     return;
   }
   if (state_ != STATE_PULL) {
     glow_scale_y_ = kPullGlowBegin;
   }
   state_ = STATE_PULL;

   start_time_ = current_time;
   duration_ = base::TimeDelta::FromMilliseconds(kPullTime);

   float abs_delta_distance = std::abs(delta_distance);
   pull_distance_ += delta_distance;
   float distance = std::abs(pull_distance_);

   edge_alpha_ = edge_alpha_start_ = Clamp(distance, kPullEdgeBegin, kMaxAlpha);
   edge_scale_y_ = edge_scale_y_start_
       = Clamp(distance * kPullDistanceEdgeFactor, kHeldEdgeScaleY, 1.f);

   glow_alpha_ = glow_alpha_start_ =
       std::min(kMaxAlpha,
                glow_alpha_ + abs_delta_distance * kPullDistanceAlphaGlowFactor);

   float glow_change = abs_delta_distance;
   if (delta_distance > 0 && pull_distance_ < 0)
     glow_change = -glow_change;
   if (pull_distance_ == 0)
     glow_scale_y_ = 0;

   // Do not allow glow to get larger than kMaxGlowHeight.
   glow_scale_y_ = glow_scale_y_start_ =
       Clamp(glow_scale_y_ + glow_change * kPullDistanceGlowFactor,
             0.f, kMaxGlowHeight);

   edge_alpha_finish_ = edge_alpha_;
   edge_scale_y_finish_ = edge_scale_y_;
   glow_alpha_finish_ = glow_alpha_;
   glow_scale_y_finish_ = glow_scale_y_;
 }

 void EdgeEffect::Release(base::TimeTicks current_time) {
   pull_distance_ = 0;

   if (state_ != STATE_PULL && state_ != STATE_PULL_DECAY)
     return;

   state_ = STATE_RECEDE;
   edge_alpha_start_ = edge_alpha_;
   edge_scale_y_start_ = edge_scale_y_;
   glow_alpha_start_ = glow_alpha_;
   glow_scale_y_start_ = glow_scale_y_;

   edge_alpha_finish_ = 0.f;
   edge_scale_y_finish_ = 0.f;
   glow_alpha_finish_ = 0.f;
   glow_scale_y_finish_ = 0.f;

   start_time_ = current_time;
   duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime);
 }

 void EdgeEffect::Absorb(base::TimeTicks current_time, float velocity) {
   state_ = STATE_ABSORB;
   velocity = Clamp(std::abs(velocity), kMinVelocity, kMaxVelocity);

   start_time_ = current_time;
   // This should never be less than 1 millisecond.
   duration_ = base::TimeDelta::FromMilliseconds(0.15f + (velocity * 0.02f));

   // The edge should always be at least partially visible, regardless
   // of velocity.
   edge_alpha_start_ = 0.f;
   edge_scale_y_ = edge_scale_y_start_ = 0.f;
   // The glow depends more on the velocity, and therefore starts out
   // nearly invisible.
   glow_alpha_start_ = 0.3f;
   glow_scale_y_start_ = 0.f;

   // Factor the velocity by 8. Testing on device shows this works best to
   // reflect the strength of the user's scrolling.
   edge_alpha_finish_ = Clamp(velocity * kVelocityEdgeFactor, 0.f, 1.f);
   // Edge should never get larger than the size of its asset.
   edge_scale_y_finish_ = Clamp(velocity * kVelocityEdgeFactor,
                                kHeldEdgeScaleY, 1.f);

   // Growth for the size of the glow should be quadratic to properly
   // respond
   // to a user's scrolling speed. The faster the scrolling speed, the more
   // intense the effect should be for both the size and the saturation.
   glow_scale_y_finish_ = std::min(
       0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);
   // Alpha should change for the glow as well as size.
   glow_alpha_finish_ = Clamp(glow_alpha_start_,
                              velocity * kVelocityGlowFactor * .00001f,
                              kMaxAlpha);
 }

 bool EdgeEffect::Update(base::TimeTicks current_time) {
   if (IsFinished())
     return false;

   const double dt = (current_time - start_time_).InMilliseconds();
   const double t = std::min(dt / duration_.InMilliseconds(), 1.);
   const float interp = static_cast<float>(Damp(t, 1.));

   edge_alpha_ = Lerp(edge_alpha_start_, edge_alpha_finish_, interp);
   edge_scale_y_ = Lerp(edge_scale_y_start_, edge_scale_y_finish_, interp);
   glow_alpha_ = Lerp(glow_alpha_start_, glow_alpha_finish_, interp);
   glow_scale_y_ = Lerp(glow_scale_y_start_, glow_scale_y_finish_, interp);

   if (t >= 1.f - kEpsilon) {
     switch (state_) {
       case STATE_ABSORB:
         state_ = STATE_RECEDE;
         start_time_ = current_time;
         duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime);

         edge_alpha_start_ = edge_alpha_;
         edge_scale_y_start_ = edge_scale_y_;
         glow_alpha_start_ = glow_alpha_;
         glow_scale_y_start_ = glow_scale_y_;

         // After absorb, the glow and edge should fade to nothing.
         edge_alpha_finish_ = 0.f;
         edge_scale_y_finish_ = 0.f;
         glow_alpha_finish_ = 0.f;
         glow_scale_y_finish_ = 0.f;
         break;
       case STATE_PULL:
         state_ = STATE_PULL_DECAY;
         start_time_ = current_time;
         duration_ = base::TimeDelta::FromMilliseconds(kPullDecayTime);

         edge_alpha_start_ = edge_alpha_;
         edge_scale_y_start_ = edge_scale_y_;
         glow_alpha_start_ = glow_alpha_;
         glow_scale_y_start_ = glow_scale_y_;

         // After pull, the glow and edge should fade to nothing.
         edge_alpha_finish_ = 0.f;
         edge_scale_y_finish_ = 0.f;
         glow_alpha_finish_ = 0.f;
         glow_scale_y_finish_ = 0.f;
         break;
       case STATE_PULL_DECAY: {
         // When receding, we want edge to decrease more slowly
         // than the glow.
         const float factor = glow_scale_y_finish_ != 0 ?
             1 / (glow_scale_y_finish_ * glow_scale_y_finish_) :
             std::numeric_limits<float>::max();
         edge_scale_y_ = edge_scale_y_start_ +
             (edge_scale_y_finish_ - edge_scale_y_start_) * interp * factor;
         state_ = STATE_RECEDE;
       } break;
       case STATE_RECEDE:
         Finish();
         break;
       default:
         break;
     }
   }

   if (state_ == STATE_RECEDE && glow_scale_y_ <= 0 && edge_scale_y_ <= 0)
     Finish();

   return !IsFinished();
 }

 void EdgeEffect::ApplyToLayers(gfx::SizeF window_size,
                                Edge edge,
                                float edge_height,
                                float glow_height,
                                float offset) {
   if (IsFinished())
     return;

   // An empty window size, while meaningless, is also relatively harmless, and
   // will simply prevent any drawing of the layers.
   if (window_size.IsEmpty()) {
     DisableLayer(edge_.get());
     DisableLayer(glow_.get());
     return;
   }

   // Glow
   const int scaled_glow_height = static_cast<int>(
       std::min(glow_height * glow_scale_y_ * kGlowHeightToWidthRatio * 0.6f,
                glow_height * kMaxGlowHeight) + 0.5f);
   UpdateLayer(
       glow_.get(), edge, window_size, offset, scaled_glow_height, glow_alpha_);

   // Edge
  const int scaled_edge_height = static_cast<int>(edge_height * edge_scale_y_);
   UpdateLayer(
       edge_.get(), edge, window_size, offset, scaled_edge_height, edge_alpha_);
 }

 } // namespace content
	// Copyright (c) 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 "content/browser/android/edge_effect.h"

	#include "cc/layers/layer.h"

	namespace content {

	namespace {

	enum State {
	STATE_IDLE = 0,
	STATE_PULL,
	STATE_ABSORB,
	STATE_RECEDE,
	STATE_PULL_DECAY
	};

	// Time it will take the effect to fully recede in ms
	const int kRecedeTime = 1000;

	// Time it will take before a pulled glow begins receding in ms
	const int kPullTime = 167;

	// Time it will take in ms for a pulled glow to decay before release
	const int kPullDecayTime = 1000;

	const float kMaxAlpha = 1.f;
	const float kHeldEdgeScaleY = .5f;

	const float kMaxGlowHeight = 4.f;

	const float kPullGlowBegin = 1.f;
	const float kPullEdgeBegin = 0.6f;

	// Min/max velocity that will be absorbed
	const float kMinVelocity = 100.f;
	const float kMaxVelocity = 10000.f;

	const float kEpsilon = 0.001f;

	const float kGlowHeightToWidthRatio = 0.25f;

	// How much dragging should effect the height of the edge image.
	// Number determined by user testing.
	const int kPullDistanceEdgeFactor = 7;

	// How much dragging should effect the height of the glow image.
	// Number determined by user testing.
	const int kPullDistanceGlowFactor = 7;
	const float kPullDistanceAlphaGlowFactor = 1.1f;

	const int kVelocityEdgeFactor = 8;
	const int kVelocityGlowFactor = 12;

	template <typename T>
	T Lerp(T a, T b, T t) {
	return a + (b - a) * t;
	}

	template <typename T>
	T Clamp(T value, T low, T high) {
	return value < low ? low : (value > high ? high : value);
	}

	template <typename T>
	T Damp(T input, T factor) {
	T result;
	if (factor == 1) {
	result = 1 - (1 - input) * (1 - input);
	} else {
	result = 1 - std::pow(1 - input, 2 * factor);
	}
	return result;
	}

	gfx::Transform ComputeTransform(EdgeEffect::Edge edge,
	const gfx::SizeF& window_size,
	int offset,
	int height) {
	// Edge effects that require rotation are translated to the center about which
	// the layer should be rotated to align with the corresponding edge.
	switch (edge) {
	case EdgeEffect::EDGE_TOP:
	return gfx::Transform(1, 0, 0, 1, 0, offset);
	case EdgeEffect::EDGE_LEFT:
	return gfx::Transform(0, 1, -1, 0,
	(-window_size.height() + height) / 2.f + offset,
	(window_size.height() - height) / 2.f);
	case EdgeEffect::EDGE_BOTTOM:
	return gfx::Transform(-1, 0, 0, -1,
	0, window_size.height() - height + offset);
	case EdgeEffect::EDGE_RIGHT:
	return gfx::Transform(0, -1, 1, 0,
	(-window_size.height() - height) / 2.f + window_size.width() + offset,
	(window_size.height() - height) / 2.f);
	default:
	NOTREACHED() << "Invalid edge: " << edge;
	return gfx::Transform();
	};
	}

	gfx::Size ComputeBounds(EdgeEffect::Edge edge,
	const gfx::SizeF& window_size,
	int height) {
	switch (edge) {
	case EdgeEffect::EDGE_TOP:
	case EdgeEffect::EDGE_BOTTOM:
	return gfx::Size(window_size.width(), height);
	case EdgeEffect::EDGE_LEFT:
	case EdgeEffect::EDGE_RIGHT:
	return gfx::Size(window_size.height(), height);
	default:
	NOTREACHED() << "Invalid edge: " << edge;
	return gfx::Size();
	};
	}

	void DisableLayer(cc::Layer* layer) {
	DCHECK(layer);
	layer->SetIsDrawable(false);
	layer->SetTransform(gfx::Transform());
	layer->SetOpacity(1.f);
	}

	void UpdateLayer(cc::Layer* layer,
	EdgeEffect::Edge edge,
	const gfx::SizeF& window_size,
	int offset,
	int height,
	float opacity) {
	DCHECK(layer);
	layer->SetIsDrawable(true);
	gfx::Size bounds = ComputeBounds(edge, window_size, height);
	layer->SetTransformOrigin(
	gfx::Point3F(bounds.width() * 0.5f, bounds.height() * 0.5f, 0));
	layer->SetTransform(ComputeTransform(edge, window_size, offset, height));
	layer->SetBounds(bounds);
	layer->SetOpacity(Clamp(opacity, 0.f, 1.f));
	}

	} // namespace

	EdgeEffect::EdgeEffect(scoped_refptr<cc::Layer> edge,
	scoped_refptr<cc::Layer> glow)
	: edge_(edge)
	, glow_(glow)
	, edge_alpha_(0)
	, edge_scale_y_(0)
	, glow_alpha_(0)
	, glow_scale_y_(0)
	, edge_alpha_start_(0)
	, edge_alpha_finish_(0)
	, edge_scale_y_start_(0)
	, edge_scale_y_finish_(0)
	, glow_alpha_start_(0)
	, glow_alpha_finish_(0)
	, glow_scale_y_start_(0)
	, glow_scale_y_finish_(0)
	, state_(STATE_IDLE)
	, pull_distance_(0) {
	// Prevent the provided layers from drawing until the effect is activated.
	DisableLayer(edge_.get());
	DisableLayer(glow_.get());
	}

	EdgeEffect::~EdgeEffect() { }

	bool EdgeEffect::IsFinished() const {
	return state_ == STATE_IDLE;
	}

	void EdgeEffect::Finish() {
	DisableLayer(edge_.get());
	DisableLayer(glow_.get());
	pull_distance_ = 0;
	state_ = STATE_IDLE;
	}

	void EdgeEffect::Pull(base::TimeTicks current_time, float delta_distance) {
	if (state_ == STATE_PULL_DECAY && current_time - start_time_ < duration_) {
	return;
	}
	if (state_ != STATE_PULL) {
	glow_scale_y_ = kPullGlowBegin;
	}
	state_ = STATE_PULL;

	start_time_ = current_time;
	duration_ = base::TimeDelta::FromMilliseconds(kPullTime);

	float abs_delta_distance = std::abs(delta_distance);
	pull_distance_ += delta_distance;
	float distance = std::abs(pull_distance_);

	edge_alpha_ = edge_alpha_start_ = Clamp(distance, kPullEdgeBegin, kMaxAlpha);
	edge_scale_y_ = edge_scale_y_start_
	= Clamp(distance * kPullDistanceEdgeFactor, kHeldEdgeScaleY, 1.f);

	glow_alpha_ = glow_alpha_start_ =
	std::min(kMaxAlpha,
	glow_alpha_ + abs_delta_distance * kPullDistanceAlphaGlowFactor);

	float glow_change = abs_delta_distance;
	if (delta_distance > 0 && pull_distance_ < 0)
	glow_change = -glow_change;
	if (pull_distance_ == 0)
	glow_scale_y_ = 0;

	// Do not allow glow to get larger than kMaxGlowHeight.
	glow_scale_y_ = glow_scale_y_start_ =
	Clamp(glow_scale_y_ + glow_change * kPullDistanceGlowFactor,
	0.f, kMaxGlowHeight);

	edge_alpha_finish_ = edge_alpha_;
	edge_scale_y_finish_ = edge_scale_y_;
	glow_alpha_finish_ = glow_alpha_;
	glow_scale_y_finish_ = glow_scale_y_;
	}

	void EdgeEffect::Release(base::TimeTicks current_time) {
	pull_distance_ = 0;

	if (state_ != STATE_PULL && state_ != STATE_PULL_DECAY)
	return;

	state_ = STATE_RECEDE;
	edge_alpha_start_ = edge_alpha_;
	edge_scale_y_start_ = edge_scale_y_;
	glow_alpha_start_ = glow_alpha_;
	glow_scale_y_start_ = glow_scale_y_;

	edge_alpha_finish_ = 0.f;
	edge_scale_y_finish_ = 0.f;
	glow_alpha_finish_ = 0.f;
	glow_scale_y_finish_ = 0.f;

	start_time_ = current_time;
	duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime);
	}

	void EdgeEffect::Absorb(base::TimeTicks current_time, float velocity) {
	state_ = STATE_ABSORB;
	velocity = Clamp(std::abs(velocity), kMinVelocity, kMaxVelocity);

	start_time_ = current_time;
	// This should never be less than 1 millisecond.
	duration_ = base::TimeDelta::FromMilliseconds(0.15f + (velocity * 0.02f));

	// The edge should always be at least partially visible, regardless
	// of velocity.
	edge_alpha_start_ = 0.f;
	edge_scale_y_ = edge_scale_y_start_ = 0.f;
	// The glow depends more on the velocity, and therefore starts out
	// nearly invisible.
	glow_alpha_start_ = 0.3f;
	glow_scale_y_start_ = 0.f;

	// Factor the velocity by 8. Testing on device shows this works best to
	// reflect the strength of the user's scrolling.
	edge_alpha_finish_ = Clamp(velocity * kVelocityEdgeFactor, 0.f, 1.f);
	// Edge should never get larger than the size of its asset.
	edge_scale_y_finish_ = Clamp(velocity * kVelocityEdgeFactor,
	kHeldEdgeScaleY, 1.f);

	// Growth for the size of the glow should be quadratic to properly
	// respond
	// to a user's scrolling speed. The faster the scrolling speed, the more
	// intense the effect should be for both the size and the saturation.
	glow_scale_y_finish_ = std::min(
	0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);
	// Alpha should change for the glow as well as size.
	glow_alpha_finish_ = Clamp(glow_alpha_start_,
	velocity * kVelocityGlowFactor * .00001f,
	kMaxAlpha);
	}

	bool EdgeEffect::Update(base::TimeTicks current_time) {
	if (IsFinished())
	return false;

	const double dt = (current_time - start_time_).InMilliseconds();
	const double t = std::min(dt / duration_.InMilliseconds(), 1.);
	const float interp = static_cast<float>(Damp(t, 1.));

	edge_alpha_ = Lerp(edge_alpha_start_, edge_alpha_finish_, interp);
	edge_scale_y_ = Lerp(edge_scale_y_start_, edge_scale_y_finish_, interp);
	glow_alpha_ = Lerp(glow_alpha_start_, glow_alpha_finish_, interp);
	glow_scale_y_ = Lerp(glow_scale_y_start_, glow_scale_y_finish_, interp);

	if (t >= 1.f - kEpsilon) {
	switch (state_) {
	case STATE_ABSORB:
	state_ = STATE_RECEDE;
	start_time_ = current_time;
	duration_ = base::TimeDelta::FromMilliseconds(kRecedeTime);

	edge_alpha_start_ = edge_alpha_;
	edge_scale_y_start_ = edge_scale_y_;
	glow_alpha_start_ = glow_alpha_;
	glow_scale_y_start_ = glow_scale_y_;

	// After absorb, the glow and edge should fade to nothing.
	edge_alpha_finish_ = 0.f;
	edge_scale_y_finish_ = 0.f;
	glow_alpha_finish_ = 0.f;
	glow_scale_y_finish_ = 0.f;
	break;
	case STATE_PULL:
	state_ = STATE_PULL_DECAY;
	start_time_ = current_time;
	duration_ = base::TimeDelta::FromMilliseconds(kPullDecayTime);

	edge_alpha_start_ = edge_alpha_;
	edge_scale_y_start_ = edge_scale_y_;
	glow_alpha_start_ = glow_alpha_;
	glow_scale_y_start_ = glow_scale_y_;

	// After pull, the glow and edge should fade to nothing.
	edge_alpha_finish_ = 0.f;
	edge_scale_y_finish_ = 0.f;
	glow_alpha_finish_ = 0.f;
	glow_scale_y_finish_ = 0.f;
	break;
	case STATE_PULL_DECAY: {
	// When receding, we want edge to decrease more slowly
	// than the glow.
	const float factor = glow_scale_y_finish_ != 0 ?
	1 / (glow_scale_y_finish_ * glow_scale_y_finish_) :
	std::numeric_limits<float>::max();
	edge_scale_y_ = edge_scale_y_start_ +
	(edge_scale_y_finish_ - edge_scale_y_start_) * interp * factor;
	state_ = STATE_RECEDE;
	} break;
	case STATE_RECEDE:
	Finish();
	break;
	default:
	break;
	}
	}

	if (state_ == STATE_RECEDE && glow_scale_y_ <= 0 && edge_scale_y_ <= 0)
	Finish();

	return !IsFinished();
	}

	void EdgeEffect::ApplyToLayers(gfx::SizeF window_size,
	Edge edge,
	float edge_height,
	float glow_height,
	float offset) {
	if (IsFinished())
	return;

	// An empty window size, while meaningless, is also relatively harmless, and
	// will simply prevent any drawing of the layers.
	if (window_size.IsEmpty()) {
	DisableLayer(edge_.get());
	DisableLayer(glow_.get());
	return;
	}

	// Glow
	const int scaled_glow_height = static_cast<int>(
	std::min(glow_height * glow_scale_y_ * kGlowHeightToWidthRatio * 0.6f,
	glow_height * kMaxGlowHeight) + 0.5f);
	UpdateLayer(
	glow_.get(), edge, window_size, offset, scaled_glow_height, glow_alpha_);

	// Edge
	const int scaled_edge_height = static_cast<int>(edge_height * edge_scale_y_);
	UpdateLayer(
	edge_.get(), edge, window_size, offset, scaled_edge_height, edge_alpha_);
	}

	} // namespace content