Discard compositor frames from unloaded web content

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 276 matching lines @@
       owned_by_render_frame_host_(false),
       is_focused_(false),
       hung_renderer_delay_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       hang_monitor_reason_(
           RendererUnresponsiveType::RENDERER_UNRESPONSIVE_UNKNOWN),
       hang_monitor_event_type_(blink::WebInputEvent::Undefined),
       last_event_type_(blink::WebInputEvent::Undefined),
       new_content_rendering_delay_(
           base::TimeDelta::FromMilliseconds(kNewContentRenderingDelayMs)),
+      current_content_source_id_(0),
       weak_factory_(this) {
   CHECK(delegate_);
   CHECK_NE(MSG_ROUTING_NONE, routing_id_);
   latency_tracker_.SetDelegate(delegate_);
 
 #if defined(OS_WIN)
   // Update the display color profile cache so that it is likely to be up to
   // date when the renderer process requests the color profile.
   if (gfx::ICCProfile::CachedProfilesNeedUpdate()) {
     base::PostTaskWithTraits(
@@ skipping 696 matching lines @@
 
 void RenderWidgetHostImpl::StopHangMonitorTimeout() {
   if (hang_monitor_timeout_) {
     hang_monitor_timeout_->Stop();
     hang_monitor_reason_ =
         RendererUnresponsiveType::RENDERER_UNRESPONSIVE_UNKNOWN;
   }
   RendererIsResponsive();
 }
 
-void RenderWidgetHostImpl::StartNewContentRenderingTimeout() {
+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;
     return;
   }
 
   new_content_rendering_timeout_->Start(new_content_rendering_delay_);
 }
@@ skipping 818 matching lines @@
   std::vector<IPC::Message> messages_to_deliver_with_frame;
   messages_to_deliver_with_frame.swap(std::get<2>(param));
 
   if (!ui::LatencyInfo::Verify(frame.metadata.latency_info,
                                "RenderWidgetHostImpl::OnSwapCompositorFrame")) {
     std::vector<ui::LatencyInfo>().swap(frame.metadata.latency_info);
   }
 
   latency_tracker_.OnSwapCompositorFrame(&frame.metadata.latency_info);
 
+  // Ignore this frame if its content has already been unloaded.

[enne (OOO), 2017/02/28 22:23:21]

I agree that maybe the mobile optimized and double tap support for page
shouldn't be updated if the frame is going to be dropped.  However, I do think
that the resources from the frame should be returned so that the renderer can
reuse them.

[kenrb, 2017/03/01 15:32:47]

Done.

+  if (frame.metadata.content_source_id < current_content_source_id_)
+    return false;
+
   bool is_mobile_optimized = IsMobileOptimizedFrame(frame.metadata);
   input_router_->NotifySiteIsMobileOptimized(is_mobile_optimized);
   if (touch_emulator_)
     touch_emulator_->SetDoubleTapSupportForPageEnabled(!is_mobile_optimized);
 
   if (view_) {
     view_->OnSwapCompositorFrame(compositor_frame_sink_id, std::move(frame));
     view_->DidReceiveRendererFrame();
   } else {
     cc::ReturnedResourceArray resources;
@@ skipping 668 matching lines @@
     // different from the receiver's.
     file_system_file.url =
         GURL(storage::GetIsolatedFileSystemRootURIString(
                  file_system_url.origin(), filesystem_id, std::string())
                  .append(register_name));
     file_system_file.filesystem_id = filesystem_id;
   }
 }
 
 }  // namespace content