overscroll: Show a shadow for the sliding window during nav gesture.

content/browser/web_contents/web_contents_view_aura.cc

 // Copyright (c) 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 "content/browser/web_contents/web_contents_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "content/browser/web_contents/interstitial_page_impl.h"
 #include "content/browser/web_contents/navigation_entry_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_view_delegate.h"
 #include "content/public/browser/web_drag_dest_delegate.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+#include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/drag_drop_delegate.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_png_rep.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/screen.h"
+#include "ui/gfx/skia_util.h"
 #include "webkit/glue/webdropdata.h"
 
 #if defined(OS_WIN)
 #include "ui/base/clipboard/clipboard_util_win.h"
 #endif
 
 namespace content {
 WebContentsView* CreateWebContentsView(
     WebContentsImpl* web_contents,
     WebContentsViewDelegate* delegate,
     RenderViewHostDelegateView** render_view_host_delegate_view) {
   WebContentsViewAura* rv = new WebContentsViewAura(web_contents, delegate);
   *render_view_host_delegate_view = rv;
   return rv;
 }
 
 namespace {
 
+const SkColor kShadowLightColor = SkColorSetARGB(0x0, 0, 0, 0);
+const SkColor kShadowDarkColor = SkColorSetARGB(0x70, 0, 0, 0);
+const int kShadowThick = 7;
+
+enum ShadowEdge {
+  SHADOW_NONE,
+  SHADOW_LEFT,
+  SHADOW_RIGHT,
+  SHADOW_TOP,
+  SHADOW_BOTTOM
+};
+
 bool ShouldNavigateForward(const NavigationController& controller,
                            OverscrollMode mode) {
   return mode == (base::i18n::IsRTL() ? OVERSCROLL_EAST : OVERSCROLL_WEST) &&
          controller.CanGoForward();
 }
 
 bool ShouldNavigateBack(const NavigationController& controller,
                         OverscrollMode mode) {
   return mode == (base::i18n::IsRTL() ? OVERSCROLL_WEST : OVERSCROLL_EAST) &&
          controller.CanGoBack();
 }
 
 // The window delegate for the overscroll window. This redirects trackpad events
 // to the web-contents window. The delegate destroys itself when the window is
 // destroyed.
 class OverscrollWindowDelegate : public aura::WindowDelegate {
  public:
   OverscrollWindowDelegate(WebContentsImpl* web_contents,
                            OverscrollMode overscroll_mode)
-      : web_contents_(web_contents) {
+      : web_contents_(web_contents),
+        show_shadow_(false) {
     const NavigationControllerImpl& controller = web_contents->GetController();
     const NavigationEntryImpl* entry = NULL;
     if (ShouldNavigateForward(controller, overscroll_mode)) {
       entry = NavigationEntryImpl::FromNavigationEntry(
           controller.GetEntryAtOffset(1));
     } else if (ShouldNavigateBack(controller, overscroll_mode)) {
       entry = NavigationEntryImpl::FromNavigationEntry(
           controller.GetEntryAtOffset(-1));
     }
     if (!entry || !entry->screenshot())
       return;
 
     std::vector<gfx::ImagePNGRep> image_reps;
     image_reps.push_back(gfx::ImagePNGRep(entry->screenshot(),
           ui::GetScaleFactorForNativeView(web_contents_window())));
     image_ = gfx::Image(image_reps);
   }
 
   bool has_screenshot() const { return !image_.IsEmpty(); }
 
+  void set_show_shadow(bool show) {
+    show_shadow_ = show;
+  }
+
  private:
   virtual ~OverscrollWindowDelegate() {}
 
   aura::Window* web_contents_window() {
     return web_contents_->GetView()->GetContentNativeView();
   }
 
   // aura::WindowDelegate implementation:
   virtual gfx::Size GetMinimumSize() const OVERRIDE {
     return gfx::Size();
@@ skipping 22 matching lines @@
   }
 
   virtual bool CanFocus() OVERRIDE {
     return false;
   }
 
   virtual void OnCaptureLost() OVERRIDE {
   }
 
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
+    if (show_shadow_) {
+      canvas->Save();
+      canvas->Translate(gfx::Vector2d(kShadowThick, 0));
+    }
     if (image_.IsEmpty())
       canvas->DrawColor(SK_ColorGRAY);
     else
       canvas->DrawImageInt(image_.AsImageSkia(), 0, 0);
+
+    if (show_shadow_) {
+      canvas->Restore();
+      SkPoint points[2];
+      points[0].iset(0, 0);
+      points[1].iset(kShadowThick, 0);
+      SkColor colors[2] = { kShadowLightColor, kShadowDarkColor };
+      skia::RefPtr<SkShader> shader = skia::AdoptRef(
+          SkGradientShader::CreateLinear(points, colors, NULL,
+              arraysize(points), SkShader::kRepeat_TileMode, NULL));
+
+      SkRect rect = { SkIntToScalar(0),
+                      SkIntToScalar(0),
+                      SkIntToScalar(kShadowThick),
+                      SkIntToScalar(web_contents_window()->bounds().height()) };
+      SkPaint paint;
+      paint.setShader(shader.get());
+      canvas->sk_canvas()->drawRect(rect, paint);
+    }
   }
 
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
   }
 
   virtual void OnWindowDestroying() OVERRIDE {
   }
 
   virtual void OnWindowDestroyed() OVERRIDE {
     delete this;
@@ skipping 19 matching lines @@
       web_contents_window()->delegate()->OnScrollEvent(event);
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
     if (web_contents_window())
       web_contents_window()->delegate()->OnGestureEvent(event);
   }
 
   WebContents* web_contents_;
   gfx::Image image_;
+  bool show_shadow_;
 
   DISALLOW_COPY_AND_ASSIGN(OverscrollWindowDelegate);
 };
 
 // Listens to all mouse drag events during a drag and drop and sends them to
 // the renderer.
 class WebDragSourceAura : public MessageLoopForUI::Observer,
                           public NotificationObserver {
  public:
   WebDragSourceAura(aura::Window* window, WebContentsImpl* contents)
@@ skipping 192 matching lines @@
   // Start resisting after the threshold.
   int resisted = threshold / 2;
   float extra = scroll - threshold;
   while ((extra /= 1.3f) > 1.f)
     resisted += 1;
   return resisted;
 }
 
 }  // namespace
 
