1 /*

     2  * Copyright (C) 2007, 2008, 2009 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  *

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

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

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

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

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

    13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    14  *     its contributors may be used to endorse or promote products derived

    15  *     from this software without specific prior written permission. 

    16  *

    17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

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

    19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

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

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

    27  */

    28 

    29 #include "config.h"

    30 #include "LayoutTestController.h"

    31 

    32 #include "WorkQueue.h"

    33 #include "WorkQueueItem.h"

    34 #include <cstring>

    35 #include <JavaScriptCore/JSContextRef.h>

    36 #include <JavaScriptCore/JSObjectRef.h>

    37 #include <JavaScriptCore/JSRetainPtr.h>

    38 #include <stdio.h>

    39 #include <wtf/Assertions.h>

    40 #include <wtf/MathExtras.h>

    41 #include <wtf/RefPtr.h>

    42 

    43 LayoutTestController::LayoutTestController(const std::string& testPathOrURL, const std::string& expectedPixelHash)

    44     : m_dumpAsPDF(false)

    45     , m_dumpAsText(false)

    46     , m_dumpBackForwardList(false)

    47     , m_dumpChildFrameScrollPositions(false)

    48     , m_dumpChildFramesAsText(false)

    49     , m_dumpDOMAsWebArchive(false)

    50     , m_dumpDatabaseCallbacks(false)

    51     , m_dumpEditingCallbacks(false)

    52     , m_dumpFrameLoadCallbacks(false)

    53     , m_dumpHistoryDelegateCallbacks(false)

    54     , m_dumpResourceLoadCallbacks(false)

    55     , m_dumpResourceResponseMIMETypes(false)

    56     , m_dumpSelectionRect(false)

    57     , m_dumpSourceAsWebArchive(false)

    58     , m_dumpStatusCallbacks(false)

    59     , m_dumpTitleChanges(false)

    60     , m_dumpIconChanges(false)

    61     , m_dumpVisitedLinksCallback(false)

    62     , m_dumpWillCacheResponse(false)

    63     , m_generatePixelResults(true)

    64     , m_callCloseOnWebViews(true)

    65     , m_canOpenWindows(false)

    66     , m_closeRemainingWindowsWhenComplete(true)

    67     , m_newWindowsCopyBackForwardList(false)

    68     , m_stopProvisionalFrameLoads(false)

    69     , m_testOnscreen(false)

    70     , m_testRepaint(false)

    71     , m_testRepaintSweepHorizontally(false)

    72     , m_waitToDump(false)

    73     , m_willSendRequestReturnsNull(false)

    74     , m_willSendRequestReturnsNullOnRedirect(false)

    75     , m_windowIsKey(true)

    76     , m_alwaysAcceptCookies(false)

    77     , m_globalFlag(false)

    78     , m_isGeolocationPermissionSet(false)

    79     , m_geolocationPermission(false)

    80     , m_handlesAuthenticationChallenges(false)

    81     , m_isPrinting(false)

    82     , m_deferMainResourceDataLoad(true)

    83     , m_testPathOrURL(testPathOrURL)

    84     , m_expectedPixelHash(expectedPixelHash)

    85 {

    86 }

    87 

    88 PassRefPtr<LayoutTestController> LayoutTestController::create(const std::string& testPathOrURL, const std::string& expectedPixelHash)

    89 {

    90     return adoptRef(new LayoutTestController(testPathOrURL, expectedPixelHash));

    91 }

    92 

    93 // Static Functions

    94 

    95 static JSValueRef dumpAsPDFCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

    96 {

    97     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

    98     controller->setDumpAsPDF(true);

    99     return JSValueMakeUndefined(context);

   100 }

   101 

   102 static JSValueRef dumpAsTextCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   103 {

   104     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   105     controller->setDumpAsText(true);

   106 

   107     // Optional paramater, describing whether it's allowed to dump pixel results in dumpAsText mode.

   108     controller->setGeneratePixelResults(argumentCount > 0 ? JSValueToBoolean(context, arguments[0]) : false);

   109 

   110     return JSValueMakeUndefined(context);

   111 }

   112 

   113 static JSValueRef dumpBackForwardListCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   114 {

   115     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   116     controller->setDumpBackForwardList(true);

   117     return JSValueMakeUndefined(context);

   118 }

   119 

   120 static JSValueRef dumpChildFramesAsTextCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   121 {

   122     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   123     controller->setDumpChildFramesAsText(true);

   124     return JSValueMakeUndefined(context);

   125 }

   126 

   127 static JSValueRef dumpChildFrameScrollPositionsCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   128 {

   129     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   130     controller->setDumpChildFrameScrollPositions(true);

   131     return JSValueMakeUndefined(context);

   132 }

   133 

   134 static JSValueRef dumpDatabaseCallbacksCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   135 {

   136     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   137     controller->setDumpDatabaseCallbacks(true);

   138     return JSValueMakeUndefined(context);

   139 }

   140 

   141 static JSValueRef dumpDOMAsWebArchiveCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   142 {

   143     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   144     controller->setDumpDOMAsWebArchive(true);

   145     return JSValueMakeUndefined(context);

   146 }

   147 

   148 static JSValueRef dumpEditingCallbacksCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   149 {

   150     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   151     controller->setDumpEditingCallbacks(true);

   152     return JSValueMakeUndefined(context);

   153 }

   154 

   155 static JSValueRef dumpFrameLoadCallbacksCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   156 {

   157     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   158     controller->setDumpFrameLoadCallbacks(true);

   159     return JSValueMakeUndefined(context);

   160 }

   161 

   162 static JSValueRef dumpResourceLoadCallbacksCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   163 {

   164     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   165     controller->setDumpResourceLoadCallbacks(true);

   166     return JSValueMakeUndefined(context);

   167 }

   168 

   169 static JSValueRef dumpResourceResponseMIMETypesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   170 {

   171     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   172     controller->setDumpResourceResponseMIMETypes(true);

   173     return JSValueMakeUndefined(context);

   174 }

   175 

   176 static JSValueRef dumpSelectionRectCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   177 {

   178     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   179     controller->setDumpSelectionRect(true);

   180     return JSValueMakeUndefined(context);

   181 }

   182 

   183 static JSValueRef dumpSourceAsWebArchiveCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   184 {

   185     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   186     controller->setDumpSourceAsWebArchive(true);

   187     return JSValueMakeUndefined(context);

   188 }

   189 

   190 static JSValueRef dumpStatusCallbacksCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   191 {

   192     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   193     controller->setDumpStatusCallbacks(true);

   194     return JSValueMakeUndefined(context);

   195 }

   196 

   197 static JSValueRef dumpTitleChangesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   198 {

   199     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   200     controller->setDumpTitleChanges(true);

   201     return JSValueMakeUndefined(context);

   202 }

   203 

   204 static JSValueRef dumpIconChangesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   205 {

   206     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   207     controller->setDumpIconChanges(true);

   208     return JSValueMakeUndefined(context);

   209 }

   210 

   211 static JSValueRef dumpWillCacheResponseCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   212 {

   213     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   214     controller->setDumpWillCacheResponse(true);

   215     return JSValueMakeUndefined(context);

   216 }

   217 

   218 static JSValueRef pathToLocalResourceCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   219 {

   220     if (argumentCount < 1)

   221         return JSValueMakeUndefined(context);

   222 

   223     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   224     JSRetainPtr<JSStringRef> localPath(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   225     ASSERT(!*exception);

   226 

   227     JSRetainPtr<JSStringRef> convertedPath(Adopt, controller->pathToLocalResource(context, localPath.get()));

   228     if (!convertedPath)

   229         return JSValueMakeUndefined(context);

   230 

   231     return JSValueMakeString(context, convertedPath.get());

   232 }

   233 

   234 static JSValueRef removeAllVisitedLinksCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   235 {

   236     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   237     controller->setDumpVisitedLinksCallback(true);

   238     controller->removeAllVisitedLinks();

   239     return JSValueMakeUndefined(context);

   240 }

   241 

   242 static JSValueRef repaintSweepHorizontallyCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   243 {

   244     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   245     controller->setTestRepaintSweepHorizontally(true);

   246     return JSValueMakeUndefined(context);

   247 }

   248 

   249 static JSValueRef setCallCloseOnWebViewsCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   250 {

   251     if (argumentCount < 1)

   252         return JSValueMakeUndefined(context);

   253 

   254     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   255     controller->setCallCloseOnWebViews(JSValueToBoolean(context, arguments[0]));

   256     return JSValueMakeUndefined(context);

   257 }

   258 

   259 static JSValueRef setCanOpenWindowsCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   260 {

   261     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   262     controller->setCanOpenWindows(true);

   263     return JSValueMakeUndefined(context);

   264 }

   265 

   266 static JSValueRef setCloseRemainingWindowsWhenCompleteCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   267 {

   268     if (argumentCount < 1)

   269         return JSValueMakeUndefined(context);

   270 

   271     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   272     controller->setCloseRemainingWindowsWhenComplete(JSValueToBoolean(context, arguments[0]));

   273     return JSValueMakeUndefined(context);

   274 }

   275 

   276 static JSValueRef testOnscreenCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   277 {

   278     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   279     controller->setTestOnscreen(true);

   280     return JSValueMakeUndefined(context);

   281 }

   282 

   283 static JSValueRef testRepaintCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   284 {

   285     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   286     controller->setTestRepaint(true);

   287     return JSValueMakeUndefined(context);

   288 }

   289 

   290 static JSValueRef addDisallowedURLCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   291 {

   292     // Has mac implementation

   293     if (argumentCount < 1)

   294         return JSValueMakeUndefined(context);

   295 

   296     JSRetainPtr<JSStringRef> url(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   297     ASSERT(!*exception);

   298 

   299     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   300     controller->addDisallowedURL(url.get());

   301 

   302     return JSValueMakeUndefined(context);

   303 }

   304 

   305 static JSValueRef callShouldCloseOnWebViewCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   306 {

   307     // Has mac & windows implementation

   308     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   309 

   310     return JSValueMakeBoolean(context, controller->callShouldCloseOnWebView());

   311 }

   312 

   313 static JSValueRef clearAllDatabasesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   314 {

   315     // Has mac & windows implementation

   316     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   317     controller->clearAllDatabases();

   318 

   319     return JSValueMakeUndefined(context);

   320 }

   321 

   322 static JSValueRef clearBackForwardListCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   323 {

   324     // Has mac & windows implementation

   325     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   326     controller->clearBackForwardList();

   327 

   328     return JSValueMakeUndefined(context);

   329 }

   330 

   331 static JSValueRef clearPersistentUserStyleSheetCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   332 {

   333     // Has mac & windows implementation

   334     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   335     controller->clearPersistentUserStyleSheet();

   336 

   337     return JSValueMakeUndefined(context);

   338 }

   339 

   340 static JSValueRef decodeHostNameCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   341 {

   342     // Has mac implementation

   343     if (argumentCount < 1)

   344         return JSValueMakeUndefined(context);

   345 

   346     JSRetainPtr<JSStringRef> name(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   347     ASSERT(!*exception);

   348 

   349     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   350     JSRetainPtr<JSStringRef> decodedHostName(Adopt, controller->copyDecodedHostName(name.get()));

   351     return JSValueMakeString(context, decodedHostName.get());

   352 }

   353 

   354 static JSValueRef disableImageLoadingCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   355 {

   356     // Has mac implementation, needs windows implementation

   357     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   358     controller->disableImageLoading();

   359     

   360     return JSValueMakeUndefined(context);

   361 }

   362 

   363 static JSValueRef dispatchPendingLoadRequestsCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   364 {

   365     // Has mac implementation, needs windows implementation

   366     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   367     controller->dispatchPendingLoadRequests();

   368     

   369     return JSValueMakeUndefined(context);

   370 }

   371 

   372 static JSValueRef displayCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   373 {

   374     // Has mac & windows implementation

   375     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   376     controller->display();

   377 

   378     return JSValueMakeUndefined(context);

   379 }

   380 

   381 static JSValueRef encodeHostNameCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   382 {

   383     // Has mac implementation

   384     if (argumentCount < 1)

   385         return JSValueMakeUndefined(context);

   386 

   387     JSRetainPtr<JSStringRef> name(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   388     ASSERT(!*exception);

   389 

   390     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   391     JSRetainPtr<JSStringRef> encodedHostName(Adopt, controller->copyEncodedHostName(name.get()));

   392     return JSValueMakeString(context, encodedHostName.get());

   393 }

   394 

   395 static JSValueRef execCommandCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   396 {

   397     // Has Mac & Windows implementations.

   398     if (argumentCount < 1)

   399         return JSValueMakeUndefined(context);

   400 

   401     JSRetainPtr<JSStringRef> name(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   402     ASSERT(!*exception);

   403 

   404     // Ignoring the second parameter (userInterface), as this command emulates a manual action.

   405 

   406     JSRetainPtr<JSStringRef> value;

   407     if (argumentCount >= 3) {

   408         value.adopt(JSValueToStringCopy(context, arguments[2], exception));

   409         ASSERT(!*exception);

   410     } else

   411         value.adopt(JSStringCreateWithUTF8CString(""));

   412 

   413 

   414     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   415     controller->execCommand(name.get(), value.get());

   416 

   417     return JSValueMakeUndefined(context);

   418 }

   419 

   420 static JSValueRef counterValueForElementByIdCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   421 {

   422     if (argumentCount < 1)

   423         return JSValueMakeUndefined(context);

   424 

   425     JSRetainPtr<JSStringRef> elementId(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   426     if (*exception)

   427         return JSValueMakeUndefined(context);

   428 

   429     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   430     JSRetainPtr<JSStringRef> counterValue(controller->counterValueForElementById(elementId.get()));

   431     if (!counterValue.get())

   432         return JSValueMakeUndefined(context);

   433     return JSValueMakeString(context, counterValue.get());

   434 }

   435 

   436 static JSValueRef grantDesktopNotificationPermissionCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   437 {

   438     // Has Windows implementation

   439     if (argumentCount < 1)

   440         return JSValueMakeUndefined(context);

   441 

   442     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   443 

   444     controller->grantDesktopNotificationPermission(JSValueToStringCopy(context, arguments[0], NULL));

   445         

   446     return JSValueMakeUndefined(context);

   447 }

   448 

   449 static JSValueRef isCommandEnabledCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   450 {

   451     // Has Mac implementation.

   452 

   453     if (argumentCount < 1)

   454         return JSValueMakeUndefined(context);

   455 

   456     JSRetainPtr<JSStringRef> name(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   457     ASSERT(!*exception);

   458 

   459     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   460 

   461     return JSValueMakeBoolean(context, controller->isCommandEnabled(name.get()));

   462 }

   463 

   464 static JSValueRef overridePreferenceCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   465 {

   466     if (argumentCount < 2)

   467         return JSValueMakeUndefined(context);

   468 

   469     JSRetainPtr<JSStringRef> key(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   470     ASSERT(!*exception);

   471     JSRetainPtr<JSStringRef> value(Adopt, JSValueToStringCopy(context, arguments[1], exception));

   472     ASSERT(!*exception);

   473 

   474     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   475     controller->overridePreference(key.get(), value.get());

   476 

   477     return JSValueMakeUndefined(context);

   478 }

   479 

   480 static JSValueRef keepWebHistoryCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   481 {

   482     // Has mac implementation

   483     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   484     controller->keepWebHistory();

   485 

   486     return JSValueMakeUndefined(context);

   487 }

   488 

   489 static JSValueRef computedStyleIncludingVisitedInfoCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   490 {

   491     if (argumentCount != 1)

   492         return JSValueMakeUndefined(context);

   493     

   494     // Has mac implementation

   495     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   496     return controller->computedStyleIncludingVisitedInfo(context, arguments[0]);

   497 }

   498 

   499 static JSValueRef layerTreeAsTextCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   500 {

   501     // Has mac & windows implementation

   502     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   503     return JSValueMakeString(context, controller->layerTreeAsText().get());

   504 }

   505 

   506 static JSValueRef notifyDoneCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   507 {

   508     // Has mac & windows implementation

   509     // May be able to be made platform independant by using shared WorkQueue

   510     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   511     controller->notifyDone();

   512     return JSValueMakeUndefined(context);

   513 }

   514 

   515 static bool parsePageParameters(JSContextRef context, int argumentCount, const JSValueRef* arguments, JSValueRef* exception, float& pageWidthInPixels, float& pageHeightInPixels)

   516 {

   517     pageWidthInPixels = LayoutTestController::maxViewWidth;

   518     pageHeightInPixels = LayoutTestController::maxViewHeight;

   519     switch (argumentCount) {

   520     case 2:

   521         pageWidthInPixels = static_cast<float>(JSValueToNumber(context, arguments[0], exception));

   522         if (*exception)

   523             return false;

   524         pageHeightInPixels = static_cast<float>(JSValueToNumber(context, arguments[1], exception));

   525         if (*exception)

   526             return false;

   527     case 0: // Fall through.

   528         break;

   529     default:

   530         return false;

   531     }

   532     return true;

   533 }

   534 

   535 // Caller needs to delete[] propertyName.

   536 static bool parsePagePropertyParameters(JSContextRef context, int argumentCount, const JSValueRef* arguments, JSValueRef* exception, char*& propertyName, int& pageNumber)

   537 {

   538     pageNumber = 0;

   539     switch (argumentCount) {

   540     case 2:

   541         pageNumber = static_cast<float>(JSValueToNumber(context, arguments[1], exception));

   542         if (*exception)

   543             return false;

   544         // Fall through.

   545     case 1: {

   546         JSRetainPtr<JSStringRef> propertyNameString(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   547         if (*exception)

   548             return false;

   549 

   550         size_t maxLength = JSStringGetMaximumUTF8CStringSize(propertyNameString.get());

   551         propertyName = new char[maxLength + 1];

   552         JSStringGetUTF8CString(propertyNameString.get(), propertyName, maxLength + 1);

   553         return true;

   554     }

   555     case 0:

   556     default:

   557         return false;

   558     }

   559 }

   560 

   561 static bool parsePageNumber(JSContextRef context, int argumentCount, const JSValueRef* arguments, JSValueRef* exception, int& pageNumber)

   562 {

   563     pageNumber = 0;

   564     switch (argumentCount) {

   565     case 1:

   566         pageNumber = static_cast<int>(JSValueToNumber(context, arguments[0], exception));

   567         if (*exception)

   568             return false;

   569         // Fall through.

   570     case 0:

   571         return true;

   572     default:

   573         return false;

   574     }

   575 }

   576 

   577 static bool parsePageNumberSizeMarings(JSContextRef context, int argumentCount, const JSValueRef* arguments, JSValueRef* exception, int& pageNumber, int& width, int& height, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)

   578 {

   579     pageNumber = 0;

   580     width = height = 0;

   581     marginTop = marginRight = marginBottom = marginLeft = 0;

   582 

   583     switch (argumentCount) {

   584     case 7:

   585         marginLeft = static_cast<int>(JSValueToNumber(context, arguments[6], exception));

   586         if (*exception)

   587             return false;

   588         // Fall through.

   589     case 6:

   590         marginBottom = static_cast<int>(JSValueToNumber(context, arguments[5], exception));

   591         if (*exception)

   592             return false;

   593         // Fall through.

   594     case 5:

   595         marginRight = static_cast<int>(JSValueToNumber(context, arguments[4], exception));

   596         if (*exception)

   597             return false;

   598         // Fall through.

   599     case 4:

   600         marginTop = static_cast<int>(JSValueToNumber(context, arguments[3], exception));

   601         if (*exception)

   602             return false;

   603         // Fall through.

   604     case 3:

   605         height = static_cast<int>(JSValueToNumber(context, arguments[2], exception));

   606         if (*exception)

   607             return false;

   608         // Fall through.

   609     case 2:

   610         width = static_cast<int>(JSValueToNumber(context, arguments[1], exception));

   611         if (*exception)

   612             return false;

   613         // Fall through.

   614     case 1:

   615         pageNumber = static_cast<int>(JSValueToNumber(context, arguments[0], exception));

   616         if (*exception)

   617             return false;

   618         // Fall through.

   619         return true;

   620     default:

   621         return false;

   622     }

   623 }

   624 

   625 static JSValueRef pageNumberForElementByIdCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   626 {

   627     float pageWidthInPixels = 0;

   628     float pageHeightInPixels = 0;

   629     if (!parsePageParameters(context, argumentCount - 1, arguments + 1, exception, pageWidthInPixels, pageHeightInPixels))

   630         return JSValueMakeUndefined(context);

   631 

   632     JSRetainPtr<JSStringRef> elementId(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   633     if (*exception)

   634         return JSValueMakeUndefined(context);

   635 

   636     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   637     int pageNumber = controller->pageNumberForElementById(elementId.get(), pageWidthInPixels, pageHeightInPixels);

   638     return JSValueMakeNumber(context, pageNumber);

   639 }

   640 

   641 static JSValueRef numberOfPagesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   642 {

   643     float pageWidthInPixels = 0;

   644     float pageHeightInPixels = 0;

   645     if (!parsePageParameters(context, argumentCount, arguments, exception, pageWidthInPixels, pageHeightInPixels))

   646         return JSValueMakeUndefined(context);

   647 

   648     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   649     return JSValueMakeNumber(context, controller->numberOfPages(pageWidthInPixels, pageHeightInPixels));

   650 }

   651 

   652 static JSValueRef pagePropertyCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   653 {

   654     char* propertyName = 0;

   655     int pageNumber = 0;

   656     if (!parsePagePropertyParameters(context, argumentCount, arguments, exception, propertyName, pageNumber))

   657         return JSValueMakeUndefined(context);

   658 

   659     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   660     JSValueRef value = JSValueMakeString(context, controller->pageProperty(propertyName, pageNumber).get());

   661 

   662     delete[] propertyName;

   663     return value;

   664 }

   665 

   666 static JSValueRef isPageBoxVisibleCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   667 {

   668     int pageNumber = 0;

   669     if (!parsePageNumber(context, argumentCount, arguments, exception, pageNumber))

   670         return JSValueMakeUndefined(context);

   671 

   672     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   673     return JSValueMakeBoolean(context, controller->isPageBoxVisible(pageNumber));

   674 }

   675 

   676 static JSValueRef pageSizeAndMarginsInPixelsCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   677 {

   678     int pageNumber = 0;

   679     int width = 0, height = 0;

   680     int marginTop = 0, marginRight = 0, marginBottom = 0, marginLeft = 0;

   681     if (!parsePageNumberSizeMarings(context, argumentCount, arguments, exception, pageNumber, width, height, marginTop, marginRight, marginBottom, marginLeft))

   682         return JSValueMakeUndefined(context);

   683 

   684     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   685     return JSValueMakeString(context, controller->pageSizeAndMarginsInPixels(pageNumber, width, height, marginTop, marginRight, marginBottom, marginLeft).get());

   686 }

   687 

   688 static JSValueRef queueBackNavigationCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   689 {

   690     // Has mac & windows implementation

   691     // May be able to be made platform independant by using shared WorkQueue

   692     if (argumentCount < 1)

   693         return JSValueMakeUndefined(context);

   694 

   695     double howFarBackDouble = JSValueToNumber(context, arguments[0], exception);

   696     ASSERT(!*exception);

   697 

   698     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   699     controller->queueBackNavigation(static_cast<int>(howFarBackDouble));

   700 

   701     return JSValueMakeUndefined(context);

   702 }

   703 

   704 static JSValueRef queueForwardNavigationCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   705 {

   706     // Has mac & windows implementation

   707     // May be able to be made platform independant by using shared WorkQueue

   708     if (argumentCount < 1)

   709         return JSValueMakeUndefined(context);

   710 

   711     double howFarForwardDouble = JSValueToNumber(context, arguments[0], exception);

   712     ASSERT(!*exception);

   713 

   714     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   715     controller->queueForwardNavigation(static_cast<int>(howFarForwardDouble));

   716 

   717     return JSValueMakeUndefined(context);

   718 }

   719 

   720 static JSValueRef queueLoadCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   721 {

   722     // Has mac & windows implementation

   723     // May be able to be made platform independant by using shared WorkQueue

   724     if (argumentCount < 1)

   725         return JSValueMakeUndefined(context);

   726 

   727     JSRetainPtr<JSStringRef> url(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   728     ASSERT(!*exception);

   729 

   730     JSRetainPtr<JSStringRef> target;

   731     if (argumentCount >= 2) {

   732         target.adopt(JSValueToStringCopy(context, arguments[1], exception));

   733         ASSERT(!*exception);

   734     } else

   735         target.adopt(JSStringCreateWithUTF8CString(""));

   736 

   737     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   738     controller->queueLoad(url.get(), target.get());

   739 

   740     return JSValueMakeUndefined(context);

   741 }

   742 

   743 static JSValueRef queueLoadHTMLStringCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   744 {

   745     // Has Mac & Windows implementation

   746     if (argumentCount < 1)

   747         return JSValueMakeUndefined(context);

   748 

   749     JSRetainPtr<JSStringRef> content(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   750     ASSERT(!*exception);

   751 

   752     JSRetainPtr<JSStringRef> baseURL;

   753     if (argumentCount >= 2) {

   754         baseURL.adopt(JSValueToStringCopy(context, arguments[1], exception));

   755         ASSERT(!*exception);

   756     } else

   757         baseURL.adopt(JSStringCreateWithUTF8CString(""));

   758 

   759     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   760     controller->queueLoadHTMLString(content.get(), baseURL.get());

   761 

   762     return JSValueMakeUndefined(context);

   763 }

   764 

   765 static JSValueRef queueReloadCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   766 {

   767     // Has mac & windows implementation

   768     // May be able to be made platform independant by using shared WorkQueue

   769 

   770     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   771     controller->queueReload();

   772 

   773     return JSValueMakeUndefined(context);

   774 }

   775 

   776 static JSValueRef queueLoadingScriptCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   777 {

   778     // Has mac & windows implementation

   779     // May be able to be made platform independant by using shared WorkQueue

   780     if (argumentCount < 1)

   781         return JSValueMakeUndefined(context);

   782 

   783     JSRetainPtr<JSStringRef> script(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   784     ASSERT(!*exception);

   785 

   786     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   787     controller->queueLoadingScript(script.get());

   788 

   789     return JSValueMakeUndefined(context);

   790 }

   791 

   792 static JSValueRef queueNonLoadingScriptCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   793 {

   794     // Has mac & windows implementation

   795     // May be able to be made platform independant by using shared WorkQueue

   796     if (argumentCount < 1)

   797         return JSValueMakeUndefined(context);

   798 

   799     JSRetainPtr<JSStringRef> script(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   800     ASSERT(!*exception);

   801 

   802     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   803     controller->queueNonLoadingScript(script.get());

   804 

   805     return JSValueMakeUndefined(context);

   806 }

   807 

   808 static JSValueRef setAcceptsEditingCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   809 {

   810     // Has mac & windows implementation

   811     if (argumentCount < 1)

   812         return JSValueMakeUndefined(context);

   813 

   814     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   815     controller->setAcceptsEditing(JSValueToBoolean(context, arguments[0]));

   816 

   817     return JSValueMakeUndefined(context);

   818 }

   819 

   820 static JSValueRef setAlwaysAcceptCookiesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   821 {

   822     // Has mac & windows implementation

   823     if (argumentCount < 1)

   824         return JSValueMakeUndefined(context);

   825 

   826     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   827     controller->setAlwaysAcceptCookies(JSValueToBoolean(context, arguments[0]));

   828 

   829     return JSValueMakeUndefined(context);

   830 }

   831 

   832 static JSValueRef setAppCacheMaximumSizeCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   833 {

   834     // Has mac implementation

   835     if (argumentCount < 1)

   836         return JSValueMakeUndefined(context);

   837 

   838     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   839 

   840     double size = JSValueToNumber(context, arguments[0], NULL);

   841     if (!isnan(size))

   842         controller->setAppCacheMaximumSize(static_cast<unsigned long long>(size));

   843         

   844     return JSValueMakeUndefined(context);

   845 

   846 }

   847 

   848 static JSValueRef setAuthenticationPasswordCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   849 {

   850     // Has mac & windows implementation

   851     if (argumentCount < 1)

   852         return JSValueMakeUndefined(context);

   853 

   854     JSRetainPtr<JSStringRef> password(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   855     ASSERT(!*exception);

   856 

   857     size_t maxLength = JSStringGetMaximumUTF8CStringSize(password.get());

   858     char* passwordBuffer = new char[maxLength + 1];

   859     JSStringGetUTF8CString(password.get(), passwordBuffer, maxLength + 1);

   860     

   861     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   862     controller->setAuthenticationPassword(passwordBuffer);

   863     delete[] passwordBuffer;

   864 

   865     return JSValueMakeUndefined(context);

   866 }

   867 

   868 static JSValueRef setAuthenticationUsernameCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   869 {

   870     // Has mac & windows implementation

   871     if (argumentCount < 1)

   872         return JSValueMakeUndefined(context);

   873 

   874     JSRetainPtr<JSStringRef> username(Adopt, JSValueToStringCopy(context, arguments[0], exception));

   875     ASSERT(!*exception);

   876 

   877     size_t maxLength = JSStringGetMaximumUTF8CStringSize(username.get());

   878     char* usernameBuffer = new char[maxLength + 1];

   879     JSStringGetUTF8CString(username.get(), usernameBuffer, maxLength + 1);

   880     

   881     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   882     controller->setAuthenticationUsername(usernameBuffer);

   883     delete[] usernameBuffer;

   884 

   885     return JSValueMakeUndefined(context);

   886 }

   887 

   888 static JSValueRef setAuthorAndUserStylesEnabledCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   889 {

   890     // Has mac & windows implementation

   891     if (argumentCount < 1)

   892         return JSValueMakeUndefined(context);

   893 

   894     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   895     controller->setAuthorAndUserStylesEnabled(JSValueToBoolean(context, arguments[0]));

   896 

   897     return JSValueMakeUndefined(context);

   898 }

   899 

   900 static JSValueRef setCacheModelCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   901 {

   902     // Has Mac implementation.

   903     if (argumentCount < 1)

   904         return JSValueMakeUndefined(context);

   905 

   906     int cacheModel = JSValueToNumber(context, arguments[0], exception);

   907     ASSERT(!*exception);

   908 

   909     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   910     controller->setCacheModel(cacheModel);

   911 

   912     return JSValueMakeUndefined(context);

   913 }

   914 

   915 static JSValueRef setCustomPolicyDelegateCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   916 {

   917     // Has mac implementation

   918     if (argumentCount < 1)

   919         return JSValueMakeUndefined(context);

   920     

   921     bool permissive = false;

   922     if (argumentCount >= 2)

   923         permissive = JSValueToBoolean(context, arguments[1]);

   924 

   925     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   926     controller->setCustomPolicyDelegate(JSValueToBoolean(context, arguments[0]), permissive);

   927 

   928     return JSValueMakeUndefined(context);

   929 }

   930 

   931 static JSValueRef setDatabaseQuotaCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   932 {

   933     // Has mac implementation

   934     if (argumentCount < 1)

   935         return JSValueMakeUndefined(context);

   936 

   937     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   938 

   939     double quota = JSValueToNumber(context, arguments[0], NULL);

   940     if (!isnan(quota))

   941         controller->setDatabaseQuota(static_cast<unsigned long long>(quota));

   942         

   943     return JSValueMakeUndefined(context);

   944 }

   945 

   946 static JSValueRef setDeferMainResourceDataLoadCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   947 {

   948     // Has Mac and Windows implementation

   949     if (argumentCount < 1)

   950         return JSValueMakeUndefined(context);

   951 

   952     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   953     controller->setDeferMainResourceDataLoad(JSValueToBoolean(context, arguments[0]));

   954 

   955     return JSValueMakeUndefined(context);

   956 }

   957 

   958 static JSValueRef setDomainRelaxationForbiddenForURLSchemeCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   959 {

   960     // Has Mac and Windows implementation

   961     if (argumentCount < 2)

   962         return JSValueMakeUndefined(context);

   963 

   964     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   965 

   966     bool forbidden = JSValueToBoolean(context, arguments[0]);

   967     JSRetainPtr<JSStringRef> scheme(Adopt, JSValueToStringCopy(context, arguments[1], 0));

   968     controller->setDomainRelaxationForbiddenForURLScheme(forbidden, scheme.get());

   969 

   970     return JSValueMakeUndefined(context);

   971 }

   972 

   973 static JSValueRef setMockGeolocationPositionCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   974 {

   975     if (argumentCount < 3)

   976         return JSValueMakeUndefined(context);

   977 

   978     LayoutTestController* controller = reinterpret_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   979     controller->setMockGeolocationPosition(JSValueToNumber(context, arguments[0], NULL),  // latitude

   980                                            JSValueToNumber(context, arguments[1], NULL),  // longitude

   981                                            JSValueToNumber(context, arguments[2], NULL));  // accuracy

   982 

   983     return JSValueMakeUndefined(context);

   984 }

   985 

   986 static JSValueRef setMockGeolocationErrorCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

   987 {

   988     if (argumentCount < 2)

   989         return JSValueMakeUndefined(context);

   990 

   991     int code = JSValueToNumber(context, arguments[0], NULL);

   992     JSRetainPtr<JSStringRef> message(Adopt, JSValueToStringCopy(context, arguments[1], exception));

   993     ASSERT(!*exception);

   994 

   995     LayoutTestController* controller = reinterpret_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

   996     controller->setMockGeolocationError(code, message.get());

   997 

   998     return JSValueMakeUndefined(context);

   999 }

  1000 

  1001 static JSValueRef setNewWindowsCopyBackForwardListCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1002 {

  1003     // Has mac implementation

  1004     if (argumentCount < 1)

  1005         return JSValueMakeUndefined(context);

  1006     

  1007     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1008     controller->setNewWindowsCopyBackForwardList(JSValueToBoolean(context, arguments[0]));

  1009 

  1010     return JSValueMakeUndefined(context);

  1011 }

  1012 

  1013 static JSValueRef setGeolocationPermissionCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1014 {

  1015     // Has mac implementation

  1016     if (argumentCount < 1)

  1017         return JSValueMakeUndefined(context);

  1018 

  1019     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1020     controller->setGeolocationPermission(JSValueToBoolean(context, arguments[0]));

  1021 

  1022     return JSValueMakeUndefined(context);

  1023 }

  1024 

  1025 static JSValueRef setHandlesAuthenticationChallengesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1026 {

  1027     // Has mac & windows implementation

  1028     if (argumentCount < 1)

  1029         return JSValueMakeUndefined(context);

  1030 

  1031     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1032     controller->setHandlesAuthenticationChallenges(JSValueToBoolean(context, arguments[0]));

  1033 

  1034     return JSValueMakeUndefined(context);

  1035 }

  1036 

  1037 static JSValueRef setPOSIXLocaleCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1038 {

  1039     if (argumentCount < 1)

  1040         return JSValueMakeUndefined(context);

  1041 

  1042     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1043     JSRetainPtr<JSStringRef> locale(Adopt, JSValueToStringCopy(context, arguments[0], exception));

  1044     ASSERT(!*exception);

  1045     controller->setPOSIXLocale(locale.get());

  1046 

  1047     return JSValueMakeUndefined(context);

  1048 }

  1049 

  1050 static JSValueRef setIconDatabaseEnabledCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1051 {

  1052     // Has mac & windows implementation

  1053     if (argumentCount < 1)

  1054         return JSValueMakeUndefined(context);

  1055 

  1056     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1057     controller->setIconDatabaseEnabled(JSValueToBoolean(context, arguments[0]));

  1058 

  1059     return JSValueMakeUndefined(context);

  1060 }

  1061 

  1062 static JSValueRef setJavaScriptProfilingEnabledCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1063 {

  1064     if (argumentCount < 1)

  1065         return JSValueMakeUndefined(context);

  1066 

  1067     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1068     controller->setJavaScriptProfilingEnabled(JSValueToBoolean(context, arguments[0]));

  1069 

  1070     return JSValueMakeUndefined(context);

  1071 }

  1072 

  1073 static JSValueRef setMainFrameIsFirstResponderCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1074 {

  1075     // Has mac implementation

  1076     if (argumentCount < 1)

  1077         return JSValueMakeUndefined(context);

  1078 

  1079     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1080     controller->setMainFrameIsFirstResponder(JSValueToBoolean(context, arguments[0]));

  1081 

  1082     return JSValueMakeUndefined(context);

  1083 }

  1084 

  1085 static JSValueRef setPersistentUserStyleSheetLocationCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1086 {

  1087     // Has mac implementation

  1088     if (argumentCount < 1)

  1089         return JSValueMakeUndefined(context);

  1090 

  1091     JSRetainPtr<JSStringRef> path(Adopt, JSValueToStringCopy(context, arguments[0], exception));

  1092     ASSERT(!*exception);

  1093 

  1094     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1095     controller->setPersistentUserStyleSheetLocation(path.get());

  1096 

  1097     return JSValueMakeUndefined(context);

  1098 }

  1099 

  1100 static JSValueRef setPrivateBrowsingEnabledCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1101 {

  1102     // Has mac & windows implementation

  1103     if (argumentCount < 1)

  1104         return JSValueMakeUndefined(context);

  1105 

  1106     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1107     controller->setPrivateBrowsingEnabled(JSValueToBoolean(context, arguments[0]));

  1108 

  1109     return JSValueMakeUndefined(context);

  1110 }

  1111 

  1112 static JSValueRef setJavaScriptCanAccessClipboardCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1113 {

  1114     // Has mac & windows implementation

  1115     if (argumentCount < 1)

  1116         return JSValueMakeUndefined(context);

  1117 

  1118     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1119     controller->setJavaScriptCanAccessClipboard(JSValueToBoolean(context, arguments[0]));

  1120 

  1121     return JSValueMakeUndefined(context);

  1122 }

  1123 

  1124 static JSValueRef setXSSAuditorEnabledCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)

  1125 {

  1126     // Has mac & windows implementation

  1127     if (argumentCount < 1)

  1128         return JSValueMakeUndefined(context);

  1129 

  1130     LayoutTestController* controller = static_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject));

  1131     controller->setXSSAuditorEnabled(JSValueToBoolean(context, arguments[0]));

  1132 

  1133     return JSValueMakeUndefined(context);

  1134 }

  1135