Remove ViewHostMsg_DidFirstPaintAfterLoad

content/browser/renderer_host/render_widget_host_impl.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_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 265 matching lines @@
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(blink::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_events_until_keydown_(false),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       is_in_touchpad_gesture_scroll_(false),
       is_in_touchscreen_gesture_scroll_(false),
-      received_paint_after_load_(false),
       latency_tracker_(),
       next_browser_snapshot_id_(1),
       owned_by_render_frame_host_(false),
       is_focused_(false),
       hung_renderer_delay_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       hang_monitor_event_type_(blink::WebInputEvent::Undefined),
       last_event_type_(blink::WebInputEvent::Undefined),
       new_content_rendering_delay_(
           base::TimeDelta::FromMilliseconds(kNewContentRenderingDelayMs)),
@@ skipping 266 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_TextInputStateChanged,
                         OnTextInputStateChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_LockMouse, OnLockMouse)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UnlockMouse, OnUnlockMouse)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ShowDisambiguationPopup,
                         OnShowDisambiguationPopup)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectionBoundsChanged,
                         OnSelectionBoundsChanged)
     IPC_MESSAGE_HANDLER(InputHostMsg_ImeCompositionRangeChanged,
                         OnImeCompositionRangeChanged)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidFirstPaintAfterLoad,
-                        OnFirstPaintAfterLoad)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetNeedsBeginFrames, OnSetNeedsBeginFrames)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FocusedNodeTouched, OnFocusedNodeTouched)
     IPC_MESSAGE_HANDLER(DragHostMsg_StartDragging, OnStartDragging)
     IPC_MESSAGE_HANDLER(DragHostMsg_UpdateDragCursor, OnUpdateDragCursor)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!handled && input_router_ && input_router_->OnMessageReceived(msg))
     return true;
 
@@ skipping 403 matching lines @@
     hang_monitor_timeout_->Stop();
   RendererIsResponsive();
 }
 
 void RenderWidgetHostImpl::StartNewContentRenderingTimeout(
     uint32_t next_source_id) {
   current_content_source_id_ = next_source_id;
   // It is possible for a compositor frame to arrive before the browser is
   // notified about the page being committed, in which case no timer is
   // necessary.
-  if (received_paint_after_load_) {
-    received_paint_after_load_ = false;
+  if (last_received_content_source_id_ >= current_content_source_id_)
     return;
-  }
 
   new_content_rendering_timeout_->Start(new_content_rendering_delay_);
 }
 
-void RenderWidgetHostImpl::OnFirstPaintAfterLoad() {
-  if (new_content_rendering_timeout_->IsRunning()) {
-    new_content_rendering_timeout_->Stop();
-  } else {
-    received_paint_after_load_ = true;
-  }
-}
-
 void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
   ForwardMouseEventWithLatencyInfo(mouse_event,
                                    ui::LatencyInfo(ui::SourceEventType::OTHER));
   if (owner_delegate_)
     owner_delegate_->RenderWidgetDidForwardMouseEvent(mouse_event);
 }
 
 void RenderWidgetHostImpl::ForwardMouseEventWithLatencyInfo(
       const blink::WebMouseEvent& mouse_event,
       const ui::LatencyInfo& ui_latency) {
@@ skipping 842 matching lines @@
                 << " Expected: size=" << last_frame_size_.ToString()
                 << ",scale=" << last_device_scale_factor_
                 << " Received: size=" << frame_size.ToString()
                 << ",scale=" << device_scale_factor;
     return false;
   }
   last_local_surface_id_ = local_surface_id;
   last_frame_size_ = frame_size;
   last_device_scale_factor_ = device_scale_factor;
 
+  last_received_content_source_id_ = frame.metadata.content_source_id;
+
   if (frame.metadata.begin_frame_ack.sequence_number <
       cc::BeginFrameArgs::kStartingFrameNumber) {
     // Received an invalid ack, renderer misbehaved.
     bad_message::ReceivedBadMessage(
         GetProcess(),
         bad_message::RWH_INVALID_BEGIN_FRAME_ACK_COMPOSITOR_FRAME);
     return false;
   }
   // |has_damage| and |remaining_frames| are not transmitted.
   frame.metadata.begin_frame_ack.has_damage = true;
@@ skipping 22 matching lines @@
                                  std::move(frame));
     view_->DidReceiveRendererFrame();
   } else {
     cc::ReturnedResourceArray resources;
     cc::TransferableResource::ReturnResources(frame.resource_list, &resources);
     SendReclaimCompositorResources(routing_id_, compositor_frame_sink_id,
                                    process_->GetID(), true /* is_swap_ack */,
                                    resources);
   }
 
+  // After navigation, if a frame belonging to the new page is received, stop
+  // the timer that triggers clearing the graphics of the last page.
+  if (last_received_content_source_id_ >= current_content_source_id_ &&
+      new_content_rendering_timeout_->IsRunning()) {
+    new_content_rendering_timeout_->Stop();
+  }
+
   RenderProcessHost* rph = GetProcess();
   for (std::vector<IPC::Message>::const_iterator i =
            messages_to_deliver_with_frame.begin();
        i != messages_to_deliver_with_frame.end();
        ++i) {
     rph->OnMessageReceived(*i);
     if (i->dispatch_error())
       rph->OnBadMessageReceived(*i);
   }
   messages_to_deliver_with_frame.clear();
@@ skipping 718 matching lines @@
 void RenderWidgetHostImpl::RequestCompositionUpdates(bool immediate_request,
                                                      bool monitor_updates) {
   if (!immediate_request && monitor_updates == monitoring_composition_info_)
     return;
   monitoring_composition_info_ = monitor_updates;
   Send(new InputMsg_RequestCompositionUpdates(routing_id_, immediate_request,
                                               monitor_updates));
 }
 
 }  // namespace content