6b34bcafbc070b760862b3d852c24a385784bb80
[WebKit-https.git] / WebCore / bindings / js / JSHTMLDocumentCustom.cpp
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  * 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 "JSHTMLDocument.h"
28
29 #include "CharacterNames.h"
30 #include "Frame.h"
31 #include "HTMLBodyElement.h"
32 #include "HTMLCollection.h"
33 #include "HTMLDocument.h"
34 #include "HTMLElement.h"
35 #include "HTMLIFrameElement.h"
36 #include "HTMLNames.h"
37 #include "JSDOMWindow.h"
38 #include "JSDOMWindowCustom.h"
39 #include "JSDOMWindowShell.h"
40 #include "JSHTMLCollection.h"
41 #include "SegmentedString.h"
42 #include "Tokenizer.h"
43 #include <runtime/Error.h>
44
45 using namespace JSC;
46
47 namespace WebCore {
48
49 using namespace HTMLNames;
50
51 bool JSHTMLDocument::canGetItemsForName(ExecState*, HTMLDocument* document, const Identifier& propertyName)
52 {
53     AtomicStringImpl* atomicPropertyName = AtomicString::find(propertyName);
54     return atomicPropertyName && (document->hasNamedItem(atomicPropertyName) || document->hasExtraNamedItem(atomicPropertyName));
55 }
56
57 JSValuePtr JSHTMLDocument::nameGetter(ExecState* exec, const Identifier& propertyName, const PropertySlot& slot)
58 {
59     JSHTMLDocument* thisObj = static_cast<JSHTMLDocument*>(asObject(slot.slotBase()));
60     HTMLDocument* document = static_cast<HTMLDocument*>(thisObj->impl());
61
62     String name = propertyName;
63     RefPtr<HTMLCollection> collection = document->documentNamedItems(name);
64
65     unsigned length = collection->length();
66     if (!length)
67         return jsUndefined();
68
69     if (length == 1) {
70         Node* node = collection->firstItem();
71
72         Frame* frame;
73         if (node->hasTagName(iframeTag) && (frame = static_cast<HTMLIFrameElement*>(node)->contentFrame()))
74             return toJS(exec, frame);
75
76         return toJS(exec, node);
77     } 
78
79     return toJS(exec, collection.get());
80 }
81
82 // Custom attributes
83
84 JSValuePtr JSHTMLDocument::all(ExecState* exec) const
85 {
86     // If "all" has been overwritten, return the overwritten value
87     JSValuePtr v = getDirect(Identifier(exec, "all"));
88     if (v)
89         return v;
90
91     return toJS(exec, static_cast<HTMLDocument*>(impl())->all().get());
92 }
93
94 void JSHTMLDocument::setAll(ExecState* exec, JSValuePtr value)
95 {
96     // Add "all" to the property map.
97     putDirect(Identifier(exec, "all"), value);
98 }
99
100 // Custom functions
101
102 JSValuePtr JSHTMLDocument::open(ExecState* exec, const ArgList& args)
103 {
104     // For compatibility with other browsers, pass open calls with more than 2 parameters to the window.
105     if (args.size() > 2) {
106         Frame* frame = static_cast<HTMLDocument*>(impl())->frame();
107         if (frame) {
108             JSDOMWindowShell* wrapper = toJSDOMWindowShell(frame);
109             if (wrapper) {
110                 JSValuePtr function = wrapper->get(exec, Identifier(exec, "open"));
111                 CallData callData;
112                 CallType callType = function.getCallData(callData);
113                 if (callType == CallTypeNone)
114                     return throwError(exec, TypeError);
115                 return call(exec, function, callType, callData, wrapper, args);
116             }
117         }
118         return jsUndefined();
119     }
120
121     // document.open clobbers the security context of the document and
122     // aliases it with the active security context.
123     Document* activeDocument = asJSDOMWindow(exec->lexicalGlobalObject())->impl()->document();
124
125     // In the case of two parameters or fewer, do a normal document open.
126     static_cast<HTMLDocument*>(impl())->open(activeDocument);
127     return this;
128 }
129
130 enum NewlineRequirement { DoNotAddNewline, DoAddNewline };
131
132 static inline void documentWrite(ExecState* exec, const ArgList& args, HTMLDocument* document, NewlineRequirement addNewline)
133 {
134     // DOM only specifies single string argument, but browsers allow multiple or no arguments.
135
136     size_t size = args.size();
137
138     UString firstString = args.at(exec, 0).toString(exec);
139     SegmentedString segmentedString(firstString.data(), firstString.size());
140     Vector<UString> subsequentStrings; // Keeps strings alive until Tokenizer::write is called on them.
141     if (size != 1) {
142         if (!size)
143             segmentedString.clear();
144         else {
145             subsequentStrings.reserveInitialCapacity(size - 1);
146             for (size_t i = 1; i < size; ++i) {
147                 UString subsequentString = args.at(exec, i).toString(exec);
148                 segmentedString.append(SegmentedString(subsequentString.data(), subsequentString.size()));
149                 subsequentStrings.append(subsequentString);
150             }
151         }
152     }
153     if (addNewline)
154         segmentedString.append(SegmentedString(&newlineCharacter, 1));
155
156     Document* activeDocument = asJSDOMWindow(exec->lexicalGlobalObject())->impl()->document();
157     document->write(segmentedString, activeDocument);
158 }
159
160 JSValuePtr JSHTMLDocument::write(ExecState* exec, const ArgList& args)
161 {
162     documentWrite(exec, args, static_cast<HTMLDocument*>(impl()), DoNotAddNewline);
163     return jsUndefined();
164 }
165
166 JSValuePtr JSHTMLDocument::writeln(ExecState* exec, const ArgList& args)
167 {
168     documentWrite(exec, args, static_cast<HTMLDocument*>(impl()), DoAddNewline);
169     return jsUndefined();
170 }
171
172 } // namespace WebCore