content: ResourceType cleanup.

content/browser/appcache/appcache_request_handler.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.
 
 #include "content/browser/appcache/appcache_request_handler.h"
 
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_policy.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 
 namespace content {
 
-AppCacheRequestHandler::AppCacheRequestHandler(
-    AppCacheHost* host, ResourceType::Type resource_type)
-    : host_(host), resource_type_(resource_type),
-      is_waiting_for_cache_selection_(false), found_group_id_(0),
-      found_cache_id_(0), found_network_namespace_(false),
-      cache_entry_not_found_(false), maybe_load_resource_executed_(false) {
+AppCacheRequestHandler::AppCacheRequestHandler(AppCacheHost* host,
+                                               ResourceType resource_type)
+    : host_(host),
+      resource_type_(resource_type),
+      is_waiting_for_cache_selection_(false),
+      found_group_id_(0),
+      found_cache_id_(0),
+      found_network_namespace_(false),
+      cache_entry_not_found_(false),
+      maybe_load_resource_executed_(false) {
   DCHECK(host_);
   host_->AddObserver(this);
 }
 
 AppCacheRequestHandler::~AppCacheRequestHandler() {
   if (host_) {
     storage()->CancelDelegateCallbacks(this);
     host_->RemoveObserver(this);
   }
 }
@@ skipping 171 matching lines @@
   }
 }
 
 void AppCacheRequestHandler::DeliverAppCachedResponse(
     const AppCacheEntry& entry, int64 cache_id, int64 group_id,
     const GURL& manifest_url,  bool is_fallback,
     const GURL& namespace_entry_url) {
   DCHECK(host_ && job_.get() && job_->is_waiting());
   DCHECK(entry.has_response_id());
 
-  if (ResourceType::IsFrame(resource_type_) && !namespace_entry_url.is_empty())
+  if (IsResourceTypeFrame(resource_type_) && !namespace_entry_url.is_empty())
     host_->NotifyMainResourceIsNamespaceEntry(namespace_entry_url);
 
   job_->DeliverAppCachedResponse(manifest_url, group_id, cache_id,
                                  entry, is_fallback);
 }
 
 void AppCacheRequestHandler::DeliverErrorResponse() {
   DCHECK(job_.get() && job_->is_waiting());
   job_->DeliverErrorResponse();
 }
 
 void AppCacheRequestHandler::DeliverNetworkResponse() {
   DCHECK(job_.get() && job_->is_waiting());
   job_->DeliverNetworkResponse();
 }
 
 // Main-resource handling ----------------------------------------------
 
 void AppCacheRequestHandler::MaybeLoadMainResource(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
   DCHECK(host_);
 
   const AppCacheHost* spawning_host =
-      ResourceType::IsSharedWorker(resource_type_) ?
-          host_ : host_->GetSpawningHost();
+      (resource_type_ == RESOURCE_TYPE_SHARED_WORKER) ?
+      host_ : host_->GetSpawningHost();
   GURL preferred_manifest_url = spawning_host ?
       spawning_host->preferred_manifest_url() : GURL();
 
   // We may have to wait for our storage query to complete, but
   // this query can also complete syncrhonously.
   job_ = new AppCacheURLRequestJob(request, network_delegate,
                                    storage(), host_, is_main_resource());
   storage()->FindResponseForMainRequest(
       request->url(), preferred_manifest_url, this);
 }
@@ skipping 10 matching lines @@
   DCHECK(!(entry.has_response_id() && fallback_entry.has_response_id()));
 
   if (!job_.get())
     return;
 
   AppCachePolicy* policy = host_->service()->appcache_policy();
   bool was_blocked_by_policy = !manifest_url.is_empty() && policy &&
       !policy->CanLoadAppCache(manifest_url, host_->first_party_url());
 
   if (was_blocked_by_policy) {
-    if (ResourceType::IsFrame(resource_type_)) {
+    if (IsResourceTypeFrame(resource_type_)) {
       host_->NotifyMainResourceBlocked(manifest_url);
     } else {
-      DCHECK(ResourceType::IsSharedWorker(resource_type_));
+      DCHECK_EQ(resource_type_, RESOURCE_TYPE_SHARED_WORKER);
       host_->frontend()->OnContentBlocked(host_->host_id(), manifest_url);
     }
     DeliverNetworkResponse();
     return;
   }
 
-  if (ResourceType::IsFrame(resource_type_) && cache_id != kAppCacheNoCacheId) {
+  if (IsResourceTypeFrame(resource_type_) && cache_id != kAppCacheNoCacheId) {
     // AppCacheHost loads and holds a reference to the main resource cache
     // for two reasons, firstly to preload the cache into the working set
     // in advance of subresource loads happening, secondly to prevent the
     // AppCache from falling out of the working set on frame navigations.
     host_->LoadMainResourceCache(cache_id);
     host_->set_preferred_manifest_url(manifest_url);
   }
 
   // 6.11.1 Navigating across documents, steps 10 and 14.
 
@@ skipping 102 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace content