1 /*

     2  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

    24  */

    25 

    26 #include "config.h"

    27 #include "WebKitDLL.h"

    28 #include "MarshallingHelpers.h"

    29 #include "MathExtras.h"

    30 

    31 #pragma warning(push, 0)

    32 #include <WebCore/IntRect.h>

    33 #include <WebCore/KURL.h>

    34 #include <WebCore/PlatformString.h>

    35 #pragma warning(pop)

    36 

    37 using namespace WebCore;

    38 

    39 static const double secondsPerDay = 60 * 60 * 24;

    40 

    41 CFArrayCallBacks MarshallingHelpers::kIUnknownArrayCallBacks = {0, IUnknownRetainCallback, IUnknownReleaseCallback, 0, 0};

    42 CFDictionaryValueCallBacks MarshallingHelpers::kIUnknownDictionaryValueCallBacks = {0, IUnknownRetainCallback, IUnknownReleaseCallback, 0, 0};

    43 

    44 KURL MarshallingHelpers::BSTRToKURL(BSTR urlStr)

    45 {

    46     return KURL(KURL(), String(urlStr, SysStringLen(urlStr)));

    47 }

    48 

    49 BSTR MarshallingHelpers::KURLToBSTR(const KURL& url)

    50 {

    51     return SysAllocStringLen(url.string().characters(), url.string().length());

    52 }

    53 

    54 CFURLRef MarshallingHelpers::PathStringToFileCFURLRef(const String& string)

    55 {

    56     CFStringRef cfPath = CFStringCreateWithCharactersNoCopy(0, (const UniChar*)string.characters(), string.length(), kCFAllocatorNull);

    57     CFURLRef pathURL = CFURLCreateWithFileSystemPath(0, cfPath, kCFURLWindowsPathStyle, false);

    58     CFRelease(cfPath);

    59     return pathURL;

    60 }

    61 

    62 String MarshallingHelpers::FileCFURLRefToPathString(CFURLRef fileURL)

    63 {

    64     CFStringRef string = CFURLCopyFileSystemPath(fileURL, kCFURLWindowsPathStyle);

    65     String result(string);

    66     CFRelease(string);

    67     return result;

    68 }

    69 

    70 CFURLRef MarshallingHelpers::BSTRToCFURLRef(BSTR urlStr)

    71 {

    72     CFStringRef urlCFString = BSTRToCFStringRef(urlStr);

    73     if (!urlCFString)

    74         return 0;

    75 

    76     CFURLRef urlRef = CFURLCreateWithString(0, urlCFString, 0);

    77     CFRelease(urlCFString);

    78 

    79     return urlRef;

    80 }

    81 

    82 CFStringRef MarshallingHelpers::BSTRToCFStringRef(BSTR str)

    83 {

    84     return CFStringCreateWithCharacters(0, (const UniChar*)(str ? str : TEXT("")), SysStringLen(str));

    85 }

    86 

    87 CFStringRef MarshallingHelpers::LPCOLESTRToCFStringRef(LPCOLESTR str)

    88 {

    89     return CFStringCreateWithCharacters(0, (const UniChar*)(str ? str : TEXT("")), (CFIndex)(str ? wcslen(str) : 0));

    90 }

    91 

    92 BSTR MarshallingHelpers::CFStringRefToBSTR(CFStringRef str)

    93 {

    94     if (!str)

    95         return 0;

    96 

    97     const UniChar* uniChars = CFStringGetCharactersPtr(str);

    98     if (uniChars)

    99         return SysAllocStringLen((LPCTSTR)uniChars, CFStringGetLength(str));

   100 

   101     CFIndex length = CFStringGetLength(str);

   102     BSTR bstr = SysAllocStringLen(0, length);

   103     if (bstr) {

   104         CFStringGetCharacters(str, CFRangeMake(0, length), (UniChar*)bstr);

   105         bstr[length] = 0;

   106     }

   107     return bstr;

   108 }

   109 

   110 int MarshallingHelpers::CFNumberRefToInt(CFNumberRef num)

   111 {

   112     int number;

   113     CFNumberGetValue(num, kCFNumberIntType, &number);

   114     return number;

   115 }

   116 

   117 CFNumberRef MarshallingHelpers::intToCFNumberRef(int num)

   118 {

   119     return CFNumberCreate(0, kCFNumberSInt32Type, &num);

   120 }

   121 

   122 CFAbsoluteTime MarshallingHelpers::windowsEpochAbsoluteTime()

   123 {

   124     static CFAbsoluteTime windowsEpochAbsoluteTime = 0;

   125     if (!windowsEpochAbsoluteTime) {

   126         CFGregorianDate windowsEpochDate = {1899, 12, 30, 0, 0, 0.0};

   127         windowsEpochAbsoluteTime = CFGregorianDateGetAbsoluteTime(windowsEpochDate, 0) / secondsPerDay;

   128     }

   129     return windowsEpochAbsoluteTime;

   130 }

   131 

   132 CFAbsoluteTime MarshallingHelpers::DATEToCFAbsoluteTime(DATE date)

   133 {

   134     // <http://msdn2.microsoft.com/en-us/library/ms221627.aspx>

   135     // DATE: This is the same numbering system used by most spreadsheet programs,

   136     // although some specify incorrectly that February 29, 1900 existed, and thus

   137     // set January 1, 1900 to 1.0. The date can be converted to and from an MS-DOS

   138     // representation using VariantTimeToDosDateTime, which is discussed in

   139     // Conversion and Manipulation Functions.

   140 

   141     // CFAbsoluteTime: Type used to represent a specific point in time relative

   142     // to the absolute reference date of 1 Jan 2001 00:00:00 GMT.

   143     // Absolute time is measured by the number of seconds between the reference

   144     // date and the specified date. Negative values indicate dates/times before

   145     // the reference date. Positive values indicate dates/times after the

   146     // reference date.

   147 

   148     return round((date + windowsEpochAbsoluteTime()) * secondsPerDay);

   149 }

   150 

   151 DATE MarshallingHelpers::CFAbsoluteTimeToDATE(CFAbsoluteTime absoluteTime)

   152 {

   153     return (round(absoluteTime)/secondsPerDay - windowsEpochAbsoluteTime());

   154 }

   155 

   156 // utility method to store a 1-dim string vector into a newly created SAFEARRAY

   157 SAFEARRAY* MarshallingHelpers::stringArrayToSafeArray(CFArrayRef inArray)

   158 {

   159     CFIndex size = CFArrayGetCount(inArray);

   160     SAFEARRAY* sa = ::SafeArrayCreateVectorEx(VT_BSTR, 0, (ULONG) size, 0);

   161     long count = 0;

   162     for (CFIndex i=0; i<size; i++) {

   163         CFStringRef item = (CFStringRef) CFArrayGetValueAtIndex(inArray, i);

   164         BSTR bstr = CFStringRefToBSTR(item);

   165         ::SafeArrayPutElement(sa, &count, bstr);

   166         SysFreeString(bstr);    // SafeArrayPutElement() should make a copy of the string

   167         count++;

   168     }

   169     return sa;

   170 }

   171 

   172 // utility method to store a 1-dim int vector into a newly created SAFEARRAY

   173 SAFEARRAY* MarshallingHelpers::intArrayToSafeArray(CFArrayRef inArray)

   174 {

   175     CFIndex size = CFArrayGetCount(inArray);

   176     SAFEARRAY* sa = ::SafeArrayCreateVectorEx(VT_I4, 0, (ULONG) size, 0);

   177     long count = 0;

   178     for (CFIndex i=0; i<size; i++) {

   179         CFNumberRef item = (CFNumberRef) CFArrayGetValueAtIndex(inArray, i);

   180         int number = CFNumberRefToInt(item);

   181         ::SafeArrayPutElement(sa, &count, &number);

   182         count++;

   183     }

   184     return sa;

   185 }

   186 

   187 SAFEARRAY* MarshallingHelpers::intRectToSafeArray(const WebCore::IntRect& rect)

   188 {

   189     SAFEARRAY* sa = ::SafeArrayCreateVectorEx(VT_I4, 0, 4, 0);

   190     long count = 0;

   191     int value;

   192 

   193     value = rect.x();

   194     ::SafeArrayPutElement(sa, &count, &value);

   195     count++;

   196 

   197     value = rect.y();

   198     ::SafeArrayPutElement(sa, &count, &value);

   199     count++;

   200 

   201     value = rect.width();

   202     ::SafeArrayPutElement(sa, &count, &value);

   203     count++;

   204 

   205     value = rect.height();

   206     ::SafeArrayPutElement(sa, &count, &value);

   207     count++;

   208 

   209     return sa;

   210 }

   211 

   212 // utility method to store a 1-dim IUnknown* vector into a newly created SAFEARRAY

   213 SAFEARRAY* MarshallingHelpers::iunknownArrayToSafeArray(CFArrayRef inArray)

   214 {

   215     CFIndex size = CFArrayGetCount(inArray);

   216     SAFEARRAY* sa = ::SafeArrayCreateVectorEx(VT_UNKNOWN, 0, (ULONG) size, (LPVOID)&IID_IUnknown);

   217     long count = 0;

   218     for (CFIndex i=0; i<size; i++) {

   219         IUnknown* item = (IUnknown*) CFArrayGetValueAtIndex(inArray, i);

   220         ::SafeArrayPutElement(sa, &count, item);    // SafeArrayPutElement() adds a reference to the IUnknown added

   221         count++;

   222     }

   223     return sa;

   224 }

   225 

   226 CFArrayRef MarshallingHelpers::safeArrayToStringArray(SAFEARRAY* inArray)

   227 {

   228     long lBound=0, uBound=-1;

   229     HRESULT hr = ::SafeArrayGetLBound(inArray, 1, &lBound);

   230     if (SUCCEEDED(hr))

   231         hr = ::SafeArrayGetUBound(inArray, 1, &uBound);

   232     long len = (SUCCEEDED(hr)) ? (uBound-lBound+1) : 0;

   233     CFStringRef* items = 0;

   234     if (len > 0) {

   235         items = new CFStringRef[len];

   236         for (; lBound <= uBound; lBound++) {

   237             BSTR str;

   238             hr = ::SafeArrayGetElement(inArray, &lBound, &str);

   239             items[lBound] = BSTRToCFStringRef(str);

   240             SysFreeString(str);

   241         }

   242     }

   243     CFArrayRef result = CFArrayCreate(0, (const void**)items, len, &kCFTypeArrayCallBacks);

   244     if (items)

   245         delete[] items;

   246     return result;

   247 }

   248 

   249 CFArrayRef MarshallingHelpers::safeArrayToIntArray(SAFEARRAY* inArray)

   250 {

   251     long lBound=0, uBound=-1;

   252     HRESULT hr = ::SafeArrayGetLBound(inArray, 1, &lBound);

   253     if (SUCCEEDED(hr))

   254         hr = ::SafeArrayGetUBound(inArray, 1, &uBound);

   255     long len = (SUCCEEDED(hr)) ? (uBound-lBound+1) : 0;

   256     CFNumberRef* items = 0;

   257     if (len > 0) {

   258         items = new CFNumberRef[len];

   259         for (; lBound <= uBound; lBound++) {

   260             int num;

   261             hr = ::SafeArrayGetElement(inArray, &lBound, &num);

   262             items[lBound] = intToCFNumberRef(num);

   263         }

   264     }

   265     CFArrayRef result = CFArrayCreate(0, (const void**) items, len, &kCFTypeArrayCallBacks);

   266     if (items)

   267         delete[] items;

   268     return result;

   269 }

   270 

   271 CFArrayRef MarshallingHelpers::safeArrayToIUnknownArray(SAFEARRAY* inArray)

   272 {

   273     long lBound=0, uBound=-1;

   274     HRESULT hr = ::SafeArrayGetLBound(inArray, 1, &lBound);

   275     if (SUCCEEDED(hr))

   276         hr = ::SafeArrayGetUBound(inArray, 1, &uBound);

   277     long len = (SUCCEEDED(hr)) ? (uBound-lBound+1) : 0;

   278     void* items;

   279     hr = ::SafeArrayAccessData(inArray, &items);

   280     CFArrayRef result = CFArrayCreate(0, (const void**) items, len, &kIUnknownArrayCallBacks);

   281     hr = ::SafeArrayUnaccessData(inArray);

   282     return result;

   283 }

   284 

   285 const void* MarshallingHelpers::IUnknownRetainCallback(CFAllocatorRef /*allocator*/, const void* value)

   286 {

   287     ((IUnknown*) value)->AddRef();

   288     return value;

   289 }

   290 

   291 void MarshallingHelpers::IUnknownReleaseCallback(CFAllocatorRef /*allocator*/, const void* value)

   292 {

   293     ((IUnknown*) value)->Release();

   294 }