https://bugs.webkit.org/show_bug.cgi?id=56425
authorbeidson@apple.com <beidson@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 18 Mar 2011 17:07:22 +0000 (17:07 +0000)
committerbeidson@apple.com <beidson@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 18 Mar 2011 17:07:22 +0000 (17:07 +0000)
More groundwork for WebKit2 IconDatabase

Reviewed by Sam Weinig.

../WebCore:

-Update the synchronous method names to be prefixed with "synchronous."
-Call asynchronous versions of the appropriate methods if the IconDatabase supports them.

Update icon database calls to be prefixed with "synchronous":
* loader/archive/cf/LegacyWebArchive.cpp:
(WebCore::LegacyWebArchive::create):
* loader/icon/IconDatabaseBase.h:
(WebCore::IconDatabaseBase::synchronousIconDataKnownForIconURL):
(WebCore::IconDatabaseBase::synchronousLoadDecisionForIconURL):
(WebCore::IconDatabaseBase::synchronousIconForPageURL):
* loader/icon/IconDatabase.cpp:
(WebCore::IconDatabase::synchronousIconForPageURL):
(WebCore::IconDatabase::readIconForPageURLFromDisk):
(WebCore::IconDatabase::synchronousIconURLForPageURL):
(WebCore::IconDatabase::synchronousLoadDecisionForIconURL):
(WebCore::IconDatabase::synchronousIconDataKnownForIconURL):
* loader/icon/IconDatabase.h:
* loader/icon/IconDatabaseBase.cpp:
(WebCore::IconDatabaseBase::synchronousIconURLForPageURL):

Add nascent support for an asynchronous icon database mode:
* loader/icon/IconDatabaseBase.h:
(WebCore::EnumCallback::create):
(WebCore::EnumCallback::~EnumCallback):
(WebCore::EnumCallback::performCallback):
(WebCore::EnumCallback::invalidate):
(WebCore::EnumCallback::EnumCallback):
(WebCore::ObjectCallback::create):
(WebCore::ObjectCallback::~ObjectCallback):
(WebCore::ObjectCallback::performCallback):
(WebCore::ObjectCallback::invalidate):
(WebCore::ObjectCallback::ObjectCallback):
(WebCore::IconDatabaseBase::supportsAsynchronousMode):
(WebCore::IconDatabaseBase::loadDecisionForIconURL):
(WebCore::IconDatabaseBase::iconDataForIconURL):

Add interfaces to use the asynchronous versions of certain IconDatabase calls:
* loader/DocumentLoader.cpp:
(WebCore::DocumentLoader::~DocumentLoader):
(WebCore::DocumentLoader::iconLoadDecisionAvailable):
(WebCore::iconLoadDecisionCallback):
(WebCore::DocumentLoader::getIconLoadDecisionForIconURL):
(WebCore::DocumentLoader::continueIconLoadWithDecision):
(WebCore::iconDataCallback):
(WebCore::DocumentLoader::getIconDataForIconURL):
* loader/DocumentLoader.h:

Break "startIconLoader" into two pieces so it can be used from both the synchronous and asynchronous
icon database modes:
* loader/FrameLoader.cpp:
(WebCore::FrameLoader::iconLoadDecisionReceived):
(WebCore::FrameLoader::startIconLoader):
(WebCore::FrameLoader::continueIconLoadWithDecision):
* loader/FrameLoader.h:

* WebCore.exp.in:

../WebKit/efl:

Update already-used function names:
* ewk/ewk_history.cpp:
(ewk_history_item_icon_surface_get):
(ewk_history_item_icon_object_add):
* ewk/ewk_settings.cpp:
(ewk_settings_icon_database_icon_surface_get):
(ewk_settings_icon_database_icon_object_add):

../WebKit/gtk:

Update already-used function names:
* webkit/webkiticondatabase.cpp:
(webkit_icon_database_get_icon_uri):
(webkit_icon_database_get_icon_pixbuf):
* webkit/webkitwebview.cpp:
(webkit_web_view_get_icon_uri):

../WebKit/mac:

Update already-used function names:
* Misc/WebIconDatabase.mm:
(-[WebIconDatabase iconForURL:withSize:cache:]):
(-[WebIconDatabase iconURLForURL:]):
* WebView/WebView.mm:
(-[WebView _dispatchDidReceiveIconFromWebFrame:]):

../WebKit/qt:

Update already-used function names:
* Api/qwebhistory.cpp:
(QWebHistoryItem::icon):
* Api/qwebsettings.cpp:
(QWebSettings::iconForUrl):

../WebKit/win:

Update already-used function names:
* WebIconDatabase.cpp:
(WebIconDatabase::iconForURL):
(WebIconDatabase::iconURLForURL):
(WebIconDatabase::hasIconForURL):

../WebKit2:

-Update the synchronous method names to be prefixed with "synchronous."
-Add empty implementations for the asynchronous accessors.

* WebProcess/IconDatabase/WebIconDatabaseProxy.cpp:
(WebKit::WebIconDatabaseProxy::setEnabled):
(WebKit::WebIconDatabaseProxy::synchronousIconForPageURL):
(WebKit::WebIconDatabaseProxy::synchronousIconURLForPageURL):
(WebKit::WebIconDatabaseProxy::synchronousIconDataKnownForIconURL):
(WebKit::WebIconDatabaseProxy::synchronousLoadDecisionForIconURL):
(WebKit::WebIconDatabaseProxy::supportsAsynchronousMode):
(WebKit::WebIconDatabaseProxy::loadDecisionForIconURL):
(WebKit::WebIconDatabaseProxy::iconDataForIconURL):
* WebProcess/IconDatabase/WebIconDatabaseProxy.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@81484 268f45cc-cd09-0410-ab3c-d52691b4dbfc

28 files changed:
Source/WebCore/ChangeLog
Source/WebCore/WebCore.exp.in
Source/WebCore/loader/DocumentLoader.cpp
Source/WebCore/loader/DocumentLoader.h
Source/WebCore/loader/FrameLoader.cpp
Source/WebCore/loader/FrameLoader.h
Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp
Source/WebCore/loader/icon/IconDatabase.cpp
Source/WebCore/loader/icon/IconDatabase.h
Source/WebCore/loader/icon/IconDatabaseBase.cpp
Source/WebCore/loader/icon/IconDatabaseBase.h
Source/WebKit/efl/ChangeLog
Source/WebKit/efl/ewk/ewk_history.cpp
Source/WebKit/efl/ewk/ewk_settings.cpp
Source/WebKit/gtk/ChangeLog
Source/WebKit/gtk/webkit/webkiticondatabase.cpp
Source/WebKit/gtk/webkit/webkitwebview.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/Misc/WebIconDatabase.mm
Source/WebKit/mac/WebView/WebView.mm
Source/WebKit/qt/Api/qwebhistory.cpp
Source/WebKit/qt/Api/qwebsettings.cpp
Source/WebKit/qt/ChangeLog
Source/WebKit/win/ChangeLog
Source/WebKit/win/WebIconDatabase.cpp
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/IconDatabase/WebIconDatabaseProxy.cpp
Source/WebKit2/WebProcess/IconDatabase/WebIconDatabaseProxy.h

