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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
// Copyright 2014 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_AUTOFILL_DOWNLOAD_MANAGER_H_
#define COMPONENTS_AUTOFILL_CORE_BROWSER_AUTOFILL_DOWNLOAD_MANAGER_H_
#include <stddef.h>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "base/compiler_specific.h"
#include "base/gtest_prod_util.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "components/autofill/core/browser/autofill_type.h"
#include "net/base/backoff_entry.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "url/gurl.h"
namespace autofill {
class AutofillDriver;
class FormStructure;
// Handles getting and updating Autofill heuristics.
class AutofillDownloadManager : public net::URLFetcherDelegate {
public:
enum RequestType { REQUEST_QUERY, REQUEST_UPLOAD, };
// An interface used to notify clients of AutofillDownloadManager.
class Observer {
public:
// Called when field type predictions are successfully received from the
// server. |response| contains the server response for the forms
// represented by |form_signatures|.
virtual void OnLoadedServerPredictions(
std::string response,
const std::vector<std::string>& form_signatures) = 0;
// These notifications are used to help with testing.
// Called when heuristic either successfully considered for upload and
// not send or uploaded.
virtual void OnUploadedPossibleFieldTypes() {}
// Called when there was an error during the request.
// |form_signature| - the signature of the requesting form.
// |request_type| - type of request that failed.
// |http_error| - HTTP error code.
virtual void OnServerRequestError(const std::string& form_signature,
RequestType request_type,
int http_error) {}
protected:
virtual ~Observer() {}
};
// |driver| must outlive this instance.
// |observer| - observer to notify on successful completion or error.
AutofillDownloadManager(AutofillDriver* driver,
Observer* observer);
~AutofillDownloadManager() override;
// Starts a query request to Autofill servers. The observer is called with the
// list of the fields of all requested forms.
// |forms| - array of forms aggregated in this request.
virtual bool StartQueryRequest(const std::vector<FormStructure*>& forms);
// Starts an upload request for the given |form|.
// |available_field_types| should contain the types for which we have data
// stored on the local client.
// |login_form_signature| may be empty. It is non-empty when the user fills
// and submits a login form using a generated password. In this case,
// |login_form_signature| should be set to the submitted form's signature.
// Note that in this case, |form.FormSignature()| gives the signature for the
// registration form on which the password was generated, rather than the
// submitted form's signature.
// |observed_submission| indicates whether the upload request is the result of
// an observed submission event.
virtual bool StartUploadRequest(
const FormStructure& form,
bool form_was_autofilled,
const ServerFieldTypeSet& available_field_types,
const std::string& login_form_signature,
bool observed_submission);
private:
friend class AutofillDownloadManagerTest;
FRIEND_TEST_ALL_PREFIXES(AutofillDownloadManagerTest, QueryAndUploadTest);
FRIEND_TEST_ALL_PREFIXES(AutofillDownloadManagerTest, BackoffLogic_Upload);
FRIEND_TEST_ALL_PREFIXES(AutofillDownloadManagerTest, BackoffLogic_Query);
struct FormRequestData;
typedef std::list<std::pair<std::string, std::string> > QueryRequestCache;
// Returns the URL and request method to use when issuing the request
// described by |request_data|. If the returned method is GET, the URL
// fully encompasses the request, do not include request_data.payload when
// transmitting the request.
std::tuple<GURL, net::URLFetcher::RequestType> GetRequestURLAndMethod(
const FormRequestData& request_data) const;
// Initiates request to Autofill servers to download/upload type predictions.
// |request_data| - form signature hash(es), request payload data and request
// type (query or upload).
// Note: |request_data| takes ownership of request_data, call with std::move.
bool StartRequest(FormRequestData request_data);
// Each request is page visited. We store last |max_form_cache_size|
// request, to avoid going over the wire. Set to 16 in constructor. Warning:
// the search is linear (newest first), so do not make the constant very big.
void set_max_form_cache_size(size_t max_form_cache_size) {
max_form_cache_size_ = max_form_cache_size;
}
// Caches query request. |forms_in_query| is a vector of form signatures in
// the query. |query_data| is the successful data returned over the wire.
void CacheQueryRequest(const std::vector<std::string>& forms_in_query,
const std::string& query_data);
// Returns true if query is in the cache, while filling |query_data|, false
// otherwise. |forms_in_query| is a vector of form signatures in the query.
bool CheckCacheForQueryRequest(const std::vector<std::string>& forms_in_query,
std::string* query_data) const;
// Concatenates |forms_in_query| into one signature.
std::string GetCombinedSignature(
const std::vector<std::string>& forms_in_query) const;
// net::URLFetcherDelegate implementation:
void OnURLFetchComplete(const net::URLFetcher* source) override;
// The AutofillDriver that this instance will use. Must not be null, and must
// outlive this instance.
AutofillDriver* const driver_; // WEAK
// The observer to notify when server predictions are successfully received.
// Must not be null.
AutofillDownloadManager::Observer* const observer_; // WEAK
// The autofill server URL root: scheme://host[:port]/path excluding the
// final path component for the request and the query params.
GURL autofill_server_url_;
// For each requested form for both query and upload we create a separate
// request and save its info. As url fetcher is identified by its address
// we use a map between fetchers and info. The value type is a pair of an
// owning pointer to the key and the actual FormRequestData.
std::map<net::URLFetcher*,
std::pair<std::unique_ptr<net::URLFetcher>, FormRequestData>>
url_fetchers_;
// Cached QUERY requests.
QueryRequestCache cached_forms_;
size_t max_form_cache_size_;
// Used for exponential backoff of requests.
net::BackoffEntry fetcher_backoff_;
// Needed for unit-test.
int fetcher_id_for_unittest_;
base::WeakPtrFactory<AutofillDownloadManager> weak_factory_;
};
} // namespace autofill
#endif // COMPONENTS_AUTOFILL_CORE_BROWSER_AUTOFILL_DOWNLOAD_MANAGER_H_
|
