2.4/plugins/ie/oophm/oophm/IESessionHandler.cpp - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */

 #include "stdafx.h"
 #include "comutil.h"
 #include "dispex.h"
 #include "ExceptionCatcher.h"
 #include "IESessionHandler.h"
 #include "ServerMethods.h"
 #include "scoped_ptr/scoped_ptr.h"
 #include "IEUtils.h"
 #include "Constants.h"


 IESessionHandler::IESessionHandler(HostChannel* channel,
                                    IHTMLWindow2* window) : SessionData(channel, window, this), jsObjectId(1)
 {
   // window->put_defaultStatus(L"GWT Developer Plugin active");
   IEUtils::resetResolver();
 }

 IESessionHandler::~IESessionHandler(void) {
   Debug::log(Debug::Debugging) << "Destroying session handler" << Debug::flush;
   Debug::log(Debug::Spam) << jsObjectsById.size() << " active JS object referances" << Debug::flush;
   // Put any remaining JavaObject references into zombie-mode in case
   // of lingering references
   Debug::log(Debug::Spam) << javaObjectsById.size() << " active Java object references" << Debug::flush;

   IEUtils::resetResolver();
   std::map<int, IUnknown*>::iterator it = javaObjectsById.begin();
   while (it != javaObjectsById.end()) {
     ((CJavaObject*)it->second)->shutdown();
     it++;
   }
   channel->disconnectFromHost();
 }

 void IESessionHandler::disconnectDetectedImpl() {
   DISPID dispId;

   HRESULT hr = IEUtils::resolveName(window, Constants::__gwt_disconnected, &dispId);
   if(FAILED(hr)) {
     Debug::log(Debug::Error) << "Unable to get dispId for __gwt_disconnected" << Debug::flush;
     return;
   }

   DISPPARAMS dispParams = {NULL, NULL, 0, 0};
   CComPtr<IDispatchEx> dispEx;
   hr = IEUtils::Invoke(getWindow(), dispId, DISPATCH_METHOD, &dispParams, NULL, NULL, NULL);
   if (FAILED(hr)) {
     Debug::log(Debug::Error) << "Unable to invoke __gwt_disconnected" << Debug::flush;
     SYSLOGERROR(L"failed to invoke __gwt_disconnected", L"hr=0x%08x", hr);
   }
 }

 void IESessionHandler::fatalError(HostChannel& channel,
     const std::string& message) {
   SYSLOGERROR(L"IESessionHandler::fatalError()", L"%S", message.c_str());
   Debug::log(Debug::Error) << "Fatal error: " << message << Debug::flush;
 }

 void IESessionHandler::freeJavaObject(unsigned int objId) {
   // Remove the now-defunct object from the lookup table
   javaObjectsById.erase(objId);

   // and add it to the set of objects to free on the server
   javaObjectsToFree.insert(objId);
 }

 void IESessionHandler::sendFreeValues(HostChannel& channel) {
   int idCount = javaObjectsToFree.size();
   if (idCount == 0) {
     return;
   }

   Debug::log(Debug::Debugging) << "Freeing " << idCount << " Java objects on server" << Debug::flush;
   scoped_array<int> ids(new int[idCount]);

   std::set<int>::iterator it = javaObjectsToFree.begin();
   for (int i = 0; it != javaObjectsToFree.end(); it++) {
     ids[i++] = *it;
   }

   if (!ServerMethods::freeJava(channel, this, idCount, ids.get())) {
     Debug::log(Debug::Error) << "Unable to free Java ids on server" << Debug::flush;
   }

   javaObjectsToFree.clear();
 }

 void IESessionHandler::freeValue(HostChannel& channel, int idCount, const int* ids) {
   for (int i = 0; i < idCount; i++) {
     int jsId = ids[i];
     std::map<int, CComPtr<IUnknown>>::iterator it = jsObjectsById.find(jsId);
     if (it == jsObjectsById.end()) {
       Debug::log(Debug::Error) << "Trying to free unknown js id " << jsId << Debug::flush;
       continue;
     }
     jsIdsByObject.erase(it->second);
     jsObjectsById.erase(it);
   }
   Debug::log(Debug::Debugging) << "Freed " << idCount << " JS objects" << Debug::flush;
 }

 bool IESessionHandler::invoke(HostChannel& channel, const Value& thisObj,
                                const std::string& methodName, int numArgs,
                                const Value* const args, Value* returnValue)
 {
   Debug::log(Debug::Debugging) << "Executing method " << methodName <<
       " on object " << thisObj.toString() << Debug::flush;

   DISPID methodDispId;
   HRESULT hr = IEUtils::resolveName(window, methodName, &methodDispId);
   if (FAILED(hr)) {
     SYSLOGERROR(L"Failed to resolve name to DISPID",
         L"IESessionHandler::invoke(thisObj=%S, methodName=%S)",
         thisObj.toString().c_str(), methodName.c_str());
     Debug::log(Debug::Error) << "Unable to find method " << methodName
         << " on the window object" <<Debug::flush;
     makeExceptionValue(*returnValue, "Unable to find named method on window");
     return true;
   }

   // Get the JS Function object as an IDispatch
   // TODO try PROPERTYGET|EXECUTE instead?
   _variant_t functionObject;
   DISPPARAMS disparamsNoArgs = {NULL, NULL, 0, 0};
   hr = IEUtils::Invoke(window, methodDispId, DISPATCH_PROPERTYGET, &disparamsNoArgs,
       functionObject.GetAddress(), NULL, NULL);
   if (FAILED(hr)) {
     Debug::log(Debug::Error) << "Unable to get method " << methodName
         << Debug::flush;
     makeExceptionValue(*returnValue, "Unable to get method from window");
     return true;
   } else if (functionObject.vt != VT_DISPATCH) {
     Debug::log(Debug::Error) << "Did not get a VT_DISPATCH, got " <<
         functionObject.vt << Debug::flush;
     makeExceptionValue(*returnValue, "Did not get a VT_DISPATCH");
     return true;
   }

   // See if it's an IDispatchEx
   CComPtr<IDispatchEx> ex;
   if (functionObject.pdispVal->QueryInterface(&ex)) {
     // Probably not a function
     Debug::log(Debug::Error) << "Failed to invoke " << methodName <<
         " which is not an IDispatchEx" << Debug::flush;
     makeExceptionValue(*returnValue, "Unable to invoke method");
     return true;
   }

   // Convert the function arguments
   // The parameters in the DISPARAMS are backwards
   // Named parameters are first
   int jsArgsLen = numArgs + 1;
   scoped_array<_variant_t> jsargs(new _variant_t[jsArgsLen]);
   DISPID thisId[] = {DISPID_THIS};
   makeValueRef(jsargs[0], thisObj);
   for (int i = 0; i < numArgs; i++) {
     makeValueRef(jsargs[jsArgsLen - 1 - i], args[i]);
   }
   DISPPARAMS callDispParams = {jsargs.get(), thisId, numArgs + 1, 1};
   EXCEPINFO excepInfo;
   _variant_t retVal;
   CComPtr<IExceptionCatcher> catcher;
   CExceptionCatcher::CreateInstance(&catcher);

   CComPtr<IServiceProvider> serviceProvider;
   catcher->QueryInterface(&serviceProvider);
   hr = ex->InvokeEx(DISPID_VALUE, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD,
     &callDispParams, retVal.GetAddress(), &excepInfo, serviceProvider);

   // There are cases where an exception was thrown and we've caught it, but
   // the return value from InvokeEx is still S_OK.  Thus, we check our
   // ExceptionCatcher before using the res value to determine failure.
   BOOL exceptionFlag = false;
   catcher->hasSeenException(&exceptionFlag);
   if (exceptionFlag) {
     VARIANT exceptionVariant;
     catcher->getException(&exceptionVariant);
     _variant_t exception(exceptionVariant);

     makeValue(*returnValue, exception);
     exceptionFlag = true;

   } else if (!SUCCEEDED(hr)) {
     makeExceptionValue(*returnValue, "Unknown failure");
     exceptionFlag = true;

   } else {
     // Success
     makeValue(*returnValue, retVal);
   }
   return exceptionFlag != 0;
 }

 bool IESessionHandler::invokeSpecial(HostChannel& channel, SpecialMethodId method, int numArgs,
                                      const Value* const args, Value* returnValue)
 {
   Debug::log(Debug::Error) << "InvokeSpecial is currently unimplemented" << Debug::flush;
   makeExceptionValue(*returnValue, "InvokeSpecial is currently unimplemented");
   return true;
 }


 void IESessionHandler::loadJsni(HostChannel& channel, const std::string& js) {
     Debug::log(Debug::Spam) << ">>> loadJsni\n" << js << "\n<<< loadJsni" << Debug::flush;

     _variant_t retVal;
     HRESULT hr = window->execScript(UTF8ToBSTR(js.length(), js.c_str()),
         Constants::JavaScript, retVal.GetAddress());
     if (FAILED(hr)) {
         Debug::log(Debug::Error) << "Unable to evaluate JSNI code" << Debug::flush;
     }
 }

 void IESessionHandler::makeException(_variant_t& in, const char* message) {
   Debug::log(Debug::Debugging) << "Creating exception variant " <<
       std::string(message) << Debug::flush;

   SYSLOGERROR(L"IESessionHandler::makeException()", L"exception: %S", message);
   DISPID dispId;
   HRESULT hr = IEUtils::resolveName(window, Constants::Error, &dispId);
   if (FAILED(hr)) {
       SYSLOGERROR(L"failed to resolve Error object", L"hr=0x%08x", hr);
       return;
   }

   DISPPARAMS emptyParams = {NULL, NULL, 0, 0};
   _variant_t errorConstructor;
   hr = IEUtils::Invoke(window, dispId, DISPATCH_PROPERTYGET, &emptyParams,
       errorConstructor.GetAddress(), NULL, NULL);
   if (FAILED(hr)) {
     Debug::log(Debug::Error) << "Unable to get Error constructor" << Debug::flush;
     in.SetString("Unable to get Error constructor");
   }

   CComPtr<IDispatchEx> ex;
   hr = errorConstructor.pdispVal->QueryInterface(&ex);
   if (FAILED(hr)) {
     Debug::log(Debug::Error) << "Error constructor not IDispatchEx" << Debug::flush;
     in.SetString("Error constructor not IDispatchEx");
   }

   _variant_t param = _variant_t(message);
   DISPPARAMS dispParams = {&param, NULL, 1, 0};

   hr = ex->InvokeEx(DISPID_VALUE, LOCALE_SYSTEM_DEFAULT, DISPATCH_CONSTRUCT,
     &dispParams, in.GetAddress(), NULL, NULL);

   if (FAILED(hr)) {
     Debug::log(Debug::Error) << "Unable to invoke Error constructor" << Debug::flush;
     in.SetString("Unable to invoke Error constructor");
   }
 }

 void IESessionHandler::makeExceptionValue(Value& in, const char* message) {
   Debug::log(Debug::Debugging) << "Creating exception value " << std::string(message) << Debug::flush;
   _variant_t exception;
   makeException(exception, message);
   makeValue(in, exception);
 }

 void IESessionHandler::makeValue(Value& retVal, const _variant_t& value) {
   CComPtr<IDispatch> dispObj;
   CComPtr<IJavaObject> javaObject;

   switch (value.vt) {
     case VT_EMPTY:
       retVal.setUndefined();
       break;

     case VT_NULL:
       retVal.setNull();
       break;

     case VT_BOOL:
       retVal.setBoolean(VARIANT_TRUE == value.boolVal);
       break;

     case VT_BSTR:
       retVal.setString(BSTRToUTF8(value.bstrVal));
       break;

     case VT_I4:
       retVal.setInt(value.lVal);
       break;

     case VT_I8:
       retVal.setLong(value.llVal);
       break;

     case VT_R4:
       retVal.setFloat(value.fltVal);
       break;

     case VT_R8:
       retVal.setDouble(value.dblVal);
       break;

     case VT_DISPATCH:
       dispObj = value.pdispVal;

       if (!dispObj) {
         // XXX Determine if this is normal operation
         retVal.setUndefined();

       } else if (!dispObj->QueryInterface(&javaObject)) {
         // It's one of our Java Object proxies
         // XXX This casting is a hack
         retVal.setJavaObject(((CJavaObject*)javaObject.p)->getObjectId());

       } else {
         _variant_t stringValue;
         DISPPARAMS emptyParams = {NULL, NULL, 0, 0};
         DISPID valueOfDispId = -1;
         // See if it's a wrapped String object by invoking valueOf()
         HRESULT hr = dispObj->GetIDsOfNames(IID_NULL, (LPOLESTR*)&Constants::valueOf, 1,
             LOCALE_SYSTEM_DEFAULT, &valueOfDispId);
         if ((valueOfDispId != -1) &&
             SUCCEEDED(dispObj->Invoke(valueOfDispId, IID_NULL, LOCALE_SYSTEM_DEFAULT,
               DISPATCH_METHOD, &emptyParams, stringValue.GetAddress(),
               NULL, NULL)) &&
             stringValue.vt == VT_BSTR) {
           retVal.setString(BSTRToUTF8(stringValue.bstrVal));

         } else {
           // It's a plain-old JavaScript Object

           // We ask for the IUnknown interface since that's the only
           // COM interface guaranteed to have object-identity semantics
           CComPtr<IUnknown> asUnknown;
           dispObj->QueryInterface(&asUnknown);

           // See if we already know about this object
           std::map<IUnknown*, int>::iterator it = jsIdsByObject.find(asUnknown);
           if (it != jsIdsByObject.end()) {
             retVal.setJsObjectId(it->second);

           } else {
             // Allocate a new id
             int objId = ++jsObjectId;
             jsObjectsById[objId] = asUnknown;
             jsIdsByObject[asUnknown] = objId;
             retVal.setJsObjectId(objId);
           }
         }
       }
       break;

     default:
       Debug::log(Debug::Error) << "Unhandled variant type " << value.vt << Debug::flush;
       retVal.setString("Unhandled variant type");
   }
 }

 void IESessionHandler::makeValueRef(_variant_t& retVal, const Value& value) {
   switch (value.getType()) {
     case Value::NULL_TYPE:
       retVal.ChangeType(VT_NULL);
       break;

     case Value::BOOLEAN:
       retVal = value.getBoolean();
       break;

     case Value::BYTE:
       retVal = value.getByte();
       break;

     case Value::CHAR:
       retVal = value.getChar();
       break;

     case Value::SHORT:
       retVal = value.getShort();
       break;

     case Value::INT:
       retVal = value.getInt();
       break;

     case Value::LONG:
       retVal = value.getLong();
       break;

     case Value::FLOAT:
       retVal = value.getFloat();
       break;

     case Value::DOUBLE:
       retVal = value.getDouble();
       break;

     case Value::STRING:
       // The copy-constructor does not correctly handle embedded nulls
       retVal.bstrVal = UTF8ToBSTR(value.getString().length(),
         value.getString().c_str()).Detach();
       retVal.vt = VT_BSTR;
       break;

     case Value::JAVA_OBJECT:
       {
         int javaId = value.getJavaObjectId();

         std::map<int, IUnknown*>::iterator i = javaObjectsById.find(javaId);
         if (i == javaObjectsById.end()) {
           CComPtr<IUnknown> target;

           // Create a new instance of the Java object proxy type
           CJavaObject::CreateInstance(&target);

           // Because we used CreateInstance, we can cast it back to the concrete type
           // which allows us to pass pointers around, since we're guaranteed that
           // it is in the same process space
           ((CJavaObject*)target.p)->initialize(javaId, this);
           target->QueryInterface(&retVal.pdispVal);

           // Don't artificially increase the lifetime of a Java object proxy by
           // calling Detach; we want Release to be called.
           javaObjectsById[javaId] = target;

           // We may have previously released the proxy for the same object id,
           // but have not yet sent a free message back to the server.
           javaObjectsToFree.erase(javaId);

         } else {
           i->second->QueryInterface(&retVal.pdispVal);
         }
         retVal.vt = VT_DISPATCH;
       }
       break;

     case Value::JS_OBJECT:
       {
         int jsId = value.getJsObjectId();

         std::map<int, CComPtr<IUnknown>>::iterator i = jsObjectsById.find(jsId);
         if (i == jsObjectsById.end()) {
           Debug::log(Debug::Error) << "Missing jsObject with id " << jsId << Debug::flush;

         } else {
           i->second->QueryInterface(&retVal.pdispVal);
           retVal.vt = VT_DISPATCH;
         }
       }
       break;

     case Value::UNDEFINED:
       retVal.ChangeType(VT_EMPTY);
       break;

     default:
       Debug::log(Debug::Error) << "Unknown Value type " << value.toString() << Debug::flush;
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/

	#include "stdafx.h"
	#include "comutil.h"
	#include "dispex.h"
	#include "ExceptionCatcher.h"
	#include "IESessionHandler.h"
	#include "ServerMethods.h"
	#include "scoped_ptr/scoped_ptr.h"
	#include "IEUtils.h"
	#include "Constants.h"


	IESessionHandler::IESessionHandler(HostChannel* channel,
	IHTMLWindow2* window) : SessionData(channel, window, this), jsObjectId(1)
	{
	// window->put_defaultStatus(L"GWT Developer Plugin active");
	IEUtils::resetResolver();
	}

	IESessionHandler::~IESessionHandler(void) {
	Debug::log(Debug::Debugging) << "Destroying session handler" << Debug::flush;
	Debug::log(Debug::Spam) << jsObjectsById.size() << " active JS object referances" << Debug::flush;
	// Put any remaining JavaObject references into zombie-mode in case
	// of lingering references
	Debug::log(Debug::Spam) << javaObjectsById.size() << " active Java object references" << Debug::flush;

	IEUtils::resetResolver();
	std::map<int, IUnknown*>::iterator it = javaObjectsById.begin();
	while (it != javaObjectsById.end()) {
	((CJavaObject*)it->second)->shutdown();
	it++;
	}
	channel->disconnectFromHost();
	}

	void IESessionHandler::disconnectDetectedImpl() {
	DISPID dispId;

	HRESULT hr = IEUtils::resolveName(window, Constants::__gwt_disconnected, &dispId);
	if(FAILED(hr)) {
	Debug::log(Debug::Error) << "Unable to get dispId for __gwt_disconnected" << Debug::flush;
	return;
	}

	DISPPARAMS dispParams = {NULL, NULL, 0, 0};
	CComPtr<IDispatchEx> dispEx;
	hr = IEUtils::Invoke(getWindow(), dispId, DISPATCH_METHOD, &dispParams, NULL, NULL, NULL);
	if (FAILED(hr)) {
	Debug::log(Debug::Error) << "Unable to invoke __gwt_disconnected" << Debug::flush;
	SYSLOGERROR(L"failed to invoke __gwt_disconnected", L"hr=0x%08x", hr);
	}
	}

	void IESessionHandler::fatalError(HostChannel& channel,
	const std::string& message) {
	SYSLOGERROR(L"IESessionHandler::fatalError()", L"%S", message.c_str());
	Debug::log(Debug::Error) << "Fatal error: " << message << Debug::flush;
	}

	void IESessionHandler::freeJavaObject(unsigned int objId) {
	// Remove the now-defunct object from the lookup table
	javaObjectsById.erase(objId);

	// and add it to the set of objects to free on the server
	javaObjectsToFree.insert(objId);
	}

	void IESessionHandler::sendFreeValues(HostChannel& channel) {
	int idCount = javaObjectsToFree.size();
	if (idCount == 0) {
	return;
	}

	Debug::log(Debug::Debugging) << "Freeing " << idCount << " Java objects on server" << Debug::flush;
	scoped_array<int> ids(new int[idCount]);

	std::set<int>::iterator it = javaObjectsToFree.begin();
	for (int i = 0; it != javaObjectsToFree.end(); it++) {
	ids[i++] = *it;
	}

	if (!ServerMethods::freeJava(channel, this, idCount, ids.get())) {
	Debug::log(Debug::Error) << "Unable to free Java ids on server" << Debug::flush;
	}

	javaObjectsToFree.clear();
	}

	void IESessionHandler::freeValue(HostChannel& channel, int idCount, const int* ids) {
	for (int i = 0; i < idCount; i++) {
	int jsId = ids[i];
	std::map<int, CComPtr<IUnknown>>::iterator it = jsObjectsById.find(jsId);
	if (it == jsObjectsById.end()) {
	Debug::log(Debug::Error) << "Trying to free unknown js id " << jsId << Debug::flush;
	continue;
	}
	jsIdsByObject.erase(it->second);
	jsObjectsById.erase(it);
	}
	Debug::log(Debug::Debugging) << "Freed " << idCount << " JS objects" << Debug::flush;
	}

	bool IESessionHandler::invoke(HostChannel& channel, const Value& thisObj,
	const std::string& methodName, int numArgs,
	const Value* const args, Value* returnValue)
	{
	Debug::log(Debug::Debugging) << "Executing method " << methodName <<
	" on object " << thisObj.toString() << Debug::flush;

	DISPID methodDispId;
	HRESULT hr = IEUtils::resolveName(window, methodName, &methodDispId);
	if (FAILED(hr)) {
	SYSLOGERROR(L"Failed to resolve name to DISPID",
	L"IESessionHandler::invoke(thisObj=%S, methodName=%S)",
	thisObj.toString().c_str(), methodName.c_str());
	Debug::log(Debug::Error) << "Unable to find method " << methodName
	<< " on the window object" <<Debug::flush;
	makeExceptionValue(*returnValue, "Unable to find named method on window");
	return true;
	}

	// Get the JS Function object as an IDispatch
	// TODO try PROPERTYGET\|EXECUTE instead?
	_variant_t functionObject;
	DISPPARAMS disparamsNoArgs = {NULL, NULL, 0, 0};
	hr = IEUtils::Invoke(window, methodDispId, DISPATCH_PROPERTYGET, &disparamsNoArgs,
	functionObject.GetAddress(), NULL, NULL);
	if (FAILED(hr)) {
	Debug::log(Debug::Error) << "Unable to get method " << methodName
	<< Debug::flush;
	makeExceptionValue(*returnValue, "Unable to get method from window");
	return true;
	} else if (functionObject.vt != VT_DISPATCH) {
	Debug::log(Debug::Error) << "Did not get a VT_DISPATCH, got " <<
	functionObject.vt << Debug::flush;
	makeExceptionValue(*returnValue, "Did not get a VT_DISPATCH");
	return true;
	}

	// See if it's an IDispatchEx
	CComPtr<IDispatchEx> ex;
	if (functionObject.pdispVal->QueryInterface(&ex)) {
	// Probably not a function
	Debug::log(Debug::Error) << "Failed to invoke " << methodName <<
	" which is not an IDispatchEx" << Debug::flush;
	makeExceptionValue(*returnValue, "Unable to invoke method");
	return true;
	}

	// Convert the function arguments
	// The parameters in the DISPARAMS are backwards
	// Named parameters are first
	int jsArgsLen = numArgs + 1;
	scoped_array<_variant_t> jsargs(new _variant_t[jsArgsLen]);
	DISPID thisId[] = {DISPID_THIS};
	makeValueRef(jsargs[0], thisObj);
	for (int i = 0; i < numArgs; i++) {
	makeValueRef(jsargs[jsArgsLen - 1 - i], args[i]);
	}
	DISPPARAMS callDispParams = {jsargs.get(), thisId, numArgs + 1, 1};
	EXCEPINFO excepInfo;
	_variant_t retVal;
	CComPtr<IExceptionCatcher> catcher;
	CExceptionCatcher::CreateInstance(&catcher);

	CComPtr<IServiceProvider> serviceProvider;
	catcher->QueryInterface(&serviceProvider);
	hr = ex->InvokeEx(DISPID_VALUE, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD,
	&callDispParams, retVal.GetAddress(), &excepInfo, serviceProvider);

	// There are cases where an exception was thrown and we've caught it, but
	// the return value from InvokeEx is still S_OK. Thus, we check our
	// ExceptionCatcher before using the res value to determine failure.
	BOOL exceptionFlag = false;
	catcher->hasSeenException(&exceptionFlag);
	if (exceptionFlag) {
	VARIANT exceptionVariant;
	catcher->getException(&exceptionVariant);
	_variant_t exception(exceptionVariant);

	makeValue(*returnValue, exception);
	exceptionFlag = true;

	} else if (!SUCCEEDED(hr)) {
	makeExceptionValue(*returnValue, "Unknown failure");
	exceptionFlag = true;

	} else {
	// Success
	makeValue(*returnValue, retVal);
	}
	return exceptionFlag != 0;
	}

	bool IESessionHandler::invokeSpecial(HostChannel& channel, SpecialMethodId method, int numArgs,
	const Value* const args, Value* returnValue)
	{
	Debug::log(Debug::Error) << "InvokeSpecial is currently unimplemented" << Debug::flush;
	makeExceptionValue(*returnValue, "InvokeSpecial is currently unimplemented");
	return true;
	}


	void IESessionHandler::loadJsni(HostChannel& channel, const std::string& js) {
	Debug::log(Debug::Spam) << ">>> loadJsni\n" << js << "\n<<< loadJsni" << Debug::flush;

	_variant_t retVal;
	HRESULT hr = window->execScript(UTF8ToBSTR(js.length(), js.c_str()),
	Constants::JavaScript, retVal.GetAddress());
	if (FAILED(hr)) {
	Debug::log(Debug::Error) << "Unable to evaluate JSNI code" << Debug::flush;
	}
	}

	void IESessionHandler::makeException(_variant_t& in, const char* message) {
	Debug::log(Debug::Debugging) << "Creating exception variant " <<
	std::string(message) << Debug::flush;

	SYSLOGERROR(L"IESessionHandler::makeException()", L"exception: %S", message);
	DISPID dispId;
	HRESULT hr = IEUtils::resolveName(window, Constants::Error, &dispId);
	if (FAILED(hr)) {
	SYSLOGERROR(L"failed to resolve Error object", L"hr=0x%08x", hr);
	return;
	}

	DISPPARAMS emptyParams = {NULL, NULL, 0, 0};
	_variant_t errorConstructor;
	hr = IEUtils::Invoke(window, dispId, DISPATCH_PROPERTYGET, &emptyParams,
	errorConstructor.GetAddress(), NULL, NULL);
	if (FAILED(hr)) {
	Debug::log(Debug::Error) << "Unable to get Error constructor" << Debug::flush;
	in.SetString("Unable to get Error constructor");
	}

	CComPtr<IDispatchEx> ex;
	hr = errorConstructor.pdispVal->QueryInterface(&ex);
	if (FAILED(hr)) {
	Debug::log(Debug::Error) << "Error constructor not IDispatchEx" << Debug::flush;
	in.SetString("Error constructor not IDispatchEx");
	}

	_variant_t param = _variant_t(message);
	DISPPARAMS dispParams = {&param, NULL, 1, 0};

	hr = ex->InvokeEx(DISPID_VALUE, LOCALE_SYSTEM_DEFAULT, DISPATCH_CONSTRUCT,
	&dispParams, in.GetAddress(), NULL, NULL);

	if (FAILED(hr)) {
	Debug::log(Debug::Error) << "Unable to invoke Error constructor" << Debug::flush;
	in.SetString("Unable to invoke Error constructor");
	}
	}

	void IESessionHandler::makeExceptionValue(Value& in, const char* message) {
	Debug::log(Debug::Debugging) << "Creating exception value " << std::string(message) << Debug::flush;
	_variant_t exception;
	makeException(exception, message);
	makeValue(in, exception);
	}

	void IESessionHandler::makeValue(Value& retVal, const _variant_t& value) {
	CComPtr<IDispatch> dispObj;
	CComPtr<IJavaObject> javaObject;

	switch (value.vt) {
	case VT_EMPTY:
	retVal.setUndefined();
	break;

	case VT_NULL:
	retVal.setNull();
	break;

	case VT_BOOL:
	retVal.setBoolean(VARIANT_TRUE == value.boolVal);
	break;

	case VT_BSTR:
	retVal.setString(BSTRToUTF8(value.bstrVal));
	break;

	case VT_I4:
	retVal.setInt(value.lVal);
	break;

	case VT_I8:
	retVal.setLong(value.llVal);
	break;

	case VT_R4:
	retVal.setFloat(value.fltVal);
	break;

	case VT_R8:
	retVal.setDouble(value.dblVal);
	break;

	case VT_DISPATCH:
	dispObj = value.pdispVal;

	if (!dispObj) {
	// XXX Determine if this is normal operation
	retVal.setUndefined();

	} else if (!dispObj->QueryInterface(&javaObject)) {
	// It's one of our Java Object proxies
	// XXX This casting is a hack
	retVal.setJavaObject(((CJavaObject*)javaObject.p)->getObjectId());

	} else {
	_variant_t stringValue;
	DISPPARAMS emptyParams = {NULL, NULL, 0, 0};
	DISPID valueOfDispId = -1;
	// See if it's a wrapped String object by invoking valueOf()
	HRESULT hr = dispObj->GetIDsOfNames(IID_NULL, (LPOLESTR*)&Constants::valueOf, 1,
	LOCALE_SYSTEM_DEFAULT, &valueOfDispId);
	if ((valueOfDispId != -1) &&
	SUCCEEDED(dispObj->Invoke(valueOfDispId, IID_NULL, LOCALE_SYSTEM_DEFAULT,
	DISPATCH_METHOD, &emptyParams, stringValue.GetAddress(),
	NULL, NULL)) &&
	stringValue.vt == VT_BSTR) {
	retVal.setString(BSTRToUTF8(stringValue.bstrVal));

	} else {
	// It's a plain-old JavaScript Object

	// We ask for the IUnknown interface since that's the only
	// COM interface guaranteed to have object-identity semantics
	CComPtr<IUnknown> asUnknown;
	dispObj->QueryInterface(&asUnknown);

	// See if we already know about this object
	std::map<IUnknown*, int>::iterator it = jsIdsByObject.find(asUnknown);
	if (it != jsIdsByObject.end()) {
	retVal.setJsObjectId(it->second);

	} else {
	// Allocate a new id
	int objId = ++jsObjectId;
	jsObjectsById[objId] = asUnknown;
	jsIdsByObject[asUnknown] = objId;
	retVal.setJsObjectId(objId);
	}
	}
	}
	break;

	default:
	Debug::log(Debug::Error) << "Unhandled variant type " << value.vt << Debug::flush;
	retVal.setString("Unhandled variant type");
	}
	}

	void IESessionHandler::makeValueRef(_variant_t& retVal, const Value& value) {
	switch (value.getType()) {
	case Value::NULL_TYPE:
	retVal.ChangeType(VT_NULL);
	break;

	case Value::BOOLEAN:
	retVal = value.getBoolean();
	break;

	case Value::BYTE:
	retVal = value.getByte();
	break;

	case Value::CHAR:
	retVal = value.getChar();
	break;

	case Value::SHORT:
	retVal = value.getShort();
	break;

	case Value::INT:
	retVal = value.getInt();
	break;

	case Value::LONG:
	retVal = value.getLong();
	break;

	case Value::FLOAT:
	retVal = value.getFloat();
	break;

	case Value::DOUBLE:
	retVal = value.getDouble();
	break;

	case Value::STRING:
	// The copy-constructor does not correctly handle embedded nulls
	retVal.bstrVal = UTF8ToBSTR(value.getString().length(),
	value.getString().c_str()).Detach();
	retVal.vt = VT_BSTR;
	break;

	case Value::JAVA_OBJECT:
	{
	int javaId = value.getJavaObjectId();

	std::map<int, IUnknown*>::iterator i = javaObjectsById.find(javaId);
	if (i == javaObjectsById.end()) {
	CComPtr<IUnknown> target;

	// Create a new instance of the Java object proxy type
	CJavaObject::CreateInstance(&target);

	// Because we used CreateInstance, we can cast it back to the concrete type
	// which allows us to pass pointers around, since we're guaranteed that
	// it is in the same process space
	((CJavaObject*)target.p)->initialize(javaId, this);
	target->QueryInterface(&retVal.pdispVal);

	// Don't artificially increase the lifetime of a Java object proxy by
	// calling Detach; we want Release to be called.
	javaObjectsById[javaId] = target;

	// We may have previously released the proxy for the same object id,
	// but have not yet sent a free message back to the server.
	javaObjectsToFree.erase(javaId);

	} else {
	i->second->QueryInterface(&retVal.pdispVal);
	}
	retVal.vt = VT_DISPATCH;
	}
	break;

	case Value::JS_OBJECT:
	{
	int jsId = value.getJsObjectId();

	std::map<int, CComPtr<IUnknown>>::iterator i = jsObjectsById.find(jsId);
	if (i == jsObjectsById.end()) {
	Debug::log(Debug::Error) << "Missing jsObject with id " << jsId << Debug::flush;

	} else {
	i->second->QueryInterface(&retVal.pdispVal);
	retVal.vt = VT_DISPATCH;
	}
	}
	break;

	case Value::UNDEFINED:
	retVal.ChangeType(VT_EMPTY);
	break;

	default:
	Debug::log(Debug::Error) << "Unknown Value type " << value.toString() << Debug::flush;
	}
	}