Add int params to URLDataSource::StartDataRequest().

content/browser/webui/url_data_manager_backend.cc

 // Copyright (c) 2012 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.
 
 #include "content/browser/webui/url_data_manager_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/histogram_internals_request_job.h"
 #include "content/browser/net/view_blob_internals_job_factory.h"
 #include "content/browser/net/view_http_cache_job_factory.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/tcmalloc_internals_request_job.h"
 #include "content/browser/webui/shared_resources_data_source.h"
 #include "content/browser/webui/url_data_source_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/resource_request_info.h"
 #include "content/public/common/url_constants.h"
 #include "googleurl/src/url_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
@@ skipping 459 matching lines @@
   job->set_allow_caching(source->source()->AllowCaching());
   job->set_add_content_security_policy(
       source->source()->ShouldAddContentSecurityPolicy());
   job->set_content_security_policy_object_source(
       source->source()->GetContentSecurityPolicyObjectSrc());
   job->set_content_security_policy_frame_source(
       source->source()->GetContentSecurityPolicyFrameSrc());
   job->set_deny_xframe_options(
       source->source()->ShouldDenyXFrameOptions());
 
+  // Look up additional request info to pass down.
+  int render_process_id = -1;
+  int render_view_id = -1;
+  ResourceRequestInfo::GetRenderViewForRequest(request,
+                                               &render_process_id,
+                                               &render_view_id);
+
   // Forward along the request to the data source.
   MessageLoop* target_message_loop =
       source->source()->MessageLoopForRequestPath(path);
   if (!target_message_loop) {
-    bool is_incognito = job->is_incognito();
     job->MimeTypeAvailable(source->source()->GetMimeType(path));
     // Eliminate potentially dangling pointer to avoid future use.
     job = NULL;
 
     // The DataSource is agnostic to which thread StartDataRequest is called
     // on for this path.  Call directly into it from this thread, the IO
     // thread.
     source->source()->StartDataRequest(
-        path, is_incognito,
+        path, render_process_id, render_view_id,
         base::Bind(&URLDataSourceImpl::SendResponse, source, request_id));
   } else {
     // URLRequestChromeJob should receive mime type before data. This
     // is guaranteed because request for mime type is placed in the
     // message loop before request for data. And correspondingly their
     // replies are put on the IO thread in the same order.
     target_message_loop->PostTask(
         FROM_HERE,
         base::Bind(&GetMimeTypeOnUI,
                    scoped_refptr<URLDataSourceImpl>(source),
                    path, job->AsWeakPtr()));
 
     // The DataSource wants StartDataRequest to be called on a specific thread,
     // usually the UI thread, for this path.
     target_message_loop->PostTask(
         FROM_HERE,
         base::Bind(&URLDataManagerBackend::CallStartRequest,
-                   make_scoped_refptr(source), path, job->is_incognito(),
-                   request_id));
+                   make_scoped_refptr(source), path, render_process_id,
+                   render_view_id, request_id));
   }
   return true;
 }
 
 void URLDataManagerBackend::CallStartRequest(
     scoped_refptr<URLDataSourceImpl> source,
     const std::string& path,
-    bool is_incognito,
+    int render_process_id,
+    int render_view_id,
     int request_id) {
+  if (BrowserThread::CurrentlyOn(BrowserThread::UI) &&
+      !RenderProcessHost::FromID(render_process_id)) {
+    // Make the request fail if its initiating renderer is no longer valid.
+    // This can happen when the IO thread posts this task just before the
+    // renderer shuts down.
+    source->SendResponse(request_id, NULL);
+    return;
+  }
   source->source()->StartDataRequest(
       path,
-      is_incognito,
+      render_process_id,
+      render_view_id,
       base::Bind(&URLDataSourceImpl::SendResponse, source, request_id));
 }
 
 void URLDataManagerBackend::RemoveRequest(URLRequestChromeJob* job) {
   // Remove the request from our list of pending requests.
   // If/when the source sends the data that was requested, the data will just
   // be thrown away.
   for (PendingRequestMap::iterator i = pending_requests_.begin();
        i != pending_requests_.end(); ++i) {
     if (i->second == job) {
@@ skipping 59 matching lines @@
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
 CreateDevToolsProtocolHandler(content::ResourceContext* resource_context,
                               bool is_incognito) {
   return new DevToolsJobFactory(resource_context, is_incognito);
 }
 
 }  // namespace content