content: ResourceType cleanup.

chrome/browser/extensions/api/web_request/web_request_api.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/extensions/api/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 185 matching lines @@
 
 void ExtractRequestInfoDetails(net::URLRequest* request,
                                bool* is_main_frame,
                                int* frame_id,
                                bool* parent_is_main_frame,
                                int* parent_frame_id,
                                int* tab_id,
                                int* window_id,
                                int* render_process_host_id,
                                int* routing_id,
-                               ResourceType::Type* resource_type) {
+                               ResourceType* resource_type) {
   if (!request->GetUserData(NULL))
     return;
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   ExtensionRendererState::GetInstance()->GetTabAndWindowId(
       info, tab_id, window_id);
   *frame_id = info->GetRenderFrameID();
   *is_main_frame = info->IsMainFrame();
   *parent_frame_id = info->GetParentRenderFrameID();
   *parent_is_main_frame = info->ParentIsMainFrame();
   *render_process_host_id = info->GetChildID();
   *routing_id = info->GetRouteID();
 
   // Restrict the resource type to the values we care about.
   if (helpers::IsRelevantResourceType(info->GetResourceType()))
     *resource_type = info->GetResourceType();
   else
-    *resource_type = ResourceType::LAST_TYPE;
+    *resource_type = content::RESOURCE_TYPE_LAST_TYPE;
 }
 
 // Extracts from |request| information for the keys requestId, url, method,
 // frameId, tabId, type, and timeStamp and writes these into |out| to be passed
 // on to extensions.
 void ExtractRequestInfo(net::URLRequest* request, base::DictionaryValue* out) {
   bool is_main_frame = false;
   int frame_id = -1;
   bool parent_is_main_frame = false;
   int parent_frame_id = -1;
   int frame_id_for_extension = -1;
   int parent_frame_id_for_extension = -1;
   int tab_id = -1;
   int window_id = -1;
   int render_process_host_id = -1;
   int routing_id = -1;
-  ResourceType::Type resource_type = ResourceType::LAST_TYPE;
+  ResourceType resource_type = content::RESOURCE_TYPE_LAST_TYPE;
   ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
                             &parent_is_main_frame, &parent_frame_id, &tab_id,
                             &window_id, &render_process_host_id, &routing_id,
                             &resource_type);
   frame_id_for_extension = GetFrameId(is_main_frame, frame_id);
   parent_frame_id_for_extension = GetFrameId(parent_is_main_frame,
                                              parent_frame_id);
 
   out->SetString(keys::kRequestIdKey,
                  base::Uint64ToString(request->identifier()));
@@ skipping 364 matching lines @@
           return false;
         }
         urls.AddPattern(pattern);
       }
     } else if (it.key() == "types") {
       const base::ListValue* types_value = NULL;
       if (!it.value().GetAsList(&types_value))
         return false;
       for (size_t i = 0; i < types_value->GetSize(); ++i) {
         std::string type_str;
-        ResourceType::Type type;
+        ResourceType type;
         if (!types_value->GetString(i, &type_str) ||
             !helpers::ParseResourceType(type_str, &type))
           return false;
         types.push_back(type);
       }
     } else if (it.key() == "tabId") {
       if (!it.value().GetAsInteger(&tab_id))
         return false;
     } else if (it.key() == "windowId") {
       if (!it.value().GetAsInteger(&window_id))
@@ skipping 768 matching lines @@
 bool ExtensionWebRequestEventRouter::IsPageLoad(
     net::URLRequest* request) const {
   bool is_main_frame = false;
   int frame_id = -1;
   bool parent_is_main_frame = false;
   int parent_frame_id = -1;
   int tab_id = -1;
   int window_id = -1;
   int render_process_host_id = -1;
   int routing_id = -1;
-  ResourceType::Type resource_type = ResourceType::LAST_TYPE;
+  ResourceType resource_type = content::RESOURCE_TYPE_LAST_TYPE;
 
   ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
                             &parent_is_main_frame, &parent_frame_id,
                             &tab_id, &window_id, &render_process_host_id,
                             &routing_id, &resource_type);
 
-  return resource_type == ResourceType::MAIN_FRAME;
+  return resource_type == content::RESOURCE_TYPE_MAIN_FRAME;
 }
 
 void ExtensionWebRequestEventRouter::NotifyPageLoad() {
   for (CallbacksForPageLoad::const_iterator i =
            callbacks_for_page_load_.begin();
        i != callbacks_for_page_load_.end(); ++i) {
     i->Run();
   }
   callbacks_for_page_load_.clear();
 }
