Changes to how FindRequestManager reports find results.

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 73 matching lines @@
 FindRequestManager::FindMatchRectsState::~FindMatchRectsState() {}
 #endif
 
 // static
 const int FindRequestManager::kInvalidId = -1;
 
 FindRequestManager::FindRequestManager(WebContentsImpl* web_contents)
     : WebContentsObserver(web_contents),
       contents_(web_contents),
       current_session_id_(kInvalidId),
+      pending_find_next_reply_(nullptr),
       pending_active_match_ordinal_(false),
       number_of_matches_(0),
       active_frame_(nullptr),
       relative_active_match_ordinal_(0),
-      active_match_ordinal_(0) {}
+      active_match_ordinal_(0),
+      last_reported_id_(kInvalidId) {}
 
 FindRequestManager::~FindRequestManager() {}
 
 void FindRequestManager::Find(int request_id,
                               const base::string16& search_text,
                               const blink::WebFindOptions& options) {
   // Every find request must have a unique ID, and these IDs must strictly
   // increase so that newer requests always have greater IDs than older
   // requests.
   DCHECK_GT(request_id, current_request_.id);
@@ skipping 74 matching lines @@
     AdvanceQueue(request_id);
   }
 
   if (!final_update) {
     NotifyFindReply(request_id, false /* final_update */);
     return;
   }
 
   // This is the final update for this frame for the current find operation.
 
