Make webkit\glue\cpp_*.cc not depend on "config.h"

TEST=none
BUG=none

Review URL: http://codereview.chromium.org/159558

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@21927 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 30 insertions, 49 deletions

diff --git a/webkit/glue/cpp_binding_example.cc b/webkit/glue/cpp_binding_example.cc
index e89bac0..b71ffd3 100644
--- a/webkit/glue/cpp_binding_example.cc
+++ b/webkit/glue/cpp_binding_example.cc
@@ -5,8 +5,6 @@
 // This file contains the definition for CppBindingExample, a usage example
 // that is not actually used anywhere.  See cpp_binding_example.h.
 
-#include "config.h"
-
 #include "cpp_binding_example.h"
 
 CppBindingExample::CppBindingExample() {
diff --git a/webkit/glue/cpp_bound_class.cc b/webkit/glue/cpp_bound_class.cc
index 151f070..ef0a72d6 100644
--- a/webkit/glue/cpp_bound_class.cc
+++ b/webkit/glue/cpp_bound_class.cc
@@ -12,25 +12,13 @@
 //   name in its internal map of methods, and then calls the appropriate
 //   method.
 
-#include "config.h"
-
 #include "base/compiler_specific.h"
 #include "base/logging.h"
-
+#include "webkit/api/public/WebBindings.h"
 #include "webkit/glue/cpp_bound_class.h"
 #include "webkit/glue/webframe.h"
 
-// This is required for the KJS build due to an artifact of the
-// npruntime_priv.h file from JavaScriptCore/bindings.
-MSVC_PUSH_DISABLE_WARNING(4067)
-#include "npruntime_priv.h"
-MSVC_POP_WARNING()
-
-#if USE(JSC)
-#pragma warning(push, 0)
-#include <runtime/JSLock.h>
-#pragma warning(pop)
-#endif
+using WebKit::WebBindings;
 
 // 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
@@ -148,10 +136,8 @@ CppBoundClass::~CppBoundClass() {
     delete i->second;
 
   // Unregister ourselves if we were bound to a frame.
-#if USE(V8)
   if (bound_to_frame_)
-    _NPN_UnregisterObject(NPVARIANT_TO_OBJECT(self_variant_));
-#endif
+    WebBindings::unregisterObject(NPVARIANT_TO_OBJECT(self_variant_));
 }
 
 bool CppBoundClass::HasMethod(NPIdentifier ident) const {
@@ -215,7 +201,7 @@ bool CppBoundClass::SetProperty(NPIdentifier ident,
 
 void CppBoundClass::BindCallback(std::string name, Callback* callback) {
   // NPUTF8 is a typedef for char, so this cast is safe.
-  NPIdentifier ident = NPN_GetStringIdentifier((const NPUTF8*)name.c_str());
+  NPIdentifier ident = WebBindings::getStringIdentifier((const NPUTF8*)name.c_str());
   MethodList::iterator old_callback = methods_.find(ident);
   if (old_callback != methods_.end())
     delete old_callback->second;
@@ -224,13 +210,13 @@ void CppBoundClass::BindCallback(std::string name, Callback* callback) {
 
 void CppBoundClass::BindProperty(std::string name, CppVariant* prop) {
   // NPUTF8 is a typedef for char, so this cast is safe.
-  NPIdentifier ident = NPN_GetStringIdentifier((const NPUTF8*)name.c_str());
+  NPIdentifier ident = WebBindings::getStringIdentifier((const NPUTF8*)name.c_str());
   properties_[ident] = prop;
 }
 
 bool CppBoundClass::IsMethodRegistered(std::string name) const {
   // NPUTF8 is a typedef for char, so this cast is safe.
-  NPIdentifier ident = NPN_GetStringIdentifier((const NPUTF8*)name.c_str());
+  NPIdentifier ident = WebBindings::getStringIdentifier((const NPUTF8*)name.c_str());
   MethodList::const_iterator callback = methods_.find(ident);
   return (callback != methods_.end());
 }
@@ -240,11 +226,11 @@ CppVariant* CppBoundClass::GetAsCppVariant() {
     // Create an NPObject using our static NPClass.  The first argument (a
     // plugin's instance handle) is passed through to the allocate function
     // directly, and we don't use it, so it's ok to be 0.
-    NPObject* np_obj = NPN_CreateObject(0, &CppNPObject::np_class_);
+    NPObject* np_obj = WebBindings::createObject(0, &CppNPObject::np_class_);
     CppNPObject* obj = reinterpret_cast<CppNPObject*>(np_obj);
     obj->bound_class = this;
     self_variant_.Set(np_obj);
-    NPN_ReleaseObject(np_obj);  // CppVariant takes the reference.
+    WebBindings::releaseObject(np_obj);  // CppVariant takes the reference.
   }
   DCHECK(self_variant_.isObject());
   return &self_variant_;
@@ -252,7 +238,8 @@ CppVariant* CppBoundClass::GetAsCppVariant() {
 
 void CppBoundClass::BindToJavascript(WebFrame* frame,
                                      const std::wstring& classname) {
-#if USE(JSC)
+#if WEBKIT_USING_JSC
+#error "This is not going to work anymore...but it's not clear what the solution is...or if it's still necessary."
   JSC::JSLock lock(false);
 #endif
 
diff --git a/webkit/glue/cpp_variant.cc b/webkit/glue/cpp_variant.cc
index 2f6be0c..9237cc9 100644
--- a/webkit/glue/cpp_variant.cc
+++ b/webkit/glue/cpp_variant.cc
@@ -5,16 +5,12 @@
 // This file contains definitions for CppVariant.
 
 #include <limits>
-#include "config.h"
+#include "webkit/api/public/WebBindings.h"
 #include "webkit/glue/cpp_variant.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 
-#include "npruntime_priv.h" // for NPN_InitializeVariantWithStringCopy
-
-#if USE(JSC)
-#define _NPN_InitializeVariantWithStringCopy NPN_InitializeVariantWithStringCopy
-#endif
+using WebKit::WebBindings;
 
 CppVariant::CppVariant() {
   type = NPVariantType_Null;
@@ -39,7 +35,7 @@ CppVariant::~CppVariant() {
 }
 
 void CppVariant::FreeData() {
-  NPN_ReleaseVariantValue(this);
+  WebBindings::releaseVariantValue(this);
 }
 
 bool CppVariant::isEqual(const CppVariant& other) const {
@@ -91,7 +87,7 @@ void CppVariant::CopyToNPVariant(NPVariant* result) const {
       result->value.doubleValue = value.doubleValue;
       break;
     case NPVariantType_String:
-      _NPN_InitializeVariantWithStringCopy(result, &value.stringValue);
+      WebBindings::initializeVariantWithStringCopy(result, &value.stringValue);
       break;
     case NPVariantType_Null:
     case NPVariantType_Void:
@@ -99,7 +95,7 @@ void CppVariant::CopyToNPVariant(NPVariant* result) const {
       break;
     case NPVariantType_Object:
       result->type = NPVariantType_Object;
-      result->value.objectValue = NPN_RetainObject(value.objectValue);
+      result->value.objectValue = WebBindings::retainObject(value.objectValue);
       break;
   }
 }
@@ -158,7 +154,7 @@ void CppVariant::Set(const char* new_value) {
   type = NPVariantType_String;
   NPString new_string = {new_value,
                          static_cast<uint32_t>(strlen(new_value))};
-  _NPN_InitializeVariantWithStringCopy(this, &new_string);
+  WebBindings::initializeVariantWithStringCopy(this, &new_string);
 }
 
 void CppVariant::Set(const std::string& new_value) {
@@ -166,18 +162,18 @@ void CppVariant::Set(const std::string& new_value) {
   type = NPVariantType_String;
   NPString new_string = {new_value.data(),
                          static_cast<uint32_t>(new_value.size())};
-  _NPN_InitializeVariantWithStringCopy(this, &new_string);
+  WebBindings::initializeVariantWithStringCopy(this, &new_string);
 }
 void CppVariant::Set(const NPString& new_value) {
   FreeData();
   type = NPVariantType_String;
-  _NPN_InitializeVariantWithStringCopy(this, &new_value);
+  WebBindings::initializeVariantWithStringCopy(this, &new_value);
 }
 
 void CppVariant::Set(NPObject* new_value) {
   FreeData();
   type = NPVariantType_Object;
-  value.objectValue = NPN_RetainObject(new_value);
+  value.objectValue = WebBindings::retainObject(new_value);
 }
 
 std::string CppVariant::ToString() const {
@@ -218,35 +214,35 @@ std::vector<std::wstring> CppVariant::ToStringVector() const {
   DCHECK(isObject());
   std::vector<std::wstring> wstring_vector;
   NPObject* np_value = value.objectValue;
-  NPIdentifier length_id = NPN_GetStringIdentifier("length");
+  NPIdentifier length_id = WebBindings::getStringIdentifier("length");
 
-  if (NPN_HasProperty(NULL, np_value, length_id)) {
+  if (WebBindings::hasProperty(NULL, np_value, length_id)) {
     NPVariant length_value;
-    if (NPN_GetProperty(NULL, np_value, length_id, &length_value)) {
+    if (WebBindings::getProperty(NULL, np_value, length_id, &length_value)) {
       int length = 0;
       // The length is a double in some cases.
       if (NPVARIANT_IS_DOUBLE(length_value))
         length = static_cast<int>(NPVARIANT_TO_DOUBLE(length_value));
       else if (NPVARIANT_IS_INT32(length_value))
         length = NPVARIANT_TO_INT32(length_value);
-      NPN_ReleaseVariantValue(&length_value);
+      WebBindings::releaseVariantValue(&length_value);
 
       // For sanity, only allow 100 items.
       length = std::min(100, length);
       for (int i = 0; i < length; ++i) {
         // Get each of the items.
         std::string index = StringPrintf("%d", i);
-        NPIdentifier index_id = NPN_GetStringIdentifier(index.c_str());
-        if (NPN_HasProperty(NULL, np_value, index_id)) {
+        NPIdentifier index_id = WebBindings::getStringIdentifier(index.c_str());
+        if (WebBindings::hasProperty(NULL, np_value, index_id)) {
           NPVariant index_value;
-          if (NPN_GetProperty(NULL, np_value, index_id, &index_value)) {
+          if (WebBindings::getProperty(NULL, np_value, index_id, &index_value)) {
             if (NPVARIANT_IS_STRING(index_value)) {
               std::string string(
                   NPVARIANT_TO_STRING(index_value).UTF8Characters,
                   NPVARIANT_TO_STRING(index_value).UTF8Length);
               wstring_vector.push_back(UTF8ToWide(string));
             }
-            NPN_ReleaseVariantValue(&index_value);
+            WebBindings::releaseVariantValue(&index_value);
           }
         }
       }
@@ -258,11 +254,11 @@ std::vector<std::wstring> CppVariant::ToStringVector() const {
 bool CppVariant::Invoke(const std::string& method, const CppVariant* args,
                         uint32 arg_count, CppVariant& result) const {
   DCHECK(isObject());
-  NPIdentifier method_name = NPN_GetStringIdentifier(method.c_str());
+  NPIdentifier method_name = WebBindings::getStringIdentifier(method.c_str());
   NPObject* np_object = value.objectValue;
-  if (NPN_HasMethod(NULL, np_object, method_name)) {
+  if (WebBindings::hasMethod(NULL, np_object, method_name)) {
     NPVariant r;
-    bool status = NPN_Invoke(NULL, np_object, method_name, args, arg_count, &r);
+    bool status = WebBindings::invoke(NULL, np_object, method_name, args, arg_count, &r);
     result.Set(r);
     return status;
   } else {