From: Kamil Nowac <k.nowac@samsung.com>
Date: Wed, 14 Sep 2016 13:37:09 +0000 (+0200)
Subject: Add favicon to tabs
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=adb454c6006633dc35e5fb7f95a12e6fc27fef86;p=profile%2Fcommon%2Fapps%2Fweb%2Fbrowser.git

Add favicon to tabs

[Issue]    http://suprem.sec.samsung.net/jira/browse/TWF-1870
[Problem]  No favicons in tabs
[Solution] Added saving tabs to database
[Verify]   Open few tabs with opened pages
           tabs should have favicons in upper right corner

Change-Id: I67a8ae334cc7c823f5ac66376fefd619e9a83524
---

diff --git a/core/AbstractWebEngine/TabId.cpp b/core/AbstractWebEngine/TabId.cpp
index 42c27c5f..468a316c 100644
--- a/core/AbstractWebEngine/TabId.cpp
+++ b/core/AbstractWebEngine/TabId.cpp
@@ -49,23 +49,37 @@ std::string TabId::toString() const {
     return std::to_string(m_id);
 }
 
-TabContent::TabContent(TabId id,
-        const std::string& url,
-        const std::string& title,
-        const TabOrigin& origin,
-        tools::BrowserImagePtr thumbnail,
-        bool isSecret)
+TabContent::TabContent(
+    TabId id,
+    const std::string& url,
+    const std::string& title,
+    const TabOrigin& origin,
+    tools::BrowserImagePtr thumbnail,
+    tools::BrowserImagePtr favicon,
+    bool isSecret)
     : m_id(id)
     , m_url(url)
     , m_title(title)
     , m_origin(origin)
     , m_thumbnail(thumbnail)
+    , m_favicon(favicon)
     , m_isSecret(isSecret)
 {
 }
 
-TabContent::TabContent(const TabId& id, const std::string& url, const std::string& title, const TabOrigin& origin, bool isSecret) :
-        TabContent(id, url, title, origin, std::make_shared<tools::BrowserImage>(), isSecret)
+TabContent::TabContent(
+    const TabId& id,
+    const std::string& url,
+    const std::string& title,
+    const TabOrigin& origin,
+    bool isSecret)
+    : m_id(id)
+    , m_url(url)
+    , m_title(title)
+    , m_origin(origin)
+    , m_thumbnail(std::make_shared<tools::BrowserImage>())
+    , m_favicon(std::make_shared<tools::BrowserImage>())
+    , m_isSecret(isSecret)
 {
 }
 
@@ -94,11 +108,21 @@ void TabContent::setThumbnail(tools::BrowserImagePtr thumbnail)
     m_thumbnail = thumbnail;
 }
 
+void TabContent::setFavicon(tools::BrowserImagePtr favicon)
+{
+    m_favicon = favicon;
+}
+
 tools::BrowserImagePtr TabContent::getThumbnail() const
 {
     return m_thumbnail;
 }
 
+tools::BrowserImagePtr TabContent::getFavicon() const
+{
+    return m_favicon;
+}
+
 bool TabContent::getIsSecret() const
 {
     return m_isSecret;
diff --git a/core/AbstractWebEngine/TabId.h b/core/AbstractWebEngine/TabId.h
index bc383f0d..2ecc4f53 100644
--- a/core/AbstractWebEngine/TabId.h
+++ b/core/AbstractWebEngine/TabId.h
@@ -71,6 +71,7 @@ public:
             const std::string& title,
             const TabOrigin& origin,
             tools::BrowserImagePtr thumbnail,
+            tools::BrowserImagePtr favicon,
             bool isSecret = false);
     TabContent(const TabId& id,
                const std::string& url,
@@ -82,7 +83,9 @@ public:
     std::string getTitle() const;
     TabOrigin getOrigin() const;
     void setThumbnail(tools::BrowserImagePtr thumbnail);
+    void setFavicon(tools::BrowserImagePtr favicon);
     tools::BrowserImagePtr getThumbnail() const;
+    tools::BrowserImagePtr getFavicon() const;
     bool getIsSecret() const;
 
 private:
@@ -91,6 +94,7 @@ private:
     std::string m_title;
     TabOrigin m_origin;
     tools::BrowserImagePtr m_thumbnail;
+    tools::BrowserImagePtr m_favicon;
     bool m_isSecret;
 
 };
