Filtered events.

chrome/browser/extensions/api/web_navigation/web_navigation_api.cc

 // Copyright (c) 2012 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.
 
 // Implements the Chrome Extensions WebNavigation API.
 
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_constants.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/retargeting_details.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/extensions/event_filtering_info.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/net_errors.h"
 
 using content::BrowserContext;
@@ skipping 31 matching lines @@
 }
 
 // Returns |time| as milliseconds since the epoch.
 double MilliSecondsFromTime(const base::Time& time) {
   return 1000 * time.ToDoubleT();
 }
 
 // Dispatches events to the extension message service.
 void DispatchEvent(BrowserContext* browser_context,
                    const char* event_name,
-                   const std::string& json_args) {
+                   const ListValue& args,
+                   const GURL& url) {
+  std::string json_args;
+  base::JSONWriter::Write(&args, &json_args);
+
+  extensions::EventFilteringInfo info;
+  info.SetURL(url);
+
   Profile* profile = Profile::FromBrowserContext(browser_context);
   if (profile && profile->GetExtensionEventRouter()) {
     profile->GetExtensionEventRouter()->DispatchEventToRenderers(
-        event_name, json_args, profile, GURL());
+        event_name, json_args, profile, GURL(), info);
   }
 }
 
 // Constructs and dispatches an onBeforeNavigate event.
 void DispatchOnBeforeNavigate(WebContents* web_contents,
                               int64 frame_id,
                               bool is_main_frame,
                               const GURL& validated_url) {
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger(keys::kTabIdKey, ExtensionTabUtil::GetTabId(web_contents));
   dict->SetString(keys::kUrlKey, validated_url.spec());
   dict->SetInteger(keys::kFrameIdKey, GetFrameId(is_main_frame, frame_id));
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args.Append(dict);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
   DispatchEvent(web_contents->GetBrowserContext(),
                 keys::kOnBeforeNavigate,
-                json_args);
+                args,
+                validated_url);
 }
 
 // Constructs and dispatches an onCommitted or onReferenceFragmentUpdated
 // event.
 void DispatchOnCommitted(const char* event_name,
                          WebContents* web_contents,
                          int64 frame_id,
                          bool is_main_frame,
                          const GURL& url,
                          content::PageTransition transition_type) {
@@ skipping 11 matching lines @@
   if (transition_type & content::PAGE_TRANSITION_SERVER_REDIRECT)
     qualifiers->Append(Value::CreateStringValue("server_redirect"));
   if (transition_type & content::PAGE_TRANSITION_FORWARD_BACK)
     qualifiers->Append(Value::CreateStringValue("forward_back"));
   if (transition_type & content::PAGE_TRANSITION_FROM_ADDRESS_BAR)
     qualifiers->Append(Value::CreateStringValue("from_address_bar"));
   dict->Set(keys::kTransitionQualifiersKey, qualifiers);
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args.Append(dict);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
-  DispatchEvent(web_contents->GetBrowserContext(), event_name, json_args);
+  DispatchEvent(web_contents->GetBrowserContext(), event_name, args, url);
 }
 
 // Constructs and dispatches an onDOMContentLoaded event.
 void DispatchOnDOMContentLoaded(WebContents* web_contents,
                                 const GURL& url,
                                 bool is_main_frame,
                                 int64 frame_id) {
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger(keys::kTabIdKey,
                    ExtensionTabUtil::GetTabId(web_contents));
   dict->SetString(keys::kUrlKey, url.spec());
   dict->SetInteger(keys::kFrameIdKey, GetFrameId(is_main_frame, frame_id));
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args.Append(dict);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
   DispatchEvent(web_contents->GetBrowserContext(),
                 keys::kOnDOMContentLoaded,
-                json_args);
+                args,
+                url);

[battre, 2012/06/14 20:05:11]

nit: different formatting here, in line 137, 175 and 206

[koz (OOO until 15th September), 2012/06/15 00:07:15]

Done.

 }
 
 // Constructs and dispatches an onCompleted event.
 void DispatchOnCompleted(WebContents* web_contents,
                          const GURL& url,
                          bool is_main_frame,
                          int64 frame_id) {
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger(keys::kTabIdKey,
                    ExtensionTabUtil::GetTabId(web_contents));
   dict->SetString(keys::kUrlKey, url.spec());
   dict->SetInteger(keys::kFrameIdKey, GetFrameId(is_main_frame, frame_id));
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args.Append(dict);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
   DispatchEvent(web_contents->GetBrowserContext(),
-                keys::kOnCompleted, json_args);
+                keys::kOnCompleted, args, url);
 }
 
 // Constructs and dispatches an onCreatedNavigationTarget event.
 void DispatchOnCreatedNavigationTarget(
     WebContents* web_contents,
     BrowserContext* browser_context,
     int64 source_frame_id,
     bool source_frame_is_main_frame,
     WebContents* target_web_contents,
     const GURL& target_url) {
   // Check that the tab is already inserted into a tab strip model. This code
   // path is exercised by ExtensionApiTest.WebNavigationRequestOpenTab.
   DCHECK(ExtensionTabUtil::GetTabById(
       ExtensionTabUtil::GetTabId(target_web_contents),
       Profile::FromBrowserContext(target_web_contents->GetBrowserContext()),
       false, NULL, NULL, NULL, NULL));
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger(keys::kSourceTabIdKey,
                    ExtensionTabUtil::GetTabId(web_contents));
   dict->SetInteger(keys::kSourceFrameIdKey,
       GetFrameId(source_frame_is_main_frame, source_frame_id));
   dict->SetString(keys::kUrlKey, target_url.possibly_invalid_spec());
   dict->SetInteger(keys::kTabIdKey,
                    ExtensionTabUtil::GetTabId(target_web_contents));
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args.Append(dict);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
   DispatchEvent(
-      browser_context, keys::kOnCreatedNavigationTarget, json_args);
+      browser_context, keys::kOnCreatedNavigationTarget, args, target_url);
 }
 
 // Constructs and dispatches an onErrorOccurred event.
 void DispatchOnErrorOccurred(WebContents* web_contents,
                              const GURL& url,
                              int64 frame_id,
                              bool is_main_frame,
                              int error_code) {
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger(keys::kTabIdKey, ExtensionTabUtil::GetTabId(web_contents));
   dict->SetString(keys::kUrlKey, url.spec());
   dict->SetInteger(keys::kFrameIdKey, GetFrameId(is_main_frame, frame_id));
   dict->SetString(keys::kErrorKey, net::ErrorToString(error_code));
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args.Append(dict);
 
-  std::string json_args;
-  base::JSONWriter::Write(&args, &json_args);
   DispatchEvent(web_contents->GetBrowserContext(),
                 keys::kOnErrorOccurred,
-                json_args);
+                args,
+                url);
 }
 
 }  // namespace
 
 
 // FrameNavigationState -------------------------------------------------------
 
 // static
 bool FrameNavigationState::allow_extension_scheme_ = false;
 
@@ skipping 564 matching lines @@
     frameDict->SetBoolean(
         keys::kErrorOccurredKey,
         navigation_state.GetErrorOccurredInFrame(*frame));
     resultList->Append(frameDict);
   }
   result_.reset(resultList);
   return true;
 }
 
 }  // namespace extensions