1// Copyright (c) 2011 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 NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
6#define NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
7#pragma once
8
9#include <string>
10#include <vector>
11
12#include "base/memory/scoped_ptr.h"
13#include "base/string16.h"
14#include "base/task.h"
15#include "base/time.h"
16#include "net/base/auth.h"
17#include "net/base/completion_callback.h"
18#include "net/http/http_request_info.h"
19#include "net/url_request/url_request_job.h"
20#include "net/url_request/url_request_throttler_entry_interface.h"
21
22namespace net {
23
24class HttpResponseInfo;
25class HttpTransaction;
26class URLRequestContext;
27
28// A URLRequestJob subclass that is built on top of HttpTransaction.  It
29// provides an implementation for both HTTP and HTTPS.
30class URLRequestHttpJob : public URLRequestJob {
31 public:
32  static URLRequestJob* Factory(URLRequest* request,
33                                const std::string& scheme);
34
35 protected:
36  explicit URLRequestHttpJob(URLRequest* request);
37
38  // Shadows URLRequestJob's version of this method so we can grab cookies.
39  void NotifyHeadersComplete();
40
41  // Shadows URLRequestJob's method so we can record histograms.
42  void NotifyDone(const URLRequestStatus& status);
43
44  void DestroyTransaction();
45  void StartTransaction();
46  void AddExtraHeaders();
47  void AddCookieHeaderAndStart();
48  void SaveCookiesAndNotifyHeadersComplete();
49  void SaveNextCookie();
50  void FetchResponseCookies(const HttpResponseInfo* response_info,
51                            std::vector<std::string>* cookies);
52
53  // Process the Strict-Transport-Security header, if one exists.
54  void ProcessStrictTransportSecurityHeader();
55
56  void OnCanGetCookiesCompleted(int result);
57  void OnCanSetCookieCompleted(int result);
58  void OnStartCompleted(int result);
59  void OnReadCompleted(int result);
60
61  bool ShouldTreatAsCertificateError(int result);
62
63  void RestartTransactionWithAuth(const string16& username,
64                                  const string16& password);
65
66  // Overridden from URLRequestJob:
67  virtual void SetUpload(UploadData* upload);
68  virtual void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
69  virtual void Start();
70  virtual void Kill();
71  virtual LoadState GetLoadState() const;
72  virtual uint64 GetUploadProgress() const;
73  virtual bool GetMimeType(std::string* mime_type) const;
74  virtual bool GetCharset(std::string* charset);
75  virtual void GetResponseInfo(HttpResponseInfo* info);
76  virtual bool GetResponseCookies(std::vector<std::string>* cookies);
77  virtual int GetResponseCode() const;
78  virtual Filter* SetupFilter() const;
79  virtual bool IsSafeRedirect(const GURL& location);
80  virtual bool NeedsAuth();
81  virtual void GetAuthChallengeInfo(scoped_refptr<AuthChallengeInfo>*);
82  virtual void SetAuth(const string16& username,
83                       const string16& password);
84  virtual void CancelAuth();
85  virtual void ContinueWithCertificate(X509Certificate* client_cert);
86  virtual void ContinueDespiteLastError();
87  virtual bool ReadRawData(IOBuffer* buf, int buf_size, int *bytes_read);
88  virtual void StopCaching();
89  virtual HostPortPair GetSocketAddress() const;
90
91  // Keep a reference to the url request context to be sure it's not deleted
92  // before us.
93  scoped_refptr<URLRequestContext> context_;
94
95  HttpRequestInfo request_info_;
96  const HttpResponseInfo* response_info_;
97
98  std::vector<std::string> response_cookies_;
99  size_t response_cookies_save_index_;
100
101  // Auth states for proxy and origin server.
102  AuthState proxy_auth_state_;
103  AuthState server_auth_state_;
104
105  string16 username_;
106  string16 password_;
107
108  CompletionCallbackImpl<URLRequestHttpJob> start_callback_;
109  CompletionCallbackImpl<URLRequestHttpJob> read_callback_;
110
111  bool read_in_progress_;
112
113  // An URL for an SDCH dictionary as suggested in a Get-Dictionary HTTP header.
114  GURL sdch_dictionary_url_;
115
116  scoped_ptr<HttpTransaction> transaction_;
117
118  // This is used to supervise traffic and enforce exponential back-off.
119  scoped_refptr<URLRequestThrottlerEntryInterface> throttling_entry_;
120
121  // Indicated if an SDCH dictionary was advertised, and hence an SDCH
122  // compressed response is expected.  We use this to help detect (accidental?)
123  // proxy corruption of a response, which sometimes marks SDCH content as
124  // having no content encoding <oops>.
125  bool sdch_dictionary_advertised_;
126
127  // For SDCH latency experiments, when we are able to do SDCH, we may enable
128  // either an SDCH latency test xor a pass through test.  The following bools
129  // indicate what we decided on for this instance.
130  bool sdch_test_activated_;  // Advertising a dictionary for sdch.
131  bool sdch_test_control_;    // Not even accepting-content sdch.
132
133  // For recording of stats, we need to remember if this is cached content.
134  bool is_cached_content_;
135
136 private:
137  class HttpFilterContext;
138
139  virtual ~URLRequestHttpJob();
140
141  void RecordTimer();
142  void ResetTimer();
143
144  virtual void UpdatePacketReadTimes();
145  void RecordPacketStats(FilterContext::StatisticSelector statistic) const;
146
147  void RecordCompressionHistograms();
148  bool IsCompressibleContent() const;
149
150  base::Time request_creation_time_;
151
152  // Data used for statistics gathering. This data is only used for histograms
153  // and is not required. It is only gathered if packet_timing_enabled_ == true.
154  //
155  // TODO(jar): improve the quality of the gathered info by gathering most times
156  // at a lower point in the network stack, assuring we have actual packet
157  // boundaries, rather than approximations.  Also note that input byte count
158  // as gathered here is post-SSL, and post-cache-fetch, and does not reflect
159  // true packet arrival times in such cases.
160
161  // Enable recording of packet arrival times for histogramming.
162  bool packet_timing_enabled_;
163
164  // The number of bytes that have been accounted for in packets (where some of
165  // those packets may possibly have had their time of arrival recorded).
166  int64 bytes_observed_in_packets_;
167
168  // Arrival times for some of the first few packets.
169  std::vector<base::Time> packet_times_;
170
171  // The request time may not be available when we are being destroyed, so we
172  // snapshot it early on.
173  base::Time request_time_snapshot_;
174
175  // Since we don't save all packet times in packet_times_, we save the
176  // last time for use in histograms.
177  base::Time final_packet_time_;
178
179  // The count of the number of packets, some of which may not have been timed.
180  // We're ignoring overflow, as 1430 x 2^31 is a LOT of bytes.
181  int observed_packet_count_;
182
183  scoped_ptr<HttpFilterContext> filter_context_;
184  ScopedRunnableMethodFactory<URLRequestHttpJob> method_factory_;
185
186  DISALLOW_COPY_AND_ASSIGN(URLRequestHttpJob);
187};
188
189}  // namespace net
190
191#endif  // NET_URL_REQUEST_URL_REQUEST_HTTP_JOB_H_
192