autofill_download_manager.h revision 5f1c94371a64b3196d4be9466099bb892df9b88e 
1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef COMPONENTS_AUTOFILL_CORE_BROWSER_AUTOFILL_DOWNLOAD_MANAGER_H_
6#define COMPONENTS_AUTOFILL_CORE_BROWSER_AUTOFILL_DOWNLOAD_MANAGER_H_
7
8#include <stddef.h>
9#include <list>
10#include <map>
11#include <string>
12#include <utility>
13#include <vector>
14
15#include "base/compiler_specific.h"
16#include "base/gtest_prod_util.h"
17#include "base/time/time.h"
18#include "components/autofill/core/browser/autofill_type.h"
19#include "net/url_request/url_fetcher_delegate.h"
20
21class PrefService;
22
23namespace net {
24class URLFetcher;
25}  // namespace net
26
27namespace autofill {
28
29class AutofillDriver;
30class AutofillMetrics;
31class FormStructure;
32
33// Handles getting and updating Autofill heuristics.
34class AutofillDownloadManager : public net::URLFetcherDelegate {
35 public:
36  enum RequestType { REQUEST_QUERY, REQUEST_UPLOAD, };
37
38  // An interface used to notify clients of AutofillDownloadManager.
39  class Observer {
40   public:
41    // Called when field type predictions are successfully received from the
42    // server.  |response_xml| contains the server response.
43    virtual void OnLoadedServerPredictions(const std::string& response_xml) = 0;
44
45    // These notifications are used to help with testing.
46    // Called when heuristic either successfully considered for upload and
47    // not send or uploaded.
48    virtual void OnUploadedPossibleFieldTypes() {}
49    // Called when there was an error during the request.
50    // |form_signature| - the signature of the requesting form.
51    // |request_type| - type of request that failed.
52    // |http_error| - HTTP error code.
53    virtual void OnServerRequestError(const std::string& form_signature,
54                                      RequestType request_type,
55                                      int http_error) {}
56
57   protected:
58    virtual ~Observer() {}
59  };
60
61  // |driver| and |pref_service| must outlive this instance.
62  // |observer| - observer to notify on successful completion or error.
63  AutofillDownloadManager(AutofillDriver* driver,
64                          PrefService* pref_service,
65                          Observer* observer);
66  virtual ~AutofillDownloadManager();
67
68  // Starts a query request to Autofill servers. The observer is called with the
69  // list of the fields of all requested forms.
70  // |forms| - array of forms aggregated in this request.
71  bool StartQueryRequest(const std::vector<FormStructure*>& forms,
72                         const AutofillMetrics& metric_logger);
73
74  // Starts an upload request for the given |form|, unless throttled by the
75  // server. The probability of the request going over the wire is
76  // GetPositiveUploadRate() if |form_was_autofilled| is true, or
77  // GetNegativeUploadRate() otherwise. The observer will be called even if
78  // there was no actual trip over the wire.
79  // |available_field_types| should contain the types for which we have data
80  // stored on the local client.
81  bool StartUploadRequest(const FormStructure& form,
82                          bool form_was_autofilled,
83                          const ServerFieldTypeSet& available_field_types);
84
85 private:
86  friend class AutofillDownloadTest;
87  FRIEND_TEST_ALL_PREFIXES(AutofillDownloadTest, QueryAndUploadTest);
88
89  struct FormRequestData;
90  typedef std::list<std::pair<std::string, std::string> > QueryRequestCache;
91
92  // Initiates request to Autofill servers to download/upload heuristics.
93  // |form_xml| - form structure XML to upload/download.
94  // |request_data| - form signature hash(es) and indicator if it was a query.
95  // |request_data.query| - if true the data is queried and observer notified
96  //   with new data, if available. If false heuristic data is uploaded to our
97  //   servers.
98  bool StartRequest(const std::string& form_xml,
99                    const FormRequestData& request_data);
100
101  // Each request is page visited. We store last |max_form_cache_size|
102  // request, to avoid going over the wire. Set to 16 in constructor. Warning:
103  // the search is linear (newest first), so do not make the constant very big.
104  void set_max_form_cache_size(size_t max_form_cache_size) {
105    max_form_cache_size_ = max_form_cache_size;
106  }
107
108  // Caches query request. |forms_in_query| is a vector of form signatures in
109  // the query. |query_data| is the successful data returned over the wire.
110  void CacheQueryRequest(const std::vector<std::string>& forms_in_query,
111                         const std::string& query_data);
112  // Returns true if query is in the cache, while filling |query_data|, false
113  // otherwise. |forms_in_query| is a vector of form signatures in the query.
114  bool CheckCacheForQueryRequest(const std::vector<std::string>& forms_in_query,
115                                 std::string* query_data) const;
116  // Concatenates |forms_in_query| into one signature.
117  std::string GetCombinedSignature(
118      const std::vector<std::string>& forms_in_query) const;
119
120  // net::URLFetcherDelegate implementation:
121  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
122
123  // Probability of the form upload. Between 0 (no upload) and 1 (upload all).
124  // GetPositiveUploadRate() is for matched forms,
125  // GetNegativeUploadRate() for non-matched.
126  double GetPositiveUploadRate() const;
127  double GetNegativeUploadRate() const;
128  void SetPositiveUploadRate(double rate);
129  void SetNegativeUploadRate(double rate);
130
131  // The AutofillDriver that this instance will use. Must not be null, and must
132  // outlive this instance.
133  AutofillDriver* const driver_;  // WEAK
134
135  // The PrefService that this instance will use. Must not be null, and must
136  // outlive this instance.
137  PrefService* const pref_service_;  // WEAK
138
139  // The observer to notify when server predictions are successfully received.
140  // Must not be null.
141  AutofillDownloadManager::Observer* const observer_;  // WEAK
142
143  // For each requested form for both query and upload we create a separate
144  // request and save its info. As url fetcher is identified by its address
145  // we use a map between fetchers and info.
146  std::map<net::URLFetcher*, FormRequestData> url_fetchers_;
147
148  // Cached QUERY requests.
149  QueryRequestCache cached_forms_;
150  size_t max_form_cache_size_;
151
152  // Time when next query/upload requests are allowed. If 50x HTTP received,
153  // exponential back off is initiated, so this times will be in the future
154  // for awhile.
155  base::Time next_query_request_;
156  base::Time next_upload_request_;
157
158  // |positive_upload_rate_| is for matched forms,
159  // |negative_upload_rate_| for non matched.
160  double positive_upload_rate_;
161  double negative_upload_rate_;
162
163  // Needed for unit-test.
164  int fetcher_id_for_unittest_;
165};
166
167}  // namespace autofill
168
169#endif  // COMPONENTS_AUTOFILL_CORE_BROWSER_AUTOFILL_DOWNLOAD_MANAGER_H_
170