Move the ProcessType enum out to its own file. This is in preparation for getting rid of ChildPro...

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 40 matching lines @@
 #include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/browser/worker_host/worker_service.h"
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/process_type.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/auth.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_cert_request_info.h"
@@ skipping 74 matching lines @@
 GURL MaybeStripReferrer(const GURL& possible_referrer) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoReferrers))
     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(ChildProcessInfo::ProcessType process_type,
+bool ShouldServiceRequest(content::ProcessType process_type,
                           int child_id,
                           const ResourceHostMsg_Request& request_data)  {
-  if (process_type == ChildProcessInfo::PLUGIN_PROCESS)
+  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)) {
     VLOG(1) << "Denied unauthorized request for "
             << request_data.url.possibly_invalid_spec();
     return false;
@@ skipping 274 matching lines @@
     IPC::Message* sync_result) {
   BeginRequest(request_id, request_data, sync_result,
                sync_result->routing_id());
 }
 
 void ResourceDispatcherHost::BeginRequest(
     int request_id,
     const ResourceHostMsg_Request& request_data,
     IPC::Message* sync_result,  // only valid for sync
     int route_id) {
-  ChildProcessInfo::ProcessType process_type = filter_->process_type();
+  content::ProcessType process_type = filter_->process_type();
   int child_id = filter_->child_id();
 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/91398
   char url_buf[128];
   base::strlcpy(url_buf, request_data.url.spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   const content::ResourceContext& resource_context =
       filter_->resource_context();
@@ skipping 99 matching lines @@
   if (request_data.upload_data) {
     request->set_upload(request_data.upload_data);
     upload_size = request_data.upload_data->GetContentLength();
   }
 
   // Install a CrossSiteResourceHandler if this request is coming from a
   // RenderViewHost with a pending cross-site request.  We only check this for
   // MAIN_FRAME requests. Unblock requests only come from a blocked page, do
   // not count as cross-site, otherwise it gets blocked indefinitely.
   if (request_data.resource_type == ResourceType::MAIN_FRAME &&
-      process_type == ChildProcessInfo::RENDER_PROCESS &&
+      process_type == content::PROCESS_TYPE_RENDERER &&
       CrossSiteRequestManager::GetInstance()->
           HasPendingCrossSiteRequest(child_id, route_id)) {
     // Wrap the event handler to be sure the current page's onunload handler
     // has a chance to run before we render the new page.
     handler = new CrossSiteResourceHandler(handler,
                                            child_id,
                                            route_id,
                                            this);
   }
 
@@ skipping 163 matching lines @@
 }
 
 ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::CreateRequestInfo(
     ResourceHandler* handler,
     int child_id,
     int route_id,
     bool download,
     const content::ResourceContext& context) {
   return new ResourceDispatcherHostRequestInfo(
       handler,
-      ChildProcessInfo::RENDER_PROCESS,
+      content::PROCESS_TYPE_RENDERER,
       child_id,
       route_id,
       0,
       request_id_,
       false,     // is_main_frame
       -1,        // frame_id
       false,     // parent_is_main_frame
       -1,        // parent_frame_id
       ResourceType::SUB_RESOURCE,
       content::PAGE_TRANSITION_LINK,
@@ skipping 443 matching lines @@
 // net::URLRequest::Delegate ---------------------------------------------------
 
 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() != ChildProcessInfo::PLUGIN_PROCESS &&
+  if (info->process_type() != content::PROCESS_TYPE_PLUGIN &&
       !ChildProcessSecurityPolicy::GetInstance()->
           CanRequestURL(info->child_id(), new_url)) {
     VLOG(1) << "Denied unauthorized request for "
             << new_url.possibly_invalid_spec();
 
     // Tell the renderer that this request was disallowed.
     CancelRequestInternal(request, false);
     return;
   }
 
@@ skipping 599 matching lines @@
     int* render_process_host_id,
     int* render_view_host_id) {
   const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (!info) {
     *render_process_host_id = -1;
     *render_view_host_id = -1;
     return false;
   }
 
   // If the request is from the worker process, find a tab that owns the worker.
-  if (info->process_type() == ChildProcessInfo::WORKER_PROCESS) {
+  if (info->process_type() == content::PROCESS_TYPE_WORKER) {
     // Need to display some related UI for this network request - pick an
     // arbitrary parent to do so.
     if (!WorkerService::GetInstance()->GetRendererForWorker(
             info->child_id(), render_process_host_id, render_view_host_id)) {
       *render_process_host_id = -1;
       *render_view_host_id = -1;
       return false;
     }
   } else {
     *render_process_host_id = info->child_id();
@@ skipping 313 matching lines @@
   return HTTP_AUTH_RESOURCE_BLOCKED_CROSS;
 }
 
 bool ResourceDispatcherHost::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }