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 "WebHistory.h"

    29 

    30 #include "CFDictionaryPropertyBag.h"

    31 #include "MemoryStream.h"

    32 #include "WebKit.h"

    33 #include "MarshallingHelpers.h"

    34 #include "WebHistoryItem.h"

    35 #include "WebKit.h"

    36 #include "WebNotificationCenter.h"

    37 #include "WebPreferences.h"

    38 #include <CoreFoundation/CoreFoundation.h>

    39 #pragma warning( push, 0 )

    40 #include <WebCore/HistoryItem.h>

    41 #include <WebCore/HistoryPropertyList.h>

    42 #include <WebCore/KURL.h>

    43 #include <WebCore/PageGroup.h>

    44 #include <WebCore/SharedBuffer.h>

    45 #pragma warning( pop )

    46 #include <functional>

    47 #include <wtf/StdLibExtras.h>

    48 #include <wtf/Vector.h>

    49 

    50 using namespace WebCore;

    51 using namespace std;

    52 

    53 CFStringRef DatesArrayKey = CFSTR("WebHistoryDates");

    54 CFStringRef FileVersionKey = CFSTR("WebHistoryFileVersion");

    55 

    56 #define currentFileVersion 1

    57 

    58 class WebHistoryWriter : public HistoryPropertyListWriter {

    59 public:

    60     WebHistoryWriter(const WebHistory::DateToEntriesMap&);

    61 

    62 private:

    63     virtual void writeHistoryItems(BinaryPropertyListObjectStream&);

    64 

    65     const WebHistory::DateToEntriesMap& m_entriesByDate;

    66     Vector<WebHistory::DateKey> m_dateKeys;

    67 };

    68 

    69 WebHistoryWriter::WebHistoryWriter(const WebHistory::DateToEntriesMap& entriesByDate)

    70     : m_entriesByDate(entriesByDate)

    71 {

    72     copyKeysToVector(m_entriesByDate, m_dateKeys);

    73     sort(m_dateKeys.begin(), m_dateKeys.end());

    74 }

    75 

    76 void WebHistoryWriter::writeHistoryItems(BinaryPropertyListObjectStream& stream)

    77 {

    78     for (int dateIndex = m_dateKeys.size() - 1; dateIndex >= 0; --dateIndex) {

    79         // get the entries for that date

    80         CFArrayRef entries = m_entriesByDate.get(m_dateKeys[dateIndex]).get();

    81         CFIndex entriesCount = CFArrayGetCount(entries);

    82         for (CFIndex j = entriesCount - 1; j >= 0; --j) {

    83             IWebHistoryItem* item = (IWebHistoryItem*) CFArrayGetValueAtIndex(entries, j);

    84             COMPtr<WebHistoryItem> webItem(Query, item);

    85             if (!webItem)

    86                 continue;

    87 

    88             writeHistoryItem(stream, webItem->historyItem());

    89         }

    90     }

    91 }

    92 

    93 static bool areEqualOrClose(double d1, double d2)

    94 {

    95     double diff = d1-d2;

    96     return (diff < .000001 && diff > -.000001);

    97 }

    98 

    99 static COMPtr<CFDictionaryPropertyBag> createUserInfoFromArray(BSTR notificationStr, CFArrayRef arrayItem)

   100 {

   101     RetainPtr<CFMutableDictionaryRef> dictionary(AdoptCF, 

   102         CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));

   103 

   104     RetainPtr<CFStringRef> key(AdoptCF, MarshallingHelpers::BSTRToCFStringRef(notificationStr));

   105     CFDictionaryAddValue(dictionary.get(), key.get(), arrayItem);

   106 

   107     COMPtr<CFDictionaryPropertyBag> result = CFDictionaryPropertyBag::createInstance();

   108     result->setDictionary(dictionary.get());

   109     return result;

   110 }

   111 

   112 static COMPtr<CFDictionaryPropertyBag> createUserInfoFromHistoryItem(BSTR notificationStr, IWebHistoryItem* item)

   113 {

   114     // reference counting of item added to the array is managed by the CFArray value callbacks

   115     RetainPtr<CFArrayRef> itemList(AdoptCF, CFArrayCreate(0, (const void**) &item, 1, &MarshallingHelpers::kIUnknownArrayCallBacks));

   116     COMPtr<CFDictionaryPropertyBag> info = createUserInfoFromArray(notificationStr, itemList.get());

   117     return info;

   118 }

   119 

   120 // WebHistory -----------------------------------------------------------------

   121 

   122 WebHistory::WebHistory()

   123 : m_refCount(0)

   124 , m_preferences(0)

   125 {

   126     gClassCount++;

   127     gClassNameCount.add("WebHistory");

   128 

   129     m_entriesByURL.adoptCF(CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &MarshallingHelpers::kIUnknownDictionaryValueCallBacks));

   130 

   131     m_preferences = WebPreferences::sharedStandardPreferences();

   132 }

   133 

   134 WebHistory::~WebHistory()

   135 {

   136     gClassCount--;

   137     gClassNameCount.remove("WebHistory");

   138 }

   139 

   140 WebHistory* WebHistory::createInstance()

   141 {

   142     WebHistory* instance = new WebHistory();

   143     instance->AddRef();

   144     return instance;

   145 }

   146 

   147 HRESULT WebHistory::postNotification(NotificationType notifyType, IPropertyBag* userInfo /*=0*/)

   148 {

   149     IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal();

   150     HRESULT hr = nc->postNotificationName(getNotificationString(notifyType), static_cast<IWebHistory*>(this), userInfo);

   151     if (FAILED(hr))

   152         return hr;

   153 

   154     return S_OK;

   155 }

   156 

   157 BSTR WebHistory::getNotificationString(NotificationType notifyType)

   158 {

   159     static BSTR keys[6] = {0};

   160     if (!keys[0]) {

   161         keys[0] = SysAllocString(WebHistoryItemsAddedNotification);

   162         keys[1] = SysAllocString(WebHistoryItemsRemovedNotification);

   163         keys[2] = SysAllocString(WebHistoryAllItemsRemovedNotification);

   164         keys[3] = SysAllocString(WebHistoryLoadedNotification);

   165         keys[4] = SysAllocString(WebHistoryItemsDiscardedWhileLoadingNotification);

   166         keys[5] = SysAllocString(WebHistorySavedNotification);

   167     }

   168     return keys[notifyType];

   169 }

   170 

   171 // IUnknown -------------------------------------------------------------------

   172 

   173 HRESULT STDMETHODCALLTYPE WebHistory::QueryInterface(REFIID riid, void** ppvObject)

   174 {

   175     *ppvObject = 0;

   176     if (IsEqualGUID(riid, CLSID_WebHistory))

   177         *ppvObject = this;

   178     else if (IsEqualGUID(riid, IID_IUnknown))

   179         *ppvObject = static_cast<IWebHistory*>(this);

   180     else if (IsEqualGUID(riid, IID_IWebHistory))

   181         *ppvObject = static_cast<IWebHistory*>(this);

   182     else if (IsEqualGUID(riid, IID_IWebHistoryPrivate))

   183         *ppvObject = static_cast<IWebHistoryPrivate*>(this);

   184     else

   185         return E_NOINTERFACE;

   186 

   187     AddRef();

   188     return S_OK;

   189 }

   190 

   191 ULONG STDMETHODCALLTYPE WebHistory::AddRef(void)

   192 {

   193     return ++m_refCount;

   194 }

   195 

   196 ULONG STDMETHODCALLTYPE WebHistory::Release(void)

   197 {

   198     ULONG newRef = --m_refCount;

   199     if (!newRef)

   200         delete(this);

   201 

   202     return newRef;

   203 }

   204 

   205 // IWebHistory ----------------------------------------------------------------

   206 

   207 static inline COMPtr<WebHistory>& sharedHistoryStorage()

   208 {

   209     DEFINE_STATIC_LOCAL(COMPtr<WebHistory>, sharedHistory, ());

   210     return sharedHistory;

   211 }

   212 

   213 WebHistory* WebHistory::sharedHistory()

   214 {

   215     return sharedHistoryStorage().get();

   216 }

   217 

   218 HRESULT STDMETHODCALLTYPE WebHistory::optionalSharedHistory( 

   219     /* [retval][out] */ IWebHistory** history)

   220 {

   221     *history = sharedHistory();

   222     if (*history)

   223         (*history)->AddRef();

   224     return S_OK;

   225 }

   226 

   227 HRESULT STDMETHODCALLTYPE WebHistory::setOptionalSharedHistory( 

   228     /* [in] */ IWebHistory* history)

   229 {

   230     if (sharedHistoryStorage() == history)

   231         return S_OK;

   232     sharedHistoryStorage().query(history);

   233     PageGroup::setShouldTrackVisitedLinks(sharedHistoryStorage());

   234     PageGroup::removeAllVisitedLinks();

   235     return S_OK;

   236 }

   237 

   238 HRESULT STDMETHODCALLTYPE WebHistory::loadFromURL( 

   239     /* [in] */ BSTR url,

   240     /* [out] */ IWebError** error,

   241     /* [retval][out] */ BOOL* succeeded)

   242 {

   243     HRESULT hr = S_OK;

   244     RetainPtr<CFMutableArrayRef> discardedItems(AdoptCF, 

   245         CFArrayCreateMutable(0, 0, &MarshallingHelpers::kIUnknownArrayCallBacks));

   246 

   247     RetainPtr<CFURLRef> urlRef(AdoptCF, MarshallingHelpers::BSTRToCFURLRef(url));

   248 

   249     hr = loadHistoryGutsFromURL(urlRef.get(), discardedItems.get(), error);

   250     if (FAILED(hr))

   251         goto exit;

   252 

   253     hr = postNotification(kWebHistoryLoadedNotification);

   254     if (FAILED(hr))

   255         goto exit;

   256 

   257     if (CFArrayGetCount(discardedItems.get()) > 0) {

   258         COMPtr<CFDictionaryPropertyBag> userInfo = createUserInfoFromArray(getNotificationString(kWebHistoryItemsDiscardedWhileLoadingNotification), discardedItems.get());

   259         hr = postNotification(kWebHistoryItemsDiscardedWhileLoadingNotification, userInfo.get());

   260         if (FAILED(hr))

   261             goto exit;

   262     }

   263 

   264 exit:

   265     if (succeeded)

   266         *succeeded = SUCCEEDED(hr);

   267     return hr;

   268 }

   269 

   270 static CFDictionaryRef createHistoryListFromStream(CFReadStreamRef stream, CFPropertyListFormat format)

   271 {

   272     return (CFDictionaryRef)CFPropertyListCreateFromStream(0, stream, 0, kCFPropertyListImmutable, &format, 0);

   273 }

   274 

   275 HRESULT WebHistory::loadHistoryGutsFromURL(CFURLRef url, CFMutableArrayRef discardedItems, IWebError** /*error*/) //FIXME

   276 {

   277     CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0 | kCFPropertyListXMLFormat_v1_0;

   278     HRESULT hr = S_OK;

   279     int numberOfItemsLoaded = 0;

   280 

   281     RetainPtr<CFReadStreamRef> stream(AdoptCF, CFReadStreamCreateWithFile(0, url));

   282     if (!stream) 

   283         return E_FAIL;

   284 

   285     if (!CFReadStreamOpen(stream.get())) 

   286         return E_FAIL;

   287 

   288     RetainPtr<CFDictionaryRef> historyList(AdoptCF, createHistoryListFromStream(stream.get(), format));

   289     CFReadStreamClose(stream.get());

   290 

   291     if (!historyList) 

   292         return E_FAIL;

   293 

   294     CFNumberRef fileVersionObject = (CFNumberRef)CFDictionaryGetValue(historyList.get(), FileVersionKey);

   295     int fileVersion;

   296     if (!CFNumberGetValue(fileVersionObject, kCFNumberIntType, &fileVersion)) 

   297         return E_FAIL;

   298 

   299     if (fileVersion > currentFileVersion) 

   300         return E_FAIL;

   301     

   302     CFArrayRef datesArray = (CFArrayRef)CFDictionaryGetValue(historyList.get(), DatesArrayKey);

   303 

   304     int itemCountLimit;

   305     hr = historyItemLimit(&itemCountLimit);

   306     if (FAILED(hr))

   307         return hr;

   308 

   309     CFAbsoluteTime limitDate;

   310     hr = ageLimitDate(&limitDate);

   311     if (FAILED(hr))

   312         return hr;

   313 

   314     bool ageLimitPassed = false;

   315     bool itemLimitPassed = false;

   316 

   317     CFIndex itemCount = CFArrayGetCount(datesArray);

   318     for (CFIndex i = 0; i < itemCount; ++i) {

   319         CFDictionaryRef itemAsDictionary = (CFDictionaryRef)CFArrayGetValueAtIndex(datesArray, i);

   320         COMPtr<WebHistoryItem> item(AdoptCOM, WebHistoryItem::createInstance());

   321         hr = item->initFromDictionaryRepresentation((void*)itemAsDictionary);

   322         if (FAILED(hr))

   323             return hr;

   324 

   325         // item without URL is useless; data on disk must have been bad; ignore

   326         BOOL hasURL;

   327         hr = item->hasURLString(&hasURL);

   328         if (FAILED(hr))

   329             return hr;

   330         

   331         if (hasURL) {

   332             // Test against date limit. Since the items are ordered newest to oldest, we can stop comparing

   333             // once we've found the first item that's too old.

   334             if (!ageLimitPassed) {

   335                 DATE lastVisitedTime;

   336                 hr = item->lastVisitedTimeInterval(&lastVisitedTime);

   337                 if (FAILED(hr))

   338                     return hr;

   339                 if (timeToDate(MarshallingHelpers::DATEToCFAbsoluteTime(lastVisitedTime)) <= limitDate)

   340                     ageLimitPassed = true;

   341             }

   342             if (ageLimitPassed || itemLimitPassed)

   343                 CFArrayAppendValue(discardedItems, item.get());

   344             else {

   345                 bool added;

   346                 addItem(item.get(), true, &added); // ref is added inside addItem

   347                 if (added)

   348                     ++numberOfItemsLoaded;

   349                 if (numberOfItemsLoaded == itemCountLimit)

   350                     itemLimitPassed = true;

   351             }

   352         }

   353     }

   354     return hr;

   355 }

   356 

   357 HRESULT STDMETHODCALLTYPE WebHistory::saveToURL( 

   358     /* [in] */ BSTR url,

   359     /* [out] */ IWebError** error,

   360     /* [retval][out] */ BOOL* succeeded)

   361 {

   362     HRESULT hr = S_OK;

   363     RetainPtr<CFURLRef> urlRef(AdoptCF, MarshallingHelpers::BSTRToCFURLRef(url));

   364 

   365     hr = saveHistoryGuts(urlRef.get(), error);

   366 

   367     if (succeeded)

   368         *succeeded = SUCCEEDED(hr);

   369     if (SUCCEEDED(hr))

   370         hr = postNotification(kWebHistorySavedNotification);

   371 

   372     return hr;

   373 }

   374 

   375 HRESULT WebHistory::saveHistoryGuts(CFURLRef url, IWebError** error)

   376 {

   377     HRESULT hr = S_OK;

   378 

   379     // FIXME: Correctly report error when new API is ready.

   380     if (error)

   381         *error = 0;

   382 

   383     RetainPtr<CFDataRef> data = this->data();

   384 

   385     RetainPtr<CFWriteStreamRef> stream(AdoptCF, CFWriteStreamCreateWithFile(kCFAllocatorDefault, url));

   386     if (!stream) 

   387         return E_FAIL;

   388 

   389     if (!CFWriteStreamOpen(stream.get())) 

   390         return E_FAIL;

   391 

   392     const UInt8* dataPtr = CFDataGetBytePtr(data.get());

   393     CFIndex length = CFDataGetLength(data.get());

   394 

   395     while (length) {

   396         CFIndex bytesWritten = CFWriteStreamWrite(stream.get(), dataPtr, length);

   397         if (bytesWritten <= 0) {

   398             hr = E_FAIL;

   399             break;

   400         }

   401         dataPtr += bytesWritten;

   402         length -= bytesWritten;

   403     }

   404 

   405     CFWriteStreamClose(stream.get());

   406 

   407     return hr;

   408 }

   409 

   410 HRESULT STDMETHODCALLTYPE WebHistory::addItems( 

   411     /* [in] */ int itemCount,

   412     /* [in] */ IWebHistoryItem** items)

   413 {

   414     // There is no guarantee that the incoming entries are in any particular

   415     // order, but if this is called with a set of entries that were created by

   416     // iterating through the results of orderedLastVisitedDays and orderedItemsLastVisitedOnDay

   417     // then they will be ordered chronologically from newest to oldest. We can make adding them

   418     // faster (fewer compares) by inserting them from oldest to newest.

   419 

   420     HRESULT hr;

   421     for (int i = itemCount - 1; i >= 0; --i) {

   422         hr = addItem(items[i], false, 0);

   423         if (FAILED(hr))

   424             return hr;

   425     }

   426 

   427     return S_OK;

   428 }

   429 

   430 HRESULT STDMETHODCALLTYPE WebHistory::removeItems( 

   431     /* [in] */ int itemCount,

   432     /* [in] */ IWebHistoryItem** items)

   433 {

   434     HRESULT hr;

   435     for (int i = 0; i < itemCount; ++i) {

   436         hr = removeItem(items[i]);

   437         if (FAILED(hr))

   438             return hr;

   439     }

   440 

   441     return S_OK;

   442 }

   443 

   444 HRESULT STDMETHODCALLTYPE WebHistory::removeAllItems( void)

   445 {

   446     m_entriesByDate.clear();

   447     m_orderedLastVisitedDays.clear();

   448 

   449     CFIndex itemCount = CFDictionaryGetCount(m_entriesByURL.get());

   450     Vector<IWebHistoryItem*> itemsVector(itemCount);

   451     CFDictionaryGetKeysAndValues(m_entriesByURL.get(), 0, (const void**)itemsVector.data());

   452     RetainPtr<CFArrayRef> allItems(AdoptCF, CFArrayCreate(kCFAllocatorDefault, (const void**)itemsVector.data(), itemCount, &MarshallingHelpers::kIUnknownArrayCallBacks));

   453 

   454     CFDictionaryRemoveAllValues(m_entriesByURL.get());

   455 

   456     PageGroup::removeAllVisitedLinks();

   457 

   458     COMPtr<CFDictionaryPropertyBag> userInfo = createUserInfoFromArray(getNotificationString(kWebHistoryAllItemsRemovedNotification), allItems.get());

   459     return postNotification(kWebHistoryAllItemsRemovedNotification, userInfo.get());

   460 }

   461 

   462 HRESULT STDMETHODCALLTYPE WebHistory::orderedLastVisitedDays( 

   463     /* [out][in] */ int* count,

   464     /* [in] */ DATE* calendarDates)

   465 {

   466     int dateCount = m_entriesByDate.size();

   467     if (!calendarDates) {

   468         *count = dateCount;

   469         return S_OK;

   470     }

   471 

   472     if (*count < dateCount) {

   473         *count = dateCount;

   474         return E_FAIL;

   475     }

   476 

   477     *count = dateCount;

   478     if (!m_orderedLastVisitedDays) {

   479         m_orderedLastVisitedDays.set(new DATE[dateCount]);

   480         DateToEntriesMap::const_iterator::Keys end = m_entriesByDate.end().keys();

   481         int i = 0;

   482         for (DateToEntriesMap::const_iterator::Keys it = m_entriesByDate.begin().keys(); it != end; ++it, ++i)

   483             m_orderedLastVisitedDays[i] = MarshallingHelpers::CFAbsoluteTimeToDATE(*it);

   484         // Use std::greater to sort the days in descending order (i.e., most-recent first).

   485         sort(m_orderedLastVisitedDays.get(), m_orderedLastVisitedDays.get() + dateCount, greater<DATE>());

   486     }

   487 

   488     memcpy(calendarDates, m_orderedLastVisitedDays.get(), dateCount * sizeof(DATE));

   489     return S_OK;

   490 }

   491 

   492 HRESULT STDMETHODCALLTYPE WebHistory::orderedItemsLastVisitedOnDay( 

   493     /* [out][in] */ int* count,

   494     /* [in] */ IWebHistoryItem** items,

   495     /* [in] */ DATE calendarDate)

   496 {

   497     DateKey dateKey;

   498     if (!findKey(&dateKey, MarshallingHelpers::DATEToCFAbsoluteTime(calendarDate))) {

   499         *count = 0;

   500         return 0;

   501     }

   502 

   503     CFArrayRef entries = m_entriesByDate.get(dateKey).get();

   504     if (!entries) {

   505         *count = 0;

   506         return 0;

   507     }

   508 

   509     int newCount = CFArrayGetCount(entries);

   510 

   511     if (!items) {

   512         *count = newCount;

   513         return S_OK;

   514     }

   515 

   516     if (*count < newCount) {

   517         *count = newCount;

   518         return E_FAIL;

   519     }

   520 

   521     *count = newCount;

   522     for (int i = 0; i < newCount; i++) {

   523         IWebHistoryItem* item = (IWebHistoryItem*)CFArrayGetValueAtIndex(entries, i);

   524         item->AddRef();

   525         items[i] = item;

   526     }

   527 

   528     return S_OK;

   529 }

   530 

   531 HRESULT STDMETHODCALLTYPE WebHistory::allItems( 

   532     /* [out][in] */ int* count,

   533     /* [out][retval] */ IWebHistoryItem** items)

   534 {

   535     int entriesByURLCount = CFDictionaryGetCount(m_entriesByURL.get());

   536 

   537     if (!items) {

   538         *count = entriesByURLCount;

   539         return S_OK;

   540     }

   541 

   542     if (*count < entriesByURLCount) {

   543         *count = entriesByURLCount;

   544         return E_FAIL;

   545     }

   546 

   547     *count = entriesByURLCount;

   548     CFDictionaryGetKeysAndValues(m_entriesByURL.get(), 0, (const void**)items);

   549     for (int i = 0; i < entriesByURLCount; i++)

   550         items[i]->AddRef();

   551 

   552     return S_OK;

   553 }

   554 

   555 HRESULT WebHistory::data(IStream** stream)

   556 {

   557     if (!stream)

   558         return E_POINTER;

   559 

   560     *stream = 0;

   561 

   562     RetainPtr<CFDataRef> historyData = data();

   563     if (!historyData)

   564         return S_OK;

   565 

   566     COMPtr<MemoryStream> result = MemoryStream::createInstance(SharedBuffer::wrapCFData(historyData.get()));

   567     return result.copyRefTo(stream);

   568 }

   569 

   570 HRESULT WebHistory::setVisitedLinkTrackingEnabled(BOOL visitedLinkTrackingEnabled)

   571 {

   572     PageGroup::setShouldTrackVisitedLinks(visitedLinkTrackingEnabled);

   573     return S_OK;

   574 }

   575 

   576 HRESULT WebHistory::removeAllVisitedLinks()

   577 {

   578     PageGroup::removeAllVisitedLinks();

   579     return S_OK;

   580 }

   581 

   582 HRESULT STDMETHODCALLTYPE WebHistory::setHistoryItemLimit( 

   583     /* [in] */ int limit)

   584 {

   585     if (!m_preferences)

   586         return E_FAIL;

   587     return m_preferences->setHistoryItemLimit(limit);

   588 }

   589 

   590 HRESULT STDMETHODCALLTYPE WebHistory::historyItemLimit( 

   591     /* [retval][out] */ int* limit)

   592 {

   593     if (!m_preferences)

   594         return E_FAIL;

   595     return m_preferences->historyItemLimit(limit);

   596 }

   597 

   598 HRESULT STDMETHODCALLTYPE WebHistory::setHistoryAgeInDaysLimit( 

   599     /* [in] */ int limit)

   600 {

   601     if (!m_preferences)

   602         return E_FAIL;

   603     return m_preferences->setHistoryAgeInDaysLimit(limit);

   604 }

   605 

   606 HRESULT STDMETHODCALLTYPE WebHistory::historyAgeInDaysLimit( 

   607     /* [retval][out] */ int* limit)

   608 {

   609     if (!m_preferences)

   610         return E_FAIL;

   611     return m_preferences->historyAgeInDaysLimit(limit);

   612 }

   613 

   614 HRESULT WebHistory::removeItem(IWebHistoryItem* entry)

   615 {

   616     HRESULT hr = S_OK;

   617     BSTR urlBStr = 0;

   618 

   619     hr = entry->URLString(&urlBStr);

   620     if (FAILED(hr))

   621         return hr;

   622 

   623     RetainPtr<CFStringRef> urlString(AdoptCF, MarshallingHelpers::BSTRToCFStringRef(urlBStr));

   624     SysFreeString(urlBStr);

   625 

   626     // If this exact object isn't stored, then make no change.

   627     // FIXME: Is this the right behavior if this entry isn't present, but another entry for the same URL is?

   628     // Maybe need to change the API to make something like removeEntryForURLString public instead.

   629     IWebHistoryItem *matchingEntry = (IWebHistoryItem*)CFDictionaryGetValue(m_entriesByURL.get(), urlString.get());

   630     if (matchingEntry != entry)

   631         return E_FAIL;

   632 

   633     hr = removeItemForURLString(urlString.get());

   634     if (FAILED(hr))

   635         return hr;

   636 

   637     COMPtr<CFDictionaryPropertyBag> userInfo = createUserInfoFromHistoryItem(

   638         getNotificationString(kWebHistoryItemsRemovedNotification), entry);

   639     hr = postNotification(kWebHistoryItemsRemovedNotification, userInfo.get());

   640 

   641     return hr;

   642 }

   643 

   644 HRESULT WebHistory::addItem(IWebHistoryItem* entry, bool discardDuplicate, bool* added)

   645 {

   646     HRESULT hr = S_OK;

   647 

   648     if (!entry)

   649         return E_FAIL;

   650 

   651     BSTR urlBStr = 0;

   652     hr = entry->URLString(&urlBStr);

   653     if (FAILED(hr))

   654         return hr;

   655 

   656     RetainPtr<CFStringRef> urlString(AdoptCF, MarshallingHelpers::BSTRToCFStringRef(urlBStr));

   657     SysFreeString(urlBStr);

   658 

   659     COMPtr<IWebHistoryItem> oldEntry((IWebHistoryItem*) CFDictionaryGetValue(

   660         m_entriesByURL.get(), urlString.get()));

   661     

   662     if (oldEntry) {

   663         if (discardDuplicate) {

   664             if (added)

   665                 *added = false;

   666             return S_OK;

   667         }

   668         

   669         removeItemForURLString(urlString.get());

   670 

   671         // If we already have an item with this URL, we need to merge info that drives the

   672         // URL autocomplete heuristics from that item into the new one.

   673         IWebHistoryItemPrivate* entryPriv;

   674         hr = entry->QueryInterface(IID_IWebHistoryItemPrivate, (void**)&entryPriv);

   675         if (SUCCEEDED(hr)) {

   676             entryPriv->mergeAutoCompleteHints(oldEntry.get());

   677             entryPriv->Release();

   678         }

   679     }

   680 

   681     hr = addItemToDateCaches(entry);

   682     if (FAILED(hr))

   683         return hr;

   684 

   685     CFDictionarySetValue(m_entriesByURL.get(), urlString.get(), entry);

   686 

   687     COMPtr<CFDictionaryPropertyBag> userInfo = createUserInfoFromHistoryItem(

   688         getNotificationString(kWebHistoryItemsAddedNotification), entry);

   689     hr = postNotification(kWebHistoryItemsAddedNotification, userInfo.get());

   690 

   691     if (added)

   692         *added = true;

   693 

   694     return hr;

   695 }

   696 

   697 void WebHistory::visitedURL(const KURL& url, const String& title, const String& httpMethod, bool wasFailure, bool increaseVisitCount)

   698 {

   699     RetainPtr<CFStringRef> urlString(AdoptCF, url.string().createCFString());

   700 

   701     IWebHistoryItem* entry = (IWebHistoryItem*) CFDictionaryGetValue(m_entriesByURL.get(), urlString.get());

   702     if (entry) {

   703         COMPtr<IWebHistoryItemPrivate> entryPrivate(Query, entry);

   704         if (!entryPrivate)

   705             return;

   706 

   707         // Remove the item from date caches before changing its last visited date.  Otherwise we might get duplicate entries

   708         // as seen in <rdar://problem/6570573>.

   709         removeItemFromDateCaches(entry);

   710         entryPrivate->visitedWithTitle(BString(title), increaseVisitCount);

   711     } else {

   712         COMPtr<WebHistoryItem> item(AdoptCOM, WebHistoryItem::createInstance());

   713         if (!item)

   714             return;

   715 

   716         entry = item.get();

   717 

   718         SYSTEMTIME currentTime;

   719         GetSystemTime(&currentTime);

   720         DATE lastVisited;

   721         if (!SystemTimeToVariantTime(&currentTime, &lastVisited))

   722             return;

   723 

   724         if (FAILED(entry->initWithURLString(BString(url.string()), BString(title), lastVisited)))

   725             return;

   726         

   727         item->recordInitialVisit();

   728 

   729         CFDictionarySetValue(m_entriesByURL.get(), urlString.get(), entry);

   730     }

   731 

   732     addItemToDateCaches(entry);

   733 

   734     COMPtr<IWebHistoryItemPrivate> entryPrivate(Query, entry);

   735     if (!entryPrivate)

   736         return;

   737 

   738     entryPrivate->setLastVisitWasFailure(wasFailure);

   739     if (!httpMethod.isEmpty())

   740         entryPrivate->setLastVisitWasHTTPNonGet(!equalIgnoringCase(httpMethod, "GET") && url.protocolInHTTPFamily());

   741 

   742     COMPtr<WebHistoryItem> item(Query, entry);

   743     item->historyItem()->setRedirectURLs(0);

   744 

   745     COMPtr<CFDictionaryPropertyBag> userInfo = createUserInfoFromHistoryItem(

   746         getNotificationString(kWebHistoryItemsAddedNotification), entry);

   747     postNotification(kWebHistoryItemsAddedNotification, userInfo.get());

   748 }

   749 

   750 HRESULT WebHistory::itemForURLString(

   751     /* [in] */ CFStringRef urlString,

   752     /* [retval][out] */ IWebHistoryItem** item) const

   753 {

   754     if (!item)

   755         return E_FAIL;

   756     *item = 0;

   757 

   758     IWebHistoryItem* foundItem = (IWebHistoryItem*) CFDictionaryGetValue(m_entriesByURL.get(), urlString);

   759     if (!foundItem)

   760         return E_FAIL;

   761 

   762     foundItem->AddRef();

   763     *item = foundItem;

   764     return S_OK;

   765 }

   766 

   767 HRESULT STDMETHODCALLTYPE WebHistory::itemForURL( 

   768     /* [in] */ BSTR url,

   769     /* [retval][out] */ IWebHistoryItem** item)

   770 {

   771     RetainPtr<CFStringRef> urlString(AdoptCF, MarshallingHelpers::BSTRToCFStringRef(url));

   772     return itemForURLString(urlString.get(), item);

   773 }

   774 

   775 HRESULT WebHistory::removeItemForURLString(CFStringRef urlString)

   776 {

   777     IWebHistoryItem* entry = (IWebHistoryItem*) CFDictionaryGetValue(m_entriesByURL.get(), urlString);

   778     if (!entry) 

   779         return E_FAIL;

   780 

   781     HRESULT hr = removeItemFromDateCaches(entry);

   782     CFDictionaryRemoveValue(m_entriesByURL.get(), urlString);

   783 

   784     if (!CFDictionaryGetCount(m_entriesByURL.get()))

   785         PageGroup::removeAllVisitedLinks();

   786 

   787     return hr;

   788 }

   789 

   790 COMPtr<IWebHistoryItem> WebHistory::itemForURLString(const String& urlString) const

   791 {

   792     RetainPtr<CFStringRef> urlCFString(AdoptCF, urlString.createCFString());

   793     if (!urlCFString)

   794         return 0;

   795     COMPtr<IWebHistoryItem> item;

   796     if (FAILED(itemForURLString(urlCFString.get(), &item)))

   797         return 0;

   798     return item;

   799 }

   800 

   801 HRESULT WebHistory::addItemToDateCaches(IWebHistoryItem* entry)

   802 {

   803     HRESULT hr = S_OK;

   804 

   805     DATE lastVisitedCOMTime;

   806     entry->lastVisitedTimeInterval(&lastVisitedCOMTime);

   807     

   808     DateKey dateKey;

   809     if (findKey(&dateKey, MarshallingHelpers::DATEToCFAbsoluteTime(lastVisitedCOMTime))) {

   810         // other entries already exist for this date

   811         hr = insertItem(entry, dateKey);

   812     } else {

   813         ASSERT(!m_entriesByDate.contains(dateKey));

   814         // no other entries exist for this date

   815         RetainPtr<CFMutableArrayRef> entryArray(AdoptCF, 

   816             CFArrayCreateMutable(0, 0, &MarshallingHelpers::kIUnknownArrayCallBacks));

   817         CFArrayAppendValue(entryArray.get(), entry);

   818         m_entriesByDate.set(dateKey, entryArray);

   819         // Clear m_orderedLastVisitedDays so it will be regenerated when next requested.

   820         m_orderedLastVisitedDays.clear();

   821     }

   822 

   823     return hr;

   824 }

   825 

   826 HRESULT WebHistory::removeItemFromDateCaches(IWebHistoryItem* entry)

   827 {

   828     HRESULT hr = S_OK;

   829 

   830     DATE lastVisitedCOMTime;

   831     entry->lastVisitedTimeInterval(&lastVisitedCOMTime);

   832 

   833     DateKey dateKey;

   834     if (!findKey(&dateKey, MarshallingHelpers::DATEToCFAbsoluteTime(lastVisitedCOMTime)))

   835         return E_FAIL;

   836 

   837     DateToEntriesMap::iterator found = m_entriesByDate.find(dateKey);

   838     ASSERT(found != m_entriesByDate.end());

   839     CFMutableArrayRef entriesForDate = found->second.get();

   840 

   841     CFIndex count = CFArrayGetCount(entriesForDate);

   842     for (int i = count - 1; i >= 0; --i) {

   843         if ((IWebHistoryItem*)CFArrayGetValueAtIndex(entriesForDate, i) == entry)

   844             CFArrayRemoveValueAtIndex(entriesForDate, i);

   845     }

   846 

   847     // remove this date entirely if there are no other entries on it

   848     if (CFArrayGetCount(entriesForDate) == 0) {

   849         m_entriesByDate.remove(found);

   850         // Clear m_orderedLastVisitedDays so it will be regenerated when next requested.

   851         m_orderedLastVisitedDays.clear();

   852     }

   853 

   854     return hr;

   855 }

   856 

   857 static void getDayBoundaries(CFAbsoluteTime day, CFAbsoluteTime& beginningOfDay, CFAbsoluteTime& beginningOfNextDay)

   858 {

   859     RetainPtr<CFTimeZoneRef> timeZone(AdoptCF, CFTimeZoneCopyDefault());

   860     CFGregorianDate date = CFAbsoluteTimeGetGregorianDate(day, timeZone.get());

   861     date.hour = 0;

   862     date.minute = 0;

   863     date.second = 0;

   864     beginningOfDay = CFGregorianDateGetAbsoluteTime(date, timeZone.get());

   865     date.day += 1;

   866     beginningOfNextDay = CFGregorianDateGetAbsoluteTime(date, timeZone.get());

   867 }

   868 

   869 static inline CFAbsoluteTime beginningOfDay(CFAbsoluteTime date)

   870 {

   871     static CFAbsoluteTime cachedBeginningOfDay = numeric_limits<CFAbsoluteTime>::quiet_NaN();

   872     static CFAbsoluteTime cachedBeginningOfNextDay;

   873     if (!(date >= cachedBeginningOfDay && date < cachedBeginningOfNextDay))

   874         getDayBoundaries(date, cachedBeginningOfDay, cachedBeginningOfNextDay);

   875     return cachedBeginningOfDay;

   876 }

   877 

   878 static inline WebHistory::DateKey dateKey(CFAbsoluteTime date)

   879 {

   880     // Converting from double (CFAbsoluteTime) to int64_t (WebHistoryDateKey) is

   881     // safe here because all sensible dates are in the range -2**48 .. 2**47 which

   882     // safely fits in an int64_t.

   883     return beginningOfDay(date);

   884 }

   885 

   886 // Returns whether the day is already in the list of days,

   887 // and fills in *key with the found or proposed key.

   888 bool WebHistory::findKey(DateKey* key, CFAbsoluteTime forDay)

   889 {

   890     ASSERT_ARG(key, key);

   891 

   892     *key = dateKey(forDay);

   893     return m_entriesByDate.contains(*key);

   894 }

   895 

   896 HRESULT WebHistory::insertItem(IWebHistoryItem* entry, DateKey dateKey)

   897 {

   898     ASSERT_ARG(entry, entry);

   899     ASSERT_ARG(dateKey, m_entriesByDate.contains(dateKey));

   900 

   901     HRESULT hr = S_OK;

   902 

   903     if (!entry)

   904         return E_FAIL;

   905 

   906     DATE entryTime;

   907     entry->lastVisitedTimeInterval(&entryTime);

   908     CFMutableArrayRef entriesForDate = m_entriesByDate.get(dateKey).get();

   909     unsigned count = CFArrayGetCount(entriesForDate);

   910 

   911     // The entries for each day are stored in a sorted array with the most recent entry first

   912     // Check for the common cases of the entry being newer than all existing entries or the first entry of the day

   913     bool isNewerThanAllEntries = false;

   914     if (count) {

   915         IWebHistoryItem* item = const_cast<IWebHistoryItem*>(static_cast<const IWebHistoryItem*>(CFArrayGetValueAtIndex(entriesForDate, 0)));

   916         DATE itemTime;

   917         isNewerThanAllEntries = SUCCEEDED(item->lastVisitedTimeInterval(&itemTime)) && itemTime < entryTime;

   918     }

   919     if (!count || isNewerThanAllEntries) {

   920         CFArrayInsertValueAtIndex(entriesForDate, 0, entry);

   921         return S_OK;

   922     }

   923 

   924     // .. or older than all existing entries

   925     bool isOlderThanAllEntries = false;

   926     if (count > 0) {

   927         IWebHistoryItem* item = const_cast<IWebHistoryItem*>(static_cast<const IWebHistoryItem*>(CFArrayGetValueAtIndex(entriesForDate, count - 1)));

   928         DATE itemTime;

   929         isOlderThanAllEntries = SUCCEEDED(item->lastVisitedTimeInterval(&itemTime)) && itemTime >= entryTime;

   930     }

   931     if (isOlderThanAllEntries) {

   932         CFArrayInsertValueAtIndex(entriesForDate, count, entry);

   933         return S_OK;

   934     }

   935 

   936     unsigned low = 0;

   937     unsigned high = count;

   938     while (low < high) {

   939         unsigned mid = low + (high - low) / 2;

   940         IWebHistoryItem* item = const_cast<IWebHistoryItem*>(static_cast<const IWebHistoryItem*>(CFArrayGetValueAtIndex(entriesForDate, mid)));

   941         DATE itemTime;

   942         if (FAILED(item->lastVisitedTimeInterval(&itemTime)))

   943             return E_FAIL;

   944 

   945         if (itemTime >= entryTime)

   946             low = mid + 1;

   947         else

   948             high = mid;

   949     }

   950 

   951     // low is now the index of the first entry that is older than entryDate

   952     CFArrayInsertValueAtIndex(entriesForDate, low, entry);

   953     return S_OK;

   954 }

   955 

   956 CFAbsoluteTime WebHistory::timeToDate(CFAbsoluteTime time)

   957 {

   958     // can't just divide/round since the day boundaries depend on our current time zone

   959     const double secondsPerDay = 60 * 60 * 24;

   960     CFTimeZoneRef timeZone = CFTimeZoneCopySystem();

   961     CFGregorianDate date = CFAbsoluteTimeGetGregorianDate(time, timeZone);

   962     date.hour = date.minute = 0;

   963     date.second = 0.0;

   964     CFAbsoluteTime timeInDays = CFGregorianDateGetAbsoluteTime(date, timeZone);

   965     if (areEqualOrClose(time - timeInDays, secondsPerDay))

   966         timeInDays += secondsPerDay;

   967     return timeInDays;

   968 }

   969 

   970 // Return a date that marks the age limit for history entries saved to or

   971 // loaded from disk. Any entry older than this item should be rejected.

   972 HRESULT WebHistory::ageLimitDate(CFAbsoluteTime* time)

   973 {

   974     // get the current date as a CFAbsoluteTime

   975     CFAbsoluteTime currentDate = timeToDate(CFAbsoluteTimeGetCurrent());

   976 

   977     CFGregorianUnits ageLimit = {0};

   978     int historyLimitDays;

   979     HRESULT hr = historyAgeInDaysLimit(&historyLimitDays);

   980     if (FAILED(hr))

   981         return hr;

   982     ageLimit.days = -historyLimitDays;

   983     *time = CFAbsoluteTimeAddGregorianUnits(currentDate, CFTimeZoneCopySystem(), ageLimit);

   984     return S_OK;

   985 }

   986 

   987 static void addVisitedLinkToPageGroup(const void* key, const void*, void* context)

   988 {

   989     CFStringRef url = static_cast<CFStringRef>(key);

   990     PageGroup* group = static_cast<PageGroup*>(context);

   991 

   992     CFIndex length = CFStringGetLength(url);

   993     const UChar* characters = reinterpret_cast<const UChar*>(CFStringGetCharactersPtr(url));

   994     if (characters)

   995         group->addVisitedLink(characters, length);

   996     else {

   997         Vector<UChar, 512> buffer(length);

   998         CFStringGetCharacters(url, CFRangeMake(0, length), reinterpret_cast<UniChar*>(buffer.data()));

   999         group->addVisitedLink(buffer.data(), length);

  1000     }

  1001 }

  1002 

  1003 void WebHistory::addVisitedLinksToPageGroup(PageGroup& group)

  1004 {

  1005     CFDictionaryApplyFunction(m_entriesByURL.get(), addVisitedLinkToPageGroup, &group);

  1006 }

  1007 

  1008 RetainPtr<CFDataRef> WebHistory::data() const

  1009 {

  1010     if (m_entriesByDate.isEmpty())

  1011         return 0;

  1012 

  1013     WebHistoryWriter writer(m_entriesByDate);

  1014     writer.writePropertyList();

  1015     return writer.releaseData();

  1016 }