Implemented proper support for checking schemes and requested resource types.

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/json/json_writer.h"
@@ skipping 52 matching lines @@
   keys::kOnBeforeRequest,
   keys::kOnBeforeSendHeaders,
   keys::kOnCompleted,
   keys::kOnErrorOccurred,
   keys::kOnSendHeaders,
   keys::kOnAuthRequired,
   keys::kOnResponseStarted,
   keys::kOnHeadersReceived,
 };
 
-static const char* kResourceTypeStrings[] = {

[battre, 2012/04/05 15:01:11]

moved this into web_request_api_helpers.cc so that it can be shared with the
declarative web request api.

-  "main_frame",
-  "sub_frame",
-  "stylesheet",
-  "script",
-  "image",
-  "object",
-  "xmlhttprequest",
-  "other",
-  "other",
-};
-
-static ResourceType::Type kResourceTypeValues[] = {
-  ResourceType::MAIN_FRAME,
-  ResourceType::SUB_FRAME,
-  ResourceType::STYLESHEET,
-  ResourceType::SCRIPT,
-  ResourceType::IMAGE,
-  ResourceType::OBJECT,
-  ResourceType::XHR,
-  ResourceType::LAST_TYPE,  // represents "other"
-  // TODO(jochen): We duplicate the last entry, so the array's size is not a
-  // power of two. If it is, this triggers a bug in gcc 4.4 in Release builds
-  // (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43949). Once we use a version
-  // of gcc with this bug fixed, or the array is changed so this duplicate
-  // entry is no longer required, this should be removed.
-  ResourceType::LAST_TYPE,
-};
-
-COMPILE_ASSERT(
-    arraysize(kResourceTypeStrings) == arraysize(kResourceTypeValues),
-    keep_resource_types_in_sync);
-
 #define ARRAYEND(array) (array + arraysize(array))
 
 // Returns the frame ID as it will be passed to the extension:
 // 0 if the navigation happens in the main frame, or the frame ID
 // modulo 32 bits otherwise.
 // Keep this in sync with the GetFrameId() function in
 // extension_webnavigation_api.cc.
 int GetFrameId(bool is_main_frame, int64 frame_id) {
   return is_main_frame ? 0 : static_cast<int>(frame_id);
 }
@@ skipping 21 matching lines @@
   return extension_info_map->process_map().Contains(info->GetChildID());
 }
 
 bool CanExtensionAccessURL(const Extension* extension, const GURL& url) {
   // about: URLs are not covered in host permissions, but are allowed anyway.
   return (url.SchemeIs(chrome::kAboutScheme) ||
           extension->HasHostPermission(url) ||
           url.GetOrigin() == extension->url());
 }
 
-const char* ResourceTypeToString(ResourceType::Type type) {
-  ResourceType::Type* iter =
-      std::find(kResourceTypeValues, ARRAYEND(kResourceTypeValues), type);
-  if (iter == ARRAYEND(kResourceTypeValues))
-    return "other";
-
-  return kResourceTypeStrings[iter - kResourceTypeValues];
-}
-
-bool ParseResourceType(const std::string& type_str,
-                       ResourceType::Type* type) {
-  const char** iter =
-      std::find(kResourceTypeStrings, ARRAYEND(kResourceTypeStrings), type_str);
-  if (iter == ARRAYEND(kResourceTypeStrings))
-    return false;
-  *type = kResourceTypeValues[iter - kResourceTypeStrings];
-  return true;
-}
-
 void ExtractRequestInfoDetails(net::URLRequest* request,
                                bool* is_main_frame,
                                int64* frame_id,
                                bool* parent_is_main_frame,
                                int64* parent_frame_id,
                                int* tab_id,
                                int* window_id,
                                ResourceType::Type* resource_type) {
   if (!request->GetUserData(NULL))
     return;
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   ExtensionTabIdMap::GetInstance()->GetTabAndWindowId(
       info->GetChildID(), info->GetRouteID(), tab_id, window_id);
   *frame_id = info->GetFrameID();
   *is_main_frame = info->IsMainFrame();
   *parent_frame_id = info->GetParentFrameID();
   *parent_is_main_frame = info->ParentIsMainFrame();
 
   // Restrict the resource type to the values we care about.
-  ResourceType::Type* iter =
-      std::find(kResourceTypeValues, ARRAYEND(kResourceTypeValues),
-                info->GetResourceType());
-  *resource_type = (iter != ARRAYEND(kResourceTypeValues)) ?
-      *iter : ResourceType::LAST_TYPE;
+  if (helpers::IsRelevantResourceType(info->GetResourceType()))
+    *resource_type = info->GetResourceType();
+  else
+    *resource_type = ResourceType::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, DictionaryValue* out) {
   bool is_main_frame = false;
   int64 frame_id = -1;
   bool parent_is_main_frame = false;
   int64 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;
   ResourceType::Type resource_type = ResourceType::LAST_TYPE;
   ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
                             &parent_is_main_frame, &parent_frame_id, &tab_id,
                             &window_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()));
   out->SetString(keys::kUrlKey, request->url().spec());
   out->SetString(keys::kMethodKey, request->method());
   out->SetInteger(keys::kFrameIdKey, frame_id_for_extension);
   out->SetInteger(keys::kParentFrameIdKey, parent_frame_id_for_extension);
   out->SetInteger(keys::kTabIdKey, tab_id);
-  out->SetString(keys::kTypeKey, ResourceTypeToString(resource_type));
+  out->SetString(keys::kTypeKey, helpers::ResourceTypeToString(resource_type));
   out->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
 }
 
 // Converts a HttpHeaders dictionary to a |name|, |value| pair. Returns
 // true if successful.
 bool FromHeaderDictionary(const DictionaryValue* header_value,
                           std::string* name,
                           std::string* value) {
   if (!header_value->GetString(keys::kHeaderNameKey, name))
     return false;
@@ skipping 196 matching lines @@
         urls.AddPattern(pattern);
       }
     } else if (*key == "types") {
       ListValue* types_value = NULL;
       if (!value.GetList("types", &types_value))
         return false;
       for (size_t i = 0; i < types_value->GetSize(); ++i) {
         std::string type_str;
         ResourceType::Type type;
         if (!types_value->GetString(i, &type_str) ||
-            !ParseResourceType(type_str, &type))
+            !helpers::ParseResourceType(type_str, &type))
           return false;
         types.push_back(type);
       }
     } else if (*key == "tabId") {
       if (!value.GetInteger("tabId", &tab_id))
         return false;
     } else if (*key == "windowId") {
       if (!value.GetInteger("windowId", &window_id))
         return false;
     } else {
@@ skipping 1313 matching lines @@
       } else if ((*it)->name().find("AdBlock") != std::string::npos) {
         adblock = true;
       } else {
         other = true;
       }
     }
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(adblock, adblock_plus, other));
 }