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 50 matching lines @@
   }
 };
 
 struct ExtensionEventRouter::ExtensionEvent {
   std::string extension_id;
   std::string event_name;
   std::string event_args;
   GURL event_url;
   Profile* restrict_to_profile;
   std::string cross_incognito_args;
+  bool user_caused;
 
   ExtensionEvent(const std::string& extension_id,
                  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,
+                 bool user_caused)
     : extension_id(extension_id),
       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_caused(user_caused) {}
 };
 
 // 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,
+                                         bool user_caused) {
   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_caused));
 }
 
 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 66 matching lines @@
     if (listener->extension_id == extension_id)
       return true;
   }
   return false;
 }
 
 void ExtensionEventRouter::DispatchEventToRenderers(
     const std::string& event_name,
     const std::string& event_args,
     Profile* restrict_to_profile,
-    const GURL& event_url) {
+    const GURL& event_url,
+    bool user_caused) {
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent("", event_name, event_args, event_url,
-                         restrict_to_profile, ""));
+                         restrict_to_profile, "", user_caused));
   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) {
+    const GURL& event_url,
+    bool user_caused) {
   DCHECK(!extension_id.empty());
   linked_ptr<ExtensionEvent> event(
       new ExtensionEvent(extension_id, event_name, event_args, event_url,
-                         restrict_to_profile, ""));
+                         restrict_to_profile, "", user_caused));
   DispatchEventImpl(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) {
+    const GURL& event_url,
+    bool user_caused) {
   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_caused));
   DispatchEventImpl(event, false);
 }
 
 bool ExtensionEventRouter::CanDispatchEventNow(
     const std::string& extension_id) {
   if (extension_id.empty())
     // TODO(mpcomplete): We need to test this per-extension, rather than
     // globally.
     return true;
 
@@ skipping 66 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_caused);
         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_caused);
     IncrementInFlightEvents(extension);
   }
 }
 
 void ExtensionEventRouter::IncrementInFlightEvents(const Extension* extension) {
   if (!extension->background_page_persists())
     in_flight_events_[extension->id()]++;
 }
 
 void ExtensionEventRouter::OnExtensionEventAck(
@@ skipping 70 matching lines @@
       ExtensionHost* eh = content::Details<ExtensionHost>(details).ptr();
       DispatchPendingEvents(eh->extension_id());
       break;
     }
     // TODO(tessamac): if background page crashed/failed clear queue.
     default:
       NOTREACHED();
       return;
   }
 }