net/base/network_delegate.cc

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