Also match against the query string if present.

chrome/browser/privacy_blacklist/blacklist.cc

 // Copyright (c) 2009 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/privacy_blacklist/blacklist.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 42 matching lines @@
     return kDontSendReferrer;
   else if (s == STRINGIZE(kDontSendUserAgent))
     return kDontSendUserAgent;
   else if (s == STRINGIZE(kBlockByType))
     return kBlockByType;
   else if (s == STRINGIZE(kBlockUnsecure))
     return kBlockUnsecure;
   return 0;
 }
 
+// static
 bool Blacklist::Matches(const std::string& pattern, const std::string& url) {
   if (pattern.size() > url.size())
     return false;
 
   std::string::size_type p = 0;
   std::string::size_type u = 0;
 
   while (pattern[p] != '\0' && url[u] != '\0') {
     if (pattern[p] == '@') {
       while (pattern[++p] == '@');  // Consecutive @ are redundant.
@@ skipping 94 matching lines @@
   blacklist_.push_back(linked_ptr<Entry>(entry));
 }
 
 void Blacklist::AddProvider(Provider* provider) {
   DCHECK(provider);
   providers_.push_back(linked_ptr<Provider>(provider));
 }
 
 // Returns a pointer to the Blacklist-owned entry which matches the given
 // URL. If no matching Entry is found, returns null.
-Blacklist::Match* Blacklist::findMatch(const GURL& url) const {
+Blacklist::Match* Blacklist::FindMatch(const GURL& url) const {
   // Never match something which is not http, https or ftp.
   // TODO(idanan): Investigate if this would be an inclusion test instead of an
   // exclusion test and if there are other schemes to test for.
   if (!url.SchemeIs(chrome::kHttpScheme) &&
       !url.SchemeIs(chrome::kHttpsScheme) &&
       !url.SchemeIs(chrome::kFtpScheme))
     return 0;
+  std::string url_spec = GetURLAsString(url);
   Match* match = NULL;
   for (EntryList::const_iterator i = blacklist_.begin();
        i != blacklist_.end(); ++i) {
-    if (Matches((*i)->pattern(), url.host() + url.path())) {
+    if (Matches((*i)->pattern(), url_spec)) {
       if (!match)
         match = new Match;
       match->AddEntry(i->get());
     }
   }
   return match;
 }
 
+// static
+std::string Blacklist::GetURLAsString(const GURL& url) {
+  std::string url_spec = url.host() + url.path();
+  if (!url.query().empty())
+    url_spec = url_spec + "?" + url.query();
+
+  return url_spec;
+}
+
 std::string Blacklist::StripCookies(const std::string& header) {
   return net::HttpUtil::StripHeaders(header, cookie_headers, 2);
 }
 
 std::string Blacklist::StripCookieExpiry(const std::string& cookie) {
   std::string::size_type delim = cookie.find(';');
   std::string::size_type start = cookie.find("expires=", delim + 1);
   if (start != std::string::npos) {
     std::string::size_type i = start;
     // Make sure only whitespace precedes the expiry until a delimiter.
     while (cookie[--i] != ';')
       if (!IsAsciiWhitespace(cookie[i]))
         return cookie;
 
     std::string session_cookie(cookie, 0, i);
     std::string::size_type end = cookie.find(';', start + 1);
     if (end != std::string::npos)
       session_cookie.append(cookie.substr(end));
     return session_cookie;
   }
   return cookie;
 }