[Display Locking]: Unlock active find-in-page match

Activatable-locked subtrees are counted in total find-in-page matches,
but we currently still skip over them for active match navigation
(the specially-highlighted match). This CL makes us unlock/commit
relevant locked elements needed to show the active match (the ancestors
of the nodes in the active match range). This includes sending the
"beforeactivate" event to those elements.

Bug: 882663
Change-Id: I743faf1391ff0157fdca12a1cbba51fd29a680c9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1491069
Commit-Queue: Rakina Zata Amni <rakina@chromium.org>
Reviewed-by: vmpstr <vmpstr@chromium.org>
Reviewed-by: Kent Tamura <tkent@chromium.org>
Reviewed-by: Yoshifumi Inoue <yosin@chromium.org>
Reviewed-by: Fergal Daly <fergal@chromium.org>
Cr-Commit-Position: refs/heads/master@{#638467}

third_party/blink/renderer/core/BUILD.gn

@@ -1813,6 +1813,7 @@ jumbo_source_set("unit_tests") {
     "css/threaded/text_renderer_threaded_test.cc",
     "display_lock/display_lock_budget_test.cc",
     "display_lock/display_lock_context_test.cc",
+    "display_lock/display_lock_utilities_test.cc",
     "dom/attr_test.cc",
     "dom/document_statistics_collector_test.cc",
     "dom/document_test.cc",

third_party/blink/renderer/core/display_lock/BUILD.gn

@@ -12,6 +12,8 @@ blink_core_sources("display_lock") {
     "display_lock_budget.h",
     "display_lock_context.cc",
     "display_lock_context.h",
+    "display_lock_utilities.cc",
+    "display_lock_utilities.h",
     "strict_yielding_display_lock_budget.cc",
     "strict_yielding_display_lock_budget.h",
     "unyielding_display_lock_budget.cc",

third_party/blink/renderer/core/display_lock/display_lock_context_test.cc

@@ -5,7 +5,9 @@
 #include "third_party/blink/renderer/core/display_lock/display_lock_context.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
 #include "third_party/blink/renderer/core/display_lock/display_lock_options.h"
+#include "third_party/blink/renderer/core/editing/ephemeral_range.h"
 #include "third_party/blink/renderer/core/editing/finder/text_finder.h"
+#include "third_party/blink/renderer/core/editing/visible_units.h"
 #include "third_party/blink/renderer/core/frame/find_in_page.h"
 #include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
 #include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"
@@ -18,7 +20,10 @@ namespace {
 class DisplayLockTestFindInPageClient : public mojom::blink::FindInPageClient {
  public:
   DisplayLockTestFindInPageClient()
-      : find_results_are_ready_(false), count_(-1), binding_(this) {}
+      : find_results_are_ready_(false),
+        active_index_(-1),
+        count_(-1),
+        binding_(this) {}
 
   ~DisplayLockTestFindInPageClient() override = default;
 
@@ -41,19 +46,29 @@ class DisplayLockTestFindInPageClient : public mojom::blink::FindInPageClient {
                       const WebRect& active_match_rect,
                       int active_match_ordinal,
                       mojom::blink::FindMatchUpdateType final_update) final {
+    active_match_rect_ = active_match_rect;
+    active_index_ = active_match_ordinal;
     find_results_are_ready_ =
         (final_update == mojom::blink::FindMatchUpdateType::kFinalUpdate);
   }
 
   bool FindResultsAreReady() const { return find_results_are_ready_; }
   int Count() const { return count_; }
+  int ActiveIndex() const { return active_index_; }
+  IntRect ActiveMatchRect() const { return active_match_rect_; }
+
   void Reset() {
     find_results_are_ready_ = false;
     count_ = -1;
+    active_index_ = -1;
+    active_match_rect_ = IntRect();
   }
 
  private:
+  IntRect active_match_rect_;
   bool find_results_are_ready_;
+  int active_index_;
+
   int count_;
   mojo::Binding<mojom::blink::FindInPageClient> binding_;
 };
@@ -342,6 +357,7 @@ TEST_F(DisplayLockContextTest,
   test::RunPendingTasks();
   EXPECT_TRUE(client.FindResultsAreReady());
   EXPECT_EQ(1, client.Count());
+  EXPECT_EQ(1, client.ActiveIndex());
   client.Reset();
 
   // Check if the result is correct if we update the contents.
@@ -353,7 +369,10 @@ TEST_F(DisplayLockContextTest,
   test::RunPendingTasks();
   EXPECT_TRUE(client.FindResultsAreReady());
   EXPECT_EQ(0, client.Count());
+  EXPECT_EQ(-1, client.ActiveIndex());
   client.Reset();
+  // Assert the container is still locked.
+  EXPECT_TRUE(element->GetDisplayLockContext()->IsLocked());
 
   // Check if the result is correct if we have non-activatable lock.
   element->SetInnerHTMLFromString(
@@ -383,16 +402,34 @@ TEST_F(DisplayLockContextTest,
   EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 4);
   EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 2);
 
+  EXPECT_TRUE(element->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(activatable->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(non_activatable->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(nested_non_activatable->GetDisplayLockContext()->IsLocked());
+
   find_in_page->Find(current_id++, "testing", find_options->Clone());
   EXPECT_FALSE(client.FindResultsAreReady());
   test::RunPendingTasks();
   EXPECT_TRUE(client.FindResultsAreReady());
   EXPECT_EQ(2, client.Count());
+  EXPECT_EQ(1, client.ActiveIndex());
   client.Reset();
 
+  UpdateAllLifecyclePhasesForTest();
+  // The locked container should be unlocked, since the match is inside that
+  // container ("testing1" inside the div).
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 3);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 2);
+  EXPECT_FALSE(element->GetDisplayLockContext()->IsLocked());
+  // Since the active match isn't in any locked container, they need to be
+  // locked.
+  EXPECT_TRUE(activatable->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(non_activatable->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(nested_non_activatable->GetDisplayLockContext()->IsLocked());
+
   // Check if the result is correct if we update style.
   activatable->setAttribute("style", "contain: style layout; display: none;");
-  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 4);
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 3);
   EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 2);
 
   find_in_page->Find(current_id++, "testing", find_options->Clone());
@@ -400,6 +437,7 @@ TEST_F(DisplayLockContextTest,
   test::RunPendingTasks();
   EXPECT_TRUE(client.FindResultsAreReady());
   EXPECT_EQ(1, client.Count());
+  EXPECT_EQ(1, client.ActiveIndex());
   client.Reset();
 
   // Now commit all the locks and ensure we can find.
@@ -421,7 +459,162 @@ TEST_F(DisplayLockContextTest,
   test::RunPendingTasks();
   EXPECT_TRUE(client.FindResultsAreReady());
   EXPECT_EQ(2, client.Count());
+}
+
+// Tests find-in-page active match navigation (find next/previous).
+TEST_F(DisplayLockContextTest, FindInPageNavigateLockedMatches) {
+  ResizeAndFocus();
+  SetHtmlInnerHTML(R"HTML(
+    <style>
+    div {
+      width: 100px;
+      height: 100px;
+      contain: content;
+    }
+    </style>
+    <body>
+      <div id="container">
+        <div id="one">result</div>
+        <div id="two"><b>r</b>esult</div>
+        <div id="three">r<i>esul</i>t</div>
+      </div>
+    </body>
+  )HTML");
+
+  WebString search_text(String("result"));
+  auto* find_in_page = GetFindInPage();
+  ASSERT_TRUE(find_in_page);
+
+  DisplayLockTestFindInPageClient client;
+  client.SetFrame(LocalMainFrame());
+
+  DisplayLockOptions options;
+  options.setActivatable(true);
+
+  // Lock the children and container.
+  auto* container = GetDocument().getElementById("container");
+  auto* div_one = GetDocument().getElementById("one");
+  auto* div_two = GetDocument().getElementById("two");
+  auto* div_three = GetDocument().getElementById("three");
+  auto* script_state = ToScriptStateForMainWorld(GetDocument().GetFrame());
+  {
+    ScriptState::Scope scope(script_state);
+    container->getDisplayLockForBindings()->acquire(script_state, &options);
+    div_one->getDisplayLockForBindings()->acquire(script_state, &options);
+    div_two->getDisplayLockForBindings()->acquire(script_state, &options);
+    div_three->getDisplayLockForBindings()->acquire(script_state, &options);
+  }
+  UpdateAllLifecyclePhasesForTest();
+
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 4);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 0);
+
+  auto find_options = mojom::blink::FindOptions::New();
+  find_options->run_synchronously_for_testing = true;
+  find_options->find_next = false;
+  find_options->forward = true;
+
+  int current_id = 123;
+
+  // Find should activate "result" number 1 in "#one".
+  find_in_page->Find(current_id++, search_text, find_options->Clone());
+  test::RunPendingTasks();
+  EXPECT_EQ(3, client.Count());
+  EXPECT_EQ(1, client.ActiveIndex());
+
+  EphemeralRange range_one = EphemeralRange::RangeOfContents(*div_one);
+  ASSERT_FALSE(range_one.IsNull());
+  EXPECT_EQ(ComputeTextRect(range_one), client.ActiveMatchRect());
+
+  UpdateAllLifecyclePhasesForTest();
+  // |div_one| and the container should be unlocked.
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 2);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 0);
+  EXPECT_FALSE(container->GetDisplayLockContext()->IsLocked());
+  EXPECT_FALSE(div_one->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(div_two->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(div_three->GetDisplayLockContext()->IsLocked());
+
+  // Find next should activate "result" number 2 in "#two".
+  client.Reset();
+  find_options->find_next = true;
+  find_in_page->Find(current_id++, search_text, find_options->Clone());
+  test::RunPendingTasks();
+  EXPECT_EQ(3, client.Count());
+  EXPECT_EQ(2, client.ActiveIndex());
+
+  EphemeralRange range_two = EphemeralRange::RangeOfContents(*div_two);
+  ASSERT_FALSE(range_one.IsNull());
+  EXPECT_EQ(ComputeTextRect(range_two), client.ActiveMatchRect());
+
+  UpdateAllLifecyclePhasesForTest();
+  // |div_two| should be unlocked.
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 1);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 0);
+  EXPECT_FALSE(container->GetDisplayLockContext()->IsLocked());
+  EXPECT_FALSE(div_one->GetDisplayLockContext()->IsLocked());
+  EXPECT_FALSE(div_two->GetDisplayLockContext()->IsLocked());
+  EXPECT_TRUE(div_three->GetDisplayLockContext()->IsLocked());
+
+  // Find next should activate "result" number 3 in "#three".
+  client.Reset();
+  find_options->find_next = true;
+  find_in_page->Find(current_id++, search_text, find_options->Clone());
+  test::RunPendingTasks();
+  EXPECT_EQ(3, client.Count());
+  EXPECT_EQ(3, client.ActiveIndex());
+
+  EphemeralRange range_three = EphemeralRange::RangeOfContents(*div_three);
+  ASSERT_FALSE(range_three.IsNull());
+  EXPECT_EQ(ComputeTextRect(range_three), client.ActiveMatchRect());
+
+  UpdateAllLifecyclePhasesForTest();
+  // |div_three| should be unlocked.
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 0);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 0);
+  EXPECT_FALSE(container->GetDisplayLockContext()->IsLocked());
+  EXPECT_FALSE(div_one->GetDisplayLockContext()->IsLocked());
+  EXPECT_FALSE(div_two->GetDisplayLockContext()->IsLocked());
+  EXPECT_FALSE(div_three->GetDisplayLockContext()->IsLocked());
+
+  // Lock them again, now making |div_two| non-activatable.
+  {
+    ScriptState::Scope scope(script_state);
+    div_one->getDisplayLockForBindings()->acquire(script_state, &options);
+    div_two->getDisplayLockForBindings()->acquire(script_state, nullptr);
+    div_three->getDisplayLockForBindings()->acquire(script_state, &options);
+  }
+  UpdateAllLifecyclePhasesForTest();
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 3);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 1);
+
+  // Find result in #one.
+  find_in_page->ClearActiveFindMatch();
   client.Reset();
