Refactor GestureNavigation to eliminate code redundancy

content/browser/web_contents/aura/overscroll_window_animation.cc

+// Copyright (c) 2015 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/web_contents/aura/overscroll_window_animation.h"
+
+#include "base/i18n/rtl.h"
+#include "content/browser/web_contents/aura/overscroll_layer_wrapper.h"
+#include "content/browser/web_contents/aura/shadow_layer_delegate.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "ui/aura/window.h"
+#include "ui/compositor/layer_animation_observer.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
+
+namespace content {
+
+namespace {
+
+OverscrollWindowAnimation::Direction GetDirectionForMode(OverscrollMode mode) {
+  LOG(ERROR) << "Getting navigation direction";
+  if (mode == (base::i18n::IsRTL() ? OVERSCROLL_EAST : OVERSCROLL_WEST))
+    return OverscrollWindowAnimation::SLIDE_FRONT;
+  if (mode == (base::i18n::IsRTL() ? OVERSCROLL_WEST : OVERSCROLL_EAST))
+    return OverscrollWindowAnimation::SLIDE_BACK;
+  return OverscrollWindowAnimation::SLIDE_NONE;
+}
+
+}  // namespace
+
+OverscrollWindowAnimation::OverscrollWindowAnimation(
+    Delegate* delegate, WebContentsImpl* web_contents)
+    : layer_wrapper_(nullptr),
+      shadow_(nullptr),
+      overlay_window_(nullptr),
+      web_contents_(web_contents),
+      delegate_(delegate),
+      direction_(SLIDE_NONE) {
+  DCHECK(delegate_);
+}
+
+OverscrollWindowAnimation::~OverscrollWindowAnimation() {
+  LOG(ERROR) << "OWA destructor";
+}
+
+void OverscrollWindowAnimation::CancelOverscroll() {
+  LOG(ERROR) << "OWA: Cancelling overscroll";
+  ui::Layer* layer = GetFrontLayer();
+  ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  settings.SetTweenType(gfx::Tween::EASE_OUT);
+  settings.AddObserver(this);
+  layer->SetTransform(gfx::Transform());
+  direction_ = SLIDE_NONE;
+}
+
+float OverscrollWindowAnimation::GetTranslationForOverscroll(
+    float delta_x) {
+  DCHECK(direction_ != SLIDE_NONE);
+  const float bounds_width = layer_wrapper_->GetBounds().width();
+  if (direction_ == SLIDE_FRONT)
+    return std::max(-bounds_width, delta_x);
+  else
+    return std::min(bounds_width, delta_x);
+}
+
+gfx::Rect OverscrollWindowAnimation::GetVisibleBounds() const {
+  return GetFrontLayer()->bounds();
+}
+
+bool OverscrollWindowAnimation::OnOverscrollUpdate(float delta_x,
+                                                   float delta_y) {
+  if (direction_ == SLIDE_NONE)
+    return false;
+  gfx::Transform transform;
+  transform.Translate(GetTranslationForOverscroll(delta_x), 0);
+  GetFrontLayer()->SetTransform(transform);
+  return true;
+}
+
+void OverscrollWindowAnimation::OnImplicitAnimationsCompleted() {
+  LOG(ERROR) << "OnImplicitAnimationsCompleted";
+  LOG(ERROR) << "LAYER_WRAPPER_: " << layer_wrapper_;
+  if (direction_ != SLIDE_NONE) {
+    direction_ = SLIDE_NONE;
+    delegate_->OnOverscrollCompleted(layer_wrapper_.Pass());
+    return;
+  }
+  delegate_->OnOverscrollAborted();
+  layer_wrapper_.reset();
+}
+
+void OverscrollWindowAnimation::OnOverscrollModeChange(
+    OverscrollMode old_mode,
+    OverscrollMode new_mode) {
+  LOG(ERROR) << "OWA: OnOverscrollModeChange for mode " << new_mode;
+  Direction new_direction = GetDirectionForMode(new_mode);
+
+  if (new_direction == SLIDE_NONE) {
+    // The user cancelled the in progress overscroll gesture.
+    // TODO(nsatragno): in this case, show a feedback animation.
+    LOG(ERROR) << "Direction: SLIDE_NONE";
+    if (is_active())
+      CancelOverscroll();
+    return;
+  }
+  LOG(ERROR) << "Preparing layer wrapper";
+  if (layer_wrapper_) {
+    LOG(ERROR) << "ALERT: MODE CHANGE WITH LAYER WRAPPER ACTIVE! "
+               << "Aborting animations.";
+    GetFrontLayer()->GetAnimator()->AbortAllAnimations();
+  }
+  layer_wrapper_ =
+      new_direction == SLIDE_FRONT ? delegate_->CreateFrontLayerWrapper()
+                                   : delegate_->CreateBackLayerWrapper();
+  if (!layer_wrapper_) {
+    LOG(ERROR) << "Cannot navigate, setting direction to SLIDE_NONE";
+    direction_ = SLIDE_NONE;
+    return;
+  }
+  gfx::Rect bounds = gfx::Rect(GetVisibleBounds().size());
+  if (new_direction == OverscrollWindowAnimation::SLIDE_FRONT)
+    bounds.Offset(base::i18n::IsRTL() ? -bounds.width() : bounds.width(), 0);
+  // TODO maybe we want to set the window bounds here, too.
+  layer_wrapper_->layer()->SetBounds(bounds);
+  LOG(ERROR) << "Setting shadow delegate.";
+  direction_ = new_direction;
+  shadow_.reset(new ShadowLayerDelegate(GetFrontLayer()));
+}
+
+void OverscrollWindowAnimation::OnOverscrollComplete(
+    OverscrollMode overscroll_mode) {
+  LOG(ERROR) << "OWA: OnOverscrollComplete";
+  if (!is_active())
+    return;
+  delegate_->OnOverscrollCompleting();
+  int content_width = layer_wrapper_->GetBounds().width();
+  float translate_x;
+  if ((base::i18n::IsRTL() && direction_ == SLIDE_FRONT) ||
+      (!base::i18n::IsRTL() && direction_ == SLIDE_BACK)) {
+    translate_x = content_width;
+  } else {
+    translate_x = -content_width;
+  }
+
+  ui::Layer* layer = GetFrontLayer();
+  gfx::Transform transform;
+  transform.Translate(translate_x, 0);
+  ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  settings.SetTweenType(gfx::Tween::EASE_OUT);
+  settings.AddObserver(this);
+  layer->SetTransform(transform);
+}
+
+ui::Layer* OverscrollWindowAnimation::GetFrontLayer() const {
+  if (direction_ == SLIDE_FRONT) {
+    DCHECK(layer_wrapper_);
+    return layer_wrapper_->layer();
+  }
+  if (web_contents_)

[mfomitchev, 2015/03/10 19:26:00]

OWA shouldn't know about web_contents

[Nina, 2015/03/12 22:21:29]

Modified so it doesn't have to.

+    return web_contents_->GetContentNativeView()->layer();
+  DCHECK(overlay_window_);
+  return overlay_window_->layer();
+}
+
+}  // namespace content