Merge 116258 - Hide downloads of extensions blacklist from web request API.

chrome/browser/extensions/extension_webrequest_api.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/extension_webrequest_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
+#include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_id_map.h"
 #include "chrome/browser/extensions/extension_webrequest_api_constants.h"
 #include "chrome/browser/extensions/extension_webrequest_api_helpers.h"
 #include "chrome/browser/extensions/extension_webrequest_time_tracker.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_message_filter.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
@@ skipping 85 matching lines @@
       ResourceDispatcherHost::InfoForRequest(request);
 
   // If this request was not created by the ResourceDispatcher, |info| is NULL.
   // All requests from extensions are created by the ResourceDispatcher.
   if (!info)
     return false;
 
   return extension_info_map->process_map().Contains(info->child_id());
 }
 
+// Returns true if the URL is sensitive and requests to this URL must not be
+// modified/canceled by extensions, e.g. because it is targeted to the webstore
+// to check for updates, extension blacklisting, etc.
+bool IsSensitiveURL(const GURL& url) {
+  bool is_webstore_gallery_url =
+      StartsWithASCII(url.spec(), extension_urls::kGalleryBrowsePrefix, true);
+  bool is_google_com_chrome_url =
+      EndsWith(url.host(), "google.com", true) &&
+      StartsWithASCII(url.path(), "/chrome", true);
+  std::string url_without_query =
+      url.spec().substr(0, url.spec().find_first_of('?'));
+  return is_webstore_gallery_url || is_google_com_chrome_url ||
+      extension_urls::IsWebstoreUpdateUrl(GURL(url_without_query)) ||
+      extension_urls::IsBlacklistUpdateUrl(url);
+}
+
 // Returns true if the scheme is one we want to allow extensions to have access
 // to. Extensions still need specific permissions for a given URL, which is
 // covered by CanExtensionAccessURL.
 bool HasWebRequestScheme(const GURL& url) {
   return (url.SchemeIs(chrome::kAboutScheme) ||
           url.SchemeIs(chrome::kFileScheme) ||
           url.SchemeIs(chrome::kFtpScheme) ||
           url.SchemeIs(chrome::kHttpScheme) ||
           url.SchemeIs(chrome::kHttpsScheme) ||
           url.SchemeIs(chrome::kExtensionScheme));
 }
 
+// Returns true if requests for |url| shall not be reported to extensions.
+bool HideRequestForURL(const GURL& url) {
+  return IsSensitiveURL(url) || !HasWebRequestScheme(url);
+}
+
 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);
@@ skipping 361 matching lines @@
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
-  // TODO(jochen): Figure out what to do with events from the system context.
-  if (!profile)
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return net::OK;
 
   if (IsPageLoad(request))
     NotifyPageLoad();
 
-  if (!HasWebRequestScheme(request->url()))
-    return net::OK;
-
   request_time_tracker_->LogRequestStartTime(request->identifier(),
                                              base::Time::Now(),
                                              request->url(),
                                              profile);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map, keys::kOnBeforeRequest,
                            request, &extra_info_spec);
   if (listeners.empty())
@@ skipping 16 matching lines @@
   }
   return net::OK;
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
-  // TODO(jochen): Figure out what to do with events from the system context.
-  if (!profile)
-    return net::OK;
-
-  if (!HasWebRequestScheme(request->url()))
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return net::OK;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders))
     return net::OK;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnBeforeSendHeaders, request,
                            &extra_info_spec);
@@ skipping 15 matching lines @@
     return net::ERR_IO_PENDING;
   }
   return net::OK;
 }
 
 void ExtensionWebRequestEventRouter::OnSendHeaders(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
-  if (!profile)
-    return;
-
-  if (!HasWebRequestScheme(request->url()))
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnSendHeaders))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRedirect);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
@@ skipping 11 matching lines @@
   DispatchEvent(profile, request, listeners, args);
 }
 
 int ExtensionWebRequestEventRouter::OnHeadersReceived(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
-  if (!profile)
-    return net::OK;
-
-  if (!HasWebRequestScheme(request->url()))
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return net::OK;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnHeadersReceived, request,
                            &extra_info_spec);
 
   if (listeners.empty())
     return net::OK;
@@ skipping 27 matching lines @@
 
 net::NetworkDelegate::AuthRequiredResponse
 ExtensionWebRequestEventRouter::OnAuthRequired(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::AuthChallengeInfo& auth_info,
     const net::NetworkDelegate::AuthCallback& callback,
     net::AuthCredentials* credentials) {
   // No profile means that this is for authentication challenges in the
-  // system context. Skip in that case.
-  if (!profile)
-    return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
-
-  if (!HasWebRequestScheme(request->url()))
+  // system context. Skip in that case. Also skip sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnAuthRequired, request, &extra_info_spec);
   if (listeners.empty())
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
   ListValue args;
@@ skipping 23 matching lines @@
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING;
   }
   return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 }
 
 void ExtensionWebRequestEventRouter::OnBeforeRedirect(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const GURL& new_location) {
-  if (!profile)
-    return;
-
-  if (!HasWebRequestScheme(request->url()))
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRedirect))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRequest);
   ClearSignaled(request->identifier(), kOnBeforeSendHeaders);
   ClearSignaled(request->identifier(), kOnSendHeaders);
   ClearSignaled(request->identifier(), kOnHeadersReceived);
 
@@ skipping 23 matching lines @@
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
-  if (!profile)
-    return;
-
-  if (!HasWebRequestScheme(request->url()))
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnResponseStarted, request, &extra_info_spec);
@@ skipping 21 matching lines @@
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnCompleted(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
-  if (!profile)
-    return;
-
-  if (!HasWebRequestScheme(request->url()))
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return;
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
                                            base::Time::Now());
 
   DCHECK(request->status().status() == net::URLRequestStatus::SUCCESS);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnCompleted));
 
   int extra_info_spec = 0;
@@ skipping 24 matching lines @@
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
-  if (!profile)
-      return;
-
-  if (!HasWebRequestScheme(request->url()))
+  // We hide events from the system context as well as sensitive requests.
+  if (!profile || HideRequestForURL(request->url()))
     return;
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
                                            base::Time::Now());
 
   DCHECK(request->status().status() == net::URLRequestStatus::FAILED ||
          request->status().status() == net::URLRequestStatus::CANCELED);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnErrorOccurred));
 
@@ skipping 805 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));
 }