| // 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 "base/containers/queue.h" |
| #include "content/browser/find_in_page_client.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/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* contents = WebContentsImpl::FromOuterFrameTreeNode(node)) { |
| children.push_back(contents->GetMainFrame()->frame_tree_node()); |
| } else { |
| contents = WebContentsImpl::FromFrameTreeNode(node); |
| if (node->IsMainFrame() && contents->GetBrowserPluginEmbedder()) { |
| for (auto* inner_contents : contents->GetInnerWebContents()) { |
| children.push_back(static_cast<WebContentsImpl*>(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; |
| 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; |
| |
| FrameTreeNode* sibling = GetNextSibling(node); |
| while (!sibling) { |
| FrameTreeNode* parent = GetParent(node); |
| if (!parent) |
| return wrap ? node : nullptr; |
| node = parent; |
| sibling = GetNextSibling(node); |
| } |
| 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)) |
| return GetDeepestLastChild(previous_sibling); |
| if (FrameTreeNode* parent = GetParent(node)) |
| return parent; |
| return wrap ? GetDeepestLastChild(node) : nullptr; |
| } |
| |
| // 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 { |
| // The |old_host| and its children are now pending deletion. Find-in-page |
| // must not interact with them anymore. |
| if (old_host) |
| RemoveFrameRecursively(static_cast<RenderFrameHostImpl*>(old_host)); |
| } |
| |
| void FrameDeleted(RenderFrameHost* rfh) override { |
| manager_->RemoveFrame(rfh); |
| } |
| |
| private: |
| void RemoveFrameRecursively(RenderFrameHostImpl* rfh) { |
| for (size_t i = 0; i < rfh->child_count(); ++i) |
| RemoveFrameRecursively(rfh->child_at(i)->current_frame_host()); |
| manager_->RemoveFrame(rfh); |
| } |
| |
| // The FindRequestManager that owns this FrameObserver. |
| FindRequestManager* const manager_; |
| |
| DISALLOW_COPY_AND_ASSIGN(FrameObserver); |
| }; |
| |
| FindRequestManager::FindRequest::FindRequest() {} |
| |
| FindRequestManager::FindRequest::FindRequest( |
| int id, |
| const base::string16& search_text, |
| blink::mojom::FindOptionsPtr options) |
| : id(id), search_text(search_text), options(std::move(options)) {} |
| |
| FindRequestManager::FindRequest::FindRequest(const FindRequest& request) |
| : id(request.id), |
| search_text(request.search_text), |
| options(request.options.Clone()) {} |
| |
| FindRequestManager::FindRequest::~FindRequest() {} |
| |
| FindRequestManager::FindRequest& FindRequestManager::FindRequest::operator=( |
| const FindRequest& request) { |
| id = request.id; |
| search_text = request.search_text; |
| options = request.options.Clone(); |
| return *this; |
| } |
| |
| #if defined(OS_ANDROID) |
| FindRequestManager::ActivateNearestFindResultState:: |
| ActivateNearestFindResultState() = default; |
| FindRequestManager::ActivateNearestFindResultState:: |
| ActivateNearestFindResultState(float x, float y) |
| : current_request_id(GetNextID()), point(x, 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), |
| 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() {} |
| |
| void FindRequestManager::Find(int request_id, |
| const base::string16& search_text, |
| blink::mojom::FindOptionsPtr 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); |
| DCHECK_GT(request_id, current_session_id_); |
| |
| // If this is a new find session, clear any queued requests from last session. |
| if (!options->find_next) |
| find_request_queue_ = base::queue<FindRequest>(); |
| |
| find_request_queue_.emplace(request_id, search_text, std::move(options)); |
| if (find_request_queue_.size() == 1) |
| FindInternal(find_request_queue_.front()); |
| } |
| |
| void FindRequestManager::StopFinding(StopFindAction action) { |
| for (WebContentsImpl* contents : contents_->GetWebContentsAndAllInner()) { |
| for (FrameTreeNode* node : contents->GetFrameTree()->Nodes()) { |
| RenderFrameHostImpl* rfh = node->current_frame_host(); |
| if (!CheckFrame(rfh) || !rfh->IsRenderFrameLive()) |
| continue; |
| rfh->GetFindInPage()->StopFinding( |
| static_cast<blink::mojom::StopFindAction>(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 |
| } |
| |
| bool FindRequestManager::ShouldIgnoreReply(RenderFrameHostImpl* rfh, |
| int request_id) { |
| // Ignore stale replies from abandoned find sessions or dead frames. |
| return current_session_id_ == kInvalidId || |
| request_id < current_session_id_ || !CheckFrame(rfh); |
| } |
| |
| void FindRequestManager::HandleFinalUpdateForFrame(RenderFrameHostImpl* rfh, |
| int request_id) { |
| // This is the final update for this frame for the current find operation. |
| pending_initial_replies_.erase(rfh); |
| if (request_id == current_session_id_ && !pending_initial_replies_.empty()) { |
| NotifyFindReply(request_id, false /* final_update */); |
| return; |
| } |
| |
| // This is the final update for all frames for the current find operation. |
| if (request_id == current_request_.id && request_id != current_session_id_) { |
| DCHECK(current_request_.options->find_next); |
| DCHECK_EQ(pending_find_next_reply_, rfh); |
| pending_find_next_reply_ = nullptr; |
| } |
| |
| FinalUpdateReceived(request_id, rfh); |
| } |
| |
| void FindRequestManager::UpdatedFrameNumberOfMatches(RenderFrameHostImpl* rfh, |
| unsigned int old_count, |
| unsigned int new_count) { |
| if (old_count == new_count) |
| return; |
| |
| // Change the number of matches for this frame in the global count. |
| number_of_matches_ -= old_count; |
| number_of_matches_ += new_count; |
| |
| // All matches may have been removed since the last find reply. |
| if (rfh == active_frame_ && !new_count) |
| relative_active_match_ordinal_ = 0; |
| |
| // The active match ordinal may need updating since the number of matches |
| // before the active match may have changed. |
| UpdateActiveMatchOrdinal(); |
| } |
| |
| void FindRequestManager::SetActiveMatchRect( |
| const gfx::Rect& active_match_rect) { |
| selection_rect_ = active_match_rect; |
| } |
| |
| void FindRequestManager::SetActiveMatchOrdinal(RenderFrameHostImpl* rfh, |
| int request_id, |
| int active_match_ordinal) { |
| if (active_match_ordinal > 0) { |
| // Call SetFocusedFrame on the WebContents associated with |rfh| (which |
| // might not be the same as |contents_|, as a WebContents might have |
| // inner WebContents). We need to focus on the frame where the active |
| // match is in, which should be in the |rfh|'s associated WebContents. |
| WebContentsImpl* web_contents = |
| static_cast<WebContentsImpl*>(WebContents::FromRenderFrameHost(rfh)); |
| web_contents->SetFocusedFrame(rfh->frame_tree_node(), |
| rfh->GetSiteInstance()); |
| } |
| if (rfh == active_frame_) { |
| active_match_ordinal_ += |
| active_match_ordinal - relative_active_match_ordinal_; |
| relative_active_match_ordinal_ = active_match_ordinal; |
| } else { |
| if (active_frame_) { |
| // The new active match is in a different frame than the previous, so |
| // the previous active frame needs to be informed (to clear its active |
| // match highlighting). |
| ClearActiveFindMatch(); |
| } |
| active_frame_ = rfh; |
| relative_active_match_ordinal_ = active_match_ordinal; |
| UpdateActiveMatchOrdinal(); |
| } |
| if (pending_active_match_ordinal_ && request_id == current_request_.id) |
| pending_active_match_ordinal_ = false; |
| AdvanceQueue(request_id); |
| } |
| |
| 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 = find_in_page_clients_.find(rfh); |
| if (it != find_in_page_clients_.end()) { |
| number_of_matches_ -= it->second->number_of_matches(); |
| find_in_page_clients_.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 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_initial_replies_.erase(rfh); |
| if (pending_initial_replies_.empty()) { |
| FinalUpdateReceived(current_session_id_, rfh); |
| } |
| } |
| |
| 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); |
| } |
| } |
| |
| void FindRequestManager::ClearActiveFindMatch() { |
| active_frame_->GetFindInPage()->ClearActiveFindMatch(); |
| } |
| |
| #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()) { |
| RenderFrameHostImpl* rfh = node->current_frame_host(); |
| |
| if (!CheckFrame(rfh) || !rfh->IsRenderFrameLive()) |
| continue; |
| |
| activate_.pending_replies.insert(rfh); |
| // Lifetime of FindRequestManager > RenderFrameHost > Mojo connection, |
| // so it's safe to bind |this| and |rfh|. |
| rfh->GetFindInPage()->GetNearestFindResult( |
| activate_.point, |
| base::BindOnce(&FindRequestManager::OnGetNearestFindResultReply, |
| base::Unretained(this), rfh, |
| activate_.current_request_id)); |
| } |
| } |
| } |
| |
| void FindRequestManager::OnGetNearestFindResultReply(RenderFrameHostImpl* 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()) { |
| RenderFrameHostImpl* rfh = node->current_frame_host(); |
| |
| 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->GetFindInPage()->FindMatchRects( |
| version, base::BindOnce(&FindRequestManager::OnFindMatchRectsReply, |
| base::Unretained(this), rfh)); |
| } |
| } |
| } |
| |
| 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::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; |
| find_in_page_clients_.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(); |
| if (!target_rfh || !CheckFrame(target_rfh)) |
| target_rfh = GetInitialFrame(request.options->forward); |
| |
| SendFindRequest(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(std::make_unique<FrameObserver>(contents, this)); |
| 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()) |
| FindInternal(find_request_queue_.front()); |
| } |
| |
| void FindRequestManager::SendFindRequest(const FindRequest& request, |
| RenderFrameHost* rfh) { |
| DCHECK(CheckFrame(rfh)); |
| DCHECK(rfh->IsRenderFrameLive()); |
| |
| if (request.options->find_next) |
| pending_find_next_reply_ = rfh; |
| else |
| pending_initial_replies_.insert(rfh); |
| |
| static_cast<RenderFrameHostImpl*>(rfh)->GetFindInPage()->Find( |
| request.id, base::UTF16ToUTF8(request.search_text), |
| request.options.Clone()); |
| } |
| |
| 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 { |
| 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 || |
| find_in_page_clients_.find(current_rfh)->second->number_of_matches() || |
| 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, bool force) { |
| if (!rfh || !rfh->IsRenderFrameLive()) |
| return; |
| |
| // A frame that is already being searched should not normally be added again. |
| DCHECK(force || !CheckFrame(rfh)); |
| |
| find_in_page_clients_[rfh] = std::make_unique<FindInPageClient>( |
| this, static_cast<RenderFrameHostImpl*>(rfh)); |
| |
| FindRequest request = current_request_; |
| request.id = current_session_id_; |
| request.options->find_next = false; |
| request.options->force = force; |
| SendFindRequest(request, rfh); |
| } |
| |
| bool FindRequestManager::CheckFrame(RenderFrameHost* rfh) const { |
| return rfh && find_in_page_clients_.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_ += find_in_page_clients_[frame]->number_of_matches(); |
| } |
| active_match_ordinal_ += relative_active_match_ordinal_; |
| } |
| |
| void FindRequestManager::FinalUpdateReceived(int request_id, |
| RenderFrameHost* rfh) { |
| if (!number_of_matches_ || |
| (active_match_ordinal_ && !pending_active_match_ordinal_) || |
| pending_find_next_reply_) { |
| // 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 (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) { |
| // 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) || |
| !find_in_page_clients_[target_rfh]->number_of_matches()) { |
| target_rfh = Traverse(target_rfh, current_request_.options->forward, |
| true /* matches_only */, false /* wrap */); |
| } |
| } |
| if (!target_rfh) { |
| // Sometimes when the WebContents is deleted/navigated, we got into this |
| // situation. We don't care about this WebContents anyways so it's ok to |
| // just not ask for the active match and return immediately. |
| // TODO(rakina): Understand what leads to this situation. |
| // See: https://crbug.com/884679. |
| return; |
| } |
| |
| // Forward the find reply without |final_update| set because the active match |
| // has not yet been found. |
| NotifyFindReply(request_id, false /* final_update */); |
| |
| current_request_.options->find_next = true; |
| SendFindRequest(current_request_, target_rfh); |
| } |
| |
| #if defined(OS_ANDROID) |
| void FindRequestManager::RemoveNearestFindResultPendingReply( |
| RenderFrameHost* rfh) { |
| auto it = activate_.pending_replies.find(rfh); |
| if (it == activate_.pending_replies.end()) |
| return; |
| |
| activate_.pending_replies.erase(it); |
| if (activate_.pending_replies.empty() && |
| CheckFrame(activate_.nearest_frame)) { |
| const auto client_it = find_in_page_clients_.find(activate_.nearest_frame); |
| if (client_it != find_in_page_clients_.end()) |
| client_it->second->ActivateNearestFindResult(current_session_id_, |
| activate_.point); |
| } |
| } |
| |
| void FindRequestManager::RemoveFindMatchRectsPendingReply( |
| RenderFrameHost* rfh) { |
| auto it = match_rects_.pending_replies.find(rfh); |
| if (it == match_rects_.pending_replies.end()) |
| return; |
| |
| match_rects_.pending_replies.erase(it); |
| if (match_rects_.pending_replies.empty()) { |
| // All replies are in. |
| std::vector<gfx::RectF> aggregate_rects; |
| if (match_rects_.request_version != match_rects_.known_version) { |
| // Request version is stale, so aggregate and report the newer find |
| // match rects. The rects should be aggregated in search order. |
| for (RenderFrameHost* frame = GetInitialFrame(true /* forward */); frame; |
| frame = Traverse(frame, |
| true /* forward */, |
| true /* matches_only */, |
| false /* wrap */)) { |
| auto frame_it = match_rects_.frame_rects.find(frame); |
| if (frame_it == match_rects_.frame_rects.end()) |
| continue; |
| |
| std::vector<gfx::RectF>& frame_rects = frame_it->second.rects; |
| aggregate_rects.insert( |
| aggregate_rects.end(), frame_rects.begin(), frame_rects.end()); |
| } |
| } |
| contents_->NotifyFindMatchRectsReply( |
| match_rects_.known_version, aggregate_rects, match_rects_.active_rect); |
| } |
| } |
| #endif |
| |
| } // namespace content |