Send user gesture to extensions for page and browser action clicks.

chrome/browser/extensions/browser_event_router.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.
 
 #include "chrome/browser/extensions/browser_event_router.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/extension_action/extension_page_actions_api_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/event_names.h"
-#include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/extensions/window_event_router.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
@@ skipping 137 matching lines @@
   if (service) {
     service->window_event_router()->OnActiveWindowChanged(
         browser ? browser->extension_window_controller() : NULL);
   }
 }
 
 void BrowserEventRouter::TabCreatedAt(WebContents* contents,
                                       int index,
                                       bool active) {
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
-  DispatchEventWithTab(profile, "", events::kOnTabCreated, contents, active);
+  DispatchEventWithTab(profile, "", events::kOnTabCreated, contents, active,
+                       EventRouter::USER_GESTURE_NOT_ENABLED);
 
   RegisterForTabNotifications(contents);
 }
 
 void BrowserEventRouter::TabInsertedAt(TabContents* contents,
                                        int index,
                                        bool active) {
   // If tab is new, send created event.
   int tab_id = ExtensionTabUtil::GetTabId(contents->web_contents());
   if (!GetTabEntry(contents->web_contents())) {
     tab_entries_[tab_id] = TabEntry();
 
     TabCreatedAt(contents->web_contents(), index, active);
     return;
   }
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kNewWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents->web_contents())));
   object_args->Set(tab_keys::kNewPositionKey, Value::CreateIntegerValue(
       index));
   args.Append(object_args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
-  DispatchEvent(contents->profile(), events::kOnTabAttached, json_args);
+  DispatchEvent(contents->profile(), events::kOnTabAttached, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabDetachedAt(TabContents* contents, int index) {
   if (!GetTabEntry(contents->web_contents())) {
     // The tab was removed. Don't send detach event.
     return;
   }
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(
       ExtensionTabUtil::GetTabId(contents->web_contents())));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kOldWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents->web_contents())));
   object_args->Set(tab_keys::kOldPositionKey, Value::CreateIntegerValue(
       index));
   args.Append(object_args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
-  DispatchEvent(contents->profile(), events::kOnTabDetached, json_args);
+  DispatchEvent(contents->profile(), events::kOnTabDetached, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabClosingAt(TabStripModel* tab_strip_model,
                                       TabContents* contents,
                                       int index) {
   int tab_id = ExtensionTabUtil::GetTabId(contents->web_contents());
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->SetBoolean(tab_keys::kWindowClosing,
                           tab_strip_model->closing_all());
   args.Append(object_args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
-  DispatchEvent(contents->profile(), events::kOnTabRemoved, json_args);
+  DispatchEvent(contents->profile(), events::kOnTabRemoved, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
 
   int removed_count = tab_entries_.erase(tab_id);
   DCHECK_GT(removed_count, 0);
 
   UnregisterForTabNotifications(contents->web_contents());
 }
 
 void BrowserEventRouter::ActiveTabChanged(TabContents* old_contents,
                                           TabContents* new_contents,
                                           int index,
@@ skipping 12 matching lines @@
   std::string old_json_args;
   base::JSONWriter::Write(&args, &old_json_args);
 
   // The onActivated event takes one argument: {windowId, tabId}.
   std::string new_json_args;
   args.Remove(0, NULL);
   object_args->Set(tab_keys::kTabIdKey, Value::CreateIntegerValue(tab_id));
   base::JSONWriter::Write(&args, &new_json_args);
 
   Profile* profile = new_contents->profile();
-  DispatchEvent(profile, events::kOnTabSelectionChanged, old_json_args);
-  DispatchEvent(profile, events::kOnTabActiveChanged, old_json_args);
-  DispatchEvent(profile, events::kOnTabActivated, new_json_args);
+  EventRouter::UserGestureState gesture = user_gesture ?
+      EventRouter::USER_GESTURE_ENABLED : EventRouter::USER_GESTURE_NOT_ENABLED;

[Matt Perry, 2012/08/01 11:57:17]

Hmm... yes, technically a user gesture caused this method to be invoked. But
should that user gesture propagate to the extension? The user was interacting
with chrome's UI, not the extension's.

Maybe I'm just misunderstanding how user_gesture should be propagated.

[Greg Billock, 2012/08/01 16:43:43]

I think this is an accurate propagation. That is, the user gesture indicator
tells the JS code "you are running as a direct result of a user interaction". So
if extension JS code is a handler for a browser UI element (context menu entry,
page/browser action click), it should carry the indicator.

On 2012/08/01 11:57:17, Matt Perry wrote:

+  DispatchEvent(profile, events::kOnTabSelectionChanged, old_json_args,
+                gesture);
+  DispatchEvent(profile, events::kOnTabActiveChanged, old_json_args, gesture);
+  DispatchEvent(profile, events::kOnTabActivated, new_json_args, gesture);
 }
 
 void BrowserEventRouter::TabSelectionChanged(
     TabStripModel* tab_strip_model,
     const TabStripSelectionModel& old_model) {
   TabStripSelectionModel::SelectedIndices new_selection =
       tab_strip_model->selection_model().selected_indices();
   ListValue* all = new ListValue();
 
   for (size_t i = 0; i < new_selection.size(); ++i) {
@@ skipping 12 matching lines @@
       ExtensionTabUtil::GetWindowIdOfTabStripModel(tab_strip_model)));
 
   select_info->Set(tab_keys::kTabIdsKey, all);
   args.Append(select_info);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   // The onHighlighted event replaced onHighlightChanged.
   Profile* profile = tab_strip_model->profile();
-  DispatchEvent(profile, events::kOnTabHighlightChanged, json_args);
-  DispatchEvent(profile, events::kOnTabHighlighted, json_args);
+  DispatchEvent(profile, events::kOnTabHighlightChanged, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
+  DispatchEvent(profile, events::kOnTabHighlighted, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabMoved(TabContents* contents,
                                   int from_index,
                                   int to_index) {
   ListValue args;
   args.Append(Value::CreateIntegerValue(
       ExtensionTabUtil::GetTabId(contents->web_contents())));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents->web_contents())));
   object_args->Set(tab_keys::kFromIndexKey, Value::CreateIntegerValue(
       from_index));
   object_args->Set(tab_keys::kToIndexKey, Value::CreateIntegerValue(
       to_index));
   args.Append(object_args);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
-  DispatchEvent(contents->profile(), events::kOnTabMoved, json_args);
+  DispatchEvent(contents->profile(), events::kOnTabMoved, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabUpdated(WebContents* contents, bool did_navigate) {
   TabEntry* entry = GetTabEntry(contents);
   DictionaryValue* changed_properties = NULL;
 
   DCHECK(entry);
 
   if (did_navigate)
     changed_properties = entry->DidNavigate(contents);
   else
     changed_properties = entry->UpdateLoadState(contents);
 
   if (changed_properties)
     DispatchTabUpdatedEvent(contents, changed_properties);
 }
 
-void BrowserEventRouter::DispatchEvent(Profile* profile,
-                                       const char* event_name,
-                                       const std::string& json_args) {
+void BrowserEventRouter::DispatchEvent(
+    Profile* profile,
+    const char* event_name,
+    const std::string& json_args,
+    EventRouter::UserGestureState user_gesture) {
   if (!profile_->IsSameProfile(profile) || !profile->GetExtensionEventRouter())
     return;
 
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
-      event_name, json_args, profile, GURL(), EventFilteringInfo());
+      event_name, json_args, profile, GURL(), user_gesture);
 }
 
 void BrowserEventRouter::DispatchEventToExtension(
     Profile* profile,
     const std::string& extension_id,
     const char* event_name,
-    const std::string& json_args) {
+    const std::string& json_args,
+    EventRouter::UserGestureState user_gesture) {
   if (!profile_->IsSameProfile(profile) || !profile->GetExtensionEventRouter())
     return;
 
   profile->GetExtensionEventRouter()->DispatchEventToExtension(
-      extension_id, event_name, json_args, profile, GURL());
+      extension_id, event_name, json_args, profile, GURL(), user_gesture);
 }
 
 void BrowserEventRouter::DispatchEventsAcrossIncognito(
     Profile* profile,
     const char* event_name,
     const std::string& json_args,
     const std::string& cross_incognito_args) {
   if (!profile_->IsSameProfile(profile) || !profile->GetExtensionEventRouter())
     return;
 
   profile->GetExtensionEventRouter()->DispatchEventsToRenderersAcrossIncognito(
       event_name, json_args, profile, cross_incognito_args, GURL());
 }
 
-void BrowserEventRouter::DispatchEventWithTab(Profile* profile,
-                                              const std::string& extension_id,
-                                              const char* event_name,
-                                              const WebContents* web_contents,
-                                              bool active) {
+void BrowserEventRouter::DispatchEventWithTab(
+    Profile* profile,
+    const std::string& extension_id,
+    const char* event_name,
+    const WebContents* web_contents,
+    bool active,
+    EventRouter::UserGestureState user_gesture) {
   if (!profile_->IsSameProfile(profile))
     return;
 
   ListValue args;
   args.Append(ExtensionTabUtil::CreateTabValueActive(
       web_contents, active));
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
   if (!extension_id.empty()) {
-    DispatchEventToExtension(profile, extension_id, event_name, json_args);
+    DispatchEventToExtension(profile, extension_id, event_name, json_args,
+                             user_gesture);
   } else {
-    DispatchEvent(profile, event_name, json_args);
+    DispatchEvent(profile, event_name, json_args, user_gesture);
   }
 }
 
 void BrowserEventRouter::DispatchSimpleBrowserEvent(
     Profile* profile, const int window_id, const char* event_name) {
   if (!profile_->IsSameProfile(profile))
     return;
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(window_id));
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
-  DispatchEvent(profile, event_name, json_args);
+  DispatchEvent(profile, event_name, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::DispatchTabUpdatedEvent(
     WebContents* contents, DictionaryValue* changed_properties) {
   DCHECK(changed_properties);
   DCHECK(contents);
 
   // The state of the tab (as seen from the extension point of view) has
   // changed.  Send a notification to the extension.
   ListValue args;
 
   // First arg: The id of the tab that changed.
   args.Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents)));
 
   // Second arg: An object containing the changes to the tab state.
   args.Append(changed_properties);
 
   // Third arg: An object containing the state of the tab.
   args.Append(ExtensionTabUtil::CreateTabValue(contents));
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
-  DispatchEvent(profile, events::kOnTabUpdated, json_args);
+  DispatchEvent(profile, events::kOnTabUpdated, json_args,
+                EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 BrowserEventRouter::TabEntry* BrowserEventRouter::GetTabEntry(
     const WebContents* contents) {
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   std::map<int, TabEntry>::iterator i = tab_entries_.find(tab_id);
   if (tab_entries_.end() == i)
     return NULL;
   return &i->second;
 }
@@ skipping 59 matching lines @@
 
   DictionaryValue* data = new DictionaryValue();
   data->Set(tab_keys::kTabIdKey, Value::CreateIntegerValue(tab_id));
   data->Set(tab_keys::kTabUrlKey, Value::CreateStringValue(url));
   data->Set(page_action_keys::kButtonKey, Value::CreateIntegerValue(button));
   args.Append(data);
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
-  DispatchEventToExtension(profile, extension_id, "pageActions", json_args);
+  DispatchEventToExtension(profile, extension_id, "pageActions", json_args,
+                           EventRouter::USER_GESTURE_ENABLED);
 }
 
 void BrowserEventRouter::BrowserActionExecuted(
     const ExtensionAction& browser_action,
     Browser* browser) {
   Profile* profile = browser->profile();
   TabContents* tab_contents = NULL;
   int tab_id = 0;
   if (!ExtensionTabUtil::GetDefaultTab(browser, &tab_contents, &tab_id))
     return;
@@ skipping 31 matching lines @@
                                          const std::string& extension_id,
                                          const std::string& command) {
   ListValue args;
   args.Append(Value::CreateStringValue(command));
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   DispatchEventToExtension(profile,
                            extension_id,
                            "experimental.commands.onCommand",
-                           json_args);
+                           json_args,
+                           EventRouter::USER_GESTURE_ENABLED);
 }
 
 void BrowserEventRouter::ExtensionActionExecuted(
     Profile* profile,
     const ExtensionAction& extension_action,
     TabContents* tab_contents) {
   const char* event_name = NULL;
   switch (extension_action.action_type()) {
     case ExtensionAction::TYPE_BROWSER:
       event_name = "browserAction.onClicked";
       break;
     case ExtensionAction::TYPE_PAGE:
       event_name = "pageAction.onClicked";
       break;
     case ExtensionAction::TYPE_SCRIPT_BADGE:
       event_name = "scriptBadge.onClicked";
       break;
   }
 
   if (event_name) {
     DispatchEventWithTab(profile,
                          extension_action.extension_id(),
                          event_name,
                          tab_contents->web_contents(),
-                         true);
+                         true,
+                         EventRouter::USER_GESTURE_ENABLED);
   }
 }
 
 }  // namespace extensions