← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Source/WebKit/chromium/src/WebHistoryItem.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/WebKit/chromium/src/WebHistoryItem.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 "WebHistoryItem.h"
 
33
 
 
34
#include "FormController.h"
 
35
#include "FormData.h"
 
36
#include "HistoryItem.h"
 
37
#include "KURL.h"
 
38
#include "SerializedScriptValue.h"
 
39
#include "platform/WebSerializedScriptValue.h"
 
40
#include <public/WebHTTPBody.h>
 
41
#include <public/WebPoint.h>
 
42
#include <public/WebString.h>
 
43
#include <public/WebVector.h>
 
44
 
 
45
using namespace WebCore;
 
46
 
 
47
namespace WebKit {
 
48
 
 
49
void WebHistoryItem::initialize()
 
50
{
 
51
    m_private = HistoryItem::create();
 
52
}
 
53
 
 
54
void WebHistoryItem::reset()
 
55
{
 
56
    m_private.reset();
 
57
}
 
58
 
 
59
void WebHistoryItem::assign(const WebHistoryItem& other)
 
60
{
 
61
    m_private = other.m_private;
 
62
}
 
63
 
 
64
WebString WebHistoryItem::urlString() const
 
65
{
 
66
    return m_private->urlString();
 
67
}
 
68
 
 
69
void WebHistoryItem::setURLString(const WebString& url)
 
70
{
 
71
    ensureMutable();
 
72
    m_private->setURLString(KURL(ParsedURLString, url).string());
 
73
}
 
74
 
 
75
WebString WebHistoryItem::originalURLString() const
 
76
{
 
77
    return m_private->originalURLString();
 
78
}
 
79
 
 
80
void WebHistoryItem::setOriginalURLString(const WebString& originalURLString)
 
81
{
 
82
    ensureMutable();
 
83
    m_private->setOriginalURLString(originalURLString);
 
84
}
 
85
 
 
86
WebString WebHistoryItem::referrer() const
 
87
{
 
88
    return m_private->referrer();
 
89
}
 
90
 
 
91
void WebHistoryItem::setReferrer(const WebString& referrer)
 
92
{
 
93
    ensureMutable();
 
94
    m_private->setReferrer(referrer);
 
95
}
 
96
 
 
97
WebString WebHistoryItem::target() const
 
98
{
 
99
    return m_private->target();
 
100
}
 
101
 
 
102
void WebHistoryItem::setTarget(const WebString& target)
 
103
{
 
104
    ensureMutable();
 
105
    m_private->setTarget(target);
 
106
}
 
107
 
 
108
WebString WebHistoryItem::parent() const
 
109
{
 
110
    return m_private->parent();
 
111
}
 
112
 
 
113
void WebHistoryItem::setParent(const WebString& parent)
 
114
{
 
115
    ensureMutable();
 
116
    m_private->setParent(parent);
 
117
}
 
118
 
 
119
WebString WebHistoryItem::title() const
 
120
{
 
121
    return m_private->title();
 
122
}
 
123
 
 
124
void WebHistoryItem::setTitle(const WebString& title)
 
125
{
 
126
    ensureMutable();
 
127
    m_private->setTitle(title);
 
128
}
 
129
 
 
130
WebString WebHistoryItem::alternateTitle() const
 
131
{
 
132
    return m_private->alternateTitle();
 
133
}
 
134
 
 
135
void WebHistoryItem::setAlternateTitle(const WebString& alternateTitle)
 
136
{
 
137
    ensureMutable();
 
138
    m_private->setAlternateTitle(alternateTitle);
 
139
}
 
140
 
 
141
double WebHistoryItem::lastVisitedTime() const
 
142
{
 
143
    return m_private->lastVisitedTime();
 
144
}
 
145
 
 
146
void WebHistoryItem::setLastVisitedTime(double lastVisitedTime)
 
147
{
 
148
    ensureMutable();
 
149
    // FIXME: setLastVisitedTime increments the visit count, so we have to
 
150
    // correct for that.  Instead, we should have a back-door to just mutate
 
151
    // the last visited time directly.
 
152
    int count = m_private->visitCount();
 
153
    m_private->setLastVisitedTime(lastVisitedTime);
 
154
    m_private->setVisitCount(count);
 
155
}
 
156
 
 
157
WebPoint WebHistoryItem::scrollOffset() const
 
158
{
 
159
    return m_private->scrollPoint();
 
160
}
 
161
 
 
162
void WebHistoryItem::setScrollOffset(const WebPoint& scrollOffset)
 
163
{
 
164
    ensureMutable();
 
165
    m_private->setScrollPoint(scrollOffset);
 
166
}
 
167
 
 
168
float WebHistoryItem::pageScaleFactor() const
 
169
{
 
170
    return m_private->pageScaleFactor();
 
171
}
 
172
 
 
173
void WebHistoryItem::setPageScaleFactor(float scale)
 
174
{
 
175
    ensureMutable();
 
176
    m_private->setPageScaleFactor(scale);
 
177
}
 
178
 
 
179
bool WebHistoryItem::isTargetItem() const
 
180
{
 
181
    return m_private->isTargetItem();
 
182
}
 
183
 
 
184
void WebHistoryItem::setIsTargetItem(bool isTargetItem)
 
185
{
 
186
    ensureMutable();
 
187
    m_private->setIsTargetItem(isTargetItem);
 
188
}
 
189
 
 
190
int WebHistoryItem::visitCount() const
 
191
{
 
192
    return m_private->visitCount();
 
193
}
 
194
 
 
195
void WebHistoryItem::setVisitCount(int count)
 
196
{
 
197
    ensureMutable();
 
198
    m_private->setVisitCount(count);
 
199
}
 
200
 
 
201
WebVector<WebString> WebHistoryItem::documentState() const
 
202
{
 
203
    return m_private->documentState();
 
204
}
 
205
 
 
206
void WebHistoryItem::setDocumentState(const WebVector<WebString>& state)
 
207
{
 
208
    ensureMutable();
 
209
    // FIXME: would be nice to avoid the intermediate copy
 
210
    Vector<String> ds;
 
211
    for (size_t i = 0; i < state.size(); ++i)
 
212
        ds.append(state[i]);
 
213
    m_private->setDocumentState(ds);
 
214
}
 
215
 
 
216
long long WebHistoryItem::itemSequenceNumber() const
 
217
{
 
218
    return m_private->itemSequenceNumber();
 
219
}
 
220
 
 
221
void WebHistoryItem::setItemSequenceNumber(long long itemSequenceNumber)
 
222
{
 
223
    ensureMutable();
 
224
    m_private->setItemSequenceNumber(itemSequenceNumber);
 
225
}
 
226
 
 
227
long long WebHistoryItem::documentSequenceNumber() const
 
228
{
 
229
    return m_private->documentSequenceNumber();
 
230
}
 
231
 
 
232
void WebHistoryItem::setDocumentSequenceNumber(long long documentSequenceNumber)
 
233
{
 
234
    ensureMutable();
 
235
    m_private->setDocumentSequenceNumber(documentSequenceNumber);
 
236
}
 
237
 
 
238
WebSerializedScriptValue WebHistoryItem::stateObject() const
 
239
{
 
240
    return WebSerializedScriptValue(m_private->stateObject());
 
241
}
 
242
 
 
243
void WebHistoryItem::setStateObject(const WebSerializedScriptValue& object)
 
244
{
 
245
    ensureMutable();
 
246
    m_private->setStateObject(object);
 
247
}
 
248
 
 
249
WebString WebHistoryItem::httpContentType() const
 
250
{
 
251
    return m_private->formContentType();
 
252
}
 
253
 
 
254
void WebHistoryItem::setHTTPContentType(const WebString& httpContentType)
 
255
{
 
256
    ensureMutable();
 
257
    m_private->setFormContentType(httpContentType);
 
258
}
 
259
 
 
260
WebHTTPBody WebHistoryItem::httpBody() const
 
261
{
 
262
    return WebHTTPBody(m_private->formData());
 
263
}
 
264
 
 
265
void WebHistoryItem::setHTTPBody(const WebHTTPBody& httpBody)
 
266
{
 
267
    ensureMutable();
 
268
    m_private->setFormData(httpBody);
 
269
}
 
270
 
 
271
WebVector<WebHistoryItem> WebHistoryItem::children() const
 
272
{
 
273
    return m_private->children();
 
274
}
 
275
 
 
276
void WebHistoryItem::setChildren(const WebVector<WebHistoryItem>& items)
 
277
{
 
278
    ensureMutable();
 
279
    m_private->clearChildren();
 
280
    for (size_t i = 0; i < items.size(); ++i)
 
281
        m_private->addChildItem(items[i]);
 
282
}
 
283
 
 
284
void WebHistoryItem::appendToChildren(const WebHistoryItem& item)
 
285
{
 
286
    ensureMutable();
 
287
    m_private->addChildItem(item);
 
288
}
 
289
 
 
290
WebVector<WebString> WebHistoryItem::getReferencedFilePaths() const
 
291
{
 
292
    Vector<WebString> filePaths;
 
293
    const FormData* formData = m_private->formData();
 
294
    if (formData) {
 
295
        for (size_t i = 0; i < formData->elements().size(); ++i) {
 
296
            const FormDataElement& element = formData->elements()[i];
 
297
            if (element.m_type == FormDataElement::encodedFile)
 
298
                filePaths.append(element.m_filename);
 
299
        }
 
300
    }
 
301
    const Vector<String>& selectedFilePaths = WebCore::FormController::getReferencedFilePaths(m_private->documentState());
 
302
    for (size_t i = 0; i < selectedFilePaths.size(); ++i)
 
303
        filePaths.append(selectedFilePaths[i]);
 
304
    return filePaths;
 
305
}
 
306
 
 
307
WebHistoryItem::WebHistoryItem(const PassRefPtr<HistoryItem>& item)
 
308
    : m_private(item)
 
309
{
 
310
}
 
311
 
 
312
WebHistoryItem& WebHistoryItem::operator=(const PassRefPtr<HistoryItem>& item)
 
313
{
 
314
    m_private = item;
 
315
    return *this;
 
316
}
 
317
 
 
318
WebHistoryItem::operator PassRefPtr<HistoryItem>() const
 
319
{
 
320
    return m_private.get();
 
321
}
 
322
 
 
323
void WebHistoryItem::ensureMutable()
 
324
{
 
325
    if (!m_private->hasOneRef())
 
326
        m_private = m_private->copy();
 
327
}
 
328
 
 
329
} // namespace WebKit