Remove "open in new tab" items from context menu if the process doesn't

content/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 136 matching lines @@
     return GURL();
   return possible_referrer;
 }
 
 // Consults the RendererSecurity policy to determine whether the
 // ResourceDispatcherHost should service this request.  A request might be
 // disallowed if the renderer is not authorized to retrieve the request URL or
 // if the renderer is attempting to upload an unauthorized file.
 bool ShouldServiceRequest(content::ProcessType process_type,
                           int child_id,
-                          const ResourceHostMsg_Request& request_data)  {
+                          const ResourceHostMsg_Request& request_data,
+                          const net::URLRequestJobFactory* job_factory)  {
   if (process_type == content::PROCESS_TYPE_PLUGIN)
     return true;
 
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
 
   // Check if the renderer is permitted to request the requested URL.
-  if (!policy->CanRequestURL(child_id, request_data.url)) {
+  if (!policy->CanRequestURL(child_id, request_data.url, job_factory)) {
     VLOG(1) << "Denied unauthorized request for "
             << request_data.url.possibly_invalid_spec();
     return false;
   }
 
   // Check if the renderer is permitted to upload the requested files.
   if (request_data.upload_data) {
     const std::vector<net::UploadData::Element>* uploads =
         request_data.upload_data->elements();
     std::vector<net::UploadData::Element>::const_iterator iter;
@@ skipping 307 matching lines @@
   const content::ResourceContext& resource_context =
       filter_->resource_context();
 
   // Might need to resolve the blob references in the upload data.
   if (request_data.upload_data) {
     resource_context.blob_storage_context()->controller()->
         ResolveBlobReferencesInUploadData(request_data.upload_data.get());
   }
 
   if (is_shutdown_ ||
-      !ShouldServiceRequest(process_type, child_id, request_data)) {
+      !ShouldServiceRequest(
+          process_type, child_id, request_data,
+          resource_context.request_context()->job_factory())) {
     AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
     return;
   }
 
   const GURL referrer = MaybeStripReferrer(request_data.referrer);
 
   // Allow the observer to block/handle the request.
   if (delegate_ && !delegate_->ShouldBeginRequest(child_id,
                                                   route_id,
                                                   request_data.method,
@@ skipping 362 matching lines @@
   const GURL& url = request->original_url();
   const net::URLRequestContext* request_context = context.request_context();
   request->set_referrer(MaybeStripReferrer(GURL(request->referrer())).spec());
   request->set_method("GET");
   request->set_context(request_context);
   request->set_load_flags(request->load_flags() |
                           net::LOAD_IS_DOWNLOAD | net::LOAD_DISABLE_CACHE);
 
   // Check if the renderer is permitted to request the requested URL.
   if (!ChildProcessSecurityPolicy::GetInstance()->
-          CanRequestURL(child_id, url)) {
+      CanRequestURL(child_id, url, request_context->job_factory())) {
     VLOG(1) << "Denied unauthorized download request for "
             << url.possibly_invalid_spec();
     if (!started_cb.is_null())
       started_cb.Run(DownloadId::Invalid(), net::ERR_ACCESS_DENIED);
     return;
   }
 
   request_id_--;
 
   DownloadId dl_id = context.download_id_factory()->GetNextId();
@@ skipping 10 matching lines @@
                                   prompt_for_save_location,
                                   started_cb,
                                   save_info));
 
   if (delegate_) {
     handler = delegate_->DownloadStarting(
         handler, context, request, child_id, route_id, request_id_, true,
         false);
   }
 
+  // FIXME(tsepez); probably redundant in face of passing job_factory to
+  // ChildProcessSecurityPolicy above.
   if (!request_context->job_factory()->IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     if (!started_cb.is_null())
       started_cb.Run(DownloadId::Invalid(), net::ERR_ACCESS_DENIED);
     return;
   }
 
   ResourceDispatcherHostRequestInfo* extra_info =
       CreateRequestInfo(handler, child_id, route_id, true, context);
@@ skipping 340 matching lines @@
 
 void ResourceDispatcherHost::OnReceivedRedirect(net::URLRequest* request,
                                                 const GURL& new_url,
                                                 bool* defer_redirect) {
   VLOG(1) << "OnReceivedRedirect: " << request->url().spec();
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   DCHECK(request->status().is_success());
 
   if (info->process_type() != content::PROCESS_TYPE_PLUGIN &&
-      !ChildProcessSecurityPolicy::GetInstance()->
-          CanRequestURL(info->child_id(), new_url)) {
+      !ChildProcessSecurityPolicy::GetInstance()->CanRequestURL(
+          info->child_id(), new_url, request->context()->job_factory())) {
     VLOG(1) << "Denied unauthorized request for "
             << new_url.possibly_invalid_spec();
 
     // Tell the renderer that this request was disallowed.
     CancelRequestInternal(request, false);
     return;
   }
 
   NotifyReceivedRedirect(request, info->child_id(), new_url);
 
@@ skipping 953 matching lines @@
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }
 
 void ResourceDispatcherHost::MarkAsTransferredNavigation(
     const GlobalRequestID& transferred_request_id,
     net::URLRequest* ransferred_request) {
   transferred_navigations_[transferred_request_id] = ransferred_request;
 }