-  pending_replies_.erase(rfh);
-  if (request_id == current_session_id_ && !pending_replies_.empty()) {
+  pending_initial_replies_.erase(rfh);
+  if (request_id == current_session_id_ && !pending_initial_replies_.empty()) {
     NotifyFindReply(request_id, false /* final_update */);
     return;
   }
-  DCHECK(request_id == current_session_id_ ||
-         current_request_.options.findNext);
 
   // This is the final update for the current find operation.
-  FinalUpdate(request_id, rfh);
+
+  if (request_id == current_request_.id && request_id != current_session_id_) {
+    DCHECK(current_request_.options.findNext);
+    DCHECK_EQ(pending_find_next_reply_, rfh);
+    pending_find_next_reply_ = nullptr;
+  }
+
+  FinalUpdateReceived(request_id, rfh);
 }
 
 void FindRequestManager::RemoveFrame(RenderFrameHost* rfh) {
   if (current_session_id_ == kInvalidId || !CheckFrame(rfh))
     return;
 
   // If matches are counted for the frame that is being removed, decrement the
   // match total before erasing that entry.
   auto it = matches_per_frame_.find(rfh);
   if (it != matches_per_frame_.end()) {
     number_of_matches_ -= it->second;
     matches_per_frame_.erase(it);
   }
 
   // Update the active match ordinal, since it may have changed.
   if (active_frame_ == rfh) {
     active_frame_ = nullptr;
     relative_active_match_ordinal_ = 0;
+    selection_rect_ = gfx::Rect();
   }
   UpdateActiveMatchOrdinal();
 
 #if defined(OS_ANDROID)
   // The removed frame may contain the nearest find result known so far. Note
   // that once all queried frames have responded, if this result was the overall
   // nearest, then no activation will occur.
   if (rfh == activate_.nearest_frame)
     activate_.nearest_frame = nullptr;
 
   // Match rects in the removed frame are no longer relevant.
   if (match_rects_.frame_rects.count(rfh)) {
     match_rects_.frame_rects.erase(rfh);
     ++match_rects_.known_version;
   }
 
   // A reply should not be expected from the removed frame.
   RemoveNearestFindResultPendingReply(rfh);
   RemoveFindMatchRectsPendingReply(rfh);
 #endif
 
-  if (pending_replies_.count(rfh)) {
+  // If no pending find replies are expected for the removed frame, then just
+  // report the updated results.
+  if (!pending_initial_replies_.count(rfh) && pending_find_next_reply_ != rfh) {
+    bool final_update =
+        pending_initial_replies_.empty() && !pending_find_next_reply_;
+    NotifyFindReply(current_session_id_, final_update);
+    return;
+  }
+
+  if (pending_initial_replies_.count(rfh)) {
     // A reply should not be expected from the removed frame.
-    pending_replies_.erase(rfh);
-    if (pending_replies_.empty()) {
-      FinalUpdate(current_request_.id, rfh);
-      return;
+    pending_initial_replies_.erase(rfh);
+    if (pending_initial_replies_.empty()) {
+      FinalUpdateReceived(current_session_id_, rfh);
     }
   }
 
-  NotifyFindReply(current_session_id_,
-                  pending_replies_.empty() /* final_update */);
+  if (pending_find_next_reply_ == rfh) {
+    // A reply should not be expected from the removed frame.
+    pending_find_next_reply_ = nullptr;
+    FinalUpdateReceived(current_request_.id, rfh);
+  }
 }
 
 #if defined(OS_ANDROID)
 void FindRequestManager::ActivateNearestFindResult(float x, float y) {
   if (current_session_id_ == kInvalidId)
     return;
 
   activate_ = ActivateNearestFindResultState(x, y);
 
   // Request from each frame the distance to the nearest find result (in that
   // frame) from the point (x, y), defined in find-in-page coordinates.
   for (FrameTreeNode* node : contents_->GetFrameTree()->Nodes()) {
     RenderFrameHost* rfh = node->current_frame_host();
 
-    if (!CheckFrame(rfh))
+    if (!CheckFrame(rfh) || !rfh->IsRenderFrameLive())
       continue;
 
     activate_.pending_replies.insert(rfh);
     rfh->Send(new FrameMsg_GetNearestFindResult(
         rfh->GetRoutingID(), activate_.current_request_id,
         activate_.x, activate_.y));
   }
 }
 
 void FindRequestManager::OnGetNearestFindResultReply(RenderFrameHost* rfh,
@@ skipping 14 matching lines @@
 }
 
 void FindRequestManager::RequestFindMatchRects(int current_version) {
   match_rects_.pending_replies.clear();
   match_rects_.request_version = current_version;
 
   // Request the latest find match rects from each frame.
   for (FrameTreeNode* node : contents_->GetFrameTree()->Nodes()) {
     RenderFrameHost* rfh = node->current_frame_host();
 
-    if (!CheckFrame(rfh))
+    if (!CheckFrame(rfh) || !rfh->IsRenderFrameLive())
       continue;
 
     match_rects_.pending_replies.insert(rfh);
     auto it = match_rects_.frame_rects.find(rfh);
     int version = (it != match_rects_.frame_rects.end())
         ? it->second.version : kInvalidId;
     rfh->Send(new FrameMsg_FindMatchRects(rfh->GetRoutingID(), version));
   }
 }
 
@@ skipping 23 matching lines @@
   RemoveFrame(old_host);
 }
 
 void FindRequestManager::FrameDeleted(RenderFrameHost* rfh) {
   RemoveFrame(rfh);
 }
 
 void FindRequestManager::Reset(const FindRequest& initial_request) {
   current_session_id_ = initial_request.id;
   current_request_ = initial_request;
-  pending_replies_.clear();
+  pending_initial_replies_.clear();
+  pending_find_next_reply_ = nullptr;
   pending_active_match_ordinal_ = true;
   matches_per_frame_.clear();
   number_of_matches_ = 0;
   active_frame_ = nullptr;
   relative_active_match_ordinal_ = 0;
   active_match_ordinal_ = 0;
   selection_rect_ = gfx::Rect();
+  last_reported_id_ = kInvalidId;
 #if defined(OS_ANDROID)
   activate_ = ActivateNearestFindResultState();
   match_rects_.pending_replies.clear();
 #endif
 }
 
 void FindRequestManager::FindInternal(const FindRequest& request) {
   DCHECK_GT(request.id, current_request_.id);
   DCHECK_GT(request.id, current_session_id_);
 
@@ skipping 29 matching lines @@
     return;
   }
 
   find_request_queue_.pop();
   if (!find_request_queue_.empty())
     FindInternal(find_request_queue_.front());
 }
 
 void FindRequestManager::SendFindIPC(const FindRequest& request,
                                      RenderFrameHost* rfh) {
-  pending_replies_.insert(rfh);
+  DCHECK(CheckFrame(rfh));
+  DCHECK(rfh->IsRenderFrameLive());
+
+  if (request.options.findNext)
+    pending_find_next_reply_ = rfh;
+  else
+    pending_initial_replies_.insert(rfh);
+
   rfh->Send(new FrameMsg_Find(rfh->GetRoutingID(), request.id,
                               request.search_text, request.options));
 }
 