+  find_options->find_next = false;
+  find_in_page->Find(current_id++, search_text, find_options->Clone());
+  test::RunPendingTasks();
+  EXPECT_EQ(2, client.Count());
+  EXPECT_EQ(1, client.ActiveIndex());
+  EXPECT_EQ(ComputeTextRect(range_one), client.ActiveMatchRect());
+
+  // Going forward from #one would go to #three.
+  client.Reset();
+  find_options->find_next = true;
+  find_in_page->Find(current_id++, search_text, find_options->Clone());
+  test::RunPendingTasks();
+  EXPECT_EQ(2, client.Count());
+  EXPECT_EQ(2, client.ActiveIndex());
+  EXPECT_EQ(ComputeTextRect(range_three), client.ActiveMatchRect());
+
+  // Going backwards from #three would go to #one.
+  client.Reset();
+  find_options->forward = false;
+  find_in_page->Find(current_id++, search_text, find_options->Clone());
+  test::RunPendingTasks();
+  EXPECT_EQ(2, client.Count());
+  EXPECT_EQ(1, client.ActiveIndex());
+  EXPECT_EQ(ComputeTextRect(range_one), client.ActiveMatchRect());
 }
 
 TEST_F(DisplayLockContextTest, CallUpdateStyleAndLayoutAfterChange) {

third_party/blink/renderer/core/display_lock/display_lock_utilities.cc

+// Copyright 2019 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 "third_party/blink/renderer/core/display_lock/display_lock_utilities.h"
+
+#include "third_party/blink/renderer/core/display_lock/display_lock_context.h"
+#include "third_party/blink/renderer/core/dom/element.h"
+#include "third_party/blink/renderer/core/dom/flat_tree_traversal.h"
+#include "third_party/blink/renderer/core/dom/node.h"
+#include "third_party/blink/renderer/core/dom/text.h"
+#include "third_party/blink/renderer/core/editing/editing_boundary.h"
+#include "third_party/blink/renderer/core/editing/editing_utilities.h"
+
+namespace blink {
+
+bool DisplayLockUtilities::ActivateFindInPageMatchRangeIfNeeded(
+    const EphemeralRangeInFlatTree& range) {
+  if (!RuntimeEnabledFeatures::DisplayLockingEnabled())
+    return false;
+  DCHECK(!range.IsNull());
+  DCHECK(!range.IsCollapsed());
+  if (range.GetDocument().LockedDisplayLockCount() ==
+      range.GetDocument().ActivationBlockingDisplayLockCount())
+    return false;
+  // Find-in-page matches can't span multiple block-level elements (because the
+  // text will be broken by newlines between blocks), so first we find the
+  // block-level element which contains the match.
+  // This means we only need to traverse up from one node in the range, in this
+  // case we are traversing from the start position of the range.
+  Element* enclosing_block =
+      EnclosingBlock(range.StartPosition(), kCannotCrossEditingBoundary);
+  DCHECK(enclosing_block);
+  DCHECK_EQ(enclosing_block,
+            EnclosingBlock(range.EndPosition(), kCannotCrossEditingBoundary));
+  const HeapVector<Member<Element>>& elements_to_activate =
+      ActivatableLockedInclusiveAncestors(*enclosing_block);
+  for (Element* element : elements_to_activate) {
+    // We save the elements to a vector and go through & activate them one by
+    // one like this because the DOM structure might change due to running event
+    // handlers of the beforeactivate event.
+    element->ActivateDisplayLockIfNeeded();
+  }
+  return !elements_to_activate.IsEmpty();
+}
+
+const HeapVector<Member<Element>>
+DisplayLockUtilities::ActivatableLockedInclusiveAncestors(Element& element) {
+  HeapVector<Member<Element>> elements_to_activate;
+  for (Node& ancestor : FlatTreeTraversal::InclusiveAncestorsOf(element)) {
+    if (!ancestor.IsElementNode())
+      continue;
+    if (auto* context = ToElement(ancestor).GetDisplayLockContext()) {
+      DCHECK(context->IsActivatable());
+      if (!context->IsLocked())
+        continue;
+      elements_to_activate.push_back(&ToElement(ancestor));
+    }
+  }
+  return elements_to_activate;
+}
+
+}  // namespace blink

third_party/blink/renderer/core/display_lock/display_lock_utilities.h

+// Copyright 2019 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 THIRD_PARTY_BLINK_RENDERER_CORE_DISPLAY_LOCK_DISPLAY_LOCK_UTILITIES_H_
+#define THIRD_PARTY_BLINK_RENDERER_CORE_DISPLAY_LOCK_DISPLAY_LOCK_UTILITIES_H_
+
+#include "third_party/blink/renderer/core/core_export.h"
+#include "third_party/blink/renderer/core/editing/ephemeral_range.h"
+#include "third_party/blink/renderer/platform/wtf/allocator.h"
+
+namespace blink {
+
+// Static utility class for display-locking related helpers.
+class CORE_EXPORT DisplayLockUtilities {
+  STATIC_ONLY(DisplayLockUtilities);
+
+ public:
+  // Activates all the nodes within a find-in-page match |range|.
+  // Returns true if at least one node gets activated.
+  // See: http://bit.ly/2RXULVi, "beforeactivate Event" part.
+  static bool ActivateFindInPageMatchRangeIfNeeded(
+      const EphemeralRangeInFlatTree& range);
+
+  // Returns activatable-locked inclusive ancestors of |element|.
+  // Note that this function will have failing DCHECKs if |element| is inside a
+  // non-activatable locked subtree (e.g. at least one ancestor is not
+  // activatable-locked).
+  static const HeapVector<Member<Element>> ActivatableLockedInclusiveAncestors(
+      Element& element);
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_DISPLAY_LOCK_DISPLAY_LOCK_UTILITIES_H_

third_party/blink/renderer/core/display_lock/display_lock_utilities_test.cc

+// Copyright 2019 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 "third_party/blink/renderer/core/display_lock/display_lock_utilities.h"
+#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
+#include "third_party/blink/renderer/core/display_lock/display_lock_context.h"
+#include "third_party/blink/renderer/core/display_lock/display_lock_options.h"
+#include "third_party/blink/renderer/core/dom/shadow_root.h"
+#include "third_party/blink/renderer/core/testing/page_test_base.h"
+
+namespace blink {
+
+class DisplayLockUtilitiesTest : public PageTestBase {
+ public:
+  void SetUp() override {
+    PageTestBase::SetUp(IntSize());
+    RuntimeEnabledFeatures::SetDisplayLockingEnabled(true);
+  }
+
+  void TearDown() override {
+    PageTestBase::TearDown();
+    RuntimeEnabledFeatures::SetDisplayLockingEnabled(false);
+  }
+};
+
+TEST_F(DisplayLockUtilitiesTest, ActivatableLockedInclusiveAncestors) {
+  SetBodyInnerHTML(R"HTML(
+    <style>
+      div {
+        contain: style layout;
+      }
+    </style>
+    <div id='outer'>
+      <div id='innerA'>
+        <div id='innermost'>text_node</div>
+      </div>
+      <div id='innerB'></div>
+    </div>
+  )HTML");
+  Element& outer = *GetDocument().getElementById("outer");
+  Element& inner_a = *GetDocument().getElementById("innerA");
+  Element& inner_b = *GetDocument().getElementById("innerB");
+  Element& innermost = *GetDocument().getElementById("innermost");
+  ShadowRoot& shadow_root =
+      inner_b.AttachShadowRootInternal(ShadowRootType::kOpen);
+  shadow_root.SetInnerHTMLFromString("<div id='shadowDiv'>shadow!</div>");
+  Element& shadow_div = *shadow_root.getElementById("shadowDiv");
+
+  auto* script_state = ToScriptStateForMainWorld(GetDocument().GetFrame());
+
+  DisplayLockOptions options;
+  options.setActivatable(true);
+  // Lock outer with activatable flag.
+  {
+    ScriptState::Scope scope(script_state);
+    outer.getDisplayLockForBindings()->acquire(script_state, &options);
+  }
+
+  UpdateAllLifecyclePhasesForTest();
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 1);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 0);
+  // Querying from every element gives |outer|.
+  HeapVector<Member<Element>> result_for_outer =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(outer);
+  EXPECT_EQ(result_for_outer.size(), 1u);
+  EXPECT_EQ(result_for_outer.at(0), outer);
+
+  HeapVector<Member<Element>> result_for_inner_a =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(inner_a);
+  EXPECT_EQ(result_for_inner_a.size(), 1u);
+  EXPECT_EQ(result_for_inner_a.at(0), outer);
+
+  HeapVector<Member<Element>> result_for_innermost =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(innermost);
+  EXPECT_EQ(result_for_innermost.size(), 1u);
+  EXPECT_EQ(result_for_innermost.at(0), outer);
+
+  HeapVector<Member<Element>> result_for_inner_b =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(inner_b);
+  EXPECT_EQ(result_for_inner_b.size(), 1u);
+  EXPECT_EQ(result_for_inner_b.at(0), outer);
+
+  HeapVector<Member<Element>> result_for_shadow_div =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(shadow_div);
+  EXPECT_EQ(result_for_shadow_div.size(), 1u);
+  EXPECT_EQ(result_for_shadow_div.at(0), outer);
+
+  // Lock innermost with activatable flag.
+  {
+    ScriptState::Scope scope(script_state);
+    innermost.getDisplayLockForBindings()->acquire(script_state, &options);
+  }
+
+  UpdateAllLifecyclePhasesForTest();
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 2);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 0);
+
+  result_for_outer =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(outer);
+  EXPECT_EQ(result_for_outer.size(), 1u);
+  EXPECT_EQ(result_for_outer.at(0), outer);
+
+  result_for_inner_a =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(inner_a);
+  EXPECT_EQ(result_for_inner_a.size(), 1u);
+  EXPECT_EQ(result_for_inner_a.at(0), outer);
+
+  result_for_innermost =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(innermost);
+  EXPECT_EQ(result_for_innermost.size(), 2u);
+  EXPECT_EQ(result_for_innermost.at(0), innermost);
+  EXPECT_EQ(result_for_innermost.at(1), outer);
+
+  result_for_inner_b =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(inner_b);
+  EXPECT_EQ(result_for_inner_b.size(), 1u);
+  EXPECT_EQ(result_for_inner_b.at(0), outer);
+
+  result_for_shadow_div =
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(shadow_div);
+  EXPECT_EQ(result_for_shadow_div.size(), 1u);
+  EXPECT_EQ(result_for_shadow_div.at(0), outer);
+
+  // Unlock everything.
+  {
+    ScriptState::Scope scope(script_state);
+    innermost.getDisplayLockForBindings()->commit(script_state);
+    outer.getDisplayLockForBindings()->commit(script_state);
+  }
+
+  UpdateAllLifecyclePhasesForTest();
+  EXPECT_EQ(GetDocument().LockedDisplayLockCount(), 0);
+  EXPECT_EQ(GetDocument().ActivationBlockingDisplayLockCount(), 0);
+
+  EXPECT_EQ(
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(outer).size(),
+      0u);
+  EXPECT_EQ(
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(inner_a).size(),
+      0u);
+  EXPECT_EQ(DisplayLockUtilities::ActivatableLockedInclusiveAncestors(innermost)
+                .size(),
+            0u);
+  EXPECT_EQ(
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(inner_b).size(),
+      0u);
+  EXPECT_EQ(
+      DisplayLockUtilities::ActivatableLockedInclusiveAncestors(shadow_div)
+          .size(),
+      0u);
+}
+
+}  // namespace blink

