webRequest.onAuthRequired listeners can provide authentication credentials.

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"
@@ skipping 285 matching lines @@
   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;
 
+  // If non-empty, this contains the auth credentials that may be filled in.
+  // Only valid for OnAuthRequired.
+  net::AuthCredentials* auth_credentials;
+
   // Time the request was paused. Used for logging purposes.
   base::Time blocking_time;
 
   // Changes requested by extensions.
   EventResponseDeltas response_deltas;
 
   BlockedRequest()
       : request(NULL),
         event(kInvalidEvent),
         num_handlers_blocking(0),
         net_log(NULL),
         callback(NULL),
         new_url(NULL),
-        request_headers(NULL) {}
+        request_headers(NULL),
+        auth_credentials(NULL) {}
 };
 
 bool ExtensionWebRequestEventRouter::RequestFilter::InitFromValue(
     const DictionaryValue& value, std::string* error) {
   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;
@@ skipping 248 matching lines @@
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS)
     dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(headers));
   // TODO(battre): support "request line".
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
-void ExtensionWebRequestEventRouter::OnAuthRequired(
+int ExtensionWebRequestEventRouter::OnAuthRequired(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
-    const net::AuthChallengeInfo& auth_info) {
+    const net::AuthChallengeInfo& auth_info,
+    net::CompletionCallback* callback,
+    net::AuthCredentials* credentials) {
+  // No profile means that this is for authentication challenges in the
+  // system context. Skip in that case.
   if (!profile)
-    return;
+    return net::OK;
 
   base::Time time(base::Time::Now());
 
   if (!HasWebRequestScheme(request->url()))
-    return;
+    return net::OK;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnAuthRequired, request, &extra_info_spec);
   if (listeners.empty())
-    return;
+    return net::OK;
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetBoolean(keys::kIsProxyKey, auth_info.is_proxy);
   if (!auth_info.scheme.empty())
     dict->SetString(keys::kSchemeKey, auth_info.scheme);
   if (!auth_info.realm.empty())
     dict->SetString(keys::kRealmKey, auth_info.realm);
   DictionaryValue* challenger = new DictionaryValue();
   challenger->SetString(keys::kHostKey, auth_info.challenger.host());
   challenger->SetInteger(keys::kPortKey, auth_info.challenger.port());
   dict->Set(keys::kChallengerKey, challenger);
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
-  if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS) {
+  if (extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS) {
     dict->Set(keys::kResponseHeadersKey,
               GetResponseHeadersList(request->response_headers()));
   }
   if (extra_info_spec & ExtraInfoSpec::STATUS_LINE)
     dict->Set(keys::kStatusLineKey, GetStatusLine(request->response_headers()));
   args.Append(dict);
 
-  DispatchEvent(profile, request, listeners, args);
+  if (DispatchEvent(profile, request, listeners, args)) {
+    blocked_requests_[request->identifier()].event = kOnAuthRequired;
+    blocked_requests_[request->identifier()].callback = callback;
+    blocked_requests_[request->identifier()].auth_credentials = credentials;
+    return net::ERR_IO_PENDING;
+  }
+  return net::OK;
 }
 
 void ExtensionWebRequestEventRouter::OnBeforeRedirect(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const GURL& new_location) {
   if (!profile)
     return;
 
@@ skipping 475 matching lines @@
       net::HttpRequestHeaders::Iterator i(*new_headers);
       while (i.GetNext()) {
         std::string value;
         if (!old_headers->GetHeader(i.name(), &value) || i.value() != value) {
           result->modified_request_headers.SetHeader(i.name(), i.value());
         }
       }
     }
   }
 
+  if (blocked_request->event == kOnAuthRequired)
+    result->auth_credentials.swap(response->auth_credentials);
+
   return result;
 }
 
 void ExtensionWebRequestEventRouter::MergeOnBeforeRequestResponses(
     BlockedRequest* request,
     std::list<std::string>* conflicting_extensions) const {
   EventResponseDeltas::iterator delta;
   EventResponseDeltas& deltas = request->response_deltas;
 
   bool redirected = false;
@@ skipping 111 matching lines @@
     } else {
       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::MergeOnAuthRequiredResponses(
+    BlockedRequest* request,
+    std::list<std::string>* conflicting_extensions) const {
+  CHECK(request);
+  CHECK(request->auth_credentials);
+  bool credentials_set = false;
+
+  const EventResponseDeltas& deltas = request->response_deltas;
+  for (EventResponseDeltas::const_iterator it = deltas.begin();
+       it != deltas.end();
+       ++it) {
+    if (!(*it)->auth_credentials.get())
+      continue;
+    if (credentials_set) {
+      conflicting_extensions->push_back((*it)->extension_id);
+    } else {
+      *request->auth_credentials = *(*it)->auth_credentials;
+      credentials_set = true;
+    }
+  }
+}
+
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
     void* profile,
     const std::string& extension_id,
     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.
@@ skipping 35 matching lines @@
     deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
     std::list<std::string> conflicting_extensions;
 
     if (blocked_request.event == kOnBeforeRequest) {
       CHECK(blocked_request.callback);
       MergeOnBeforeRequestResponses(&blocked_request, &conflicting_extensions);
     } else if (blocked_request.event == kOnBeforeSendHeaders) {
       CHECK(blocked_request.callback);
       MergeOnBeforeSendHeadersResponses(&blocked_request,
                                         &conflicting_extensions);
+    } else if (blocked_request.event == kOnAuthRequired) {
+      CHECK(blocked_request.callback);
+      MergeOnAuthRequiredResponses(&blocked_request, &conflicting_extensions);
     } else {
       NOTREACHED();
     }
     std::list<std::string>::iterator conflict_iter;
     for (conflict_iter = conflicting_extensions.begin();
          conflict_iter != conflicting_extensions.end();
          ++conflict_iter) {
       // TODO(mpcomplete): Do some fancy notification in the UI.
       LOG(ERROR) << "Extension " << *conflict_iter << " was ignored in "
                     "webRequest API because of conflicting request "
@@ skipping 160 matching lines @@
         EXTENSION_FUNCTION_VALIDATE(
             request_headers_value->GetDictionary(i, &header_value));
         EXTENSION_FUNCTION_VALIDATE(
             header_value->GetString(keys::kHeaderNameKey, &name));
         EXTENSION_FUNCTION_VALIDATE(
             header_value->GetString(keys::kHeaderValueKey, &value));
 
         response->request_headers->SetHeader(name, value);
       }
     }
+
+    if (value->HasKey(keys::kAuthCredentialsKey)) {
+      DictionaryValue* credentials_value = NULL;
+      EXTENSION_FUNCTION_VALIDATE(value->GetDictionary(
+          keys::kAuthCredentialsKey,
+          &credentials_value));
+      response->auth_credentials.reset(new net::AuthCredentials());
+      EXTENSION_FUNCTION_VALIDATE(
+          credentials_value->GetString(keys::kUsernameKey,
+                                       &response->auth_credentials->username));
+      EXTENSION_FUNCTION_VALIDATE(
+          credentials_value->GetString(keys::kPasswordKey,
+                                       &response->auth_credentials->password));
+      response->auth_credentials->is_valid = true;
+    }
   }
 
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
       profile(), extension_id(), event_name, sub_event_name, request_id,
       response.release());
 
   return true;
 }