Revert of Refactor GestureNavigation to eliminate code redundancy

content/browser/web_contents/aura/overscroll_navigation_overlay.cc

 // Copyright 2014 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_navigation_overlay.h"
 
-#include <vector>
-
-#include "base/i18n/rtl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
-#include "content/browser/web_contents/aura/overscroll_window_delegate.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "ui/aura/window.h"
+#include "ui/aura_extra/image_window_delegate.h"
 #include "ui/base/layout.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_png_rep.h"
+#include "ui/gfx/image/image_skia.h"
 
 namespace content {
 namespace {
 
 // Returns true if the entry's URL or any of the URLs in entry's redirect chain
 // match |url|.
 bool DoesEntryMatchURL(NavigationEntry* entry, const GURL& url) {
   if (!entry)
     return false;
   if (entry->GetURL() == url)
     return true;
   const std::vector<GURL>& redirect_chain = entry->GetRedirectChain();
   for (std::vector<GURL>::const_iterator it = redirect_chain.begin();
        it != redirect_chain.end();
        it++) {
     if (*it == url)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
-// A class that sets masks to bounds to false on a layer and restores the old
-// value on destruction.
-class OverscrollNavigationOverlay::ScopedLayerClippingSetting {
+// A LayerDelegate that paints an image for the layer.
+class ImageLayerDelegate : public ui::LayerDelegate {
  public:
-  explicit ScopedLayerClippingSetting(ui::Layer* layer)
-      : masks_to_bounds_(layer->GetMasksToBounds()), layer_(layer) {
-    layer_->SetMasksToBounds(false);
+  ImageLayerDelegate() {}
+
+  ~ImageLayerDelegate() override {}
+
+  void SetImage(const gfx::Image& image) {
+    image_ = image;
+    image_size_ = image.AsImageSkia().size();
+  }
+  const gfx::Image& image() const { return image_; }
+
+ private:
+  // Overridden from ui::LayerDelegate:
+  void OnPaintLayer(const ui::PaintContext& context) override {
+    ui::PaintRecorder recorder(context);
+    if (image_.IsEmpty()) {
+      recorder.canvas()->DrawColor(SK_ColorWHITE);
+    } else {
+      SkISize size = recorder.canvas()->sk_canvas()->getDeviceSize();
+      if (size.width() != image_size_.width() ||
+          size.height() != image_size_.height()) {
+        recorder.canvas()->DrawColor(SK_ColorWHITE);
+      }
+      recorder.canvas()->DrawImageInt(image_.AsImageSkia(), 0, 0);
+    }
   }
 
-  ~ScopedLayerClippingSetting() { layer_->SetMasksToBounds(masks_to_bounds_); }
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
- private:
-  bool masks_to_bounds_;
-  ui::Layer* layer_;
+  // Called when the layer's device scale factor has changed.
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+
+  // Invoked prior to the bounds changing. The returned closured is run after
+  // the bounds change.
+  base::Closure PrepareForLayerBoundsChange() override {
+    return base::Closure();
+  }
+
+  gfx::Image image_;
+  gfx::Size image_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageLayerDelegate);
 };
 
 // Responsible for fading out and deleting the layer of the overlay window.
 class OverlayDismissAnimator
     : public ui::LayerAnimationObserver {
  public:
   // Takes ownership of the layer.
   explicit OverlayDismissAnimator(scoped_ptr<ui::Layer> layer)
       : layer_(layer.Pass()) {
     CHECK(layer_.get());
@@ skipping 25 matching lines @@
 
  private:
   ~OverlayDismissAnimator() override {}
 
   scoped_ptr<ui::Layer> layer_;
 
   DISALLOW_COPY_AND_ASSIGN(OverlayDismissAnimator);
 };
 
 OverscrollNavigationOverlay::OverscrollNavigationOverlay(
-    WebContentsImpl* web_contents,
-    aura::Window* web_contents_window)
-    : direction_(NONE),
-      web_contents_(web_contents),
+    WebContentsImpl* web_contents)
+    : web_contents_(web_contents),
+      image_delegate_(NULL),
       loading_complete_(false),
       received_paint_update_(false),
-      owa_(new OverscrollWindowAnimation(this)),
-      web_contents_window_(web_contents_window) {
+      slide_direction_(SLIDE_UNKNOWN) {
 }
 
 OverscrollNavigationOverlay::~OverscrollNavigationOverlay() {
-  if (owa_->is_active())
-    GetMainWindow()->ReleaseCapture();
 }
 
 void OverscrollNavigationOverlay::StartObserving() {
   loading_complete_ = false;
   received_paint_update_ = false;
+  overlay_dismiss_layer_.reset();
   Observe(web_contents_);
 
+  // Make sure the overlay window is on top.
+  if (window_.get() && window_->parent())
+    window_->parent()->StackChildAtTop(window_.get());
+
   // Assumes the navigation has been initiated.
   NavigationEntry* pending_entry =
       web_contents_->GetController().GetPendingEntry();
   // Save url of the pending entry to identify when it loads and paints later.
   // Under some circumstances navigation can leave a null pending entry -
   // see comments in NavigationControllerImpl::NavigateToPendingEntry().
   pending_entry_url_ = pending_entry ? pending_entry->GetURL() : GURL();
 }
 
+void OverscrollNavigationOverlay::SetOverlayWindow(
+    scoped_ptr<aura::Window> window,
+    aura_extra::ImageWindowDelegate* delegate) {
+  window_ = window.Pass();
+  if (window_.get() && window_->parent())
+    window_->parent()->StackChildAtTop(window_.get());
+  image_delegate_ = delegate;
+
+  if (window_.get() && delegate->has_image()) {
+    window_slider_.reset(new WindowSlider(this,
+                                          window_->parent(),
+                                          window_.get()));
+    slide_direction_ = SLIDE_UNKNOWN;
+  } else {
+    window_slider_.reset();
+  }
+}
+
 void OverscrollNavigationOverlay::StopObservingIfDone() {
   // Normally we dismiss the overlay once we receive a paint update, however
   // for in-page navigations DidFirstVisuallyNonEmptyPaint() does not get
   // called, and we rely on loading_complete_ for those cases.
-  // If an overscroll gesture is in progress, then do not destroy the window.
-  if (!window_ || !(loading_complete_ || received_paint_update_) ||
-      owa_->is_active()) {
+  if (!received_paint_update_ && !loading_complete_)
     return;
+
+  // If a slide is in progress, then do not destroy the window or the slide.
+  if (window_slider_.get() && window_slider_->IsSlideInProgress())
+    return;
+
+  // The layer to be animated by OverlayDismissAnimator
+  scoped_ptr<ui::Layer> overlay_dismiss_layer;
+  if (overlay_dismiss_layer_)
+    overlay_dismiss_layer = overlay_dismiss_layer_.Pass();
+  else if (window_.get())
+    overlay_dismiss_layer = window_->AcquireLayer();
+  Observe(NULL);
+  window_slider_.reset();
+  window_.reset();
+  image_delegate_ = NULL;
+  if (overlay_dismiss_layer.get()) {
+    // OverlayDismissAnimator deletes overlay_dismiss_layer and itself when the
+    // animation completes.
+    (new OverlayDismissAnimator(overlay_dismiss_layer.Pass()))->Animate();
   }
-  // Restore layer clipping.
-  contents_layer_settings_.reset();
-  contents_layer_parent_settings_.reset();
-
-  // OverlayDismissAnimator deletes the dismiss layer and itself when the
-  // animation completes.
-  scoped_ptr<ui::Layer> dismiss_layer = window_->AcquireLayer();
-  window_.reset();
-  (new OverlayDismissAnimator(dismiss_layer.Pass()))->Animate();
-  Observe(nullptr);
-  received_paint_update_ = false;
-  loading_complete_ = false;
 }
 
-scoped_ptr<aura::Window> OverscrollNavigationOverlay::CreateOverlayWindow(
-    const gfx::Rect& bounds) {
-  OverscrollWindowDelegate* overscroll_delegate = new OverscrollWindowDelegate(
-      owa_.get(), GetImageForDirection(direction_));
-  scoped_ptr<aura::Window> window(new aura::Window(overscroll_delegate));
-  window->SetTransparent(true);
-  window->Init(ui::LAYER_TEXTURED);
-  window->layer()->SetMasksToBounds(false);
-  window->SetName("OverscrollOverlay");
-  web_contents_window_->AddChild(window.get());
-  aura::Window* event_window = GetMainWindow();
-  if (direction_ == FORWARD)
-    web_contents_window_->StackChildAbove(window.get(), event_window);
-  else
-    web_contents_window_->StackChildBelow(window.get(), event_window);
-  window->SetBounds(bounds);
-  // Set capture on the window that is receiving the overscroll events so that
-  // trackpad scroll gestures keep targetting it even if the mouse pointer moves
-  // off its bounds.
-  event_window->SetCapture();
-  window->Show();
-  return window.Pass();
-}
+ui::Layer* OverscrollNavigationOverlay::CreateSlideLayer(int offset) {
+  const NavigationControllerImpl& controller = web_contents_->GetController();
+  const NavigationEntryImpl* entry = controller.GetEntryAtOffset(offset);
 
-const gfx::Image OverscrollNavigationOverlay::GetImageForDirection(
-    NavigationDirection direction) const {
-  const NavigationControllerImpl& controller = web_contents_->GetController();
-  const NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
-      controller.GetEntryAtOffset(direction == FORWARD ? 1 : -1));
-
+  gfx::Image image;
   if (entry && entry->screenshot().get()) {
     std::vector<gfx::ImagePNGRep> image_reps;
     image_reps.push_back(gfx::ImagePNGRep(entry->screenshot(), 1.0f));
-    return gfx::Image(image_reps);
+    image = gfx::Image(image_reps);
   }
-  return gfx::Image();
+  if (!layer_delegate_)
+    layer_delegate_.reset(new ImageLayerDelegate());
+  layer_delegate_->SetImage(image);
+
+  ui::Layer* layer = new ui::Layer(ui::LAYER_TEXTURED);
+  layer->set_delegate(layer_delegate_.get());
+  return layer;
 }
 
-scoped_ptr<aura::Window> OverscrollNavigationOverlay::CreateFrontWindow(
-    const gfx::Rect& bounds) {
-  if (!web_contents_->GetController().CanGoForward())
-    return nullptr;
-  direction_ = FORWARD;
-  return CreateOverlayWindow(bounds);
+ui::Layer* OverscrollNavigationOverlay::CreateBackLayer() {
+  if (!web_contents_->GetController().CanGoBack())
+    return NULL;
+  slide_direction_ = SLIDE_BACK;
+  return CreateSlideLayer(-1);
 }
 
-scoped_ptr<aura::Window> OverscrollNavigationOverlay::CreateBackWindow(
-    const gfx::Rect& bounds) {
-  if (!web_contents_->GetController().CanGoBack())
-    return nullptr;
-  direction_ = BACK;
-  return CreateOverlayWindow(bounds);
+ui::Layer* OverscrollNavigationOverlay::CreateFrontLayer() {
+  if (!web_contents_->GetController().CanGoForward())
+    return NULL;
+  slide_direction_ = SLIDE_FRONT;
+  return CreateSlideLayer(1);
 }
 
-aura::Window* OverscrollNavigationOverlay::GetMainWindow() const {
-  if (window_)
-    return window_.get();
-  return web_contents_->GetContentNativeView();
-}
+void OverscrollNavigationOverlay::OnWindowSlideCompleting() {
+  if (slide_direction_ == SLIDE_UNKNOWN)
+    return;
 
-void OverscrollNavigationOverlay::OnOverscrollCompleting() {
-  GetMainWindow()->ReleaseCapture();
-  // We start the navigation as soon as we know the overscroll gesture is
-  // completing.
-  DCHECK(direction_ != NONE);
+  // Perform the navigation.
+  if (slide_direction_ == SLIDE_BACK)
+    web_contents_->GetController().GoBack();
+  else if (slide_direction_ == SLIDE_FRONT)
+    web_contents_->GetController().GoForward();
+  else
+    NOTREACHED();
 
-  // Avoid clipping on the screenshot caused by the contents window being moved
-  // outside of the screen bounds.
-  contents_layer_settings_.reset(
-      new ScopedLayerClippingSetting(web_contents_->GetNativeView()->layer()));
-  contents_layer_parent_settings_.reset(new ScopedLayerClippingSetting(
-      web_contents_->GetNativeView()->layer()->parent()));
-
-  // Make sure we can navigate first, as other factors can trigger a navigation
-  // during an overscroll gesture and navigating without history produces a
-  // crash.
-  if (direction_ == FORWARD && web_contents_->GetController().CanGoForward())
-    web_contents_->GetController().GoForward();
-  if (direction_ == BACK && web_contents_->GetController().CanGoBack())
-    web_contents_->GetController().GoBack();
+  // Reset state and wait for the new navigation page to complete
+  // loading/painting.
   StartObserving();
 }
 
-void OverscrollNavigationOverlay::OnOverscrollCompleted(
-    scoped_ptr<aura::Window> window) {
-  GetMainWindow()->SetTransform(gfx::Transform());
-  window_ = window.Pass();
-  // Make sure the window is in its default position.
-  window_->SetBounds(gfx::Rect(web_contents_window_->bounds().size()));
-  window_->SetTransform(gfx::Transform());
-  // Make sure the overlay window is on top.
-  web_contents_window_->StackChildAtTop(window_.get());
-  direction_ = NONE;
+void OverscrollNavigationOverlay::OnWindowSlideCompleted(
+    scoped_ptr<ui::Layer> layer) {
+  if (slide_direction_ == SLIDE_UNKNOWN) {
+    window_slider_.reset();
+    StopObservingIfDone();
+    return;
+  }
+
+  // Change the image used for the overlay window.
+  image_delegate_->SetImage(layer_delegate_->image());
+  window_->layer()->SetTransform(gfx::Transform());
+  window_->SchedulePaintInRect(gfx::Rect(window_->bounds().size()));
+  slide_direction_ = SLIDE_UNKNOWN;
+  // We may end up dismissing the overlay before it has a chance to repaint, so
+  // set the slider layer to be the one animated by OverlayDismissAnimator.
+  if (layer.get())
+    overlay_dismiss_layer_ = layer.Pass();
   StopObservingIfDone();
 }
 
-void OverscrollNavigationOverlay::OnOverscrollCancelled() {
-  GetMainWindow()->ReleaseCapture();
-  direction_ = NONE;
+void OverscrollNavigationOverlay::OnWindowSlideAborted() {
   StopObservingIfDone();
 }
 
+void OverscrollNavigationOverlay::OnWindowSliderDestroyed() {
+  // We only want to take an action here if WindowSlider is being destroyed
+  // outside of OverscrollNavigationOverlay. If window_slider_.get() is NULL,
+  // then OverscrollNavigationOverlay is the one destroying WindowSlider, and
+  // we don't need to do anything.
+  // This check prevents StopObservingIfDone() being called multiple times
+  // (including recursively) for a single event.
+  if (window_slider_.get()) {
+    // The slider has just been destroyed. Release the ownership.
+    ignore_result(window_slider_.release());
+    StopObservingIfDone();
+  }
+}
+
 void OverscrollNavigationOverlay::DidFirstVisuallyNonEmptyPaint() {
   NavigationEntry* visible_entry =
       web_contents_->GetController().GetVisibleEntry();
   if (pending_entry_url_.is_empty() ||
       DoesEntryMatchURL(visible_entry, pending_entry_url_)) {
     received_paint_update_ = true;
     StopObservingIfDone();
   }
 }
 
 void OverscrollNavigationOverlay::DidStopLoading() {
   // Don't compare URLs in this case - it's possible they won't match if
   // a gesture-nav initiated navigation was interrupted by some other in-site
-  // navigation (e.g., from a script, or from a bookmark).
+  // navigation ((e.g., from a script, or from a bookmark).
   loading_complete_ = true;
   StopObservingIfDone();
 }
 
 }  // namespace content