+// ShadowWindow is used to paint shadows around a content window.
+// A ShadowWindow destroys itself when the content window is destroyed, and
+// updates its bounds to make sure the shadows are painted in the correct size.
+class ShadowWindow : public aura::Window,
+                     public aura::WindowObserver {
+ public:
+  explicit ShadowWindow(aura::Window* window)
+      : aura::Window(NULL),
+        window_(window),
+        edge_(SHADOW_NONE) {
+    SetType(aura::client::WINDOW_TYPE_CONTROL);
+    SetTransparent(true);
+    set_owned_by_parent(false);
+    Init(ui::LAYER_NOT_DRAWN);
+    layer()->SetMasksToBounds(false);
+
+    AddChild(window);
+    window_->AddObserver(this);
+
+    SetBounds(gfx::Rect(window->bounds().size()));
+    Show();
+  }
+
+  void SetShadowEdge(ShadowEdge edge) {
+    edge_ = edge;
+    if (edge_ == SHADOW_NONE) {
+      shadow_.reset();
+      return;
+    }
+
+    shadow_.reset(new ui::Layer(ui::LAYER_TEXTURED));
+    shadow_->set_delegate(this);
+    shadow_->SetFillsBoundsOpaquely(false);
+    layer()->Add(shadow_.get());
+    layer()->StackBelow(shadow_.get(), window_->layer());
+    UpdateShadowBounds();
+  }
+
+ private:
+  friend class base::DeleteHelper<content::ShadowWindow>;
+
+  virtual ~ShadowWindow() {
+  }
+
+  void UpdateShadowBounds() {
+    if (!shadow_.get())
+      return;
+    gfx::Rect bound;
+    switch (edge_) {
+      case SHADOW_LEFT:
+        bound.SetRect(-kShadowThick, 0, kShadowThick, bounds().height());
+        break;
+      case SHADOW_RIGHT:
+        bound.SetRect(bounds().right(), 0, kShadowThick, bounds().height());
+        break;
+      case SHADOW_TOP:
+        bound.SetRect(0, -kShadowThick, bounds().width(), kShadowThick);
+        break;
+      case SHADOW_BOTTOM:
+        bound.SetRect(0, bounds().bottom(), bounds().width(), kShadowThick);
+        break;
+      case SHADOW_NONE:
+        NOTREACHED();
+    }
+    shadow_->SetBounds(bound);
+  }
+
+  // Overridden from aura::WindowObserver:
+  virtual void OnWindowBoundsChanged(Window* window,
+                                     const gfx::Rect& old_bounds,
+                                     const gfx::Rect& new_bounds) OVERRIDE {
+    SetBounds(gfx::Rect(new_bounds.size()));
+    UpdateShadowBounds();
+  }
+
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+    DCHECK_EQ(window, window_);
+    window_->RemoveObserver(this);
+    window_ = NULL;
+    MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+  }
+
+  // Overridden from ui::LayerDelegate:
+  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
+    SkPoint points[2];
+    SkColor colors[2];
+
+    points[0].iset(0, 0);
+    switch (edge_) {
+      case SHADOW_LEFT:
+      case SHADOW_RIGHT:
+        points[1].iset(shadow_->bounds().width(), 0);
+        break;
+
+      case SHADOW_TOP:
+      case SHADOW_BOTTOM:
+        points[1].iset(0, shadow_->bounds().height());
+        break;
+
+      default:
+        NOTREACHED();
+    }
+
+    switch (edge_) {
+      case SHADOW_LEFT:
+      case SHADOW_TOP:
+        colors[0] = kShadowLightColor;
+        colors[1] = kShadowDarkColor;
+        break;
+
+      case SHADOW_RIGHT:
+      case SHADOW_BOTTOM:
+        colors[0] = kShadowDarkColor;
+        colors[1] = kShadowLightColor;
+        break;
+
+      default:
+        NOTREACHED();
+    }
+
+    skia::RefPtr<SkShader> shader = skia::AdoptRef(
+        SkGradientShader::CreateLinear(points, colors, NULL,
+            arraysize(points), SkShader::kRepeat_TileMode, NULL));
+
+    SkPaint paint;
+    paint.setShader(shader.get());
+    canvas->sk_canvas()->drawRect(gfx::RectToSkRect(bounds()), paint);
+  }
+
+  aura::Window* window_;
+  scoped_ptr<ui::Layer> shadow_;
+  ShadowEdge edge_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShadowWindow);
+};
+
 // When a history navigation is triggered at the end of an overscroll
 // navigation, it is necessary to show the history-screenshot until the page is
 // done navigating and painting. This class accomplishes this by showing the
 // screenshot window on top of the page until the page has completed loading and
 // painting.
 class OverscrollNavigationOverlay :
     public RenderWidgetHostViewAura::PaintObserver {
  public:
   OverscrollNavigationOverlay()
       : view_(NULL),
@@ skipping 150 matching lines @@
 // WebContentsViewAura, public:
 
 WebContentsViewAura::WebContentsViewAura(
     WebContentsImpl* web_contents,
     WebContentsViewDelegate* delegate)
     : web_contents_(web_contents),
       delegate_(delegate),
       current_drag_op_(WebKit::WebDragOperationNone),
       drag_dest_delegate_(NULL),
       current_rvh_for_drag_(NULL),
+      content_container_(NULL),
       overscroll_change_brightness_(false),
       current_overscroll_gesture_(OVERSCROLL_NONE),
       completed_overscroll_gesture_(OVERSCROLL_NONE) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, private:
 
 WebContentsViewAura::~WebContentsViewAura() {
   if (!window_)
@@ skipping 36 matching lines @@
     base::AutoReset<OverscrollMode> reset_state(&current_overscroll_gesture_,
                                                 current_overscroll_gesture_);
     scoped_ptr<aura::Window> reset_window(overscroll_window_.release());
   }
 
   OverscrollWindowDelegate* overscroll_delegate = new OverscrollWindowDelegate(
       web_contents_,
       current_overscroll_gesture_);
   overscroll_window_.reset(new aura::Window(overscroll_delegate));
   overscroll_window_->SetType(aura::client::WINDOW_TYPE_CONTROL);
-  overscroll_window_->SetTransparent(false);
+  overscroll_window_->SetTransparent(true);
   overscroll_window_->Init(ui::LAYER_TEXTURED);
   overscroll_window_->layer()->SetMasksToBounds(true);
   overscroll_window_->SetName("OverscrollOverlay");
 
   overscroll_change_brightness_ = overscroll_delegate->has_screenshot();
   window_->AddChild(overscroll_window_.get());
 
   gfx::Rect bounds = gfx::Rect(window_->bounds().size());
   if (ShouldNavigateForward(web_contents_->GetController(),
                             current_overscroll_gesture_)) {
     // The overlay will be sliding in from the right edge towards the left in
     // non-RTL, or sliding in from the left edge towards the right in RTL.
     // So position the overlay window accordingly.
     bounds.Offset(base::i18n::IsRTL() ? -bounds.width() : bounds.width(), 0);
   }
 
-  if (GetWindowToAnimateForOverscroll() == overscroll_window_.get())
-    window_->StackChildAbove(overscroll_window_.get(), GetContentNativeView());
-  else
-    window_->StackChildBelow(overscroll_window_.get(), GetContentNativeView());
+  if (GetWindowToAnimateForOverscroll() == overscroll_window_.get()) {
+    overscroll_delegate->set_show_shadow(true);
+    window_->StackChildAbove(overscroll_window_.get(), content_container_);
+  } else {
+    window_->StackChildBelow(overscroll_window_.get(), content_container_);
+
+    switch (current_overscroll_gesture_) {
+      case OVERSCROLL_EAST:
+        content_container_->SetShadowEdge(SHADOW_LEFT);
+        break;
+
+      case OVERSCROLL_WEST:
+        content_container_->SetShadowEdge(SHADOW_RIGHT);
+        break;
+
+      case OVERSCROLL_NORTH:
+        content_container_->SetShadowEdge(SHADOW_BOTTOM);
+        break;
+
+      case OVERSCROLL_SOUTH:
+        content_container_->SetShadowEdge(SHADOW_TOP);
+        break;
+
+      case OVERSCROLL_NONE:
+      case OVERSCROLL_COUNT:
+        NOTREACHED();
+    }
+  }
 
   UpdateOverscrollWindowBrightness(0.f);
 
   overscroll_window_->SetBounds(bounds);
   overscroll_window_->Show();
 }
 
 void WebContentsViewAura::PrepareContentWindowForOverscroll() {
-  aura::Window* content = GetContentNativeView();
+  aura::Window* content = content_container_;
   if (!content)
     return;
 
   ui::ScopedLayerAnimationSettings settings(content->layer()->GetAnimator());
   settings.SetPreemptionStrategy(ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
   content->SetTransform(gfx::Transform());
   content->layer()->SetLayerBrightness(0.f);
 }
 
 void WebContentsViewAura::ResetOverscrollTransform() {
@@ skipping 46 matching lines @@
   target->SetTransform(transform);
   UpdateOverscrollWindowBrightness(translate_x);
 }
 
 aura::Window* WebContentsViewAura::GetWindowToAnimateForOverscroll() {
   if (current_overscroll_gesture_ == OVERSCROLL_NONE)
     return NULL;
 
   return ShouldNavigateForward(web_contents_->GetController(),
                                current_overscroll_gesture_) ?
-      overscroll_window_.get() : GetContentNativeView();
+      overscroll_window_.get() : content_container_;
 }
 
 gfx::Vector2d WebContentsViewAura::GetTranslationForOverscroll(int delta_x,
                                                                int delta_y) {
   if (current_overscroll_gesture_ == OVERSCROLL_NORTH ||
       current_overscroll_gesture_ == OVERSCROLL_SOUTH) {
     // For vertical overscroll, always do a resisted drag.
     const float threshold = GetOverscrollConfig(
         OVERSCROLL_CONFIG_VERT_RESIST_AFTER);
     int scroll = GetResistedScrollAmount(abs(delta_y),
@@ skipping 11 matching lines @@
     return gfx::Vector2d(std::min(bounds.width(), delta_x), 0);
 
   const float threshold = GetOverscrollConfig(
       OVERSCROLL_CONFIG_HORIZ_RESIST_AFTER);
   int scroll = GetResistedScrollAmount(abs(delta_x),
                                        static_cast<int>(threshold));
   return gfx::Vector2d(delta_x < 0 ? -scroll : scroll, 0);
 }
 
 void WebContentsViewAura::PrepareOverscrollNavigationOverlay() {
+  OverscrollWindowDelegate* delegate = static_cast<OverscrollWindowDelegate*>(
+      overscroll_window_->delegate());
+  delegate->set_show_shadow(false);
+  overscroll_window_->SchedulePaintInRect(
+      gfx::Rect(overscroll_window_->bounds().size()));
   navigation_overlay_->SetOverlayWindow(overscroll_window_.Pass());
   navigation_overlay_->StartObservingView(static_cast<
       RenderWidgetHostViewAura*>(web_contents_->GetRenderWidgetHostView()));
 }
 
 void WebContentsViewAura::UpdateOverscrollWindowBrightness(float delta_x) {
   if (!overscroll_change_brightness_)
     return;
 
   const float kBrightnessMin = -.5f;
@@ skipping 58 matching lines @@
     // this actually is happening (and somebody isn't accidentally creating the
     // view twice), we check for the RVH Factory, which will be set when we're
     // making special ones (which go along with the special views).
     DCHECK(RenderViewHostFactory::has_factory());
     return render_widget_host->GetView();
   }
 
   RenderWidgetHostView* view =
       RenderWidgetHostView::CreateViewForWidget(render_widget_host);
   view->InitAsChild(NULL);
-  GetNativeView()->AddChild(view->GetNativeView());
+  content_container_ = new ShadowWindow(view->GetNativeView());
+  GetNativeView()->AddChild(content_container_);
 
   if (navigation_overlay_.get() && navigation_overlay_->has_window()) {
     navigation_overlay_->StartObservingView(static_cast<
         RenderWidgetHostViewAura*>(view));
   }
 
   view->Show();
 
   // We listen to drag drop events in the newly created view's window.
   aura::client::SetDragDropDelegate(view->GetNativeView(), this);
@@ skipping 249 matching lines @@
                             completed_overscroll_gesture_)) {
     PrepareOverscrollNavigationOverlay();
     web_contents_->GetController().GoForward();
   } else if (ShouldNavigateBack(web_contents_->GetController(),
                                 completed_overscroll_gesture_)) {
     PrepareOverscrollNavigationOverlay();
     web_contents_->GetController().GoBack();
   }
 
   if (GetContentNativeView()) {
-    GetContentNativeView()->SetTransform(gfx::Transform());
-    GetContentNativeView()->layer()->SetLayerBrightness(0.f);
+    content_container_->SetTransform(gfx::Transform());
+    content_container_->layer()->SetLayerBrightness(0.f);
+    content_container_->SetShadowEdge(SHADOW_NONE);
   }
   current_overscroll_gesture_ = OVERSCROLL_NONE;
   completed_overscroll_gesture_ = OVERSCROLL_NONE;
   overscroll_window_.reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, aura::WindowDelegate implementation:
 
 gfx::Size WebContentsViewAura::GetMinimumSize() const {
@@ skipping 176 matching lines @@
       event.location(),
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint(),
       ConvertAuraEventFlagsToWebInputEventModifiers(event.flags()));
   if (drag_dest_delegate_)
     drag_dest_delegate_->OnDrop();
   current_drop_data_.reset();
   return current_drag_op_;
 }
 
 }  // namespace content