// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#import "ios/web/find_in_page/java_script_find_in_page_manager_impl.h"
#import <optional>
#import "base/metrics/user_metrics.h"
#import "base/metrics/user_metrics_action.h"
#import "base/strings/sys_string_conversions.h"
#import "base/values.h"
#import "ios/web/find_in_page/find_in_page_constants.h"
#import "ios/web/find_in_page/find_in_page_java_script_feature.h"
#import "ios/web/find_in_page/find_in_page_metrics.h"
#import "ios/web/public/find_in_page/find_in_page_manager_delegate.h"
#import "ios/web/public/js_messaging/web_frame.h"
#import "ios/web/public/js_messaging/web_frames_manager.h"
#import "ios/web/public/thread/web_task_traits.h"
#import "ios/web/public/thread/web_thread.h"
#import "ios/web/web_state/web_state_impl.h"
namespace web {
// static
void JavaScriptFindInPageManager::CreateForWebState(WebState* web_state) {
DCHECK(web_state);
if (!FromWebState(web_state)) {
web_state->SetUserData(
UserDataKey(),
std::make_unique<JavaScriptFindInPageManagerImpl>(web_state));
}
}
JavaScriptFindInPageManagerImpl::JavaScriptFindInPageManagerImpl(
WebState* web_state)
: web_state_(web_state), weak_factory_(this) {
web_state_->AddObserver(this);
web::WebFramesManager* web_frames_manager =
FindInPageJavaScriptFeature::GetInstance()->GetWebFramesManager(
web_state);
web_frames_manager->AddObserver(this);
}
JavaScriptFindInPageManagerImpl::~JavaScriptFindInPageManagerImpl() {
if (web_state_) {
web_state_->RemoveObserver(this);
web_state_ = nullptr;
}
}
FindInPageManagerDelegate* JavaScriptFindInPageManagerImpl::GetDelegate() {
return delegate_;
}
void JavaScriptFindInPageManagerImpl::SetDelegate(
FindInPageManagerDelegate* delegate) {
delegate_ = delegate;
}
void JavaScriptFindInPageManagerImpl::WebFrameBecameAvailable(
WebFramesManager* web_frames_manager,
WebFrame* web_frame) {
const std::string frame_id = web_frame->GetFrameId();
last_find_request_.AddFrame(web_frame);
}
void JavaScriptFindInPageManagerImpl::WebFrameBecameUnavailable(
WebFramesManager* web_frames_manager,
const std::string& frame_id) {
int match_count = last_find_request_.GetMatchCountForFrame(frame_id);
last_find_request_.RemoveFrame(frame_id);
// Only notify the delegate if the match count has changed.
if (delegate_ && last_find_request_.GetRequestQuery() && match_count > 0) {
delegate_->DidHighlightMatches(this, web_state_,
last_find_request_.GetTotalMatchCount(),
last_find_request_.GetRequestQuery());
}
}
void JavaScriptFindInPageManagerImpl::WebStateDestroyed(WebState* web_state) {
web_state_->RemoveObserver(this);
web_state_ = nullptr;
}
void JavaScriptFindInPageManagerImpl::Find(NSString* query,
FindInPageOptions options) {
DCHECK(CanSearchContent());
switch (options) {
case FindInPageOptions::FindInPageSearch:
DCHECK(query);
StartSearch(query);
break;
case FindInPageOptions::FindInPageNext:
SelectNextMatch();
break;
case FindInPageOptions::FindInPagePrevious:
SelectPreviousMatch();
break;
}
}
void JavaScriptFindInPageManagerImpl::StartSearch(NSString* query) {
if (!web_state_) {
return;
}
RecordSearchStartedAction();
WebFramesManager* frames_manager =
FindInPageJavaScriptFeature::GetInstance()->GetWebFramesManager(
web_state_);
std::set<WebFrame*> all_frames = frames_manager->GetAllWebFrames();
last_find_request_.Reset(query, all_frames.size());
if (all_frames.size() == 0) {
// No frames to search in.
// Call asyncronously to match behavior if find was successful in frames.
GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(
&JavaScriptFindInPageManagerImpl::LastFindRequestCompleted,
weak_factory_.GetWeakPtr()));
return;
}
for (WebFrame* frame : all_frames) {
bool result = FindInPageJavaScriptFeature::GetInstance()->Search(
frame, base::SysNSStringToUTF8(query),
base::BindOnce(
&JavaScriptFindInPageManagerImpl::ProcessFindInPageResult,
weak_factory_.GetWeakPtr(), frame->GetFrameId(),
last_find_request_.GetRequestId()));
if (!result) {
// Calling JavaScript function failed or the frame does not support
// messaging.
last_find_request_.DidReceiveFindResponseFromOneFrame();
if (last_find_request_.AreAllFindResponsesReturned()) {
// Call asyncronously to match behavior if find was done in frames.
GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(
&JavaScriptFindInPageManagerImpl::LastFindRequestCompleted,
weak_factory_.GetWeakPtr()));
}
}
}
}
void JavaScriptFindInPageManagerImpl::StopFinding() {
if (!web_state_) {
return;
}
last_find_request_.Reset(/*new_query=*/nil,
/*new_pending_frame_call_count=*/0);
WebFramesManager* frames_manager =
FindInPageJavaScriptFeature::GetInstance()->GetWebFramesManager(
web_state_);
std::set<WebFrame*> all_frames = frames_manager->GetAllWebFrames();
for (WebFrame* frame : all_frames) {
FindInPageJavaScriptFeature::GetInstance()->Stop(frame);
}
if (delegate_) {
delegate_->DidHighlightMatches(this, web_state_,
last_find_request_.GetTotalMatchCount(),
last_find_request_.GetRequestQuery());
}
}
bool JavaScriptFindInPageManagerImpl::CanSearchContent() {
return web_state_->ContentIsHTML();
}
void JavaScriptFindInPageManagerImpl::ProcessFindInPageResult(
const std::string& frame_id,
const int unique_id,
std::optional<int> result_matches) {
if (unique_id != last_find_request_.GetRequestId()) {
// New find was started or current find was stopped.
return;
}
if (!web_state_) {
// WebState was destroyed before find finished.
return;
}
FindInPageJavaScriptFeature* feature =
FindInPageJavaScriptFeature::GetInstance();
WebFrame* frame =
feature->GetWebFramesManager(web_state_)->GetFrameWithId(frame_id);
if (!result_matches || !frame) {
// The frame no longer exists or the function call timed out. In both cases,
// result will be null.
// Zero out count to ensure every frame is updated for every find.
last_find_request_.SetMatchCountForFrame(0, frame_id);
} else {
// If response is equal to kFindInPagePending, find did not finish in the
// JavaScript. Call pumpSearch to continue find.
if (result_matches.value() == find_in_page::kFindInPagePending) {
feature->Pump(
frame, base::BindOnce(
&JavaScriptFindInPageManagerImpl::ProcessFindInPageResult,
weak_factory_.GetWeakPtr(), frame_id, unique_id));
return;
}
last_find_request_.SetMatchCountForFrame(result_matches.value(), frame_id);
}
last_find_request_.DidReceiveFindResponseFromOneFrame();
if (last_find_request_.AreAllFindResponsesReturned()) {
LastFindRequestCompleted();
}
}
void JavaScriptFindInPageManagerImpl::LastFindRequestCompleted() {
if (delegate_) {
delegate_->DidHighlightMatches(this, web_state_,
last_find_request_.GetTotalMatchCount(),
last_find_request_.GetRequestQuery());
}
int total_matches = last_find_request_.GetTotalMatchCount();
if (total_matches == 0) {
return;
}
if (last_find_request_.GoToFirstMatch()) {
SelectCurrentMatch();
}
}
void JavaScriptFindInPageManagerImpl::SelectDidFinish(
const base::Value* result) {
std::string match_context_string;
if (result && result->is_dict()) {
const base::Value::Dict& result_dict = result->GetDict();
// Get updated match count.
const std::optional<double> matches =
result_dict.FindDouble(kSelectAndScrollResultMatches);
if (matches) {
int match_count = static_cast<int>(matches.value());
if (match_count != last_find_request_.GetMatchCountForSelectedFrame()) {
last_find_request_.SetMatchCountForSelectedFrame(match_count);
if (delegate_) {
delegate_->DidHighlightMatches(
this, web_state_, last_find_request_.GetTotalMatchCount(),
last_find_request_.GetRequestQuery());
}
}
}
// Get updated currently selected index.
const std::optional<double> index =
result_dict.FindDouble(kSelectAndScrollResultIndex);
if (index) {
int current_index = static_cast<int>(index.value());
last_find_request_.SetCurrentSelectedMatchFrameIndex(current_index);
}
// Get context string.
const std::string* context_string =
result_dict.FindString(kSelectAndScrollResultContextString);
if (context_string) {
match_context_string = *context_string;
}
}
if (delegate_) {
delegate_->DidSelectMatch(
this, web_state_, last_find_request_.GetCurrentSelectedMatchPageIndex(),
base::SysUTF8ToNSString(match_context_string));
}
}
void JavaScriptFindInPageManagerImpl::SelectNextMatch() {
if (last_find_request_.GetTotalMatchCount() > 2) {
// Only record if number of matches is greater than 2 so
// JavaScriptFindInPageManagerImpl and FindInPageManagerImpl can be
// compared. The latter lacks the ability to differentiate between FindNext
// and FindPrevious metrics for 2 matches or less.
RecordFindNextAction();
}
if (last_find_request_.GoToNextMatch()) {
SelectCurrentMatch();
}
}
void JavaScriptFindInPageManagerImpl::SelectPreviousMatch() {
if (last_find_request_.GetTotalMatchCount() > 2) {
// Only record if number of matches is greater than 2 so
// JavaScriptFindInPageManagerImpl and FindInPageManagerImpl can be
// compared. The latter lacks the ability to differentiate between FindNext
// and FindPrevious metrics for 2 matches or less.
RecordFindPreviousAction();
}
if (last_find_request_.GoToPreviousMatch()) {
SelectCurrentMatch();
}
}
void JavaScriptFindInPageManagerImpl::SelectCurrentMatch() {
FindInPageJavaScriptFeature* feature =
FindInPageJavaScriptFeature::GetInstance();
WebFrame* frame =
feature->GetWebFramesManager(web_state_)
->GetFrameWithId(last_find_request_.GetSelectedFrameId());
if (frame) {
feature->SelectMatch(
frame, last_find_request_.GetCurrentSelectedMatchFrameIndex(),
base::BindOnce(&JavaScriptFindInPageManagerImpl::SelectDidFinish,
weak_factory_.GetWeakPtr()));
}
}
WEB_STATE_USER_DATA_KEY_IMPL(JavaScriptFindInPageManager)
} // namespace web
Codebase Browser
chromium