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