Remove void* in WebRequestEventRouterDelegate

chrome/browser/extensions/api/web_request/web_request_api.cc

Index: chrome/browser/extensions/api/web_request/web_request_api.cc
diff --git a/chrome/browser/extensions/api/web_request/web_request_api.cc b/chrome/browser/extensions/api/web_request/web_request_api.cc
index e80989cbb0ae8bd3186fde475fca179082e4ca77..259d6b05946aaae20d3074bae3cfe93479ac39d9 100644
--- a/chrome/browser/extensions/api/web_request/web_request_api.cc
+++ b/chrome/browser/extensions/api/web_request/web_request_api.cc
@@ -25,6 +25,7 @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/user_metrics.h"
+#include "extensions/browser/api/activity_log/web_request_constants.h"
 #include "extensions/browser/api/declarative_webrequest/request_stage.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_rules_registry.h"
@@ -78,6 +79,7 @@ using extensions::Warning;
 using extensions::WarningService;
 using extensions::WarningSet;
 
+namespace activitylog = activity_log_web_request_constants;
 namespace helpers = extension_web_request_api_helpers;
 namespace utils = extension_web_request_api_utils;
 namespace keys = extension_web_request_api_constants;
@@ -1616,8 +1618,148 @@ helpers::EventResponseDelta* CalculateDelta(
   return NULL;
 }
 
+base::Value* SerializeResponseHeaders(const helpers::ResponseHeaders& headers) {
+  scoped_ptr<base::ListValue> serialized_headers(new base::ListValue());
+  for (helpers::ResponseHeaders::const_iterator i = headers.begin();
+       i != headers.end(); ++i) {
+    serialized_headers->Append(
+        helpers::CreateHeaderDictionary(i->first, i->second));
+  }
+  return serialized_headers.release();
+}
+
+// Convert a RequestCookieModifications/ResponseCookieModifications object to a
+// base::ListValue which summarizes the changes made.  This is templated since
+// the two types (request/response) are different but contain essentially the
+// same fields.
+template<typename CookieType>
+base::ListValue* SummarizeCookieModifications(
+    const std::vector<linked_ptr<CookieType> >& modifications) {
+  scoped_ptr<base::ListValue> cookie_modifications(new base::ListValue());
+  for (typename std::vector<linked_ptr<CookieType> >::const_iterator i =
+           modifications.begin();
+       i != modifications.end(); ++i) {
+    scoped_ptr<base::DictionaryValue> summary(new base::DictionaryValue());
+    const CookieType& mod = *i->get();
+    switch (mod.type) {
+      case helpers::ADD:
+        summary->SetString(activitylog::kCookieModificationTypeKey,
+                           activitylog::kCookieModificationAdd);
+        break;
+      case helpers::EDIT:
+        summary->SetString(activitylog::kCookieModificationTypeKey,
+                           activitylog::kCookieModificationEdit);
+        break;
+      case helpers::REMOVE:
+        summary->SetString(activitylog::kCookieModificationTypeKey,
+                           activitylog::kCookieModificationRemove);
+        break;
+    }
+    if (mod.filter) {
+      if (mod.filter->name)
+        summary->SetString(activitylog::kCookieFilterNameKey,
+                           *mod.modification->name);
+      if (mod.filter->domain)
+        summary->SetString(activitylog::kCookieFilterDomainKey,
+                           *mod.modification->name);
+    }
+    if (mod.modification) {
+      if (mod.modification->name)
+        summary->SetString(activitylog::kCookieModDomainKey,
+                           *mod.modification->name);
+      if (mod.modification->domain)
+        summary->SetString(activitylog::kCookieModDomainKey,
+                           *mod.modification->name);
+    }
+    cookie_modifications->Append(summary.release());
+  }
+  return cookie_modifications.release();
+}
+
+// Converts an EventResponseDelta object to a dictionary value suitable for the
+// activity log.
+scoped_ptr<base::DictionaryValue> SummarizeResponseDelta(
+    const std::string& event_name,
+    const helpers::EventResponseDelta& delta) {
+  scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue());
+  if (delta.cancel) {
+    details->SetBoolean(activitylog::kCancelKey, true);
+  }
+  if (!delta.new_url.is_empty()) {
+      details->SetString(activitylog::kNewUrlKey, delta.new_url.spec());
+  }
+
+  scoped_ptr<base::ListValue> modified_headers(new base::ListValue());
+  net::HttpRequestHeaders::Iterator iter(delta.modified_request_headers);
+  while (iter.GetNext()) {
+    modified_headers->Append(
+        helpers::CreateHeaderDictionary(iter.name(), iter.value()));
+  }
+  if (!modified_headers->empty()) {
+    details->Set(activitylog::kModifiedRequestHeadersKey,
+                 modified_headers.release());
+  }
+
+  scoped_ptr<base::ListValue> deleted_headers(new base::ListValue());
+  deleted_headers->AppendStrings(delta.deleted_request_headers);
+  if (!deleted_headers->empty()) {
+    details->Set(activitylog::kDeletedRequestHeadersKey,
+                 deleted_headers.release());
+  }
+
+  if (!delta.added_response_headers.empty()) {
+    details->Set(activitylog::kAddedRequestHeadersKey,
+                 SerializeResponseHeaders(delta.added_response_headers));
+  }
+  if (!delta.deleted_response_headers.empty()) {
+    details->Set(activitylog::kDeletedResponseHeadersKey,
+                 SerializeResponseHeaders(delta.deleted_response_headers));
+  }
+  if (delta.auth_credentials) {
+    details->SetString(activitylog::kAuthCredentialsKey,
+                       base::UTF16ToUTF8(
+                           delta.auth_credentials->username()) + ":*");
+  }
+
+  if (!delta.response_cookie_modifications.empty()) {
+    details->Set(
+        activitylog::kResponseCookieModificationsKey,
+        SummarizeCookieModifications(delta.response_cookie_modifications));
+  }
+
+  return details.Pass();
+}
+
 }  // namespace
 
+void ExtensionWebRequestEventRouter::LogExtensionActivity(
+    void* browser_context_id,
+    bool is_incognito,
+    const std::string& extension_id,
+    const GURL& url,
+    const std::string& api_call,
+    scoped_ptr<base::DictionaryValue> details) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&ExtensionWebRequestEventRouter::LogExtensionActivity,
+                    base::Unretained(this),
+                    browser_context_id,
+                    is_incognito,
+                    extension_id,
+                    url,
+                    api_call,
+                    base::Passed(&details)));
+  } else {
+    if (web_request_event_router_delegate_) {
+      web_request_event_router_delegate_->LogExtensionActivity(
+          reinterpret_cast<content::BrowserContext*>(browser_context_id),
+          is_incognito, extension_id, url, api_call, details.Pass());
+    }
+  }
+}
+
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
     void* browser_context,
     const std::string& extension_id,
@@ -1639,15 +1781,12 @@ void ExtensionWebRequestEventRouter::DecrementBlockCount(
     helpers::EventResponseDelta* delta =
         CalculateDelta(&blocked_request, response);
 
-    if (web_request_event_router_delegate_) {
-      web_request_event_router_delegate_->LogExtensionActivity(
-          browser_context,
-          blocked_request.is_incognito,
-          extension_id,
-          blocked_request.request->url(),
-          event_name,
-          *delta);
-    }
+    LogExtensionActivity(browser_context,
+                         blocked_request.is_incognito,
+                         extension_id,
+                         blocked_request.request->url(),
+                         event_name,
+                         SummarizeResponseDelta(event_name, *delta));
 
     blocked_request.response_deltas.push_back(
         linked_ptr<helpers::EventResponseDelta>(delta));