Enable find-in-page across GuestViews.

content/browser/web_contents/web_contents_impl.h

 // Copyright (c) 2012 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_WEB_CONTENTS_WEB_CONTENTS_IMPL_H_
 #define CONTENT_BROWSER_WEB_CONTENTS_WEB_CONTENTS_IMPL_H_
 
 #include <stdint.h>
 
 #include <functional>
@@ skipping 114 matching lines @@
   class FriendWrapper;
 
   ~WebContentsImpl() override;
 
   static WebContentsImpl* CreateWithOpener(
       const WebContents::CreateParams& params,
       FrameTreeNode* opener);
 
   static std::vector<WebContentsImpl*> GetAllWebContents();
 
-  static WebContentsImpl* FromFrameTreeNode(FrameTreeNode* frame_tree_node);
+  static WebContentsImpl* FromFrameTreeNode(
+      const FrameTreeNode* frame_tree_node);
   static WebContents* FromRenderFrameHostID(int render_process_host_id,
                                             int render_frame_host_id);
   static WebContents* FromFrameTreeNodeId(int frame_tree_node_id);
+  static WebContentsImpl* FromOuterFrameTreeNode(
+      const FrameTreeNode* frame_tree_node);
 
   // Complex initialization here. Specifically needed to avoid having
   // members call back into our virtual functions in the constructor.
   virtual void Init(const WebContents::CreateParams& params);
 
   // Returns the SavePackage which manages the page saving job. May be NULL.
   SavePackage* save_package() const { return save_package_.get(); }
 
 #if defined(OS_ANDROID)
   // In Android WebView, the RenderView needs created even there is no
@@ skipping 112 matching lines @@
   // |binding_set| is not owned and must either outlive this WebContents or be
   // explicitly removed before being destroyed.
   base::Closure AddBindingSet(const std::string& interface_name,
                               WebContentsBindingSet* binding_set);
 
   // Accesses a WebContentsBindingSet for a specific interface on this
   // WebContents. Returns null of there is no registered binder for the
   // interface.
   WebContentsBindingSet* GetBindingSet(const std::string& interface_name);
 
+  // Returns the focused WebContents.
+  // If there are multiple inner/outer WebContents (when embedding <webview>,
+  // <guestview>, ...) returns the single one containing the currently focused
+  // frame. Otherwise, returns this WebContents.
+  WebContentsImpl* GetFocusedWebContents();
+
+  // TODO(paulmeyer): Once GuestViews are no longer implemented as
+  // BrowserPluginGuests, frame traversal across WebContents should be moved to
+  // be handled by FrameTreeNode, and |GetInnerWebContents| and
+  // |GetWebContentsAndAllInner| can be removed.
+
+  // Returns a vector to the inner WebContents within this WebContents.
+  std::vector<WebContentsImpl*> GetInnerWebContents();
+
+  // Returns a vector containing this WebContents and all inner WebContents
+  // within it (recursively).
+  std::vector<WebContentsImpl*> GetWebContentsAndAllInner();
+
   // WebContents ------------------------------------------------------
   WebContentsDelegate* GetDelegate() override;
   void SetDelegate(WebContentsDelegate* delegate) override;
   NavigationControllerImpl& GetController() override;
   const NavigationControllerImpl& GetController() const override;
   BrowserContext* GetBrowserContext() const override;
   const GURL& GetURL() const override;
   const GURL& GetVisibleURL() const override;
   const GURL& GetLastCommittedURL() const override;
   RenderProcessHost* GetRenderProcessHost() const override;
@@ skipping 523 matching lines @@
   // Called when the WebContents gains or loses a persistent video.
   void SetHasPersistentVideo(bool has_persistent_video);
 
   // Whether the WebContents has an active player is effectively fullscreen.
   // That means that the video is either fullscreen or it is the content of
   // a fullscreen page (in other words, a fullscreen video with custom
   // controls).
   // |IsFullscreen| must return |true| when this method is called.
   bool HasActiveEffectivelyFullscreenVideo() const;
 
+  // Called by this WebContents's BrowserPluginGuest (if one exists) to indicate
+  // that the guest will be destroyed.
+  void BrowserPluginGuestWillDestroy();
+
 #if defined(OS_ANDROID)
   // Called by FindRequestManager when all of the find match rects are in.
   void NotifyFindMatchRectsReply(int version,
                                  const std::vector<gfx::RectF>& rects,
                                  const gfx::RectF& active_rect);
 #endif
 
  private:
   friend class WebContentsObserver;
   friend class WebContents;  // To implement factory methods.