diff --git a/core/Tools/EflTools.cpp b/core/Tools/EflTools.cpp
index 93fb4ab2..d1dc97ef 100644
--- a/core/Tools/EflTools.cpp
+++ b/core/Tools/EflTools.cpp
@@ -35,19 +35,27 @@ namespace EflTools {
 std::unique_ptr<Blob> getBlobPNG(std::shared_ptr<BrowserImage> browserImage)
 {
     BROWSER_LOGD("[%s:%d]", __PRETTY_FUNCTION__, __LINE__);
+    if (!browserImage) {
+        BROWSER_LOGD("browserImage is null");
+        return nullptr;
+    }
     unsigned long long length = 0;
-    void* mem_buffer = getBlobPNG(browserImage->getWidth(), browserImage->getHeight(), browserImage->getData(), &length);
-    if (!mem_buffer || !length){
+    void* mem_buffer = getBlobPNG(
+        browserImage->getWidth(),
+        browserImage->getHeight(),
+        browserImage->getData(),
+        &length);
+    if (!mem_buffer || !length) {
         BROWSER_LOGW("Cannot create BlobPNG");
         return nullptr;
     }
     std::unique_ptr<Blob> image(new Blob(mem_buffer, length));
-
     return std::move(image);
 }
 
 void* getBlobPNG(int width, int height, void* image_data, unsigned long long* length)
 {
+    BROWSER_LOGD("[%s:%d]", __PRETTY_FUNCTION__, __LINE__);
     EINA_SAFETY_ON_NULL_RETURN_VAL(image_data, NULL);
 
     image_util_encode_h handler = nullptr;
@@ -87,7 +95,6 @@ void* getBlobPNG(int width, int height, void* image_data, unsigned long long* le
         BROWSER_LOGW("[%s:%d] mage_util_encode_destroy: error!", __PRETTY_FUNCTION__, __LINE__);
         return nullptr;
     }
-
     return outputBuffer;
 }
 
diff --git a/services/SimpleUI/SimpleUI.cpp b/services/SimpleUI/SimpleUI.cpp
index 19012084..348b21de 100755
--- a/services/SimpleUI/SimpleUI.cpp
+++ b/services/SimpleUI/SimpleUI.cpp
@@ -238,7 +238,13 @@ void SimpleUI::restoreLastSession()
 
     auto vec = m_tabService->getAllTabs();
     for (const basic_webengine::TabContent& i : *vec) {
-        openNewTab(i.getUrl(), i.getTitle(), boost::optional<int>(i.getId().get()), false, false, i.getOrigin());
+        openNewTab(
+            i.getUrl(),
+            i.getTitle(),
+            boost::optional<int>(i.getId().get()),
+            false,
+            false,
+            i.getOrigin());
     }
 }
 
@@ -626,6 +632,7 @@ void SimpleUI::connectModelSignals()
     m_historyService->historyDeleted.connect(boost::bind(&SimpleUI::onHistoryRemoved, this,_1));
 
     m_tabService->generateThumb.connect(boost::bind(&SimpleUI::onGenerateThumb, this, _1));
+    m_tabService->generateFavicon.connect(boost::bind(&SimpleUI::onGenerateFavicon, this, _1));
 
     m_platformInputManager->returnPressed.connect(boost::bind(&elm_exit));
     m_platformInputManager->backPressed.connect(boost::bind(&SimpleUI::onBackPressed, this));
@@ -1023,6 +1030,13 @@ void SimpleUI::onGenerateThumb(basic_webengine::TabId tabId)
     m_tabService->updateTabItemSnapshot(tabId, snapshotImage);
 }
 
