Make sure ports are closed when they're no longer used.

chrome/renderer/extensions/miscellaneous_bindings.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/renderer/extensions/miscellaneous_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 66 matching lines @@
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
     if (name->Equals(v8::String::New("PostMessage"))) {
       return v8::FunctionTemplate::New(PostMessage);
     } else if (name->Equals(v8::String::New("CloseChannel"))) {
       return v8::FunctionTemplate::New(CloseChannel);
     } else if (name->Equals(v8::String::New("PortAddRef"))) {
       return v8::FunctionTemplate::New(PortAddRef);
     } else if (name->Equals(v8::String::New("PortRelease"))) {
       return v8::FunctionTemplate::New(PortRelease);
+    } else if (name->Equals(v8::String::New("BindToGC"))) {
+      return v8::FunctionTemplate::New(BindToGC);
     }
     return ChromeV8Extension::GetNativeFunction(name);
   }
 
   // Sends a message along the given channel.
   static v8::Handle<v8::Value> PostMessage(const v8::Arguments& args) {
     content::RenderView* renderview = GetCurrentRenderView();
     if (!renderview)
       return v8::Undefined();
 
@@ skipping 45 matching lines @@
       int port_id = args[0]->Int32Value();
       if (HasPortData(port_id) && --GetPortData(port_id).ref_count == 0) {
         // Send via the RenderThread because the RenderView might be closing.
         content::RenderThread::Get()->Send(
             new ExtensionHostMsg_CloseChannel(port_id));
         ClearPortData(port_id);
       }
     }
     return v8::Undefined();
   }
+
+  struct GCCallbackArgs {
+    v8::Persistent<v8::Object> object;
+    v8::Persistent<v8::Function> callback;
+  };
+
+  static void GCCallback(v8::Persistent<v8::Value> object, void* parameter) {
+    v8::HandleScope handle_scope;
+    GCCallbackArgs* args = reinterpret_cast<GCCallbackArgs*>(parameter);
+    args->callback->Call(args->callback->CreationContext()->Global(), 0, NULL);
+    args->callback.Dispose();
+    args->object.Dispose();
+    delete args;
+  }
+
+  // Binds a callback to be invoked when the given object is garbage collected.
+  static v8::Handle<v8::Value> BindToGC(const v8::Arguments& args) {
+    if (args.Length() == 2 && args[0]->IsObject() && args[1]->IsFunction()) {
+      GCCallbackArgs* context = new GCCallbackArgs;
+      context->callback = v8::Persistent<v8::Function>::New(
+          v8::Handle<v8::Function>::Cast(args[1]));
+      context->object = v8::Persistent<v8::Object>::New(
+          v8::Handle<v8::Object>::Cast(args[0]));
+      context->object.MakeWeak(context, GCCallback);
+    } else {
+      NOTREACHED();
+    }
+    return v8::Undefined();
+  }
 };
 
 }  // namespace
 
 namespace extensions {
 
 v8::Extension* MiscellaneousBindings::Get(ExtensionDispatcher* dispatcher) {
   static v8::Extension* extension = new ExtensionImpl(dispatcher);
   return extension;
 }
@@ skipping 30 matching lines @@
     arguments.push_back(v8::String::New(message.c_str(), message.size()));
     arguments.push_back(port_id_handle);
     CHECK((*it)->CallChromeHiddenMethod("Port.dispatchOnMessage",
                                         arguments.size(),
                                         &arguments[0],
                                         NULL));
   }
 }
 
 }  // namespace extension