1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
// Copyright 2025 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/permissions/prediction_service/language_detection_observer.h"
#include "chrome/browser/translate/chrome_translate_client.h"
#include "components/permissions/permission_uma_util.h"
#include "components/translate/core/browser/language_state.h"
using ::permissions::LanguageDetectionStatus;
constexpr auto& RecordLanguageDetectionStatus =
::permissions::PermissionUmaUtil::RecordLanguageDetectionStatus;
namespace permissions {
LanguageDetectionObserver::LanguageDetectionObserver() = default;
LanguageDetectionObserver::~LanguageDetectionObserver() = default;
void LanguageDetectionObserver::Init(
content::WebContents* web_contents,
base::OnceCallback<void()> on_english_detected,
base::OnceCallback<void()> on_fallback) {
web_contents_ = web_contents;
on_english_detected_callback_ = std::move(on_english_detected);
fallback_callback_ = std::move(on_fallback);
std::string_view source_language =
chrome_translate_client()->GetLanguageState().source_language();
if (source_language.starts_with("en")) {
RecordLanguageDetectionStatus(
LanguageDetectionStatus::kImmediatelyAvailableEnglish);
std::move(on_english_detected_callback_).Run();
} else if (source_language.empty()) {
chrome_translate_client()
->GetTranslateDriver()
->AddLanguageDetectionObserver(this);
// We start a timer here, in case language detection takes more than
// |kLanguageDetectionTimeout| seconds. It will call the fallback callback
// if the language detection doesn't converge during the timeout interval.
timeout_timer_.Start(FROM_HERE, base::Seconds(kLanguageDetectionTimeout),
base::BindOnce(&LanguageDetectionObserver::OnTimeout,
weak_ptr_factory_.GetWeakPtr()));
} else {
RecordLanguageDetectionStatus(
LanguageDetectionStatus::kImmediatelyAvailableNotEnglish);
std::move(fallback_callback_).Run();
}
}
void LanguageDetectionObserver::Reset() {
RemoveAsObserver();
timeout_timer_.Stop();
web_contents_ = nullptr;
}
ChromeTranslateClient* LanguageDetectionObserver::chrome_translate_client() {
return ChromeTranslateClient::FromWebContents(web_contents_);
}
void LanguageDetectionObserver::RemoveAsObserver() {
if (web_contents_) {
chrome_translate_client()
->GetTranslateDriver()
->RemoveLanguageDetectionObserver(this);
}
}
void LanguageDetectionObserver::OnTimeout() {
RecordLanguageDetectionStatus(LanguageDetectionStatus::kNoResultDueToTimeout);
if (on_english_detected_callback_) {
std::move(fallback_callback_).Run();
}
RemoveAsObserver();
}
bool LanguageDetectionObserver::WaitingForLanguageDetection() {
return timeout_timer_.IsRunning();
}
void LanguageDetectionObserver::OnLanguageDetermined(
const translate::LanguageDetectionDetails& details) {
if (details.adopted_language.starts_with("en") &&
on_english_detected_callback_) {
RecordLanguageDetectionStatus(
LanguageDetectionStatus::kDelayedDetectedEnglish);
std::move(on_english_detected_callback_).Run();
} else if (on_english_detected_callback_) {
RecordLanguageDetectionStatus(
LanguageDetectionStatus::kDelayedDetectedNotEnglish);
std::move(fallback_callback_).Run();
}
timeout_timer_.Stop();
RemoveAsObserver();
}
} // namespace permissions
|
