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

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/utf_string_conversions.h"
 #include "base/values.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/profiles/profile.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_message_filter.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #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;
 
 namespace {
 
 // List of all the webRequest events.
 static const char* const kWebRequestEvents[] = {
   keys::kOnBeforeRedirect,
   keys::kOnBeforeRequest,
   keys::kOnBeforeSendHeaders,
@@ skipping 190 matching lines @@
   return a->extension_install_time > b->extension_install_time;
 }
 
 }  // namespace
 
 // 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;
+  std::string extension_name;
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
   base::WeakPtr<IPC::Message::Sender> ipc_sender;
   mutable std::set<uint64> blocked_requests;
 
   // Comparator to work with std::set.
   bool operator<(const EventListener& that) const {
     if (extension_id < that.extension_id)
       return true;
     if (extension_id == that.extension_id &&
         sub_event_name < that.sub_event_name)
       return true;
     return false;
   }
 
   EventListener() : extra_info_spec(0) {}
 };
 
 // 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;
 
   // The number of event handlers that we are awaiting a response from.
   int num_handlers_blocking;
 
   // Pointer to NetLog to report significant changes to the request for
   // debugging.
   const net::BoundNetLog* net_log;
 
   // The callback to call when we get a response from all event handlers.
   net::CompletionCallback* callback;
 
   // If non-empty, this contains the new URL that the request will redirect to.
   // Only valid for OnBeforeRequest.
   GURL* new_url;
 
   // The request headers that will be issued along with this request. Only valid
   // for OnBeforeSendHeaders.
   net::HttpRequestHeaders* request_headers;
 
   // Time the request was paused. Used for logging purposes.
   base::Time blocking_time;
 
   // Changes requested by extensions.
   EventResponseDeltas response_deltas;
 
   BlockedRequest()
-      : event(kInvalidEvent),
+      : request(NULL),
+        event(kInvalidEvent),
         num_handlers_blocking(0),
         net_log(NULL),
         callback(NULL),
         new_url(NULL),
         request_headers(NULL) {}
 };
 
 bool ExtensionWebRequestEventRouter::RequestFilter::InitFromValue(
     const DictionaryValue& value, std::string* error) {
   for (DictionaryValue::key_iterator key = value.begin_keys();
@@ skipping 482 matching lines @@
       dict->Remove(keys::kStatusLineKey, NULL);
 
     base::JSONWriter::Write(args_filtered.get(), false, &json_args);
 
     ExtensionEventRouter::DispatchEvent(
         (*it)->ipc_sender.get(), (*it)->extension_id, (*it)->sub_event_name,
         json_args, GURL());
     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();
 
     return true;
   }
 
   return false;
 }
 
 void ExtensionWebRequestEventRouter::OnEventHandled(
     void* profile,
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& sub_event_name,
     uint64 request_id,
     EventResponse* response) {
   EventListener listener;
   listener.extension_id = extension_id;
   listener.sub_event_name = sub_event_name;
 
   // The listener may have been removed (e.g. due to the process going away)
   // before we got here.
   std::set<EventListener>::iterator found =
       listeners_[profile][event_name].find(listener);
   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,
     int extra_info_spec,
     base::WeakPtr<IPC::Message::Sender> ipc_sender) {
   if (!IsWebRequestEvent(event_name))
     return;
 
   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;
   listener.ipc_sender = ipc_sender;
 
   CHECK_EQ(listeners_[profile][event_name].count(listener), 0u) <<
       "extension=" << extension_id << " event=" << event_name;
   listeners_[profile][event_name].insert(listener);
 }
 
@@ skipping 18 matching lines @@
       listeners_[profile][event_name].find(listener);
   if (found == listeners_[profile][event_name].end())
     return;
 
   CHECK_EQ(listeners_[profile][event_name].count(listener), 1u) <<
       "extension=" << extension_id << " event=" << event_name;
 
   // 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);
 }
 
 void ExtensionWebRequestEventRouter::OnOTRProfileCreated(
     void* original_profile, void* otr_profile) {
   cross_profile_map_[original_profile] = otr_profile;
   cross_profile_map_[otr_profile] = original_profile;
 }
@@ skipping 266 matching lines @@
       conflicting_extensions->push_back((*delta)->extension_id);
       request->net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           make_scoped_refptr(
               new NetLogExtensionIdParameter((*delta)->extension_id)));
     }
   }
 }
 
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
+    void* profile,
+    const std::string& event_name,
     uint64 request_id,
     EventResponse* response) {
   scoped_ptr<EventResponse> response_scoped(response);
 
   // It's possible that this request was deleted, or 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];
@@ skipping 55 matching lines @@
     if (blocked_request.callback) {
       int rv = canceled ? net::ERR_EMPTY_RESPONSE : net::OK;
       net::CompletionCallback* callback = blocked_request.callback;
       // Ensure that request is removed before callback because the callback
       // might trigger the next event.
       blocked_requests_.erase(request_id);
       callback->Run(rv);
     } 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;
+      }
+    }
   }
 }
 
 bool ExtensionWebRequestEventRouter::GetAndSetSignaled(uint64 request_id,
                                                        EventTypes event_type) {
   SignaledRequestMap::iterator iter = signaled_requests_.find(request_id);
   if (iter == signaled_requests_.end()) {
     signaled_requests_[request_id] = event_type;
     return false;
   }
@@ skipping 33 matching lines @@
         ExtensionWebRequestEventRouter::ExtraInfoSpec::InitFromValue(
             *value, &extra_info_spec));
   }
 
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(3, &event_name));
 
   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;
 }
 
 bool WebRequestEventHandled::RunImpl() {
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &event_name));
 
   std::string sub_event_name;
@@ skipping 61 matching lines @@
       }
     }
   }
 
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile(), extension_id(), event_name, sub_event_name, request_id,
       response.release());
 
   return true;
 }