network_delegate.cc revision 1e9bf3e0803691d0a228da41fc608347b6db4340 
1// Copyright (c) 2012 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#include "net/base/network_delegate.h"
6
7#include "base/logging.h"
8#include "net/base/load_flags.h"
9#include "net/base/net_errors.h"
10#include "net/url_request/url_request.h"
11
12namespace net {
13
14int NetworkDelegate::NotifyBeforeURLRequest(
15    URLRequest* request, const CompletionCallback& callback,
16    GURL* new_url) {
17  DCHECK(CalledOnValidThread());
18  DCHECK(request);
19  DCHECK(!callback.is_null());
20  return OnBeforeURLRequest(request, callback, new_url);
21}
22
23int NetworkDelegate::NotifyBeforeSendHeaders(
24    URLRequest* request, const CompletionCallback& callback,
25    HttpRequestHeaders* headers) {
26  DCHECK(CalledOnValidThread());
27  DCHECK(headers);
28  DCHECK(!callback.is_null());
29  return OnBeforeSendHeaders(request, callback, headers);
30}
31
32void NetworkDelegate::NotifySendHeaders(URLRequest* request,
33                                        const HttpRequestHeaders& headers) {
34  DCHECK(CalledOnValidThread());
35  OnSendHeaders(request, headers);
36}
37
38int NetworkDelegate::NotifyHeadersReceived(
39    URLRequest* request,
40    const CompletionCallback& callback,
41    const HttpResponseHeaders* original_response_headers,
42    scoped_refptr<HttpResponseHeaders>* override_response_headers) {
43  DCHECK(CalledOnValidThread());
44  DCHECK(original_response_headers);
45  DCHECK(!callback.is_null());
46  return OnHeadersReceived(request, callback, original_response_headers,
47                           override_response_headers);
48}
49
50void NetworkDelegate::NotifyResponseStarted(URLRequest* request) {
51  DCHECK(CalledOnValidThread());
52  DCHECK(request);
53  OnResponseStarted(request);
54}
55
56void NetworkDelegate::NotifyRawBytesRead(const URLRequest& request,
57                                         int bytes_read) {
58  DCHECK(CalledOnValidThread());
59  OnRawBytesRead(request, bytes_read);
60}
61
62void NetworkDelegate::NotifyBeforeRedirect(URLRequest* request,
63                                           const GURL& new_location) {
64  DCHECK(CalledOnValidThread());
65  DCHECK(request);
66  OnBeforeRedirect(request, new_location);
67}
68
69void NetworkDelegate::NotifyCompleted(URLRequest* request, bool started) {
70  DCHECK(CalledOnValidThread());
71  DCHECK(request);
72  OnCompleted(request, started);
73}
74
75void NetworkDelegate::NotifyURLRequestDestroyed(URLRequest* request) {
76  DCHECK(CalledOnValidThread());
77  DCHECK(request);
78  OnURLRequestDestroyed(request);
79}
80
81void NetworkDelegate::NotifyPACScriptError(int line_number,
82                                           const base::string16& error) {
83  DCHECK(CalledOnValidThread());
84  OnPACScriptError(line_number, error);
85}
86
87NetworkDelegate::AuthRequiredResponse NetworkDelegate::NotifyAuthRequired(
88    URLRequest* request,
89    const AuthChallengeInfo& auth_info,
90    const AuthCallback& callback,
91    AuthCredentials* credentials) {
92  DCHECK(CalledOnValidThread());
93  return OnAuthRequired(request, auth_info, callback, credentials);
94}
95
96int NetworkDelegate::NotifyBeforeSocketStreamConnect(
97    SocketStream* socket,
98    const CompletionCallback& callback) {
99  DCHECK(CalledOnValidThread());
100  DCHECK(socket);
101  DCHECK(!callback.is_null());
102  return OnBeforeSocketStreamConnect(socket, callback);
103}
104
105void NetworkDelegate::NotifyRequestWaitStateChange(const URLRequest& request,
106                                                   RequestWaitState state) {
107  DCHECK(CalledOnValidThread());
108  OnRequestWaitStateChange(request, state);
109}
110
111bool NetworkDelegate::CanGetCookies(const URLRequest& request,
112                                    const CookieList& cookie_list) {
113  DCHECK(CalledOnValidThread());
114  DCHECK(!(request.load_flags() & net::LOAD_DO_NOT_SEND_COOKIES));
115  return OnCanGetCookies(request, cookie_list);
116}
117
118bool NetworkDelegate::CanSetCookie(const URLRequest& request,
119                                   const std::string& cookie_line,
120                                   CookieOptions* options) {
121  DCHECK(CalledOnValidThread());
122  DCHECK(!(request.load_flags() & net::LOAD_DO_NOT_SAVE_COOKIES));
123  return OnCanSetCookie(request, cookie_line, options);
124}
125
126bool NetworkDelegate::CanAccessFile(const URLRequest& request,
127                                    const base::FilePath& path) const {
128  DCHECK(CalledOnValidThread());
129  return OnCanAccessFile(request, path);
130}
131
132bool NetworkDelegate::CanThrottleRequest(const URLRequest& request) const {
133  DCHECK(CalledOnValidThread());
134  return OnCanThrottleRequest(request);
135}
136
137bool NetworkDelegate::CanEnablePrivacyMode(
138    const GURL& url,
139    const GURL& first_party_for_cookies) const {
140  DCHECK(CalledOnValidThread());
141  return OnCanEnablePrivacyMode(url, first_party_for_cookies);
142}
143
144int NetworkDelegate::OnBeforeURLRequest(URLRequest* request,
145                                        const CompletionCallback& callback,
146                                        GURL* new_url) {
147  return OK;
148}
149
150int NetworkDelegate::OnBeforeSendHeaders(URLRequest* request,
151                                         const CompletionCallback& callback,
152                                         HttpRequestHeaders* headers) {
153  return OK;
154}
155
156void NetworkDelegate::OnSendHeaders(URLRequest* request,
157                                    const HttpRequestHeaders& headers) {
158}
159
160int NetworkDelegate::OnHeadersReceived(
161    URLRequest* request,
162    const CompletionCallback& callback,
163    const HttpResponseHeaders* original_response_headers,
164    scoped_refptr<HttpResponseHeaders>* override_response_headers) {
165  return OK;
166}
167
168void NetworkDelegate::OnBeforeRedirect(URLRequest* request,
169                                       const GURL& new_location) {
170}
171
172void NetworkDelegate::OnResponseStarted(URLRequest* request) {
173}
174
175void NetworkDelegate::OnRawBytesRead(const URLRequest& request,
176                                     int bytes_read) {
177}
178
179void NetworkDelegate::OnCompleted(URLRequest* request, bool started) {
180}
181
182void NetworkDelegate::OnURLRequestDestroyed(URLRequest* request) {
183}
184
185void NetworkDelegate::OnPACScriptError(int line_number,
186                                       const base::string16& error) {
187}
188
189NetworkDelegate::AuthRequiredResponse NetworkDelegate::OnAuthRequired(
190    URLRequest* request,
191    const AuthChallengeInfo& auth_info,
192    const AuthCallback& callback,
193    AuthCredentials* credentials) {
194  return AUTH_REQUIRED_RESPONSE_NO_ACTION;
195}
196
197bool NetworkDelegate::OnCanGetCookies(const URLRequest& request,
198                                      const CookieList& cookie_list)  {
199  return true;
200}
201
202bool NetworkDelegate::OnCanSetCookie(const URLRequest& request,
203                                     const std::string& cookie_line,
204                                     CookieOptions* options) {
205  return true;
206}
207
208bool NetworkDelegate::OnCanAccessFile(const URLRequest& request,
209                                      const base::FilePath& path) const  {
210  return false;
211}
212
213bool NetworkDelegate::OnCanThrottleRequest(const URLRequest& request) const {
214  return false;
215}
216
217bool NetworkDelegate::OnCanEnablePrivacyMode(
218    const GURL& url,
219    const GURL& first_party_for_cookies) const {
220  return false;
221}
222
223int NetworkDelegate::OnBeforeSocketStreamConnect(
224    SocketStream* socket,
225    const CompletionCallback& callback) {
226  return OK;
227}
228
229void NetworkDelegate::OnRequestWaitStateChange(const URLRequest& request,
230                                               RequestWaitState state) {
231}
232
233}  // namespace net
234