base::Bind() conversion for webkit.

webkit/glue/cpp_bound_class.cc

 // Copyright (c) 2006-2008 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.
 
 // This file contains definitions for CppBoundClass
 
 // Here's the control flow of a JS method getting forwarded to a class.
 // - Something calls our NPObject with a function like "Invoke".
 // - CppNPObject's static invoke() function forwards it to its attached
 //   CppBoundClass's Invoke() method.
 // - CppBoundClass has then overridden Invoke() to look up the function
 //   name in its internal map of methods, and then calls the appropriate
 //   method.
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "webkit/glue/cpp_bound_class.h"
 
 using WebKit::WebBindings;
 using WebKit::WebFrame;
 
 namespace {
@@ skipping 10 matching lines @@
     value_->Set(value);
     return true;
   }
 
  private:
   CppVariant* value_;
 };
 
 class GetterPropertyCallback : public CppBoundClass::PropertyCallback {
 public:
-  GetterPropertyCallback(CppBoundClass::GetterCallback* callback)
+  GetterPropertyCallback(const CppBoundClass::GetterCallback& callback)
       : callback_(callback) { }
 
   virtual bool GetValue(CppVariant* value) {
-    callback_->Run(value);
+    callback_.Run(value);
     return true;
   }
 
   virtual bool SetValue(const CppVariant& value) {
     return false;
   }
 
 private:
-  scoped_ptr<CppBoundClass::GetterCallback> callback_;
+  CppBoundClass::GetterCallback callback_;
 };
 
 }
 
 // Our special NPObject type.  We extend an NPObject with a pointer to a
 // CppBoundClass, which is just a C++ interface that we forward all NPObject
 // callbacks to.
 struct CppNPObject {
   NPObject parent;  // This must be the first field in the struct.
   CppBoundClass* bound_class;
@@ skipping 100 matching lines @@
                                            const NPVariant* value) {
   CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj);
   return obj->bound_class->SetProperty(ident, value);
 }
 
 CppBoundClass::CppBoundClass()
     : bound_to_frame_(false) {
 }
 
 CppBoundClass::~CppBoundClass() {
-  for (MethodList::iterator i = methods_.begin(); i != methods_.end(); ++i)
-    delete i->second;
-
-  for (PropertyList::iterator i = properties_.begin(); i != properties_.end();
-      ++i) {
-    delete i->second;
-  }
+  STLDeleteValues(&properties_);
 
   // Unregister ourselves if we were bound to a frame.
   if (bound_to_frame_)
     WebBindings::unregisterObject(NPVARIANT_TO_OBJECT(self_variant_));
 }
 
 bool CppBoundClass::HasMethod(NPIdentifier ident) const {
   return (methods_.find(ident) != methods_.end());
 }
 
 bool CppBoundClass::HasProperty(NPIdentifier ident) const {
   return (properties_.find(ident) != properties_.end());
 }
 
 bool CppBoundClass::Invoke(NPIdentifier ident,
                               const NPVariant* args,

[awong, 2011/11/21 21:46:56]

Fix indenting?

[dcheng, 2011/11/21 22:04:16]

Done.

                               size_t arg_count,
                               NPVariant* result) {
   MethodList::const_iterator method = methods_.find(ident);
-  Callback* callback;
+  Callback callback;
   if (method == methods_.end()) {
-    if (fallback_callback_.get()) {
-      callback = fallback_callback_.get();
+    if (!fallback_callback_.is_null()) {
+      callback = fallback_callback_;
     } else {
       VOID_TO_NPVARIANT(*result);
       return false;
     }
   } else {
-    callback = (*method).second;
+    callback = method->second;
   }
 
   // Build a CppArgumentList argument vector from the NPVariants coming in.
   CppArgumentList cpp_args(arg_count);
   for (size_t i = 0; i < arg_count; i++)
     cpp_args[i].Set(args[i]);
 
   CppVariant cpp_result;
-  callback->Run(cpp_args, &cpp_result);
+  callback.Run(cpp_args, &cpp_result);
 
   cpp_result.CopyToNPVariant(result);
   return true;
 }
 
 bool CppBoundClass::GetProperty(NPIdentifier ident, NPVariant* result) const {
   PropertyList::const_iterator callback = properties_.find(ident);
   if (callback == properties_.end()) {
     VOID_TO_NPVARIANT(*result);
     return false;
@@ skipping 10 matching lines @@
                                 const NPVariant* value) {
   PropertyList::iterator callback = properties_.find(ident);
   if (callback == properties_.end())
     return false;
 
   CppVariant cpp_value;
   cpp_value.Set(*value);
   return (*callback).second->SetValue(cpp_value);
 }
 
-void CppBoundClass::BindCallback(const std::string& name, Callback* callback) {
+void CppBoundClass::BindCallback(const std::string& name,
+                                 const Callback& callback) {
   NPIdentifier ident = WebBindings::getStringIdentifier(name.c_str());
   MethodList::iterator old_callback = methods_.find(ident);
-  if (old_callback != methods_.end()) {
-    delete old_callback->second;
-    if (callback == NULL) {
-      methods_.erase(old_callback);
-      return;
-    }
+  if (old_callback != methods_.end() && callback.is_null()) {

[csilv, 2011/11/21 21:26:31]

If the callback is null, there's no reason to call methods_.find, so I would
move that check before line 254.

[dcheng, 2011/11/21 22:04:16]

Done.

+    methods_.erase(old_callback);
+    return;
   }
 
   methods_[ident] = callback;
 }
 
 void CppBoundClass::BindGetterCallback(const std::string& name,
-                                       GetterCallback* callback) {
-  PropertyCallback* property_callback = callback == NULL ?
+                                       const GetterCallback& callback) {
+  PropertyCallback* property_callback = callback.is_null() ?
       NULL : new GetterPropertyCallback(callback);
 
   BindProperty(name, property_callback);
 }
 
 void CppBoundClass::BindProperty(const std::string& name, CppVariant* prop) {
   PropertyCallback* property_callback = prop == NULL ?
       NULL : new CppVariantPropertyCallback(prop);
 
   BindProperty(name, property_callback);
@@ skipping 42 matching lines @@
   JSC::JSLock lock(false);
 #endif
 
   // BindToWindowObject will take its own reference to the NPObject, and clean
   // up after itself.  It will also (indirectly) register the object with V8,
   // so we must remember this so we can unregister it when we're destroyed.
   frame->bindToWindowObject(ASCIIToUTF16(classname),
                             NPVARIANT_TO_OBJECT(*GetAsCppVariant()));
   bound_to_frame_ = true;
 }