@@ skipping 24 matching lines @@
 void ExtensionWebRequestEventRouter::GetMatchingListenersImpl(
     void* profile,
     InfoMap* extension_info_map,
     bool crosses_incognito,
     const std::string& event_name,
     const GURL& url,
     int tab_id,
     int window_id,
     int render_process_host_id,
     int routing_id,
-    ResourceType::Type resource_type,
+    ResourceType resource_type,
     bool is_async_request,
     bool is_request_from_extension,
     int* extra_info_spec,
     std::vector<const ExtensionWebRequestEventRouter::EventListener*>*
         matching_listeners) {
   std::string web_request_event_name(event_name);
   WebViewRendererState::WebViewInfo web_view_info;
   bool is_web_view_guest = WebViewRendererState::GetInstance()->
       GetInfo(render_process_host_id, routing_id, &web_view_info);
   if (is_web_view_guest) {
@@ skipping 35 matching lines @@
     bool blocking_listener =
         (it->extra_info_spec &
             (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) != 0;
 
     // We do not want to notify extensions about XHR requests that are
     // triggered by themselves. This is a workaround to prevent deadlocks
     // in case of synchronous XHR requests that block the extension renderer
     // and therefore prevent the extension from processing the request
     // handler. This is only a problem for blocking listeners.
     // http://crbug.com/105656
-    bool synchronous_xhr_from_extension = !is_async_request &&
-        is_request_from_extension && resource_type == ResourceType::XHR;
+    bool synchronous_xhr_from_extension =
+        !is_async_request && is_request_from_extension &&
+        resource_type == content::RESOURCE_TYPE_XHR;
 
     // Only send webRequest events for URLs the extension has access to.
     if (blocking_listener && synchronous_xhr_from_extension)
       continue;
 
     matching_listeners->push_back(&(*it));
     *extra_info_spec |= it->extra_info_spec;
   }
 }
 
 std::vector<const ExtensionWebRequestEventRouter::EventListener*>
 ExtensionWebRequestEventRouter::GetMatchingListeners(
     void* profile,
     InfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
     int* extra_info_spec) {
   // TODO(mpcomplete): handle profile == NULL (should collect all listeners).
   *extra_info_spec = 0;
 
   bool is_main_frame = false;
   int frame_id = -1;
   bool parent_is_main_frame = false;
   int parent_frame_id = -1;
   int tab_id = -1;
   int window_id = -1;
   int render_process_host_id = -1;
   int routing_id = -1;
-  ResourceType::Type resource_type = ResourceType::LAST_TYPE;
+  ResourceType resource_type = content::RESOURCE_TYPE_LAST_TYPE;
   const GURL& url = request->url();
 
   ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
                             &parent_is_main_frame, &parent_frame_id,
                             &tab_id, &window_id, &render_process_host_id,
                             &routing_id, &resource_type);
 
   std::vector<const ExtensionWebRequestEventRouter::EventListener*>
       matching_listeners;
 
@@ skipping 918 matching lines @@
   extensions::RuntimeData* runtime_data =
       extensions::ExtensionSystem::Get(profile)->runtime_data();
   for (extensions::ExtensionSet::const_iterator it = extensions.begin();
        !webrequest_used && it != extensions.end();
        ++it) {
     webrequest_used |= runtime_data->HasUsedWebRequest(it->get());
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(webrequest_used));
 }