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

chrome/browser/extensions/extension_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/extension_event_router.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_devtools_manager.h"
@@ skipping 49 matching lines @@
     return false;
   }
 };
 
 struct ExtensionEventRouter::ExtensionEvent {
   std::string event_name;
   std::string event_args;
   GURL event_url;
   Profile* restrict_to_profile;
   std::string cross_incognito_args;
+  UserGestureState user_gesture;
 
   ExtensionEvent(const std::string& event_name,
                  const std::string& event_args,
                  const GURL& event_url,
                  Profile* restrict_to_profile,
-                 const std::string& cross_incognito_args)
+                 const std::string& cross_incognito_args,
+                 UserGestureState user_gesture)
     : event_name(event_name),
       event_args(event_args),
       event_url(event_url),
       restrict_to_profile(restrict_to_profile),
-      cross_incognito_args(cross_incognito_args) {}
+      cross_incognito_args(cross_incognito_args),
+      user_gesture(user_gesture) {}
 };
 
 // static
 void ExtensionEventRouter::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,
+                                         UserGestureState user_gesture) {
   ListValue args;
   args.Set(0, Value::CreateStringValue(event_name));
   args.Set(1, Value::CreateStringValue(event_args));
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(MSG_ROUTING_CONTROL,
-      extension_id, kDispatchEvent, args, event_url));
+      extension_id, kDispatchEvent, args, event_url,
+      user_gesture == USER_GESTURE_ENABLED));
 }
 
 ExtensionEventRouter::ExtensionEventRouter(Profile* profile)
     : profile_(profile),
       extension_devtools_manager_(profile->GetExtensionDevToolsManager()) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
@@ skipping 114 matching lines @@
   return false;
 }
 
 void ExtensionEventRouter::DispatchEventToRenderers(
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
     const GURL& event_url) {
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(event_name, event_args, event_url,
-                         restrict_to_profile, ""));
+                         restrict_to_profile, "", USER_GESTURE_UNKNOWN));
   DispatchEventImpl("", event, false);
 }
 
 void ExtensionEventRouter::DispatchEventToExtension(
     const std::string& extension_id,
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
     const GURL& event_url) {
   DCHECK(!extension_id.empty());
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(event_name, event_args, event_url,
-                         restrict_to_profile, ""));
+                         restrict_to_profile, "", USER_GESTURE_UNKNOWN));
   DispatchEventImpl(extension_id, event, false);
 }
 
+void ExtensionEventRouter::DispatchEventToExtension(
+    const std::string& extension_id,
+    const std::string& event_name,
+    const std::string& event_args,
+    Profile* restrict_to_profile,
+    const GURL& event_url,
+    UserGestureState user_gesture) {
+  DCHECK(!extension_id.empty());
+  linked_ptr<ExtensionEvent> event(
+      new ExtensionEvent(event_name, event_args, event_url,
+                         restrict_to_profile, "", user_gesture));
+  DispatchEventImpl(extension_id, event, false);
+}
+
 void ExtensionEventRouter::DispatchEventsToRenderersAcrossIncognito(
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
     const std::string& cross_incognito_args,
     const GURL& event_url) {
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(event_name, event_args, event_url,
-                         restrict_to_profile, cross_incognito_args));
+                         restrict_to_profile, cross_incognito_args,
+                         USER_GESTURE_UNKNOWN));
   DispatchEventImpl("", event, false);
 }
 
 bool ExtensionEventRouter::CanDispatchEventNow(const Extension* extension) {
   DCHECK(extension);
   if (extension->has_background_page() &&
       !extension->background_page_persists()) {
     ExtensionProcessManager* pm = profile_->GetExtensionProcessManager();
     ExtensionHost* background_host =
         pm->GetBackgroundHostForExtension(extension->id());
@@ skipping 57 matching lines @@
     // Is this event from a different profile than the renderer (ie, an
     // incognito tab event sent to a normal process, or vice versa).
     bool cross_incognito = event->restrict_to_profile &&
         listener_profile != event->restrict_to_profile;
     // Send the event with different arguments to extensions that can't
     // cross incognito, if necessary.
     if (cross_incognito && !service->CanCrossIncognito(extension)) {
       if (!event->cross_incognito_args.empty()) {
         DispatchEvent(listener->process, listener->extension_id,
                       event->event_name, event->cross_incognito_args,
-                      event->event_url);
+                      event->event_url, event->user_gesture);
         IncrementInFlightEvents(extension);
       }
       continue;
     }
 
     DispatchEvent(listener->process, listener->extension_id,
-                  event->event_name, event->event_args, event->event_url);
+                  event->event_name, event->event_args,
+                  event->event_url, event->user_gesture);
     IncrementInFlightEvents(extension);
   }
 }
 
 void ExtensionEventRouter::LoadLazyBackgroundPagesForEvent(
     const std::string& extension_id,
     const linked_ptr<ExtensionEvent>& event) {
   ExtensionService* service = profile_->GetExtensionService();
   ExtensionProcessManager* pm = profile_->GetExtensionProcessManager();
 
@@ skipping 150 matching lines @@
           extension->id(), kOnInstalledEvent, "[]", NULL, GURL());
       break;
     }
 
     // TODO(tessamac): if background page crashed/failed clear queue.
     default:
       NOTREACHED();
       return;
   }
 }