Changes to how FindRequestManager reports find results.

content/browser/find_request_manager.h

 // 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.
 
 #ifndef CONTENT_BROWSER_FIND_REQUEST_MANAGER_H_
 #define CONTENT_BROWSER_FIND_REQUEST_MANAGER_H_
 
 #include <queue>
 #include <unordered_map>
 #include <unordered_set>
@@ skipping 106 matching lines @@
   // Called when an informative response (a response with enough information to
   // be able to route subsequent find requests) comes in for the find request
   // with ID |request_id|. Advances the |find_request_queue_| if appropriate.
   void AdvanceQueue(int request_id);
 
   // Sends a find IPC containing the find request |request| to the RenderFrame
   // associated with |rfh|.
   void SendFindIPC(const FindRequest& request, RenderFrameHost* rfh);
 
   // Sends the find results (as they currently are) to the WebContents.
-  void NotifyFindReply(int request_id, bool final_update) const;
+  void NotifyFindReply(int request_id, bool final_update);
 
   // Returns the initial frame in search order. This will be either the first
   // frame, if searching forward, or the last frame, if searching backward.
   RenderFrameHost* GetInitialFrame(bool forward) const;
 
   // Traverses the frame tree to find and return the next RenderFrameHost after
   // |from_rfh| in search order. |forward| indicates whether the frame tree
   // should be traversed forward (if true) or backward (if false). If
   // |matches_only| is set, then the frame tree will be traversed until the
   // first frame is found for which matches have been found. If |wrap| is set,
@@ skipping 13 matching lines @@
   // Returns whether |rfh| is in the set of frames being searched in the current
   // find session.
   bool CheckFrame(RenderFrameHost* rfh) const;
 
   // Computes and updates |active_match_ordinal_| based on |active_frame_| and
   // |relative_active_match_ordinal_|.
   void UpdateActiveMatchOrdinal();
 
   // Called when all pending find replies have been received for the find
   // request with ID |request_id|. The final update was received from |rfh|.
-  void FinalUpdate(int request_id, RenderFrameHost* rfh);
+  //
+  // Note that this is the final update for this particular find request, but
+  // not necessarily for all issued requests. If there are still pending replies
+  // expected for a previous find request, then the outgoing find reply issued
+  // from this function will not be marked final.
+  void FinalUpdateReceived(int request_id, RenderFrameHost* rfh);
 
 #if defined(OS_ANDROID)
   // Called when a nearest find result reply is no longer pending for a frame.
   void RemoveNearestFindResultPendingReply(RenderFrameHost* rfh);
 
   // Called when a find match rects reply is no longer pending for a frame.
   void RemoveFindMatchRectsPendingReply(RenderFrameHost* rfh);
 
   // State related to ActivateNearestFindResult requests.
   struct ActivateNearestFindResultState {
@@ skipping 73 matching lines @@
   // The request ID of the initial find request in the current find-in-page
   // session, which uniquely identifies this session. Request IDs are included
   // in all find-related IPCs, which allows reply IPCs containing results from
   // previous sessions (with |request_id| < |current_session_id_|) to be easily
   // identified and ignored.
   int current_session_id_;
 
   // The current find request.
   FindRequest current_request_;
 
-  // The set of frames that are still expected to reply to a pending find
-  // request. Frames are removed from |pending_replies_| when their reply with
-  // |final_update| set to true is received.
-  std::unordered_set<RenderFrameHost*> pending_replies_;
+  // The set of frames that are still expected to reply to a pending initial
+  // find request. Frames are removed from |pending_initial_replies_| when their
+  // reply to the initial find request is received with |final_update| set to
+  // true.
+  std::unordered_set<RenderFrameHost*> pending_initial_replies_;
+
+  // The frame (if any) that is still expected to reply to the last pending
+  // "find next" request.
+  RenderFrameHost* pending_find_next_reply_;
 
   // Indicates whether an update to the active match ordinal is expected. Once
   // set, |pending_active_match_ordinal_| will not reset until an update to the
   // active match ordinal is received in response to the find request with ID
   // |current_request_.id| (the latest request).
   bool pending_active_match_ordinal_;
 
   // The number of matches found in each frame. There will necessarily be
   // entries in this map for every frame that is being (or has been) searched in
   // the current find session, and no other frames.
@@ skipping 12 matching lines @@
 
   // The overall active match ordinal for the current find-in-page session.
   int active_match_ordinal_;
 
   // The rectangle around the active match, in screen coordinates.
   gfx::Rect selection_rect_;
 
   // Find requests are queued here when previous requests need to be handled
   // before these ones can be properly routed.
   std::queue<FindRequest> find_request_queue_;
+
+  // Keeps track of the find request ID of the last find reply reported via
+  // NotifyFindReply().
+  int last_reported_id_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FIND_REQUEST_MANAGER_H_