gesture-nav: Use a WebContentsObserver to more reliably dismiss the navigation overlay.

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/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
@@ skipping 474 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ImageLayerDelegate);
 };
 
 }  // namespace
 
 // 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 WindowSlider::Delegate {
+class OverscrollNavigationOverlay : public WebContentsObserver,
+                                    public WindowSlider::Delegate {
  public:
   explicit OverscrollNavigationOverlay(WebContentsImpl* web_contents)
       : web_contents_(web_contents),
         image_delegate_(NULL),
-        view_(NULL),
         loading_complete_(false),
         received_paint_update_(false),
-        compositor_updated_(false),
         slide_direction_(SLIDE_UNKNOWN),
         need_paint_update_(true) {
   }
 
   virtual ~OverscrollNavigationOverlay() {
-    if (view_)
-      view_->set_paint_observer(NULL);
   }
 
   bool has_window() const { return !!window_.get(); }
 
-  void StartObservingView(RenderWidgetHostViewAura* view) {
-    if (view_)
-      view_->set_paint_observer(NULL);
-
+  void StartObserving() {
     loading_complete_ = false;
     received_paint_update_ = false;
-    compositor_updated_ = false;
-    view_ = view;
-    if (view_)
-      view_->set_paint_observer(this);
+    Observe(web_contents_);
 
     // Make sure the overlay window is on top.
     if (window_.get() && window_->parent())
       window_->parent()->StackChildAtTop(window_.get());
   }
 
   void SetOverlayWindow(scoped_ptr<aura::Window> window,
                         ImageWindowDelegate* delegate) {
     window_ = window.Pass();
     if (window_.get() && window_->parent())
@@ skipping 25 matching lines @@
     // as soon as there is any new painting notification.
     if ((need_paint_update_ && !received_paint_update_) ||
         (image_delegate_->has_image() && !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;
 
+    Observe(NULL);
     window_slider_.reset();
     window_.reset();
     image_delegate_ = NULL;
-    if (view_) {
-      view_->set_paint_observer(NULL);
-      view_ = NULL;
-    }
   }
 
   // Creates a layer to be used for window-slide. |offset| is the offset of the
   // NavigationEntry for the screenshot image to display.
   ui::Layer* CreateSlideLayer(int offset) {
     const NavigationControllerImpl& controller = web_contents_->GetController();
     const NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
         controller.GetEntryAtOffset(offset));
 
     gfx::Image image;
@@ skipping 36 matching lines @@
     // 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()));
 
     SlideDirection direction = slide_direction_;
     slide_direction_ = SLIDE_UNKNOWN;
 
     // Reset state and wait for the new navigation page to complete
     // loading/painting.
-    StartObservingView(ToRenderWidgetHostViewAura(
-        web_contents_->GetRenderWidgetHostView()));
+    StartObserving();
 
     // Perform the navigation.
     if (direction == SLIDE_BACK)
       web_contents_->GetController().GoBack();
     else if (direction == SLIDE_FRONT)
       web_contents_->GetController().GoForward();
     else
       NOTREACHED();
   }
 
   virtual void OnWindowSlideAborted() OVERRIDE {
     StopObservingIfDone();
   }
 
   virtual void OnWindowSliderDestroyed() OVERRIDE {
     // The slider has just been destroyed. Release the ownership.
     WindowSlider* slider ALLOW_UNUSED = window_slider_.release();
     StopObservingIfDone();
   }
 
-  // Overridden from RenderWidgetHostViewAura::PaintObserver:
-  virtual void OnPaintComplete() OVERRIDE {
+  // Overridden from WebContentsObserver:
+  virtual void DidFirstVisuallyNonEmptyPaint(int32 page_id) OVERRIDE {
     received_paint_update_ = true;
     StopObservingIfDone();
   }
 
-  virtual void OnCompositingComplete() OVERRIDE {
-    received_paint_update_ = compositor_updated_;
-    StopObservingIfDone();
-  }
-
-  virtual void OnUpdateCompositorContent() OVERRIDE {
-    compositor_updated_ = true;
-  }
-
-  virtual void OnPageLoadComplete() OVERRIDE {
+  virtual void DidStopLoading(RenderViewHost* host) OVERRIDE {
     loading_complete_ = true;
     StopObservingIfDone();
   }
 
-  virtual void OnViewDestroyed() OVERRIDE {
-    DCHECK(view_);
-    view_->set_paint_observer(NULL);
-    view_ = NULL;
-  }
-
   // The WebContents which is being navigated.
   WebContentsImpl* web_contents_;
 
   scoped_ptr<aura::Window> window_;
 
   // This is the WindowDelegate of |window_|. The delegate manages its own
   // lifetime (destroys itself when |window_| is destroyed).
   ImageWindowDelegate* image_delegate_;
 
-  RenderWidgetHostViewAura* view_;
   bool loading_complete_;
   bool received_paint_update_;
-  bool compositor_updated_;
 
   enum SlideDirection {
     SLIDE_UNKNOWN,
     SLIDE_BACK,
     SLIDE_FRONT
   };
 
   // The |WindowSlider| that allows sliding history layers while the page is
   // being reloaded.
   scoped_ptr<WindowSlider> window_slider_;
@@ skipping 448 matching lines @@
 
 void WebContentsViewAura::PrepareOverscrollNavigationOverlay() {
   OverscrollWindowDelegate* delegate = static_cast<OverscrollWindowDelegate*>(
       overscroll_window_->delegate());
   overscroll_window_->SchedulePaintInRect(
       gfx::Rect(overscroll_window_->bounds().size()));
   overscroll_window_->SetBounds(gfx::Rect(window_->bounds().size()));
   overscroll_window_->SetTransform(gfx::Transform());
   navigation_overlay_->SetOverlayWindow(overscroll_window_.Pass(),
                                         delegate);
-  navigation_overlay_->StartObservingView(ToRenderWidgetHostViewAura(
-      web_contents_->GetRenderWidgetHostView()));
+  navigation_overlay_->StartObserving();
 }
 
 void WebContentsViewAura::UpdateOverscrollWindowBrightness(float delta_x) {
   if (!overscroll_change_brightness_)
     return;
 
   const float kBrightnessMin = -.1f;
   const float kBrightnessMax = -.01f;
 
   float ratio = fabs(delta_x) / GetViewBounds().width();
@@ skipping 156 matching lines @@
     DCHECK(RenderViewHostFactory::has_factory());
     return render_widget_host->GetView();
   }
 
   RenderWidgetHostView* view =
       RenderWidgetHostView::CreateViewForWidget(render_widget_host);
   view->InitAsChild(NULL);
   GetNativeView()->AddChild(view->GetNativeView());
 
   if (navigation_overlay_.get() && navigation_overlay_->has_window()) {
-    navigation_overlay_->StartObservingView(ToRenderWidgetHostViewAura(view));
+    navigation_overlay_->StartObserving();
   }
 
   RenderWidgetHostImpl* host_impl =
       RenderWidgetHostImpl::From(render_widget_host);
 
   if (!host_impl->is_hidden())
     view->Show();
 
   // We listen to drag drop events in the newly created view's window.
   aura::client::SetDragDropDelegate(view->GetNativeView(), this);
@@ skipping 16 matching lines @@
 }
 
 void WebContentsViewAura::SetPageTitle(const base::string16& title) {
   window_->set_title(title);
 }
 
 void WebContentsViewAura::RenderViewCreated(RenderViewHost* host) {
 }
 
 void WebContentsViewAura::RenderViewSwappedIn(RenderViewHost* host) {
-  if (navigation_overlay_.get() && navigation_overlay_->has_window()) {
-    navigation_overlay_->StartObservingView(
-        ToRenderWidgetHostViewAura(host->GetView()));
-  }
+  if (navigation_overlay_.get() && navigation_overlay_->has_window())
+    navigation_overlay_->StartObserving();
   AttachTouchEditableToRenderView();
 }
 
 void WebContentsViewAura::SetOverscrollControllerEnabled(bool enabled) {
   RenderViewHostImpl* host = static_cast<RenderViewHostImpl*>(
       web_contents_->GetRenderViewHost());
   if (host) {
     host->SetOverscrollControllerEnabled(enabled);
     if (enabled)
       host->overscroll_controller()->set_delegate(this);
@@ skipping 399 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 ConvertFromWeb(current_drag_op_);
 }
 
 }  // namespace content