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

content/browser/renderer_host/render_widget_host_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/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 468 matching lines @@
       accept_return_character_(false),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
       last_swapped_surface_scale_factor_(1.f),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       accelerated_compositing_state_changed_(false),
       can_lock_compositor_(YES),
       cursor_visibility_state_in_renderer_(UNKNOWN),
-      paint_observer_(NULL),
       touch_editing_client_(NULL),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)),
       weak_ptr_factory_(this) {
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetActivationChangeObserver(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
@@ skipping 410 matching lines @@
 
 void RenderWidgetHostViewAura::UpdateCursor(const WebCursor& cursor) {
   current_cursor_ = cursor;
   const gfx::Display display = gfx::Screen::GetScreenFor(window_)->
       GetDisplayNearestWindow(window_);
   current_cursor_.SetDisplayInfo(display);
   UpdateCursorIfOverSelf();
 }
 
 void RenderWidgetHostViewAura::SetIsLoading(bool is_loading) {
-  if (is_loading_ && !is_loading && paint_observer_)
-    paint_observer_->OnPageLoadComplete();
   is_loading_ = is_loading;
   UpdateCursorIfOverSelf();
 }
 
 void RenderWidgetHostViewAura::TextInputTypeChanged(
     ui::TextInputType type,
     ui::TextInputMode input_mode,
     bool can_compose_inline) {
   if (text_input_type_ != type ||
       text_input_mode_ != input_mode ||
@@ skipping 558 matching lines @@
       window_->layer()->SetShowDelegatedContent(frame_provider_.get(),
                                                 frame_size_in_dip);
     } else {
       frame_provider_->SetFrameData(frame_data.Pass());
     }
   }
   released_front_lock_ = NULL;
   current_frame_size_ = frame_size_in_dip;
   CheckResizeLock();
 
-  if (paint_observer_)
-    paint_observer_->OnUpdateCompositorContent();
   window_->SchedulePaintInRect(damage_rect_in_dip);
 
   pending_delegated_ack_count_++;
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     SendDelegatedFrameAck(output_surface_id);
   } else {
     for (size_t i = 0; i < latency_info.size(); i++)
       compositor->SetLatencyInfo(latency_info[i]);
@@ skipping 94 matching lines @@
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
     for (size_t i = 0; i < latency_info.size(); i++)
       compositor->SetLatencyInfo(latency_info[i]);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   }
-  if (paint_observer_)
-    paint_observer_->OnUpdateCompositorContent();
   DidReceiveFrameFromRenderer();
 
   software_frame_manager_->SwapToNewFrameComplete(!host_->is_hidden());
 }
 
 void RenderWidgetHostViewAura::SendSoftwareFrameAck(uint32 output_surface_id) {
   unsigned software_frame_id = 0;
   if (released_software_frame_ &&
       released_software_frame_->output_surface_id == output_surface_id) {
     software_frame_id = released_software_frame_->frame_id;
@@ skipping 148 matching lines @@
                                    surface_size_in_pixel.height() -
                                        damage_rect.y() - damage_rect.height(),
                                    damage_rect.width(),
                                    damage_rect.height()));
 
     // Damage may not have been DIP aligned, so inflate damage to compensate
     // for any round-off error.
     rect_to_paint.Inset(-1, -1);
     rect_to_paint.Intersect(window_->bounds());
 
-    if (paint_observer_)
-      paint_observer_->OnUpdateCompositorContent();
     window_->SchedulePaintInRect(rect_to_paint);
     for (size_t i = 0; i < latency_info.size(); i++)
       compositor->SetLatencyInfo(latency_info[i]);
   }
 
   SwapBuffersCompleted(ack_callback, previous_texture);
 }
 
 void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
@@ skipping 808 matching lines @@
 
 void RenderWidgetHostViewAura::OnPaint(gfx::Canvas* canvas) {
   bool has_backing_store = !!host_->GetBackingStore(false);
   if (has_backing_store) {
     paint_canvas_ = canvas;
     BackingStoreAura* backing_store = static_cast<BackingStoreAura*>(
         host_->GetBackingStore(true));
     paint_canvas_ = NULL;
     backing_store->SkiaShowRect(gfx::Point(), canvas);
 
-    if (paint_observer_)
-      paint_observer_->OnPaintComplete();
     ui::Compositor* compositor = GetCompositor();
     if (compositor) {
       for (size_t i = 0; i < software_latency_info_.size(); i++)
         compositor->SetLatencyInfo(software_latency_info_[i]);
     }
     software_latency_info_.clear();
   } else {
     // For non-opaque windows, we don't draw anything, since we depend on the
     // canvas coming from the compositor to already be initialized as
     // transparent.
@@ skipping 569 matching lines @@
   }
 }
 
 void RenderWidgetHostViewAura::OnCompositingStarted(
     ui::Compositor* compositor, base::TimeTicks start_time) {
   last_draw_ended_ = start_time;
 }
 
 void RenderWidgetHostViewAura::OnCompositingEnded(
     ui::Compositor* compositor) {
-  if (paint_observer_)
-    paint_observer_->OnCompositingComplete();
 }
 
 void RenderWidgetHostViewAura::OnCompositingAborted(
     ui::Compositor* compositor) {
 }
 
 void RenderWidgetHostViewAura::OnCompositingLockStateChanged(
     ui::Compositor* compositor) {
   // A compositor lock that is part of a resize lock timed out. We
   // should display a renderer frame.
@@ skipping 85 matching lines @@
   // are using is becoming invalid. This sends pending ACKs and needs to happen
   // after calling UpdateExternalTexture() which syncs with the impl thread.
   RunOnCommitCallbacks();
   host_->ScheduleComposite();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, private:
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
-  if (paint_observer_)
-    paint_observer_->OnViewDestroyed();
   if (touch_editing_client_)
     touch_editing_client_->OnViewDestroyed();
 
   ImageTransportFactory::GetInstance()->RemoveObserver(this);
 
   window_observer_.reset();
   if (window_->GetDispatcher())
     window_->GetDispatcher()->RemoveRootWindowObserver(this);
   UnlockMouse();
   if (popup_parent_host_view_) {
@@ skipping 250 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content