Moved ExtensionInfoMap and ExtensionsQuotaService to extensions/

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 12 matching lines @@
 #include "chrome/browser/extensions/activity_log/web_request_constants.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/request_stage.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/upload_data_presenter.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/web_request_time_tracker.h"
 #include "chrome/browser/extensions/event_router.h"
-#include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_renderer_state.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_warning_service.h"
 #include "chrome/browser/extensions/extension_warning_set.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/common/extensions/api/web_request.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/permissions/permissions_data.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/user_metrics.h"
+#include "extensions/browser/info_map.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/event_filtering_info.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/url_pattern.h"
 #include "grit/generated_resources.h"
 #include "net/base/auth.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using chrome::VersionInfo;
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using extensions::ErrorUtils;
 using extensions::Extension;
 using extensions::ExtensionWarning;
 using extensions::ExtensionWarningService;
 using extensions::ExtensionWarningSet;
+using extensions::InfoMap;
 using extensions::Feature;
 using extensions::web_navigation_api_helpers::GetFrameId;
 
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
 namespace web_request = extensions::api::web_request;
 namespace declarative_keys = extensions::declarative_webrequest_constants;
 namespace activitylog = activity_log_web_request_constants;
 
 namespace {
@@ skipping 48 matching lines @@
   std::string web_request_event_name(event_name);
   if (web_request_event_name.find(kWebView) != std::string::npos)
     web_request_event_name.replace(0, sizeof(kWebView) - 1, kWebRequest);
   return std::find(kWebRequestEvents, ARRAYEND(kWebRequestEvents),
                    web_request_event_name) != ARRAYEND(kWebRequestEvents);
 }
 
 // Returns whether |request| has been triggered by an extension in
 // |extension_info_map|.
 bool IsRequestFromExtension(const net::URLRequest* request,
-                            const ExtensionInfoMap* extension_info_map) {
+                            const InfoMap* extension_info_map) {
   // |extension_info_map| is NULL for system-level requests.
   if (!extension_info_map)
     return false;
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(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;
@@ skipping 304 matching lines @@
   net::NetworkDelegate::AuthCallback auth_callback;
 
   // Time the request was paused. Used for logging purposes.
   base::Time blocking_time;
 
   // Changes requested by extensions.
   helpers::EventResponseDeltas response_deltas;
 
   // Provider of meta data about extensions, only used and non-NULL for events
   // that are delayed until the rules registry is ready.
-  ExtensionInfoMap* extension_info_map;
+  InfoMap* extension_info_map;
 
   BlockedRequest()
       : request(NULL),
         is_incognito(false),
         event(kInvalidEvent),
         num_handlers_blocking(0),
         net_log(NULL),
         new_url(NULL),
         request_headers(NULL),
         override_response_headers(NULL),
@@ skipping 118 matching lines @@
     void* profile,
     scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry) {
   if (rules_registry.get())
     rules_registries_[profile] = rules_registry;
   else
     rules_registries_.erase(profile);
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   if (IsPageLoad(request))
     NotifyPageLoad();
@@ skipping 45 matching lines @@
     // to modify the request and we can respond synchronously.
     return ExecuteDeltas(profile, request->identifier(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
@@ skipping 36 matching lines @@
     // to modify the request and we can respond synchronously.
     return ExecuteDeltas(profile, request->identifier(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 void ExtensionWebRequestEventRouter::OnSendHeaders(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnSendHeaders))
     return;
 
@@ skipping 12 matching lines @@
   ExtractRequestInfo(request, dict);
   if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS)
     dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(headers));
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 int ExtensionWebRequestEventRouter::OnHeadersReceived(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::OK;
 
   bool initialize_blocked_requests = false;
@@ skipping 47 matching lines @@
     return ExecuteDeltas(profile, request->identifier(),
                          false /* call_callback*/);
   } else {
     return net::ERR_IO_PENDING;
   }
 }
 
 net::NetworkDelegate::AuthRequiredResponse
 ExtensionWebRequestEventRouter::OnAuthRequired(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* 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. Also skip sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 
@@ skipping 32 matching lines @@
     blocked_requests_[request->identifier()].auth_callback = callback;
     blocked_requests_[request->identifier()].auth_credentials = credentials;
     blocked_requests_[request->identifier()].net_log = &request->net_log();
     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,
+    InfoMap* extension_info_map,
     net::URLRequest* request,
     const GURL& new_location) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRedirect))
     return;
 
@@ skipping 27 matching lines @@
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* extension_info_map,
     net::URLRequest* request) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
       WebRequestPermissions::HideRequest(extension_info_map, request))
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
@@ skipping 22 matching lines @@
   dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
