Get rid of the ProfileId. It was added for ceee. I reverted the original change, since it led to ...

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 318 matching lines @@
   return Singleton<ExtensionWebRequestEventRouter>::get();
 }
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter() {
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     net::CompletionCallback* callback,
     GURL* new_url) {
   // TODO(jochen): Figure out what to do with events from the system context.
-  if (profile_id == Profile::kInvalidProfileId)
+  if (!profile)
     return net::OK;
 
   if (!HasWebRequestScheme(request->url()))
     return net::OK;
 
   // 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.
   // We need to do this even if no extension subscribes to OnBeforeRequest to
   // guarantee that |http_requests_| is populated if an extension subscribes
   // to OnBeforeSendHeaders or OnRequestSent.
   if (request->url().SchemeIs(chrome::kHttpScheme) ||
       request->url().SchemeIs(chrome::kHttpsScheme)) {
     http_requests_[request->identifier()] = request;
   }
 
   int tab_id = -1;
   int window_id = -1;
   ResourceType::Type resource_type = ResourceType::LAST_TYPE;
   ExtractRequestInfo(request, &tab_id, &window_id, &resource_type);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, extension_info_map,
-                           keys::kOnBeforeRequest, request->url(),
-                           tab_id, window_id, resource_type, &extra_info_spec);
+      GetMatchingListeners(profile, extension_info_map, keys::kOnBeforeRequest,
+                           request->url(), tab_id, window_id, resource_type,
+                           &extra_info_spec);
   if (listeners.empty())
     return net::OK;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRequest))
     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->SetString(keys::kMethodKey, request->method());
   dict->SetInteger(keys::kTabIdKey, tab_id);
   dict->SetString(keys::kTypeKey, ResourceTypeToString(resource_type));
   dict->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
   args.Append(dict);
 
-  if (DispatchEvent(profile_id, request, listeners, args)) {
+  if (DispatchEvent(profile, request, listeners, args)) {
     blocked_requests_[request->identifier()].event = kOnBeforeRequest;
     blocked_requests_[request->identifier()].callback = callback;
     blocked_requests_[request->identifier()].new_url = new_url;
     return net::ERR_IO_PENDING;
   }
   return net::OK;
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     net::CompletionCallback* callback,
     net::HttpRequestHeaders* headers) {
   // TODO(jochen): Figure out what to do with events from the system context.
-  if (profile_id == Profile::kInvalidProfileId)
+  if (!profile)
     return net::OK;
 
   if (!HasWebRequestScheme(request->url()))
     return net::OK;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders))
     return net::OK;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, extension_info_map,
+      GetMatchingListeners(profile, extension_info_map,
                            keys::kOnBeforeSendHeaders, request,
                            &extra_info_spec);
   if (listeners.empty())
     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->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
 
   if (extra_info_spec & ExtraInfoSpec::REQUEST_HEADERS)
     dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(headers));
   // TODO(battre): implement request line.
 
   args.Append(dict);
 
-  if (DispatchEvent(profile_id, request, listeners, args)) {
+  if (DispatchEvent(profile, request, listeners, args)) {
     blocked_requests_[request->identifier()].event = kOnBeforeSendHeaders;
     blocked_requests_[request->identifier()].callback = callback;
     blocked_requests_[request->identifier()].request_headers = headers;
     return net::ERR_IO_PENDING;
   }
   return net::OK;
 }
 
 void ExtensionWebRequestEventRouter::OnRequestSent(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     uint64 request_id,
     const net::HostPortPair& socket_address,
     const net::HttpRequestHeaders& headers) {
-  if (profile_id == Profile::kInvalidProfileId)
+  if (!profile)
     return;
 
   base::Time time(base::Time::Now());
 
   HttpRequestMap::iterator iter = http_requests_.find(request_id);
   if (iter == http_requests_.end())
     return;
 
   net::URLRequest* request = iter->second;
 
   if (!HasWebRequestScheme(request->url()))
     return;
 
   if (GetAndSetSignaled(request->identifier(), kOnRequestSent))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRedirect);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, extension_info_map,
