Stop recording LCP after OOPIF input.

A subframe's PaintTimingDetector is supposed to stop recording after an
input, but we were only calling NotifyInputEvent on the same-site
codepath (WebViewImpl) and not the OOPIF codepath (WebFrameWidgetImpl).

This also ensures that we set first_input_or_scroll_notified_timestamp
in PageLoadMetrics timing updates after an OOPIF input.

Bug: 1115529
Change-Id: I9599d1cc7094551b899cfa19591eeaf5c85eb88b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2436770Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Nicolás Peña Moreno <npm@chromium.org>
Commit-Queue: Steve Kobes <skobes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#813268}

chrome/browser/page_load_metrics/integration_tests/data/lcp_subframe_input.html

+<iframe id="f"></iframe>
+<script>
+  f.src = origin.replace("example.com", "b.com") +
+      "/lcp_subframe_input_sub.html";
+</script>

chrome/browser/page_load_metrics/integration_tests/data/lcp_subframe_input_sub.html

+<div><img src="images/green-16x16.png"></div>
+<div id="container"></div>
+<script>
+  var last_url = null;
+  const test_step_1 = async () => {
+    return new Promise(resolve => {
+      new PerformanceObserver(list => {
+        resolve(last_url = list.getEntries()[0].url.match(/images\/(.*)/)[1]);
+      }).observe({type: 'largest-contentful-paint', buffered: true});
+    });
+  };
+  const test_step_2 = async () => {
+    let img = document.createElement("img");
+    let img_load = new Promise(resolve => {
+      new PerformanceObserver(list => {
+        if (list.getEntries().some(e => e.identifier == "blue"))
+          resolve();
+      }).observe({type: 'element'});
+      img.setAttribute("elementtiming", "blue");
+    });
+    container.appendChild(img);
+    img.src = "images/blue96x96.png";
+    await img_load;
+    await new Promise(resolve => { requestAnimationFrame(resolve); });
+    return last_url;
+  };
+</script>

chrome/browser/page_load_metrics/integration_tests/largest_contentful_paint_browsertest.cc

@@ -130,3 +130,17 @@ IN_PROC_BROWSER_TEST_F(MetricIntegrationTest, LargestContentfulPaint) {
       "PageLoad.PaintTiming.NavigationToLargestContentfulPaint.MainFrame",
       lcp_timestamps[2].value());
 }
+
+IN_PROC_BROWSER_TEST_F(MetricIntegrationTest,
+                       LargestContentfulPaint_SubframeInput) {
+  Start();
+  Load("/lcp_subframe_input.html");
+  auto* sub = ChildFrameAt(web_contents()->GetMainFrame(), 0);
+  EXPECT_EQ(EvalJs(sub, "test_step_1()").value.GetString(), "green-16x16.png");
+
+  content::SimulateMouseClickAt(web_contents(), 0,
+                                blink::WebMouseEvent::Button::kLeft,
+                                gfx::Point(100, 100));
+
+  EXPECT_EQ(EvalJs(sub, "test_step_2()").value.GetString(), "green-16x16.png");
+}

chrome/browser/page_load_metrics/integration_tests/metric_integration_test.cc