@@ skipping 55 matching lines @@
 
     WebContentsImpl* outer_web_contents() const { return outer_web_contents_; }
     int outer_contents_frame_tree_node_id() const {
       return outer_contents_frame_tree_node_id_;
     }
     FrameTreeNode* OuterContentsFrameTreeNode() const;
 
     WebContentsImpl* focused_web_contents() { return focused_web_contents_; }
     void SetFocusedWebContents(WebContentsImpl* web_contents);
 
+    // Returns the inner WebContents within |frame|, if one exists, or nullptr
+    // otherwise.
+    WebContentsImpl* GetInnerWebContentsInFrame(const FrameTreeNode* frame);
+
+    const std::vector<WebContentsImpl*>& inner_web_contents() const;
+
    private:
+    void AttachInnerWebContents(WebContentsImpl* inner_web_contents);
+    void DetachInnerWebContents(WebContentsImpl* inner_web_contents);
+
     // FrameTreeNode::Observer implementation.
     void OnFrameTreeNodeDestroyed(FrameTreeNode* node) final;
 
     // The WebContents that owns this WebContentsTreeNode.
     WebContentsImpl* const current_web_contents_;
 
     // The outer WebContents of |current_web_contents_|, or nullptr if
     // |current_web_contents_| is the outermost WebContents.
     WebContentsImpl* outer_web_contents_;
 
     // The ID of the FrameTreeNode in the |outer_web_contents_| that hosts
     // |current_web_contents_| as an inner WebContents.
     int outer_contents_frame_tree_node_id_;
 
+    // List of inner WebContents that we host.
+    std::vector<WebContentsImpl*> inner_web_contents_;
+
     // Only the root node should have this set. This indicates the WebContents
     // whose frame tree has the focused frame. The WebContents tree could be
     // arbitrarily deep.
     WebContentsImpl* focused_web_contents_;
   };
 
   // See WebContents::Create for a description of these parameters.
   WebContentsImpl(BrowserContext* browser_context);
 
   // Add and remove observers for page navigation notifications. The order in
@@ skipping 157 matching lines @@
   //
   // These functions are helpers in managing a hierarchy of WebContents
   // involved in rendering inner WebContents.
 
   // When multiple WebContents are present within a tab or window, a single one
   // is focused and will route keyboard events in most cases to a RenderWidget
   // contained within it. |GetFocusedWebContents()|'s main frame widget will
   // receive page focus and blur events when the containing window changes focus
   // state.
 
-  // Returns the focused WebContents.
-  // If there are multiple inner/outer WebContents (when embedding <webview>,
-  // <guestview>, ...) returns the single one containing the currently focused
-  // frame. Otherwise, returns this WebContents.
-  WebContentsImpl* GetFocusedWebContents();
-
   // Returns true if |this| is the focused WebContents or an ancestor of the
   // focused WebContents.
   bool ContainsOrIsFocusedWebContents();
 
   // When inner or outer WebContents are present, become the focused
   // WebContentsImpl. This will activate this content's main frame RenderWidget
   // and indirectly all its subframe widgets.  GetFocusedRenderWidgetHost will
   // search this WebContentsImpl for a focused RenderWidgetHost. The previously
   // focused WebContentsImpl, if any, will have its RenderWidgetHosts
   // deactivated.
@@ skipping 88 matching lines @@
   // Internal helper to create WebUI objects associated with |this|. |url| is
   // used to determine which WebUI should be created (if any). |frame_name|
   // corresponds to the name of a frame that the WebUI should be created for (or
   // the main frame if empty).
   std::unique_ptr<WebUIImpl> CreateWebUI(const GURL& url,
                                          const std::string& frame_name);
 
   void SetJavaScriptDialogManagerForTesting(
       JavaScriptDialogManager* dialog_manager);
 
-  // Returns the FindRequestManager, or creates one if it doesn't already exist.
+  // Returns the FindRequestManager, which may be found in an outer WebContents.
+  FindRequestManager* GetFindRequestManager();
+
+  // Returns the FindRequestManager, or creates one if it doesn't already
+  // exist. The FindRequestManager may be found in an outer WebContents.
   FindRequestManager* GetOrCreateFindRequestManager();
 
   // Removes a registered WebContentsBindingSet by interface name.
   void RemoveBindingSet(const std::string& interface_name);
 
   // Prints a console warning when visiting a localhost site with a bad
   // certificate via --allow-insecure-localhost.
   void ShowInsecureLocalhostWarningIfNeeded();
 
   // Notify this WebContents that the preferences have changed. This will send
@@ skipping 350 matching lines @@
   // Adds/removes a callback called on creation of each new WebContents.
   static void AddCreatedCallbackForTesting(const CreatedCallback& callback);
   static void RemoveCreatedCallbackForTesting(const CreatedCallback& callback);
 
   DISALLOW_COPY_AND_ASSIGN(FriendWrapper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_WEB_CONTENTS_WEB_CONTENTS_IMPL_H_