Add a status message "Waiting for extension Foo..." when there's a request

chrome/browser/extensions/extension_webrequest_api.cc

Index: chrome/browser/extensions/extension_webrequest_api.cc
diff --git a/chrome/browser/extensions/extension_webrequest_api.cc b/chrome/browser/extensions/extension_webrequest_api.cc
index f619f612db911e92a89966e5e70506def7638b9e..50c69ee8e5184480bd2ac1ed9c19accd77012109 100644
--- a/chrome/browser/extensions/extension_webrequest_api.cc
+++ b/chrome/browser/extensions/extension_webrequest_api.cc
@@ -9,6 +9,7 @@
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_info_map.h"
@@ -31,6 +32,8 @@
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "googleurl/src/gurl.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace keys = extension_webrequest_api_constants;
 
@@ -241,6 +244,7 @@ bool InDecreasingExtensionInstallationTimeOrder(
 // added.
 struct ExtensionWebRequestEventRouter::EventListener {
   std::string extension_id;
+  std::string extension_name;
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
@@ -263,6 +267,9 @@ struct ExtensionWebRequestEventRouter::EventListener {
 // Contains info about requests that are blocked waiting for a response from
 // an extension.
 struct ExtensionWebRequestEventRouter::BlockedRequest {
+  // The request that is being blocked.
+  net::URLRequest* request;
+
   // The event that we're currently blocked on.
   EventTypes event;
 
@@ -291,7 +298,8 @@ struct ExtensionWebRequestEventRouter::BlockedRequest {
   EventResponseDeltas response_deltas;
 
   BlockedRequest()
-      : event(kInvalidEvent),
+      : request(NULL),
+        event(kInvalidEvent),
         num_handlers_blocking(0),
         net_log(NULL),
         callback(NULL),
@@ -794,12 +802,17 @@ bool ExtensionWebRequestEventRouter::DispatchEvent(
     if ((*it)->extra_info_spec & ExtraInfoSpec::BLOCKING) {
       (*it)->blocked_requests.insert(request->identifier());
       ++num_handlers_blocking;
+
+      request->SetLoadStateParam(
+          l10n_util::GetStringFUTF8(IDS_LOAD_STATE_PARAMETER_EXTENSION,
+                                    UTF8ToUTF16((*it)->extension_name)));
     }
   }
 
   if (num_handlers_blocking > 0) {
     CHECK(blocked_requests_.find(request->identifier()) ==
           blocked_requests_.end());
+    blocked_requests_[request->identifier()].request = request;
     blocked_requests_[request->identifier()].num_handlers_blocking =
         num_handlers_blocking;
     blocked_requests_[request->identifier()].blocking_time = base::Time::Now();
@@ -828,12 +841,13 @@ void ExtensionWebRequestEventRouter::OnEventHandled(
   if (found != listeners_[profile][event_name].end())
     found->blocked_requests.erase(request_id);
 
-  DecrementBlockCount(request_id, response);
+  DecrementBlockCount(profile, event_name, request_id, response);
 }
 
 void ExtensionWebRequestEventRouter::AddEventListener(
     void* profile,
     const std::string& extension_id,
+    const std::string& extension_name,
     const std::string& event_name,
     const std::string& sub_event_name,
     const RequestFilter& filter,
@@ -844,6 +858,7 @@ void ExtensionWebRequestEventRouter::AddEventListener(
 
   EventListener listener;
   listener.extension_id = extension_id;
+  listener.extension_name = extension_name;
   listener.sub_event_name = sub_event_name;
   listener.filter = filter;
   listener.extra_info_spec = extra_info_spec;
@@ -882,7 +897,7 @@ void ExtensionWebRequestEventRouter::RemoveEventListener(
   // Unblock any request that this event listener may have been blocking.
   for (std::set<uint64>::iterator it = found->blocked_requests.begin();
        it != found->blocked_requests.end(); ++it) {
-    DecrementBlockCount(*it, NULL);
+    DecrementBlockCount(profile, event_name, *it, NULL);
   }
 
   listeners_[profile][event_name].erase(listener);
@@ -1169,6 +1184,8 @@ void ExtensionWebRequestEventRouter::MergeOnBeforeSendHeadersResponses(
 }
 
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
+    void* profile,
+    const std::string& event_name,
     uint64 request_id,
     EventResponse* response) {
   scoped_ptr<EventResponse> response_scoped(response);
@@ -1244,6 +1261,20 @@ void ExtensionWebRequestEventRouter::DecrementBlockCount(
     } else {
       blocked_requests_.erase(request_id);
     }
+  } else {
+    // Update the URLRequest to indicate it is now blocked on a different
+    // extension.
+    std::set<EventListener>& listeners = listeners_[profile][event_name];
+
+    for (std::set<EventListener>::iterator it = listeners.begin();
+         it != listeners.end(); ++it) {
+      if (it->blocked_requests.count(request_id)) {
+        blocked_request.request->SetLoadStateParam(
+            l10n_util::GetStringFUTF8(IDS_LOAD_STATE_PARAMETER_EXTENSION,
+                                      UTF8ToUTF16(it->extension_name)));
+        break;
+      }
+    }
   }
 }
 
@@ -1297,8 +1328,13 @@ bool WebRequestAddEventListener::RunImpl() {
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(4, &sub_event_name));
 
+  const Extension* extension =
+      extension_info_map()->extensions().GetByID(extension_id());
+  std::string extension_name = extension ? extension->name() : extension_id();
+
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
-      profile(), extension_id(), event_name, sub_event_name, filter,
+      profile(), extension_id(), extension_name,
+      event_name, sub_event_name, filter,
       extra_info_spec, ipc_sender_weak());
 
   return true;