diff options
Diffstat (limited to 'chromium/webkit/renderer/cpp_bound_class.cc')
| -rw-r--r-- | chromium/webkit/renderer/cpp_bound_class.cc | 329 |
1 files changed, 0 insertions, 329 deletions
diff --git a/chromium/webkit/renderer/cpp_bound_class.cc b/chromium/webkit/renderer/cpp_bound_class.cc deleted file mode 100644 index 6a652f48505..00000000000 --- a/chromium/webkit/renderer/cpp_bound_class.cc +++ /dev/null @@ -1,329 +0,0 @@ -// 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. - -// 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 "webkit/renderer/cpp_bound_class.h" - -#include "base/compiler_specific.h" -#include "base/logging.h" -#include "base/stl_util.h" -#include "base/strings/utf_string_conversions.h" -#include "third_party/WebKit/public/web/WebBindings.h" -#include "third_party/WebKit/public/web/WebFrame.h" -#include "third_party/WebKit/public/platform/WebString.h" - -using blink::WebBindings; -using blink::WebFrame; - -namespace webkit_glue { - -namespace { - -class CppVariantPropertyCallback : public CppBoundClass::PropertyCallback { - public: - CppVariantPropertyCallback(CppVariant* value) : value_(value) { } - - virtual bool GetValue(CppVariant* value) OVERRIDE { - value->Set(*value_); - return true; - } - virtual bool SetValue(const CppVariant& value) OVERRIDE { - value_->Set(value); - return true; - } - - private: - CppVariant* value_; -}; - -class GetterPropertyCallback : public CppBoundClass::PropertyCallback { -public: - GetterPropertyCallback(const CppBoundClass::GetterCallback& callback) - : callback_(callback) { } - - virtual bool GetValue(CppVariant* value) OVERRIDE { - callback_.Run(value); - return true; - } - - virtual bool SetValue(const CppVariant& value) OVERRIDE { - return false; - } - -private: - 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; - - // - // All following objects and functions are static, and just used to interface - // with NPObject/NPClass. - // - - // An NPClass associates static functions of CppNPObject with the - // function pointers used by the JS runtime. - static NPClass np_class_; - - // Allocate a new NPObject with the specified class. - static NPObject* allocate(NPP npp, NPClass* aClass); - - // Free an object. - static void deallocate(NPObject* obj); - - // Returns true if the C++ class associated with this NPObject exposes the - // given property. Called by the JS runtime. - static bool hasProperty(NPObject *obj, NPIdentifier ident); - - // Returns true if the C++ class associated with this NPObject exposes the - // given method. Called by the JS runtime. - static bool hasMethod(NPObject *obj, NPIdentifier ident); - - // If the given method is exposed by the C++ class associated with this - // NPObject, invokes it with the given args and returns a result. Otherwise, - // returns "undefined" (in the JavaScript sense). Called by the JS runtime. - static bool invoke(NPObject *obj, NPIdentifier ident, - const NPVariant *args, uint32_t arg_count, - NPVariant *result); - - // If the given property is exposed by the C++ class associated with this - // NPObject, returns its value. Otherwise, returns "undefined" (in the - // JavaScript sense). Called by the JS runtime. - static bool getProperty(NPObject *obj, NPIdentifier ident, - NPVariant *result); - - // If the given property is exposed by the C++ class associated with this - // NPObject, sets its value. Otherwise, does nothing. Called by the JS - // runtime. - static bool setProperty(NPObject *obj, NPIdentifier ident, - const NPVariant *value); -}; - -// Build CppNPObject's static function pointers into an NPClass, for use -// in constructing NPObjects for the C++ classes. -NPClass CppNPObject::np_class_ = { - NP_CLASS_STRUCT_VERSION, - CppNPObject::allocate, - CppNPObject::deallocate, - /* NPInvalidateFunctionPtr */ NULL, - CppNPObject::hasMethod, - CppNPObject::invoke, - /* NPInvokeDefaultFunctionPtr */ NULL, - CppNPObject::hasProperty, - CppNPObject::getProperty, - CppNPObject::setProperty, - /* NPRemovePropertyFunctionPtr */ NULL -}; - -/* static */ NPObject* CppNPObject::allocate(NPP npp, NPClass* aClass) { - CppNPObject* obj = new CppNPObject; - // obj->parent will be initialized by the NPObject code calling this. - obj->bound_class = NULL; - return &obj->parent; -} - -/* static */ void CppNPObject::deallocate(NPObject* np_obj) { - CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj); - delete obj; -} - -/* static */ bool CppNPObject::hasMethod(NPObject* np_obj, - NPIdentifier ident) { - CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj); - return obj->bound_class->HasMethod(ident); -} - -/* static */ bool CppNPObject::hasProperty(NPObject* np_obj, - NPIdentifier ident) { - CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj); - return obj->bound_class->HasProperty(ident); -} - -/* static */ bool CppNPObject::invoke(NPObject* np_obj, NPIdentifier ident, - const NPVariant* args, uint32_t arg_count, - NPVariant* result) { - CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj); - return obj->bound_class->Invoke(ident, args, arg_count, result); -} - -/* static */ bool CppNPObject::getProperty(NPObject* np_obj, - NPIdentifier ident, - NPVariant* result) { - CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj); - return obj->bound_class->GetProperty(ident, result); -} - -/* static */ bool CppNPObject::setProperty(NPObject* np_obj, - NPIdentifier ident, - const NPVariant* value) { - CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj); - return obj->bound_class->SetProperty(ident, value); -} - -CppBoundClass::CppBoundClass() : bound_to_frame_(false), npp_(new NPP_t) { - WebBindings::registerObjectOwner(npp_.get()); -} - -CppBoundClass::~CppBoundClass() { - STLDeleteValues(&properties_); - - // TODO(wez): Remove once crrev.com/14019005 lands. - if (bound_to_frame_) - WebBindings::unregisterObject(NPVARIANT_TO_OBJECT(self_variant_)); - - WebBindings::unregisterObjectOwner(npp_.get()); -} - -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, - size_t arg_count, - NPVariant* result) { - MethodList::const_iterator method = methods_.find(ident); - Callback callback; - if (method == methods_.end()) { - if (!fallback_callback_.is_null()) { - callback = fallback_callback_; - } else { - VOID_TO_NPVARIANT(*result); - return false; - } - } else { - 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); - - 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; - } - - CppVariant cpp_value; - if (!callback->second->GetValue(&cpp_value)) - return false; - cpp_value.CopyToNPVariant(result); - return true; -} - -bool CppBoundClass::SetProperty(NPIdentifier ident, - 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, - const Callback& callback) { - NPIdentifier ident = WebBindings::getStringIdentifier(name.c_str()); - if (callback.is_null()) { - methods_.erase(ident); - return; - } - - methods_[ident] = callback; -} - -void CppBoundClass::BindGetterCallback(const std::string& name, - 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); -} - -void CppBoundClass::BindProperty(const std::string& name, - PropertyCallback* callback) { - NPIdentifier ident = WebBindings::getStringIdentifier(name.c_str()); - PropertyList::iterator old_callback = properties_.find(ident); - if (old_callback != properties_.end()) { - delete old_callback->second; - if (callback == NULL) { - properties_.erase(old_callback); - return; - } - } - - properties_[ident] = callback; -} - -bool CppBoundClass::IsMethodRegistered(const std::string& name) const { - NPIdentifier ident = WebBindings::getStringIdentifier(name.c_str()); - MethodList::const_iterator callback = methods_.find(ident); - return (callback != methods_.end()); -} - -CppVariant* CppBoundClass::GetAsCppVariant() { - if (!self_variant_.isObject()) { - // Create an NPObject using our static NPClass. The first argument has type - // NPP, but is only used to track object ownership, so passing this is fine. - NPObject* np_obj = WebBindings::createObject( - npp_.get(), &CppNPObject::np_class_); - CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj); - obj->bound_class = this; - self_variant_.Set(np_obj); - WebBindings::releaseObject(np_obj); // CppVariant takes the reference. - } - DCHECK(self_variant_.isObject()); - return &self_variant_; -} - -void CppBoundClass::BindToJavascript(WebFrame* frame, - const std::string& classname) { - // BindToWindowObject will take its own reference to the NPObject, and clean - // up after itself. It will also (indirectly) register the object with V8, - // against an owner pointer we supply, so we must register that as an owner, - // and unregister when we teardown. - frame->bindToWindowObject(ASCIIToUTF16(classname), - NPVARIANT_TO_OBJECT(*GetAsCppVariant())); - bound_to_frame_ = true; -} - -} // namespace webkit_glue |