index e09cbd20cec9786780364702cf0c9346214120a9..31b0a11ce93b97753a165a073769db6bb6c03796 100644 (file)
@@ -1,3 +1,67 @@
+2011-03-18  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        https://bugs.webkit.org/show_bug.cgi?id=56425
+        More groundwork for WebKit2 IconDatabase
+
+        -Update the synchronous method names to be prefixed with "synchronous."
+        -Call asynchronous versions of the appropriate methods if the IconDatabase supports them.
+
+        Update icon database calls to be prefixed with "synchronous":
+        * loader/archive/cf/LegacyWebArchive.cpp:
+        (WebCore::LegacyWebArchive::create):
+        * loader/icon/IconDatabaseBase.h:
+        (WebCore::IconDatabaseBase::synchronousIconDataKnownForIconURL):
+        (WebCore::IconDatabaseBase::synchronousLoadDecisionForIconURL):
+        (WebCore::IconDatabaseBase::synchronousIconForPageURL):
+        * loader/icon/IconDatabase.cpp:
+        (WebCore::IconDatabase::synchronousIconForPageURL):
+        (WebCore::IconDatabase::readIconForPageURLFromDisk):
+        (WebCore::IconDatabase::synchronousIconURLForPageURL):
+        (WebCore::IconDatabase::synchronousLoadDecisionForIconURL):
+        (WebCore::IconDatabase::synchronousIconDataKnownForIconURL):
+        * loader/icon/IconDatabase.h:
+        * loader/icon/IconDatabaseBase.cpp:
+        (WebCore::IconDatabaseBase::synchronousIconURLForPageURL):
+
+        Add nascent support for an asynchronous icon database mode:
+        * loader/icon/IconDatabaseBase.h:
+        (WebCore::EnumCallback::create):
+        (WebCore::EnumCallback::~EnumCallback):
+        (WebCore::EnumCallback::performCallback):
+        (WebCore::EnumCallback::invalidate):
+        (WebCore::EnumCallback::EnumCallback):
+        (WebCore::ObjectCallback::create):
+        (WebCore::ObjectCallback::~ObjectCallback):
+        (WebCore::ObjectCallback::performCallback):
+        (WebCore::ObjectCallback::invalidate):
+        (WebCore::ObjectCallback::ObjectCallback):
+        (WebCore::IconDatabaseBase::supportsAsynchronousMode):
+        (WebCore::IconDatabaseBase::loadDecisionForIconURL):
+        (WebCore::IconDatabaseBase::iconDataForIconURL):
+
+        Add interfaces to use the asynchronous versions of certain IconDatabase calls:
+        * loader/DocumentLoader.cpp:
+        (WebCore::DocumentLoader::~DocumentLoader):
+        (WebCore::DocumentLoader::iconLoadDecisionAvailable):
+        (WebCore::iconLoadDecisionCallback):
+        (WebCore::DocumentLoader::getIconLoadDecisionForIconURL):
+        (WebCore::DocumentLoader::continueIconLoadWithDecision):
+        (WebCore::iconDataCallback):
+        (WebCore::DocumentLoader::getIconDataForIconURL):
+        * loader/DocumentLoader.h:
+
+        Break "startIconLoader" into two pieces so it can be used from both the synchronous and asynchronous 
+        icon database modes:
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::iconLoadDecisionReceived):
+        (WebCore::FrameLoader::startIconLoader):
+        (WebCore::FrameLoader::continueIconLoadWithDecision):
+        * loader/FrameLoader.h:
+
+        * WebCore.exp.in:
+
 2011-03-18  Pavel Feldman  <pfeldman@chromium.org>
 
         Not reviewed: add missing brace to the generated Inspector.idl.
index 1686a8652eb04342cabce393f30622ea1bd0b9be..007f0f487f26163f8b3188dbc140af75243abc21 100644 (file)
@@ -245,10 +245,8 @@ __ZN7WebCore12GCController17garbageCollectNowEv
 __ZN7WebCore12GCController43garbageCollectOnAlternateThreadForDebuggingEb
 __ZN7WebCore12IconDatabase10setEnabledEb
 __ZN7WebCore12IconDatabase11defaultIconERKNS_7IntSizeE
-__ZN7WebCore12IconDatabase14iconForPageURLERKN3WTF6StringERKNS_7IntSizeE
 __ZN7WebCore12IconDatabase14removeAllIconsEv
 __ZN7WebCore12IconDatabase15iconRecordCountEv
-__ZN7WebCore12IconDatabase17iconURLForPageURLERKN3WTF6StringE
 __ZN7WebCore12IconDatabase19pageURLMappingCountEv
 __ZN7WebCore12IconDatabase20allowDatabaseCleanupEv
 __ZN7WebCore12IconDatabase20delayDatabaseCleanupEv   
@@ -426,6 +424,7 @@ __ZN7WebCore16FontFallbackList15releaseFontDataEv
 __ZN7WebCore16FontPlatformDataC1EP6NSFontfbbNS_15FontOrientationENS_15TextOrientationENS_16FontWidthVariantE
 __ZN7WebCore16FontPlatformDataD1Ev
 __ZN7WebCore16HTMLInputElement13setAutofilledEb
+__ZN7WebCore16IconDatabaseBase28synchronousIconURLForPageURLERKN3WTF6StringE
 __ZN7WebCore16LegacyWebArchive19createFromSelectionEPNS_5FrameE
 __ZN7WebCore16LegacyWebArchive21rawDataRepresentationEv
 __ZN7WebCore16LegacyWebArchive6createEN3WTF10PassRefPtrINS_15ArchiveResourceEEERNS1_6VectorIS4_Lm0EEERNS5_INS2_IS0_EELm0EEE
index e223765830d10328f2d7453de4c02bc3b32b8796..601ddfca54378d0124654d91b2a77ea777a0b21d 100644 (file)
@@ -112,6 +112,10 @@ FrameLoader* DocumentLoader::frameLoader() const
 DocumentLoader::~DocumentLoader()
 {
     ASSERT(!m_frame || frameLoader()->activeDocumentLoader() != this || !frameLoader()->isLoading());
+    if (m_iconLoadDecisionCallback)
+        m_iconLoadDecisionCallback->invalidate();
+    if (m_iconDataCallback)
+        m_iconDataCallback->invalidate();
 }
 
 PassRefPtr<SharedBuffer> DocumentLoader::mainResourceData() const