third_party/blink/renderer/core/editing/finder/text_finder.cc

@@ -37,6 +37,7 @@
 #include "third_party/blink/public/web/web_local_frame_client.h"
 #include "third_party/blink/public/web/web_view_client.h"
 #include "third_party/blink/renderer/core/accessibility/ax_object_cache_base.h"
+#include "third_party/blink/renderer/core/display_lock/display_lock_utilities.h"
 #include "third_party/blink/renderer/core/dom/range.h"
 #include "third_party/blink/renderer/core/dom/shadow_root.h"
 #include "third_party/blink/renderer/core/editing/editor.h"
@@ -74,9 +75,13 @@ void TextFinder::FindMatch::Trace(Visitor* visitor) {
 
 static void ScrollToVisible(Range* match) {
   const Node& first_node = *match->FirstNode();
-  if (RuntimeEnabledFeatures::InvisibleDOMEnabled() &&
-      InvisibleDOM::ActivateRangeIfNeeded(EphemeralRangeInFlatTree(match)))
-    first_node.GetDocument().UpdateStyleAndLayoutIgnorePendingStylesheets();
+  if (RuntimeEnabledFeatures::InvisibleDOMEnabled() ||
+      RuntimeEnabledFeatures::DisplayLockingEnabled()) {
+    const EphemeralRangeInFlatTree range(match);
+    if (InvisibleDOM::ActivateRangeIfNeeded(range) ||
+        DisplayLockUtilities::ActivateFindInPageMatchRangeIfNeeded(range))
+      first_node.GetDocument().UpdateStyleAndLayoutIgnorePendingStylesheets();
+  }
   Settings* settings = first_node.GetDocument().GetSettings();
   bool smooth_find_enabled =
       settings ? settings->GetSmoothScrollForFindEnabled() : false;