Add request_id to HttpRequestInfo and pass it to the NetworkDelegate for events.

chrome/browser/extensions/extension_webrequest_api.cc

 // Copyright (c) 2011 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/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router_forwarder.h"
 #include "chrome/browser/extensions/extension_webrequest_api_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_extent.h"
 #include "chrome/common/extensions/url_pattern.h"
+#include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "googleurl/src/gurl.h"
 
 namespace keys = extension_webrequest_api_constants;
 
 namespace {
 
 // List of all the webRequest events.
 static const char *kWebRequestEvents[] = {
   keys::kOnBeforeRedirect,
   keys::kOnBeforeRequest,
+  keys::kOnBeforeSendHeaders,
   keys::kOnCompleted,
   keys::kOnErrorOccurred,
   keys::kOnHeadersReceived,
   keys::kOnRequestSent
 };
 
 // TODO(mpcomplete): should this be a set of flags?
 static const char* kRequestFilterTypes[] = {
   "main_frame",
   "sub_frame",
@@ skipping 57 matching lines @@
 // Internal representation of the extraInfoSpec parameter on webRequest events,
 // used to specify extra information to be included with network events.
 struct ExtensionWebRequestEventRouter::ExtraInfoSpec {
   enum Flags {
     REQUEST_LINE = 1<<0,
     REQUEST_HEADERS = 1<<1,
     STATUS_LINE = 1<<2,
     RESPONSE_HEADERS = 1<<3,
     REDIRECT_REQUEST_LINE = 1<<4,
     REDIRECT_REQUEST_HEADERS = 1<<5,
-    BLOCKING = 1<<5,
+    BLOCKING = 1<<6,
   };
 
   static bool InitFromValue(const ListValue& value, int* extra_info_spec);
 };
 
 // Represents a single unique listener to an event, along with whatever filter
 // parameters and extra_info_spec were specified at the time the listener was
 // added.
 struct ExtensionWebRequestEventRouter::EventListener {
   std::string extension_id;
@@ skipping 21 matching lines @@
 
   // The callback to call when we get a response from all event handlers.
   net::CompletionCallback* callback;
 
   // Time the request was issued. Used for logging purposes.
   base::Time request_time;
 
   BlockedRequest() : num_handlers_blocking(0), callback(NULL) {}
 };
 
+// We use this class as UserData on any URLRequests that we are tracking. This

[willchan no longer on Chromium, 2011/03/22 23:05:35]

Why is this simpler than adding a cancellation API in NetworkDelegate that is
called when the URLRequest is destroyed? It's non-obvious that this is
happening.

[Matt Perry, 2011/03/24 00:11:25]

It isn't... I guess I'll do that then :).

+// lets us know when the URLRequest is deleted, so we can remove it from our
+// tracked list.
+class ExtensionWebRequestEventRouter::TrackedRequest
+    : public net::URLRequest::UserData {
+public:
+  TrackedRequest(net::URLRequest* request,
+                 ExtensionWebRequestEventRouter* router)
+      : router_(router), request_(request) {
+    request->SetUserData(router_, this);
+  }
+  virtual ~TrackedRequest() {
+    if (router_)
+      router_->OnRequestDeleted(request_);
+  }
+
+  void StopTracking() {
+    ExtensionWebRequestEventRouter* key = router_;
+    router_ = NULL;
+    request_->SetUserData(key, NULL);  // deletes |this|
+  }
+
+  net::URLRequest* request() const { return request_; }
+
+ private:
+  ExtensionWebRequestEventRouter* router_;
+  net::URLRequest* request_;
+};
+
 bool ExtensionWebRequestEventRouter::RequestFilter::InitFromValue(
     const DictionaryValue& value) {
   for (DictionaryValue::key_iterator key = value.begin_keys();
        key != value.end_keys(); ++key) {
     if (*key == "urls") {
       ListValue* urls_value = NULL;
       if (!value.GetList("urls", &urls_value))
         return false;
       for (size_t i = 0; i < urls_value->GetSize(); ++i) {
         std::string url;
@@ skipping 60 matching lines @@
 
 // static
 ExtensionWebRequestEventRouter* ExtensionWebRequestEventRouter::GetInstance() {
   return Singleton<ExtensionWebRequestEventRouter>::get();
 }
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter() {
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
+  for (HttpRequestMap::iterator it = http_requests_.begin();
+       it != http_requests_.end(); ++it) {
+    it->second->StopTracking();  // deletes the object
+  }
 }
 
 bool ExtensionWebRequestEventRouter::OnBeforeRequest(
     ProfileId profile_id,
     ExtensionEventRouterForwarder* event_router,
     net::URLRequest* request,
     net::CompletionCallback* callback) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (profile_id == Profile::kInvalidProfileId)
     return false;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile_id, keys::kOnBeforeRequest, request->url());
   if (listeners.empty())
     return false;
 
+  // If this is an HTTP request, keep track of it. HTTP-specific events only
+  // have the request ID, so we'll need to look up the URLRequest from that.
+  if (request->url().SchemeIs(chrome::kHttpScheme) ||
+      request->url().SchemeIs(chrome::kHttpsScheme)) {
+    http_requests_[request->identifier()] = new TrackedRequest(request, this);
+  }
+
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kMethodKey, request->method());
   // TODO(mpcomplete): implement
   dict->SetInteger(keys::kTabIdKey, 0);
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kTypeKey, "main_frame");
   dict->SetInteger(keys::kTimeStampKey, 1);
   args.Append(dict);
 
+  return DispatchEvent(profile_id, event_router, request, callback, listeners,
+                       args);
+}
+
+bool ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
+    ProfileId profile_id,
+    ExtensionEventRouterForwarder* event_router,
+    uint64 request_id,
+    net::HttpRequestHeaders* headers,
+    net::CompletionCallback* callback) {
+  // TODO(jochen): Figure out what to do with events from the system context.
+  if (profile_id == Profile::kInvalidProfileId)
+    return false;
+
+  HttpRequestMap::iterator iter = http_requests_.find(request_id);
+  if (iter == http_requests_.end())
+    return false;
+
+  net::URLRequest* request = iter->second->request();
+  iter->second->StopTracking();
+  http_requests_.erase(iter);
+
+  std::vector<const EventListener*> listeners =
+      GetMatchingListeners(profile_id, keys::kOnBeforeSendHeaders, request);
+  if (listeners.empty())
+    return false;
+
+  ListValue args;
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString(keys::kRequestIdKey,
+                  base::Uint64ToString(request->identifier()));
+  dict->SetString(keys::kUrlKey, request->url().spec());
+  dict->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
+  // TODO(mpcomplete): request headers.
+  args.Append(dict);
+
+  return DispatchEvent(profile_id, event_router, request, callback, listeners,
+                       args);
+}
+
+bool ExtensionWebRequestEventRouter::DispatchEvent(
+    ProfileId profile_id,
+    ExtensionEventRouterForwarder* event_router,
+    net::URLRequest* request,
+    net::CompletionCallback* callback,
+    const std::vector<const EventListener*>& listeners,
+    const ListValue& args) {
   std::string json_args;
   base::JSONWriter::Write(&args, false, &json_args);
 
   // TODO(mpcomplete): Consider consolidating common (extension_id,json_args)
   // pairs into a single message sent to a list of sub_event_names.
   int num_handlers_blocking = 0;
-  for (std::vector<const EventListener*>::iterator it = listeners.begin();
+  for (std::vector<const EventListener*>::const_iterator it = listeners.begin();
        it != listeners.end(); ++it) {
     event_router->DispatchEventToExtension(
         (*it)->extension_id, (*it)->sub_event_name, json_args,
         profile_id, true, GURL());
-    if ((*it)->extra_info_spec & ExtraInfoSpec::BLOCKING) {
+    if (callback && (*it)->extra_info_spec & ExtraInfoSpec::BLOCKING) {
       (*it)->blocked_requests.insert(request->identifier());
       ++num_handlers_blocking;
     }
   }
 
   if (num_handlers_blocking > 0) {
     CHECK(blocked_requests_.find(request->identifier()) ==
           blocked_requests_.end());
     blocked_requests_[request->identifier()].num_handlers_blocking =
         num_handlers_blocking;
@@ skipping 87 matching lines @@
   std::vector<const EventListener*> matching_listeners;
   std::set<EventListener>& listeners = listeners_[profile_id][event_name];
   for (std::set<EventListener>::iterator it = listeners.begin();
        it != listeners.end(); ++it) {
     if (it->filter.urls.is_empty() || it->filter.urls.ContainsURL(url))
       matching_listeners.push_back(&(*it));
   }
   return matching_listeners;
 }
 
+std::vector<const ExtensionWebRequestEventRouter::EventListener*>
+ExtensionWebRequestEventRouter::GetMatchingListeners(
+    ProfileId profile_id,
+    const std::string& event_name,
+    net::URLRequest* request) {
+  int tab_id = -1;
+  int window_id = -1;
+  ResourceType::Type resource_type = ResourceType::LAST_TYPE;
+  ExtractRequestInfo(request, &tab_id, &window_id, &resource_type);
+
+  return GetMatchingListeners(
+      profile_id, event_name, request->url(), tab_id, window_id, resource_type);
+}
+
 void ExtensionWebRequestEventRouter::DecrementBlockCount(uint64 request_id,
                                                          bool cancel) {
   // It's possible that this request was already cancelled by a previous event
   // handler. If so, ignore this response.
   if (blocked_requests_.find(request_id) == blocked_requests_.end())
     return;
 
   BlockedRequest& blocked_request = blocked_requests_[request_id];
   int num_handlers_blocking = --blocked_request.num_handlers_blocking;
   CHECK_GE(num_handlers_blocking, 0);
 
   HISTOGRAM_TIMES("Extensions.NetworkDelay",
                    base::Time::Now() - blocked_request.request_time);
 
   if (num_handlers_blocking == 0 || cancel) {
     CHECK(blocked_request.callback);
     blocked_request.callback->Run(cancel ? net::ERR_EMPTY_RESPONSE : net::OK);
     blocked_requests_.erase(request_id);
   }
 }
 
+void ExtensionWebRequestEventRouter::OnRequestDeleted(
+    net::URLRequest* request) {
+  http_requests_.erase(request->identifier());
+}
+
 bool WebRequestAddEventListener::RunImpl() {
   // Argument 0 is the callback, which we don't use here.
 
   ExtensionWebRequestEventRouter::RequestFilter filter;
   if (HasOptionalArgument(1)) {
     DictionaryValue* value = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &value));
     EXTENSION_FUNCTION_VALIDATE(filter.InitFromValue(*value));
   }
 
@@ skipping 46 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableFunction(
           &EventHandledOnIOThread,
           profile()->GetRuntimeId(), extension_id(),
           event_name, sub_event_name, request_id, cancel));
 
   return true;
 }