Revert of Enable find-in-page across GuestViews.

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 <algorithm>
-
 #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"
-#include "content/public/browser/guest_mode.h"
 
 namespace content {
 
 namespace {
 
-// The following functions allow traversal over all frames, including those
-// across WebContentses.
-//
-// Note that there are currently two different ways in which an inner
-// WebContents may be embedded in an outer WebContents:
-//
-// 1) As a guest of the outer WebContents's BrowserPluginEmbedder.
-// 2) Within an inner WebContentsTreeNode of the outer WebContents's
-//    WebContentsTreeNode.
-
-// Returns all child frames of |node|.
-std::vector<FrameTreeNode*> GetChildren(FrameTreeNode* node) {
-  std::vector<FrameTreeNode*> children(node->child_count());
-  for (size_t i = 0; i != node->child_count(); ++i)
-    children[i] = node->child_at(i);
-
-  if (auto* inner_contents = WebContentsImpl::FromOuterFrameTreeNode(node)) {
-    children.push_back(inner_contents->GetMainFrame()->frame_tree_node());
-  } else {
-    auto* contents = WebContentsImpl::FromFrameTreeNode(node);
-    if (node->IsMainFrame() && contents->GetBrowserPluginEmbedder()) {
-      for (auto* inner_contents : contents->GetInnerWebContents()) {
-        children.push_back(inner_contents->GetMainFrame()->frame_tree_node());
-      }
-    }
-  }
-
-  return children;
-}
-
-// Returns the first child FrameTreeNode under |node|, if |node| has a child, or
-// nullptr otherwise.
-FrameTreeNode* GetFirstChild(FrameTreeNode* node) {
-  auto children = GetChildren(node);
-  if (!children.empty())
-    return children.front();
-  return nullptr;
-}
-
-// Returns the last child FrameTreeNode under |node|, if |node| has a child, or
-// nullptr otherwise.
-FrameTreeNode* GetLastChild(FrameTreeNode* node) {
-  auto children = GetChildren(node);
-  if (!children.empty())
-    return children.back();
-  return nullptr;
-}
-
 // Returns the deepest last child frame under |node|/|rfh| in the frame tree.
 FrameTreeNode* GetDeepestLastChild(FrameTreeNode* node) {
-  while (FrameTreeNode* last_child = GetLastChild(node))
-    node = last_child;
+  while (node->child_count())
+    node = node->child_at(node->child_count() - 1);
   return node;
 }
 RenderFrameHost* GetDeepestLastChild(RenderFrameHost* rfh) {
   FrameTreeNode* node =
       static_cast<RenderFrameHostImpl*>(rfh)->frame_tree_node();
   return GetDeepestLastChild(node)->current_frame_host();
 }
 
-// Returns the parent FrameTreeNode of |node|, if |node| has a parent, or
-// nullptr otherwise.
-FrameTreeNode* GetParent(FrameTreeNode* node) {
-  if (node->parent())
-    return node->parent();
-
-  // The parent frame may be in another WebContents.
-  if (node->IsMainFrame()) {
-    auto* contents = WebContentsImpl::FromFrameTreeNode(node);
-    if (GuestMode::IsCrossProcessFrameGuest(contents)) {
-      int node_id = contents->GetOuterDelegateFrameTreeNodeId();
-      if (node_id != FrameTreeNode::kFrameTreeNodeInvalidId)
-        return FrameTreeNode::GloballyFindByID(node_id);
-    } else if (auto* outer_contents = contents->GetOuterWebContents()) {
-      return outer_contents->GetMainFrame()->frame_tree_node();
-    }
-  }
-
-  return nullptr;
-}
-
-// Returns the previous sibling FrameTreeNode of |node|, if one exists, or
-// nullptr otherwise.
-FrameTreeNode* GetPreviousSibling(FrameTreeNode* node) {
-  if (FrameTreeNode* previous_sibling = node->PreviousSibling())
-    return previous_sibling;
-
-  // The previous sibling may be in another WebContents.
-  if (FrameTreeNode* parent = GetParent(node)) {
-    auto children = GetChildren(parent);
-    auto it = std::find(children.begin(), children.end(), node);
-    // It is odd that this node may not be a child of its parent, but this is
-    // actually possible during teardown, hence the need for the check for
-    // "it != children.end()".
-    if (it != children.end() && it != children.begin())
-      return *--it;
-  }
-
-  return nullptr;
-}
-
-// Returns the next sibling FrameTreeNode of |node|, if one exists, or nullptr
-// otherwise.
-FrameTreeNode* GetNextSibling(FrameTreeNode* node) {
-  if (FrameTreeNode* next_sibling = node->NextSibling())
-    return next_sibling;
-
-  // The next sibling may be in another WebContents.
-  if (FrameTreeNode* parent = GetParent(node)) {
-    auto children = GetChildren(parent);
-    auto it = std::find(children.begin(), children.end(), node);
-    // It is odd that this node may not be a child of its parent, but this is
-    // actually possible during teardown, hence the need for the check for
-    // "it != children.end()".
-    if (it != children.end() && ++it != children.end())
-      return *it;
-  }
-
-  return nullptr;
-}
-
 // Returns the FrameTreeNode directly after |node| in the frame tree in search
 // order, or nullptr if one does not exist. If |wrap| is set, then wrapping
 // between the first and last frames is permitted. Note that this traversal
 // follows the same ordering as in blink::FrameTree::traverseNextWithWrap().
 FrameTreeNode* TraverseNext(FrameTreeNode* node, bool wrap) {
-  if (FrameTreeNode* first_child = GetFirstChild(node))
-    return first_child;
+  if (node->child_count())
+    return node->child_at(0);
 
-  FrameTreeNode* sibling = GetNextSibling(node);
+  FrameTreeNode* sibling = node->NextSibling();
   while (!sibling) {
-    FrameTreeNode* parent = GetParent(node);
-    if (!parent)
+    if (!node->parent())
       return wrap ? node : nullptr;
-    node = parent;
-    sibling = GetNextSibling(node);
+    node = node->parent();
+    sibling = node->NextSibling();
   }
   return sibling;
 }
 
 // Returns the FrameTreeNode directly before |node| in the frame tree in search
 // order, or nullptr if one does not exist. If |wrap| is set, then wrapping
 // between the first and last frames is permitted. Note that this traversal
 // follows the same ordering as in blink::FrameTree::traversePreviousWithWrap().
 FrameTreeNode* TraversePrevious(FrameTreeNode* node, bool wrap) {
-  if (FrameTreeNode* previous_sibling = GetPreviousSibling(node))
+  if (FrameTreeNode* previous_sibling = node->PreviousSibling())
     return GetDeepestLastChild(previous_sibling);
-  if (FrameTreeNode* parent = GetParent(node))
-    return parent;
+  if (node->parent())
+    return node->parent();
   return wrap ? GetDeepestLastChild(node) : nullptr;
 }
 
-// The same as either TraverseNext() or TraversePrevious(), depending on
+// The same as either TraverseNext() or TraversePrevious() depending on
 // |forward|.
 FrameTreeNode* TraverseNode(FrameTreeNode* node, bool forward, bool wrap) {
   return forward ? TraverseNext(node, wrap) : TraversePrevious(node, wrap);
 }
 
 }  // namespace
 
-// Observes searched WebContentses for frame changes, including deletion,
-// creation, and navigation.
-class FindRequestManager::FrameObserver : public WebContentsObserver {
- public:
-  FrameObserver(WebContentsImpl* web_contents, FindRequestManager* manager)
-      : WebContentsObserver(web_contents), manager_(manager) {}
-
-  ~FrameObserver() override {}
-
-  void DidFinishLoad(RenderFrameHost* rfh, const GURL& validated_url) override {
-    if (manager_->current_session_id_ == kInvalidId)
-      return;
-
-    manager_->RemoveFrame(rfh);
-    manager_->AddFrame(rfh, true /* force */);
-  }
-
-  void RenderFrameDeleted(RenderFrameHost* rfh) override {
-    manager_->RemoveFrame(rfh);
-  }
-
-  void RenderFrameHostChanged(RenderFrameHost* old_host,
-                              RenderFrameHost* new_host) override {
-    manager_->RemoveFrame(old_host);
-  }
-
-  void FrameDeleted(RenderFrameHost* rfh) override {
-    manager_->RemoveFrame(rfh);
-  }
-
- private:
-  // The FindRequestManager that owns this FrameObserver.
-  FindRequestManager* const manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(FrameObserver);
-};
-
 #if defined(OS_ANDROID)
 FindRequestManager::ActivateNearestFindResultState::
 ActivateNearestFindResultState() = default;
 FindRequestManager::ActivateNearestFindResultState::
 ActivateNearestFindResultState(float x, float y)
     : current_request_id(GetNextID()),
       x(x),
       y(y) {}
 FindRequestManager::ActivateNearestFindResultState::
 ~ActivateNearestFindResultState() {}
 
 FindRequestManager::FrameRects::FrameRects() = default;
 FindRequestManager::FrameRects::FrameRects(const std::vector<gfx::RectF>& rects,
                                            int version)
     : rects(rects), version(version) {}
 FindRequestManager::FrameRects::~FrameRects() {}
 
 FindRequestManager::FindMatchRectsState::FindMatchRectsState() = default;
 FindRequestManager::FindMatchRectsState::~FindMatchRectsState() {}
 #endif
 
 // static
 const int FindRequestManager::kInvalidId = -1;
 
 FindRequestManager::FindRequestManager(WebContentsImpl* web_contents)
-    : contents_(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),
       last_reported_id_(kInvalidId) {}
 
 FindRequestManager::~FindRequestManager() {}
@@ skipping 10 matching lines @@
   // If this is a new find session, clear any queued requests from last session.
   if (!options.find_next)
     find_request_queue_ = std::queue<FindRequest>();
 
   find_request_queue_.emplace(request_id, search_text, options);
   if (find_request_queue_.size() == 1)
     FindInternal(find_request_queue_.front());
 }
 
 void FindRequestManager::StopFinding(StopFindAction action) {
-  for (WebContentsImpl* contents : contents_->GetWebContentsAndAllInner()) {
-    contents->SendToAllFrames(
-        new FrameMsg_StopFinding(MSG_ROUTING_NONE, action));
-  }
+  contents_->SendToAllFrames(
+      new FrameMsg_StopFinding(MSG_ROUTING_NONE, action));
 
   current_session_id_ = kInvalidId;
 #if defined(OS_ANDROID)
   // It is important that these pending replies are cleared whenever a find
   // session ends, so that subsequent replies for the old session are ignored.
   activate_.pending_replies.clear();
   match_rects_.pending_replies.clear();
 #endif
 }
 