@@ -836,7 +840,39 @@ void DocumentLoader::transferLoadingResourcesFromPage(Page* oldPage)
 void DocumentLoader::iconLoadDecisionAvailable()
 {
     if (m_frame)
-        m_frame->loader()->iconLoadDecisionAvailable();
+        m_frame->loader()->iconLoadDecisionReceived(iconDatabase().synchronousLoadDecisionForIconURL(KURL(frameLoader()->iconURL()), this));
 }
 
+static void iconLoadDecisionCallback(IconLoadDecision decision, void* context)
+{
+    static_cast<DocumentLoader*>(context)->continueIconLoadWithDecision(decision);
+}
+
+void DocumentLoader::getIconLoadDecisionForIconURL(const String& urlString)
+{
+    if (m_iconLoadDecisionCallback)
+        m_iconLoadDecisionCallback->invalidate();
+    m_iconLoadDecisionCallback = IconLoadDecisionCallback::create(this, iconLoadDecisionCallback);
+    iconDatabase().loadDecisionForIconURL(urlString, m_iconLoadDecisionCallback);
+}
+
+void DocumentLoader::continueIconLoadWithDecision(IconLoadDecision decision)
+{
+    if (m_frame)
+        m_frame->loader()->continueIconLoadWithDecision(decision);
+}
+
+static void iconDataCallback(SharedBuffer*, void*)
+{
+    // FIXME: Implement this once we know what parts of WebCore actually need the icon data returned.
 }
+
+void DocumentLoader::getIconDataForIconURL(const String& urlString)
+{   
+    if (m_iconDataCallback)
+        m_iconDataCallback->invalidate();
+    m_iconDataCallback = IconDataCallback::create(this, iconDataCallback);
+    iconDatabase().iconDataForIconURL(urlString, m_iconDataCallback);
+}
+
+} // namespace WebCore
index 8e9ab8f74d815d24b8ea005b026469595b934b67..0d26921395316a870dcd56710a04ced0fe314030 100644 (file)
@@ -31,6 +31,7 @@
 
 #include "DocumentLoadTiming.h"
 #include "DocumentWriter.h"
+#include "IconDatabaseBase.h"
 #include "NavigationAction.h"
 #include "ResourceError.h"
 #include "ResourceRequest.h"
