src/chrome/browser/renderer_host/chrome_resource_dispatcher_host_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/renderer_host/chrome_resource_dispatcher_host_delegate.h"
   6
   7 #include <string>
   8
   9 #include "base/base64.h"
  10 #include "base/logging.h"
  11 #include "base/metrics/histogram.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/component_updater/component_updater_service.h"
  15 #include "chrome/browser/content_settings/host_content_settings_map.h"
  16 #include "chrome/browser/download/download_request_limiter.h"
  17 #include "chrome/browser/download/download_resource_throttle.h"
  18 #include "chrome/browser/extensions/api/streams_private/streams_private_api.h"
  19 #include "chrome/browser/extensions/extension_info_map.h"
  20 #include "chrome/browser/extensions/extension_renderer_state.h"
  21 #include "chrome/browser/extensions/user_script_listener.h"
  22 #include "chrome/browser/external_protocol/external_protocol_handler.h"
  23 #include "chrome/browser/google/google_util.h"
  24 #include "chrome/browser/metrics/variations/variations_http_header_provider.h"
  25 #include "chrome/browser/net/resource_prefetch_predictor_observer.h"
  26 #include "chrome/browser/prerender/prerender_manager.h"
  27 #include "chrome/browser/prerender/prerender_resource_throttle.h"
  28 #include "chrome/browser/prerender/prerender_tracker.h"
  29 #include "chrome/browser/prerender/prerender_util.h"
  30 #include "chrome/browser/profiles/profile.h"
  31 #include "chrome/browser/profiles/profile_io_data.h"
  32 #include "chrome/browser/renderer_host/chrome_url_request_user_data.h"
  33 #include "chrome/browser/renderer_host/safe_browsing_resource_throttle_factory.h"
  34 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
  35 #include "chrome/browser/ui/auto_login_prompter.h"
  36 #include "chrome/browser/ui/login/login_prompt.h"
  37 #include "chrome/browser/ui/sync/one_click_signin_helper.h"
  38 #include "chrome/common/extensions/extension_constants.h"
  39 #include "chrome/common/extensions/mime_types_handler.h"
  40 #include "chrome/common/render_messages.h"
  41 #include "content/public/browser/browser_thread.h"
  42 #include "content/public/browser/notification_service.h"
  43 #include "content/public/browser/render_process_host.h"
  44 #include "content/public/browser/render_view_host.h"
  45 #include "content/public/browser/resource_context.h"
  46 #include "content/public/browser/resource_dispatcher_host.h"
  47 #include "content/public/browser/resource_request_info.h"
  48 #include "content/public/browser/stream_handle.h"
  49 #include "content/public/common/resource_response.h"
  50 #include "extensions/common/constants.h"
  51 #include "extensions/common/user_script.h"
  52 #include "net/base/load_flags.h"
  53 #include "net/base/load_timing_info.h"
  54 #include "net/http/http_response_headers.h"
  55 #include "net/ssl/ssl_config_service.h"
  56 #include "net/url_request/url_request.h"
  57
  58 #if defined(ENABLE_MANAGED_USERS)
  59 #include "chrome/browser/managed_mode/managed_mode_resource_throttle.h"
  60 #endif
  61
  62 #if defined(USE_SYSTEM_PROTOBUF)
  63 #include <google/protobuf/repeated_field.h>
  64 #else
  65 #include "third_party/protobuf/src/google/protobuf/repeated_field.h"
  66 #endif
  67
  68 #if defined(OS_ANDROID)
  69 #include "chrome/browser/android/intercept_download_resource_throttle.h"
  70 #include "components/navigation_interception/intercept_navigation_delegate.h"
  71 #else
  72 #include "chrome/browser/apps/app_url_redirector.h"
  73 #endif
  74
  75 #if defined(OS_CHROMEOS)
  76 #include "chrome/browser/chromeos/login/merge_session_throttle.h"
  77 // TODO(oshima): Enable this for other platforms.
  78 #include "chrome/browser/renderer_host/offline_resource_throttle.h"
  79 #endif
  80
  81 using content::BrowserThread;
  82 using content::RenderViewHost;
  83 using content::ResourceDispatcherHostLoginDelegate;
  84 using content::ResourceRequestInfo;
  85 using extensions::Extension;
  86 using extensions::StreamsPrivateAPI;
  87
  88 #if defined(OS_ANDROID)
  89 using navigation_interception::InterceptNavigationDelegate;
  90 #endif
  91
  92 namespace {
  93
  94 void NotifyDownloadInitiatedOnUI(int render_process_id, int render_view_id) {
  95   RenderViewHost* rvh = RenderViewHost::FromID(render_process_id,
  96                                                render_view_id);
  97   if (!rvh)
  98     return;
  99
 100   content::NotificationService::current()->Notify(
 101       chrome::NOTIFICATION_DOWNLOAD_INITIATED,
 102       content::Source<RenderViewHost>(rvh),
 103       content::NotificationService::NoDetails());
 104 }
 105
 106 // Goes through the extension's file browser handlers and checks if there is one
 107 // that can handle the |mime_type|.
 108 // |extension| must not be NULL.
 109 bool ExtensionCanHandleMimeType(const Extension* extension,
 110                                 const std::string& mime_type) {
 111   MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
 112   if (!handler)
 113     return false;
 114
 115   return handler->CanHandleMIMEType(mime_type);
 116 }
 117
 118 void SendExecuteMimeTypeHandlerEvent(scoped_ptr<content::StreamHandle> stream,
 119                                      int64 expected_content_size,
 120                                      int render_process_id,
 121                                      int render_view_id,
 122                                      const std::string& extension_id) {
 123   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 124
 125   content::RenderViewHost* render_view_host =
 126       content::RenderViewHost::FromID(render_process_id, render_view_id);
 127   if (!render_view_host)
 128     return;
 129
 130   content::WebContents* web_contents =
 131       content::WebContents::FromRenderViewHost(render_view_host);
 132   if (!web_contents)
 133     return;
 134
 135   content::BrowserContext* browser_context = web_contents->GetBrowserContext();
 136   if (!browser_context)
 137     return;
 138
 139   Profile* profile = Profile::FromBrowserContext(browser_context);
 140   if (!profile)
 141     return;
 142
 143   StreamsPrivateAPI* streams_private = StreamsPrivateAPI::Get(profile);
 144   if (!streams_private)
 145     return;
 146   streams_private->ExecuteMimeTypeHandler(
 147       extension_id, web_contents, stream.Pass(), expected_content_size);
 148 }
 149
 150 enum PrerenderSchemeCancelReason {
 151   PRERENDER_SCHEME_CANCEL_REASON_EXTERNAL_PROTOCOL,
 152   PRERENDER_SCHEME_CANCEL_REASON_DATA,
 153   PRERENDER_SCHEME_CANCEL_REASON_BLOB,
 154   PRERENDER_SCHEME_CANCEL_REASON_FILE,
 155   PRERENDER_SCHEME_CANCEL_REASON_FILESYSTEM,
 156   PRERENDER_SCHEME_CANCEL_REASON_WEBSOCKET,
 157   PRERENDER_SCHEME_CANCEL_REASON_FTP,
 158   PRERENDER_SCHEME_CANCEL_REASON_CHROME,
 159   PRERENDER_SCHEME_CANCEL_REASON_CHROME_EXTENSION,
 160   PRERENDER_SCHEME_CANCEL_REASON_ABOUT,
 161   PRERENDER_SCHEME_CANCEL_REASON_UNKNOWN,
 162   PRERENDER_SCHEME_CANCEL_REASON_MAX,
 163 };
 164
 165 void ReportPrerenderSchemeCancelReason(PrerenderSchemeCancelReason reason) {
 166   UMA_HISTOGRAM_ENUMERATION(
 167       "Prerender.SchemeCancelReason", reason,
 168       PRERENDER_SCHEME_CANCEL_REASON_MAX);
 169 }
 170
 171 void ReportUnsupportedPrerenderScheme(const GURL& url) {
 172   if (url.SchemeIs("data")) {
 173     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_DATA);
 174   } else if (url.SchemeIs("blob")) {
 175     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_BLOB);
 176   } else if (url.SchemeIsFile()) {
 177     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_FILE);
 178   } else if (url.SchemeIsFileSystem()) {
 179     ReportPrerenderSchemeCancelReason(
 180         PRERENDER_SCHEME_CANCEL_REASON_FILESYSTEM);
 181   } else if (url.SchemeIs("ws") || url.SchemeIs("wss")) {
 182     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_WEBSOCKET);
 183   } else if (url.SchemeIs("ftp")) {
 184     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_FTP);
 185   } else if (url.SchemeIs("chrome")) {
 186     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_CHROME);
 187   } else if (url.SchemeIs("chrome-extension")) {
 188     ReportPrerenderSchemeCancelReason(
 189         PRERENDER_SCHEME_CANCEL_REASON_CHROME_EXTENSION);
 190   } else if (url.SchemeIs("about")) {
 191     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_ABOUT);
 192   } else {
 193     ReportPrerenderSchemeCancelReason(PRERENDER_SCHEME_CANCEL_REASON_UNKNOWN);
 194   }
 195 }
 196
 197 void AppendComponentUpdaterThrottles(
 198     net::URLRequest* request,
 199     content::ResourceContext* resource_context,
 200     ResourceType::Type resource_type,
 201     ScopedVector<content::ResourceThrottle>* throttles) {
 202   const char* crx_id = NULL;
 203   ComponentUpdateService* cus = g_browser_process->component_updater();
 204   if (!cus)
 205     return;
 206   // Check for PNaCL nexe request.
 207   if (resource_type == ResourceType::OBJECT) {
 208     const net::HttpRequestHeaders& headers = request->extra_request_headers();
 209     std::string accept_headers;
 210     if (headers.GetHeader("Accept", &accept_headers)) {
 211       if (accept_headers.find("application/x-pnacl") != std::string::npos)
 212         crx_id = "hnimpnehoodheedghdeeijklkeaacbdc";
 213     }
 214   }
 215
 216   if (crx_id) {
 217     // We got a component we need to install, so throttle the resource
 218     // until the component is installed.
 219     throttles->push_back(cus->GetOnDemandResourceThrottle(request, crx_id));
 220   }
 221 }
 222
 223 }  // end namespace
 224
 225 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate(
 226     prerender::PrerenderTracker* prerender_tracker)
 227     : download_request_limiter_(g_browser_process->download_request_limiter()),
 228       safe_browsing_(g_browser_process->safe_browsing_service()),
 229       user_script_listener_(new extensions::UserScriptListener()),
 230       prerender_tracker_(prerender_tracker) {
 231 }
 232
 233 ChromeResourceDispatcherHostDelegate::~ChromeResourceDispatcherHostDelegate() {
 234 }
 235
 236 bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
 237     int child_id,
 238     int route_id,
 239     const std::string& method,
 240     const GURL& url,
 241     ResourceType::Type resource_type,
 242     content::ResourceContext* resource_context) {
 243   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 244
 245   // Handle a PREFETCH resource type. If prefetch is disabled, squelch the
 246   // request.  Otherwise, do a normal request to warm the cache.
 247   if (resource_type == ResourceType::PREFETCH) {
 248     // All PREFETCH requests should be GETs, but be defensive about it.
 249     if (method != "GET")
 250       return false;
 251
 252     // If prefetch is disabled, kill the request.
 253     if (!prerender::PrerenderManager::IsPrefetchEnabled())
 254       return false;
 255   }
 256
 257   // Abort any prerenders that spawn requests that use invalid HTTP methods
 258   // or invalid schemes.
 259   if (prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id)) {
 260     if (!prerender::PrerenderManager::IsValidHttpMethod(method) &&
 261         prerender_tracker_->TryCancelOnIOThread(
 262             child_id, route_id, prerender::FINAL_STATUS_INVALID_HTTP_METHOD)) {
 263       return false;
 264     }
 265     if (!prerender::PrerenderManager::DoesSubresourceURLHaveValidScheme(url) &&
 266         prerender_tracker_->TryCancelOnIOThread(
 267             child_id, route_id, prerender::FINAL_STATUS_UNSUPPORTED_SCHEME)) {
 268       ReportUnsupportedPrerenderScheme(url);
 269       return false;
 270     }
 271   }
 272
 273   return true;
 274 }
 275
 276 void ChromeResourceDispatcherHostDelegate::RequestBeginning(
 277     net::URLRequest* request,
 278     content::ResourceContext* resource_context,
 279     appcache::AppCacheService* appcache_service,
 280     ResourceType::Type resource_type,
 281     int child_id,
 282     int route_id,
 283     ScopedVector<content::ResourceThrottle>* throttles) {
 284   ChromeURLRequestUserData* user_data =
 285       ChromeURLRequestUserData::Create(request);
 286   bool is_prerendering = prerender_tracker_->IsPrerenderingOnIOThread(
 287       child_id, route_id);
 288   if (is_prerendering) {
 289     user_data->set_is_prerender(true);
 290     request->SetPriority(net::IDLE);
 291   }
 292
 293   ProfileIOData* io_data = ProfileIOData::FromResourceContext(
 294       resource_context);
 295
 296   if (!is_prerendering && resource_type == ResourceType::MAIN_FRAME) {
 297 #if defined(OS_ANDROID)
 298     throttles->push_back(
 299         InterceptNavigationDelegate::CreateThrottleFor(request));
 300 #else
 301     // Redirect some navigations to apps that have registered matching URL
 302     // handlers ('url_handlers' in the manifest).
 303     content::ResourceThrottle* url_to_app_throttle =
 304         AppUrlRedirector::MaybeCreateThrottleFor(request, io_data);
 305     if (url_to_app_throttle)
 306       throttles->push_back(url_to_app_throttle);
 307 #endif
 308   }
 309
 310 #if defined(OS_CHROMEOS)
 311   if (resource_type == ResourceType::MAIN_FRAME) {
 312     // We check offline first, then check safe browsing so that we still can
 313     // block unsafe site after we remove offline page.
 314     throttles->push_back(new OfflineResourceThrottle(request,
 315                                                      appcache_service));
 316     // Add interstitial page while merge session process (cookie
 317     // reconstruction from OAuth2 refresh token in ChromeOS login) is still in
 318     // progress while we are attempting to load a google property.
 319     if (!MergeSessionThrottle::AreAllSessionMergedAlready() &&
 320         request->url().SchemeIsHTTPOrHTTPS()) {
 321       throttles->push_back(new MergeSessionThrottle(request));
 322     }
 323   }
 324 #endif
 325
 326   // Don't attempt to append headers to requests that have already started.
 327   // TODO(stevet): Remove this once the request ordering issues are resolved
 328   // in crbug.com/128048.
 329   if (!request->is_pending()) {
 330     net::HttpRequestHeaders headers;
 331     headers.CopyFrom(request->extra_request_headers());
 332     bool incognito = io_data->is_incognito();
 333     chrome_variations::VariationsHttpHeaderProvider::GetInstance()->
 334         AppendHeaders(request->url(),
 335                       incognito,
 336                       !incognito && io_data->GetMetricsEnabledStateOnIOThread(),
 337                       &headers);
 338     request->SetExtraRequestHeaders(headers);
 339   }
 340
 341 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 342   AppendChromeSyncGaiaHeader(request, resource_context);
 343 #endif
 344
 345   AppendStandardResourceThrottles(request,
 346                                   resource_context,
 347                                   resource_type,
 348                                   throttles);
 349   if (!is_prerendering) {
 350     AppendComponentUpdaterThrottles(request,
 351                                     resource_context,
 352                                     resource_type,
 353                                     throttles);
 354   }
 355
 356   if (io_data->resource_prefetch_predictor_observer()) {
 357     io_data->resource_prefetch_predictor_observer()->OnRequestStarted(
 358         request, resource_type, child_id, route_id);
 359   }
 360 }
 361
 362 void ChromeResourceDispatcherHostDelegate::WillTransferRequestToNewProcess(
 363     int old_child_id,
 364     int old_route_id,
 365     int old_request_id,
 366     int new_child_id,
 367     int new_route_id,
 368     int new_request_id) {
 369   // If a prerender, it have should been aborted on cross-process
 370   // navigation in PrerenderContents::WebContentsImpl::OpenURLFromTab.
 371   DCHECK(!prerender_tracker_->IsPrerenderingOnIOThread(old_child_id,
 372                                                        old_route_id));
 373 }
 374
 375 void ChromeResourceDispatcherHostDelegate::DownloadStarting(
 376     net::URLRequest* request,
 377     content::ResourceContext* resource_context,
 378     int child_id,
 379     int route_id,
 380     int request_id,
 381     bool is_content_initiated,
 382     bool must_download,
 383     ScopedVector<content::ResourceThrottle>* throttles) {
 384   BrowserThread::PostTask(
 385       BrowserThread::UI, FROM_HERE,
 386       base::Bind(&NotifyDownloadInitiatedOnUI, child_id, route_id));
 387
 388   // If it's from the web, we don't trust it, so we push the throttle on.
 389   if (is_content_initiated) {
 390     throttles->push_back(
 391         new DownloadResourceThrottle(download_request_limiter_.get(),
 392                                      child_id,
 393                                      route_id,
 394                                      request_id,
 395                                      request->method()));
 396 #if defined(OS_ANDROID)
 397     throttles->push_back(
 398         new chrome::InterceptDownloadResourceThrottle(
 399             request, child_id, route_id, request_id));
 400 #endif
 401   }
 402
 403   // If this isn't a new request, we've seen this before and added the standard
 404   //  resource throttles already so no need to add it again.
 405   if (!request->is_pending()) {
 406     AppendStandardResourceThrottles(request,
 407                                     resource_context,
 408                                     ResourceType::MAIN_FRAME,
 409                                     throttles);
 410   }
 411 }
 412
 413 bool ChromeResourceDispatcherHostDelegate::AcceptSSLClientCertificateRequest(
 414     net::URLRequest* request, net::SSLCertRequestInfo* cert_request_info) {
 415   if (request->load_flags() & net::LOAD_PREFETCH)
 416     return false;
 417
 418   ChromeURLRequestUserData* user_data = ChromeURLRequestUserData::Get(request);
 419   if (user_data && user_data->is_prerender()) {
 420     int child_id, route_id;
 421     if (ResourceRequestInfo::ForRequest(request)->GetAssociatedRenderView(
 422             &child_id, &route_id)) {
 423       if (prerender_tracker_->TryCancel(
 424               child_id, route_id,
 425               prerender::FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED)) {
 426         return false;
 427       }
 428     }
 429   }
 430
 431   return true;
 432 }
 433
 434 bool ChromeResourceDispatcherHostDelegate::AcceptAuthRequest(
 435     net::URLRequest* request,
 436     net::AuthChallengeInfo* auth_info) {
 437   ChromeURLRequestUserData* user_data = ChromeURLRequestUserData::Get(request);
 438   if (!user_data || !user_data->is_prerender())
 439     return true;
 440
 441   int child_id, route_id;
 442   if (!ResourceRequestInfo::ForRequest(request)->GetAssociatedRenderView(
 443           &child_id, &route_id)) {
 444     NOTREACHED();
 445     return true;
 446   }
 447
 448   if (!prerender_tracker_->TryCancelOnIOThread(
 449           child_id, route_id, prerender::FINAL_STATUS_AUTH_NEEDED)) {
 450     return true;
 451   }
 452
 453   return false;
 454 }
 455
 456 ResourceDispatcherHostLoginDelegate*
 457     ChromeResourceDispatcherHostDelegate::CreateLoginDelegate(
 458         net::AuthChallengeInfo* auth_info, net::URLRequest* request) {
 459   return CreateLoginPrompt(auth_info, request);
 460 }
 461
 462 bool ChromeResourceDispatcherHostDelegate::HandleExternalProtocol(
 463     const GURL& url, int child_id, int route_id) {
 464 #if defined(OS_ANDROID)
 465   // Android use a resource throttle to handle external as well as internal
 466   // protocols.
 467   return false;
 468 #else
 469
 470   if (prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id) &&
 471       prerender_tracker_->TryCancel(
 472           child_id, route_id, prerender::FINAL_STATUS_UNSUPPORTED_SCHEME)) {
 473     ReportPrerenderSchemeCancelReason(
 474         PRERENDER_SCHEME_CANCEL_REASON_EXTERNAL_PROTOCOL);
 475     return false;
 476   }
 477
 478   ExtensionRendererState::WebViewInfo info;
 479   if (ExtensionRendererState::GetInstance()->GetWebViewInfo(child_id,
 480                                                             route_id,
 481                                                             &info)) {
 482     return false;
 483   }
 484
 485   BrowserThread::PostTask(
 486       BrowserThread::UI, FROM_HERE,
 487       base::Bind(&ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
 488   return true;
 489 #endif
 490 }
 491
 492 void ChromeResourceDispatcherHostDelegate::AppendStandardResourceThrottles(
 493     net::URLRequest* request,
 494     content::ResourceContext* resource_context,
 495     ResourceType::Type resource_type,
 496     ScopedVector<content::ResourceThrottle>* throttles) {
 497   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 498 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
 499   // Insert safe browsing at the front of the list, so it gets to decide on
 500   // policies first.
 501   if (io_data->safe_browsing_enabled()->GetValue()) {
 502     bool is_subresource_request = resource_type != ResourceType::MAIN_FRAME;
 503     content::ResourceThrottle* throttle =
 504         SafeBrowsingResourceThrottleFactory::Create(request,
 505                                                     is_subresource_request,
 506                                                     safe_browsing_.get());
 507     if (throttle)
 508       throttles->push_back(throttle);
 509   }
 510 #endif
 511
 512 #if defined(ENABLE_MANAGED_USERS)
 513   bool is_subresource_request = resource_type != ResourceType::MAIN_FRAME;
 514   throttles->push_back(new ManagedModeResourceThrottle(
 515         request, !is_subresource_request,
 516         io_data->managed_mode_url_filter()));
 517 #endif
 518
 519   content::ResourceThrottle* throttle =
 520       user_script_listener_->CreateResourceThrottle(request->url(),
 521                                                     resource_type);
 522   if (throttle)
 523     throttles->push_back(throttle);
 524
 525   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 526   if (prerender_tracker_->IsPrerenderingOnIOThread(info->GetChildID(),
 527                                                    info->GetRouteID())) {
 528     throttles->push_back(new prerender::PrerenderResourceThrottle(
 529         request, prerender_tracker_));
 530   }
 531 }
 532
 533 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 534 void ChromeResourceDispatcherHostDelegate::AppendChromeSyncGaiaHeader(
 535     net::URLRequest* request,
 536     content::ResourceContext* resource_context) {
 537   static const char kAllowChromeSignIn[] = "Allow-Chrome-SignIn";
 538
 539   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 540   OneClickSigninHelper::Offer offer =
 541       OneClickSigninHelper::CanOfferOnIOThread(request, io_data);
 542   switch (offer) {
 543     case OneClickSigninHelper::CAN_OFFER:
 544       request->SetExtraRequestHeaderByName(kAllowChromeSignIn, "1", false);
 545       break;
 546     case OneClickSigninHelper::DONT_OFFER:
 547       request->RemoveRequestHeaderByName(kAllowChromeSignIn);
 548       break;
 549     case OneClickSigninHelper::IGNORE_REQUEST:
 550       break;
 551   }
 552 }
 553 #endif
 554
 555 bool ChromeResourceDispatcherHostDelegate::ShouldForceDownloadResource(
 556     const GURL& url, const std::string& mime_type) {
 557   // Special-case user scripts to get downloaded instead of viewed.
 558   return extensions::UserScript::IsURLUserScript(url, mime_type);
 559 }
 560
 561 bool ChromeResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
 562     content::ResourceContext* resource_context,
 563     const GURL& url,
 564     const std::string& mime_type,
 565     GURL* origin,
 566     std::string* target_id) {
 567 #if !defined(OS_ANDROID)
 568   ProfileIOData* io_data =
 569       ProfileIOData::FromResourceContext(resource_context);
 570   bool profile_is_incognito = io_data->is_incognito();
 571   const scoped_refptr<const ExtensionInfoMap> extension_info_map(
 572       io_data->GetExtensionInfoMap());
 573   std::vector<std::string> whitelist = MimeTypesHandler::GetMIMETypeWhitelist();
 574   // Go through the white-listed extensions and try to use them to intercept
 575   // the URL request.
 576   for (size_t i = 0; i < whitelist.size(); ++i) {
 577     const char* extension_id = whitelist[i].c_str();
 578     const Extension* extension =
 579         extension_info_map->extensions().GetByID(extension_id);
 580     // The white-listed extension may not be installed, so we have to NULL check
 581     // |extension|.
 582     if (!extension ||
 583         (profile_is_incognito &&
 584          !extension_info_map->IsIncognitoEnabled(extension_id))) {
 585       continue;
 586     }
 587
 588     if (ExtensionCanHandleMimeType(extension, mime_type)) {
 589       *origin = Extension::GetBaseURLFromExtensionId(extension_id);
 590       *target_id = extension_id;
 591       return true;
 592     }
 593   }
 594 #endif
 595   return false;
 596 }
 597
 598 void ChromeResourceDispatcherHostDelegate::OnStreamCreated(
 599     content::ResourceContext* resource_context,
 600     int render_process_id,
 601     int render_view_id,
 602     const std::string& target_id,
 603     scoped_ptr<content::StreamHandle> stream,
 604     int64 expected_content_size) {
 605 #if !defined(OS_ANDROID)
 606   content::BrowserThread::PostTask(
 607       content::BrowserThread::UI, FROM_HERE,
 608       base::Bind(&SendExecuteMimeTypeHandlerEvent, base::Passed(&stream),
 609                  expected_content_size, render_process_id, render_view_id,
 610                  target_id));
 611 #endif
 612 }
 613
 614 void ChromeResourceDispatcherHostDelegate::OnResponseStarted(
 615     net::URLRequest* request,
 616     content::ResourceContext* resource_context,
 617     content::ResourceResponse* response,
 618     IPC::Sender* sender) {
 619   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 620
 621   if (request->url().SchemeIsSecure()) {
 622     const net::URLRequestContext* context = request->context();
 623     net::TransportSecurityState* state = context->transport_security_state();
 624     if (state) {
 625       net::TransportSecurityState::DomainState domain_state;
 626       bool has_sni = net::SSLConfigService::IsSNIAvailable(
 627           context->ssl_config_service());
 628       if (state->GetDomainState(request->url().host(), has_sni,
 629                                 &domain_state) &&
 630           domain_state.ShouldUpgradeToSSL()) {
 631         sender->Send(new ChromeViewMsg_AddStrictSecurityHost(
 632             info->GetRouteID(), request->url().host()));
 633       }
 634     }
 635   }
 636
 637   // See if the response contains the X-Auto-Login header.  If so, this was
 638   // a request for a login page, and the server is allowing the browser to
 639   // suggest auto-login, if available.
 640   AutoLoginPrompter::ShowInfoBarIfPossible(request, info->GetChildID(),
 641                                            info->GetRouteID());
 642
 643   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 644
 645 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 646   // See if the response contains the Google-Accounts-SignIn header.  If so,
 647   // then the user has just finished signing in, and the server is allowing the
 648   // browser to suggest connecting the user's profile to the account.
 649   OneClickSigninHelper::ShowInfoBarIfPossible(request, io_data,
 650                                               info->GetChildID(),
 651                                               info->GetRouteID());
 652 #endif
 653
 654   // Build in additional protection for the chrome web store origin.
 655   GURL webstore_url(extension_urls::GetWebstoreLaunchURL());
 656   if (request->url().DomainIs(webstore_url.host().c_str())) {
 657     net::HttpResponseHeaders* response_headers = request->response_headers();
 658     if (!response_headers->HasHeaderValue("x-frame-options", "deny") &&
 659         !response_headers->HasHeaderValue("x-frame-options", "sameorigin")) {
 660       response_headers->RemoveHeader("x-frame-options");
 661       response_headers->AddHeader("x-frame-options: sameorigin");
 662     }
 663   }
 664
 665   if (io_data->resource_prefetch_predictor_observer())
 666     io_data->resource_prefetch_predictor_observer()->OnResponseStarted(request);
 667
 668   prerender::URLRequestResponseStarted(request);
 669 }
 670
 671 void ChromeResourceDispatcherHostDelegate::OnRequestRedirected(
 672     const GURL& redirect_url,
 673     net::URLRequest* request,
 674     content::ResourceContext* resource_context,
 675     content::ResourceResponse* response) {
 676   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 677
 678 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 679   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 680
 681   // See if the response contains the Google-Accounts-SignIn header.  If so,
 682   // then the user has just finished signing in, and the server is allowing the
 683   // browser to suggest connecting the user's profile to the account.
 684   OneClickSigninHelper::ShowInfoBarIfPossible(request, io_data,
 685                                               info->GetChildID(),
 686                                               info->GetRouteID());
 687   AppendChromeSyncGaiaHeader(request, resource_context);
 688 #endif
 689
 690   if (io_data->resource_prefetch_predictor_observer()) {
 691     io_data->resource_prefetch_predictor_observer()->OnRequestRedirected(
 692         redirect_url, request);
 693   }
 694
 695   int child_id, route_id;
 696   if (!prerender::PrerenderManager::DoesURLHaveValidScheme(redirect_url) &&
 697       ResourceRequestInfo::ForRequest(request)->GetAssociatedRenderView(
 698           &child_id, &route_id) &&
 699       prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id) &&
 700       prerender_tracker_->TryCancel(
 701           child_id, route_id, prerender::FINAL_STATUS_UNSUPPORTED_SCHEME)) {
 702     ReportUnsupportedPrerenderScheme(redirect_url);
 703     request->Cancel();
 704   }
 705 }