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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// 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_data_android.h"
#include <memory>
#include <string_view>
#include <tuple>
#include "base/containers/flat_map.h"
#include "base/feature_list.h"
#include "components/android_autofill/browser/android_autofill_bridge_factory.h"
#include "components/android_autofill/browser/form_data_android_bridge.h"
#include "components/android_autofill/browser/form_field_data_android.h"
#include "components/autofill/core/browser/autofill_field.h"
#include "components/autofill/core/browser/field_types.h"
#include "components/autofill/core/browser/form_structure.h"
#include "components/autofill/core/common/autofill_features.h"
#include "components/autofill/core/common/form_field_data.h"
#include "components/autofill/core/common/unique_ids.h"
namespace autofill {
FormDataAndroid::FormDataAndroid(const FormData& form, SessionId session_id)
: session_id_(session_id),
form_(form),
bridge_(AndroidAutofillBridgeFactory::GetInstance()
.CreateFormDataAndroidBridge()) {
fields_.reserve(form_.fields().size());
for (FormFieldData& field : form_.mutable_fields(/*pass_key=*/{})) {
fields_.push_back(std::make_unique<FormFieldDataAndroid>(&field));
}
}
FormDataAndroid::~FormDataAndroid() = default;
base::android::ScopedJavaLocalRef<jobject> FormDataAndroid::GetJavaPeer() {
return bridge_->GetOrCreateJavaPeer(form_, session_id_, fields_);
}
void FormDataAndroid::UpdateFromJava() {
for (std::unique_ptr<FormFieldDataAndroid>& field : fields_)
field->UpdateFromJava();
}
void FormDataAndroid::OnFormFieldDidChange(size_t index,
std::u16string_view value) {
fields_[index]->OnFormFieldDidChange(value);
}
bool FormDataAndroid::GetFieldIndex(const FormFieldData& field, size_t* index) {
for (size_t i = 0; i < form_.fields().size(); ++i) {
if (base::FeatureList::IsEnabled(
features::kAutofillUseDeepEqualInsteadOfSameFieldAs)
? FormFieldData::DeepEqual(form_.fields()[i], field)
: form_.fields()[i].SameFieldAs(field)) {
*index = i;
return true;
}
}
return false;
}
bool FormDataAndroid::GetSimilarFieldIndex(const FormFieldData& field,
size_t* index) {
for (size_t i = 0; i < form_.fields().size(); ++i) {
if (fields_[i]->SimilarFieldAs(field)) {
*index = i;
return true;
}
}
return false;
}
bool FormDataAndroid::SimilarFieldsAs(const FormData& form) const {
if (fields_.size() != form.fields().size()) {
return false;
}
for (size_t i = 0; i < fields_.size(); ++i) {
if (!fields_[i]->SimilarFieldAs(form.fields()[i])) {
return false;
}
}
return true;
}
bool FormDataAndroid::SimilarFormAs(const FormData& form) const {
// Note that comparing unique renderer ids alone is not a strict enough check,
// since these remain constant even if the page has dynamically modified its
// fields to have different labels, form control types, etc.
auto SimilarityTuple = [](const FormData& f) {
return std::tie(f.host_frame(), f.renderer_id(), f.name(), f.id_attribute(),
f.name_attribute(), f.url(), f.action());
};
return SimilarityTuple(form_) == SimilarityTuple(form) &&
SimilarFieldsAs(form);
}
void FormDataAndroid::UpdateFieldTypes(const FormStructure& form_structure) {
// Map FieldGlobalId's to their respective AutofillField, this way we can
// quickly ignore below FormFieldDataAndroid's with no matching AutofillField.
auto autofill_fields = base::MakeFlatMap<FieldGlobalId, const AutofillField*>(
form_structure, {}, [](const auto& field) {
return std::make_pair(field->global_id(), field.get());
});
for (auto& form_field_data_android : fields_) {
if (auto it = autofill_fields.find(form_field_data_android->global_id());
it != autofill_fields.end()) {
const AutofillField* autofill_field = it->second;
std::vector<FieldType> server_predictions;
for (const auto& prediction : autofill_field->server_predictions()) {
server_predictions.emplace_back(
ToSafeFieldType(prediction.type(), NO_SERVER_DATA));
}
form_field_data_android->UpdateFieldTypes(
FormFieldDataAndroid::FieldTypes(
autofill_field->heuristic_type(), autofill_field->server_type(),
autofill_field->ComputedType().ToStringView(),
std::move(server_predictions)));
}
}
}
void FormDataAndroid::UpdateFieldTypes(
const base::flat_map<FieldGlobalId, FieldType>& types) {
for (const std::unique_ptr<FormFieldDataAndroid>& field : fields_) {
auto it = types.find(field->global_id());
if (it == types.end()) {
continue;
}
FieldType new_type = it->second;
if (field->field_types() != new_type) {
field->UpdateFieldTypes(FormFieldDataAndroid::FieldTypes(new_type));
}
}
}
std::vector<int> FormDataAndroid::UpdateFieldVisibilities(
const FormData& form) {
CHECK_EQ(form_.fields().size(), form.fields().size());
CHECK_EQ(form_.fields().size(), fields_.size());
// We rarely expect to find any difference in visibility - therefore do not
// reserve space in the vector.
std::vector<int> indices;
for (size_t i = 0; i < form_.fields().size(); ++i) {
if (form_.fields()[i].IsFocusable() != form.fields()[i].IsFocusable()) {
fields_[i]->OnFormFieldVisibilityDidChange(form.fields()[i]);
indices.push_back(i);
}
}
return indices;
}
} // namespace autofill
|