+      GetMatchingListeners(profile, extension_info_map,
                            keys::kOnRequestSent, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kIpKey, socket_address.host());
   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_id, request, listeners, args);
+  DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnBeforeRedirect(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const GURL& new_location) {
-  if (profile_id == Profile::kInvalidProfileId)
+  if (!profile)
     return;
 
   if (!HasWebRequestScheme(request->url()))
     return;
 
   base::Time time(base::Time::Now());
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRedirect))
     return;
 
   ClearSignaled(request->identifier(), kOnBeforeRequest);
   ClearSignaled(request->identifier(), kOnBeforeSendHeaders);
   ClearSignaled(request->identifier(), kOnRequestSent);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, extension_info_map,
+      GetMatchingListeners(profile, extension_info_map,
                            keys::kOnBeforeRedirect, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   int http_status_code = request->GetResponseCode();
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kRedirectUrlKey, new_location.spec());
   dict->SetInteger(keys::kStatusCodeKey, http_status_code);
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   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_id, request, listeners, args);
+  DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnResponseStarted(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
-  if (profile_id == Profile::kInvalidProfileId)
+  if (!profile)
     return;
 
   if (!HasWebRequestScheme(request->url()))
     return;
 
   // OnResponseStarted is even triggered, when the request was cancelled.
   if (request->status().status() != net::URLRequestStatus::SUCCESS)
     return;
 
   base::Time time(base::Time::Now());
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, extension_info_map,
+      GetMatchingListeners(profile, extension_info_map,
                            keys::kOnResponseStarted, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   // UrlRequestFileJobs do not send headers, so we simulate their behavior.
   int response_code = 200;
   if (request->response_headers())
     response_code = request->response_headers()->response_code();
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetInteger(keys::kStatusCodeKey, response_code);
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   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_id, request, listeners, args);
+  DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnCompleted(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
-  if (profile_id == Profile::kInvalidProfileId)
+  if (!profile)
     return;
 
   if (!HasWebRequestScheme(request->url()))
     return;
 
   DCHECK(request->status().status() == net::URLRequestStatus::SUCCESS);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnCompleted));
 
   base::Time time(base::Time::Now());
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, extension_info_map,
+      GetMatchingListeners(profile, extension_info_map,
                            keys::kOnCompleted, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   // UrlRequestFileJobs do not send headers, so we simulate their behavior.
   int response_code = 200;
   if (request->response_headers())
     response_code = request->response_headers()->response_code();
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetInteger(keys::kStatusCodeKey, response_code);
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   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_id, request, listeners, args);
+  DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnErrorOccurred(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request) {
-  if (profile_id == Profile::kInvalidProfileId)
+  if (!profile)
       return;
 
   if (!HasWebRequestScheme(request->url()))
     return;
 
   DCHECK(request->status().status() == net::URLRequestStatus::FAILED);
 
   DCHECK(!GetAndSetSignaled(request->identifier(), kOnErrorOccurred));
 
   base::Time time(base::Time::Now());
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
-      GetMatchingListeners(profile_id, extension_info_map,
+      GetMatchingListeners(profile, extension_info_map,
                            keys::kOnErrorOccurred, request, &extra_info_spec);
   if (listeners.empty())
     return;
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(keys::kRequestIdKey,
                   base::Uint64ToString(request->identifier()));
   dict->SetString(keys::kUrlKey, request->url().spec());
   dict->SetString(keys::kErrorKey,
                   net::ErrorToString(request->status().os_error()));
   dict->SetDouble(keys::kTimeStampKey, time.ToDoubleT() * 1000);
   args.Append(dict);
 
-  DispatchEvent(profile_id, request, listeners, args);
+  DispatchEvent(profile, request, listeners, args);
 }
 
 void ExtensionWebRequestEventRouter::OnURLRequestDestroyed(
-    ProfileId profile_id, net::URLRequest* request) {
+    void* profile, net::URLRequest* request) {
   blocked_requests_.erase(request->identifier());
   signaled_requests_.erase(request->identifier());
   http_requests_.erase(request->identifier());
 }
 
 void ExtensionWebRequestEventRouter::OnHttpTransactionDestroyed(
-    ProfileId profile_id, uint64 request_id) {
+    void* profile, uint64 request_id) {
   if (blocked_requests_.find(request_id) != blocked_requests_.end() &&
       blocked_requests_[request_id].event == kOnBeforeSendHeaders) {
     // Ensure we don't call into the deleted HttpTransaction.
     blocked_requests_[request_id].callback = NULL;
     blocked_requests_[request_id].request_headers = NULL;
   }
 }
 
 bool ExtensionWebRequestEventRouter::DispatchEvent(
-    ProfileId profile_id,
+    void* profile,
     net::URLRequest* request,
     const std::vector<const EventListener*>& listeners,
     const ListValue& args) {
   std::string 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*>::const_iterator it = listeners.begin();
        it != listeners.end(); ++it) {
@@ skipping 26 matching lines @@
         num_handlers_blocking;
     blocked_requests_[request->identifier()].blocking_time = base::Time::Now();
 
     return true;
   }
 
   return false;
 }
 
 void ExtensionWebRequestEventRouter::OnEventHandled(
-    ProfileId profile_id,
+    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_id][event_name].find(listener);
-  if (found != listeners_[profile_id][event_name].end())
+      listeners_[profile][event_name].find(listener);
+  if (found != listeners_[profile][event_name].end())
     found->blocked_requests.erase(request_id);
 
   DecrementBlockCount(request_id, response);
 }
 
 void ExtensionWebRequestEventRouter::AddEventListener(
-    ProfileId profile_id,
+    void* profile,
     const std::string& extension_id,
     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.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_id][event_name].count(listener), 0u) <<
