Only send events to renderers that are listening to an event....

chrome/renderer/extensions/event_bindings.cc

 // Copyright (c) 2009 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/renderer/extensions/event_bindings.h"
 
 #include "base/basictypes.h"
 #include "base/singleton.h"
+#include "chrome/common/render_messages.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/js_only_v8_extensions.h"
 #include "chrome/renderer/render_thread.h"
 #include "grit/renderer_resources.h"
 
 namespace {
 
+// Keep a local cache of RenderThread so that we can mock it out for unit tests.
+static RenderThreadBase* render_thread = NULL;
+
+static RenderThreadBase* GetRenderThread() {
+  return render_thread ? render_thread : RenderThread::current();
+}
+
 // Keep a list of contexts that have registered themselves with us.  This lets
 // us know where to dispatch events when we receive them.
 typedef std::list< v8::Persistent<v8::Context> > ContextList;
 struct ExtensionData {
   ContextList contexts;
+  std::map<std::string, int> listener_count;
 };
 ContextList& GetRegisteredContexts() {
   return Singleton<ExtensionData>::get()->contexts;
 }
+int EventIncrementListenerCount(const std::string& event_name) {
+  ExtensionData *data = Singleton<ExtensionData>::get();
+  return ++(data->listener_count[event_name]);
+}
+int EventDecrementListenerCount(const std::string& event_name) {
+  ExtensionData *data = Singleton<ExtensionData>::get();
+  return --(data->listener_count[event_name]);
+}
+
 
 const char* kExtensionDeps[] = { JsonJsV8Extension::kName };
 const char* kContextAttachCount = "chromium.attachCount";
 
 class ExtensionImpl : public v8::Extension {
  public:
   ExtensionImpl()
       : v8::Extension(EventBindings::kName,
                       GetStringResource<IDR_EVENT_BINDINGS_JS>(),
                       arraysize(kExtensionDeps), kExtensionDeps) {
   }
   ~ExtensionImpl() {}
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
     if (name->Equals(v8::String::New("AttachEvent"))) {
       return v8::FunctionTemplate::New(AttachEvent);
     } else if (name->Equals(v8::String::New("DetachEvent"))) {
       return v8::FunctionTemplate::New(DetachEvent);
     }
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   // Attach an event name to an object.
-  // TODO(mpcomplete): I'm just using this to register the v8 Context right now.
-  // The idea is to eventually notify the browser about what events are being
-  // listened to, so it can dispatch appropriately.
   static v8::Handle<v8::Value> AttachEvent(const v8::Arguments& args) {
+    DCHECK(args.Length() == 1);
+    // TODO(erikkay) should enforce that event name is a string in the bindings
+    DCHECK(args[0]->IsString() || args[0]->IsUndefined());
+
     v8::Persistent<v8::Context> context =
         v8::Persistent<v8::Context>::New(v8::Context::GetCurrent());
     v8::Local<v8::Object> global = context->Global();
 
     // Remember how many times this context has been attached, so we can
     // register the context on first attach and unregister on last detach.
     v8::Local<v8::Value> attach_count = global->GetHiddenValue(
         v8::String::New(kContextAttachCount));
     int32_t account_count_value =
         (!attach_count.IsEmpty() && attach_count->IsNumber()) ?
         attach_count->Int32Value() : 0;
     if (account_count_value == 0) {
       // First time attaching.
       GetRegisteredContexts().push_back(context);
       context.MakeWeak(NULL, WeakContextCallback);
     }
     global->SetHiddenValue(
         v8::String::New(kContextAttachCount),
         v8::Integer::New(account_count_value + 1));
 
+    if (args[0]->IsString()) {
+      std::string event_name(*v8::String::AsciiValue(args[0]));
+      if (EventIncrementListenerCount(event_name) == 1) {
+        GetRenderThread()->Send(
+            new ViewHostMsg_ExtensionAddListener(event_name));
+      }
+    }
+
     return v8::Undefined();
   }
 
   static v8::Handle<v8::Value> DetachEvent(const v8::Arguments& args) {
+    DCHECK(args.Length() == 1);
+    // TODO(erikkay) should enforce that event name is a string in the bindings
+    DCHECK(args[0]->IsString() || args[0]->IsUndefined());
+
     v8::Local<v8::Context> context = v8::Context::GetCurrent();
     v8::Local<v8::Object> global = context->Global();
     v8::Local<v8::Value> attach_count = global->GetHiddenValue(
         v8::String::New(kContextAttachCount));
     DCHECK(!attach_count.IsEmpty() && attach_count->IsNumber());
     int32_t account_count_value = attach_count->Int32Value();
     DCHECK(account_count_value > 0);
     if (account_count_value == 1) {
       // Clean up after last detach.
       UnregisterContext(context);
     }
     global->SetHiddenValue(
         v8::String::New(kContextAttachCount),
         v8::Integer::New(account_count_value - 1));
 
+    if (args[0]->IsString()) {
+      std::string event_name(*v8::String::AsciiValue(args[0]));
+      if (EventDecrementListenerCount(event_name) == 0) {
+        GetRenderThread()->Send(
+          new ViewHostMsg_ExtensionRemoveListener(event_name));
+      }
+    }
+
     return v8::Undefined();
   }
 
   // Called when a registered context is garbage collected.
   static void UnregisterContext(v8::Handle<void> context) {
     ContextList& contexts = GetRegisteredContexts();
     ContextList::iterator it = std::find(contexts.begin(), contexts.end(),
                                          context);
     if (it == contexts.end()) {
       NOTREACHED();
@@ skipping 12 matching lines @@
 };
 
 }  // namespace
 
 const char* EventBindings::kName = "chrome/EventBindings";
 
 v8::Extension* EventBindings::Get() {
   return new ExtensionImpl();
 }
 
+// static
+void EventBindings::SetRenderThread(RenderThreadBase* thread) {
+  render_thread = thread;
+}
+
 void EventBindings::CallFunction(const std::string& function_name,
                                  int argc, v8::Handle<v8::Value>* argv) {
   for (ContextList::iterator it = GetRegisteredContexts().begin();
        it != GetRegisteredContexts().end(); ++it) {
     DCHECK(!it->IsEmpty());
     v8::Context::Scope context_scope(*it);
     v8::Local<v8::Object> global = (*it)->Global();
 
     v8::Local<v8::Script> script = v8::Script::Compile(
         v8::String::New(function_name.c_str()));
     v8::Local<v8::Value> function_obj = script->Run();
     if (!function_obj->IsFunction())
       continue;
 
     v8::Local<v8::Function> function =
         v8::Local<v8::Function>::Cast(function_obj);
     if (!function.IsEmpty())
       function->Call(v8::Object::New(), argc, argv);
   }
 }