-void FindRequestManager::NotifyFindReply(int request_id,
-                                         bool final_update) const {
+void FindRequestManager::NotifyFindReply(int request_id, bool final_update) {
   if (request_id == kInvalidId) {
     NOTREACHED();
     return;
   }
 
+  // Ensure that replies are not reported with IDs lower than the ID of the
+  // latest request we have results from.
+  if (request_id < last_reported_id_)
+    request_id = last_reported_id_;
+  else
+    last_reported_id_ = request_id;
+
   contents_->NotifyFindReply(request_id, number_of_matches_, selection_rect_,
                              active_match_ordinal_, final_update);
 }
 
 RenderFrameHost* FindRequestManager::GetInitialFrame(bool forward) const {
   RenderFrameHost* rfh = contents_->GetMainFrame();
 
   if (!forward)
     rfh = GetDeepestLastChild(rfh);
 
   return rfh;
 }
 
 RenderFrameHost* FindRequestManager::Traverse(RenderFrameHost* from_rfh,
                                               bool forward,
                                               bool matches_only,
                                               bool wrap) const {
   FrameTreeNode* node =
       static_cast<RenderFrameHostImpl*>(from_rfh)->frame_tree_node();
 
   while ((node = TraverseNode(node, forward, wrap)) != nullptr) {
     if (!CheckFrame(node->current_frame_host()))
       continue;
     RenderFrameHost* current_rfh = node->current_frame_host();
     if (!matches_only || matches_per_frame_.find(current_rfh)->second ||
-        pending_replies_.count(current_rfh)) {
+        pending_initial_replies_.count(current_rfh)) {
       // Note that if there is still a pending reply expected for this frame,
       // then it may have unaccounted matches and will not be skipped via
       // |matches_only|.
       return node->current_frame_host();
     }
     if (wrap && node->current_frame_host() == from_rfh)
       return nullptr;
   }
 
   return nullptr;
 }
 
 void FindRequestManager::AddFrame(RenderFrameHost* rfh) {
   if (!rfh || !rfh->IsRenderFrameLive())
     return;
 
   // A frame that is already being searched should not be added again.
   DCHECK(!CheckFrame(rfh));
 
   matches_per_frame_[rfh] = 0;
 
   FindRequest request = current_request_;
   request.id = current_session_id_;
   request.options.findNext = false;
   SendFindIPC(request, rfh);
 }
 
 bool FindRequestManager::CheckFrame(RenderFrameHost* rfh) const {
-  return rfh && rfh->IsRenderFrameLive() && matches_per_frame_.count(rfh);
+  return rfh && matches_per_frame_.count(rfh);
 }
 
 void FindRequestManager::UpdateActiveMatchOrdinal() {
   active_match_ordinal_ = 0;
 
   if (!active_frame_ || !relative_active_match_ordinal_) {
     DCHECK(!active_frame_ && !relative_active_match_ordinal_);
     return;
   }
 
   // Traverse the frame tree backwards (in search order) and count all of the
   // matches in frames before the frame with the active match, in order to
   // determine the overall active match ordinal.
   RenderFrameHost* frame = active_frame_;
   while ((frame = Traverse(frame,
                            false /* forward */,
                            true /* matches_only */,
                            false /* wrap */)) != nullptr) {
     active_match_ordinal_ += matches_per_frame_[frame];
   }
   active_match_ordinal_ += relative_active_match_ordinal_;
 }
 
-void FindRequestManager::FinalUpdate(int request_id, RenderFrameHost* rfh) {
+void FindRequestManager::FinalUpdateReceived(int request_id,
+                                             RenderFrameHost* rfh) {
   if (!number_of_matches_ ||
-      !pending_active_match_ordinal_ ||
+      (active_match_ordinal_ && !pending_active_match_ordinal_) ||
       request_id != current_request_.id) {
-    NotifyFindReply(request_id, true /* final_update */);
+    // 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 this was a find next operation, then the active match will be in the
@@ skipping 72 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