+  CHECK_EQ(listeners_[profile][event_name].count(listener), 0u) <<
       "extension=" << extension_id << " event=" << event_name;
-  listeners_[profile_id][event_name].insert(listener);
+  listeners_[profile][event_name].insert(listener);
 }
 
 void ExtensionWebRequestEventRouter::RemoveEventListener(
-    ProfileId profile_id,
+    void* profile,
     const std::string& extension_id,
     const std::string& sub_event_name) {
   size_t slash_sep = sub_event_name.find('/');
   std::string event_name = sub_event_name.substr(0, slash_sep);
 
   if (!IsWebRequestEvent(event_name))
     return;
 
   EventListener listener;
   listener.extension_id = extension_id;
   listener.sub_event_name = sub_event_name;
 
   // It's possible for AddEventListener to fail asynchronously. In that case,
   // the renderer believes the listener exists, while the browser does not.
   // Ignore a RemoveEventListener in that case.
   std::set<EventListener>::iterator found =
-      listeners_[profile_id][event_name].find(listener);
-  if (found == listeners_[profile_id][event_name].end())
+      listeners_[profile][event_name].find(listener);
+  if (found == listeners_[profile][event_name].end())
     return;
 
-  CHECK_EQ(listeners_[profile_id][event_name].count(listener), 1u) <<
+  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);
   }
 