-void ExtensionWebRequestEventRouter::OnCompleted(
-    void* profile,
-    ExtensionInfoMap* extension_info_map,
-    net::URLRequest* request) {
+void ExtensionWebRequestEventRouter::OnCompleted(void* profile,
+                                                 InfoMap* extension_info_map,
+                                                 net::URLRequest* request) {
   // We hide events from the system context as well as sensitive requests.
   // However, if the request first became sensitive after redirecting we have
   // already signaled it and thus we have to signal the end of it. This is
   // risk-free because the handler cannot modify the request now.
   if (!profile ||
       (WebRequestPermissions::HideRequest(extension_info_map, request) &&
        !WasSignaled(*request)))
     return;
 
   request_time_tracker_->LogRequestEndTime(request->identifier(),
@@ skipping 31 matching lines @@
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* extension_info_map,
     net::URLRequest* request,
     bool started) {
   // We hide events from the system context as well as sensitive requests.
   // However, if the request first became sensitive after redirecting we have
   // already signaled it and thus we have to signal the end of it. This is
   // risk-free because the handler cannot modify the request now.
   if (!profile ||
       (WebRequestPermissions::HideRequest(extension_info_map, request) &&
        !WasSignaled(*request)))
     return;
@@ skipping 292 matching lines @@
 
 bool ExtensionWebRequestEventRouter::WasSignaled(
     const net::URLRequest& request) const {
   SignaledRequestMap::const_iterator flag =
       signaled_requests_.find(request.identifier());
   return (flag != signaled_requests_.end()) && (flag->second != 0);
 }
 
 void ExtensionWebRequestEventRouter::GetMatchingListenersImpl(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    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,
     bool is_async_request,
     bool is_request_from_extension,
@@ skipping 56 matching lines @@
       continue;
 
     matching_listeners->push_back(&(*it));
     *extra_info_spec |= it->extra_info_spec;
   }
 }
 
 std::vector<const ExtensionWebRequestEventRouter::EventListener*>
 ExtensionWebRequestEventRouter::GetMatchingListeners(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    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;
   int64 frame_id = -1;
   bool parent_is_main_frame = false;
   int64 parent_frame_id = -1;
@@ skipping 407 matching lines @@
     if (call_callback)
       callback.Run(response);
   } else {
     blocked_requests_.erase(request_id);
   }
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
     void* profile,
-    ExtensionInfoMap* extension_info_map,
+    InfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
     extensions::RequestStage request_stage,
     const net::HttpResponseHeaders* original_response_headers) {
   // If this check fails, check that the active stages are up-to-date in
   // browser/extensions/api/declarative_webrequest/request_stage.h .
   DCHECK(request_stage & extensions::kActiveStages);
 
   // Rules of the current |profile| may apply but we need to check also whether
   // there are applicable rules from extensions whose background page
@@ skipping 129 matching lines @@
 // of WebKit at the time of the next page load (top level navigation event).
 // This quota heuristic is intended to limit the number of times the cache is
 // cleared by an extension.
 //
 // As we want to account for the number of times the cache is really cleared
 // (opposed to the number of times webRequest.handlerBehaviorChanged() is
 // called), we cannot decide whether a call of
 // webRequest.handlerBehaviorChanged() should trigger a quota violation at the
 // time it is called. Instead we only decrement the bucket counter at the time
 // when the cache is cleared (when page loads happen).
-class ClearCacheQuotaHeuristic : public QuotaLimitHeuristic {
+class ClearCacheQuotaHeuristic : public extensions::QuotaLimitHeuristic {
  public:
   ClearCacheQuotaHeuristic(const Config& config, BucketMapper* map)
       : QuotaLimitHeuristic(
             config,
             map,
             "MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES"),
         callback_registered_(false),
         weak_ptr_factory_(this) {}
   virtual ~ClearCacheQuotaHeuristic() {}
   virtual bool Apply(Bucket* bucket,
@@ skipping 225 matching lines @@
   }
 
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile_id(), extension_id(), event_name, sub_event_name, request_id,
       response.release());
 
   return true;
 }
 
 void WebRequestHandlerBehaviorChangedFunction::GetQuotaLimitHeuristics(
-    QuotaLimitHeuristics* heuristics) const {
-  QuotaLimitHeuristic::Config config = {
-    // See web_request.json for current value.
-    web_request::MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES,
-    base::TimeDelta::FromMinutes(10)
-  };
-  QuotaLimitHeuristic::BucketMapper* bucket_mapper =
-      new QuotaLimitHeuristic::SingletonBucketMapper();
+    extensions::QuotaLimitHeuristics* heuristics) const {
+  extensions::QuotaLimitHeuristic::Config config = {
+      // See web_request.json for current value.
+      web_request::MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES,
+      base::TimeDelta::FromMinutes(10)};
+  extensions::QuotaLimitHeuristic::BucketMapper* bucket_mapper =
+      new extensions::QuotaLimitHeuristic::SingletonBucketMapper();
   ClearCacheQuotaHeuristic* heuristic =
       new ClearCacheQuotaHeuristic(config, bucket_mapper);
   heuristics->push_back(heuristic);
 }
 
 void WebRequestHandlerBehaviorChangedFunction::OnQuotaExceeded(
     const std::string& violation_error) {
   // Post warning message.
   ExtensionWarningSet warnings;
   warnings.insert(
@@ skipping 31 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));
 }