@@ skipping 151 matching lines @@
 
 #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 (WebContentsImpl* contents : contents_->GetWebContentsAndAllInner()) {
-    for (FrameTreeNode* node : contents->GetFrameTree()->Nodes()) {
-      RenderFrameHost* rfh = node->current_frame_host();
+  for (FrameTreeNode* node : contents_->GetFrameTree()->Nodes()) {
+    RenderFrameHost* rfh = node->current_frame_host();
 
-      if (!CheckFrame(rfh) || !rfh->IsRenderFrameLive())
-        continue;
+    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));
-    }
+    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,
                                                      int request_id,
                                                      float distance) {
   if (request_id != activate_.current_request_id ||
       !activate_.pending_replies.count(rfh)) {
     return;
   }
 
   // Check if this frame has a nearer find result than the current nearest.
   if (distance < activate_.nearest_distance) {
     activate_.nearest_frame = rfh;
     activate_.nearest_distance = distance;
   }
 
   RemoveNearestFindResultPendingReply(rfh);
 }
 
 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 (WebContentsImpl* contents : contents_->GetWebContentsAndAllInner()) {
-    for (FrameTreeNode* node : contents->GetFrameTree()->Nodes()) {
-      RenderFrameHost* rfh = node->current_frame_host();
+  for (FrameTreeNode* node : contents_->GetFrameTree()->Nodes()) {
+    RenderFrameHost* rfh = node->current_frame_host();
 
-      if (!CheckFrame(rfh) || !rfh->IsRenderFrameLive())
-        continue;
+    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));
-    }
+    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));
   }
 }
 
 void FindRequestManager::OnFindMatchRectsReply(
     RenderFrameHost* rfh,
     int version,
     const std::vector<gfx::RectF>& rects,
     const gfx::RectF& active_rect) {
   auto it = match_rects_.frame_rects.find(rfh);
   if (it == match_rects_.frame_rects.end() || it->second.version != version) {
     // 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) {
+  RemoveFrame(rfh);
+}
+
 void FindRequestManager::Reset(const FindRequest& initial_request) {
   current_session_id_ = initial_request.id;
   current_request_ = initial_request;
   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;
-  frame_observers_.clear();
 #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_);
 
   if (request.options.find_next) {
     // This is a find next operation.
 
     // This implies that there is an ongoing find session with the same search
     // text.
     DCHECK_GE(current_session_id_, 0);
     DCHECK_EQ(request.search_text, current_request_.search_text);
 
     // The find next request will be directed at the focused frame if there is
     // one, or the first frame with matches otherwise.
-    RenderFrameHost* target_rfh =
-        contents_->GetFocusedWebContents()->GetFocusedFrame();
+    RenderFrameHost* target_rfh = contents_->GetFocusedFrame();
     if (!target_rfh || !CheckFrame(target_rfh))
       target_rfh = GetInitialFrame(request.options.forward);
 
     SendFindIPC(request, target_rfh);
     current_request_ = request;
     pending_active_match_ordinal_ = true;
     return;
   }
 
   // This is an initial find operation.
   Reset(request);
-  for (WebContentsImpl* contents : contents_->GetWebContentsAndAllInner()) {
-    frame_observers_.push_back(base::MakeUnique<FrameObserver>(contents, this));
-    for (FrameTreeNode* node : contents->GetFrameTree()->Nodes()) {
-      AddFrame(node->current_frame_host(), false /* force */);
-    }
-  }
+  for (FrameTreeNode* node : contents_->GetFrameTree()->Nodes())
+    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 37 matching lines @@
   if (!forward)
     rfh = GetDeepestLastChild(rfh);
 
   return rfh;
 }
 
 RenderFrameHost* FindRequestManager::Traverse(RenderFrameHost* from_rfh,
                                               bool forward,
                                               bool matches_only,
                                               bool wrap) const {
-  DCHECK(from_rfh);
   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_initial_replies_.count(current_rfh)) {
       // Note that if there is still a pending reply expected for this frame,
@@ skipping 67 matching lines @@
   // request must be sent.
 
   RenderFrameHost* target_rfh;
   if (request_id == current_request_.id && current_request_.options.find_next) {
     // 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_->GetFocusedWebContents()->GetFocusedFrame()) !=
-             nullptr) {
+  } 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,
                           current_request_.options.forward,
                           true /* matches_only */,
                           true /* wrap */);
   } else {
     // Otherwise, the first frame with matches will have the active match.
     target_rfh = GetInitialFrame(current_request_.options.forward);
     if (!CheckFrame(target_rfh) || !matches_per_frame_[target_rfh]) {
@@ skipping 56 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