diff -r 000000000000 -r 4f2f89ce4247 WebKit2/WebProcess/WebPage/WebBackForwardListProxy.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit2/WebProcess/WebPage/WebBackForwardListProxy.cpp	Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,277 @@
+/*
+ * Copyright (C) 2010 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "WebBackForwardListProxy.h"
+
+#include "WebCoreArgumentCoders.h"
+#include "WebPage.h"
+#include "WebPageProxyMessageKinds.h"
+#include "WebProcess.h"
+#include "WebProcessProxyMessageKinds.h"
+#include <WebCore/HistoryItem.h>
+#include <wtf/HashMap.h>
+
+using namespace WebCore;
+
+namespace WebKit {
+
+static const unsigned DefaultCapacity = 100;
+static const unsigned NoCurrentItemIndex = UINT_MAX;
+
+// FIXME: This leaks all HistoryItems that go into these maps.  We need to clear
+// up the life time of these objects.
+
+typedef HashMap<uint64_t, RefPtr<HistoryItem> > IDToHistoryItemMap;
+typedef HashMap<RefPtr<HistoryItem>, uint64_t> HistoryItemToIDMap;
+
+static IDToHistoryItemMap& idToHistoryItemMap()
+{
+    static IDToHistoryItemMap map;
+    return map;
+} 
+
+static HistoryItemToIDMap& historyItemToIDMap()
+{
+    static HistoryItemToIDMap map;
+    return map;
+} 
+
+static uint64_t generateHistoryItemID()
+{
+    static uint64_t uniqueHistoryItemID = 1;
+    return uniqueHistoryItemID++;
+}
+
+static uint64_t getIDForHistoryItem(HistoryItem* item)
+{
+    uint64_t itemID = 0;
+
+    std::pair<HistoryItemToIDMap::iterator, bool> result = historyItemToIDMap().add(item, 0);
+    if (result.second) {
+        itemID = generateHistoryItemID();
+        result.first->second = itemID;
+        idToHistoryItemMap().set(itemID, item);
+    } else
+        itemID = result.first->second;
+
+    ASSERT(itemID);
+    return itemID;
+}
+
+static void updateBackForwardItem(HistoryItem* item)
+{
+    uint64_t itemID = getIDForHistoryItem(item);
+    const String& originalURLString = item->originalURLString();
+    const String& urlString = item->urlString();
+    const String& title = item->title();
+    WebProcess::shared().connection()->send(WebProcessProxyMessage::AddBackForwardItem, 0, CoreIPC::In(itemID, originalURLString, urlString, title));
+}
+
+static void WK2NotifyHistoryItemChanged(HistoryItem* item)
+{
+    updateBackForwardItem(item);
+}
+
+HistoryItem* WebBackForwardListProxy::itemForID(uint64_t itemID)
+{
+    return idToHistoryItemMap().get(itemID).get();
+}
+
+WebBackForwardListProxy::WebBackForwardListProxy(WebPage* page)
+    : m_page(page)
+    , m_capacity(DefaultCapacity)
+    , m_closed(true)
+    , m_enabled(true)
+{
+    WebCore::notifyHistoryItemChanged = WK2NotifyHistoryItemChanged;
+}
+
+WebBackForwardListProxy::~WebBackForwardListProxy()
+{
+}
+
+void WebBackForwardListProxy::addItem(PassRefPtr<HistoryItem> prpItem)
+{
+    if (!m_capacity || !m_enabled)
+        return;
+
+    RefPtr<HistoryItem> item = prpItem;
+    uint64_t itemID = historyItemToIDMap().get(item);
+    WebProcess::shared().connection()->send(WebPageProxyMessage::BackForwardAddItem, m_page->pageID(), CoreIPC::In(itemID));
+}
+
+void WebBackForwardListProxy::goBack()
+{
+    ASSERT_NOT_REACHED();
+}
+
+void WebBackForwardListProxy::goForward()
+{
+    ASSERT_NOT_REACHED();
+}
+
+void WebBackForwardListProxy::goToItem(HistoryItem* item)
+{
+    uint64_t itemID = historyItemToIDMap().get(item);
+    WebProcess::shared().connection()->send(WebPageProxyMessage::BackForwardGoToItem, m_page->pageID(), CoreIPC::In(itemID));
+}
+
+HistoryItem* WebBackForwardListProxy::backItem()
+{
+    return 0;
+}
+
+HistoryItem* WebBackForwardListProxy::currentItem()
+{
+    uint64_t currentItemID = 0;
+    if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardCurrentItem,
+                                                     m_page->pageID(), CoreIPC::In(),
+                                                     CoreIPC::Out(currentItemID),
+                                                     CoreIPC::Connection::NoTimeout)) {
+        return 0;
+    }
+
+    if (!currentItemID)
+        return 0;
+
+    RefPtr<HistoryItem> item = idToHistoryItemMap().get(currentItemID);
+    return item.get();
+}
+
+HistoryItem* WebBackForwardListProxy::forwardItem()
+{
+    return 0;
+}
+
+HistoryItem* WebBackForwardListProxy::itemAtIndex(int itemIndex)
+{
+    uint64_t itemID = 0;
+    if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardItemAtIndex,
+                                                     m_page->pageID(), CoreIPC::In(itemIndex),
+                                                     CoreIPC::Out(itemID),
+                                                     CoreIPC::Connection::NoTimeout)) {
+        return 0;
+    }
+
+    if (!itemID)
+        return 0;
+
+    RefPtr<HistoryItem> item = idToHistoryItemMap().get(itemID);
+    return item.get();
+}
+
+void WebBackForwardListProxy::backListWithLimit(int, HistoryItemVector&)
+{
+    ASSERT_NOT_REACHED();
+}
+
+void WebBackForwardListProxy::forwardListWithLimit(int, HistoryItemVector&)
+{
+    ASSERT_NOT_REACHED();
+}
+
+int WebBackForwardListProxy::capacity()
+{
+    return m_capacity;
+}
+
+void WebBackForwardListProxy::setCapacity(int capacity)
+{
+    m_capacity = capacity;
+}
+
+bool WebBackForwardListProxy::enabled()
+{
+    return m_enabled;
+}
+
+void WebBackForwardListProxy::setEnabled(bool enabled)
+{
+    m_enabled = enabled;
+}
+
+int WebBackForwardListProxy::backListCount()
+{
+    int backListCount = 0;
+    if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardBackListCount,
+                                                     m_page->pageID(), CoreIPC::In(),
+                                                     CoreIPC::Out(backListCount),
+                                                     CoreIPC::Connection::NoTimeout)) {
+        return 0;
+    }
+
+    return backListCount;
+}
+
+int WebBackForwardListProxy::forwardListCount()
+{
+    int forwardListCount = 0;
+    if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardForwardListCount,
+                                                     m_page->pageID(), CoreIPC::In(),
+                                                     CoreIPC::Out(forwardListCount),
+                                                     CoreIPC::Connection::NoTimeout)) {
+        return 0;
+    }
+
+    return forwardListCount;
+}
+
+bool WebBackForwardListProxy::containsItem(HistoryItem*)
+{
+    return false;
+}
+
+void WebBackForwardListProxy::close()
+{
+    m_closed = true;
+    m_page = 0;
+}
+
+bool WebBackForwardListProxy::closed()
+{
+    return m_closed;
+}
+
+void WebBackForwardListProxy::removeItem(HistoryItem*)
+{
+}
+
+HistoryItemVector& WebBackForwardListProxy::entries()
+{
+    static HistoryItemVector noEntries;
+    return noEntries;
+}
+
+void WebBackForwardListProxy::pushStateItem(PassRefPtr<HistoryItem>)
+{
+}
+
+#if ENABLE(WML)
+void WebBackForwardListProxy::clearWMLPageHistory()
+{
+}
+#endif
+
+} // namespace WebKit