summaryrefslogtreecommitdiffstats
path: root/webkit/activex_shim/npn_scripting.cc
diff options
context:
space:
mode:
authorinitial.commit <initial.commit@0039d316-1c4b-4281-b951-d872f2087c98>2008-07-27 00:20:51 +0000
committerinitial.commit <initial.commit@0039d316-1c4b-4281-b951-d872f2087c98>2008-07-27 00:20:51 +0000
commitf5b16fed647e941aa66933178da85db2860d639b (patch)
treef00e9856c04aad3b558a140955e7674add33f051 /webkit/activex_shim/npn_scripting.cc
parent920c091ac3ee15079194c82ae8a7a18215f3f23c (diff)
downloadchromium_src-f5b16fed647e941aa66933178da85db2860d639b.zip
chromium_src-f5b16fed647e941aa66933178da85db2860d639b.tar.gz
chromium_src-f5b16fed647e941aa66933178da85db2860d639b.tar.bz2
Add webkit to the repository.
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@18 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'webkit/activex_shim/npn_scripting.cc')
-rw-r--r--webkit/activex_shim/npn_scripting.cc295
1 files changed, 295 insertions, 0 deletions
diff --git a/webkit/activex_shim/npn_scripting.cc b/webkit/activex_shim/npn_scripting.cc
new file mode 100644
index 0000000..aaf3960
--- /dev/null
+++ b/webkit/activex_shim/npn_scripting.cc
@@ -0,0 +1,295 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "webkit/activex_shim/npn_scripting.h"
+
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "webkit/activex_shim/npp_impl.h"
+
+namespace activex_shim {
+
+NPNScriptableObject::NPNScriptableObject() : npp_(NULL), object_(NULL) {
+}
+
+NPNScriptableObject::NPNScriptableObject(NPP npp, NPObject* object)
+ : npp_(npp),
+ object_(object) {
+}
+
+NPNScriptableObject::NPNScriptableObject(NPNScriptableObject& object)
+ : npp_(object.npp_),
+ object_(object.object_) {
+ if (object_)
+ g_browser->retainobject(object_);
+}
+
+NPNScriptableObject::~NPNScriptableObject() {
+ Release();
+}
+
+NPNScriptableObject& NPNScriptableObject::operator=(
+ NPNScriptableObject& object) {
+ if (this == &object)
+ return *this;
+ if (object_)
+ g_browser->releaseobject(object_);
+ npp_ = object.npp_;
+ object_ = object.object_;
+ if (object_)
+ g_browser->retainobject(object_);
+ return *this;
+}
+
+void NPNScriptableObject::Init(NPP npp, NPObject* object) {
+ Release();
+ npp_ = npp;
+ object_ = object;
+}
+
+void NPNScriptableObject::Release() {
+ if (object_) {
+ g_browser->releaseobject(object_);
+ object_ = NULL;
+ }
+ npp_ = NULL;
+}
+
+bool NPNScriptableObject::HasProperty(const std::string& name) {
+ if (!IsValid())
+ return false;
+ NPIdentifier id = g_browser->getstringidentifier(name.c_str());
+ bool res = g_browser->hasproperty(npp_, object_, id);
+ // How do we release id since it's coming from the browser? the answer is
+ // we never release them. See implementation of NPN_GetStringIdentifier
+ // in npruntime.cpp.
+ return res;
+}
+
+bool NPNScriptableObject::GetProperty(const std::string& name, NPVariant* ret) {
+ if (!IsValid())
+ return false;
+ NPIdentifier id = g_browser->getstringidentifier(name.c_str());
+ return g_browser->getproperty(npp_, object_, id, ret);
+}
+
+bool NPNScriptableObject::SetProperty(const std::string& name,
+ const NPVariant& val) {
+ if (!IsValid())
+ return false;
+ NPIdentifier id = g_browser->getstringidentifier(name.c_str());
+ return g_browser->setproperty(npp_, object_, id, &val);
+}
+
+NPNScriptableObject NPNScriptableObject::GetObjectProperty(
+ const std::string& name,
+ bool* succeeded) {
+ NPNScriptableObject res;
+ if (succeeded)
+ *succeeded = false;
+ NPVariant var;
+ if (!GetProperty(name, &var))
+ return res;
+ if (var.type == NPVariantType_Object) {
+ res.Init(npp_, var.value.objectValue);
+ // From now, the object should have reference count as 1. We shall not
+ // release the variant cause it will release the object.
+ if (succeeded)
+ *succeeded = true;
+ } else {
+ g_browser->releasevariantvalue(&var);
+ }
+ return res;
+}
+
+std::wstring NPNScriptableObject::GetStringProperty(const std::string& name,
+ bool* succeeded) {
+ std::wstring res;
+ if (succeeded)
+ *succeeded = false;
+ NPVariant var;
+ if (!GetProperty(name, &var))
+ return res;
+ if (var.type == NPVariantType_String) {
+ std::string tmp(var.value.stringValue.UTF8Characters,
+ var.value.stringValue.UTF8Length);
+ res = UTF8ToWide(tmp.c_str());
+ if (succeeded)
+ *succeeded = true;
+ }
+ // We've made a copy of the string. Thus we should release the variant in
+ // any case.
+ g_browser->releasevariantvalue(&var);
+ return res;
+}
+
+bool NPNScriptableObject::SetStringProperty(const std::string& name,
+ const std::wstring& val) {
+ NPVariantWrap var;
+ var.SetString(val);
+ return SetProperty(name, var);
+}
+
+bool NPNScriptableObject::Invoke(const std::string& name,
+ const char* format, ...) {
+ if (!IsValid())
+ return false;
+ NPIdentifier id = g_browser->getstringidentifier(name.c_str());
+ std::vector<NPVariantWrap> args;
+ va_list argptr;
+ va_start(argptr, format);
+ for (const char* p = format; *p; ++p) {
+ char c = *p;
+ DCHECK(c == '%' && *(p + 1) != 0);
+ if (c != '%' || *(p + 1) == 0)
+ continue;
+ ++p;
+ c = *p;
+ NPVariantWrap var;
+ switch(c) {
+ case 's': {
+ // String
+ wchar_t *s = va_arg(argptr, wchar_t*);
+ var.SetString(s);
+ break;
+ }
+ case 'd': {
+ // String
+ int n = va_arg(argptr, int);
+ var.SetInt(n);
+ break;
+ }
+ default: {
+ DCHECK(false);
+ break;
+ }
+ }
+ args.push_back(var);
+ }
+ NPVariant ret;
+ ret.type = NPVariantType_Void;
+ bool res = false;
+ if (args.size())
+ res = g_browser->invoke(npp_, object_, id, &args[0],
+ static_cast<unsigned int>(args.size()), &ret);
+ else
+ res = g_browser->invoke(npp_, object_, id, NULL, 0, &ret);
+
+ g_browser->releasevariantvalue(&ret);
+ return res;
+}
+
+NPVariantWrap::NPVariantWrap() {
+ type = NPVariantType_Void;
+}
+
+NPVariantWrap::NPVariantWrap(const NPVariantWrap& v) {
+ type = NPVariantType_Void;
+ Copy(v);
+}
+
+NPVariantWrap::~NPVariantWrap() {
+ Release();
+}
+
+NPVariantWrap& NPVariantWrap::operator=(const NPVariantWrap& v) {
+ if (this != &v)
+ Copy(v);
+ return *this;
+}
+
+void NPVariantWrap::Copy(const NPVariant& v) {
+ if (this == &v)
+ return;
+ Release();
+ switch(v.type) {
+ case NPVariantType_Void:
+ break;
+ case NPVariantType_Null:
+ break;
+ case NPVariantType_Bool:
+ value.boolValue = v.value.boolValue;
+ break;
+ case NPVariantType_Int32:
+ value.intValue = v.value.intValue;
+ break;
+ case NPVariantType_Double:
+ value.doubleValue = v.value.doubleValue;
+ break;
+ case NPVariantType_String:
+ SetUTF8String(v.value.stringValue.UTF8Characters,
+ v.value.stringValue.UTF8Length);
+ break;
+ case NPVariantType_Object:
+ g_browser->retainobject(v.value.objectValue);
+ value.objectValue = v.value.objectValue;
+ break;
+ default:
+ DCHECK(false);
+ break;
+ }
+ type = v.type;
+}
+
+void NPVariantWrap::Release() {
+ if (type == NPVariantType_String) {
+ delete[] value.stringValue.UTF8Characters;
+ } else if (type == NPVariantType_Object) {
+ g_browser->releaseobject(value.objectValue);
+ }
+ type = NPVariantType_Void;
+}
+
+void NPVariantWrap::SetBool(bool val) {
+ Release();
+ value.boolValue = val;
+ type = NPVariantType_Bool;
+}
+
+void NPVariantWrap::SetInt(int val) {
+ Release();
+ value.intValue = val;
+ type = NPVariantType_Int32;
+}
+
+void NPVariantWrap::SetUTF8String(const NPUTF8* p, unsigned int size) {
+ Release();
+ value.stringValue.UTF8Characters = new char[size + 1];
+ memcpy(const_cast<NPUTF8*>(value.stringValue.UTF8Characters),
+ p, size + 1);
+ value.stringValue.UTF8Length = size;
+ type = NPVariantType_String;
+}
+
+void NPVariantWrap::SetString(const std::wstring& val) {
+ std::string s = WideToUTF8(val);
+ SetUTF8String(s.c_str(), static_cast<unsigned int>(s.size()));
+}
+
+} // namespace activex_shim