WebKit/mac/WebView/WebHTMLRepresentation.mm

   1 /*
   2  * Copyright (C) 2005, 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  *
   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 #import "WebHTMLRepresentation.h"
  30
  31 #import "DOMNodeInternal.h"
  32 #import "DOMRangeInternal.h"
  33 #import "WebArchive.h"
  34 #import "WebBasePluginPackage.h"
  35 #import "WebDataSourceInternal.h"
  36 #import "WebDocumentPrivate.h"
  37 #import "WebFrameBridge.h"
  38 #import "WebFrameInternal.h"
  39 #import "WebKitNSStringExtras.h"
  40 #import "WebKitStatisticsPrivate.h"
  41 #import "WebNSAttributedStringExtras.h"
  42 #import "WebNSObjectExtras.h"
  43 #import "WebResourcePrivate.h"
  44 #import "WebView.h"
  45 #import <Foundation/NSURLResponse.h>
  46 #import <JavaScriptCore/Assertions.h>
  47 #import <WebCore/Document.h>
  48 #import <WebCore/DocumentLoader.h>
  49 #import <WebCore/Frame.h>
  50 #import <WebCore/FrameLoader.h>
  51 #import <WebCore/MIMETypeRegistry.h>
  52 #import <WebCore/Range.h>
  53
  54 using namespace WebCore;
  55
  56 @interface WebHTMLRepresentationPrivate : NSObject
  57 {
  58 @public
  59     WebDataSource *dataSource;
  60     WebFrameBridge *bridge;
  61     NSData *parsedArchiveData;
  62
  63     BOOL hasSentResponseToPlugin;
  64     id <WebPluginManualLoader> manualLoader;
  65     NSView *pluginView;
  66 }
  67 @end
  68
  69 @implementation WebHTMLRepresentationPrivate
  70
  71 - (void)dealloc
  72 {
  73     [parsedArchiveData release];
  74     [super dealloc];
  75 }
  76
  77 @end
  78
  79 @implementation WebHTMLRepresentation
  80
  81 static NSArray *stringArray(const HashSet<String>& set)
  82 {
  83     NSMutableArray *array = [NSMutableArray arrayWithCapacity:set.size()];
  84     HashSet<String>::const_iterator end = set.end();
  85     for (HashSet<String>::const_iterator it = set.begin(); it != end; ++it)
  86         [array addObject:(NSString *)(*it)];
  87     return array;
  88 }
  89
  90 static NSArray *concatenateArrays(NSArray *first, NSArray *second)
  91 {
  92     NSMutableArray *result = [[first mutableCopy] autorelease];
  93     [result addObjectsFromArray:second];
  94     return result;
  95 }
  96
  97 + (NSArray *)supportedMIMETypes
  98 {
  99     static RetainPtr<NSArray> staticSupportedMIMETypes =
 100         concatenateArrays([self supportedNonImageMIMETypes], [self supportedImageMIMETypes]);
 101     return staticSupportedMIMETypes.get();
 102 }
 103
 104 + (NSArray *)supportedNonImageMIMETypes
 105 {
 106     static RetainPtr<NSArray> staticSupportedNonImageMIMETypes =
 107         stringArray(MIMETypeRegistry::getSupportedNonImageMIMETypes());
 108     return staticSupportedNonImageMIMETypes.get();
 109 }
 110
 111 + (NSArray *)supportedImageMIMETypes
 112 {
 113     static RetainPtr<NSArray> staticSupportedImageMIMETypes =
 114         stringArray(MIMETypeRegistry::getSupportedImageMIMETypes());
 115     return staticSupportedImageMIMETypes.get();
 116 }
 117
 118 - init
 119 {
 120     self = [super init];
 121     if (!self)
 122         return nil;
 123
 124     _private = [[WebHTMLRepresentationPrivate alloc] init];
 125
 126     ++WebHTMLRepresentationCount;
 127
 128     return self;
 129 }
 130
 131 - (void)dealloc
 132 {
 133     --WebHTMLRepresentationCount;
 134
 135     [_private release];
 136
 137     [super dealloc];
 138 }
 139
 140 - (void)finalize
 141 {
 142     --WebHTMLRepresentationCount;
 143
 144     [super finalize];
 145 }
 146
 147 - (WebFrameBridge *)_bridge
 148 {
 149     return _private->bridge;
 150 }
 151
 152 - (void)_redirectDataToManualLoader:(id<WebPluginManualLoader>)manualLoader forPluginView:(NSView *)pluginView;
 153 {
 154     _private->manualLoader = manualLoader;
 155     _private->pluginView = pluginView;
 156 }
 157
 158 - (void)setDataSource:(WebDataSource *)dataSource
 159 {
 160     _private->dataSource = dataSource;
 161     _private->bridge = [[dataSource webFrame] _bridge];
 162 }
 163
 164 - (BOOL)_isDisplayingWebArchive
 165 {
 166     return [[[_private->dataSource response] MIMEType] _webkit_isCaseInsensitiveEqualToString:@"application/x-webarchive"];
 167 }
 168
 169 - (void)receivedData:(NSData *)data withDataSource:(WebDataSource *)dataSource
 170 {
 171     if ([dataSource webFrame] && ![self _isDisplayingWebArchive]) {
 172         if (!_private->pluginView)
 173             [_private->bridge receivedData:data textEncodingName:[[_private->dataSource response] textEncodingName]];
 174
 175         if (_private->pluginView) {
 176             if (!_private->hasSentResponseToPlugin) {
 177                 [_private->manualLoader pluginView:_private->pluginView receivedResponse:[dataSource response]];
 178                 _private->hasSentResponseToPlugin = YES;
 179             }
 180
 181             [_private->manualLoader pluginView:_private->pluginView receivedData:data];
 182         }
 183     }
 184 }
 185
 186 - (void)receivedError:(NSError *)error withDataSource:(WebDataSource *)dataSource
 187 {
 188     if (_private->pluginView) {
 189         [_private->manualLoader pluginView:_private->pluginView receivedError:error];
 190     }
 191 }
 192
 193 - (void)_loadDataSourceAsWebArchive
 194 {
 195     WebArchive *archive = [[WebArchive alloc] initWithData:[_private->dataSource data]];
 196     WebResource *mainResource = [archive mainResource];
 197     if (!mainResource) {
 198         [archive release];
 199         return;
 200     }
 201
 202     NSData *data = [mainResource data];
 203     [data retain];
 204     [_private->parsedArchiveData release];
 205     _private->parsedArchiveData = data;
 206
 207     [_private->dataSource _addToUnarchiveState:archive];
 208     [archive release];
 209
 210     WebFrame *webFrame = [_private->dataSource webFrame];
 211
 212     if (!webFrame)
 213         return;
 214
 215     core(webFrame)->loader()->continueLoadWithData(SharedBuffer::wrapNSData(data).get(), [mainResource MIMEType], [mainResource textEncodingName], [mainResource URL]);
 216 }
 217
 218 - (void)finishedLoadingWithDataSource:(WebDataSource *)dataSource
 219 {
 220     WebFrame *frame = [dataSource webFrame];
 221
 222     if (_private->pluginView) {
 223         [_private->manualLoader pluginViewFinishedLoading:_private->pluginView];
 224         return;
 225     }
 226
 227     if (frame) {
 228         if ([self _isDisplayingWebArchive])
 229             [self _loadDataSourceAsWebArchive];
 230         else
 231             // Telling the bridge we received some data and passing nil as the data is our
 232             // way to get work done that is normally done when the first bit of data is
 233             // received, even for the case of a document with no data (like about:blank).
 234             [_private->bridge receivedData:nil textEncodingName:[[_private->dataSource response] textEncodingName]];
 235
 236         WebView *webView = [frame webView];
 237         if ([webView isEditable])
 238             core(frame)->applyEditingStyleToBodyElement();
 239     }
 240 }
 241
 242 - (BOOL)canProvideDocumentSource
 243 {
 244     return [_private->bridge canProvideDocumentSource];
 245 }
 246
 247 - (BOOL)canSaveAsWebArchive
 248 {
 249     return [_private->bridge canSaveAsWebArchive];
 250 }
 251
 252 - (NSString *)documentSource
 253 {
 254     if ([self _isDisplayingWebArchive])
 255         return [[[NSString alloc] initWithData:_private->parsedArchiveData encoding:NSUTF8StringEncoding] autorelease];
 256
 257     return [_private->bridge stringWithData:[_private->dataSource data]];
 258 }
 259
 260 - (NSString *)title
 261 {
 262     return nsStringNilIfEmpty([_private->dataSource _documentLoader]->title());
 263 }
 264
 265 - (DOMDocument *)DOMDocument
 266 {
 267     return [[_private->bridge webFrame] DOMDocument];
 268 }
 269
 270 - (NSAttributedString *)attributedText
 271 {
 272     // FIXME: Implement
 273     return nil;
 274 }
 275
 276 - (NSAttributedString *)attributedStringFrom:(DOMNode *)startNode startOffset:(int)startOffset to:(DOMNode *)endNode endOffset:(int)endOffset
 277 {
 278     return [NSAttributedString _web_attributedStringFromRange:Range::create([startNode _node]->document(), [startNode _node], startOffset, [endNode _node], endOffset).get()];
 279 }
 280
 281 - (DOMElement *)elementWithName:(NSString *)name inForm:(DOMElement *)form
 282 {
 283     return [_private->bridge elementWithName:name inForm:form];
 284 }
 285
 286 - (BOOL)elementDoesAutoComplete:(DOMElement *)element
 287 {
 288     return [_private->bridge elementDoesAutoComplete:element];
 289 }
 290
 291 - (BOOL)elementIsPassword:(DOMElement *)element
 292 {
 293     return [_private->bridge elementIsPassword:element];
 294 }
 295
 296 - (DOMElement *)formForElement:(DOMElement *)element
 297 {
 298     return [_private->bridge formForElement:element];
 299 }
 300
 301 - (DOMElement *)currentForm
 302 {
 303     return [_private->bridge currentForm];
 304 }
 305
 306 - (NSArray *)controlsInForm:(DOMElement *)form
 307 {
 308     return [_private->bridge controlsInForm:form];
 309 }
 310
 311 - (NSString *)searchForLabels:(NSArray *)labels beforeElement:(DOMElement *)element
 312 {
 313     return [_private->bridge searchForLabels:labels beforeElement:element];
 314 }
 315
 316 - (NSString *)matchLabels:(NSArray *)labels againstElement:(DOMElement *)element
 317 {
 318     return [_private->bridge matchLabels:labels againstElement:element];
 319 }
 320
 321 @end