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 "FormData.h"
  35 #include "HistoryItem.h"
  36 #include "KURL.h"
  37 #include "SerializedScriptValue.h"
  38
  39 #include "WebHTTPBody.h"
  40 #include "WebPoint.h"
  41 #include "WebSerializedScriptValue.h"
  42 #include "WebString.h"
  43 #include "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     return 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 WebHistoryItem::WebHistoryItem(const PassRefPtr<HistoryItem>& item)
 291     : m_private(item)
 292 {
 293 }
 294
 295 WebHistoryItem& WebHistoryItem::operator=(const PassRefPtr<HistoryItem>& item)
 296 {
 297     m_private = item;
 298     return *this;
 299 }
 300
 301 WebHistoryItem::operator PassRefPtr<HistoryItem>() const
 302 {
 303     return m_private.get();
 304 }
 305
 306 void WebHistoryItem::ensureMutable()
 307 {
 308     if (!m_private->hasOneRef())
 309         m_private = m_private->copy();
 310 }
 311
 312 } // namespace WebKit