chrome/browser/net/chrome_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 "chrome/browser/net/chrome_network_delegate.h"
   6
   7 #include <stdlib.h>
   8
   9 #include <vector>
  10
  11 #include "base/base_paths.h"
  12 #include "base/debug/dump_without_crashing.h"
  13 #include "base/debug/trace_event.h"
  14 #include "base/logging.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/metrics/user_metrics.h"
  17 #include "base/path_service.h"
  18 #include "base/prefs/pref_member.h"
  19 #include "base/prefs/pref_service.h"
  20 #include "base/strings/string_number_conversions.h"
  21 #include "base/time/time.h"
  22 #include "chrome/browser/browser_process.h"
  23 #include "chrome/browser/content_settings/cookie_settings.h"
  24 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
  25 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
  26 #include "chrome/browser/net/chrome_extensions_network_delegate.h"
  27 #include "chrome/browser/net/client_hints.h"
  28 #include "chrome/browser/net/connect_interceptor.h"
  29 #include "chrome/browser/net/safe_search_util.h"
  30 #include "chrome/browser/prerender/prerender_tracker.h"
  31 #include "chrome/browser/profiles/profile_manager.h"
  32 #include "chrome/browser/task_manager/task_manager.h"
  33 #include "chrome/common/pref_names.h"
  34 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_auth_request_handler.h"
  35 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_metrics.h"
  36 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_params.h"
  37 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_protocol.h"
  38 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_statistics_prefs.h"
  39 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_usage_stats.h"
  40 #include "components/domain_reliability/monitor.h"
  41 #include "content/public/browser/browser_thread.h"
  42 #include "content/public/browser/render_frame_host.h"
  43 #include "content/public/browser/render_view_host.h"
  44 #include "content/public/browser/resource_request_info.h"
  45 #include "net/base/host_port_pair.h"
  46 #include "net/base/net_errors.h"
  47 #include "net/base/net_log.h"
  48 #include "net/cookies/canonical_cookie.h"
  49 #include "net/cookies/cookie_options.h"
  50 #include "net/http/http_request_headers.h"
  51 #include "net/http/http_response_headers.h"
  52 #include "net/proxy/proxy_config.h"
  53 #include "net/proxy/proxy_info.h"
  54 #include "net/proxy/proxy_retry_info.h"
  55 #include "net/proxy/proxy_server.h"
  56 #include "net/socket_stream/socket_stream.h"
  57 #include "net/url_request/url_request.h"
  58 #include "net/url_request/url_request_context.h"
  59
  60 #if defined(OS_ANDROID)
  61 #include "chrome/browser/io_thread.h"
  62 #include "components/precache/content/precache_manager.h"
  63 #include "components/precache/content/precache_manager_factory.h"
  64 #endif
  65
  66 #if defined(OS_CHROMEOS)
  67 #include "base/command_line.h"
  68 #include "base/sys_info.h"
  69 #include "chrome/common/chrome_switches.h"
  70 #endif
  71
  72 #if defined(ENABLE_CONFIGURATION_POLICY)
  73 #include "components/policy/core/browser/url_blacklist_manager.h"
  74 #endif
  75
  76 #if defined(ENABLE_EXTENSIONS)
  77 #include "extensions/common/constants.h"
  78 #endif
  79
  80 using content::BrowserThread;
  81 using content::RenderViewHost;
  82 using content::ResourceRequestInfo;
  83 using content::ResourceType;
  84
  85 // By default we don't allow access to all file:// urls on ChromeOS and
  86 // Android.
  87 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
  88 bool ChromeNetworkDelegate::g_allow_file_access_ = false;
  89 #else
  90 bool ChromeNetworkDelegate::g_allow_file_access_ = true;
  91 #endif
  92
  93 #if defined(ENABLE_EXTENSIONS)
  94 // This remains false unless the --disable-extensions-http-throttling
  95 // flag is passed to the browser.
  96 bool ChromeNetworkDelegate::g_never_throttle_requests_ = false;
  97 #endif
  98
  99 namespace {
 100
 101 const char kDNTHeader[] = "DNT";
 102
 103 // Gets called when the extensions finish work on the URL. If the extensions
 104 // did not do a redirect (so |new_url| is empty) then we enforce the
 105 // SafeSearch parameters. Otherwise we will get called again after the
 106 // redirect and we enforce SafeSearch then.
 107 void ForceGoogleSafeSearchCallbackWrapper(
 108     const net::CompletionCallback& callback,
 109     net::URLRequest* request,
 110     GURL* new_url,
 111     int rv) {
 112   if (rv == net::OK && new_url->is_empty())
 113     safe_search_util::ForceGoogleSafeSearch(request, new_url);
 114   callback.Run(rv);
 115 }
 116
 117 void UpdateContentLengthPrefs(
 118     int received_content_length,
 119     int original_content_length,
 120     data_reduction_proxy::DataReductionProxyRequestType request_type,
 121     Profile* profile,
 122     data_reduction_proxy::DataReductionProxyStatisticsPrefs* statistics_prefs) {
 123   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 124   DCHECK_GE(received_content_length, 0);
 125   DCHECK_GE(original_content_length, 0);
 126
 127   // Can be NULL in a unit test.
 128   if (!g_browser_process)
 129     return;
 130
 131   // Ignore off-the-record data.
 132   if (!g_browser_process->profile_manager()->IsValidProfile(profile) ||
 133       profile->IsOffTheRecord()) {
 134     return;
 135   }
 136   data_reduction_proxy::UpdateContentLengthPrefs(
 137       received_content_length,
 138       original_content_length,
 139       profile->GetPrefs(),
 140       request_type, statistics_prefs);
 141 }
 142
 143 void StoreAccumulatedContentLength(
 144     int received_content_length,
 145     int original_content_length,
 146     data_reduction_proxy::DataReductionProxyRequestType request_type,
 147     Profile* profile,
 148     data_reduction_proxy::DataReductionProxyStatisticsPrefs* statistics_prefs) {
 149   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 150       base::Bind(&UpdateContentLengthPrefs,
 151                  received_content_length,
 152                  original_content_length,
 153                  request_type,
 154                  profile,
 155                  statistics_prefs));
 156 }
 157
 158 void RecordContentLengthHistograms(
 159     int64 received_content_length,
 160     int64 original_content_length,
 161     const base::TimeDelta& freshness_lifetime) {
 162   // Add the current resource to these histograms only when a valid
 163   // X-Original-Content-Length header is present.
 164   if (original_content_length >= 0) {
 165     UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthWithValidOCL",
 166                          received_content_length);
 167     UMA_HISTOGRAM_COUNTS("Net.HttpOriginalContentLengthWithValidOCL",
 168                          original_content_length);
 169     UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthDifferenceWithValidOCL",
 170                          original_content_length - received_content_length);
 171   } else {
 172     // Presume the original content length is the same as the received content
 173     // length if the X-Original-Content-Header is not present.
 174     original_content_length = received_content_length;
 175   }
 176   UMA_HISTOGRAM_COUNTS("Net.HttpContentLength", received_content_length);
 177   UMA_HISTOGRAM_COUNTS("Net.HttpOriginalContentLength",
 178                        original_content_length);
 179   UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthDifference",
 180                        original_content_length - received_content_length);
 181   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.HttpContentFreshnessLifetime",
 182                               freshness_lifetime.InSeconds(),
 183                               base::TimeDelta::FromHours(1).InSeconds(),
 184                               base::TimeDelta::FromDays(30).InSeconds(),
 185                               100);
 186   if (freshness_lifetime.InSeconds() <= 0)
 187     return;
 188   UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable",
 189                        received_content_length);
 190   if (freshness_lifetime.InHours() < 4)
 191     return;
 192   UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable4Hours",
 193                        received_content_length);
 194
 195   if (freshness_lifetime.InHours() < 24)
 196     return;
 197   UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable24Hours",
 198                        received_content_length);
 199 }
 200
 201 #if defined(OS_ANDROID)
 202 void RecordPrecacheStatsOnUIThread(const GURL& url,
 203                                    const base::Time& fetch_time, int64 size,
 204                                    bool was_cached, void* profile_id) {
 205   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 206
 207   Profile* profile = reinterpret_cast<Profile*>(profile_id);
 208   if (!g_browser_process->profile_manager()->IsValidProfile(profile)) {
 209     return;
 210   }
 211
 212   precache::PrecacheManager* precache_manager =
 213       precache::PrecacheManagerFactory::GetForBrowserContext(profile);
 214   if (!precache_manager || !precache_manager->IsPrecachingAllowed()) {
 215     // |precache_manager| could be NULL if the profile is off the record.
 216     return;
 217   }
 218
 219   precache_manager->RecordStatsForFetch(url, fetch_time, size, was_cached);
 220 }
 221
 222 void RecordIOThreadToRequestStartOnUIThread(
 223     const base::TimeTicks& request_start) {
 224   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 225   base::TimeDelta request_lag = request_start -
 226       g_browser_process->io_thread()->creation_time();
 227   UMA_HISTOGRAM_TIMES("Net.IOThreadCreationToHTTPRequestStart", request_lag);
 228 }
 229 #endif  // defined(OS_ANDROID)
 230
 231 void ReportInvalidReferrerSend(const GURL& target_url,
 232                                const GURL& referrer_url) {
 233   base::RecordAction(
 234       base::UserMetricsAction("Net.URLRequest_StartJob_InvalidReferrer"));
 235   base::debug::DumpWithoutCrashing();
 236   NOTREACHED();
 237 }
 238
 239 }  // namespace
 240
 241 ChromeNetworkDelegate::ChromeNetworkDelegate(
 242     extensions::EventRouterForwarder* event_router,
 243     BooleanPrefMember* enable_referrers)
 244     : profile_(NULL),
 245       enable_referrers_(enable_referrers),
 246       enable_do_not_track_(NULL),
 247       force_google_safe_search_(NULL),
 248       data_reduction_proxy_enabled_(NULL),
 249 #if defined(ENABLE_CONFIGURATION_POLICY)
 250       url_blacklist_manager_(NULL),
 251 #endif
 252       domain_reliability_monitor_(NULL),
 253       received_content_length_(0),
 254       original_content_length_(0),
 255       first_request_(true),
 256       prerender_tracker_(NULL),
 257       data_reduction_proxy_params_(NULL),
 258       data_reduction_proxy_usage_stats_(NULL),
 259       data_reduction_proxy_auth_request_handler_(NULL),
 260       data_reduction_proxy_statistics_prefs_(NULL) {
 261   DCHECK(enable_referrers);
 262   extensions_delegate_.reset(
 263       ChromeExtensionsNetworkDelegate::Create(event_router));
 264 }
 265
 266 ChromeNetworkDelegate::~ChromeNetworkDelegate() {}
 267
 268 void ChromeNetworkDelegate::set_extension_info_map(
 269     extensions::InfoMap* extension_info_map) {
 270   extensions_delegate_->set_extension_info_map(extension_info_map);
 271 }
 272
 273 void ChromeNetworkDelegate::set_profile(void* profile) {
 274   profile_ = profile;
 275   extensions_delegate_->set_profile(profile);
 276 }
 277
 278 void ChromeNetworkDelegate::set_cookie_settings(
 279     CookieSettings* cookie_settings) {
 280   cookie_settings_ = cookie_settings;
 281 }
 282
 283 void ChromeNetworkDelegate::set_predictor(
 284     chrome_browser_net::Predictor* predictor) {
 285   connect_interceptor_.reset(
 286       new chrome_browser_net::ConnectInterceptor(predictor));
 287 }
 288
 289 void ChromeNetworkDelegate::SetEnableClientHints() {
 290   client_hints_.reset(new ClientHints());
 291   client_hints_->Init();
 292 }
 293
 294 // static
 295 #if defined(ENABLE_EXTENSIONS)
 296 void ChromeNetworkDelegate::NeverThrottleRequests() {
 297   g_never_throttle_requests_ = true;
 298 }
 299 #endif
 300
 301 // static
 302 void ChromeNetworkDelegate::InitializePrefsOnUIThread(
 303     BooleanPrefMember* enable_referrers,
 304     BooleanPrefMember* enable_do_not_track,
 305     BooleanPrefMember* force_google_safe_search,
 306     PrefService* pref_service) {
 307   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 308   enable_referrers->Init(prefs::kEnableReferrers, pref_service);
 309   enable_referrers->MoveToThread(
 310       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 311   if (enable_do_not_track) {
 312     enable_do_not_track->Init(prefs::kEnableDoNotTrack, pref_service);
 313     enable_do_not_track->MoveToThread(
 314         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 315   }
 316   if (force_google_safe_search) {
 317     force_google_safe_search->Init(prefs::kForceSafeSearch, pref_service);
 318     force_google_safe_search->MoveToThread(
 319         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 320   }
 321 }
 322
 323 // static
 324 void ChromeNetworkDelegate::AllowAccessToAllFiles() {
 325   g_allow_file_access_ = true;
 326 }
 327
 328 // static
 329 // TODO(megjablon): Use data_reduction_proxy_delayed_pref_service to read prefs.
 330 // Until updated the pref values may be up to an hour behind on desktop.
 331 base::Value* ChromeNetworkDelegate::HistoricNetworkStatsInfoToValue() {
 332   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 333   PrefService* prefs = g_browser_process->local_state();
 334   int64 total_received = prefs->GetInt64(
 335       data_reduction_proxy::prefs::kHttpReceivedContentLength);
 336   int64 total_original = prefs->GetInt64(
 337       data_reduction_proxy::prefs::kHttpOriginalContentLength);
 338
 339   base::DictionaryValue* dict = new base::DictionaryValue();
 340   // Use strings to avoid overflow.  base::Value only supports 32-bit integers.
 341   dict->SetString("historic_received_content_length",
 342                   base::Int64ToString(total_received));
 343   dict->SetString("historic_original_content_length",
 344                   base::Int64ToString(total_original));
 345   return dict;
 346 }
 347
 348 base::Value* ChromeNetworkDelegate::SessionNetworkStatsInfoToValue() const {
 349   base::DictionaryValue* dict = new base::DictionaryValue();
 350   // Use strings to avoid overflow.  base::Value only supports 32-bit integers.
 351   dict->SetString("session_received_content_length",
 352                   base::Int64ToString(received_content_length_));
 353   dict->SetString("session_original_content_length",
 354                   base::Int64ToString(original_content_length_));
 355   return dict;
 356 }
 357
 358 int ChromeNetworkDelegate::OnBeforeURLRequest(
 359     net::URLRequest* request,
 360     const net::CompletionCallback& callback,
 361     GURL* new_url) {
 362 #if defined(OS_ANDROID)
 363   // This UMA tracks the time to the first user-initiated request start, so
 364   // only non-null profiles are considered.
 365   if (first_request_ && profile_) {
 366     bool record_timing = true;
 367     if (data_reduction_proxy_params_) {
 368       record_timing =
 369           (request->url() != data_reduction_proxy_params_->probe_url()) &&
 370           (request->url() != data_reduction_proxy_params_->warmup_url());
 371     }
 372     if (record_timing) {
 373       first_request_ = false;
 374       net::LoadTimingInfo timing_info;
 375       request->GetLoadTimingInfo(&timing_info);
 376       BrowserThread::PostTask(
 377           BrowserThread::UI, FROM_HERE,
 378           base::Bind(&RecordIOThreadToRequestStartOnUIThread,
 379                      timing_info.request_start));
 380     }
 381   }
 382 #endif  // defined(OS_ANDROID)
 383
 384 #if defined(ENABLE_CONFIGURATION_POLICY)
 385   // TODO(joaodasilva): This prevents extensions from seeing URLs that are
 386   // blocked. However, an extension might redirect the request to another URL,
 387   // which is not blocked.
 388   int error = net::ERR_BLOCKED_BY_ADMINISTRATOR;
 389   if (url_blacklist_manager_ &&
 390       url_blacklist_manager_->IsRequestBlocked(*request, &error)) {
 391     // URL access blocked by policy.
 392     request->net_log().AddEvent(
 393         net::NetLog::TYPE_CHROME_POLICY_ABORTED_REQUEST,
 394         net::NetLog::StringCallback("url",
 395                                     &request->url().possibly_invalid_spec()));
 396     return error;
 397   }
 398 #endif
 399
 400   extensions_delegate_->ForwardStartRequestStatus(request);
 401
 402   if (!enable_referrers_->GetValue())
 403     request->SetReferrer(std::string());
 404   if (enable_do_not_track_ && enable_do_not_track_->GetValue())
 405     request->SetExtraRequestHeaderByName(kDNTHeader, "1", true /* override */);
 406
 407   if (client_hints_) {
 408     request->SetExtraRequestHeaderByName(
 409         ClientHints::kDevicePixelRatioHeader,
 410         client_hints_->GetDevicePixelRatioHeader(), true);
 411   }
 412
 413   bool force_safe_search = force_google_safe_search_ &&
 414                            force_google_safe_search_->GetValue();
 415
 416   net::CompletionCallback wrapped_callback = callback;
 417   if (force_safe_search) {
 418     wrapped_callback = base::Bind(&ForceGoogleSafeSearchCallbackWrapper,
 419                                   callback,
 420                                   base::Unretained(request),
 421                                   base::Unretained(new_url));
 422   }
 423
 424   int rv = extensions_delegate_->OnBeforeURLRequest(
 425       request, wrapped_callback, new_url);
 426
 427   if (force_safe_search && rv == net::OK && new_url->is_empty())
 428     safe_search_util::ForceGoogleSafeSearch(request, new_url);
 429
 430   if (connect_interceptor_)
 431     connect_interceptor_->WitnessURLRequest(request);
 432
 433   return rv;
 434 }
 435
 436 void ChromeNetworkDelegate::OnResolveProxy(
 437     const GURL& url,
 438     int load_flags,
 439     const net::ProxyService& proxy_service,
 440     net::ProxyInfo* result) {
 441   if (!on_resolve_proxy_handler_.is_null() &&
 442       !proxy_config_getter_.is_null()) {
 443     on_resolve_proxy_handler_.Run(url, load_flags,
 444                                   proxy_config_getter_.Run(),
 445                                   proxy_service.proxy_retry_info(),
 446                                   data_reduction_proxy_params_, result);
 447   }
 448 }
 449
 450 void ChromeNetworkDelegate::OnProxyFallback(const net::ProxyServer& bad_proxy,
 451                                             int net_error) {
 452   if (data_reduction_proxy_usage_stats_) {
 453     data_reduction_proxy_usage_stats_->OnProxyFallback(
 454         bad_proxy, net_error);
 455   }
 456 }
 457
 458 int ChromeNetworkDelegate::OnBeforeSendHeaders(
 459     net::URLRequest* request,
 460     const net::CompletionCallback& callback,
 461     net::HttpRequestHeaders* headers) {
 462   bool force_safe_search = force_google_safe_search_ &&
 463                            force_google_safe_search_->GetValue();
 464   if (force_safe_search)
 465     safe_search_util::ForceYouTubeSafetyMode(request, headers);
 466
 467   TRACE_EVENT_ASYNC_STEP_PAST0("net", "URLRequest", request, "SendRequest");
 468   return extensions_delegate_->OnBeforeSendHeaders(request, callback, headers);
 469 }
 470
 471 void ChromeNetworkDelegate::OnBeforeSendProxyHeaders(
 472     net::URLRequest* request,
 473     const net::ProxyInfo& proxy_info,
 474     net::HttpRequestHeaders* headers) {
 475   if (data_reduction_proxy_auth_request_handler_) {
 476     data_reduction_proxy_auth_request_handler_->MaybeAddRequestHeader(
 477         request, proxy_info.proxy_server(), headers);
 478   }
 479 }
 480
 481 void ChromeNetworkDelegate::OnSendHeaders(
 482     net::URLRequest* request,
 483     const net::HttpRequestHeaders& headers) {
 484   extensions_delegate_->OnSendHeaders(request, headers);
 485 }
 486
 487 int ChromeNetworkDelegate::OnHeadersReceived(
 488     net::URLRequest* request,
 489     const net::CompletionCallback& callback,
 490     const net::HttpResponseHeaders* original_response_headers,
 491     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
 492     GURL* allowed_unsafe_redirect_url) {
 493   data_reduction_proxy::DataReductionProxyBypassType bypass_type;
 494   if (data_reduction_proxy::MaybeBypassProxyAndPrepareToRetry(
 495       data_reduction_proxy_params_,
 496       request,
 497       original_response_headers,
 498       override_response_headers,
 499       &bypass_type)) {
 500     if (data_reduction_proxy_usage_stats_)
 501       data_reduction_proxy_usage_stats_->SetBypassType(bypass_type);
 502     return net::OK;
 503   }
 504
 505   return extensions_delegate_->OnHeadersReceived(
 506       request,
 507       callback,
 508       original_response_headers,
 509       override_response_headers,
 510       allowed_unsafe_redirect_url);
 511 }
 512
 513 void ChromeNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
 514                                              const GURL& new_location) {
 515   if (domain_reliability_monitor_)
 516     domain_reliability_monitor_->OnBeforeRedirect(request);
 517   extensions_delegate_->OnBeforeRedirect(request, new_location);
 518 }
 519
 520
 521 void ChromeNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
 522   TRACE_EVENT_ASYNC_STEP_PAST0("net", "URLRequest", request, "ResponseStarted");
 523   extensions_delegate_->OnResponseStarted(request);
 524 }
 525
 526 void ChromeNetworkDelegate::OnRawBytesRead(const net::URLRequest& request,
 527                                            int bytes_read) {
 528   TRACE_EVENT_ASYNC_STEP_PAST1("net", "URLRequest", &request, "DidRead",
 529                                "bytes_read", bytes_read);
 530 #if defined(ENABLE_TASK_MANAGER)
 531   // This is not completely accurate, but as a first approximation ignore
 532   // requests that are served from the cache. See bug 330931 for more info.
 533   if (!request.was_cached())
 534     TaskManager::GetInstance()->model()->NotifyBytesRead(request, bytes_read);
 535 #endif  // defined(ENABLE_TASK_MANAGER)
 536 }
 537
 538 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
 539                                         bool started) {
 540   if (data_reduction_proxy_usage_stats_)
 541     data_reduction_proxy_usage_stats_->OnUrlRequestCompleted(request, started);
 542
 543   TRACE_EVENT_ASYNC_END0("net", "URLRequest", request);
 544   if (request->status().status() == net::URLRequestStatus::SUCCESS) {
 545     // For better accuracy, we use the actual bytes read instead of the length
 546     // specified with the Content-Length header, which may be inaccurate,
 547     // or missing, as is the case with chunked encoding.
 548     int64 received_content_length = request->received_response_content_length();
 549
 550 #if defined(OS_ANDROID)
 551     if (precache::PrecacheManager::IsPrecachingEnabled()) {
 552       // Record precache metrics when a fetch is completed successfully, if
 553       // precaching is enabled.
 554       BrowserThread::PostTask(
 555           BrowserThread::UI, FROM_HERE,
 556           base::Bind(&RecordPrecacheStatsOnUIThread, request->url(),
 557                      base::Time::Now(), received_content_length,
 558                      request->was_cached(), profile_));
 559     }
 560 #endif  // defined(OS_ANDROID)
 561
 562     // Only record for http or https urls.
 563     bool is_http = request->url().SchemeIs("http");
 564     bool is_https = request->url().SchemeIs("https");
 565
 566     if (!request->was_cached() &&         // Don't record cached content
 567         received_content_length &&        // Zero-byte responses aren't useful.
 568         (is_http || is_https)) {          // Only record for HTTP or HTTPS urls.
 569       int64 original_content_length =
 570           request->response_info().headers->GetInt64HeaderValue(
 571               "x-original-content-length");
 572       data_reduction_proxy::DataReductionProxyRequestType request_type =
 573           data_reduction_proxy::GetDataReductionProxyRequestType(request);
 574
 575       base::TimeDelta freshness_lifetime =
 576           request->response_info()
 577               .headers->GetFreshnessLifetimes(
 578                             request->response_info().response_time)
 579               .fresh;
 580       int64 adjusted_original_content_length =
 581           data_reduction_proxy::GetAdjustedOriginalContentLength(
 582               request_type, original_content_length,
 583               received_content_length);
 584       AccumulateContentLength(received_content_length,
 585                               adjusted_original_content_length,
 586                               request_type);
 587       RecordContentLengthHistograms(received_content_length,
 588                                     original_content_length,
 589                                     freshness_lifetime);
 590
 591       if (data_reduction_proxy_enabled_ &&
 592           data_reduction_proxy_usage_stats_ &&
 593           !proxy_config_getter_.is_null()) {
 594         data_reduction_proxy_usage_stats_->RecordBytesHistograms(
 595             request,
 596             *data_reduction_proxy_enabled_,
 597             proxy_config_getter_.Run());
 598       }
 599       DVLOG(2) << __FUNCTION__
 600           << " received content length: " << received_content_length
 601           << " original content length: " << original_content_length
 602           << " url: " << request->url();
 603     }
 604
 605     extensions_delegate_->OnCompleted(request, started);
 606   } else if (request->status().status() == net::URLRequestStatus::FAILED ||
 607              request->status().status() == net::URLRequestStatus::CANCELED) {
 608     extensions_delegate_->OnCompleted(request, started);
 609   } else {
 610     NOTREACHED();
 611   }
 612   if (domain_reliability_monitor_)
 613     domain_reliability_monitor_->OnCompleted(request, started);
 614   extensions_delegate_->ForwardProxyErrors(request);
 615   extensions_delegate_->ForwardDoneRequestStatus(request);
 616 }
 617
 618 void ChromeNetworkDelegate::OnURLRequestDestroyed(net::URLRequest* request) {
 619   extensions_delegate_->OnURLRequestDestroyed(request);
 620 }
 621
 622 void ChromeNetworkDelegate::OnPACScriptError(int line_number,
 623                                              const base::string16& error) {
 624   extensions_delegate_->OnPACScriptError(line_number, error);
 625 }
 626
 627 net::NetworkDelegate::AuthRequiredResponse
 628 ChromeNetworkDelegate::OnAuthRequired(
 629     net::URLRequest* request,
 630     const net::AuthChallengeInfo& auth_info,
 631     const AuthCallback& callback,
 632     net::AuthCredentials* credentials) {
 633   return extensions_delegate_->OnAuthRequired(
 634       request, auth_info, callback, credentials);
 635 }
 636
 637 bool ChromeNetworkDelegate::OnCanGetCookies(
 638     const net::URLRequest& request,
 639     const net::CookieList& cookie_list) {
 640   // NULL during tests, or when we're running in the system context.
 641   if (!cookie_settings_.get())
 642     return true;
 643
 644   bool allow = cookie_settings_->IsReadingCookieAllowed(
 645       request.url(), request.first_party_for_cookies());
 646
 647   int render_process_id = -1;
 648   int render_frame_id = -1;
 649
 650   // |is_for_blocking_resource| indicates whether the cookies read were for a
 651   // blocking resource (eg script, css). It is only temporarily added for
 652   // diagnostic purposes, per bug 353678. Will be removed again once data
 653   // collection is finished.
 654   bool is_for_blocking_resource = false;
 655   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(&request);
 656   if (info && ((!info->IsAsync()) ||
 657                info->GetResourceType() == content::RESOURCE_TYPE_STYLESHEET ||
 658                info->GetResourceType() == content::RESOURCE_TYPE_SCRIPT)) {
 659     is_for_blocking_resource = true;
 660   }
 661
 662   if (content::ResourceRequestInfo::GetRenderFrameForRequest(
 663           &request, &render_process_id, &render_frame_id)) {
 664     BrowserThread::PostTask(
 665         BrowserThread::UI, FROM_HERE,
 666         base::Bind(&TabSpecificContentSettings::CookiesRead,
 667                    render_process_id, render_frame_id,
 668                    request.url(), request.first_party_for_cookies(),
 669                    cookie_list, !allow, is_for_blocking_resource));
 670   }
 671
 672   return allow;
 673 }
 674
 675 bool ChromeNetworkDelegate::OnCanSetCookie(const net::URLRequest& request,
 676                                            const std::string& cookie_line,
 677                                            net::CookieOptions* options) {
 678   // NULL during tests, or when we're running in the system context.
 679   if (!cookie_settings_.get())
 680     return true;
 681
 682   bool allow = cookie_settings_->IsSettingCookieAllowed(
 683       request.url(), request.first_party_for_cookies());
 684
 685   int render_process_id = -1;
 686   int render_frame_id = -1;
 687   if (content::ResourceRequestInfo::GetRenderFrameForRequest(
 688           &request, &render_process_id, &render_frame_id)) {
 689     BrowserThread::PostTask(
 690         BrowserThread::UI, FROM_HERE,
 691         base::Bind(&TabSpecificContentSettings::CookieChanged,
 692                    render_process_id, render_frame_id,
 693                    request.url(), request.first_party_for_cookies(),
 694                    cookie_line, *options, !allow));
 695   }
 696
 697   if (prerender_tracker_) {
 698     prerender_tracker_->OnCookieChangedForURL(
 699         render_process_id,
 700         request.context()->cookie_store()->GetCookieMonster(),
 701         request.url());
 702   }
 703
 704   return allow;
 705 }
 706
 707 bool ChromeNetworkDelegate::OnCanAccessFile(const net::URLRequest& request,
 708                                             const base::FilePath& path) const {
 709   if (g_allow_file_access_)
 710     return true;
 711
 712 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
 713   return true;
 714 #else
 715 #if defined(OS_CHROMEOS)
 716   // If we're running Chrome for ChromeOS on Linux, we want to allow file
 717   // access.
 718   if (!base::SysInfo::IsRunningOnChromeOS() ||
 719       CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType)) {
 720     return true;
 721   }
 722
 723   // Use a whitelist to only allow access to files residing in the list of
 724   // directories below.
 725   static const char* const kLocalAccessWhiteList[] = {
 726       "/home/chronos/user/Downloads",
 727       "/home/chronos/user/log",
 728       "/home/chronos/user/WebRTC Logs",
 729       "/media",
 730       "/opt/oem",
 731       "/usr/share/chromeos-assets",
 732       "/tmp",
 733       "/var/log",
 734   };
 735
 736   // The actual location of "/home/chronos/user/Xyz" is the Xyz directory under
 737   // the profile path ("/home/chronos/user' is a hard link to current primary
 738   // logged in profile.) For the support of multi-profile sessions, we are
 739   // switching to use explicit "$PROFILE_PATH/Xyz" path and here whitelist such
 740   // access.
 741   if (!profile_path_.empty()) {
 742     const base::FilePath downloads = profile_path_.AppendASCII("Downloads");
 743     if (downloads == path.StripTrailingSeparators() || downloads.IsParent(path))
 744       return true;
 745     const base::FilePath webrtc_logs = profile_path_.AppendASCII("WebRTC Logs");
 746     if (webrtc_logs == path.StripTrailingSeparators() ||
 747         webrtc_logs.IsParent(path)) {
 748       return true;
 749     }
 750   }
 751 #elif defined(OS_ANDROID)
 752   // Access to files in external storage is allowed.
 753   base::FilePath external_storage_path;
 754   PathService::Get(base::DIR_ANDROID_EXTERNAL_STORAGE, &external_storage_path);
 755   if (external_storage_path.IsParent(path))
 756     return true;
 757
 758   // Whitelist of other allowed directories.
 759   static const char* const kLocalAccessWhiteList[] = {
 760       "/sdcard",
 761       "/mnt/sdcard",
 762   };
 763 #endif
 764
 765   for (size_t i = 0; i < arraysize(kLocalAccessWhiteList); ++i) {
 766     const base::FilePath white_listed_path(kLocalAccessWhiteList[i]);
 767     // base::FilePath::operator== should probably handle trailing separators.
 768     if (white_listed_path == path.StripTrailingSeparators() ||
 769         white_listed_path.IsParent(path)) {
 770       return true;
 771     }
 772   }
 773
 774   DVLOG(1) << "File access denied - " << path.value().c_str();
 775   return false;
 776 #endif  // !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
 777 }
 778
 779 bool ChromeNetworkDelegate::OnCanThrottleRequest(
 780     const net::URLRequest& request) const {
 781 #if defined(ENABLE_EXTENSIONS)
 782   if (g_never_throttle_requests_)
 783     return false;
 784   return request.first_party_for_cookies().scheme() ==
 785       extensions::kExtensionScheme;
 786 #else
 787   return false;
 788 #endif
 789 }
 790
 791 bool ChromeNetworkDelegate::OnCanEnablePrivacyMode(
 792     const GURL& url,
 793     const GURL& first_party_for_cookies) const {
 794   // NULL during tests, or when we're running in the system context.
 795   if (!cookie_settings_.get())
 796     return false;
 797
 798   bool reading_cookie_allowed = cookie_settings_->IsReadingCookieAllowed(
 799       url, first_party_for_cookies);
 800   bool setting_cookie_allowed = cookie_settings_->IsSettingCookieAllowed(
 801       url, first_party_for_cookies);
 802   bool privacy_mode = !(reading_cookie_allowed && setting_cookie_allowed);
 803   return privacy_mode;
 804 }
 805
 806 int ChromeNetworkDelegate::OnBeforeSocketStreamConnect(
 807     net::SocketStream* socket,
 808     const net::CompletionCallback& callback) {
 809 #if defined(ENABLE_CONFIGURATION_POLICY)
 810   if (url_blacklist_manager_ &&
 811       url_blacklist_manager_->IsURLBlocked(socket->url())) {
 812     // URL access blocked by policy.
 813     socket->net_log()->AddEvent(
 814         net::NetLog::TYPE_CHROME_POLICY_ABORTED_REQUEST,
 815         net::NetLog::StringCallback("url",
 816                                     &socket->url().possibly_invalid_spec()));
 817     return net::ERR_BLOCKED_BY_ADMINISTRATOR;
 818   }
 819 #endif
 820   return net::OK;
 821 }
 822
 823 bool ChromeNetworkDelegate::OnCancelURLRequestWithPolicyViolatingReferrerHeader(
 824     const net::URLRequest& request,
 825     const GURL& target_url,
 826     const GURL& referrer_url) const {
 827   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 828       base::Bind(&ReportInvalidReferrerSend, target_url, referrer_url));
 829   return true;
 830 }
 831
 832 void ChromeNetworkDelegate::AccumulateContentLength(
 833     int64 received_content_length,
 834     int64 original_content_length,
 835     data_reduction_proxy::DataReductionProxyRequestType request_type) {
 836   DCHECK_GE(received_content_length, 0);
 837   DCHECK_GE(original_content_length, 0);
 838   if (data_reduction_proxy_statistics_prefs_) {
 839     StoreAccumulatedContentLength(received_content_length,
 840                                   original_content_length,
 841                                   request_type,
 842                                   reinterpret_cast<Profile*>(profile_),
 843                                   data_reduction_proxy_statistics_prefs_);
 844   }
 845   received_content_length_ += received_content_length;
 846   original_content_length_ += original_content_length;
 847 }