+void SimpleUI::onGenerateFavicon(basic_webengine::TabId tabId)
+{
+    BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+
+    m_tabService->updateTabItemFavicon(tabId, m_webEngine->getFavicon());
+}
+
 void SimpleUI::onCreateTabId()
 {
     int id = m_tabService->createTabId();
@@ -1246,17 +1260,17 @@ void SimpleUI::loadFinished()
 {
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
     m_webPageUI->loadFinished();
-#if PROFILE_MOBILE
     if (!m_webEngine->isSecretMode()) {
-        m_tabService->updateTabItem(m_webEngine->currentTabId(),
-                m_webEngine->getURI(),
-                m_webEngine->getTitle(),
-                m_webEngine->getOrigin());
-        m_historyService->addHistoryItem(m_webEngine->getURI(),
-                                                 m_webEngine->getTitle(),
-                                                 m_webEngine->getFavicon());
+        m_tabService->updateTabItem(
+            m_webEngine->currentTabId(),
+            m_webEngine->getURI(),
+            m_webEngine->getTitle(),
+            m_webEngine->getOrigin());
+        m_historyService->addHistoryItem(
+            m_webEngine->getURI(),
+            m_webEngine->getTitle(),
+            m_webEngine->getFavicon());
     }
-#endif
 }
 
 void SimpleUI::filterURL(const std::string& url)
@@ -1376,8 +1390,15 @@ void SimpleUI::showTabUI()
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
     m_viewManager.pushViewToStack(m_tabUI.get());
 
-    if (!m_webPageUI->stateEquals(WPUState::QUICK_ACCESS) && m_webEngine->tabsCount() > 0 && m_webEngine->isLoading())
+    if (!m_webPageUI->stateEquals(WPUState::QUICK_ACCESS) &&
+        m_webEngine->tabsCount() > 0 &&
+        m_webEngine->isLoading())
         onGenerateThumb(m_webEngine->currentTabId());
+
+    auto tabsContents = m_webEngine->getTabContents();
+    m_tabService->fillThumbs(tabsContents);
+    m_tabService->fillFavicons(tabsContents);
+    m_tabUI->addTabItems(tabsContents, m_webEngine->isSecretMode());
 }
 
 void SimpleUI::closeTabUI()
@@ -1388,9 +1409,9 @@ void SimpleUI::closeTabUI()
 }
 
 void SimpleUI::refetchTabUIData() {
-    std::vector<basic_webengine::TabContentPtr> tabsContents =
-            m_webEngine->getTabContents();
+    auto tabsContents = m_webEngine->getTabContents();
     m_tabService->fillThumbs(tabsContents);
+    m_tabService->fillFavicons(tabsContents);
     m_tabUI->addTabItems(tabsContents, m_webEngine->isSecretMode());
 }
 
diff --git a/services/SimpleUI/SimpleUI.h b/services/SimpleUI/SimpleUI.h
index 87f7b3b7..57d3e5bb 100644
--- a/services/SimpleUI/SimpleUI.h
+++ b/services/SimpleUI/SimpleUI.h
@@ -186,6 +186,7 @@ private:
      * @brief Handles 'generateThumb' signals.
      */
     void onGenerateThumb(basic_webengine::TabId tabId);
+    void onGenerateFavicon(basic_webengine::TabId tabId);
     void onSnapshotCaptured(std::shared_ptr<tools::BrowserImage> snapshot, tools::SnapshotType snapshot_type);
     void onCreateTabId();
 
diff --git a/services/TabService/TabService.cpp b/services/TabService/TabService.cpp
index d114e04f..d2f5a440 100644
--- a/services/TabService/TabService.cpp
+++ b/services/TabService/TabService.cpp
@@ -30,25 +30,22 @@ EXPORT_SERVICE(TabService, DOMAIN_TAB_SERVICE)
 
 TabService::TabService()
 {
-    if (bp_tab_adaptor_initialize() < 0) {
+    if (bp_tab_adaptor_initialize() < 0)
         errorPrint("bp_tab_adaptor_initialize");
-    }
 }
 
 TabService::~TabService()
 {
-    if (bp_tab_adaptor_deinitialize() < 0) {
+    if (bp_tab_adaptor_deinitialize() < 0)
         errorPrint("bp_tab_adaptor_deinitialize");
-    }
 }
 
 // return -1 when tab adaptor is not created
 int TabService::createTabId(int tabId) const
 {
     int adaptorId = tabId;
-    if (bp_tab_adaptor_create(&adaptorId) < 0) {
+    if (bp_tab_adaptor_create(&adaptorId) < 0)
         errorPrint("bp_tab_adaptor_create");
-    }
     return adaptorId;
 }
 
@@ -58,8 +55,9 @@ boost::optional<int> TabService::convertTabId(std::string tabId) const
         boost::optional<int> tabIdConverted = std::stoi(tabId);
         return tabIdConverted;
     } catch (const std::exception& /*e*/) {
-        BROWSER_LOGE("%s can't convert %s to tab id", __PRETTY_FUNCTION__,
-                tabId.c_str());
+        BROWSER_LOGE("%s can't convert %s to tab id",
+            __PRETTY_FUNCTION__,
+            tabId.c_str());
         return boost::none;
     }
 }