-  listeners_[profile_id][event_name].erase(listener);
+  listeners_[profile][event_name].erase(listener);
 }
 
 void ExtensionWebRequestEventRouter::OnOTRProfileCreated(
-    ProfileId original_profile_id, ProfileId otr_profile_id) {
-  cross_profile_map_[original_profile_id] = otr_profile_id;
-  cross_profile_map_[otr_profile_id] = original_profile_id;
+    void* original_profile, void* otr_profile) {
+  cross_profile_map_[original_profile] = otr_profile;
+  cross_profile_map_[otr_profile] = original_profile;
 }
 
 void ExtensionWebRequestEventRouter::OnOTRProfileDestroyed(
-    ProfileId original_profile_id, ProfileId otr_profile_id) {
-  cross_profile_map_.erase(otr_profile_id);
-  cross_profile_map_.erase(original_profile_id);
+    void* original_profile, void* otr_profile) {
+  cross_profile_map_.erase(otr_profile);
+  cross_profile_map_.erase(original_profile);
 }
 
 void ExtensionWebRequestEventRouter::GetMatchingListenersImpl(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     bool crosses_incognito,
     const std::string& event_name,
     const GURL& url,
     int tab_id,
     int window_id,
     ResourceType::Type resource_type,
     int* extra_info_spec,
     std::vector<const ExtensionWebRequestEventRouter::EventListener*>*
         matching_listeners) {
-  std::set<EventListener>& listeners = listeners_[profile_id][event_name];
+  std::set<EventListener>& listeners = listeners_[profile][event_name];
   for (std::set<EventListener>::iterator it = listeners.begin();
        it != listeners.end(); ++it) {
     if (!it->ipc_sender.get()) {
       // The IPC sender has been deleted. This listener will be removed soon
       // via a call to RemoveEventListener. For now, just skip it.
       continue;
     }
 
     if (!it->filter.urls.is_empty() && !it->filter.urls.MatchesURL(url))
       continue;
@@ skipping 17 matching lines @@
         continue;
     }
 
     matching_listeners->push_back(&(*it));
     *extra_info_spec |= it->extra_info_spec;
   }
 }
 
 std::vector<const ExtensionWebRequestEventRouter::EventListener*>
 ExtensionWebRequestEventRouter::GetMatchingListeners(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     const std::string& event_name,
     const GURL& url,
     int tab_id,
     int window_id,
     ResourceType::Type resource_type,
     int* extra_info_spec) {
-  // TODO(mpcomplete): handle profile_id == invalid (should collect all
-  // listeners).
+  // TODO(mpcomplete): handle profile == NULL (should collect all listeners).
   *extra_info_spec = 0;
 
   std::vector<const ExtensionWebRequestEventRouter::EventListener*>
       matching_listeners;
 
   GetMatchingListenersImpl(
-      profile_id, extension_info_map, false, event_name, url,
+      profile, extension_info_map, false, event_name, url,
       tab_id, window_id, resource_type, extra_info_spec, &matching_listeners);
-  CrossProfileMap::const_iterator cross_profile_id =
-      cross_profile_map_.find(profile_id);
-  if (cross_profile_id != cross_profile_map_.end()) {
+  CrossProfileMap::const_iterator cross_profile =
+      cross_profile_map_.find(profile);
+  if (cross_profile != cross_profile_map_.end()) {
     GetMatchingListenersImpl(
-        cross_profile_id->second, extension_info_map, true, event_name, url,
+        cross_profile->second, extension_info_map, true, event_name, url,
         tab_id, window_id, resource_type, extra_info_spec, &matching_listeners);
   }
 
   return matching_listeners;
 }
 
 std::vector<const ExtensionWebRequestEventRouter::EventListener*>
 ExtensionWebRequestEventRouter::GetMatchingListeners(
-    ProfileId profile_id,
+    void* profile,
     ExtensionInfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
     int* extra_info_spec) {
   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, extension_info_map, event_name, request->url(),
+      profile, extension_info_map, event_name, request->url(),
       tab_id, window_id, resource_type, extra_info_spec);
 }
 
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
     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 105 matching lines @@
             *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));
 
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
-      profile_id(), extension_id(), event_name, sub_event_name, filter,
+      profile(), extension_id(), 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 56 matching lines @@
             header_value->GetString(keys::kHeaderNameKey, &name));
         EXTENSION_FUNCTION_VALIDATE(
             header_value->GetString(keys::kHeaderValueKey, &value));
 
         response->request_headers->SetHeader(name, value);
       }
     }
   }
 
   ExtensionWebRequestEventRouter::GetInstance()->OnEventHandled(
-      profile_id(), extension_id(), event_name, sub_event_name, request_id,
+      profile(), extension_id(), event_name, sub_event_name, request_id,
       response.release());
 
   return true;
 }