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
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_AUTOFILL_CORE_BROWSER_FORM_FIELD_H_
#define COMPONENTS_AUTOFILL_CORE_BROWSER_FORM_FIELD_H_
#include <memory>
#include <vector>
#include "base/gtest_prod_util.h"
#include "base/macros.h"
#include "base/strings/string16.h"
#include "components/autofill/core/browser/field_candidates.h"
#include "components/autofill/core/browser/field_types.h"
namespace autofill {
class AutofillField;
class AutofillScanner;
// Represents a logical form field in a web form. Classes that implement this
// interface can identify themselves as a particular type of form field, e.g.
// name, phone number, or address field.
class FormField {
public:
virtual ~FormField() {}
// Classifies each field in |fields| with its heuristically detected type.
// Each field has a derived unique name that is used as the key into the
// returned FieldCandidatesMap.
static FieldCandidatesMap ParseFormFields(
const std::vector<std::unique_ptr<AutofillField>>& fields,
bool is_form_tag);
protected:
// A bit-field used for matching specific parts of a field in question.
enum MatchType {
// Attributes.
MATCH_LABEL = 1 << 0,
MATCH_NAME = 1 << 1,
// Input types.
MATCH_TEXT = 1 << 2,
MATCH_EMAIL = 1 << 3,
MATCH_TELEPHONE = 1 << 4,
MATCH_SELECT = 1 << 5,
MATCH_TEXT_AREA = 1 << 6,
MATCH_PASSWORD = 1 << 7,
MATCH_NUMBER = 1 << 8,
MATCH_ALL_INPUTS =
MATCH_TEXT | MATCH_EMAIL | MATCH_TELEPHONE | MATCH_SELECT |
MATCH_TEXT_AREA | MATCH_PASSWORD | MATCH_NUMBER,
// By default match label and name for input/text types.
MATCH_DEFAULT = MATCH_LABEL | MATCH_NAME | MATCH_TEXT,
};
// Initial values assigned to FieldCandidates by their corresponding parsers.
static const float kBaseEmailParserScore;
static const float kBasePhoneParserScore;
static const float kBaseAddressParserScore;
static const float kBaseCreditCardParserScore;
static const float kBaseNameParserScore;
// Only derived classes may instantiate.
FormField() {}
// Attempts to parse a form field with the given pattern. Returns true on
// success and fills |match| with a pointer to the field.
static bool ParseField(AutofillScanner* scanner,
const base::string16& pattern,
AutofillField** match);
// Parses the stream of fields in |scanner| with regular expression |pattern|
// as specified in the |match_type| bit field (see |MatchType|). If |match|
// is non-NULL and the pattern matches, the matched field is returned.
// A |true| result is returned in the case of a successful match, false
// otherwise.
static bool ParseFieldSpecifics(AutofillScanner* scanner,
const base::string16& pattern,
int match_type,
AutofillField** match);
// Attempts to parse a field with an empty label. Returns true
// on success and fills |match| with a pointer to the field.
static bool ParseEmptyLabel(AutofillScanner* scanner, AutofillField** match);
// Adds an association between a |field| and a |type| into |field_candidates|.
// This association is weighted by |score|, the higher the stronger the
// association.
static void AddClassification(const AutofillField* field,
ServerFieldType type,
float score,
FieldCandidatesMap* field_candidates);
// Returns true iff |type| matches |match_type|.
static bool MatchesFormControlType(const std::string& type, int match_type);
// Derived classes must implement this interface to supply field type
// information. |ParseFormFields| coordinates the parsing and extraction
// of types from an input vector of |AutofillField| objects and delegates
// the type extraction via this method.
virtual void AddClassifications(
FieldCandidatesMap* field_candidates) const = 0;
private:
FRIEND_TEST_ALL_PREFIXES(FormFieldTest, Match);
// Function pointer type for the parsing function that should be passed to the
// ParseFormFieldsPass() helper function.
typedef std::unique_ptr<FormField> ParseFunction(AutofillScanner* scanner);
// Matches |pattern| to the contents of the field at the head of the
// |scanner|.
// Returns |true| if a match is found according to |match_type|, and |false|
// otherwise.
static bool MatchAndAdvance(AutofillScanner* scanner,
const base::string16& pattern,
int match_type,
AutofillField** match);
// Matches the regular expression |pattern| against the components of |field|
// as specified in the |match_type| bit field (see |MatchType|).
static bool Match(const AutofillField* field,
const base::string16& pattern,
int match_type);
// Perform a "pass" over the |fields| where each pass uses the supplied
// |parse| method to match content to a given field type.
// |fields| is both an input and an output parameter. Upon exit |fields|
// holds any remaining unclassified fields for further processing.
// Classification results of the processed fields are stored in
// |field_candidates|.
static void ParseFormFieldsPass(ParseFunction parse,
const std::vector<AutofillField*>& fields,
FieldCandidatesMap* field_candidates);
DISALLOW_COPY_AND_ASSIGN(FormField);
};
} // namespace autofill
#endif // COMPONENTS_AUTOFILL_CORE_BROWSER_FORM_FIELD_H_
|
