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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/android_autofill/browser/form_field_data_android.h"
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
#include "components/android_autofill/browser/android_autofill_bridge_factory.h"
#include "components/android_autofill/browser/form_field_data_android_bridge.h"
#include "components/autofill/core/browser/field_types.h"
#include "components/autofill/core/common/autofill_util.h"
#include "components/autofill/core/common/form_field_data.h"
namespace autofill {
using base::android::ScopedJavaLocalRef;
FormFieldDataAndroid::FieldTypes::FieldTypes() = default;
FormFieldDataAndroid::FieldTypes::FieldTypes(FieldType type)
: heuristic_type(type),
server_type(type),
computed_type(FieldTypeToStringView(type)),
server_predictions({type}) {}
FormFieldDataAndroid::FieldTypes::FieldTypes(
FieldType heuristic_type,
FieldType server_type,
std::string_view computed_type,
std::vector<FieldType> server_predictions)
: heuristic_type(heuristic_type),
server_type(server_type),
computed_type(computed_type),
server_predictions(std::move(server_predictions)) {}
FormFieldDataAndroid::FieldTypes::FieldTypes(FieldTypes&&) = default;
FormFieldDataAndroid::FieldTypes& FormFieldDataAndroid::FieldTypes::operator=(
FieldTypes&&) = default;
FormFieldDataAndroid::FieldTypes::~FieldTypes() = default;
bool FormFieldDataAndroid::FieldTypes::operator==(FieldType type) const {
return heuristic_type == type && server_type == type &&
computed_type == FieldTypeToStringView(type) &&
server_predictions.size() == 1 && server_predictions[0] == type;
}
FormFieldDataAndroid::FormFieldDataAndroid(FormFieldData* field)
: bridge_(AndroidAutofillBridgeFactory::GetInstance()
.CreateFormFieldDataAndroidBridge()),
field_(*field) {
field_types_.heuristic_type = UNKNOWN_TYPE;
}
FormFieldDataAndroid::~FormFieldDataAndroid() = default;
ScopedJavaLocalRef<jobject> FormFieldDataAndroid::GetJavaPeer() {
return bridge_->GetOrCreateJavaPeer(*field_, field_types_);
}
void FormFieldDataAndroid::UpdateFromJava() {
bridge_->UpdateFieldFromJava(*field_);
}
void FormFieldDataAndroid::OnFormFieldDidChange(std::u16string_view value) {
field_->set_value(std::u16string(value));
field_->set_is_autofilled(false);
bridge_->UpdateValue(value);
}
void FormFieldDataAndroid::OnFormFieldVisibilityDidChange(
const FormFieldData& field) {
field_->set_is_focusable(field.is_focusable());
field_->set_role(field.role());
CHECK_EQ(field_->IsFocusable(), field.IsFocusable());
bridge_->UpdateVisible(field_->IsFocusable());
}
bool FormFieldDataAndroid::SimilarFieldAs(const FormFieldData& field) const {
auto SimilarityTuple = [](const FormFieldData& f) {
return std::tuple_cat(
std::tie(f.host_frame(), f.name(), f.name_attribute(),
f.id_attribute()),
std::make_tuple(f.renderer_id(), f.form_control_type(),
IsCheckable(f.check_status())));
};
// For Android Autofill, labels are considered similar if they meet one of the
// following two conditions:
// 1. The labels have the same value.
// 2. The labels were inferred from the same type of source and that source
// was not `LabelSource::kLabelTag`.
auto LabelsAreSimilar = [](const FormFieldData& f1, const FormFieldData& f2) {
return f1.label() == f2.label() ||
(f1.label_source() != FormFieldData::LabelSource::kLabelTag &&
f1.label_source() == f2.label_source());
};
return SimilarityTuple(*field_) == SimilarityTuple(field) &&
LabelsAreSimilar(*field_, field);
}
void FormFieldDataAndroid::UpdateFieldTypes(FieldTypes field_types) {
field_types_ = std::move(field_types);
bridge_->UpdateFieldTypes(field_types_);
}
} // namespace autofill
|
