Update extension events, routing, and delivery to use user gesture.

chrome/browser/extensions/extension_event_router.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 10 matching lines @@
 class Extension;
 class ExtensionDevToolsManager;
 class Profile;
 
 namespace content {
 class RenderProcessHost;
 }
 
 class ExtensionEventRouter : public content::NotificationObserver {
  public:
+  // These constants convey the state of our knowledge of whether we're in
+  // a user-caused gesture as part of DispatchEvent.
+  enum UserGesture {

[Aaron Boodman, 2012/02/29 01:20:37]

Naming suggestion: UserGestureState?

[Greg Billock, 2012/02/29 17:58:08]

Done.

+    kUnknownUserGesture = 0,

[Aaron Boodman, 2012/02/29 01:20:37]

according to the style guide (http://www.chromium.org/developers/coding-style),
this should be:

USER_GESTURE_UNKNOWN,
USER_GESTURE_ENABLED,
USER_GESTURE_NOT_ENABLED

or something...

[Greg Billock, 2012/02/29 17:58:08]

I'd read this: "Though the style guide says to use kConstantNaming for enums
now, we still use MACRO_STYLE naming for enums for consistency with existing
code."

And that made me think that the style guide wanted me to use kEnumValue style,
except where existing code differed (i.e. adding a value to an existing list).

Reading it again, I am not sure what it means!

On 2012/02/29 01:20:37, Aaron Boodman wrote:

+    kIsUserGesture = 1,
+    kIsNotUserGesture = 2,
+  };
+
   // Sends an event via ipc_sender to the given extension. Can be called on
   // any thread.
   static void DispatchEvent(IPC::Message::Sender* ipc_sender,
                             const std::string& extension_id,
                             const std::string& event_name,
                             const std::string& event_args,
-                            const GURL& event_url);
+                            const GURL& event_url,
+                            UserGesture user_gesture);
 
   explicit ExtensionEventRouter(Profile* profile);
   virtual ~ExtensionEventRouter();
 
   // Add or remove the process/extension pair as a listener for |event_name|.
   // Note that multiple extensions can share a process due to process
   // collapsing. Also, a single extension can have 2 processes if it is a split
   // mode extension.
   void AddEventListener(const std::string& event_name,
                         content::RenderProcessHost* process,
@@ skipping 31 matching lines @@
       const GURL& event_url);
 
   // Same as above, except only send the event to the given extension.
   virtual void DispatchEventToExtension(
       const std::string& extension_id,
       const std::string& event_name,
       const std::string& event_args,
       Profile* restrict_to_profile,
       const GURL& event_url);
 
+  // Dispatch an event to particular extension. Also include an
+  // explicit user gesture indicator.
+  virtual void DispatchEventToExtension(
+      const std::string& extension_id,
+      const std::string& event_name,
+      const std::string& event_args,
+      Profile* restrict_to_profile,
+      const GURL& event_url,
+      UserGesture user_gesture);
+
   // Send different versions of an event to extensions in different profiles.
   // This is used in the case of sending one event to extensions that have
   // incognito access, and another event to extensions that don't (here),
   // in order to avoid sending 2 events to "spanning" extensions.
   // If |cross_incognito_profile| is non-NULL and different from
   // restrict_to_profile, send the event with cross_incognito_args to the
   // extensions in that profile that can't cross incognito.
   void DispatchEventsToRenderersAcrossIncognito(
       const std::string& event_name,
       const std::string& event_args,
@@ skipping 79 matching lines @@
 
   // Track of the number of dispatched events that have not yet sent an
   // ACK from the renderer.
   void IncrementInFlightEvents(const Extension* extension);
   std::map<std::string, int> in_flight_events_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionEventRouter);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_EVENT_ROUTER_H_