code.vuplus.com Git - vuplus_webkit/blob - Source/WebKit/win/WebBackForwardList.cpp

   1 /*
   2  * Copyright (C) 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  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "WebKitDLL.h"
  28 #include "WebBackForwardList.h"
  29
  30 #include "WebFrame.h"
  31 #include "WebKit.h"
  32 #include "WebPreferences.h"
  33
  34 #include <WebCore/BackForwardListImpl.h>
  35 #include <WebCore/COMPtr.h>
  36 #include <WebCore/HistoryItem.h>
  37
  38 using std::min;
  39 using namespace WebCore;
  40
  41 // WebBackForwardList ----------------------------------------------------------------
  42
  43 // FIXME: Instead of this we could just create a class derived from BackForwardListImpl
  44 // with a pointer to a WebBackForwardList in it.
  45 static HashMap<BackForwardListImpl*, WebBackForwardList*>& backForwardListWrappers()
  46 {
  47     static HashMap<BackForwardListImpl*, WebBackForwardList*> staticBackForwardListWrappers;
  48     return staticBackForwardListWrappers;
  49 }
  50
  51 WebBackForwardList::WebBackForwardList(PassRefPtr<BackForwardListImpl> backForwardList)
  52     : m_refCount(0)
  53     , m_backForwardList(backForwardList)
  54 {
  55     ASSERT(!backForwardListWrappers().contains(m_backForwardList.get()));
  56     backForwardListWrappers().set(m_backForwardList.get(), this);
  57
  58     gClassCount++;
  59     gClassNameCount.add("WebBackForwardList");
  60 }
  61
  62 WebBackForwardList::~WebBackForwardList()
  63 {
  64     ASSERT(m_backForwardList->closed());
  65
  66     ASSERT(backForwardListWrappers().contains(m_backForwardList.get()));
  67     backForwardListWrappers().remove(m_backForwardList.get());
  68
  69     gClassCount--;
  70     gClassNameCount.remove("WebBackForwardList");
  71 }
  72
  73 WebBackForwardList* WebBackForwardList::createInstance(PassRefPtr<BackForwardListImpl> backForwardList)
  74 {
  75     WebBackForwardList* instance;
  76
  77     instance = backForwardListWrappers().get(backForwardList.get());
  78
  79     if (!instance)
  80         instance = new WebBackForwardList(backForwardList);
  81
  82     instance->AddRef();
  83     return instance;
  84 }
  85
  86 // IUnknown -------------------------------------------------------------------
  87
  88 HRESULT STDMETHODCALLTYPE WebBackForwardList::QueryInterface(REFIID riid, void** ppvObject)
  89 {
  90     *ppvObject = 0;
  91     if (IsEqualGUID(riid, IID_IUnknown))
  92         *ppvObject = static_cast<IWebBackForwardList*>(this);
  93     else if (IsEqualGUID(riid, IID_IWebBackForwardList))
  94         *ppvObject = static_cast<IWebBackForwardList*>(this);
  95     else if (IsEqualGUID(riid, IID_IWebBackForwardListPrivate))
  96         *ppvObject = static_cast<IWebBackForwardListPrivate*>(this);
  97     else
  98         return E_NOINTERFACE;
  99
 100     AddRef();
 101     return S_OK;
 102 }
 103
 104 ULONG STDMETHODCALLTYPE WebBackForwardList::AddRef(void)
 105 {
 106     return ++m_refCount;
 107 }
 108
 109 ULONG STDMETHODCALLTYPE WebBackForwardList::Release(void)
 110 {
 111     ULONG newRef = --m_refCount;
 112     if (!newRef)
 113         delete(this);
 114
 115     return newRef;
 116 }
 117
 118 // IWebBackForwardList ---------------------------------------------------------
 119
 120 HRESULT STDMETHODCALLTYPE WebBackForwardList::addItem(
 121     /* [in] */ IWebHistoryItem* item)
 122 {
 123     COMPtr<WebHistoryItem> webHistoryItem;
 124
 125     if (!item || FAILED(item->QueryInterface(&webHistoryItem)))
 126         return E_FAIL;
 127
 128     m_backForwardList->addItem(webHistoryItem->historyItem());
 129     return S_OK;
 130 }
 131
 132 HRESULT STDMETHODCALLTYPE WebBackForwardList::goBack( void)
 133 {
 134     m_backForwardList->goBack();
 135     return S_OK;
 136 }
 137
 138 HRESULT STDMETHODCALLTYPE WebBackForwardList::goForward( void)
 139 {
 140     m_backForwardList->goForward();
 141     return S_OK;
 142 }
 143
 144 HRESULT STDMETHODCALLTYPE WebBackForwardList::goToItem(
 145     /* [in] */ IWebHistoryItem* item)
 146 {
 147     COMPtr<WebHistoryItem> webHistoryItem;
 148
 149     if (!item || FAILED(item->QueryInterface(&webHistoryItem)))
 150         return E_FAIL;
 151
 152     m_backForwardList->goToItem(webHistoryItem->historyItem());
 153     return S_OK;
 154 }
 155
 156 HRESULT STDMETHODCALLTYPE WebBackForwardList::backItem(
 157     /* [retval][out] */ IWebHistoryItem** item)
 158 {
 159     if (!item)
 160         return E_POINTER;
 161
 162     HistoryItem* historyItem = m_backForwardList->backItem();
 163
 164     if (!historyItem)
 165         return E_FAIL;
 166
 167     *item = WebHistoryItem::createInstance(historyItem);
 168     return S_OK;
 169 }
 170
 171 HRESULT STDMETHODCALLTYPE WebBackForwardList::currentItem(
 172     /* [retval][out] */ IWebHistoryItem** item)
 173 {
 174     if (!item)
 175         return E_POINTER;
 176
 177     HistoryItem* historyItem = m_backForwardList->currentItem();
 178
 179     if (!historyItem)
 180         return E_FAIL;
 181
 182     *item = WebHistoryItem::createInstance(historyItem);
 183     return S_OK;
 184 }
 185
 186 HRESULT STDMETHODCALLTYPE WebBackForwardList::forwardItem(
 187     /* [retval][out] */ IWebHistoryItem** item)
 188 {
 189     if (!item)
 190         return E_POINTER;
 191
 192     HistoryItem* historyItem = m_backForwardList->forwardItem();
 193
 194     if (!historyItem)
 195         return E_FAIL;
 196
 197     *item = WebHistoryItem::createInstance(historyItem);
 198     return S_OK;
 199 }
 200
 201 HRESULT STDMETHODCALLTYPE WebBackForwardList::backListWithLimit(
 202     /* [in] */ int limit,
 203     /* [out] */ int* listCount,
 204     /* [retval][out] */ IWebHistoryItem** list)
 205 {
 206     HistoryItemVector historyItemVector;
 207     m_backForwardList->backListWithLimit(limit, historyItemVector);
 208
 209     *listCount = static_cast<int>(historyItemVector.size());
 210
 211     if (list)
 212         for (unsigned i = 0; i < historyItemVector.size(); i++)
 213             list[i] = WebHistoryItem::createInstance(historyItemVector[i].get());
 214
 215     return S_OK;
 216 }
 217
 218 HRESULT STDMETHODCALLTYPE WebBackForwardList::forwardListWithLimit(
 219     /* [in] */ int limit,
 220     /* [out] */ int* listCount,
 221     /* [retval][out] */ IWebHistoryItem** list)
 222 {
 223     HistoryItemVector historyItemVector;
 224     m_backForwardList->forwardListWithLimit(limit, historyItemVector);
 225
 226     *listCount = static_cast<int>(historyItemVector.size());
 227
 228     if (list)
 229         for (unsigned i = 0; i < historyItemVector.size(); i++)
 230             list[i] = WebHistoryItem::createInstance(historyItemVector[i].get());
 231
 232     return S_OK;
 233 }
 234
 235 HRESULT STDMETHODCALLTYPE WebBackForwardList::capacity(
 236     /* [retval][out] */ int* result)
 237 {
 238     *result = (int)m_backForwardList->capacity();
 239     return S_OK;
 240 }
 241
 242 HRESULT STDMETHODCALLTYPE WebBackForwardList::setCapacity(
 243     /* [in] */ int size)
 244 {
 245     if (size < 0)
 246         return E_FAIL;
 247
 248     m_backForwardList->setCapacity(size);
 249     return S_OK;
 250 }
 251
 252 HRESULT STDMETHODCALLTYPE WebBackForwardList::backListCount(
 253     /* [retval][out] */ int* count)
 254 {
 255     *count = m_backForwardList->backListCount();
 256     return S_OK;
 257 }
 258
 259 HRESULT STDMETHODCALLTYPE WebBackForwardList::forwardListCount(
 260     /* [retval][out] */ int* count)
 261 {
 262     *count = m_backForwardList->forwardListCount();
 263     return S_OK;
 264 }
 265
 266 HRESULT STDMETHODCALLTYPE WebBackForwardList::containsItem(
 267     /* [in] */ IWebHistoryItem* item,
 268     /* [retval][out] */ BOOL* result)
 269 {
 270     COMPtr<WebHistoryItem> webHistoryItem;
 271
 272     if (!item || FAILED(item->QueryInterface(&webHistoryItem)))
 273         return E_FAIL;
 274
 275     *result = m_backForwardList->containsItem(webHistoryItem->historyItem());
 276     return S_OK;
 277 }
 278
 279 HRESULT STDMETHODCALLTYPE WebBackForwardList::itemAtIndex(
 280     /* [in] */ int index,
 281     /* [retval][out] */ IWebHistoryItem** item)
 282 {
 283     if (!item)
 284         return E_POINTER;
 285
 286     HistoryItem* historyItem = m_backForwardList->itemAtIndex(index);
 287
 288     if (!historyItem)
 289         return E_FAIL;
 290
 291     *item = WebHistoryItem::createInstance(historyItem);
 292     return S_OK;
 293 }
 294
 295 // IWebBackForwardListPrivate --------------------------------------------------------
 296
 297 HRESULT STDMETHODCALLTYPE WebBackForwardList::removeItem(
 298     /* [in] */ IWebHistoryItem* item)
 299 {
 300     COMPtr<WebHistoryItem> webHistoryItem;
 301
 302     if (!item || FAILED(item->QueryInterface(&webHistoryItem)))
 303         return E_FAIL;
 304
 305     m_backForwardList->removeItem(webHistoryItem->historyItem());
 306     return S_OK;
 307 }