Handling new frames and frame navigations with find-in-page during a find session.

content/browser/find_request_manager.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 "content/browser/find_request_manager.h"
 
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/common/input_messages.h"
@@ skipping 133 matching lines @@
   DCHECK(CheckFrame(rfh));
 
   // Update the stored find results.
 
   DCHECK_GE(number_of_matches, -1);
   DCHECK_GE(active_match_ordinal, -1);
 
   // Check for an update to the number of matches.
   if (number_of_matches != -1) {
     DCHECK_GE(number_of_matches, 0);
-    // Increment the global number of matches by the number of additional
-    // matches found for this frame.
     auto matches_per_frame_it = matches_per_frame_.find(rfh);
-    number_of_matches_ += number_of_matches - matches_per_frame_it->second;
-    matches_per_frame_it->second = number_of_matches;
+    if (int matches_delta = number_of_matches - matches_per_frame_it->second) {
+      // Increment the global number of matches by the number of additional
+      // matches found for this frame.
+      number_of_matches_ += matches_delta;
+      matches_per_frame_it->second = number_of_matches;
+
+      // The active match ordinal may need updating since the number of matches
+      // before the active match may have changed.
+      if (rfh != active_frame_)
+        UpdateActiveMatchOrdinal();
+    }
   }
 
   // Check for an update to the selection rect.
   if (!selection_rect.IsEmpty())
     selection_rect_ = selection_rect;
 
   // Check for an update to the active match ordinal.
   if (active_match_ordinal > 0) {
     if (rfh == active_frame_) {
       active_match_ordinal_ +=
@@ skipping 170 matching lines @@
     // New version of rects has been received, so update the data.
     match_rects_.frame_rects[rfh] = FrameRects(rects, version);
     ++match_rects_.known_version;
   }
   if (!active_rect.IsEmpty())
     match_rects_.active_rect = active_rect;
   RemoveFindMatchRectsPendingReply(rfh);
 }
 #endif
 
+void FindRequestManager::DidFinishLoad(RenderFrameHost* rfh,
+                                       const GURL& validated_url) {
+  if (current_session_id_ == kInvalidId)
+    return;
+
+  RemoveFrame(rfh);
+  AddFrame(rfh, true /* force */);
+}
+
 void FindRequestManager::RenderFrameDeleted(RenderFrameHost* rfh) {
   RemoveFrame(rfh);
 }
 
 void FindRequestManager::RenderFrameHostChanged(RenderFrameHost* old_host,
                                                 RenderFrameHost* new_host) {
   RemoveFrame(old_host);
 }
 
 void FindRequestManager::FrameDeleted(RenderFrameHost* rfh) {
@@ skipping 39 matching lines @@
 
     SendFindIPC(request, target_rfh);
     current_request_ = request;
     pending_active_match_ordinal_ = true;
     return;
   }
 
   // This is an initial find operation.
   Reset(request);
   for (FrameTreeNode* node : contents_->GetFrameTree()->Nodes())
-    AddFrame(node->current_frame_host());
+    AddFrame(node->current_frame_host(), false /* force */);
 }
 
 void FindRequestManager::AdvanceQueue(int request_id) {
   if (find_request_queue_.empty() ||
       request_id != find_request_queue_.front().id) {
     return;
   }
 
   find_request_queue_.pop();
   if (!find_request_queue_.empty())
@@ skipping 58 matching lines @@
       // |matches_only|.
       return node->current_frame_host();
     }
     if (wrap && node->current_frame_host() == from_rfh)
       return nullptr;
   }
 
   return nullptr;
 }
 
-void FindRequestManager::AddFrame(RenderFrameHost* rfh) {
+void FindRequestManager::AddFrame(RenderFrameHost* rfh, bool force) {
   if (!rfh || !rfh->IsRenderFrameLive())
     return;
 
-  // A frame that is already being searched should not be added again.
-  DCHECK(!CheckFrame(rfh));
+  // A frame that is already being searched should not normally be added again.
+  DCHECK(force || !CheckFrame(rfh));
 
   matches_per_frame_[rfh] = 0;
 
   FindRequest request = current_request_;
   request.id = current_session_id_;
   request.options.findNext = false;
+  request.options.force = force;
   SendFindIPC(request, rfh);
 }
 
 bool FindRequestManager::CheckFrame(RenderFrameHost* rfh) const {
   return rfh && matches_per_frame_.count(rfh);
 }
 
 void FindRequestManager::UpdateActiveMatchOrdinal() {
   active_match_ordinal_ = 0;
 
@@ skipping 12 matching lines @@
                            false /* wrap */)) != nullptr) {
     active_match_ordinal_ += matches_per_frame_[frame];
   }
   active_match_ordinal_ += relative_active_match_ordinal_;
 }
 
 void FindRequestManager::FinalUpdateReceived(int request_id,
                                              RenderFrameHost* rfh) {
   if (!number_of_matches_ ||
       (active_match_ordinal_ && !pending_active_match_ordinal_) ||
-      request_id != current_request_.id) {
+      pending_find_next_reply_) {
     // All the find results for |request_id| are in and ready to report. Note
     // that |final_update| will be set to false if there are still pending
     // replies expected from the initial find request.
     NotifyFindReply(request_id,
                     pending_initial_replies_.empty() /* final_update */);
     AdvanceQueue(request_id);
     return;
   }
 
   // There are matches, but no active match was returned, so another find next
   // request must be sent.
 
   RenderFrameHost* target_rfh;
-  if (current_request_.options.findNext) {
+  if (request_id == current_request_.id && current_request_.options.findNext) {
     // If this was a find next operation, then the active match will be in the
     // next frame with matches after this one.
     target_rfh = Traverse(rfh,
                           current_request_.options.forward,
                           true /* matches_only */,
                           true /* wrap */);
   } else if ((target_rfh = contents_->GetFocusedFrame()) != nullptr) {
     // Otherwise, if there is a focused frame, then the active match will be in
     // the next frame with matches after that one.
     target_rfh = Traverse(target_rfh,
@@ skipping 63 matching lines @@
             aggregate_rects.end(), frame_rects.begin(), frame_rects.end());
       }
     }
     contents_->NotifyFindMatchRectsReply(
         match_rects_.known_version, aggregate_rects, match_rects_.active_rect);
   }
 }
 #endif
 
 }  // namespace content