@@ -112,6 +112,8 @@ void MetricIntegrationTest::SetUpCommandLine(CommandLine* command_line) {
   // Set a default window size for consistency.
   command_line->AppendSwitchASCII(switches::kWindowSize, "800,600");
   command_line->AppendSwitch(switches::kEnableExperimentalWebPlatformFeatures);
+
+  content::IsolateAllSitesForTesting(command_line);
 }
 
 std::unique_ptr<HttpResponse> MetricIntegrationTest::HandleRequest(

third_party/blink/renderer/core/exported/web_view_impl.cc

@@ -2323,6 +2323,9 @@ WebInputEventResult WebViewImpl::HandleInputEvent(
     return WebInputEventResult::kNotHandled;
   DCHECK(!WebInputEvent::IsTouchEventType(input_event.GetType()));
 
+  WebFrameWidgetBase* widget = MainFrameImpl()->FrameWidgetImpl();
+  DCHECK(widget);
+
   GetPage()->GetVisualViewport().StartTrackingPinchStats();
 
   TRACE_EVENT1("input,rail", "WebViewImpl::handleInputEvent", "type",
@@ -2330,7 +2333,7 @@ WebInputEventResult WebViewImpl::HandleInputEvent(
 
   // If a drag-and-drop operation is in progress, ignore input events except
   // PointerCancel.
-  if (MainFrameImpl()->FrameWidgetImpl()->DoingDragAndDrop() &&
+  if (widget->DoingDragAndDrop() &&
       input_event.GetType() != WebInputEvent::Type::kPointerCancel)
     return WebInputEventResult::kHandledSuppressed;
 
@@ -2350,14 +2353,12 @@ WebInputEventResult WebViewImpl::HandleInputEvent(
   UIEventWithKeyState::ClearNewTabModifierSetFromIsolatedWorld();
 
   bool is_pointer_locked = false;
-  if (WebFrameWidgetBase* widget = MainFrameImpl()->FrameWidgetImpl()) {
-    if (WebWidgetClient* client = widget->Client())
-      is_pointer_locked = client->IsPointerLocked();
-  }
+  if (WebWidgetClient* client = widget->Client())
+    is_pointer_locked = client->IsPointerLocked();
 
   if (is_pointer_locked &&
       WebInputEvent::IsMouseEventType(input_event.GetType())) {
-    MainFrameImpl()->FrameWidgetImpl()->PointerLockMouseEvent(coalesced_event);
+    widget->PointerLockMouseEvent(coalesced_event);
     return WebInputEventResult::kHandledSystem;
   }
 
@@ -2377,16 +2378,12 @@ WebInputEventResult WebViewImpl::HandleInputEvent(
     }
   }
 
+  widget->NotifyInputObservers(coalesced_event);
+
   // Notify the focus frame of the input. Note that the other frames are not
   // notified as input is only handled by the focused frame.
   Frame* frame = FocusedCoreFrame();
   if (auto* local_frame = DynamicTo<LocalFrame>(frame)) {
-    if (local_frame->View() && local_frame->View()
-                                   ->GetPaintTimingDetector()
-                                   .NeedToNotifyInputOrScroll()) {
-      local_frame->View()->GetPaintTimingDetector().NotifyInputEvent(
-          input_event.GetType());
-    }
     if (auto* content_capture_manager =
             local_frame->LocalFrameRoot().GetContentCaptureManager()) {
       content_capture_manager->NotifyInputEvent(input_event.GetType(),

third_party/blink/renderer/core/frame/web_frame_widget_base.cc

@@ -53,6 +53,7 @@
 #include "third_party/blink/renderer/core/page/focus_controller.h"
 #include "third_party/blink/renderer/core/page/page.h"
 #include "third_party/blink/renderer/core/page/pointer_lock_controller.h"
+#include "third_party/blink/renderer/core/paint/paint_timing_detector.h"
 #include "third_party/blink/renderer/core/scroll/scrollbar_theme.h"
 #include "third_party/blink/renderer/platform/graphics/animation_worklet_mutator_dispatcher_impl.h"
 #include "third_party/blink/renderer/platform/graphics/compositor_mutator_client.h"
@@ -2299,4 +2300,21 @@ void WebFrameWidgetBase::WasShown(bool was_evicted) {
   }
 }
 
+void WebFrameWidgetBase::NotifyInputObservers(
+    const WebCoalescedInputEvent& coalesced_event) {
+  LocalFrame* frame = FocusedLocalFrameInWidget();
+  if (!frame)
+    return;
+
+  LocalFrameView* frame_view = frame->View();
+  if (!frame_view)
+    return;
+
+  const WebInputEvent& input_event = coalesced_event.Event();
+  auto& paint_timing_detector = frame_view->GetPaintTimingDetector();
+
+  if (paint_timing_detector.NeedToNotifyInputOrScroll())
+    paint_timing_detector.NotifyInputEvent(input_event.GetType());
+}
+
 }  // namespace blink

third_party/blink/renderer/core/frame/web_frame_widget_base.h

@@ -607,6 +607,11 @@ class CORE_EXPORT WebFrameWidgetBase
   void NotifyPageScaleFactorChanged(float page_scale_factor,
                                     bool is_pinch_gesture_active);
 
+  // Helper for notifying frame-level objects that care about input events.
+  // TODO: With some effort, this could be folded into a common implementation
+  // of WebViewImpl::HandleInputEvent and WebFrameWidgetImpl::HandleInputEvent.
+  void NotifyInputObservers(const WebCoalescedInputEvent& coalesced_event);
+
   // A copy of the web drop data object we received from the browser.
   Member<DataObject> current_drag_data_;
 

third_party/blink/renderer/core/frame/web_frame_widget_impl.cc

@@ -490,6 +490,8 @@ WebInputEventResult WebFrameWidgetImpl::HandleInputEvent(
     return WebInputEventResult::kHandledSystem;
   }
 
+  NotifyInputObservers(coalesced_event);
+
   if (mouse_capture_element_ &&
       WebInputEvent::IsMouseEventType(input_event.GetType())) {
     TRACE_EVENT1("input", "captured mouse event", "type",

third_party/blink/renderer/core/frame/web_frame_widget_impl.h

@@ -67,6 +67,11 @@ class WebMouseEvent;
 class WebMouseWheelEvent;
 class WebFrameWidgetImpl;
 
+// Implements WebFrameWidget for a child local root frame (OOPIF). This object
+// is created in the child renderer and attached to the OOPIF's WebLocalFrame.
+//
+// For the main frame's WebFrameWidget implementation, see WebViewFrameWidget.
+//
 class WebFrameWidgetImpl final : public WebFrameWidgetBase,
                                  public PageWidgetEventHandler {
  public: