Fix overscroll glow when the FIP dialog is active

content/browser/android/overscroll_glow.cc

 // 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/overscroll_glow.h"
 
 #include "base/lazy_instance.h"
 #include "cc/layers/image_layer.h"
 #include "content/browser/android/edge_effect.h"
 #include "skia/ext/image_operations.h"
@@ skipping 57 matching lines @@
 gfx::Vector2dF ZeroSmallComponents(gfx::Vector2dF vector) {
   if (IsApproxZero(vector.x()))
     vector.set_x(0);
   if (IsApproxZero(vector.y()))
     vector.set_y(0);
   return vector;
 }
 
 } // namespace
 
-scoped_ptr<OverscrollGlow> OverscrollGlow::Create() {
+scoped_ptr<OverscrollGlow> OverscrollGlow::Create(bool enabled) {
   const SkBitmap& edge = g_overscroll_resources.Get().edge_bitmap();
   const SkBitmap& glow = g_overscroll_resources.Get().glow_bitmap();
   if (edge.isNull() || glow.isNull())
     return scoped_ptr<OverscrollGlow>();
 
-  return make_scoped_ptr(new OverscrollGlow(edge, glow));
+  return make_scoped_ptr(new OverscrollGlow(enabled, edge, glow));
 }
 
 void OverscrollGlow::EnsureResources() {
   g_overscroll_resources.Get();
 }
 
-OverscrollGlow::OverscrollGlow(const SkBitmap& edge, const SkBitmap& glow)
-  : horizontal_overscroll_enabled_(true),
+OverscrollGlow::OverscrollGlow(bool enabled,
+                               const SkBitmap& edge,
+                               const SkBitmap& glow)
+  : enabled_(enabled),
+    horizontal_overscroll_enabled_(true),
     vertical_overscroll_enabled_(true),
     root_layer_(cc::Layer::Create()) {
   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
     scoped_refptr<cc::Layer> edge_layer = CreateImageLayer(edge);
     scoped_refptr<cc::Layer> glow_layer = CreateImageLayer(glow);
     root_layer_->AddChild(edge_layer);
     root_layer_->AddChild(glow_layer);
     edge_effects_[i] = make_scoped_ptr(new EdgeEffect(edge_layer, glow_layer));
   }
 }
 
 OverscrollGlow::~OverscrollGlow() {
   root_layer_->RemoveFromParent();
 }
 
 void OverscrollGlow::OnOverscrolled(base::TimeTicks current_time,
                                     gfx::Vector2dF overscroll,
                                     gfx::Vector2dF velocity) {
+  if (!enabled_)
+    return;
+
   // The size of the glow determines the relative effect of the inputs; an
   // empty-sized effect is effectively disabled.
   if (size_.IsEmpty())
     return;
 
   if (!horizontal_overscroll_enabled_) {
     overscroll.set_x(0);
     velocity.set_x(0);
   }
   if (!vertical_overscroll_enabled_) {
@@ skipping 28 matching lines @@
       Release(AXIS_Y, current_time);
 
     Pull(current_time, overscroll - old_overscroll_);
   }
 
   old_velocity_ = velocity;
   old_overscroll_ = overscroll;
 }
 
 bool OverscrollGlow::Animate(base::TimeTicks current_time) {
-  if (!IsActive())
+  if (!NeedsAnimate())
     return false;
 
   const gfx::SizeF sizes[EdgeEffect::EDGE_COUNT] = {
     size_, gfx::SizeF(size_.height(), size_.width()),
     size_, gfx::SizeF(size_.height(), size_.width())
   };
 
   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
     if (edge_effects_[i]->Update(current_time)) {
       edge_effects_[i]->ApplyToLayers(sizes[i],
                                       static_cast<EdgeEffect::Edge>(i));
     }
   }
 
-  return IsActive();
+  return NeedsAnimate();
 }
 
-bool OverscrollGlow::IsActive() const {
+void OverscrollGlow::SetEnabled(bool enabled) {
+  if (enabled_ == enabled)
+    return;
+  enabled_ = enabled;
+  if (!enabled_) {
+    for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
+      edge_effects_[i]->Finish();
+  }
+}
+
+bool OverscrollGlow::NeedsAnimate() const {
+  if (!enabled_)
+    return false;
   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
     if (!edge_effects_[i]->IsFinished())
       return true;
   }
   return false;
 }
 
-void OverscrollGlow::Finish() {
-  for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
-    edge_effects_[i]->Finish();
-}
-
 void OverscrollGlow::Pull(base::TimeTicks current_time,
                           gfx::Vector2dF overscroll_delta) {
   overscroll_delta = ZeroSmallComponents(overscroll_delta);
   if (overscroll_delta.IsZero())
     return;
 
   gfx::Vector2dF overscroll_pull = gfx::ScaleVector2d(overscroll_delta,
                                                       1.f / size_.width(),
                                                       1.f / size_.height());
   float edge_overscroll_pull[EdgeEffect::EDGE_COUNT] = {
@@ skipping 59 matching lines @@
       break;
   };
 }
 
 EdgeEffect* OverscrollGlow::GetOppositeEdge(int edge_index) {
   return edge_effects_[(edge_index + 2) % EdgeEffect::EDGE_COUNT].get();
 }
 
 }  // namespace content