@@ -193,8 +194,14 @@ namespace WebCore {
         bool startLoadingMainResource(unsigned long identifier);
         void cancelMainResourceLoad(const ResourceError&);
         
+        // Support iconDatabase in synchronous mode.
         void iconLoadDecisionAvailable();
         
+        // Support iconDatabase in asynchronous mode.
+        void continueIconLoadWithDecision(IconLoadDecision);
+        void getIconLoadDecisionForIconURL(const String&);
+        void getIconDataForIconURL(const String&);
+        
         bool isLoadingMainResource() const;
         bool isLoadingSubresources() const;
         bool isLoadingPlugIns() const;
@@ -326,6 +333,9 @@ namespace WebCore {
         bool m_didCreateGlobalHistoryEntry;
 
         DocumentLoadTiming m_documentLoadTiming;
+    
+        RefPtr<IconLoadDecisionCallback> m_iconLoadDecisionCallback;
+        RefPtr<IconDataCallback> m_iconDataCallback;
 
 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
         friend class ApplicationCacheHost;  // for substitute resource delivery
index 25fa7877644f5406c267e297df1850354ffaa149..4e53b41a4cf3acec80d413140d4cf8147c617f6c 100644 (file)
@@ -678,12 +678,13 @@ void FrameLoader::didEndDocument()
     m_isLoadingMainResource = false;
 }
 
-void FrameLoader::iconLoadDecisionAvailable()
+// Callback for the old-style synchronous IconDatabase interface.
+void FrameLoader::iconLoadDecisionReceived(IconLoadDecision iconLoadDecision)
 {
     if (!m_mayLoadIconLater)
         return;
     LOG(IconDatabase, "FrameLoader %p was told a load decision is available for its icon", this);
-    startIconLoader();
+    continueIconLoadWithDecision(iconLoadDecision);
     m_mayLoadIconLater = false;
 }
 
@@ -702,48 +703,73 @@ void FrameLoader::startIconLoader()
     if (urlString.isEmpty())
         return;
 
-    // If we're not reloading and the icon database doesn't say to load now then bail before we actually start the load
-    if (loadType() != FrameLoadTypeReload && loadType() != FrameLoadTypeReloadFromOrigin) {
-        IconLoadDecision decision = iconDatabase().loadDecisionForIconURL(urlString, m_documentLoader.get());
-        if (decision == IconLoadNo) {
-            LOG(IconDatabase, "FrameLoader::startIconLoader() - Told not to load this icon, committing iconURL %s to database for pageURL mapping", urlString.ascii().data());
-            commitIconURLToIconDatabase(url);
-            
-            // We were told not to load this icon - that means this icon is already known by the database
-            // If the icon data hasn't been read in from disk yet, kick off the read of the icon from the database to make sure someone
-            // has done it.  This is after registering for the notification so the WebView can call the appropriate delegate method.
-            // Otherwise if the icon data *is* available, notify the delegate
-            if (!iconDatabase().iconDataKnownForIconURL(urlString)) {
-                LOG(IconDatabase, "Told not to load icon %s but icon data is not yet available - registering for notification and requesting load from disk", urlString.ascii().data());
-                m_client->registerForIconNotification();
-                iconDatabase().iconForPageURL(m_frame->document()->url().string(), IntSize(0, 0));
-                iconDatabase().iconForPageURL(originalRequestURL().string(), IntSize(0, 0));
-            } else
-                m_client->dispatchDidReceiveIcon();
-                
-            return;
-        } 
-        
-        if (decision == IconLoadUnknown) {
-            // In this case, we may end up loading the icon later, but we still want to commit the icon url mapping to the database
-            // just in case we don't end up loading later - if we commit the mapping a second time after the load, that's no big deal
-            // We also tell the client to register for the notification that the icon is received now so it isn't missed in case the 
-            // icon is later read in from disk
-            LOG(IconDatabase, "FrameLoader %p might load icon %s later", this, urlString.ascii().data());
-            m_mayLoadIconLater = true;    
-            m_client->registerForIconNotification();
-            commitIconURLToIconDatabase(url);
-            return;
-        }
-    }
-
     // People who want to avoid loading images generally want to avoid loading all images.
     // Now that we've accounted for URL mapping, avoid starting the network load if images aren't set to display automatically.
     Settings* settings = m_frame->settings();
     if (settings && !settings->loadsImagesAutomatically())
         return;
 
-    // This is either a reload or the icon database said "yes, load the icon", so kick off the load!
+    // If we're reloading the page, always start the icon load now.
+    if (loadType() == FrameLoadTypeReload && loadType() == FrameLoadTypeReloadFromOrigin) {
+        continueIconLoadWithDecision(IconLoadYes);
+        return;
+    }
+
+    if (iconDatabase().supportsAsynchronousMode()) {
+        m_documentLoader->getIconLoadDecisionForIconURL(urlString);
+        // Commit the icon url mapping to the database just in case we don't end up loading later.
+        commitIconURLToIconDatabase(url);
+        return;
+    }
+    
+    IconLoadDecision decision = iconDatabase().synchronousLoadDecisionForIconURL(urlString, m_documentLoader.get());
+
+    if (decision == IconLoadUnknown) {
+        // In this case, we may end up loading the icon later, but we still want to commit the icon url mapping to the database
+        // just in case we don't end up loading later - if we commit the mapping a second time after the load, that's no big deal
+        // We also tell the client to register for the notification that the icon is received now so it isn't missed in case the 
+        // icon is later read in from disk
+        LOG(IconDatabase, "FrameLoader %p might load icon %s later", this, urlString.ascii().data());
+        m_mayLoadIconLater = true;    
+        m_client->registerForIconNotification();
+        commitIconURLToIconDatabase(url);
+        return;
+    }
+
+    continueIconLoadWithDecision(decision);
+}
+
+void FrameLoader::continueIconLoadWithDecision(IconLoadDecision iconLoadDecision)
+{
+    ASSERT(iconLoadDecision != IconLoadUnknown);
+    
+    if (iconLoadDecision == IconLoadNo) {
+        KURL url(iconURL());
+        String urlString(url.string());
+        
+        LOG(IconDatabase, "FrameLoader::startIconLoader() - Told not to load this icon, committing iconURL %s to database for pageURL mapping", urlString.ascii().data());
+        commitIconURLToIconDatabase(url);
+        
+        if (iconDatabase().supportsAsynchronousMode()) {
+            m_documentLoader->getIconDataForIconURL(urlString);
+            return;
+        }
+        
+        // We were told not to load this icon - that means this icon is already known by the database
+        // If the icon data hasn't been read in from disk yet, kick off the read of the icon from the database to make sure someone
+        // has done it. This is after registering for the notification so the WebView can call the appropriate delegate method.
+        // Otherwise if the icon data *is* available, notify the delegate
+        if (!iconDatabase().synchronousIconDataKnownForIconURL(urlString)) {
+            LOG(IconDatabase, "Told not to load icon %s but icon data is not yet available - registering for notification and requesting load from disk", urlString.ascii().data());
+            m_client->registerForIconNotification();
+            iconDatabase().synchronousIconForPageURL(m_frame->document()->url().string(), IntSize(0, 0));
+            iconDatabase().synchronousIconForPageURL(originalRequestURL().string(), IntSize(0, 0));
+        } else
+            m_client->dispatchDidReceiveIcon();
+            
+        return;
+    } 
+    
     if (!m_iconLoader)
         m_iconLoader = IconLoader::create(m_frame);
         
index d59eb165c512fe654f04f29f4049cffe4235e88e..3781d8dda2fe58369277e76816d8d5fa0734b121 100644 (file)
@@ -35,6 +35,7 @@
 #include "FrameLoaderStateMachine.h"
 #include "FrameLoaderTypes.h"
 #include "HistoryController.h"
+#include "IconDatabaseBase.h"
 #include "PolicyChecker.h"
 #include "ResourceLoadNotifier.h"
 #include "SubframeLoader.h"
@@ -289,13 +290,13 @@ public:
 
     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
 
-    void iconLoadDecisionAvailable();
+    void startIconLoader();
+    void iconLoadDecisionReceived(IconLoadDecision);
+    void continueIconLoadWithDecision(IconLoadDecision);
 
     bool shouldAllowNavigation(Frame* targetFrame) const;
     Frame* findFrameForNavigation(const AtomicString& name);
 
-    void startIconLoader();
-
     void applyUserAgent(ResourceRequest& request);
 
     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
index 7979423c9dbd15fa43d3c0d29d123e515cca263e..6e0a1ebf2b0b41982748072f820777210f84ef5e 100644 (file)
@@ -546,9 +546,9 @@ PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(const String& markupString
 
     // Add favicon if one exists for this page, if we are archiving the entire page.
     if (nodesSize && nodes[0]->isDocumentNode() && iconDatabase().isEnabled()) {
-        const String& iconURL = iconDatabase().iconURLForPageURL(responseURL);
-        if (!iconURL.isEmpty() && iconDatabase().iconDataKnownForIconURL(iconURL)) {
-            if (Image* iconImage = iconDatabase().iconForPageURL(responseURL, IntSize(16, 16))) {
+        const String& iconURL = iconDatabase().synchronousIconURLForPageURL(responseURL);
+        if (!iconURL.isEmpty() && iconDatabase().synchronousIconDataKnownForIconURL(iconURL)) {
+            if (Image* iconImage = iconDatabase().synchronousIconForPageURL(responseURL, IntSize(16, 16))) {
                 if (RefPtr<ArchiveResource> resource = ArchiveResource::create(iconImage->data(), KURL(ParsedURLString, iconURL), "image/x-icon", "", ""))
                     subresources.append(resource.release());
             }
index df6c2033cc4be2473d163cbd849a752c2c7fbf6c..a8ad4e48127fb18dc619d94ae1fe26c8675e4a1c 100644 (file)
@@ -202,7 +202,7 @@ void IconDatabase::removeAllIcons()
     wakeSyncThread();
 }
 
-Image* IconDatabase::iconForPageURL(const String& pageURLOriginal, const IntSize& size)
+Image* IconDatabase::synchronousIconForPageURL(const String& pageURLOriginal, const IntSize& size)
 {   
     ASSERT_NOT_SYNC_THREAD();
 
@@ -286,10 +286,10 @@ void IconDatabase::readIconForPageURLFromDisk(const String& pageURL)
     // The effect of asking for an Icon for a pageURL automatically queues it to be read from disk
     // if it hasn't already been set in memory.  The special IntSize (0, 0) is a special way of telling 
     // that method "I don't care about the actual Image, i just want you to make sure you're getting it from disk.
-    iconForPageURL(pageURL, IntSize(0,0));
+    synchronousIconForPageURL(pageURL, IntSize(0, 0));
 }
 
-String IconDatabase::iconURLForPageURL(const String& pageURLOriginal)
+String IconDatabase::synchronousIconURLForPageURL(const String& pageURLOriginal)
 {    
     ASSERT_NOT_SYNC_THREAD(); 
         
@@ -626,7 +626,7 @@ void IconDatabase::setIconURLForPageURL(const String& iconURLOriginal, const Str
     }
 }
 
-IconLoadDecision IconDatabase::loadDecisionForIconURL(const String& iconURL, DocumentLoader* notificationDocumentLoader)
+IconLoadDecision IconDatabase::synchronousLoadDecisionForIconURL(const String& iconURL, DocumentLoader* notificationDocumentLoader)
 {
     ASSERT_NOT_SYNC_THREAD();
 
@@ -657,7 +657,7 @@ IconLoadDecision IconDatabase::loadDecisionForIconURL(const String& iconURL, Doc
     return IconLoadUnknown;
 }
 
-bool IconDatabase::iconDataKnownForIconURL(const String& iconURL)
+bool IconDatabase::synchronousIconDataKnownForIconURL(const String& iconURL)
 {
     ASSERT_NOT_SYNC_THREAD();
     
index 3125cde54afd55e8fa34475cde72a843bbf91393..6a119c31289693314aada0edcbb22834c95a6c7d 100644 (file)
@@ -84,14 +84,13 @@ public:
 
     virtual void retainIconForPageURL(const String&);
     virtual void releaseIconForPageURL(const String&);
-
-    virtual Image* iconForPageURL(const String&, const IntSize&);
-    virtual String iconURLForPageURL(const String&);
+    virtual void setIconDataForIconURL(PassRefPtr<SharedBuffer> data, const String&);
     virtual void setIconURLForPageURL(const String& iconURL, const String& pageURL);
 
-    virtual void setIconDataForIconURL(PassRefPtr<SharedBuffer> data, const String&);
-    virtual bool iconDataKnownForIconURL(const String&);
-    virtual IconLoadDecision loadDecisionForIconURL(const String&, DocumentLoader*);    
+    virtual Image* synchronousIconForPageURL(const String&, const IntSize&);
+    virtual String synchronousIconURLForPageURL(const String&);
+    virtual bool synchronousIconDataKnownForIconURL(const String&);
+    virtual IconLoadDecision synchronousLoadDecisionForIconURL(const String&, DocumentLoader*);    
     
     virtual void setEnabled(bool);
     virtual bool isEnabled() const;
index 948a00e1a3e3232e60a8034cf58f56b1937fac3e..628518028f700147f9a02441c09cc5aafca78d0f 100644 (file)
@@ -31,7 +31,7 @@
 
 namespace WebCore {
 
-String IconDatabaseBase::iconURLForPageURL(const String&)
+String IconDatabaseBase::synchronousIconURLForPageURL(const String&)
 {
     return String();
 }
index 578edc5fe02bc24a8ab3e9bca7af6e7e3c5af1d5..1cf7a989002763db05c686d2f308fa65700de903 100644 (file)
@@ -45,6 +45,87 @@ enum IconLoadDecision {
     IconLoadUnknown
 };
 
+template<typename EnumType> 
+class EnumCallback : public RefCounted<EnumCallback<EnumType> > {
+public:
+    typedef void (*CallbackFunction)(EnumType, void*);
+
+    static PassRefPtr<EnumCallback> create(void* context, CallbackFunction callback)
+    {
+        return adoptRef(new EnumCallback(context, callback));
+    }
+
+    virtual ~EnumCallback()
+    {
+        ASSERT(!m_callback);
+    }
+
+    void performCallback(EnumType result)
+    {
+        ASSERT(m_callback);
+        m_callback(result, m_context);
+        m_callback = 0;
+    }
+    
+    void invalidate()
+    {
+        ASSERT(m_callback);
+        m_callback = 0;
+    }
+
+private:
+    EnumCallback(void* context, CallbackFunction callback)
+        : m_context(context)
+        , m_callback(callback)
+    {
+    }
+
+    void* m_context;
+    CallbackFunction m_callback;
+};
+
+template<typename ObjectType> 
+class ObjectCallback : public RefCounted<ObjectCallback<ObjectType> > {
+public:
+    typedef void (*CallbackFunction)(ObjectType, void*);
+
+    static PassRefPtr<ObjectCallback> create(void* context, CallbackFunction callback)
+    {
+        return adoptRef(new ObjectCallback(context, callback));
+    }
+
+    virtual ~ObjectCallback()
+    {
+        ASSERT(!m_callback);
+    }
+
+    void performCallback(ObjectType result)
+    {
+        ASSERT(m_callback);
+        m_callback(result, m_context);
+        m_callback = 0;
+    }
+    
+    void invalidate()
+    {
+        ASSERT(m_callback);
+        m_callback = 0;
+    }
+
+private:
+    ObjectCallback(void* context, CallbackFunction callback)
+        : m_context(context)
+        , m_callback(callback)
+    {
+    }
+
+    void* m_context;
+    CallbackFunction m_callback;
+};
+
+typedef EnumCallback<IconLoadDecision> IconLoadDecisionCallback;
+typedef ObjectCallback<SharedBuffer*> IconDataCallback;
+
 class IconDatabaseBase {
     WTF_MAKE_NONCOPYABLE(IconDatabaseBase);
 
@@ -56,19 +137,26 @@ public:
 
     // Used internally by WebCore
     virtual bool isEnabled() const { return false; }
-    
-    virtual Image* iconForPageURL(const String&, const IntSize&) { return 0; }
-    
+        
     virtual void retainIconForPageURL(const String&) { }
     virtual void releaseIconForPageURL(const String&) { }
 
-    virtual String iconURLForPageURL(const String&);
-    virtual bool iconDataKnownForIconURL(const String&) { return false; }
-    virtual IconLoadDecision loadDecisionForIconURL(const String&, DocumentLoader*) { return IconLoadNo; }
-    
     virtual void setIconURLForPageURL(const String&, const String&) { }
     virtual void setIconDataForIconURL(PassRefPtr<SharedBuffer>, const String&) { }
 
+    // Synchronous calls used internally by WebCore.
+    // Usage should be replaced by asynchronous calls.
+    virtual String synchronousIconURLForPageURL(const String&);
+    virtual bool synchronousIconDataKnownForIconURL(const String&) { return false; }
+    virtual IconLoadDecision synchronousLoadDecisionForIconURL(const String&, DocumentLoader*) { return IconLoadNo; }
+    virtual Image* synchronousIconForPageURL(const String&, const IntSize&) { return 0; }
+    
+    // Asynchronous calls we should use to replace the above when supported.
+    virtual bool supportsAsynchronousMode() { return false; }
+    virtual void loadDecisionForIconURL(const String&, PassRefPtr<IconLoadDecisionCallback>) { }
+    virtual void iconDataForIconURL(const String&, PassRefPtr<IconDataCallback>) { }
+    
+
     // Used within one or more WebKit ports.
     // We should try to remove these dependencies from the IconDatabaseBase class.
     virtual void setEnabled(bool) { }
index 78144159491db277017ddec4f09fc7bf69de1cb4..5be16d9c110bbe006b76da9f154e1c97dbd5251c 100644 (file)
@@ -1,3 +1,18 @@
+2011-03-17  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        https://bugs.webkit.org/show_bug.cgi?id=56425
+        More groundwork for WebKit2 IconDatabase
+
+        Update already-used function names:
+        * ewk/ewk_history.cpp:
+        (ewk_history_item_icon_surface_get):
+        (ewk_history_item_icon_object_add):
+        * ewk/ewk_settings.cpp:
+        (ewk_settings_icon_database_icon_surface_get):
+        (ewk_settings_icon_database_icon_object_add):
+
 2011-03-16  Joseph Pecoraro  <joepeck@webkit.org>
 
         Reviewed by Kenneth Rohde Christiansen.
index c39687eed58cd9c98a3d87369ec51973fbf4937a..fb70903b5d649d61781ecf932c79b42dba5622ac 100644 (file)
@@ -581,7 +581,7 @@ cairo_surface_t* ewk_history_item_icon_surface_get(const Ewk_History_Item* item)
 {
     EWK_HISTORY_ITEM_CORE_GET_OR_RETURN(item, core, 0);
     
-    WebCore::Image* icon = WebCore::iconDatabase().iconForPageURL(core->url(), WebCore::IntSize(16, 16));
+    WebCore::Image* icon = WebCore::iconDatabase().synchronousIconForPageURL(core->url(), WebCore::IntSize(16, 16));
     if (!icon) {
         ERR("icon is NULL.");
         return 0;
@@ -609,7 +609,7 @@ Evas_Object* ewk_history_item_icon_object_add(const Ewk_History_Item* item, Evas
 {
     EWK_HISTORY_ITEM_CORE_GET_OR_RETURN(item, core, 0);
     EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);
-    WebCore::Image* icon = WebCore::iconDatabase().iconForPageURL(core->url(), WebCore::IntSize(16, 16));
+    WebCore::Image* icon = WebCore::iconDatabase().synchronousIconForPageURL(core->url(), WebCore::IntSize(16, 16));
     cairo_surface_t* surface;
 
     if (!icon) {
index d6e8506d6200ce616918aae215ae050cf11b56fb..3ae503a4ce7d0e06fdb463b1b8a4af3fe727da09 100644 (file)
@@ -231,7 +231,7 @@ cairo_surface_t* ewk_settings_icon_database_icon_surface_get(const char *url)
     EINA_SAFETY_ON_NULL_RETURN_VAL(url, 0);
 
     WebCore::KURL kurl(WebCore::KURL(), WTF::String::fromUTF8(url));
-    WebCore::Image *icon = WebCore::iconDatabase().iconForPageURL(kurl.string(), WebCore::IntSize(16, 16));
+    WebCore::Image *icon = WebCore::iconDatabase().synchronousIconForPageURL(kurl.string(), WebCore::IntSize(16, 16));
 
     if (!icon) {
         ERR("no icon for url %s", url);
@@ -263,7 +263,7 @@ Evas_Object* ewk_settings_icon_database_icon_object_add(const char* url, Evas* c
     EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);
 
     WebCore::KURL kurl(WebCore::KURL(), WTF::String::fromUTF8(url));
-    WebCore::Image* icon = WebCore::iconDatabase().iconForPageURL(kurl.string(), WebCore::IntSize(16, 16));
+    WebCore::Image* icon = WebCore::iconDatabase().synchronousIconForPageURL(kurl.string(), WebCore::IntSize(16, 16));
     cairo_surface_t* surface;
 
     if (!icon) {
index 08bf7ab2510a086722c87dd7c11d93680f487f34..93f9d2253d4210f89517abecb1da433c18e9bb7a 100644 (file)
@@ -1,3 +1,17 @@
+2011-03-17  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        https://bugs.webkit.org/show_bug.cgi?id=56425
+        More groundwork for WebKit2 IconDatabase
+
+        Update already-used function names:
+        * webkit/webkiticondatabase.cpp:
+        (webkit_icon_database_get_icon_uri):
+        (webkit_icon_database_get_icon_pixbuf):
+        * webkit/webkitwebview.cpp:
+        (webkit_web_view_get_icon_uri):
+
 2011-03-16  Joseph Pecoraro  <joepeck@webkit.org>
 
         Reviewed by Kenneth Rohde Christiansen.
index c1562b03be52e42df967fca0df34d2fc7769f105..88116237a3f01143da3953d94a01d9295dce1a59 100644 (file)
@@ -261,7 +261,7 @@ gchar* webkit_icon_database_get_icon_uri(WebKitIconDatabase* database, const gch
     g_return_val_if_fail(pageURI, 0);
 
     String pageURL = String::fromUTF8(pageURI);
-    return g_strdup(WebCore::iconDatabase().iconURLForPageURL(pageURL).utf8().data());
+    return g_strdup(WebCore::iconDatabase().synchronousIconURLForPageURL(pageURL).utf8().data());
 }
 
 /**
@@ -291,7 +291,7 @@ GdkPixbuf* webkit_icon_database_get_icon_pixbuf(WebKitIconDatabase* database, co
     String pageURL = String::fromUTF8(pageURI);
     // The exact size we pass is irrelevant to the WebCore::iconDatabase code.
     // We must pass something greater than 0, 0 to get a pixbuf.
-    WebCore::Image* icon = WebCore::iconDatabase().iconForPageURL(pageURL, WebCore::IntSize(16, 16));
+    WebCore::Image* icon = WebCore::iconDatabase().synchronousIconForPageURL(pageURL, WebCore::IntSize(16, 16));
     if (!icon)
         return 0;
     GdkPixbuf* pixbuf = icon->getGdkPixbuf();
index 46b1b89eadef67e55fd090044b5bb5a0fbb36277..e609d318b5e42ad48cdd9fbd91a1ef7e6bccbe2f 100644 (file)
@@ -5066,7 +5066,7 @@ WebKitHitTestResult* webkit_web_view_get_hit_test_result(WebKitWebView* webView,
 G_CONST_RETURN gchar* webkit_web_view_get_icon_uri(WebKitWebView* webView)
 {
     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
-    String iconURL = iconDatabase().iconURLForPageURL(core(webView)->mainFrame()->document()->url().prettyURL());
+    String iconURL = iconDatabase().synchronousIconURLForPageURL(core(webView)->mainFrame()->document()->url().prettyURL());
     webView->priv->iconURI = iconURL.utf8();
     return webView->priv->iconURI.data();
 }
index 89473b37250ec3d5407ee9527ee9765dfe4e2900..fb4c3ae1f88ff7b2ada7dfcf25bdca52306e4536 100644 (file)
@@ -1,3 +1,17 @@
+2011-03-17  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        https://bugs.webkit.org/show_bug.cgi?id=56425
+        More groundwork for WebKit2 IconDatabase
+
+        Update already-used function names:
+        * Misc/WebIconDatabase.mm:
+        (-[WebIconDatabase iconForURL:withSize:cache:]):
+        (-[WebIconDatabase iconURLForURL:]):
+        * WebView/WebView.mm:
+        (-[WebView _dispatchDidReceiveIconFromWebFrame:]):
+
 2011-03-18  Pavel Podivilov  <podivilov@chromium.org>
 
         Reviewed by Yury Semikhatsky.
index d82f8512da6e3d28cc445e024daf2dc222040b09..c1cdbf0f2d0cedb087e07ed4bf18b0caa3981898 100644 (file)
@@ -137,8 +137,8 @@ static WebIconDatabaseClient* defaultClient()
     // FIXME - <rdar://problem/4697934> - Move the handling of FileURLs to WebCore and implement in ObjC++
     if ([URL _webkit_isFileURL])
         return [self _iconForFileURL:URL withSize:size];
-      
-    if (Image* image = iconDatabase().iconForPageURL(URL, IntSize(size)))
+    
+    if (Image* image = iconDatabase().synchronousIconForPageURL(URL, IntSize(size)))
         if (NSImage *icon = webGetNSImage(image, size))
             return icon;
     return [self defaultIconForURL:URL withSize:size];
@@ -155,7 +155,7 @@ static WebIconDatabaseClient* defaultClient()
         return nil;
     ASSERT_MAIN_THREAD();
 
-    return iconDatabase().iconURLForPageURL(URL);
+    return iconDatabase().synchronousIconURLForPageURL(URL);
 }
 
 - (NSImage *)defaultIconWithSize:(NSSize)size
index 006e10eb6b19c9741ede20e4558b639221869c9b..a05a9872fcc45ba637d30cee5765643607cbe837 100644 (file)
@@ -5864,7 +5864,7 @@ static inline uint64_t roundUpToPowerOf2(uint64_t num)
 
     WebFrameLoadDelegateImplementationCache* cache = &_private->frameLoadDelegateImplementations;
     if (cache->didReceiveIconForFrameFunc) {
-        Image* image = iconDatabase().iconForPageURL(core(webFrame)->document()->url().string(), IntSize(16, 16));
+        Image* image = iconDatabase().synchronousIconForPageURL(core(webFrame)->document()->url().string(), IntSize(16, 16));
         if (NSImage *icon = webGetNSImage(image, NSMakeSize(16, 16)))
             CallFrameLoadDelegate(cache->didReceiveIconForFrameFunc, self, @selector(webView:didReceiveIcon:forFrame:), icon, webFrame);
     }
index 4abb4581b4a5f96eb961574fad061f4143fee7ea..33bad4174c93636d54e045e8770da5c09b71052e 100644 (file)
@@ -158,7 +158,7 @@ QDateTime QWebHistoryItem::lastVisited() const
 QIcon QWebHistoryItem::icon() const
 {
     if (d->item)
-        return *WebCore::iconDatabase().iconForPageURL(d->item->url(), WebCore::IntSize(16, 16))->nativeImageForCurrentFrame();
+        return *WebCore::iconDatabase().synchronousIconForPageURL(d->item->url(), WebCore::IntSize(16, 16))->nativeImageForCurrentFrame();
 
     return QIcon();
 }
index 972d1b1df9e3c9241652b4c6530b453dcb1b514c..5310426bcf7a1818c59cf8efab5b4f078fa76376 100644 (file)
@@ -693,7 +693,7 @@ void QWebSettings::clearIconDatabase()
 */
 QIcon QWebSettings::iconForUrl(const QUrl& url)
 {
-    WebCore::Image* image = WebCore::iconDatabase().iconForPageURL(WebCore::KURL(url).string(),
+    WebCore::Image* image = WebCore::iconDatabase().synchronousIconForPageURL(WebCore::KURL(url).string(),
                                 WebCore::IntSize(16, 16));
     if (!image)
         return QPixmap();
index 0e057afaf25b922ff1d4bc23808f64336db61f78..e8a23df6ec7cd15d13a9755baf476453bae6280c 100644 (file)
@@ -1,3 +1,16 @@
+2011-03-17  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        https://bugs.webkit.org/show_bug.cgi?id=56425
+        More groundwork for WebKit2 IconDatabase
+
+        Update already-used function names:
+        * Api/qwebhistory.cpp:
+        (QWebHistoryItem::icon):
+        * Api/qwebsettings.cpp:
+        (QWebSettings::iconForUrl):
+
 2011-03-18  Alexis Menard  <alexis.menard@openbossa.org>
 
         Reviewed by Benjamin Poulain.
index 2714ab611ae2eb48f3d4c114b6609aff67845c54..f4dd49a961c6b0d192e46528d18393ae2e04855a 100644 (file)
@@ -1,3 +1,16 @@
+2011-03-17  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        https://bugs.webkit.org/show_bug.cgi?id=56425
+        More groundwork for WebKit2 IconDatabase
+
+        Update already-used function names:
+        * WebIconDatabase.cpp:
+        (WebIconDatabase::iconForURL):
+        (WebIconDatabase::iconURLForURL):
+        (WebIconDatabase::hasIconForURL):
+
 2011-03-18  Pavel Podivilov  <podivilov@chromium.org>
 
         Reviewed by Yury Semikhatsky.
index 1d72d3fc75fbb657b29b1c9aca19581820f81a74..71d6614230b563b1605ad507c4df4bf37633a2c0 100644 (file)
@@ -174,7 +174,7 @@ HRESULT STDMETHODCALLTYPE WebIconDatabase::iconForURL(
 
     Image* icon = 0;
     if (url)
-        icon = iconDatabase().iconForPageURL(String(url, SysStringLen(url)), intSize);
+        icon = iconDatabase().synchronousIconForPageURL(String(url, SysStringLen(url)), intSize);
 
     // Make sure we check for the case of an "empty image"
     if (icon && icon->width()) {
@@ -236,7 +236,7 @@ HRESULT STDMETHODCALLTYPE WebIconDatabase::iconURLForURL(
 {
     if (!url || !iconURL)
         return E_POINTER;
-    BString iconURLBSTR(iconDatabase().iconURLForPageURL(String(url, SysStringLen(url))));
+    BString iconURLBSTR(iconDatabase().synchronousIconURLForPageURL(String(url, SysStringLen(url))));
     *iconURL = iconURLBSTR.release();
     return S_OK;
 }
@@ -274,11 +274,11 @@ HRESULT STDMETHODCALLTYPE WebIconDatabase::hasIconForURL(
 
     // Passing a size parameter of 0, 0 means we don't care about the result of the image, we just
     // want to make sure the read from disk to load the icon is kicked off.
-    iconDatabase().iconForPageURL(urlString, IntSize(0, 0));
+    iconDatabase().synchronousIconForPageURL(urlString, IntSize(0, 0));
 
     // Check to see if we have a non-empty icon URL for the page, and if we do, we have an icon for
     // the page.
-    *result = !(iconDatabase().iconURLForPageURL(urlString).isEmpty());
+    *result = !(iconDatabase().synchronousIconURLForPageURL(urlString).isEmpty());
 
     return S_OK;
 }
index 35e339acc85d9f50a413c40a73f75385ce45623a..2bf03ab315d0db306246998717cf3e134cd68d54 100644 (file)
@@ -1,3 +1,24 @@
+2011-03-18  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Sam Weinig.
+
+        https://bugs.webkit.org/show_bug.cgi?id=56425
+        More groundwork for WebKit2 IconDatabase
+
+        -Update the synchronous method names to be prefixed with "synchronous."
+        -Add empty implementations for the asynchronous accessors.
+
+        * WebProcess/IconDatabase/WebIconDatabaseProxy.cpp:
+        (WebKit::WebIconDatabaseProxy::setEnabled):
+        (WebKit::WebIconDatabaseProxy::synchronousIconForPageURL):
+        (WebKit::WebIconDatabaseProxy::synchronousIconURLForPageURL):
+        (WebKit::WebIconDatabaseProxy::synchronousIconDataKnownForIconURL):
+        (WebKit::WebIconDatabaseProxy::synchronousLoadDecisionForIconURL):
+        (WebKit::WebIconDatabaseProxy::supportsAsynchronousMode):
+        (WebKit::WebIconDatabaseProxy::loadDecisionForIconURL):
+        (WebKit::WebIconDatabaseProxy::iconDataForIconURL):
+        * WebProcess/IconDatabase/WebIconDatabaseProxy.h:
+
 2011-03-18  Alejandro G. Castro  <alex@igalia.com>
 
         Reviewed by Martin Robinson.
index 42a8eb46a56004c2317184bad66a0533aac8ee40..2db909ca988cbf7d40e03a78ddb6e5276e28c764 100644 (file)
@@ -61,15 +61,6 @@ void WebIconDatabaseProxy::setEnabled(bool enabled)
     setGlobalIconDatabase(enabled ? this : 0);
 }
 
-Image* WebIconDatabaseProxy::iconForPageURL(const String& pageURL, const IntSize& size)
-{
-    CoreIPC::DataReference result;
-    if (!m_process->connection()->sendSync(Messages::WebIconDatabase::IconDataForPageURL(pageURL), Messages::WebIconDatabase::IconDataForPageURL::Reply(result), 0))
-        return 0;
-    
-    // FIXME: Return Image created with the above data.
-    return 0;
-}
 
 void WebIconDatabaseProxy::retainIconForPageURL(const String& pageURL)
 {
@@ -81,27 +72,51 @@ void WebIconDatabaseProxy::releaseIconForPageURL(const String& pageURL)
     m_process->connection()->send(Messages::WebIconDatabase::ReleaseIconForPageURL(pageURL), 0);
 }
 
-String WebIconDatabaseProxy::iconURLForPageURL(const String& pageURL)
+Image* WebIconDatabaseProxy::synchronousIconForPageURL(const String& pageURL, const IntSize& size)
+{
+    CoreIPC::DataReference result;
+    if (!m_process->connection()->sendSync(Messages::WebIconDatabase::IconDataForPageURL(pageURL), Messages::WebIconDatabase::IconDataForPageURL::Reply(result), 0))
+        return 0;
+    
+    // FIXME: Return Image created with the above data.
+    return 0;
+}
+
+
+String WebIconDatabaseProxy::synchronousIconURLForPageURL(const String& pageURL)
 {
     // FIXME: This needs to ask the UI process for the iconURL, but it can't do so synchronously because it will slow down page loading.
     // The parts in WebCore that need this data will have to be changed to work asycnchronously.
     return String();
 }
 
-bool WebIconDatabaseProxy::iconDataKnownForIconURL(const String& iconURL)
+bool WebIconDatabaseProxy::synchronousIconDataKnownForIconURL(const String& iconURL)
 {
     // FIXME: This needs to ask the UI process for the iconURL, but it can't do so synchronously because it will slow down page loading.
     // The parts in WebCore that need this data will have to be changed to work asycnchronously.
     return false;
 }
 
-IconLoadDecision WebIconDatabaseProxy::loadDecisionForIconURL(const String& iconURL, DocumentLoader* documentLoader)
+IconLoadDecision WebIconDatabaseProxy::synchronousLoadDecisionForIconURL(const String& iconURL, DocumentLoader* documentLoader)
 {
     // FIXME: This needs to ask the UI process for the iconURL, but it can't do so synchronously because it will slow down page loading.
     // The parts in WebCore that need this data will have to be changed to work asycnchronously.
     return IconLoadNo;
 }
 
+bool WebIconDatabaseProxy::supportsAsynchronousMode()
+{
+    return true;
+}
+
+void WebIconDatabaseProxy::loadDecisionForIconURL(const String& iconURL, PassRefPtr<WebCore::IconLoadDecisionCallback> callback)
+{
+}
+
+void WebIconDatabaseProxy::iconDataForIconURL(const String& iconURL, PassRefPtr<WebCore::IconDataCallback> callback)
+{
+}
+
 void WebIconDatabaseProxy::setIconURLForPageURL(const String& iconURL, const String& pageURL)
 {
     m_process->connection()->send(Messages::WebIconDatabase::SetIconURLForPageURL(iconURL, pageURL), 0);
index 0064e69a031e71119e3a6d9f0871456997bead9d..e5b53a158c48c0e172d3d8da08659de6c2508c5a 100644 (file)
@@ -52,17 +52,21 @@ public:
     virtual bool isEnabled() const;
     void setEnabled(bool);
     
-    virtual WebCore::Image* iconForPageURL(const String&, const WebCore::IntSize&);
     
     virtual void retainIconForPageURL(const String&);
     virtual void releaseIconForPageURL(const String&);
-
-    virtual String iconURLForPageURL(const String&);
-    virtual bool iconDataKnownForIconURL(const String&);
-    virtual WebCore::IconLoadDecision loadDecisionForIconURL(const String&, WebCore::DocumentLoader*);
-    
     virtual void setIconURLForPageURL(const String&, const String&);
     virtual void setIconDataForIconURL(PassRefPtr<WebCore::SharedBuffer>, const String&);
+
+    virtual String synchronousIconURLForPageURL(const String&);
+    virtual bool synchronousIconDataKnownForIconURL(const String&);
+    virtual WebCore::IconLoadDecision synchronousLoadDecisionForIconURL(const String&, WebCore::DocumentLoader*);
+    virtual WebCore::Image* synchronousIconForPageURL(const String&, const WebCore::IntSize&);
+    
+    // Asynchronous calls we should use to replace the above when supported.
+    virtual bool supportsAsynchronousMode();
+    virtual void loadDecisionForIconURL(const String&, PassRefPtr<WebCore::IconLoadDecisionCallback>);
+    virtual void iconDataForIconURL(const String&, PassRefPtr<WebCore::IconDataCallback>);
         
     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);