@@ -67,8 +65,10 @@ boost::optional<int> TabService::convertTabId(std::string tabId) const
 void TabService::errorPrint(std::string method) const
 {
     int error_code = bp_tab_adaptor_get_errorcode();
-    BROWSER_LOGE("%s error: %d (%s)", method.c_str(), error_code,
-            tools::capiWebError::tabErrorToString(error_code).c_str());
+    BROWSER_LOGE("%s error: %d (%s)",
+        method.c_str(),
+        error_code,
+        tools::capiWebError::tabErrorToString(error_code).c_str());
 }
 
 std::shared_ptr<std::vector<basic_webengine::TabContent> > TabService::getAllTabs()
@@ -100,7 +100,9 @@ std::shared_ptr<std::vector<basic_webengine::TabContent> > TabService::getAllTab
             BROWSER_LOGW("[%s:%d] unknown index!", __PRETTY_FUNCTION__, __LINE__);
             continue;
         }
-        vec->push_back(basic_webengine::TabContent(basic_webengine::TabId(items[i]),
+        vec->push_back(
+            basic_webengine::TabContent(
+                basic_webengine::TabId(items[i]),
                 std::string(info.url),
                 std::string(info.title),
                 basic_webengine::TabOrigin(info.index)));
@@ -114,12 +116,11 @@ std::shared_ptr<std::vector<basic_webengine::TabContent> > TabService::getAllTab
 tools::BrowserImagePtr TabService::getThumb(const basic_webengine::TabId& tabId)
 {
     auto imageCache = getThumbCache(tabId);
-    if (imageCache) {
+    if (imageCache)
         return *imageCache;
-    }
 
     auto imageDatabase = getThumbDatabase(tabId);
-    if(imageDatabase) {
+    if (imageDatabase) {
         saveThumbCache(tabId, *imageDatabase);
         return *imageDatabase;
     }
@@ -134,24 +135,54 @@ tools::BrowserImagePtr TabService::getThumb(const basic_webengine::TabId& tabId)
         return std::make_shared<tools::BrowserImage>();
 }
 
+tools::BrowserImagePtr TabService::getFavicon(const basic_webengine::TabId& tabId)
+{
+    auto imageCache = getFaviconCache(tabId);
+    if (imageCache)
+        return *imageCache;
+
+    auto imageDatabase = getFaviconDatabase(tabId);
+    if (imageDatabase) {
+        saveFaviconCache(tabId, *imageDatabase);
+        return *imageDatabase;
+    }
+
+    BROWSER_LOGD("%s [%d] generating favicon", __FUNCTION__, tabId.get());
+    generateFavicon(tabId);
+
+    imageCache = getFaviconCache(tabId);
+    if (imageCache)
+        return *imageCache;
+    else
+        return std::make_shared<tools::BrowserImage>();
+}
+
 boost::optional<tools::BrowserImagePtr> TabService::getThumbCache(
-        const basic_webengine::TabId& tabId)
+    const basic_webengine::TabId& tabId)
 {
-    if (!thumbCached(tabId)) {
+    if (!thumbCached(tabId))
         return boost::none;
-    }
     return m_thumbMap.find(tabId.get())->second;
 }
 
+boost::optional<tools::BrowserImagePtr> TabService::getFaviconCache(
+    const basic_webengine::TabId& tabId)
+{
+    if (!faviconCached(tabId))
+        return boost::none;
+    return m_faviconMap.find(tabId.get())->second;
+}
+
 void TabService::removeTab(const basic_webengine::TabId& tabId)
 {
     BROWSER_LOGD("[%s:%d] tab id: %d", __PRETTY_FUNCTION__, __LINE__, tabId.get());
     clearFromDatabase(tabId);
     clearFromCache(tabId);
+    clearFaviconFromCache(tabId);
 }
 
 void TabService::fillThumbs(
-        const std::vector<basic_webengine::TabContentPtr>& tabsContents)
+    const std::vector<basic_webengine::TabContentPtr>& tabsContents)
 {
     for (auto& tc : tabsContents) {
         auto thumbPtr = getThumb(tc->getId());
@@ -159,84 +190,152 @@ void TabService::fillThumbs(
     }
 }
 
-void TabService::updateTabItem(const basic_webengine::TabId& tabId,
-        const std::string& url,
-        const std::string& title,
-        const basic_webengine::TabOrigin& origin)
+void TabService::fillFavicons(
+    const std::vector<basic_webengine::TabContentPtr>& tabsContents)
+{
+    for (auto& tc : tabsContents) {
+        auto faviconPtr = getFavicon(tc->getId());
+        tc->setFavicon(faviconPtr);
+    }
+}
+
+void TabService::updateTabItem(
+    const basic_webengine::TabId& tabId,
+    const std::string& url,
+    const std::string& title,
+    const basic_webengine::TabOrigin& origin)
 {
     BROWSER_LOGD("[%s:%d] tabid: %d", __PRETTY_FUNCTION__, __LINE__, tabId.get());
 
-    if (!thumbInDatabase(tabId))
+    if (!tabInDatabase(tabId))
         createTabId(tabId.get());
-    if (bp_tab_adaptor_set_url(tabId.get(), url.c_str()) < 0) {
+
+    if (bp_tab_adaptor_set_url(tabId.get(), url.c_str()) < 0)
         errorPrint("bp_tab_adaptor_set_url");
-    }
-    if (bp_tab_adaptor_set_title(tabId.get(), title.c_str()) < 0) {
+    if (bp_tab_adaptor_set_title(tabId.get(), title.c_str()) < 0)
         errorPrint("bp_tab_adaptor_set_title");
-    }
-    if (bp_tab_adaptor_set_index(tabId.get(), origin.getValue()) < 0) {     // tab origin is int saved in index bp_tab parameter
+    if (bp_tab_adaptor_set_index(tabId.get(), origin.getValue()) < 0)     // tab origin is int saved in index bp_tab parameter
         errorPrint("bp_tab_adaptor_set_index");
-    }
 }
 
-void TabService::updateTabItemSnapshot(const basic_webengine::TabId& tabId,
-        tools::BrowserImagePtr imagePtr)
+void TabService::updateTabItemSnapshot(
+    const basic_webengine::TabId& tabId,
+    tools::BrowserImagePtr imagePtr)
 {
     BROWSER_LOGD("[%s:%d] tabid: %d", __PRETTY_FUNCTION__, __LINE__, tabId.get());
 
-    if (!thumbInDatabase(tabId))
+    if (!tabInDatabase(tabId))
         createTabId(tabId.get());
+
+    // thumbnail
     saveThumbCache(tabId, imagePtr);
     saveThumbDatabase(tabId, imagePtr);
 }
 
-void TabService::saveThumbCache(const basic_webengine::TabId& tabId,
-        tools::BrowserImagePtr imagePtr)
+void TabService::updateTabItemFavicon(
+    const basic_webengine::TabId& tabId,
+    tools::BrowserImagePtr imagePtr)
+{
+    BROWSER_LOGD("[%s:%d] tabid: %d", __PRETTY_FUNCTION__, __LINE__, tabId.get());
+
+    if (!tabInDatabase(tabId))
+        createTabId(tabId.get());
+
+    // favicon
+    saveFaviconCache(tabId, imagePtr);
+    saveFaviconDatabase(tabId, imagePtr);
+}
+
+void TabService::saveThumbCache(
+    const basic_webengine::TabId& tabId,
+    tools::BrowserImagePtr imagePtr)
 {
     m_thumbMap[tabId.get()] = imagePtr;
 }
 
+void TabService::saveFaviconCache(
+    const basic_webengine::TabId& tabId,
+    tools::BrowserImagePtr imagePtr)
+{
+    m_faviconMap[tabId.get()] = imagePtr;
+}
+
 bool TabService::thumbCached(const basic_webengine::TabId& tabId) const
 {
     return m_thumbMap.find(tabId.get()) != m_thumbMap.end();
 }
 
-void TabService::clearFromCache(const basic_webengine::TabId& tabId) {
+bool TabService::faviconCached(const basic_webengine::TabId& tabId) const
+{
+    return m_faviconMap.find(tabId.get()) != m_faviconMap.end();
+}
+
+void TabService::clearFromCache(const basic_webengine::TabId& tabId)
+{
     m_thumbMap.erase(tabId.get());
 }
 
+void TabService::clearFaviconFromCache(const basic_webengine::TabId& tabId)
+{
+    m_faviconMap.erase(tabId.get());
+}
+
 void TabService::clearFromDatabase(const basic_webengine::TabId& tabId)
 {
-    if (bp_tab_adaptor_delete(tabId.get()) < 0) {
+    if (bp_tab_adaptor_delete(tabId.get()) < 0)
         errorPrint("bp_tab_adaptor_delete");
-    }
 }
 
-void TabService::saveThumbDatabase(const basic_webengine::TabId& tabId,
-        tools::BrowserImagePtr imagePtr)
+void TabService::saveThumbDatabase(
+    const basic_webengine::TabId& tabId,
+    tools::BrowserImagePtr imagePtr)
 {
     BROWSER_LOGD("[%s:%d] tabId: %d", __PRETTY_FUNCTION__, __LINE__, tabId.get());
-    std::unique_ptr<tools::Blob> thumb_blob = tools::EflTools::getBlobPNG(
-            imagePtr);
-    if (!thumb_blob){
+    auto thumb_blob = tools::EflTools::getBlobPNG(imagePtr);
+    if (!thumb_blob) {
         BROWSER_LOGW("getBlobPNG failed");
         return;
     }
-    unsigned char* thumbData = std::move((unsigned char*) thumb_blob->getData());
-    if (bp_tab_adaptor_set_snapshot(tabId.get(), imagePtr->getWidth(),
-            imagePtr->getHeight(), thumbData, thumb_blob->getLength()) < 0) {
+    auto thumbData = std::move((unsigned char*)thumb_blob->getData());
+    if (bp_tab_adaptor_set_snapshot(
+        tabId.get(),
+        imagePtr->getWidth(),
+        imagePtr->getHeight(),
+        thumbData,
+        thumb_blob->getLength()) < 0) {
         errorPrint("bp_tab_adaptor_set_snapshot");
     }
 }
 
-bool TabService::thumbInDatabase(const basic_webengine::TabId& tabId) const
+void TabService::saveFaviconDatabase(
+    const basic_webengine::TabId& tabId,
+    tools::BrowserImagePtr imagePtr)
+{
+    BROWSER_LOGD("[%s:%d] tabId: %d", __PRETTY_FUNCTION__, __LINE__, tabId.get());
+    auto favicon_blob = tools::EflTools::getBlobPNG(imagePtr);
+    if (!favicon_blob) {
+        BROWSER_LOGW("getBlobPNG failed");
+        return;
+    }
+    auto faviconData = std::move((unsigned char*)favicon_blob->getData());
+    if (bp_tab_adaptor_set_icon(
+            tabId.get(),
+            imagePtr->getWidth(),
+            imagePtr->getHeight(),
+            faviconData,
+            favicon_blob->getLength()) < 0)
+        errorPrint("bp_tab_adaptor_set_snapshot");
+}
+
+bool TabService::tabInDatabase(const basic_webengine::TabId& tabId) const
 {
     char* url;
     int result = bp_tab_adaptor_get_url(tabId.get(), &url);
     if (result == BP_TAB_ERROR_ID_NOT_FOUND) {
+        errorPrint("passed the id is not exist in the storage");
         return false;
     } else if (result < 0) {
-        errorPrint("bp_tab_adaptor_get_full_ids_p");
+        errorPrint("bp_tab_adaptor_get_url");
         return false;
     }
 
@@ -244,15 +343,15 @@ bool TabService::thumbInDatabase(const basic_webengine::TabId& tabId) const
 }
 
 boost::optional<tools::BrowserImagePtr> TabService::getThumbDatabase(
-        const basic_webengine::TabId& tabId)
+    const basic_webengine::TabId& tabId)
 {
     BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
-    if (!thumbInDatabase(tabId)) {
+    if (!tabInDatabase(tabId)) {
         return boost::none;
     }
 
     int w = 0, h = 0, l = 0;
-    unsigned char *v = nullptr;
+    unsigned char* v = nullptr;
     if (bp_tab_adaptor_get_snapshot(tabId.get(), &w, &h, &v, &l)) {
         errorPrint("bp_tab_adaptor_get_snapshot");
         return boost::none;
@@ -270,5 +369,33 @@ boost::optional<tools::BrowserImagePtr> TabService::getThumbDatabase(
     return image;
 }
 
+boost::optional<tools::BrowserImagePtr> TabService::getFaviconDatabase(
+    const basic_webengine::TabId& tabId)
+{
+    BROWSER_LOGD("[%s:%d] ", __PRETTY_FUNCTION__, __LINE__);
+    if (!tabInDatabase(tabId)) {
+        BROWSER_LOGD("no tab in database");
+        return boost::none;
+    }
+
+    int w = 0, h = 0, l = 0;
+    unsigned char* v = nullptr;
+    if (bp_tab_adaptor_get_icon(tabId.get(), &w, &h, &v, &l)) {
+        errorPrint("bp_tab_adaptor_get_snapshot");
+        return boost::none;
+    }
+
+    tools::BrowserImagePtr image = std::make_shared<tools::BrowserImage>(w, h, l);
+    // TODO check if we can use shared memory here
+    image->setData((void*)v, false, tools::ImageType::ImageTypePNG);
+
+    if (image->getSize() <= 0) {
+        BROWSER_LOGW("[%s:%d] empty image!", __PRETTY_FUNCTION__, __LINE__);
+        return boost::none;
+    }
+
+    return image;
+}
+
 } /* namespace base_ui */
 } /* namespace tizen_browser */
diff --git a/services/TabService/TabService.h b/services/TabService/TabService.h
index 6b42b040..7c9677fb 100644
--- a/services/TabService/TabService.h
+++ b/services/TabService/TabService.h
@@ -72,6 +72,12 @@ public:
     void fillThumbs(
             const std::vector<basic_webengine::TabContentPtr>& tabsContents);
 
+    /**
+     * Set favicon images for given TabContent objects
+     */
+    void fillFavicons(
+        const std::vector<basic_webengine::TabContentPtr>& tabsContents);
+
     /**
      * Invoke bp_tab_adaptor_create.
      *
@@ -89,14 +95,25 @@ public:
     boost::optional<int> convertTabId(std::string tabId) const;
 
     boost::signals2::signal<void(basic_webengine::TabId)> generateThumb;
+    boost::signals2::signal<void(basic_webengine::TabId)> generateFavicon;
 
     void updateTabItemSnapshot(const basic_webengine::TabId& tabId,
             tools::BrowserImagePtr imagePtr);
+
+    void updateTabItemFavicon(const basic_webengine::TabId& tabId,
+            tools::BrowserImagePtr imagePtr);
+
     /**
      * Cache given thumb image with given tab id.
      */
     void saveThumbCache(const basic_webengine::TabId& tabId,
         tools::BrowserImagePtr imagePtr);
+
+    /**
+     * Cache given favicon image with given tab id.
+     */
+    void saveFaviconCache(const basic_webengine::TabId& tabId,
+        tools::BrowserImagePtr imagePtr);
 private:
     /**
      * Help method printing last bp_tab_error_defs error.
@@ -109,6 +126,11 @@ private:
      */
     tools::BrowserImagePtr getThumb(const basic_webengine::TabId& tabId);
 
+    /**
+     * Get favicon for given id (from cache or database).
+     */
+    tools::BrowserImagePtr getFavicon(const basic_webengine::TabId& tabId);
+
     /**
      * Get cached thumb for given tab id.
      *
@@ -116,15 +138,35 @@ private:
      */
     boost::optional<tools::BrowserImagePtr> getThumbCache(
             const basic_webengine::TabId& tabId);
+
+    /**
+     * Get cached favicon for given tab id.
+     *
+     * @return Image or boost::none.
+     */
+    boost::optional<tools::BrowserImagePtr> getFaviconCache(
+            const basic_webengine::TabId& tabId);
+
     /**
      * Check if thumb for given id is in a map.
      */
     bool thumbCached(const basic_webengine::TabId& tabId) const;
+
+    /**
+     * Check if favicon for given id is in a map.
+     */
+    bool faviconCached(const basic_webengine::TabId& tabId) const;
+
     /**
      * Remove image from cache for given tab id.
      */
     void clearFromCache(const basic_webengine::TabId& tabId);
 
+    /**
+     * Remove favicon from cache for given tab id.
+     */
+    void clearFaviconFromCache(const basic_webengine::TabId& tabId);
+
     /**
      * Get thumb from database for given tab id.
      *
@@ -138,9 +180,9 @@ private:
     void saveThumbDatabase(const basic_webengine::TabId& tabId,
             tools::BrowserImagePtr imagePtr);
     /**
-     * Check if thumb for given id is in a database.
+     * Check if tab for given id is in a database.
      */
-    bool thumbInDatabase(const basic_webengine::TabId& tabId) const;
+    bool tabInDatabase(const basic_webengine::TabId& tabId) const;
     /**
      * Remove image from a database for given tab id.
      *
@@ -148,10 +190,24 @@ private:
      */
     void clearFromDatabase(const basic_webengine::TabId& tabId);
 
+    /**
+     * Get favicon from database for given tab id.
+     *
+     * @return Image or boost::none.
+     */
+    boost::optional<tools::BrowserImagePtr> getFaviconDatabase(
+            const basic_webengine::TabId& tabId);
+    /**
+     * Save given favicon image with given tab id in a database.
+     */
+    void saveFaviconDatabase(const basic_webengine::TabId& tabId,
+            tools::BrowserImagePtr imagePtr);
+
     /**
      * Map caching images. Keys: tab ids, values: thumb images.
      */
     std::map<int, tools::BrowserImagePtr> m_thumbMap;
+    std::map<int, tools::BrowserImagePtr> m_faviconMap;
 };
 
 } /* namespace base_ui */
diff --git a/services/TabUI/TabUI.cpp b/services/TabUI/TabUI.cpp
index 4032a0c0..d19d1ad4 100644
--- a/services/TabUI/TabUI.cpp
+++ b/services/TabUI/TabUI.cpp
@@ -466,11 +466,23 @@ Evas_Object * TabUI::_gengrid_content_get(void *data, Evas_Object *obj, const ch
 {
     BROWSER_LOGD("[%s:%d] part=%s", __PRETTY_FUNCTION__, __LINE__, part);
     if (data && obj && part) {
-        TabData *itemData = static_cast<TabData*>(data);
+        auto itemData = static_cast<TabData*>(data);
         if (!strcmp(part, "elm.icon")) {
-            auto layout = elm_layout_add(obj);
-            elm_layout_file_set(layout, itemData->tabUI->m_edjFilePath.c_str(), "favicon_image");
-            return layout;
+            auto favicon = itemData->item->getFavicon();
+            if (favicon) {
+                auto faviconEvas = favicon->getEvasImage(obj);
+                evas_object_size_hint_min_set(faviconEvas,
+                    ELM_SCALE_SIZE(40),
+                    ELM_SCALE_SIZE(40));
+                evas_object_size_hint_max_set(faviconEvas,
+                    ELM_SCALE_SIZE(40),
+                    ELM_SCALE_SIZE(40));
+                return faviconEvas;
+            } else {
+                auto layout = elm_layout_add(obj);
+                elm_layout_file_set(layout, itemData->tabUI->m_edjFilePath.c_str(), "favicon_image");
+                return layout;
+            }
         }
         if (!strcmp(part, "elm.button")) {
             auto button = elm_button_add(obj);
diff --git a/services/WebEngineService/WebEngineService.cpp b/services/WebEngineService/WebEngineService.cpp
index 5e3ab2d2..3aa2e002 100755
--- a/services/WebEngineService/WebEngineService.cpp
+++ b/services/WebEngineService/WebEngineService.cpp
@@ -477,15 +477,24 @@ TabId WebEngineService::currentTabId() const
 std::vector<TabContentPtr> WebEngineService::getTabContents() const {
     std::vector<TabContentPtr> result;
     for (auto const& tab : m_stateStruct->tabs) {
-        auto tabContent = std::make_shared<TabContent>(tab.first, tab.second->getURI(),
-            tab.second->getTitle(), tab.second->getOrigin(), m_state == State::SECRET);
+        auto tabContent =
+            std::make_shared<TabContent>(
+                tab.first,
+                tab.second->getURI(),
+                tab.second->getTitle(),
+                tab.second->getOrigin(),
+                m_state == State::SECRET);
         result.push_back(tabContent);
     }
     return result;
 }
 
-TabId WebEngineService::addTab(const std::string & uri, const boost::optional<int> tabId,
-        const std::string& title, bool desktopMode, TabOrigin origin)
+TabId WebEngineService::addTab(
+    const std::string & uri,
+    const boost::optional<int> tabId,
+    const std::string& title,
+    bool desktopMode,
+    TabOrigin origin)
 {
     if (!(*AbstractWebEngine::checkIfCreate()))
         return currentTabId();