| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/tab_resumption/visited_url_ranking_backend.h" |
| |
| #include <map> |
| #include <utility> |
| #include <variant> |
| #include <vector> |
| |
| #include "base/android/jni_string.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "base/time/time.h" |
| #include "chrome/browser/sync/session_sync_service_factory.h" |
| #include "chrome/browser/sync/sync_service_factory.h" |
| #include "chrome/browser/visited_url_ranking/visited_url_ranking_service_factory.h" |
| #include "components/sync/base/data_type.h" |
| #include "components/sync/service/sync_service.h" |
| #include "components/sync_sessions/session_sync_service.h" |
| #include "components/visited_url_ranking/public/fetch_options.h" |
| #include "components/visited_url_ranking/public/url_visit.h" |
| #include "components/visited_url_ranking/public/url_visit_util.h" |
| #include "url/android/gurl_android.h" |
| |
| // Must come after all headers that specialize FromJniType() / ToJniType(). |
| #include "chrome/browser/tab_resumption/jni_headers/VisitedUrlRankingBackend_jni.h" |
| |
| using tab_resumption::jni::SuggestionEntryType; |
| |
| namespace { |
| |
| using Source = visited_url_ranking::URLVisit::Source; |
| using FetchSources = |
| base::EnumSet<Source, Source::kNotApplicable, Source::kForeign>; |
| using tab_resumption::jni::Java_VisitedUrlRankingBackend_addSuggestionEntry; |
| using tab_resumption::jni::Java_VisitedUrlRankingBackend_onSuggestions; |
| using tab_resumption::jni::VisitedUrlRankingBackend; |
| |
| using visited_url_ranking::Config; |
| using visited_url_ranking::Fetcher; |
| using visited_url_ranking::FetchOptions; |
| using visited_url_ranking::ResultStatus; |
| using visited_url_ranking::ScoredURLUserAction; |
| using visited_url_ranking::URLVisitAggregate; |
| using visited_url_ranking::URLVisitAggregatesTransformType; |
| using visited_url_ranking::VisitedURLRankingService; |
| |
| // Must match Java Tab.INVALID_TAB_ID. |
| static constexpr int kInvalidTabId = -1; |
| |
| // FetchOptions::CreateDefaultFetchOptionsForTabResumption() specifies data |
| // sources that are currently unavailable. This function returns a simplified |
| // FetchOptions instance. |
| FetchOptions CreateFetchOptionsForTabResumption(base::Time current_time, |
| bool fetch_local_tab, |
| bool fetch_history) { |
| FetchOptions::URLTypeSet expected_types = { |
| FetchOptions::URLType::kActiveRemoteTab}; |
| if (fetch_local_tab) { |
| expected_types.Put(FetchOptions::URLType::kLocalVisit); |
| } |
| if (fetch_history) { |
| expected_types.Put(FetchOptions::URLType::kLocalVisit); |
| expected_types.Put(FetchOptions::URLType::kRemoteVisit); |
| expected_types.Put(FetchOptions::URLType::kCCTVisit); |
| } |
| return FetchOptions::CreateFetchOptionsForTabResumption(expected_types); |
| } |
| |
| // Class to manage tab resumption fetch and rank flow, containing required |
| // parameters and states |
| class FetchAndRankFlow : public base::RefCounted<FetchAndRankFlow> { |
| public: |
| friend base::RefCounted<FetchAndRankFlow>; |
| |
| FetchAndRankFlow(Profile* profile, |
| JNIEnv* env, |
| jni_zero::ScopedJavaGlobalRef<jobject> jobj, |
| base::Time current_time, |
| bool fetch_local_tabs, |
| bool fetch_history, |
| jni_zero::ScopedJavaGlobalRef<jobject> j_suggestions, |
| jni_zero::ScopedJavaGlobalRef<jobject> j_callback) |
| : ranking_service_( |
| visited_url_ranking::VisitedURLRankingServiceFactory::GetInstance() |
| ->GetForProfile(profile)), |
| env_(env), |
| jobj_(jobj), |
| j_suggestions_(j_suggestions), |
| j_callback_(j_callback), |
| fetch_options_(CreateFetchOptionsForTabResumption(current_time, |
| fetch_local_tabs, |
| fetch_history)), |
| config_({.key = visited_url_ranking::kTabResumptionRankerKey}) {} |
| |
| void RunFlow() { |
| ranking_service_->FetchURLVisitAggregates( |
| fetch_options_, |
| base::BindOnce(&FetchAndRankFlow::OnFetched, base::RetainedRef(this))); |
| } |
| |
| private: |
| ~FetchAndRankFlow() = default; |
| |
| // Continuing after RunFlow()'s call to FetchURLVisitAggregates(). |
| void OnFetched(ResultStatus status, |
| std::vector<URLVisitAggregate> aggregates) { |
| if (status != ResultStatus::kSuccess) { |
| Java_VisitedUrlRankingBackend_onSuggestions(env_, j_suggestions_, |
| j_callback_); |
| return; |
| } |
| |
| ranking_service_->RankURLVisitAggregates( |
| config_, std::move(aggregates), |
| base::BindOnce(&FetchAndRankFlow::OnRanked, base::RetainedRef(this))); |
| } |
| |
| // Continuing after OnFetched()'s call to RankVisitAggregates(). |
| void OnRanked(ResultStatus status, |
| std::vector<URLVisitAggregate> aggregates) { |
| if (status != ResultStatus::kSuccess) { |
| Java_VisitedUrlRankingBackend_onSuggestions(env_, j_suggestions_, |
| j_callback_); |
| return; |
| } |
| |
| ranking_service_->DecorateURLVisitAggregates( |
| {}, std::move(aggregates), |
| base::BindOnce(&FetchAndRankFlow::PassResults, |
| base::RetainedRef(this))); |
| } |
| |
| // Translates results to Java objects and passes results to |j_callback_|. |
| void PassResults(visited_url_ranking::ResultStatus status, |
| std::vector<URLVisitAggregate> aggregates) { |
| for (const URLVisitAggregate& aggregate : aggregates) { |
| // TODO(crbug.com/337858147): Choose representative member. For now, just |
| // take the first one. |
| if (aggregate.fetcher_data_map.empty()) { |
| continue; |
| } |
| auto decoration = |
| !aggregate.decorations.empty() |
| ? base::android::ConvertUTF16ToJavaString( |
| env_, |
| visited_url_ranking::GetMostRelevantDecoration(aggregate) |
| .GetDisplayString()) |
| : nullptr; |
| const auto& fetcher_entry = *aggregate.fetcher_data_map.begin(); |
| std::visit( |
| visited_url_ranking::URLVisitVariantHelper{ |
| [&](const URLVisitAggregate::TabData& tab_data) { |
| bool is_local_tab = |
| (tab_data.last_active_tab.session_tag == std::nullopt); |
| Java_VisitedUrlRankingBackend_addSuggestionEntry( |
| env_, jobj_, |
| JniIntWrapper(static_cast<int>( |
| is_local_tab ? SuggestionEntryType::kLocalTab |
| : SuggestionEntryType::kForeignTab)), |
| base::android::ConvertUTF8ToJavaString( |
| env_, |
| tab_data.last_active_tab.session_name.value_or("?")), |
| url::GURLAndroid::FromNativeGURL( |
| env_, tab_data.last_active_tab.visit.url), |
| base::android::ConvertUTF16ToJavaString( |
| env_, tab_data.last_active_tab.visit.title), |
| tab_data.last_active.InMillisecondsSinceUnixEpoch(), |
| is_local_tab ? tab_data.last_active_tab.id : kInvalidTabId, |
| base::android::ConvertUTF8ToJavaString(env_, |
| aggregate.url_key), |
| aggregate.request_id.is_null() |
| ? -1LL |
| : aggregate.request_id.GetUnsafeValue(), |
| nullptr, decoration, !is_local_tab, j_suggestions_); |
| }, |
| [&](const URLVisitAggregate::HistoryData& history_data) { |
| bool need_match_local_tab = |
| history_data.last_visited.context_annotations.on_visit |
| .browser_type == |
| history::VisitContextAnnotations::BrowserType::kTabbed; |
| Java_VisitedUrlRankingBackend_addSuggestionEntry( |
| env_, jobj_, |
| JniIntWrapper( |
| static_cast<int>(SuggestionEntryType::kHistory)), |
| base::android::ConvertUTF8ToJavaString(env_, "?"), |
| url::GURLAndroid::FromNativeGURL( |
| env_, history_data.last_visited.url_row.url()), |
| base::android::ConvertUTF16ToJavaString( |
| env_, history_data.last_visited.url_row.title()), |
| history_data.last_visited.visit_row.visit_time |
| .InMillisecondsSinceUnixEpoch(), |
| kInvalidTabId, |
| base::android::ConvertUTF8ToJavaString(env_, |
| aggregate.url_key), |
| aggregate.request_id.is_null() |
| ? -1LL |
| : aggregate.request_id.GetUnsafeValue(), |
| history_data.last_app_id |
| ? base::android::ConvertUTF8ToJavaString( |
| env_, *history_data.last_app_id) |
| : nullptr, |
| decoration, need_match_local_tab, j_suggestions_); |
| }}, |
| fetcher_entry.second); |
| } |
| |
| Java_VisitedUrlRankingBackend_onSuggestions(env_, j_suggestions_, |
| j_callback_); |
| } |
| |
| private: |
| raw_ptr<visited_url_ranking::VisitedURLRankingService> ranking_service_; |
| raw_ptr<JNIEnv> env_; |
| jni_zero::ScopedJavaGlobalRef<jobject> jobj_; |
| jni_zero::ScopedJavaGlobalRef<jobject> j_suggestions_; |
| jni_zero::ScopedJavaGlobalRef<jobject> j_callback_; |
| const FetchOptions fetch_options_; |
| const Config config_; |
| }; |
| |
| } // namespace |
| |
| namespace tab_resumption::jni { |
| |
| static jlong JNI_VisitedUrlRankingBackend_Init( |
| JNIEnv* env, |
| const jni_zero::JavaParamRef<jobject>& jobj, |
| Profile* profile) { |
| return reinterpret_cast<intptr_t>( |
| new VisitedUrlRankingBackend(jobj, profile)); |
| } |
| |
| VisitedUrlRankingBackend::VisitedUrlRankingBackend( |
| const jni_zero::JavaRef<jobject>& jobj, |
| Profile* profile) |
| : jobj_(jni_zero::ScopedJavaGlobalRef<jobject>(jobj)), profile_(profile) { |
| sync_sessions::SessionSyncService* session_sync_service = |
| SessionSyncServiceFactory::GetInstance()->GetForProfile(profile_); |
| |
| // SessionSyncService can be null in tests. |
| if (session_sync_service) { |
| // base::Unretained() is safe below because the subscription itself is a |
| // class member field and handles destruction well. |
| foreign_session_updated_subscription_ = |
| session_sync_service->SubscribeToForeignSessionsChanged( |
| base::BindRepeating(&VisitedUrlRankingBackend::OnRefresh, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| } |
| |
| VisitedUrlRankingBackend::~VisitedUrlRankingBackend() = default; |
| |
| void VisitedUrlRankingBackend::Destroy(JNIEnv* env) { |
| jobj_ = nullptr; |
| delete this; |
| } |
| |
| void VisitedUrlRankingBackend::TriggerUpdate(JNIEnv* env) { |
| syncer::SyncService* service = SyncServiceFactory::GetForProfile(profile_); |
| if (!service) { |
| return; |
| } |
| |
| service->TriggerRefresh({syncer::SESSIONS}); |
| } |
| |
| void VisitedUrlRankingBackend::GetRankedSuggestions( |
| JNIEnv* env, |
| jlong current_time_ms, |
| jboolean fetch_local_tabs, |
| jboolean fetch_history, |
| const jni_zero::JavaParamRef<jobject>& suggestions, |
| const jni_zero::JavaParamRef<jobject>& callback) { |
| jni_zero::ScopedJavaGlobalRef<jobject> j_suggestions(env, suggestions); |
| jni_zero::ScopedJavaGlobalRef<jobject> j_callback(env, callback); |
| |
| auto current_time = |
| base::Time::FromMillisecondsSinceUnixEpoch(current_time_ms); |
| scoped_refptr<FetchAndRankFlow> flow = base::MakeRefCounted<FetchAndRankFlow>( |
| profile_, env, jobj_, current_time, fetch_local_tabs, fetch_history, |
| j_suggestions, j_callback); |
| |
| flow->RunFlow(); |
| } |
| |
| void VisitedUrlRankingBackend::RecordAction(JNIEnv* env, |
| jint scored_url_user_action, |
| jstring visit_id, |
| jlong visit_request_id) { |
| visited_url_ranking::VisitedURLRankingService* ranking_service = |
| visited_url_ranking::VisitedURLRankingServiceFactory::GetInstance() |
| ->GetForProfile(profile_); |
| if (!ranking_service) { |
| return; |
| } |
| ranking_service->RecordAction( |
| static_cast<ScoredURLUserAction>(scored_url_user_action), |
| base::android::ConvertJavaStringToUTF8(env, visit_id), |
| segmentation_platform::TrainingRequestId::FromUnsafeValue( |
| visit_request_id)); |
| } |
| |
| void VisitedUrlRankingBackend::OnRefresh() { |
| JNIEnv* env = jni_zero::AttachCurrentThread(); |
| Java_VisitedUrlRankingBackend_onRefresh(env, jobj_); |
| } |
| |
| } // namespace tab_resumption::jni |
