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.
@@ skipping 207 matching lines @@
     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;
 
+  // Don't handle HTTP requests yet. We want to wait until we have headers
+  // available. Then we can dispatch the event. Remember the request, because
+  // we only have access to the ID at that point.
+  if (request->url().SchemeIs(chrome::kHttpScheme) ||
+      request->url().SchemeIs(chrome::kHttpsScheme)) {
+    http_requests_[request->identifier()] = request;

[willchan no longer on Chromium, 2011/03/17 15:55:54]

You insert into this map here. What happens if OnBeforeHttpRequest() never gets
called for it (the URLRequest got canceled)? Will we keep the mapping forever?

We should probably be clear at this point that the webRequest API won't stop
Chromium from doing a TCP connect to the origin server. At the point that
OnBeforeHttpRequest() is called, we have already completed establishing the
connection. Even if we were to reorder that, then due to preconnect and other
such things, we can't block the TCP connect unless we were to provide a new
lower level networking extension API.

[Matt Perry, 2011/03/22 21:11:43]

Yep... I added a tracking object so they're removed now.

+    return false;
+  }
+
+  return OnBeforeRequestCommon(profile_id, event_router, request, callback,
+                               tab_id, window_id, resource_type, listeners);

[willchan no longer on Chromium, 2011/03/17 15:55:54]

where are these variables coming from? looks like the tryjobs caught this too.

[Matt Perry, 2011/03/22 21:11:43]

oops. bad base revision messed this up.

+}
+
+bool ExtensionWebRequestEventRouter::OnBeforeHttpRequest(
+    ProfileId profile_id,
+    ExtensionEventRouterForwarder* event_router,
+    uint64 request_id,
+    net::HttpRequestHeaders* headers,

[willchan no longer on Chromium, 2011/03/17 15:55:54]

Don't you need to pass this variable through to OnBeforeRequestCommon()? Or
somehow make it available to the extension process?

[Matt Perry, 2011/03/22 21:11:43]

Yeah, I'm leaving that as a TODO for now. There's no API for enumerating the
headers, so I'd like to add that first (if net/ owners agree).

+    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())

[willchan no longer on Chromium, 2011/03/17 15:55:54]

Isn't this a bug? Should this be LOG(DFATAL)?

+    return false;
+
+  net::URLRequest* request = iter->second;
+  http_requests_.erase(iter);
+
+  int tab_id = -1;
+  int window_id = -1;
+  ResourceType::Type resource_type = ResourceType::LAST_TYPE;
+  ExtractRequestInfo(request, &tab_id, &window_id, &resource_type);
+
+  std::vector<const EventListener*> listeners =
+      GetMatchingListeners(profile_id, keys::kOnBeforeRequest, request->url(),
+                           tab_id, window_id, resource_type);
+  if (listeners.empty())
+    return false;
+
+  return OnBeforeRequestCommon(profile_id, event_router, request, callback,
+                               tab_id, window_id, resource_type, listeners);
+}
+
+bool ExtensionWebRequestEventRouter::OnBeforeRequestCommon(
+    ProfileId profile_id,
+    ExtensionEventRouterForwarder* event_router,
+    net::URLRequest* request,
+    net::CompletionCallback* callback,
+    int tab_id,
+    int window_id,
+    ResourceType::Type resource_type,
+    const std::vector<const EventListener*>& listeners) {
   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);
 
   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 174 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableFunction(
           &EventHandledOnIOThread,
           profile()->GetRuntimeId(), extension_id(),
           event_name, sub_event_name, request_id, cancel));
 
   return true;
 }