content: ResourceType cleanup.

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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 "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 208 matching lines @@
       url,
       render_process_id,
       render_view_id,
       g_external_protocol_handler_delegate);
 }
 #endif  // !defined(OS_ANDROID)
 
 void AppendComponentUpdaterThrottles(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
-    ResourceType::Type resource_type,
+    ResourceType resource_type,
     ScopedVector<content::ResourceThrottle>* throttles) {
   const char* crx_id = NULL;
   component_updater::ComponentUpdateService* cus =
       g_browser_process->component_updater();
   if (!cus)
     return;
   // Check for PNaCl pexe request.
-  if (resource_type == ResourceType::OBJECT) {
+  if (resource_type == content::RESOURCE_TYPE_OBJECT) {
     const net::HttpRequestHeaders& headers = request->extra_request_headers();
     std::string accept_headers;
     if (headers.GetHeader("Accept", &accept_headers)) {
       if (accept_headers.find("application/x-pnacl") != std::string::npos &&
           pnacl::NeedsOnDemandUpdate())
         crx_id = "hnimpnehoodheedghdeeijklkeaacbdc";
     }
   }
 
   if (crx_id) {
@@ skipping 20 matching lines @@
 #if defined(ENABLE_EXTENSIONS)
   CHECK(stream_target_info_.empty());
 #endif
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
     int child_id,
     int route_id,
     const std::string& method,
     const GURL& url,
-    ResourceType::Type resource_type,
+    ResourceType resource_type,
     content::ResourceContext* resource_context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Handle a PREFETCH resource type. If prefetch is disabled, squelch the
   // request.  Otherwise, do a normal request to warm the cache.
-  if (resource_type == ResourceType::PREFETCH) {
+  if (resource_type == content::RESOURCE_TYPE_PREFETCH) {
     // All PREFETCH requests should be GETs, but be defensive about it.
     if (method != "GET")
       return false;
 
     // If prefetch is disabled, kill the request.
     if (!prefetch::IsPrefetchEnabled(resource_context))
       return false;
   }
 
   return true;
 }
 
 void ChromeResourceDispatcherHostDelegate::RequestBeginning(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::AppCacheService* appcache_service,
-    ResourceType::Type resource_type,
+    ResourceType resource_type,
     int child_id,
     int route_id,
     ScopedVector<content::ResourceThrottle>* throttles) {
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   bool is_prerendering =
       info->GetVisibilityState() == blink::WebPageVisibilityStatePrerender;
   if (is_prerendering) {
     // Requests with the IGNORE_LIMITS flag set (i.e., sync XHRs)
     // should remain at MAXIMUM_PRIORITY.
     if (request->load_flags() & net::LOAD_IGNORE_LIMITS) {
       DCHECK_EQ(request->priority(), net::MAXIMUM_PRIORITY);
     } else {
       request->SetPriority(net::IDLE);
     }
   }
 
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(
       resource_context);
 
 #if defined(OS_ANDROID)
   // TODO(davidben): This is insufficient to integrate with prerender properly.
   // https://crbug.com/370595
-  if (resource_type == ResourceType::MAIN_FRAME && !is_prerendering) {
+  if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME && !is_prerendering) {
     throttles->push_back(
         InterceptNavigationDelegate::CreateThrottleFor(request));
   }
 #else
-  if (resource_type == ResourceType::MAIN_FRAME) {
+  if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
     // Redirect some navigations to apps that have registered matching URL
     // handlers ('url_handlers' in the manifest).
     content::ResourceThrottle* url_to_app_throttle =
         AppUrlRedirector::MaybeCreateThrottleFor(request, io_data);
     if (url_to_app_throttle)
       throttles->push_back(url_to_app_throttle);
 
     if (!is_prerendering) {
       // Experimental: Launch ephemeral apps from search results.
       content::ResourceThrottle* ephemeral_app_throttle =
           EphemeralAppThrottle::MaybeCreateThrottleForLaunch(
               request, io_data);
       if (ephemeral_app_throttle)
         throttles->push_back(ephemeral_app_throttle);
     }
   }
 #endif
 
 #if defined(OS_CHROMEOS)
   // Check if we need to add offline throttle. This should be done only
   // for main frames.
-  if (resource_type == ResourceType::MAIN_FRAME) {
+  if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
     // We check offline first, then check safe browsing so that we still can
     // block unsafe site after we remove offline page.
     throttles->push_back(new OfflineResourceThrottle(request,
                                                      appcache_service));
   }
 
   // Check if we need to add merge session throttle. This throttle will postpone
   // loading of main frames and XHR request.
-  if (resource_type == ResourceType::MAIN_FRAME ||
-      resource_type == ResourceType::XHR) {
+  if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME ||
+      resource_type == content::RESOURCE_TYPE_XHR) {
     // Add interstitial page while merge session process (cookie
     // reconstruction from OAuth2 refresh token in ChromeOS login) is still in
     // progress while we are attempting to load a google property.
     if (!MergeSessionThrottle::AreAllSessionMergedAlready() &&
         request->url().SchemeIsHTTPOrHTTPS()) {
       throttles->push_back(new MergeSessionThrottle(request, resource_type));
     }
   }
 #endif
 
@@ skipping 64 matching lines @@
         new chrome::InterceptDownloadResourceThrottle(
             request, child_id, route_id, request_id));
 #endif
   }
 
   // If this isn't a new request, we've seen this before and added the standard
   //  resource throttles already so no need to add it again.
   if (!request->is_pending()) {
     AppendStandardResourceThrottles(request,
                                     resource_context,
-                                    ResourceType::MAIN_FRAME,
+                                    content::RESOURCE_TYPE_MAIN_FRAME,
                                     throttles);
   }
 }
 
 ResourceDispatcherHostLoginDelegate*
     ChromeResourceDispatcherHostDelegate::CreateLoginDelegate(
         net::AuthChallengeInfo* auth_info, net::URLRequest* request) {
   return CreateLoginPrompt(auth_info, request);
 }
 
@@ skipping 16 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&LaunchURL, url, child_id, route_id));
   return true;
 #endif
 }
 
 void ChromeResourceDispatcherHostDelegate::AppendStandardResourceThrottles(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
-    ResourceType::Type resource_type,
+    ResourceType resource_type,
     ScopedVector<content::ResourceThrottle>* throttles) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
   // Insert safe browsing at the front of the list, so it gets to decide on
   // policies first.
   if (io_data->safe_browsing_enabled()->GetValue()
 #if defined(OS_ANDROID)
       || io_data->IsDataReductionProxyEnabled()
 #endif
   ) {
-    bool is_subresource_request = resource_type != ResourceType::MAIN_FRAME;
+    bool is_subresource_request =
+        resource_type != content::RESOURCE_TYPE_MAIN_FRAME;
     content::ResourceThrottle* throttle =
         SafeBrowsingResourceThrottleFactory::Create(request,
                                                     resource_context,
                                                     is_subresource_request,
                                                     safe_browsing_.get());
     if (throttle)
       throttles->push_back(throttle);
   }
 #endif
 
 #if defined(ENABLE_MANAGED_USERS)
-  bool is_subresource_request = resource_type != ResourceType::MAIN_FRAME;
+  bool is_subresource_request =
+      resource_type != content::RESOURCE_TYPE_MAIN_FRAME;
   throttles->push_back(new SupervisedUserResourceThrottle(
         request, !is_subresource_request,
         io_data->supervised_user_url_filter()));
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
   content::ResourceThrottle* throttle =
       user_script_listener_->CreateResourceThrottle(request->url(),
                                                     resource_type);
   if (throttle)
@@ skipping 214 matching lines @@
                                        url_request->GetTotalReceivedBytes()));
   }
 }
 
 // static
 void ChromeResourceDispatcherHostDelegate::
     SetExternalProtocolHandlerDelegateForTesting(
     ExternalProtocolHandler::Delegate* delegate) {
   g_external_protocol_handler_delegate = delegate;
 }