← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebCore/workers/WorkerScriptLoader.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebCore/workers/WorkerScriptLoader.cpp
 
1
/*
 
2
 * Copyright (C) 2009 Apple Inc. All Rights Reserved.
 
3
 * Copyright (C) 2009, 2011 Google Inc. All Rights Reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
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
 *
 
14
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 
15
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
16
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
17
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 
18
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
19
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
20
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
21
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 
22
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
23
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
24
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
25
 *
 
26
 */
 
27
 
 
28
#include "config.h"
 
29
 
 
30
#if ENABLE(WORKERS)
 
31
 
 
32
#include "WorkerScriptLoader.h"
 
33
 
 
34
#include "CrossThreadTask.h"
 
35
#include "ResourceResponse.h"
 
36
#include "ScriptExecutionContext.h"
 
37
#include "SecurityOrigin.h"
 
38
#include "TextResourceDecoder.h"
 
39
#include "WorkerContext.h"
 
40
#include "WorkerScriptLoaderClient.h"
 
41
#include "WorkerThreadableLoader.h"
 
42
 
 
43
#include <wtf/OwnPtr.h>
 
44
#include <wtf/RefPtr.h>
 
45
#include <wtf/UnusedParam.h>
 
46
 
 
47
namespace WebCore {
 
48
 
 
49
WorkerScriptLoader::WorkerScriptLoader()
 
50
    : m_client(0)
 
51
    , m_failed(false)
 
52
    , m_identifier(0)
 
53
    , m_finishing(false)
 
54
#if PLATFORM(CHROMIUM)
 
55
    , m_targetType(ResourceRequest::TargetIsWorker)
 
56
#endif
 
57
{
 
58
}
 
59
 
 
60
WorkerScriptLoader::~WorkerScriptLoader()
 
61
{
 
62
}
 
63
 
 
64
void WorkerScriptLoader::loadSynchronously(ScriptExecutionContext* scriptExecutionContext, const KURL& url, CrossOriginRequestPolicy crossOriginRequestPolicy)
 
65
{
 
66
    m_url = url;
 
67
 
 
68
    OwnPtr<ResourceRequest> request(createResourceRequest());
 
69
    if (!request)
 
70
        return;
 
71
 
 
72
    ASSERT(scriptExecutionContext->isWorkerContext());
 
73
 
 
74
    ThreadableLoaderOptions options;
 
75
    options.allowCredentials = AllowStoredCredentials;
 
76
    options.crossOriginRequestPolicy = crossOriginRequestPolicy;
 
77
    options.sendLoadCallbacks = SendCallbacks;
 
78
 
 
79
    WorkerThreadableLoader::loadResourceSynchronously(static_cast<WorkerContext*>(scriptExecutionContext), *request, *this, options);
 
80
}
 
81
    
 
82
void WorkerScriptLoader::loadAsynchronously(ScriptExecutionContext* scriptExecutionContext, const KURL& url, CrossOriginRequestPolicy crossOriginRequestPolicy, WorkerScriptLoaderClient* client)
 
83
{
 
84
    ASSERT(client);
 
85
    m_client = client;
 
86
    m_url = url;
 
87
 
 
88
    OwnPtr<ResourceRequest> request(createResourceRequest());
 
89
    if (!request)
 
90
        return;
 
91
 
 
92
    ThreadableLoaderOptions options;
 
93
    options.allowCredentials = AllowStoredCredentials;
 
94
    options.crossOriginRequestPolicy = crossOriginRequestPolicy;
 
95
    options.sendLoadCallbacks = SendCallbacks;
 
96
 
 
97
    // During create, callbacks may happen which remove the last reference to this object.
 
98
    RefPtr<WorkerScriptLoader> protect(this);
 
99
    m_threadableLoader = ThreadableLoader::create(scriptExecutionContext, this, *request, options);
 
100
}
 
101
 
 
102
const KURL& WorkerScriptLoader::responseURL() const
 
103
{
 
104
    ASSERT(!failed());
 
105
    return m_responseURL;
 
106
}
 
107
 
 
108
PassOwnPtr<ResourceRequest> WorkerScriptLoader::createResourceRequest()
 
109
{
 
110
    OwnPtr<ResourceRequest> request = adoptPtr(new ResourceRequest(m_url));
 
111
    request->setHTTPMethod("GET");
 
112
#if PLATFORM(CHROMIUM) || PLATFORM(BLACKBERRY)
 
113
    request->setTargetType(m_targetType);
 
114
#endif
 
115
    return request.release();
 
116
}
 
117
    
 
118
void WorkerScriptLoader::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
 
119
{
 
120
    if (response.httpStatusCode() / 100 != 2 && response.httpStatusCode()) {
 
121
        m_failed = true;
 
122
        return;
 
123
    }
 
124
    m_responseURL = response.url();
 
125
    m_responseEncoding = response.textEncodingName();
 
126
    if (m_client)
 
127
        m_client->didReceiveResponse(identifier, response);
 
128
}
 
129
 
 
130
void WorkerScriptLoader::didReceiveData(const char* data, int len)
 
131
{
 
132
    if (m_failed)
 
133
        return;
 
134
 
 
135
    if (!m_decoder) {
 
136
        if (!m_responseEncoding.isEmpty())
 
137
            m_decoder = TextResourceDecoder::create("text/javascript", m_responseEncoding);
 
138
        else
 
139
            m_decoder = TextResourceDecoder::create("text/javascript", "UTF-8");
 
140
    }
 
141
 
 
142
    if (!len)
 
143
        return;
 
144
    
 
145
    if (len == -1)
 
146
        len = strlen(data);
 
147
    
 
148
    m_script.append(m_decoder->decode(data, len));
 
149
}
 
150
 
 
151
void WorkerScriptLoader::didFinishLoading(unsigned long identifier, double)
 
152
{
 
153
    if (m_failed) {
 
154
        notifyError();
 
155
        return;
 
156
    }
 
157
 
 
158
    if (m_decoder)
 
159
        m_script.append(m_decoder->flush());
 
160
 
 
161
    m_identifier = identifier;
 
162
    notifyFinished();
 
163
}
 
164
 
 
165
void WorkerScriptLoader::didFail(const ResourceError&)
 
166
{
 
167
    notifyError();
 
168
}
 
169
 
 
170
void WorkerScriptLoader::didFailRedirectCheck()
 
171
{
 
172
    notifyError();
 
173
}
 
174
 
 
175
void WorkerScriptLoader::notifyError()
 
176
{
 
177
    m_failed = true;
 
178
    notifyFinished();
 
179
}
 
180
 
 
181
String WorkerScriptLoader::script()
 
182
{
 
183
    return m_script.toString();
 
184
}
 
185
 
 
186
void WorkerScriptLoader::notifyFinished()
 
187
{
 
188
    if (!m_client || m_finishing)
 
189
        return;
 
190
 
 
191
    m_finishing = true;
 
192
    m_client->notifyFinished();
 
193
}
 
194
 
 
195
} // namespace WebCore
 
196
 
 
197
#endif // ENABLE(WORKERS)