Enable find-in-page across GuestViews.

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>
 #include <utility>
 #include <vector>
 
 #include "content/common/content_export.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/stop_find_action.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace content {
 
 class RenderFrameHost;
 class WebContentsImpl;
 
 // FindRequestManager manages all of the find-in-page requests/replies
 // initiated/received through a WebContents. It coordinates searching across
 // multiple (potentially out-of-process) frames, handles the aggregation of find
 // results from each frame, and facilitates active match traversal. It is
-// instantiated once per WebContents, and is owned by that WebContents.
-class CONTENT_EXPORT FindRequestManager : public WebContentsObserver {
+// instantiated once per top-level WebContents, and is owned by that
+// WebContents.
+class CONTENT_EXPORT FindRequestManager {
  public:
   explicit FindRequestManager(WebContentsImpl* web_contents);
-  ~FindRequestManager() override;
+  ~FindRequestManager();
 
   // Initiates a find operation for |search_text| with the options specified in
   // |options|. |request_id| uniquely identifies the find request.
   void Find(int request_id,
             const base::string16& search_text,
             const blink::WebFindOptions& options);
 
   // Stops the active find session and clears the general highlighting of the
   // matches. |action| determines whether the last active match (if any) will be
   // activated, cleared, or remain highlighted.
@@ skipping 32 matching lines @@
                              int version,
                              const std::vector<gfx::RectF>& rects,
                              const gfx::RectF& active_rect);
 #endif
 
  private:
   // An invalid ID. This value is invalid for any render process ID, render
   // frame ID, find request ID, or find match rects version number.
   static const int kInvalidId;
 
+  class FrameObserver;
+
   // The request data for a single find request.
   struct FindRequest {
     // The find request ID that uniquely identifies this find request.
     int id = kInvalidId;
 
     // The text that is being searched for in this find request.
     base::string16 search_text;
 
     // The set of find options in effect for this find request.
     blink::WebFindOptions options;
 
     FindRequest() = default;
     FindRequest(int id,
                 const base::string16& search_text,
                 const blink::WebFindOptions& options)
         : id(id), search_text(search_text), options(options) {}
   };
 
-  // WebContentsObserver implementation.
-  void DidFinishLoad(RenderFrameHost* rfh, const GURL& validated_url) override;
-  void RenderFrameDeleted(RenderFrameHost* rfh) override;
-  void RenderFrameHostChanged(RenderFrameHost* old_host,
-                              RenderFrameHost* new_host) override;
-  void FrameDeleted(RenderFrameHost* rfh) override;
-
   // Resets all of the per-session state for a new find-in-page session.
   void Reset(const FindRequest& initial_request);
 
   // Called internally as find requests come up in the queue.
   void FindInternal(const FindRequest& request);
 
   // 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);
@@ skipping 119 matching lines @@
     gfx::RectF active_rect;
 
     // Find match rects replies are still pending for these frames.
     std::unordered_set<RenderFrameHost*> pending_replies;
 
     FindMatchRectsState();
     ~FindMatchRectsState();
   } match_rects_;
 #endif
 
-  // The WebContents that owns this FindRequestManager.
+  // The WebContents that owns this FindRequestManager. This also defines the
+  // scope of all find sessions. Only frames in |contents_| and any inner
+  // WebContentses within it will be searched.
   WebContentsImpl* const contents_;
 
   // 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.
@@ skipping 37 matching lines @@
   // 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_;
+
+  // WebContentsObservers to observe frame changes in |contents_| and its inner
+  // WebContentses.
+  std::vector<std::unique_ptr<FrameObserver>> frame_observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(FindRequestManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FIND_REQUEST_MANAGER_H_