Fix find-in-page re-scope across frame boundaries.

content/browser/find_request_manager_browsertest.cc

 // Copyright 2016 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 "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/test/content_browser_test_utils_internal.h"
 #include "net/dns/mock_host_resolver.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 
 namespace content {
 
 namespace {
 
 const int kInvalidId = -1;
 
 // The results of a find request.
 struct FindResults {
-  int request_id = kInvalidId;
-  int number_of_matches = 0;
-  int active_match_ordinal = 0;
+  FindResults(int request_id, int number_of_matches, int active_match_ordinal)
+      : request_id(request_id),
+        number_of_matches(number_of_matches),
+        active_match_ordinal(active_match_ordinal) {}
+  FindResults() : FindResults(kInvalidId, 0, 0) {}
+
+  int request_id;
+  int number_of_matches;
+  int active_match_ordinal;
 };
 
 }  // namespace
 
 class TestWebContentsDelegate : public WebContentsDelegate {
  public:
   TestWebContentsDelegate()
       : last_request_id_(kInvalidId),
         last_finished_request_id_(kInvalidId),
         next_reply_received_(false),
+        record_replies_(false),
         waiting_for_(NOTHING) {}
   ~TestWebContentsDelegate() override {}
 
   // Returns the current find results.
-  FindResults GetFindResults() {
+  const FindResults& GetFindResults() const {
     return current_results_;
   }
 
   // Waits for all pending replies to be received.
   void WaitForFinalReply() {
     if (last_finished_request_id_ >= last_request_id_)
       return;
 
     WaitFor(FINAL_REPLY);
   }
@@ skipping 14 matching lines @@
   void MarkNextReply() {
     next_reply_received_ = false;
   }
 
   // Called when a new find request is issued, so the delegate knows the last
   // request ID.
   void UpdateLastRequest(int request_id) {
     last_request_id_ = request_id;
   }
 
+  // From when this function is called, all replies coming in via FindReply()
+  // will be recorded. These replies can be retrieved via GetReplyRecord().
+  void StartReplyRecord() {
+    reply_record_.clear();
+    record_replies_ = true;
+  }
+
+  // Retreives the results from the find replies recorded since the last call to
+  // StartReplyRecord(). Calling this function also stops the recording new find
+  // replies.
+  const std::vector<FindResults>& GetReplyRecord() {
+    record_replies_ = false;
+    return reply_record_;
+  }
+
 #if defined(OS_ANDROID)
   // Waits for all of the find match rects to be received.
   void WaitForMatchRects() {
     WaitFor(MATCH_RECTS);
   }
 
   const std::vector<gfx::RectF>& find_match_rects() const {
     return find_match_rects_;
   }
 
@@ skipping 12 matching lines @@
 #endif
   };
 
   // WebContentsDelegate override.
   void FindReply(WebContents* web_contents,
                  int request_id,
                  int number_of_matches,
                  const gfx::Rect& selection_rect,
                  int active_match_ordinal,
                  bool final_update) override {
+    if (record_replies_) {
+      reply_record_.emplace_back(
+          request_id, number_of_matches, active_match_ordinal);
+    }
+
     // Update the current results.
     if (request_id > current_results_.request_id)
       current_results_.request_id = request_id;
     if (number_of_matches != -1)
       current_results_.number_of_matches = number_of_matches;
     if (active_match_ordinal != -1)
       current_results_.active_match_ordinal = active_match_ordinal;
 
     if (!final_update)
       return;
@@ skipping 59 matching lines @@
 
   // The ID of the last find request issued.
   int last_request_id_;
 
   // The ID of the last find request to finish (all replies received).
   int last_finished_request_id_;
 
   // Indicates whether the next reply after MarkNextReply() has been received.
   bool next_reply_received_;
 
+  // Indicates whether the find results from incoming find replies are currently
+  // being recorded.
+  bool record_replies_;
+
+  // A record of all find replies that have come in via FindReply() since
+  // StartReplyRecor() was last called.
+  std::vector<FindResults> reply_record_;
+
   // Indicates what |message_loop_runner_| is waiting for, if anything.
   WaitingFor waiting_for_;
 
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebContentsDelegate);
 };
 
 class FindRequestManagerTest : public ContentBrowserTest,
                                public testing::WithParamInterface<bool> {
@@ skipping 210 matching lines @@
   EXPECT_EQ(last_request_id() % results.number_of_matches,
             results.active_match_ordinal);
 }
 
 // Tests removing a frame during a find session.
 IN_PROC_BROWSER_TEST_P(FindRequestManagerTest, MAYBE(RemoveFrame)) {
   LoadMultiFramePage(2 /* height */, GetParam() /* cross_process */);
 
   blink::WebFindOptions options;
   Find("result", options);
+  delegate()->WaitForFinalReply();
   options.findNext = true;
   options.forward = false;
   Find("result", options);
   Find("result", options);
   Find("result", options);
   Find("result", options);
   Find("result", options);
   delegate()->WaitForFinalReply();
 
   FindResults results = delegate()->GetFindResults();
@@ skipping 51 matching lines @@
 
   Find("result", options);
   delegate()->WaitForFinalReply();
 
   results = delegate()->GetFindResults();
   EXPECT_EQ(last_request_id(), results.request_id);
   EXPECT_EQ(8, results.number_of_matches);
   EXPECT_EQ(4, results.active_match_ordinal);
 }
 
+IN_PROC_BROWSER_TEST_F(FindRequestManagerTest, MAYBE(FindInPage_Issue627799)) {
+  LoadAndWait("/find_in_long_page.html");
+
+  blink::WebFindOptions options;
+  Find("42", options);
+  delegate()->WaitForFinalReply();
+
+  FindResults results = delegate()->GetFindResults();
+  EXPECT_EQ(last_request_id(), results.request_id);
+  EXPECT_EQ(970, results.number_of_matches);
+  EXPECT_EQ(1, results.active_match_ordinal);
+
+  delegate()->StartReplyRecord();
+  options.findNext = true;
+  options.forward = false;
+  Find("42", options);
+  delegate()->WaitForFinalReply();
+
+  // This is the crux of the issue that this test guards against. Searching
+  // across the frame boundary should not cause the frame to be re-scoped. If
+  // the re-scope occurs, then we will see the number of matches change in one
+  // of the recorded find replies.
+  for (auto& reply : delegate()->GetReplyRecord()) {
+    EXPECT_EQ(last_request_id(), reply.request_id);
+    EXPECT_TRUE(reply.number_of_matches == kInvalidId ||
+                reply.number_of_matches == results.number_of_matches);
+  }
+}
+
 #if defined(OS_ANDROID)
 // Tests requesting find match rects.
 IN_PROC_BROWSER_TEST_F(FindRequestManagerTest, MAYBE(FindMatchRects)) {
   LoadAndWait("/find_in_page.html");
 
   blink::WebFindOptions default_options;
   Find("result", default_options);
   delegate()->WaitForFinalReply();
   EXPECT_EQ(19, delegate()->GetFindResults().number_of_matches);
 
@@ skipping 93 matching lines @@
     delegate()->MarkNextReply();
     contents()->ActivateNearestFindResult(
         rects[order[i]].CenterPoint().x(), rects[order[i]].CenterPoint().y());
     delegate()->WaitForNextReply();
     EXPECT_EQ(order[i] + 1, delegate()->GetFindResults().active_match_ordinal);
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content