2011-06-09 Jay Civelli <jcivelli@chromium.org>
[WebKit-https.git] / Source / WebKit / chromium / src / WebPageSerializer.cpp
1 /*
2  * Copyright (C) 2009 Google 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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "WebPageSerializer.h"
33
34 #include "DocumentLoader.h"
35 #include "Element.h"
36 #include "Frame.h"
37 #include "HTMLAllCollection.h"
38 #include "HTMLFrameOwnerElement.h"
39 #include "HTMLInputElement.h"
40 #include "HTMLNames.h"
41 #include "KURL.h"
42 #include "MHTMLArchive.h"
43 #include "PageSerializer.h"
44 #include "Vector.h"
45
46 #include "WebCString.h"
47 #include "WebFrame.h"
48 #include "WebFrameImpl.h"
49 #include "WebPageSerializerClient.h"
50 #include "WebPageSerializerImpl.h"
51 #include "WebString.h"
52 #include "WebURL.h"
53 #include "WebVector.h"
54 #include "WebView.h"
55 #include "WebViewImpl.h"
56
57 #include <wtf/text/StringConcatenate.h>
58
59 using namespace WebCore;
60
61 namespace {
62
63 KURL getSubResourceURLFromElement(Element* element)
64 {
65     ASSERT(element);
66     const QualifiedName* attributeName = 0;
67     if (element->hasTagName(HTMLNames::imgTag) || element->hasTagName(HTMLNames::scriptTag))
68         attributeName = &HTMLNames::srcAttr;
69     else if (element->hasTagName(HTMLNames::inputTag)) {
70         HTMLInputElement* input = static_cast<HTMLInputElement*>(element);
71         if (input->isImageButton())
72             attributeName = &HTMLNames::srcAttr;
73     } else if (element->hasTagName(HTMLNames::bodyTag)
74                || element->hasTagName(HTMLNames::tableTag)
75                || element->hasTagName(HTMLNames::trTag)
76                || element->hasTagName(HTMLNames::tdTag))
77         attributeName = &HTMLNames::backgroundAttr;
78     else if (element->hasTagName(HTMLNames::blockquoteTag)
79              || element->hasTagName(HTMLNames::qTag)
80              || element->hasTagName(HTMLNames::delTag)
81              || element->hasTagName(HTMLNames::insTag))
82         attributeName = &HTMLNames::citeAttr;
83     else if (element->hasTagName(HTMLNames::linkTag)) {
84         // If the link element is not css, ignore it.
85         if (equalIgnoringCase(element->getAttribute(HTMLNames::typeAttr), "text/css")) {
86             // FIXME: Add support for extracting links of sub-resources which
87             // are inside style-sheet such as @import, @font-face, url(), etc.
88             attributeName = &HTMLNames::hrefAttr;
89         }
90     } else if (element->hasTagName(HTMLNames::objectTag))
91         attributeName = &HTMLNames::dataAttr;
92     else if (element->hasTagName(HTMLNames::embedTag))
93         attributeName = &HTMLNames::srcAttr;
94
95     if (!attributeName)
96         return KURL();
97
98     String value = element->getAttribute(*attributeName);
99     // Ignore javascript content.
100     if (value.isEmpty() || value.stripWhiteSpace().startsWith("javascript:", false))
101         return KURL();
102   
103     return element->document()->completeURL(value);
104 }
105
106 void retrieveResourcesForElement(Element* element,
107                                  Vector<Frame*>* visitedFrames,
108                                  Vector<Frame*>* framesToVisit,
109                                  Vector<KURL>* frameURLs,
110                                  Vector<KURL>* resourceURLs)
111 {
112     // If the node is a frame, we'll process it later in retrieveResourcesForFrame.
113     if ((element->hasTagName(HTMLNames::iframeTag) || element->hasTagName(HTMLNames::frameTag)
114         || element->hasTagName(HTMLNames::objectTag) || element->hasTagName(HTMLNames::embedTag))
115             && element->isFrameOwnerElement()) {
116         Frame* frame = static_cast<HTMLFrameOwnerElement*>(element)->contentFrame();
117         if (frame) {
118             if (!visitedFrames->contains(frame))
119                 framesToVisit->append(frame);
120             return;
121         }
122     }
123
124     KURL url = getSubResourceURLFromElement(element);
125     if (url.isEmpty() || !url.isValid())
126         return; // No subresource for this node.
127
128     // Ignore URLs that have a non-standard protocols. Since the FTP protocol
129     // does no have a cache mechanism, we skip it as well.
130     if (!url.protocolInHTTPFamily() && !url.isLocalFile())
131         return;
132
133     if (!resourceURLs->contains(url))
134         resourceURLs->append(url);
135 }
136
137 void retrieveResourcesForFrame(Frame* frame,
138                                const WebKit::WebVector<WebKit::WebCString>& supportedSchemes,
139                                Vector<Frame*>* visitedFrames,
140                                Vector<Frame*>* framesToVisit,
141                                Vector<KURL>* frameURLs,
142                                Vector<KURL>* resourceURLs)
143 {
144     KURL frameURL = frame->loader()->documentLoader()->request().url();
145
146     // If the frame's URL is invalid, ignore it, it is not retrievable.
147     if (!frameURL.isValid())
148         return;
149
150     // Ignore frames from unsupported schemes.
151     bool isValidScheme = false;
152     for (size_t i = 0; i < supportedSchemes.size(); ++i) {
153         if (frameURL.protocolIs(static_cast<CString>(supportedSchemes[i]).data())) {
154             isValidScheme = true;
155             break;
156         }
157     }
158     if (!isValidScheme)
159         return;
160
161     // If we have already seen that frame, ignore it.
162     if (visitedFrames->contains(frame))
163         return;
164     visitedFrames->append(frame);
165     if (!frameURLs->contains(frameURL))
166         frameURLs->append(frameURL);
167   
168     // Now get the resources associated with each node of the document.
169     RefPtr<HTMLAllCollection> allNodes = frame->document()->all();
170     for (unsigned i = 0; i < allNodes->length(); ++i) {
171         Node* node = allNodes->item(i);
172         // We are only interested in HTML resources.
173         if (!node->isElementNode())
174             continue;
175         retrieveResourcesForElement(static_cast<Element*>(node),
176                                     visitedFrames, framesToVisit,
177                                     frameURLs, resourceURLs);
178     }
179 }
180
181 } // namespace
182
183 namespace WebKit {
184
185 void WebPageSerializer::serialize(WebView* view, WebVector<WebPageSerializer::Resource>* resourcesParam)
186 {
187     Vector<PageSerializer::Resource> resources;
188     PageSerializer serializer(&resources);
189     serializer.serialize(static_cast<WebViewImpl*>(view)->page());
190
191     Vector<Resource> result;
192     for (Vector<PageSerializer::Resource>::const_iterator iter = resources.begin(); iter != resources.end(); ++iter) {
193         Resource resource;
194         resource.url = iter->url;
195         resource.mimeType = iter->mimeType.ascii();
196         resource.data = iter->data;
197         result.append(resource);
198     }
199     *resourcesParam = result;         
200 }
201
202 WebData WebPageSerializer::serializeToMHTML(WebView* view)
203 {
204     return MHTMLArchive::generateMHTMLData(static_cast<WebViewImpl*>(view)->page());
205 }
206
207 bool WebPageSerializer::serialize(WebFrame* frame,
208                                   bool recursive,
209                                   WebPageSerializerClient* client,
210                                   const WebVector<WebURL>& links,
211                                   const WebVector<WebString>& localPaths,
212                                   const WebString& localDirectoryName)
213 {
214     WebPageSerializerImpl serializerImpl(
215         frame, recursive, client, links, localPaths, localDirectoryName);
216     return serializerImpl.serialize();
217 }
218
219 bool WebPageSerializer::retrieveAllResources(WebView* view,
220                                              const WebVector<WebCString>& supportedSchemes,
221                                              WebVector<WebURL>* resourceURLs,
222                                              WebVector<WebURL>* frameURLs) {
223     WebFrameImpl* mainFrame = static_cast<WebFrameImpl*>(view->mainFrame());
224     if (!mainFrame)
225         return false;
226
227     Vector<Frame*> framesToVisit;
228     Vector<Frame*> visitedFrames;
229     Vector<KURL> frameKURLs;
230     Vector<KURL> resourceKURLs;
231     
232     // Let's retrieve the resources from every frame in this page.
233     framesToVisit.append(mainFrame->frame());
234     while (!framesToVisit.isEmpty()) {
235         Frame* frame = framesToVisit[0];
236         framesToVisit.remove(0);
237         retrieveResourcesForFrame(frame, supportedSchemes,
238                                   &visitedFrames, &framesToVisit,
239                                   &frameKURLs, &resourceKURLs);
240     }
241
242     // Converts the results to WebURLs.
243     WebVector<WebURL> resultResourceURLs(resourceKURLs.size());
244     for (size_t i = 0; i < resourceKURLs.size(); ++i) {
245         resultResourceURLs[i] = resourceKURLs[i];
246         // A frame's src can point to the same URL as another resource, keep the
247         // resource URL only in such cases.
248         size_t index = frameKURLs.find(resourceKURLs[i]);
249         if (index != notFound)
250             frameKURLs.remove(index);
251     }
252     *resourceURLs = resultResourceURLs;
253     WebVector<WebURL> resultFrameURLs(frameKURLs.size());
254     for (size_t i = 0; i < frameKURLs.size(); ++i)
255         resultFrameURLs[i] = frameKURLs[i];
256     *frameURLs = resultFrameURLs;
257     
258     return true;
259 }
260
261 WebString WebPageSerializer::generateMetaCharsetDeclaration(const WebString& charset)
262 {
263     return makeString("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=", static_cast<const String&>(charset), "\">");
264 }
265
266 WebString WebPageSerializer::generateMarkOfTheWebDeclaration(const WebURL& url)
267 {
268     return String::format("\n<!-- saved from url=(%04d)%s -->\n",
269                           static_cast<int>(url.spec().length()),
270                           url.spec().data());
271 }
272
273 WebString WebPageSerializer::generateBaseTagDeclaration(const WebString& baseTarget)
274 {
275     if (baseTarget.isEmpty())
276         return makeString("<base href=\".\">");
277     return makeString("<base href=\".\" target=\"", static_cast<const String&>(baseTarget), "\">");
278 }
279
280 } // namespace WebKit