Clear page display after navigation if no rendered output arrives

content/browser/renderer_host/render_widget_host_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 98 matching lines @@
 
   // Use RenderWidgetHostImpl::From(rwh) to downcast a
   // RenderWidgetHost to a RenderWidgetHostImpl.  Internally, this
   // uses RenderWidgetHost::AsRenderWidgetHostImpl().
   static RenderWidgetHostImpl* From(RenderWidgetHost* rwh);
 
   void set_hung_renderer_delay(const base::TimeDelta& delay) {
     hung_renderer_delay_ = delay;
   }
 
+  void set_new_content_rendering_delay_for_testing(
+      const base::TimeDelta& delay) {
+    new_content_rendering_delay_ = delay;
+  }
+
   // RenderWidgetHost implementation.
   void UpdateTextDirection(blink::WebTextDirection direction) override;
   void NotifyTextDirection() override;
   void Focus() override;
   void Blur() override;
   void SetActive(bool active) override;
   void CopyFromBackingStore(const gfx::Rect& src_rect,
                             const gfx::Size& accelerated_dst_size,
                             ReadbackRequestCallback& callback,
                             const SkColorType preferred_color_type) override;
@@ skipping 122 matching lines @@
 
   // Starts a hang monitor timeout. If there's already a hang monitor timeout
   // the new one will only fire if it has a shorter delay than the time
   // left on the existing timeouts.
   void StartHangMonitorTimeout(base::TimeDelta delay);
 
   // Stops all existing hang monitor timeouts and assumes the renderer is
   // responsive.
   void StopHangMonitorTimeout();
 
+  // Starts the rendering timeout, which will clear displayed graphics if
+  // a new compositor frame is not received before it expires.
+  void StartNewContentRenderingTimeout();
+
+  // Stops the rendering timeout and prevents it from clearing any displayed
+  // graphics.
+  void StopNewContentRenderingTimeout();
+
   // Forwards the given message to the renderer. These are called by the view
   // when it has received a message.
   void ForwardGestureEventWithLatencyInfo(
       const blink::WebGestureEvent& gesture_event,
       const ui::LatencyInfo& ui_latency);
   void ForwardTouchEventWithLatencyInfo(
       const blink::WebTouchEvent& touch_event,
       const ui::LatencyInfo& ui_latency);
   void ForwardMouseEventWithLatencyInfo(
       const blink::WebMouseEvent& mouse_event,
@@ skipping 214 matching lines @@
   // Notification that the user has made some kind of input that could
   // perform an action. The gestures that count are 1) any mouse down
   // event and 2) enter or space key presses.
   virtual void OnUserGesture() {}
 
   // Callbacks for notification when the renderer becomes unresponsive to user
   // input events, and subsequently responsive again.
   virtual void NotifyRendererUnresponsive() {}
   virtual void NotifyRendererResponsive() {}
 
+  // Callback for notification that we failed to receive any rendered graphics
+  // from a newly loaded page. Used for testing.
+  virtual void NotifyNewContentRenderingTimeoutForTesting() {}
+
   // Called when auto-resize resulted in the renderer size changing.
   virtual void OnRenderAutoResized(const gfx::Size& new_size) {}
 
   // ---------------------------------------------------------------------------
 
   // RenderViewHost overrides this method to impose further restrictions on when
   // to allow mouse lock.
   // Once the request is approved or rejected, GotResponseToLockMouseRequest()
   // will be called.
   virtual void RequestToLockMouse(bool user_gesture,
@@ skipping 40 matching lines @@
 
   // A weak pointer to the view. The above pointer should be weak, but changing
   // that to be weak causes crashes on Android.
   // TODO(ccameron): Fix this.
   // http://crbug.com/404828
   base::WeakPtr<RenderWidgetHostViewBase> view_weak_;
 
   // This value indicates how long to wait before we consider a renderer hung.
   base::TimeDelta hung_renderer_delay_;
 
+  // This value indicates how long to wait for a new compositor frame from a
+  // renderer process before clearing any previously displayed content.
+  base::TimeDelta new_content_rendering_delay_;
+
  private:
   friend class MockRenderWidgetHost;
 
   // Tell this object to destroy itself.
   void Destroy();
 
   // Called by |hang_monitor_timeout_| on delayed response from the renderer.
   void RendererIsUnresponsive();
 
+  // Called by |new_content_rendering_timeout_| if a renderer has loaded new
+  // content but failed to produce a compositor frame in a defined time.
+  void ClearDisplayedGraphics();
+
   // Called if we know the renderer is responsive. When we currently think the
   // renderer is unresponsive, this will clear that state and call
   // NotifyRendererResponsive.
   void RendererIsResponsive();
 
   // Routines used to send the RenderWidget its screen color profile.
   void DispatchColorProfile();
   void SendColorProfile();
 
   // IPC message handlers
@@ skipping 209 matching lines @@
 
   scoped_ptr<SyntheticGestureController> synthetic_gesture_controller_;
 
   scoped_ptr<TouchEmulator> touch_emulator_;
 
   // Receives and handles all input events.
   scoped_ptr<InputRouter> input_router_;
 
   scoped_ptr<TimeoutMonitor> hang_monitor_timeout_;
 
+  scoped_ptr<TimeoutMonitor> new_content_rendering_timeout_;
+
 #if defined(OS_WIN)
   std::list<HWND> dummy_windows_for_activation_;
 #endif
 
   RenderWidgetHostLatencyTracker latency_tracker_;
 
   int next_browser_snapshot_id_;
   using PendingSnapshotMap = std::map<int, GetSnapshotFromBrowserCallback>;
   PendingSnapshotMap pending_browser_snapshots_;
 
   // Indicates whether a RenderFramehost has ownership, in which case this
   // object does not self destroy.
   bool owned_by_render_frame_host_;
 
   // Indicates whether this RenderWidgetHost thinks is focused. This is trying
   // to match what the renderer process knows. It is different from
   // RenderWidgetHostView::HasFocus in that in that the focus request may fail,
   // causing HasFocus to return false when is_focused_ is true.
   bool is_focused_;
 
   base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_