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