[EFL] Remove ewk_view_tiled
authorryuan.choi@samsung.com <ryuan.choi@samsung.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 30 Dec 2013 01:23:58 +0000 (01:23 +0000)
committerryuan.choi@samsung.com <ryuan.choi@samsung.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 30 Dec 2013 01:23:58 +0000 (01:23 +0000)
https://bugs.webkit.org/show_bug.cgi?id=125961

Reviewed by Gyuyoung Kim.

Source/WebKit:

* PlatformEfl.cmake: Removed ewk_view_tiled related files.

Source/WebKit/efl:

We didn't use ewk_view_tiled very long time while we focused webkit2/efl.
There are many bugs and we don't have plan to fix them.
Instead, We will use WebCore's TiledBackingStore and it looks more stable.

* WebCoreSupport/FrameLoaderClientEfl.cpp:
(WebCore::FrameLoaderClientEfl::transitionToCommittedForNewPage):
* ewk/ewk_tiled_backing_store.cpp: Removed.
* ewk/ewk_tiled_backing_store_private.h: Removed.
* ewk/ewk_tiled_matrix.cpp: Removed.
* ewk/ewk_tiled_matrix_private.h: Removed.
* ewk/ewk_tiled_model.cpp: Removed.
* ewk/ewk_tiled_model_private.h: Removed.
* ewk/ewk_view.cpp:
* ewk/ewk_view.h:
* ewk/ewk_view_private.h:
* ewk/ewk_view_tiled.cpp: Removed.
* tests/UnitTestUtils/EWKTestView.cpp:
(EWKUnitTests::EWKTestView::init):

Tools:

* DumpRenderTree/efl/DumpRenderTreeChrome.cpp:
(shouldUseTiledBackingStore):
Moved from DumpRenderTreeChrome to enable WebCore's TiledBackingStore
instead of switching ewk_view_tiled.
(DumpRenderTreeChrome::createView):
* DumpRenderTree/efl/DumpRenderTreeView.cpp:
(drtViewAdd):
* EWebLauncher/main.c: Removed ewk_view_tiled option.
(windowCreate):
(parseUserArguments):

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

19 files changed:
Source/WebKit/ChangeLog
Source/WebKit/PlatformEfl.cmake
Source/WebKit/efl/ChangeLog
Source/WebKit/efl/WebCoreSupport/FrameLoaderClientEfl.cpp
Source/WebKit/efl/ewk/ewk_tiled_backing_store.cpp [deleted file]
Source/WebKit/efl/ewk/ewk_tiled_backing_store_private.h [deleted file]
Source/WebKit/efl/ewk/ewk_tiled_matrix.cpp [deleted file]
Source/WebKit/efl/ewk/ewk_tiled_matrix_private.h [deleted file]
Source/WebKit/efl/ewk/ewk_tiled_model.cpp [deleted file]
Source/WebKit/efl/ewk/ewk_tiled_model_private.h [deleted file]
Source/WebKit/efl/ewk/ewk_view.cpp
Source/WebKit/efl/ewk/ewk_view.h
Source/WebKit/efl/ewk/ewk_view_private.h
Source/WebKit/efl/ewk/ewk_view_tiled.cpp [deleted file]
Source/WebKit/efl/tests/UnitTestUtils/EWKTestView.cpp
Tools/ChangeLog
Tools/DumpRenderTree/efl/DumpRenderTreeChrome.cpp
Tools/DumpRenderTree/efl/DumpRenderTreeView.cpp
Tools/EWebLauncher/main.c

index ed76e79..8ecd7c9 100644 (file)
@@ -1,3 +1,12 @@
+2013-12-29  Ryuan Choi  <ryuan.choi@samsung.com>
+
+        [EFL] Remove ewk_view_tiled
+        https://bugs.webkit.org/show_bug.cgi?id=125961
+
+        Reviewed by Gyuyoung Kim.
+
+        * PlatformEfl.cmake: Removed ewk_view_tiled related files.
+
 2013-12-29  Martin Robinson  <mrobinson@igalia.com>
 
         [GTK] [CMake] Convenience libraries that export API should be compiled with --whole-archive on Unix
index 2ab9d2e..160d3e3 100644 (file)
@@ -140,13 +140,9 @@ list(APPEND WebKit_SOURCES
     efl/ewk/ewk_security_origin.cpp
     efl/ewk/ewk_security_policy.cpp
     efl/ewk/ewk_settings.cpp
-    efl/ewk/ewk_tiled_backing_store.cpp
-    efl/ewk/ewk_tiled_matrix.cpp
-    efl/ewk/ewk_tiled_model.cpp
     efl/ewk/ewk_touch_event.cpp
     efl/ewk/ewk_view.cpp
     efl/ewk/ewk_view_single.cpp
-    efl/ewk/ewk_view_tiled.cpp
     efl/ewk/ewk_web_database.cpp
     efl/ewk/ewk_window_features.cpp
 )
index 5da13c8..70650e5 100644 (file)
@@ -1,3 +1,29 @@
+2013-12-29  Ryuan Choi  <ryuan.choi@samsung.com>
+
+        [EFL] Remove ewk_view_tiled
+        https://bugs.webkit.org/show_bug.cgi?id=125961
+
+        Reviewed by Gyuyoung Kim.
+
+        We didn't use ewk_view_tiled very long time while we focused webkit2/efl.
+        There are many bugs and we don't have plan to fix them.
+        Instead, We will use WebCore's TiledBackingStore and it looks more stable.
+
+        * WebCoreSupport/FrameLoaderClientEfl.cpp:
+        (WebCore::FrameLoaderClientEfl::transitionToCommittedForNewPage):
+        * ewk/ewk_tiled_backing_store.cpp: Removed.
+        * ewk/ewk_tiled_backing_store_private.h: Removed.
+        * ewk/ewk_tiled_matrix.cpp: Removed.
+        * ewk/ewk_tiled_matrix_private.h: Removed.
+        * ewk/ewk_tiled_model.cpp: Removed.
+        * ewk/ewk_tiled_model_private.h: Removed.
+        * ewk/ewk_view.cpp:
+        * ewk/ewk_view.h:
+        * ewk/ewk_view_private.h:
+        * ewk/ewk_view_tiled.cpp: Removed.
+        * tests/UnitTestUtils/EWKTestView.cpp:
+        (EWKUnitTests::EWKTestView::init):
+
 2013-12-23  Ryuan Choi  <ryuan.choi@samsung.com>
 
         Unreviewed build fix after r161033
index 88213f4..204c05f 100644 (file)
@@ -1026,10 +1026,8 @@ void FrameLoaderClientEfl::transitionToCommittedForNewPage()
 
     ewk_frame_view_create_for_view(m_frame, m_view);
 
-    if (isLoadingMainFrame()) {
-        ewk_view_frame_view_creation_notify(m_view);
+    if (isLoadingMainFrame())
         ewk_view_frame_main_cleared(m_view);
-    }
 }
 
 void FrameLoaderClientEfl::didSaveToPageCache()
diff --git a/Source/WebKit/efl/ewk/ewk_tiled_backing_store.cpp b/Source/WebKit/efl/ewk/ewk_tiled_backing_store.cpp
deleted file mode 100644 (file)
index 3c3f1d7..0000000
+++ /dev/null
@@ -1,1936 +0,0 @@
-/*
-    Copyright (C) 2009-2010 Samsung Electronics
-    Copyright (C) 2009-2010 ProFUSION embedded systems
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
-*/
-
-#include "config.h"
-
-#include "ewk_private.h"
-#include "ewk_tiled_backing_store_private.h"
-#include "ewk_tiled_matrix_private.h"
-#include "ewk_tiled_model_private.h"
-#include <Ecore.h>
-#include <Eina.h>
-#include <algorithm>
-#include <errno.h>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
-
-typedef struct _Ewk_Tiled_Backing_Store_Data Ewk_Tiled_Backing_Store_Data;
-typedef struct _Ewk_Tiled_Backing_Store_Item Ewk_Tiled_Backing_Store_Item;
-typedef struct _Ewk_Tiled_Backing_Store_Pre_Render_Request Ewk_Tiled_Backing_Store_Pre_Render_Request;
-
-struct _Ewk_Tiled_Backing_Store_Item {
-    EINA_INLIST;
-    Ewk_Tile* tile;
-    Evas_Coord_Rectangle geometry;
-    bool smoothScale;
-};
-
-struct _Ewk_Tiled_Backing_Store_Pre_Render_Request {
-    EINA_INLIST;
-    unsigned long column, row;
-    float zoom;
-};
-
-struct _Ewk_Tiled_Backing_Store_Data {
-    Evas_Object_Smart_Clipped_Data base;
-    Evas_Object* self;
-    Evas_Object* contentsClipper;
-    struct {
-        Eina_Inlist** items;
-        Evas_Coord x, y, width, height;
-        unsigned long columns, rows;
-        struct {
-            Evas_Coord width, height;
-            float zoom;
-            bool zoomWeakSmoothScale : 1;
-            bool hasAlpha : 1;
-        } tile;
-        struct {
-            struct {
-                Evas_Coord x, y;
-            } current, old, base, zoomCenter;
-        } offset;
-        bool visible : 1;
-    } view;
-    Evas_Colorspace colorSpace;
-    struct {
-        Ewk_Tile_Matrix* matrix;
-        struct {
-            unsigned long column, row;
-        } base;
-        struct {
-            unsigned long columns, rows;
-        } current, old;
-        Evas_Coord width, height;
-    } model;
-    struct {
-        bool (*callback)(void* data, Ewk_Tile* tile, const Eina_Rectangle* area);
-        void* data;
-        Eina_Inlist* preRenderRequests;
-        Ecore_Idler* idler;
-        bool disabled;
-        bool suspend : 1;
-    } render;
-    struct {
-        void* (*preCallback)(void* data, Evas_Object* ewkBackingStore);
-        void* preData;
-        void* (*postCallback)(void* data, void* preData, Evas_Object* ewkBackingStore);
-        void* postData;
-    } process;
-    struct {
-        bool any : 1;
-        bool position : 1;
-        bool size : 1;
-        bool model : 1;
-        bool offset : 1;
-        bool contentsSize : 1;
-    } changed;
-#ifdef DEBUG_MEM_LEAKS
-    Ecore_Event_Handler* signalUser;
-#endif
-};
-
-static Evas_Smart_Class _parent_sc = EVAS_SMART_CLASS_INIT_NULL;
-
-#define PRIV_DATA_GET_OR_RETURN(obj, ptr, ...) \
-    Ewk_Tiled_Backing_Store_Data* ptr = static_cast<Ewk_Tiled_Backing_Store_Data*>(evas_object_smart_data_get(obj)); \
-    if (!ptr) { \
-        CRITICAL("no private data in obj=%p", obj); \
-        return __VA_ARGS__; \
-    }
-
-static void _ewk_tiled_backing_store_fill_renderers(Ewk_Tiled_Backing_Store_Data* priv);
-static inline void _ewk_tiled_backing_store_changed(Ewk_Tiled_Backing_Store_Data* priv);
-
-#ifdef DEBUG_MEM_LEAKS
-static inline void _ewk_tiled_backing_store_view_dbg(const Ewk_Tiled_Backing_Store_Data* priv);
-#endif
-
-static inline void _ewk_tiled_backing_store_updates_process(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    /* Do not process updates. Note that we still want to get updates requests
-     * in the queue in order to not miss any updates after the render is
-     * resumed.
-     */
-    if (priv->render.suspend || !priv->view.visible)
-        return;
-
-    void* data = priv->process.preCallback ? priv->process.preCallback(priv->process.preData, priv->self) : 0;
-
-    ewk_tile_matrix_updates_process(priv->model.matrix);
-
-    if (priv->process.postCallback)
-        priv->process.postCallback(priv->process.postData, data, priv->self);
-}
-
-static void _ewk_tiled_backing_store_flush(void* data)
-{
-    Ewk_Tiled_Backing_Store_Data* priv = static_cast<Ewk_Tiled_Backing_Store_Data*>(data);
-    Ewk_Tile_Unused_Cache* tiledUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-
-    if (tiledUnusedCache) {
-        DBG("flush unused tile cache.");
-        ewk_tile_unused_cache_auto_flush(tiledUnusedCache);
-    } else
-        ERR("no cache?!");
-}
-
-static Ewk_Tile* _ewk_tiled_backing_store_tile_new(Ewk_Tiled_Backing_Store_Data* priv, unsigned long column, unsigned long row, float zoom)
-{
-    Evas* evas = evas_object_evas_get(priv->self);
-    if (!evas) {
-        CRITICAL("evas_object_evas_get failed!");
-        return 0;
-    }
-
-    Ewk_Tile* tile = ewk_tile_matrix_tile_new(priv->model.matrix, evas, column, row, zoom);
-    if (!tile) {
-        CRITICAL("ewk_tile_matrix_tile_new failed!");
-        return 0;
-    }
-
-    return tile;
-}
-
-static void _ewk_tiled_backing_store_item_move(Ewk_Tiled_Backing_Store_Item* item, Evas_Coord x, Evas_Coord y)
-{
-    item->geometry.x = x;
-    item->geometry.y = y;
-
-    if (item->tile)
-        evas_object_move(item->tile->image, x, y);
-}
-
-static void _ewk_tiled_backing_store_item_resize(Ewk_Tiled_Backing_Store_Item* item, Evas_Coord width, Evas_Coord height)
-{
-    item->geometry.w = width;
-    item->geometry.h = height;
-
-    if (!item->tile)
-        return;
-
-    evas_object_resize(item->tile->image, width, height);
-    evas_object_image_fill_set(item->tile->image, 0, 0, width, height);
-}
-
-static void _ewk_tiled_backing_store_tile_associate(Ewk_Tiled_Backing_Store_Data* priv, Ewk_Tile* tile, Ewk_Tiled_Backing_Store_Item* item)
-{
-    if (item->tile)
-        CRITICAL("item->tile=%p, but it should be 0!", item->tile);
-
-    item->tile = tile;
-    evas_object_move(item->tile->image, item->geometry.x, item->geometry.y);
-    evas_object_resize(item->tile->image, item->geometry.w, item->geometry.h);
-    evas_object_image_fill_set(item->tile->image, 0, 0, item->geometry.w, item->geometry.h);
-    evas_object_image_smooth_scale_set(item->tile->image, item->smoothScale);
-    evas_object_image_alpha_set(item->tile->image, priv->view.tile.hasAlpha);
-
-    if (!ewk_tile_visible_get(tile))
-        evas_object_smart_member_add(tile->image, priv->self);
-
-    ewk_tile_show(tile);
-}
-
-static void _ewk_tiled_backing_store_tile_dissociate(Ewk_Tiled_Backing_Store_Data* priv, Ewk_Tiled_Backing_Store_Item* item, double lastUsed)
-{
-    ewk_tile_hide(item->tile);
-    if (!ewk_tile_visible_get(item->tile))
-        evas_object_smart_member_del(item->tile->image);
-
-    ewk_tile_matrix_tile_put(priv->model.matrix, item->tile, lastUsed);
-    Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-    ewk_tile_unused_cache_auto_flush(tileUnusedCache);
-
-    item->tile = 0;
-}
-
-static void _ewk_tiled_backing_store_tile_dissociate_all(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    double last_used = ecore_loop_time_get();
-
-    for (unsigned long i = 0; i < priv->view.rows; ++i) {
-        Ewk_Tiled_Backing_Store_Item* item;
-        Eina_Inlist* list = priv->view.items[i];
-        EINA_INLIST_FOREACH(list, item) {
-            if (item->tile)
-                _ewk_tiled_backing_store_tile_dissociate(priv, item, last_used);
-        }
-    }
-}
-
-static inline bool _ewk_tiled_backing_store_pre_render_request_add(Ewk_Tiled_Backing_Store_Data* priv, unsigned long column, unsigned long row, float zoom)
-{
-    Ewk_Tiled_Backing_Store_Pre_Render_Request* request = new Ewk_Tiled_Backing_Store_Pre_Render_Request;
-
-    priv->render.preRenderRequests = eina_inlist_append(priv->render.preRenderRequests, EINA_INLIST_GET(request));
-
-    request->column = column;
-    request->row = row;
-    request->zoom = zoom;
-
-    return true;
-}
-
-static inline void _ewk_tiled_backing_store_pre_render_request_del(Ewk_Tiled_Backing_Store_Data* priv, Ewk_Tiled_Backing_Store_Pre_Render_Request* request)
-{
-    priv->render.preRenderRequests = eina_inlist_remove(priv->render.preRenderRequests, EINA_INLIST_GET(request));
-    delete request;
-}
-
-static inline Ewk_Tiled_Backing_Store_Pre_Render_Request* _ewk_tiled_backing_store_pre_render_request_first(const Ewk_Tiled_Backing_Store_Data* priv)
-{
-    return EINA_INLIST_CONTAINER_GET(priv->render.preRenderRequests, Ewk_Tiled_Backing_Store_Pre_Render_Request);
-}
-
-static void _ewk_tiled_backing_store_pre_render_request_flush(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    Eina_Inlist** preRenderList = &priv->render.preRenderRequests;
-    while (*preRenderList) {
-        Ewk_Tiled_Backing_Store_Pre_Render_Request* request;
-        request = _ewk_tiled_backing_store_pre_render_request_first(priv);
-        *preRenderList = eina_inlist_remove(*preRenderList, *preRenderList);
-        delete request;
-    }
-}
-
-static void _ewk_tiled_backing_store_pre_render_request_clear(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    Eina_Inlist** preRenderList = &priv->render.preRenderRequests;
-    Eina_Inlist* iter = *preRenderList;
-    while (iter) {
-        Ewk_Tiled_Backing_Store_Pre_Render_Request* request = EINA_INLIST_CONTAINER_GET(iter, Ewk_Tiled_Backing_Store_Pre_Render_Request);
-        Eina_Inlist* next = iter->next;
-        *preRenderList = eina_inlist_remove(*preRenderList, iter);
-        iter = next;
-        delete request;
-    }
-}
-
-/* assumes priv->process.preCallback was called if required! */
-static void _ewk_tiled_backing_store_pre_render_request_process_single(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    Ewk_Tile_Matrix* tileMatrix = priv->model.matrix;
-    double last_used = ecore_loop_time_get();
-
-    Ewk_Tiled_Backing_Store_Pre_Render_Request* request = _ewk_tiled_backing_store_pre_render_request_first(priv);
-    if (!request)
-        return;
-
-    unsigned long column = request->column;
-    unsigned long row = request->row;
-    float zoom = request->zoom;
-
-    if (ewk_tile_matrix_tile_exact_exists(tileMatrix, column, row, zoom)) {
-        DBG("no pre-render required for tile %lu,%lu @ %f.", column, row, zoom);
-        _ewk_tiled_backing_store_pre_render_request_del(priv, request);
-        ewk_tile_unused_cache_auto_flush(ewk_tile_matrix_unused_cache_get(priv->model.matrix));
-        return;
-    }
-
-    Ewk_Tile* tile = _ewk_tiled_backing_store_tile_new(priv, column, row, zoom);
-    if (!tile) {
-        _ewk_tiled_backing_store_pre_render_request_del(priv, request);
-        ewk_tile_unused_cache_auto_flush(ewk_tile_matrix_unused_cache_get(priv->model.matrix));
-        return;
-    }
-
-    Eina_Rectangle area;
-    EINA_RECTANGLE_SET(&area, 0, 0, priv->view.tile.width, priv->view.tile.height);
-
-    priv->render.callback(priv->render.data, tile, &area);
-    evas_object_image_data_update_add(tile->image, area.x, area.y, area.w, area.h);
-    ewk_tile_matrix_tile_updates_clear(tileMatrix, tile);
-
-    ewk_tile_matrix_tile_put(tileMatrix, tile, last_used);
-}
-
-static Eina_Bool _ewk_tiled_backing_store_item_process_idler_cb(void* data)
-{
-    Ewk_Tiled_Backing_Store_Data* priv = static_cast<Ewk_Tiled_Backing_Store_Data*>(data);
-
-    if (priv->process.preCallback)
-        data = priv->process.preCallback(priv->process.preData, priv->self);
-
-    _ewk_tiled_backing_store_pre_render_request_process_single(priv);
-
-    if (priv->process.postCallback)
-        priv->process.postCallback(priv->process.postData, data, priv->self);
-
-    if (!priv->render.preRenderRequests) {
-        priv->render.idler = 0;
-        return false;
-    }
-
-    return true;
-}
-
-static inline void _ewk_tiled_backing_store_item_process_idler_stop(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    if (!priv->render.idler)
-        return;
-
-    ecore_idler_del(priv->render.idler);
-    priv->render.idler = 0;
-}
-
-static inline void _ewk_tiled_backing_store_item_process_idler_start(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    if (priv->render.idler || !priv->view.visible)
-        return;
-
-    priv->render.idler = ecore_idler_add(_ewk_tiled_backing_store_item_process_idler_cb, priv);
-}
-
-static bool _ewk_tiled_backing_store_disable_render(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    if (priv->render.suspend)
-        return true;
-
-    priv->render.suspend = true;
-    _ewk_tiled_backing_store_item_process_idler_stop(priv);
-    return true;
-}
-
-static bool _ewk_tiled_backing_store_enable_render(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    if (!priv->render.suspend)
-        return true;
-
-    priv->render.suspend = false;
-
-    _ewk_tiled_backing_store_fill_renderers(priv);
-    _ewk_tiled_backing_store_item_process_idler_start(priv);
-
-    return true;
-}
-
-static inline bool _ewk_tiled_backing_store_item_fill(Ewk_Tiled_Backing_Store_Data* priv, Ewk_Tiled_Backing_Store_Item* item, unsigned long column, unsigned long row)
-{
-    if (!priv->view.visible)
-        return false;
-
-    unsigned long currentColumn = priv->model.base.column + column;
-    unsigned long currentRow = priv->model.base.row + row;
-    double lastUsed = ecore_loop_time_get();
-
-    if (currentColumn >= priv->model.current.columns || currentRow >= priv->model.current.rows) {
-        if (item->tile)
-            _ewk_tiled_backing_store_tile_dissociate(priv, item, lastUsed);
-    } else {
-        const float zoom = priv->view.tile.zoom;
-
-        if (item->tile) {
-            Ewk_Tile* old = item->tile;
-            if (old->row != currentRow || old->column != currentColumn || old->zoom != zoom)
-                _ewk_tiled_backing_store_tile_dissociate(priv, item, lastUsed);
-            else if (old->row == currentRow && old->column == currentColumn && old->zoom == zoom)
-                return true;
-        }
-
-        Ewk_Tile* tile = ewk_tile_matrix_tile_exact_get(priv->model.matrix, currentColumn, currentRow, zoom);
-        if (!tile) {
-            /* NOTE: it never returns 0 if item->tile was set! */
-            if (item->tile) {
-                CRITICAL("item->tile=%p, but it should be 0!", item->tile);
-                _ewk_tiled_backing_store_tile_dissociate(priv, item,
-                                                         lastUsed);
-            }
-
-            /* Do not add new requests to the render queue */
-            if (!priv->render.suspend) {
-                tile = _ewk_tiled_backing_store_tile_new(priv, currentColumn, currentRow, zoom);
-                if (!tile)
-                    return false;
-                _ewk_tiled_backing_store_tile_associate(priv, tile, item);
-            }
-        } else if (tile != item->tile) {
-            if (item->tile)
-                _ewk_tiled_backing_store_tile_dissociate(priv,
-                                                         item, lastUsed);
-            _ewk_tiled_backing_store_tile_associate(priv, tile, item);
-        }
-    }
-
-    return true;
-}
-
-static Ewk_Tiled_Backing_Store_Item* _ewk_tiled_backing_store_item_add(Ewk_Tiled_Backing_Store_Data* priv, unsigned long column, unsigned long row)
-{
-    DBG("ewkBackingStore=%p", priv->self);
-
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-    Evas_Coord x = priv->view.offset.base.x + priv->view.x + tileWidth * column;
-    Evas_Coord y = priv->view.offset.base.y + priv->view.y + tileHeight * row;
-
-    OwnPtr<Ewk_Tiled_Backing_Store_Item> item = adoptPtr(new Ewk_Tiled_Backing_Store_Item);
-    item->tile = 0;
-    item->smoothScale = priv->view.tile.zoomWeakSmoothScale;
-
-    _ewk_tiled_backing_store_item_move(item.get(), x, y);
-    _ewk_tiled_backing_store_item_resize(item.get(), tileWidth, tileHeight);
-    if (!_ewk_tiled_backing_store_item_fill(priv, item.get(), column, row))
-        return 0;
-
-    return item.leakPtr();
-}
-
-static void _ewk_tiled_backing_store_item_del(Ewk_Tiled_Backing_Store_Data* priv, Ewk_Tiled_Backing_Store_Item* item)
-{
-    if (item->tile) {
-        double last_used = ecore_loop_time_get();
-        _ewk_tiled_backing_store_tile_dissociate(priv, item, last_used);
-    }
-
-    delete item;
-}
-
-static void _ewk_tiled_backing_store_item_smooth_scale_set(Ewk_Tiled_Backing_Store_Item* item, bool smoothScale)
-{
-    if (item->smoothScale == smoothScale)
-        return;
-
-    if (item->tile)
-        evas_object_image_smooth_scale_set(item->tile->image, smoothScale);
-}
-
-static inline void _ewk_tiled_backing_store_changed(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    if (priv->changed.any)
-        return;
-
-    evas_object_smart_changed(priv->self);
-    priv->changed.any = true;
-}
-
-static void _ewk_tiled_backing_store_view_cols_end_del(Ewk_Tiled_Backing_Store_Data* priv, Eina_Inlist** rowList, unsigned long count)
-{
-    if (!count)
-        return;
-
-    Eina_Inlist* nextItem = (*rowList)->last;
-    for (unsigned long i = 0; i < count; ++i) {
-        Ewk_Tiled_Backing_Store_Item* item;
-        item = EINA_INLIST_CONTAINER_GET(nextItem, Ewk_Tiled_Backing_Store_Item);
-        nextItem = nextItem->prev;
-        *rowList = eina_inlist_remove(*rowList, EINA_INLIST_GET(item));
-        _ewk_tiled_backing_store_item_del(priv, item);
-    }
-}
-
-static bool _ewk_tiled_backing_store_view_cols_end_add(Ewk_Tiled_Backing_Store_Data* priv, Eina_Inlist** rowList, unsigned long baseColumn, unsigned long count)
-{
-    const unsigned long row = rowList - priv->view.items;
-
-    for (unsigned long i = 0; i < count; ++i, ++baseColumn) {
-        Ewk_Tiled_Backing_Store_Item* item = _ewk_tiled_backing_store_item_add(priv, baseColumn, row);
-        if (!item) {
-            CRITICAL("failed to add column %lu of %lu in row %lu.", i, count, row);
-            _ewk_tiled_backing_store_view_cols_end_del(priv, rowList, i);
-            return false;
-        }
-
-        *rowList = eina_inlist_append(*rowList, EINA_INLIST_GET(item));
-    }
-    return true;
-}
-
-static void _ewk_tiled_backing_store_view_row_del(Ewk_Tiled_Backing_Store_Data* priv, Eina_Inlist* row)
-{
-    while (row) {
-        Ewk_Tiled_Backing_Store_Item* item = EINA_INLIST_CONTAINER_GET(row, Ewk_Tiled_Backing_Store_Item);
-        row = row->next;
-        _ewk_tiled_backing_store_item_del(priv, item);
-    }
-}
-
-static void _ewk_tiled_backing_store_view_rows_range_del(Ewk_Tiled_Backing_Store_Data* priv, Eina_Inlist** start, Eina_Inlist** end)
-{
-    for (; start < end; ++start) {
-        _ewk_tiled_backing_store_view_row_del(priv, *start);
-        *start = 0;
-    }
-}
-
-static void _ewk_tiled_backing_store_view_rows_all_del(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    Eina_Inlist** start = priv->view.items;
-    Eina_Inlist** end = priv->view.items + priv->view.rows;
-    _ewk_tiled_backing_store_view_rows_range_del(priv, start, end);
-
-    free(priv->view.items);
-    priv->view.items = 0;
-    priv->view.columns = 0;
-    priv->view.rows = 0;
-}
-
-static void _ewk_tiled_backing_store_render(void* data, Ewk_Tile* tile, const Eina_Rectangle* area)
-{
-    Ewk_Tiled_Backing_Store_Data* priv = static_cast<Ewk_Tiled_Backing_Store_Data*>(data);
-
-    INFO("TODO %p (visible? %d) [%lu,%lu] %d,%d + %dx%d",
-        tile, tile->visible, tile->column, tile->row, area->x, area->y, area->w, area->h);
-
-    if (!tile->visible)
-        return;
-
-    if (priv->view.tile.width != tile->width || priv->view.tile.height != tile->height)
-        return; // todo: remove me later, don't even flag as dirty!
-
-    EINA_SAFETY_ON_NULL_RETURN(priv->render.callback);
-    if (!priv->render.callback(priv->render.data, tile, area))
-        return;
-
-    evas_object_image_data_update_add(tile->image, area->x, area->y, area->w, area->h);
-}
-
-static inline void _ewk_tiled_backing_store_model_matrix_create(Ewk_Tiled_Backing_Store_Data* priv, Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    if (priv->model.matrix) {
-        _ewk_tiled_backing_store_view_rows_all_del(priv);
-
-        priv->changed.offset = false;
-        priv->changed.size = true;
-
-        ewk_tile_matrix_free(priv->model.matrix);
-    }
-
-    priv->model.matrix = ewk_tile_matrix_new(tileUnusedCache, priv->model.current.columns, priv->model.current.rows, priv->view.tile.zoom, priv->colorSpace, _ewk_tiled_backing_store_render, priv);
-}
-
-static void _ewk_tiled_backing_store_smart_member_del(Evas_Object* ewkBackingStore, Evas_Object* member)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-    if (!priv->contentsClipper)
-        return;
-
-    evas_object_clip_unset(member);
-    if (!evas_object_clipees_get(priv->contentsClipper))
-        evas_object_hide(priv->contentsClipper);
-}
-
-static void _ewk_tiled_backing_store_smart_member_add(Evas_Object* ewkBackingStore, Evas_Object* member)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-    if (!priv->contentsClipper)
-        return;
-
-    evas_object_clip_set(member, priv->contentsClipper);
-    if (priv->view.visible)
-        evas_object_show(priv->contentsClipper);
-}
-
-#ifdef DEBUG_MEM_LEAKS
-static void _ewk_tiled_backing_store_mem_dbg(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    static unsigned run = 0;
-
-    ++run;
-
-    printf("\n--- BEGIN DEBUG TILED BACKING STORE MEMORY [%d] --\n"
-           "tile=%0.2f, obj=%p, priv=%p, view.items=%p, matrix=%p\n",
-           run, ecore_loop_time_get(),
-           priv->self, priv, priv->view.items, priv->model.matrix);
-
-    ewk_tile_matrix_dbg(priv->model.matrix);
-    ewk_tile_accounting_dbg();
-
-    printf("--- END DEBUG TILED BACKING STORE MEMORY [%d] --\n\n", run);
-}
-
-static bool _ewk_tiled_backing_store_sig_usr(void* data, int type, void* event)
-{
-    Ecore_Event_Signal_User* signalUser = static_cast<Ecore_Event_Signal_User*>(event);
-    Ewk_Tiled_Backing_Store_Data* priv = static_cast<Ewk_Tiled_Backing_Store_Data*>(data);
-
-    if (signalUser->number == 2) {
-        Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-        ewk_tile_unused_cache_auto_flush(tileUnusedCache);
-    }
-
-    _ewk_tiled_backing_store_view_dbg(priv);
-    _ewk_tiled_backing_store_mem_dbg(priv);
-
-    return true;
-}
-#endif
-
-static void _ewk_tiled_backing_store_smart_add(Evas_Object* ewkBackingStore)
-{
-    DBG("ewkBackingStore=%p", ewkBackingStore);
-
-    Ewk_Tiled_Backing_Store_Data* priv = static_cast<Ewk_Tiled_Backing_Store_Data*>(calloc(1, sizeof(*priv)));
-    if (!priv)
-        return;
-
-    priv->self = ewkBackingStore;
-    priv->view.tile.zoom = 1.0;
-    priv->view.tile.width = defaultTileWidth;
-    priv->view.tile.height = defaultTileHeigth;
-    priv->view.offset.current.x = 0;
-    priv->view.offset.current.y = 0;
-    priv->view.offset.old.x = 0;
-    priv->view.offset.old.y = 0;
-    priv->view.offset.base.x = 0;
-    priv->view.offset.base.y = 0;
-
-    priv->model.base.column = 0;
-    priv->model.base.row = 0;
-    priv->model.current.columns = 1;
-    priv->model.current.rows = 1;
-    priv->model.old.columns = 0;
-    priv->model.old.rows = 0;
-    priv->model.width = 0;
-    priv->model.height = 0;
-    priv->render.suspend = false;
-    priv->colorSpace = EVAS_COLORSPACE_ARGB8888; // TODO: detect it.
-
-    evas_object_smart_data_set(ewkBackingStore, priv);
-    _parent_sc.add(ewkBackingStore);
-
-    priv->contentsClipper = evas_object_rectangle_add(
-        evas_object_evas_get(ewkBackingStore));
-    evas_object_move(priv->contentsClipper, 0, 0);
-    evas_object_resize(priv->contentsClipper,
-                       priv->model.width, priv->model.height);
-    evas_object_color_set(priv->contentsClipper, 255, 255, 255, 255);
-    evas_object_show(priv->contentsClipper);
-    evas_object_smart_member_add(priv->contentsClipper, ewkBackingStore);
-
-    _ewk_tiled_backing_store_model_matrix_create(priv, 0);
-    evas_object_move(priv->base.clipper, 0, 0);
-    evas_object_resize(priv->base.clipper, 0, 0);
-    evas_object_clip_set(priv->contentsClipper, priv->base.clipper);
-
-#ifdef DEBUG_MEM_LEAKS
-    priv->signalUser = ecore_event_handler_add
-                        (ECORE_EVENT_SIGNAL_USER, _ewk_tiled_backing_store_sig_usr, priv);
-#endif
-}
-
-static void _ewk_tiled_backing_store_smart_del(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-    DBG("ewkBackingStore=%p", ewkBackingStore);
-
-    Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-    ewk_tile_unused_cache_unlock_area(tileUnusedCache);
-
-    _ewk_tiled_backing_store_flush(priv);
-
-    _ewk_tiled_backing_store_pre_render_request_flush(priv);
-    _ewk_tiled_backing_store_item_process_idler_stop(priv);
-    _ewk_tiled_backing_store_view_rows_all_del(priv);
-
-#ifdef DEBUG_MEM_LEAKS
-    _ewk_tiled_backing_store_mem_dbg(priv);
-    if (priv->sig_usr)
-        ecore_event_handler_del(priv->sig_usr);
-#endif
-
-    ewk_tile_matrix_free(priv->model.matrix);
-    evas_object_smart_member_del(priv->contentsClipper);
-    evas_object_del(priv->contentsClipper);
-
-    _parent_sc.del(ewkBackingStore);
-
-#ifdef DEBUG_MEM_LEAKS
-    printf("\nIMPORTANT: TILED BACKING STORE DELETED (may be real leaks)\n");
-    ewk_tile_accounting_dbg();
-#endif
-}
-
-static void _ewk_tiled_backing_store_smart_move(Evas_Object* ewkBackingStore, Evas_Coord x, Evas_Coord y)
-{
-    DBG("ewkBackingStore=%p, new pos: %dx%d", ewkBackingStore, x, y);
-
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    if (priv->changed.position)
-        return;
-
-    if (priv->view.x == x && priv->view.y == y)
-        return;
-
-    priv->changed.position = true;
-    _ewk_tiled_backing_store_changed(priv);
-}
-
-static void _ewk_tiled_backing_store_smart_resize(Evas_Object* ewkBackingStore, Evas_Coord width, Evas_Coord height)
-{
-    DBG("ewkBackingStore=%p, new size: %dx%d", ewkBackingStore, width, height);
-
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    if (priv->changed.size)
-        return;
-
-    if (priv->view.width == width && priv->view.height == height)
-        return;
-
-    priv->changed.size = true;
-    _ewk_tiled_backing_store_changed(priv);
-}
-
-static void _ewk_tiled_backing_store_smart_show(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    priv->view.visible = true;
-    ewk_tiled_backing_store_enable_render(ewkBackingStore);
-    _parent_sc.show(ewkBackingStore);
-}
-
-static void _ewk_tiled_backing_store_smart_hide(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    priv->view.visible = false;
-    ewk_tiled_backing_store_disable_render(ewkBackingStore);
-    _ewk_tiled_backing_store_tile_dissociate_all(priv);
-    _parent_sc.hide(ewkBackingStore);
-}
-
-static void _ewk_tiled_backing_store_recalc_renderers(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord width, Evas_Coord height, Evas_Coord tileWidth, Evas_Coord tileHeight)
-{
-    INFO("ewkBackingStore=%p, new size: %dx%d", priv->self, width, height);
-
-    unsigned long columns = 1 + static_cast<unsigned long>(ceil(width / static_cast<float>(tileWidth)));
-    unsigned long rows = 1 + static_cast<unsigned long>(ceil(height / static_cast<float>(tileHeight)));
-
-    INFO("ewkBackingStore=%p new grid size columns: %lu, rows: %lu, was %lu, %lu", priv->self, columns, rows, priv->view.columns, priv->view.rows);
-
-    if (priv->view.columns == columns && priv->view.rows == rows)
-        return;
-
-    unsigned long oldCols = priv->view.columns;
-    unsigned long oldRows = priv->view.rows;
-
-    if (rows < oldRows) {
-        Eina_Inlist** start = priv->view.items + rows;
-        Eina_Inlist** end = priv->view.items + oldRows;
-        _ewk_tiled_backing_store_view_rows_range_del(priv, start, end);
-    }
-
-    void* newItems = realloc(priv->view.items, sizeof(Eina_Inlist*) * rows);
-    if (!newItems)
-        return;
-
-    priv->view.items = static_cast<Eina_Inlist**>(newItems);
-    priv->view.rows = rows;
-    priv->view.columns = columns;
-    if (rows > oldRows) {
-        Eina_Inlist** start = priv->view.items + oldRows;
-        Eina_Inlist** end = priv->view.items + rows;
-        for (; start < end; ++start) {
-            *start = 0;
-            bool result = _ewk_tiled_backing_store_view_cols_end_add(priv, start, 0, columns);
-            if (!result) {
-                CRITICAL("failed to allocate %ld columns", columns);
-                _ewk_tiled_backing_store_view_rows_range_del(priv, priv->view.items + oldRows, start);
-                priv->view.rows = oldRows;
-                return;
-            }
-        }
-    }
-
-    if (columns != oldCols) {
-        long todo = columns - oldCols;
-        Eina_Inlist** start = priv->view.items;
-        Eina_Inlist** end = start + std::min(oldRows, rows);
-        if (todo > 0) {
-            for (; start < end; ++start) {
-                bool result = _ewk_tiled_backing_store_view_cols_end_add(priv, start, oldCols, todo);
-                if (!result) {
-                    CRITICAL("failed to allocate %ld columns!", todo);
-
-                    for (start--; start >= priv->view.items; --start)
-                        _ewk_tiled_backing_store_view_cols_end_del(priv, start, todo);
-                    if (rows > oldRows) {
-                        start = priv->view.items + oldRows;
-                        end = priv->view.items + rows;
-                        for (; start < end; start++)
-                            _ewk_tiled_backing_store_view_cols_end_del(priv, start, todo);
-                    }
-                    return;
-                }
-            }
-        } else if (todo < 0) {
-            todo = -todo;
-            for (; start < end; ++start)
-                _ewk_tiled_backing_store_view_cols_end_del(priv, start, todo);
-        }
-    }
-
-    _ewk_tiled_backing_store_fill_renderers(priv);
-}
-
-static void _ewk_tiled_backing_store_smart_calculate_size(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord width, Evas_Coord height)
-{
-    evas_object_resize(priv->base.clipper, width, height);
-
-    priv->view.width = width;
-    priv->view.height = height;
-
-    _ewk_tiled_backing_store_recalc_renderers(priv, width, height, priv->view.tile.width, priv->view.tile.height);
-}
-
-#ifdef DEBUG_MEM_LEAKS
-// TODO: remove me later.
-static inline void _ewk_tiled_backing_store_view_dbg(const Ewk_Tiled_Backing_Store_Data* priv)
-{
-    printf("tiles=%2ld,%2ld  model=%2ld,%2ld [%dx%d] base=%+3ld,%+4ld offset=%+4d,%+4d old=%+4d,%+4d base=%+3d,%+3d\n",
-           priv->view.columns, priv->view.rows,
-           priv->model.current.columns, priv->model.current.rows,
-           priv->model.width, priv->model.height,
-           priv->model.base.column, priv->model.base.row,
-           priv->view.offset.current.x, priv->view.offset.current.y,
-           priv->view.offset.old.x, priv->view.offset.old.y,
-           priv->view.offset.base.x, priv->view.offset.base.y);
-
-    Eina_Inlist** start = priv->view.items;
-    Eina_Inlist** end = priv->view.items + priv->view.rows;
-    for (; start < end; ++start) {
-        const Ewk_Tiled_Backing_Store_Item* item;
-
-        EINA_INLIST_FOREACH(*start, item) {
-            printf(" %+4d,%+4d ", item->geometry.x, item->geometry.y);
-
-            if (!item->tile)
-                printf("            ;");
-            else
-                printf("%8p %lu,%lu;", item->tile, item->tile->column, item->tile->row);
-        }
-        printf("\n");
-    }
-    printf("---\n");
-}
-#endif
-
-/**
- * @internal
- * Move top row down as last.
- *
- * The final result is visually the same, but logically the top that
- * went out of screen is now at bottom and filled with new model items.
- *
- * This is worth just when @a count is smaller than @c
- * priv->view.rows, after that one is refilling the whole matrix so it
- * is better to trigger full refill.
- *
- * @param count the number of times to repeat the process.
- */
-static void _ewk_tiled_backing_store_view_wrap_up(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y, unsigned long count)
-{
-    unsigned long lastRow = priv->view.rows - 1;
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-    Evas_Coord offsetY = priv->view.offset.base.y + count * tileHeight;
-    Evas_Coord tilePositionY = y + (lastRow - count + 1) * tileHeight + offsetY;
-    Evas_Coord originX = x + priv->view.offset.base.x;
-
-    Eina_Inlist** start = priv->view.items;
-    Eina_Inlist** end = start + lastRow;
-
-    for (; count > 0; --count) {
-        Eina_Inlist** it;
-        Eina_Inlist* temp = *start;
-
-        for (it = start; it < end; ++it)
-            *it = *(it + 1);
-        *it = temp;
-
-        ++priv->model.base.row;
-
-        Evas_Coord tilePositionX = originX;
-        unsigned long column = 0;
-        Ewk_Tiled_Backing_Store_Item* item;
-        EINA_INLIST_FOREACH(temp, item) {
-            _ewk_tiled_backing_store_item_move(item, tilePositionX, tilePositionY);
-            tilePositionX += tileWidth;
-            _ewk_tiled_backing_store_item_fill(priv, item, column, lastRow);
-            ++column;
-        }
-        tilePositionY += tileHeight;
-    }
-    priv->view.offset.base.y = offsetY;
-}
-
-/**
- * @internal
- * Move bottom row up as first.
- *
- * The final result is visually the same, but logically the bottom that
- * went out of screen is now at top and filled with new model items.
- *
- * This is worth just when @a count is smaller than @c
- * priv->view.rows, after that one is refilling the whole matrix so it
- * is better to trigger full refill.
- *
- * @param count the number of times to repeat the process.
- */
-static void _ewk_tiled_backing_store_view_wrap_down(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y, unsigned long count)
-{
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-    Evas_Coord offsetY = priv->view.offset.base.y - count * tileHeight;
-    Evas_Coord tilePositionY = y + offsetY + (count - 1) * tileHeight;
-    Evas_Coord originX = x + priv->view.offset.base.x;
-
-    Eina_Inlist** start = priv->view.items + priv->view.rows - 1;
-    Eina_Inlist** end = priv->view.items;
-
-    for (; count > 0; --count) {
-        Eina_Inlist** it;
-        Eina_Inlist* temp = *start;
-        Evas_Coord tilePositionX = originX;
-
-        for (it = start; it > end; --it)
-            *it = *(it - 1);
-        *it = temp;
-
-        --priv->model.base.row;
-
-        unsigned long column = 0;
-        Ewk_Tiled_Backing_Store_Item* item;
-        EINA_INLIST_FOREACH(temp, item) {
-            _ewk_tiled_backing_store_item_move(item, tilePositionX, tilePositionY);
-            tilePositionX += tileWidth;
-            _ewk_tiled_backing_store_item_fill(priv, item, column, 0);
-            ++column;
-        }
-        tilePositionY -= tileHeight;
-    }
-    priv->view.offset.base.y = offsetY;
-}
-
-/**
- * @internal
- * Move left-most (first) column right as last (right-most).
- *
- * The final result is visually the same, but logically the first column that
- * went out of screen is now at last and filled with new model items.
- *
- * This is worth just when @a count is smaller than @c
- * priv->view.columns, after that one is refilling the whole matrix so it
- * is better to trigger full refill.
- *
- * @param count the number of times to repeat the process.
- */
-static void _ewk_tiled_backing_store_view_wrap_left(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y, unsigned long count)
-{
-    unsigned long lastColumn = priv->view.columns - 1;
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-    Evas_Coord offsetX = priv->view.offset.base.x + count * tileWidth;
-    Evas_Coord offsetY = y + priv->view.offset.base.y;
-
-    unsigned long baseColumn = lastColumn - count + 1;
-    Evas_Coord originX = x + baseColumn * tileWidth + offsetX;
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-
-    priv->model.base.column += count;
-
-    for (unsigned long row = 0; it < end; ++it, ++row) {
-        Evas_Coord tilePositionX = originX;
-        unsigned long column = baseColumn;
-
-        for (unsigned long i = 0; i < count; ++i, ++column, tilePositionX += tileWidth) {
-            Ewk_Tiled_Backing_Store_Item* item = EINA_INLIST_CONTAINER_GET(*it, Ewk_Tiled_Backing_Store_Item);
-            *it = eina_inlist_demote(*it, *it);
-
-            _ewk_tiled_backing_store_item_move(item, tilePositionX, offsetY);
-            _ewk_tiled_backing_store_item_fill(priv, item, column, row);
-        }
-        offsetY += tileHeight;
-    }
-
-    priv->view.offset.base.x = offsetX;
-}
-
-/**
- * @internal
- * Move right-most (last) column left as first (left-most).
- *
- * The final result is visually the same, but logically the last column that
- * went out of screen is now at first and filled with new model items.
- *
- * This is worth just when @a count is smaller than @c
- * priv->view.columns, after that one is refilling the whole matrix so it
- * is better to trigger full refill.
- *
- * @param count the number of times to repeat the process.
- */
-static void _ewk_tiled_backing_store_view_wrap_right(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y, unsigned long count)
-{
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-    Evas_Coord offsetX = priv->view.offset.base.x - count * tileWidth;
-    Evas_Coord tilePositionY = y + priv->view.offset.base.y;
-
-    unsigned long baseColumn = count - 1;
-    Evas_Coord originX = x + baseColumn * tileWidth + offsetX;
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-
-    priv->model.base.column -= count;
-
-    for (unsigned long row = 0; it < end; ++it, ++row) {
-        Evas_Coord tilePositionX = originX;
-        unsigned long column = baseColumn;
-
-        for (unsigned long i = 0; i < count; ++i, --column, tilePositionX -= tileWidth) {
-            Ewk_Tiled_Backing_Store_Item* item = EINA_INLIST_CONTAINER_GET((*it)->last, Ewk_Tiled_Backing_Store_Item);
-            *it = eina_inlist_promote(*it, (*it)->last);
-
-            _ewk_tiled_backing_store_item_move(item, tilePositionX, tilePositionY);
-            _ewk_tiled_backing_store_item_fill(priv, item, column, row);
-        }
-        tilePositionY += tileHeight;
-    }
-
-    priv->view.offset.base.x = offsetX;
-}
-
-static void _ewk_tiled_backing_store_view_refill(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y, int stepX, int stepY)
-{
-    evas_object_move(priv->base.clipper, x, y);
-
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-
-    Evas_Coord baseTilePositionX = x + priv->view.offset.base.x;
-    Evas_Coord tilePositionY = y + priv->view.offset.base.y;
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-
-    priv->model.base.column -= stepX;
-    priv->model.base.row -= stepY;
-
-    for (unsigned long row = 0; it < end; ++it, ++row) {
-        Ewk_Tiled_Backing_Store_Item* item;
-        Evas_Coord newTilePositionX = baseTilePositionX;
-        unsigned long column = 0;
-        EINA_INLIST_FOREACH(*it, item) {
-            _ewk_tiled_backing_store_item_fill(priv, item, column, row);
-            _ewk_tiled_backing_store_item_move(item, newTilePositionX, tilePositionY);
-            ++column;
-            newTilePositionX += tileWidth;
-        }
-        tilePositionY += tileHeight;
-    }
-}
-
-static void _ewk_tiled_backing_store_view_pos_apply(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y)
-{
-    evas_object_move(priv->base.clipper, x, y);
-
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-
-    Evas_Coord baseTilePositionX = x + priv->view.offset.base.x;
-    Evas_Coord baseTilePositionY = y + priv->view.offset.base.y;
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-    for (; it < end; ++it) {
-        Ewk_Tiled_Backing_Store_Item* item;
-        Evas_Coord offsetX = baseTilePositionX;
-        EINA_INLIST_FOREACH(*it, item) {
-            _ewk_tiled_backing_store_item_move(item, offsetX, baseTilePositionY);
-            offsetX += tileWidth;
-        }
-        baseTilePositionY += tileHeight;
-    }
-}
-
-static void _ewk_tiled_backing_store_smart_calculate_offset_force(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    Evas_Coord deltaX = priv->view.offset.current.x - priv->view.offset.old.x;
-    Evas_Coord deltaY = priv->view.offset.current.y - priv->view.offset.old.y;
-
-    INFO("ewkBackingStore=%p, offset: %+4d, %+4d (%+4d, %+4d)",
-        priv->self, deltaX, deltaY, priv->view.offset.current.x, priv->view.offset.current.y);
-
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-
-    unsigned long newColumn = -priv->view.offset.current.x / tileWidth;
-    int stepX = priv->model.base.column - newColumn;
-    unsigned long newRow = -priv->view.offset.current.y / tileHeight;
-    int stepY = priv->model.base.row - newRow;
-
-    priv->view.offset.old.x = priv->view.offset.current.x;
-    priv->view.offset.old.y = priv->view.offset.current.y;
-    evas_object_move(priv->contentsClipper, priv->view.offset.current.x + priv->view.x, priv->view.offset.current.y + priv->view.y);
-
-    priv->view.offset.base.x += deltaX - stepX * tileWidth;
-    priv->view.offset.base.y += deltaY - stepY * tileHeight;
-
-    _ewk_tiled_backing_store_view_refill(priv, priv->view.x, priv->view.y, stepX, stepY);
-}
-
-static void _ewk_tiled_backing_store_smart_calculate_offset(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y)
-{
-    Evas_Coord deltaX = priv->view.offset.current.x - priv->view.offset.old.x;
-    Evas_Coord deltaY = priv->view.offset.current.y - priv->view.offset.old.y;
-
-    INFO("ewkBackingStore=%p, offset: %+4d, %+4d (%+4d, %+4d)", priv->self, deltaX, deltaY, priv->view.offset.current.x, priv->view.offset.current.y);
-
-    if (!deltaX && !deltaY)
-        return;
-
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-
-    long newCol = -priv->view.offset.current.x / tileWidth;
-    long stepX = priv->model.base.column - newCol;
-    long newRow = -priv->view.offset.current.y / tileHeight;
-    long stepY = priv->model.base.row - newRow;
-
-    priv->view.offset.old.x = priv->view.offset.current.x;
-    priv->view.offset.old.y = priv->view.offset.current.y;
-    evas_object_move(priv->contentsClipper, priv->view.offset.current.x + priv->view.x, priv->view.offset.current.y + priv->view.y);
-
-    if ((stepX < 0 && stepX <= -static_cast<long>(priv->view.columns))
-        || (stepX > 0 && stepX >= static_cast<long>(priv->view.columns))
-        || (stepY < 0 && stepY <= -static_cast<long>(priv->view.rows))
-        || (stepY > 0 && stepY >= static_cast<long>(priv->view.rows))) {
-
-        priv->view.offset.base.x += deltaX - stepX * tileWidth;
-        priv->view.offset.base.y += deltaY - stepY * tileHeight;
-
-        _ewk_tiled_backing_store_view_refill(priv, priv->view.x, priv->view.y, stepX, stepY);
-        return;
-    }
-
-    priv->view.offset.base.x += deltaX;
-    priv->view.offset.base.y += deltaY;
-
-    if (stepY < 0)
-        _ewk_tiled_backing_store_view_wrap_up(priv, x, y, -stepY);
-    else if (stepY > 0)
-        _ewk_tiled_backing_store_view_wrap_down(priv, x, y, stepY);
-
-    if (stepX < 0)
-        _ewk_tiled_backing_store_view_wrap_left(priv, x, y, -stepX);
-    else if (stepX > 0)
-        _ewk_tiled_backing_store_view_wrap_right(priv, x, y, stepX);
-
-    _ewk_tiled_backing_store_view_pos_apply(priv, x, y);
-}
-
-static void _ewk_tiled_backing_store_smart_calculate_pos(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y)
-{
-    _ewk_tiled_backing_store_view_pos_apply(priv, x, y);
-    priv->view.x = x;
-    priv->view.y = y;
-    evas_object_move(priv->contentsClipper, priv->view.offset.current.x + priv->view.x, priv->view.offset.current.y + priv->view.y);
-}
-
-static void _ewk_tiled_backing_store_fill_renderers(Ewk_Tiled_Backing_Store_Data* priv)
-{
-    for (unsigned long i = 0; i < priv->view.rows; ++i) {
-        Eina_Inlist* list = priv->view.items[i];
-
-        unsigned long j = 0;
-        Ewk_Tiled_Backing_Store_Item* item;
-        EINA_INLIST_FOREACH(list, item)
-            _ewk_tiled_backing_store_item_fill(priv, item, j++, i);
-    }
-}
-
-static void _ewk_tiled_backing_store_smart_calculate(Evas_Object* ewkBackingStore)
-{
-    Evas_Coord x, y, width, height;
-
-    evas_object_geometry_get(ewkBackingStore, &x, &y, &width, &height);
-    DBG("ewkBackingStore=%p at %d,%d + %dx%d", ewkBackingStore, x, y, width, height);
-
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    priv->changed.any = false;
-
-    ewk_tile_matrix_freeze(priv->model.matrix);
-
-    if (priv->changed.contentsSize)
-        ewk_tile_matrix_invalidate(priv->model.matrix);
-
-    if (!priv->render.suspend && (priv->changed.model || priv->changed.contentsSize)) {
-        unsigned long columns = priv->model.width / priv->view.tile.width + 1;
-        unsigned long rows = priv->model.height / priv->view.tile.height + 1;
-
-        priv->model.old.columns = priv->model.current.columns;
-        priv->model.old.rows = priv->model.current.rows;
-        priv->model.current.columns = columns;
-        priv->model.current.rows = rows;
-        if (priv->model.old.columns > columns)
-            columns = priv->model.old.columns;
-        if (priv->model.old.rows > rows)
-            rows = priv->model.old.rows;
-        ewk_tile_matrix_resize(priv->model.matrix, columns, rows);
-    }
-
-    if (priv->changed.position && (priv->view.x != x || priv->view.y != y)) {
-        _ewk_tiled_backing_store_smart_calculate_pos(priv, x, y);
-        priv->changed.position = false;
-    }
-    if (priv->changed.offset) {
-        _ewk_tiled_backing_store_smart_calculate_offset(priv, x, y);
-        priv->changed.offset = false;
-    }
-
-    if (priv->changed.size) {
-        _ewk_tiled_backing_store_smart_calculate_size(priv, width, height);
-        priv->changed.size = false;
-    }
-
-    if (!priv->render.suspend && (priv->changed.model || priv->changed.contentsSize)) {
-        _ewk_tiled_backing_store_fill_renderers(priv);
-        ewk_tile_matrix_resize(priv->model.matrix,
-                               priv->model.current.columns,
-                               priv->model.current.rows);
-        priv->changed.model = false;
-        evas_object_resize(priv->contentsClipper, priv->model.width, priv->model.height);
-        _ewk_tiled_backing_store_smart_calculate_offset_force(priv);
-
-        /* Make sure we do not miss any important repaint by
-         * repainting the whole viewport */
-        const Eina_Rectangle rect = { 0, 0, priv->model.width, priv->model.height };
-        ewk_tile_matrix_update(priv->model.matrix, &rect, priv->view.tile.zoom);
-
-        priv->changed.contentsSize = false;
-    }
-
-    ewk_tile_matrix_thaw(priv->model.matrix);
-
-    _ewk_tiled_backing_store_updates_process(priv);
-
-    if (priv->view.offset.base.x > 0
-        || priv->view.offset.base.x <= - priv->view.tile.width
-        || priv->view.offset.base.y > 0
-        || priv->view.offset.base.y <= - priv->view.tile.height) {
-        ERR("incorrect base offset %+4d,%+4d, tile=%dx%d, current=%+4d,%+4d\n",
-            priv->view.offset.base.x, priv->view.offset.base.y,
-            priv->view.tile.width, priv->view.tile.height,
-            priv->view.offset.current.x, priv->view.offset.current.y);
-    }
-}
-
-Evas_Object* ewk_tiled_backing_store_add(Evas* canvas)
-{
-    static Evas_Smart* smart = 0;
-
-    if (!smart) {
-        static Evas_Smart_Class sc =
-            EVAS_SMART_CLASS_INIT_NAME_VERSION("Ewk_Tiled_Backing_Store");
-
-        evas_object_smart_clipped_smart_set(&sc);
-        _parent_sc = sc;
-
-        sc.add = _ewk_tiled_backing_store_smart_add;
-        sc.del = _ewk_tiled_backing_store_smart_del;
-        sc.resize = _ewk_tiled_backing_store_smart_resize;
-        sc.move = _ewk_tiled_backing_store_smart_move;
-        sc.show = _ewk_tiled_backing_store_smart_show;
-        sc.hide = _ewk_tiled_backing_store_smart_hide;
-        sc.calculate = _ewk_tiled_backing_store_smart_calculate;
-        sc.member_add = _ewk_tiled_backing_store_smart_member_add;
-        sc.member_del = _ewk_tiled_backing_store_smart_member_del;
-
-        smart = evas_smart_class_new(&sc);
-    }
-
-    return evas_object_smart_add(canvas, smart);
-}
-
-void ewk_tiled_backing_store_render_cb_set(Evas_Object* ewkBackingStore, bool (*callback)(void* data, Ewk_Tile* tile, const Eina_Rectangle* area), const void* data)
-{
-    EINA_SAFETY_ON_NULL_RETURN(callback);
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    priv->render.callback = callback;
-    priv->render.data = const_cast<void*>(data);
-}
-
-Ewk_Tile_Unused_Cache* ewk_tiled_backing_store_tile_unused_cache_get(const Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, 0);
-
-    return ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-}
-
-void ewk_tiled_backing_store_tile_unused_cache_set(Evas_Object* ewkBackingStore, Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    if (ewk_tile_matrix_unused_cache_get(priv->model.matrix) == tileUnusedCache)
-        return;
-
-    _ewk_tiled_backing_store_model_matrix_create(priv, tileUnusedCache);
-}
-
-static bool _ewk_tiled_backing_store_scroll_full_offset_set_internal(Ewk_Tiled_Backing_Store_Data* priv, Evas_Coord x, Evas_Coord y)
-{
-    /* TODO: check offset go out of bounds, clamp */
-    if (priv->render.disabled)
-        return false;
-
-    priv->view.offset.current.x = x;
-    priv->view.offset.current.y = y;
-
-    priv->changed.offset = true;
-    _ewk_tiled_backing_store_changed(priv);
-
-    return true;
-}
-
-bool ewk_tiled_backing_store_scroll_full_offset_set(Evas_Object* ewkBackingStore, Evas_Coord x, Evas_Coord y)
-{
-    DBG("ewkBackingStore=%p, x=%d, y=%d", ewkBackingStore, x, y);
-
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-    if (x == priv->view.offset.current.x && y == priv->view.offset.current.y)
-        return true;
-
-    return _ewk_tiled_backing_store_scroll_full_offset_set_internal(priv, x, y);
-}
-
-bool ewk_tiled_backing_store_scroll_full_offset_add(Evas_Object* ewkBackingStore, Evas_Coord deltaX, Evas_Coord deltaY)
-{
-    DBG("ewkBackingStore=%p, deltaX=%d, deltaY=%d", ewkBackingStore, deltaX, deltaY);
-
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-    if (!deltaX && !deltaY)
-        return true;
-
-    return _ewk_tiled_backing_store_scroll_full_offset_set_internal(priv, priv->view.offset.current.x + deltaX, priv->view.offset.current.y + deltaY);
-}
-
-static bool _ewk_tiled_backing_store_zoom_set_internal(Ewk_Tiled_Backing_Store_Data* priv, float* zoom, Evas_Coord currentX, Evas_Coord currentY, Evas_Coord* offsetX, Evas_Coord* offsetY)
-{
-    *offsetX = priv->view.offset.current.x;
-    *offsetY = priv->view.offset.current.y;
-
-    if (fabsf(priv->view.tile.zoom - *zoom) < zoomStepMinimum) {
-        DBG("ignored as zoom difference is < %f: %f",
-            (double)zoomStepMinimum, fabsf(priv->view.tile.zoom - *zoom));
-
-        return true;
-    }
-
-    _ewk_tiled_backing_store_pre_render_request_flush(priv);
-
-    *zoom = ROUNDED_ZOOM(priv->view.tile.width, *zoom);
-
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-
-    float scale = *zoom / priv->view.tile.zoom;
-
-    priv->view.tile.zoom = *zoom;
-    // todo: check currentX [0, w]...
-    priv->view.offset.zoomCenter.x = currentX;
-    priv->view.offset.zoomCenter.y = currentY;
-
-    unsigned long columns, rows;
-    ewk_tile_matrix_size_get(priv->model.matrix, &columns, &rows);
-    if (!ewk_tile_matrix_zoom_level_set(priv->model.matrix, *zoom))
-        ewk_tile_matrix_entry_new(priv->model.matrix, *zoom);
-    ewk_tile_matrix_resize(priv->model.matrix, columns, rows);
-
-    if (!priv->view.width || !priv->view.height) {
-        priv->view.offset.base.x = 0;
-        priv->view.offset.base.y = 0;
-        return true;
-    }
-
-    Evas_Coord newX = currentX + (priv->view.offset.current.x - currentX) * scale;
-    Evas_Coord newY = currentY + (priv->view.offset.current.y - currentY) * scale;
-
-    Evas_Coord modelWidth = priv->model.width * scale;
-    Evas_Coord modelHeight = priv->model.height * scale;
-
-    if (modelWidth < priv->view.width || newX >= 0)
-        newX = 0;
-    else if (-newX + priv->view.width >= modelWidth)
-        newX = -modelWidth + priv->view.width;
-
-    if (modelHeight < priv->view.height || newY >= 0)
-        newY = 0;
-    else if (-newY + priv->view.height >= modelHeight)
-        newY = -modelHeight + priv->view.height;
-
-    Evas_Coord baseX = newX % tileWidth;
-    Evas_Coord baseY = newY % tileHeight;
-    priv->model.base.column = -newX / tileWidth;
-    priv->model.base.row = -newY / tileHeight;
-
-    priv->changed.size = true;
-    priv->changed.model = true;
-    _ewk_tiled_backing_store_changed(priv);
-
-    priv->view.offset.current.x = newX;
-    priv->view.offset.current.y = newY;
-    priv->view.offset.base.x = baseX;
-    priv->view.offset.base.y = baseY;
-
-    priv->view.offset.old.x = priv->view.offset.current.x;
-    priv->view.offset.old.y = priv->view.offset.current.y;
-    *offsetX = priv->view.offset.current.x;
-    *offsetY = priv->view.offset.current.y;
-
-    evas_object_move(priv->contentsClipper, newX + priv->view.x, newY + priv->view.y);
-
-    _ewk_tiled_backing_store_fill_renderers(priv);
-
-    Evas_Coord tilePositionY = priv->view.offset.base.y + priv->view.y;
-    Evas_Coord baseTilePositionX = priv->view.x + priv->view.offset.base.x;
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-    for (; it < end; ++it) {
-        Evas_Coord tilePositionX = baseTilePositionX;
-        Eina_Inlist* lst = *it;
-        Ewk_Tiled_Backing_Store_Item* item;
-        EINA_INLIST_FOREACH(lst, item) {
-            _ewk_tiled_backing_store_item_move(item, tilePositionX, tilePositionY);
-            _ewk_tiled_backing_store_item_resize(item, tileWidth, tileHeight);
-            tilePositionX += tileWidth;
-        }
-        tilePositionY += tileHeight;
-    }
-
-    return true;
-}
-
-bool ewk_tiled_backing_store_zoom_set(Evas_Object* ewkBackingStore, float* zoom, Evas_Coord currentX, Evas_Coord currentY, Evas_Coord* offsetX, Evas_Coord* offsetY)
-{
-    DBG("ewkBackingStore=%p, zoom=%f", ewkBackingStore, *zoom);
-
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-
-    return _ewk_tiled_backing_store_zoom_set_internal(priv, zoom, currentX, currentY, offsetX, offsetY);
-}
-
-bool ewk_tiled_backing_store_zoom_weak_set(Evas_Object* ewkBackingStore, float zoom, Evas_Coord currentX, Evas_Coord currentY)
-{
-    DBG("ewkBackingStore=%p, zoom=%f", ewkBackingStore, zoom);
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-    if (!priv->view.width || !priv->view.height)
-        return false;
-
-    bool reCalculate = false;
-
-    float scale = zoom / priv->view.tile.zoom;
-
-    Evas_Coord tileWidth = TILE_SIZE_AT_ZOOM(priv->view.tile.width, scale);
-    scale = TILE_ZOOM_AT_SIZE(tileWidth, priv->view.tile.width);
-    Evas_Coord tileHeight = TILE_SIZE_AT_ZOOM(priv->view.tile.height, scale);
-    zoom = scale * priv->view.tile.zoom;
-
-    Evas_Coord modelWidth = priv->model.width * scale;
-    Evas_Coord modelHeight = priv->model.height * scale;
-
-    evas_object_resize(priv->contentsClipper, modelWidth, modelHeight);
-
-    unsigned long vrows = static_cast<unsigned long>(ceil(priv->view.height /static_cast<float>(tileHeight)) + 1);
-    unsigned long vcols = static_cast<unsigned long>(ceil(priv->view.width / static_cast<float>(tileWidth)) + 1);
-    Evas_Coord newX = currentX + (priv->view.offset.current.x - currentX) * scale;
-    Evas_Coord newY = currentY + (priv->view.offset.current.y - currentY) * scale;
-    Evas_Coord baseX = newX % tileWidth;
-    Evas_Coord baseY = newY % tileHeight;
-    unsigned long baseRow = -newY / tileHeight;
-    unsigned long baseColumn = -newX / tileWidth;
-
-    if (baseRow != priv->model.base.row || baseColumn != priv->model.base.column) {
-        priv->model.base.row = baseRow;
-        priv->model.base.column = baseColumn;
-        reCalculate = true;
-    }
-
-    if (vrows > priv->view.rows || vcols > priv->view.columns)
-        reCalculate = true;
-
-    if (reCalculate) {
-        Evas_Coord width, height;
-        evas_object_geometry_get(ewkBackingStore, 0, 0, &width, &height);
-        _ewk_tiled_backing_store_recalc_renderers(priv, width, height, tileWidth, tileHeight);
-        _ewk_tiled_backing_store_fill_renderers(priv);
-        _ewk_tiled_backing_store_updates_process(priv);
-    }
-
-    Evas_Coord baseTilePositionX = baseX + priv->view.x;
-    Evas_Coord tilePositionY = baseY + priv->view.y;
-
-    evas_object_move(priv->contentsClipper, newX + priv->view.x, newY + priv->view.y);
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-    for (; it < end; ++it) {
-        Evas_Coord tilePositionX = baseTilePositionX;
-        Eina_Inlist* list = *it;
-        Ewk_Tiled_Backing_Store_Item* item;
-        EINA_INLIST_FOREACH(list, item) {
-            _ewk_tiled_backing_store_item_move(item, tilePositionX, tilePositionY);
-            _ewk_tiled_backing_store_item_resize(item, tileWidth, tileHeight);
-            tilePositionX += tileWidth;
-        }
-        tilePositionY += tileHeight;
-    }
-
-    return true;
-}
-
-void ewk_tiled_backing_store_fix_offsets(Evas_Object* ewkBackingStore, Evas_Coord width, Evas_Coord height)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    Evas_Coord newX = priv->view.offset.current.x;
-    Evas_Coord newY = priv->view.offset.current.y;
-    Evas_Coord baseX = priv->view.offset.base.x;
-    Evas_Coord baseY = priv->view.offset.base.y;
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-
-    if (-newX > width) {
-        newX = -width;
-        baseX = newX % tileWidth;
-        priv->model.base.column = -newX / tileWidth;
-    }
-
-    if (-newY > height) {
-        newY = -height;
-        baseY = newY % tileHeight;
-        priv->model.base.row = -newY / tileHeight;
-    }
-
-    if (baseX >= 0 || baseX <= -2 * priv->view.tile.width) {
-        baseX = newX % tileWidth;
-        priv->model.base.column = -newX / tileWidth;
-    }
-
-    if (baseY >= 0 || baseY <= -2 * priv->view.tile.height) {
-        baseY = newY % tileHeight;
-        priv->model.base.row = -newY / tileHeight;
-    }
-
-    priv->view.offset.current.x = newX;
-    priv->view.offset.current.y = newY;
-    priv->view.offset.old.x = newX;
-    priv->view.offset.old.y = newY;
-    priv->view.offset.base.x = baseX;
-    priv->view.offset.base.y = baseY;
-    evas_object_move(priv->contentsClipper, newX + priv->view.x, newY + priv->view.y);
-
-    Evas_Coord tilePositionY = priv->view.offset.base.y + priv->view.y;
-    Evas_Coord baseTilePositionX = priv->view.x + priv->view.offset.base.x;
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-    for (; it < end; ++it) {
-        Evas_Coord tilePositionX = baseTilePositionX;
-        Eina_Inlist* lst = *it;
-        Ewk_Tiled_Backing_Store_Item* item;
-        EINA_INLIST_FOREACH(lst, item) {
-            _ewk_tiled_backing_store_item_move(item, tilePositionX, tilePositionY);
-            _ewk_tiled_backing_store_item_resize(item, tileWidth, tileHeight);
-            tilePositionX += tileWidth;
-        }
-        tilePositionY += tileHeight;
-    }
-}
-
-void ewk_tiled_backing_store_zoom_weak_smooth_scale_set(Evas_Object* ewkBackingStore, bool smoothScale)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    Eina_Inlist** it = priv->view.items;
-    Eina_Inlist** end = it + priv->view.rows;
-    priv->view.tile.zoomWeakSmoothScale = smoothScale;
-
-    for (; it< end; ++it) {
-        Ewk_Tiled_Backing_Store_Item* item;
-        EINA_INLIST_FOREACH(*it, item)
-            if (item->tile)
-                _ewk_tiled_backing_store_item_smooth_scale_set(item, smoothScale);
-    }
-}
-
-void ewk_tiled_backing_store_alpha_set(Evas_Object* ewkBackingStore, bool hasAlpha)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-    priv->view.tile.hasAlpha = hasAlpha;
-}
-
-bool ewk_tiled_backing_store_update(Evas_Object* ewkBackingStore, const Eina_Rectangle* update)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-
-    if (priv->render.disabled)
-        return false;
-
-    return ewk_tile_matrix_update(priv->model.matrix, update, priv->view.tile.zoom);
-}
-
-void ewk_tiled_backing_store_updates_process_pre_set(Evas_Object* ewkBackingStore, void* (*callback)(void* data, Evas_Object *ewkBackingStore), const void* data)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-    priv->process.preCallback = callback;
-    priv->process.preData = const_cast<void*>(data);
-}
-
-void ewk_tiled_backing_store_updates_process_post_set(Evas_Object* ewkBackingStore, void* (*callback)(void* data, void* preData, Evas_Object *ewkBackingStore), const void* data)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-    priv->process.postCallback = callback;
-    priv->process.postData = const_cast<void*>(data);
-}
-
-void ewk_tiled_backing_store_updates_process(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-    _ewk_tiled_backing_store_updates_process(priv);
-}
-
-void ewk_tiled_backing_store_updates_clear(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    ewk_tile_matrix_updates_clear(priv->model.matrix);
-}
-
-void ewk_tiled_backing_store_contents_resize(Evas_Object* ewkBackingStore, Evas_Coord width, Evas_Coord height)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    if (width == priv->model.width && height == priv->model.height)
-        return;
-
-    priv->model.width = width;
-    priv->model.height = height;
-    priv->changed.contentsSize = true;
-
-    DBG("w,h=%d, %d", width, height);
-    _ewk_tiled_backing_store_changed(priv);
-}
-
-void ewk_tiled_backing_store_disabled_update_set(Evas_Object* ewkBackingStore, bool value)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    if (value != priv->render.disabled)
-        priv->render.disabled = value;
-}
-
-void ewk_tiled_backing_store_flush(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    priv->view.offset.current.x = 0;
-    priv->view.offset.current.y = 0;
-    priv->view.offset.old.x = 0;
-    priv->view.offset.old.y = 0;
-    priv->view.offset.base.x = 0;
-    priv->view.offset.base.y = 0;
-    priv->model.base.column = 0;
-    priv->model.base.row = 0;
-    priv->model.current.columns = 1;
-    priv->model.current.rows = 1;
-    priv->model.old.columns = 0;
-    priv->model.old.rows = 0;
-    priv->model.width = 0;
-    priv->model.height = 0;
-    priv->changed.size = true;
-
-#ifdef DEBUG_MEM_LEAKS
-    printf("\nFLUSHED BACKING STORE, STATUS BEFORE DELETING TILE MATRIX:\n");
-    _ewk_tiled_backing_store_mem_dbg(priv);
-#endif
-
-    _ewk_tiled_backing_store_pre_render_request_flush(priv);
-    _ewk_tiled_backing_store_tile_dissociate_all(priv);
-    Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-    ewk_tile_unused_cache_clear(tileUnusedCache);
-
-#ifdef DEBUG_MEM_LEAKS
-    printf("\nFLUSHED BACKING STORE, STATUS AFTER RECREATING TILE MATRIX:\n");
-    _ewk_tiled_backing_store_mem_dbg(priv);
-#endif
-}
-
-bool ewk_tiled_backing_store_pre_render_tile_add(Evas_Object* ewkBackingStore, unsigned long column, unsigned long row, float zoom)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-
-    if (ewk_tile_matrix_tile_exact_exists(priv->model.matrix, column, row, zoom))
-        return false;
-
-    if (!_ewk_tiled_backing_store_pre_render_request_add(priv, column, row, zoom))
-        return false;
-
-    return true;
-}
-
-bool ewk_tiled_backing_store_pre_render_spiral_queue(Evas_Object* ewkBackingStore, Eina_Rectangle* viewRect, Eina_Rectangle* renderRect, int maxMemory, float zoom)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-    EINA_SAFETY_ON_NULL_RETURN_VAL(viewRect, false);
-    EINA_SAFETY_ON_NULL_RETURN_VAL(renderRect, false);
-
-    const int tileWidth = priv->view.tile.width;
-    const int tileHeight = priv->view.tile.height;
-
-    Eina_Tile_Grid_Slicer viewSlicer;
-    if (!eina_tile_grid_slicer_setup(&viewSlicer, viewRect->x, viewRect->y, viewRect->w, viewRect->h, tileWidth, tileHeight)) {
-        ERR("could not setup grid viewSlicer for %d,%d+%dx%d tile=%dx%d", viewRect->x, viewRect->y, viewRect->w, viewRect->h, tileWidth, tileHeight);
-        return false;
-    }
-
-    Eina_Tile_Grid_Slicer renderSlicer;
-    if (!eina_tile_grid_slicer_setup(&renderSlicer, renderRect->x, renderRect->y, renderRect->w, renderRect->h, tileWidth, tileHeight)) {
-        ERR("could not setup grid RenderSlicer for %d,%d+%dx%d tile=%dx%d", renderRect->y, renderRect->y, renderRect->w, renderRect->h, tileWidth, tileHeight);
-        return false;
-    }
-
-    // set limits of the loop.
-    int memoryLimits = maxMemory / (EWK_ARGB_BYTES_SIZE * tileWidth * tileHeight);
-    const unsigned long maxViewSideLength = std::max(viewSlicer.col2 - viewSlicer.col1, viewSlicer.row2 - viewSlicer.row1);
-    const unsigned long maxRenderSideLength = std::max(renderSlicer.col2 - renderSlicer.col1, renderSlicer.row2 - renderSlicer.row1);
-    const unsigned long maxLoopCount = maxViewSideLength + maxRenderSideLength;
-
-    // spire starts from the center of the view area.
-    unsigned long centerColumn = (viewSlicer.col1 + viewSlicer.col2) / 2;
-    unsigned long centerRow = (viewSlicer.row1 + viewSlicer.row2) / 2;
-
-    unsigned long step = 1;
-    const unsigned squareSide = 4;
-    for (unsigned loop = 0; loop < maxLoopCount; ++loop) {
-        for (unsigned long i = 1; i < step * squareSide + 1; ++i) {
-            if (memoryLimits <= 0)
-                goto memoryLimitsReached;
-            /*
-            this code means the loop runs like spiral. (i.g. left->down->right->up)
-            when it moves back to original place and then walk 1 tile left and up.
-            the loop keeps on doing this until it reaches max memory to draw tiles.
-            e.g. )
-                         333333
-                         322223
-                         321123
-                         321123
-                         322223
-                         333333
-            */
-            if (i > 0 && i <= step)
-                ++centerColumn; // move left.
-            else if (i > step && i <= step * 2)
-                ++centerRow; // move down.
-            else if (i > step * 2 && i <= step * 3)
-                --centerColumn; // move right.
-            else if (i > step * 3 && i <= step * 4)
-                --centerRow; // move up.
-            else
-                ERR("ERROR : out of bounds\r\n");
-
-            // skip in view port area.
-            if (viewSlicer.col1 < centerColumn
-                && viewSlicer.col2 > centerColumn
-                && viewSlicer.row1 < centerRow
-                && viewSlicer.row2 > centerRow)
-                continue;
-
-            if (renderSlicer.col1 <= centerColumn
-                && renderSlicer.col2 >= centerColumn
-                && renderSlicer.row1 <= centerRow
-                && renderSlicer.row2 >= centerRow) {
-
-                if (!ewk_tiled_backing_store_pre_render_tile_add(ewkBackingStore, centerColumn, centerRow, zoom))
-                    continue;
-                DBG("R>[%lu %lu] ", centerColumn, centerRow);
-                --memoryLimits;
-            }
-        }
-        --centerRow;
-        --centerColumn;
-        step += 2;
-    }
-
-memoryLimitsReached:
-    _ewk_tiled_backing_store_item_process_idler_start(priv);
-
-    return true;
-}
-
-bool ewk_tiled_backing_store_pre_render_region(Evas_Object* ewkBackingStore, Evas_Coord x, Evas_Coord y, Evas_Coord width, Evas_Coord height, float zoom)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-
-    Evas_Coord tileWidth = priv->view.tile.width;
-    Evas_Coord tileHeight = priv->view.tile.height;
-    zoom = ROUNDED_ZOOM(priv->view.tile.width, zoom);
-
-    Eina_Tile_Grid_Slicer slicer;
-    memset(&slicer, 0, sizeof(Eina_Tile_Grid_Slicer));
-
-    if (!eina_tile_grid_slicer_setup(&slicer, x, y, width, height, tileWidth, tileHeight)) {
-        ERR("could not setup grid slicer for %d,%d+%dx%d tile=%dx%d",
-            x, y, width, height, tileWidth, tileHeight);
-        return false;
-    }
-
-    const Eina_Tile_Grid_Info* gridInfo;
-    while (eina_tile_grid_slicer_next(&slicer, &gridInfo)) {
-        const unsigned long column = gridInfo->col;
-        const unsigned long row = gridInfo->row;
-        if (!_ewk_tiled_backing_store_pre_render_request_add(priv, column, row, zoom))
-            break;
-    }
-
-    _ewk_tiled_backing_store_item_process_idler_start(priv);
-
-    Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-    ewk_tile_unused_cache_lock_area(tileUnusedCache, x, y, width, height, zoom);
-
-    return true;
-}
-
-bool ewk_tiled_backing_store_pre_render_relative_radius(Evas_Object* ewkBackingStore, unsigned int n, float zoom)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-
-    INFO("priv->model.base.row =%ld, n=%u priv->view.rows=%lu", priv->model.base.row, n, priv->view.rows);
-    unsigned long startRow = priv->model.base.row - n;
-    unsigned long startCol = priv->model.base.column - n;
-    unsigned long endRow = std::min(priv->model.current.rows - 1, priv->model.base.row + priv->view.rows + n - 1);
-    unsigned long endCol = std::min(priv->model.current.columns - 1, priv->model.base.column + priv->view.columns + n - 1);
-
-    INFO("startRow=%lu, endRow=%lu, startCol=%lu, endCol=%lu", startRow, endRow, startCol, endCol);
-
-    zoom = ROUNDED_ZOOM(priv->view.tile.width, zoom);
-
-    for (unsigned long i = startRow; i <= endRow; ++i)
-        for (unsigned long j = startCol; j <= endCol; ++j)
-            if (!_ewk_tiled_backing_store_pre_render_request_add(priv, j, i, zoom))
-                goto start_processing;
-
-start_processing:
-    _ewk_tiled_backing_store_item_process_idler_start(priv);
-
-    Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-    unsigned long height = (endRow - startRow + 1) * TILE_SIZE_AT_ZOOM(priv->view.tile.height, zoom);
-    unsigned long width = (endCol - startCol + 1) * TILE_SIZE_AT_ZOOM(priv->view.tile.width, zoom);
-    ewk_tile_unused_cache_lock_area(tileUnusedCache,
-                                    startCol * TILE_SIZE_AT_ZOOM(priv->view.tile.width, zoom),
-                                    startRow * TILE_SIZE_AT_ZOOM(priv->view.tile.height, zoom), width, height, zoom);
-
-    return true;
-}
-
-void ewk_tiled_backing_store_pre_render_cancel(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv);
-
-    _ewk_tiled_backing_store_pre_render_request_clear(priv);
-
-    Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_tile_matrix_unused_cache_get(priv->model.matrix);
-    ewk_tile_unused_cache_unlock_area(tileUnusedCache);
-}
-
-bool ewk_tiled_backing_store_disable_render(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-
-    return _ewk_tiled_backing_store_disable_render(priv);
-}
-
-bool ewk_tiled_backing_store_enable_render(Evas_Object* ewkBackingStore)
-{
-    PRIV_DATA_GET_OR_RETURN(ewkBackingStore, priv, false);
-    _ewk_tiled_backing_store_changed(priv);
-
-    return _ewk_tiled_backing_store_enable_render(priv);
-}
diff --git a/Source/WebKit/efl/ewk/ewk_tiled_backing_store_private.h b/Source/WebKit/efl/ewk/ewk_tiled_backing_store_private.h
deleted file mode 100644 (file)
index 15362d0..0000000
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-    Copyright (C) 2009-2010 Samsung Electronics
-    Copyright (C) 2009-2010 ProFUSION embedded systems
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
-*/
-
-#ifndef ewk_tiled_backing_store_private_h
-#define ewk_tiled_backing_store_private_h
-
-#include "EWebKit.h"
-#include <Evas.h>
-
-/* Enable accounting of render time in tile statistics */
-// #define TILE_STATS_ACCOUNT_RENDER_TIME
-
-/* If define ewk will do more accounting to check for memory leaks
- * try "kill -USR1 $PID" to get instantaneous debug
- * try "kill -USR2 $PID" to get instantaneous debug and force flush of cache
- */
-#undef DEBUG_MEM_LEAKS
-
-static const int defaultTileWidth = 256;
-static const int defaultTileHeigth = 256;
-
-static const float zoomStepMinimum = 0.01;
-
-#define TILE_SIZE_AT_ZOOM(SIZE, ZOOM) ((int)roundf((SIZE) * (ZOOM)))
-#define TILE_ZOOM_AT_SIZE(SIZE, ORIG_TILE) ((float)(SIZE) / (float)(ORIG_TILE))
-#define ROUNDED_ZOOM(SIZE, ZOOM) ((float)(SIZE) / (float)(((int)roundf((SIZE) / (ZOOM)))))
-
-typedef struct _Ewk_Tile                     Ewk_Tile;
-typedef struct _Ewk_Tile_Stats               Ewk_Tile_Stats;
-typedef struct _Ewk_Tile_Matrix              Ewk_Tile_Matrix;
-
-struct _Ewk_Tile_Stats {
-    double last_used;        /**< time of last use */
-#ifdef TILE_STATS_ACCOUNT_RENDER_TIME
-    double render_time;      /**< amount of time this tile took to render */
-#endif
-    unsigned int area;       /**< cache for (w * h) */
-    unsigned int misses;     /**< number of times it became dirty but not
-                              * repainted at all since it was not visible.
-                              */
-    bool full_update : 1; /**< tile requires full size update */
-};
-
-struct _Ewk_Tile {
-    Eina_Tiler* updates;    /**< updated/dirty areas */
-    Ewk_Tile_Stats stats;       /**< tile usage statistics */
-    unsigned long column, row; /**< tile tile position */
-    Evas_Coord x, y;        /**< tile coordinate position */
-
-    /** Never ever change those after tile is created (respect const!) */
-    const Evas_Coord width, height;        /**< tile size (see TILE_SIZE_AT_ZOOM()) */
-    const Evas_Colorspace cspace; /**< colorspace */
-    const float zoom;             /**< zoom level contents were rendered at */
-    const size_t bytes;           /**< bytes used in pixels. keep
-                                   * before pixels to guarantee
-                                   * alignement!
-                                   */
-    int visible;                  /**< visibility counter of this tile */
-    Evas_Object* image;           /**< Evas Image, the tile to be rendered */
-};
-
-/* view */
-Evas_Object* ewk_tiled_backing_store_add(Evas* e);
-
-void ewk_tiled_backing_store_render_cb_set(Evas_Object* o, bool (*cb)(void* data, Ewk_Tile* t, const Eina_Rectangle* area), const void* data);
-
-bool ewk_tiled_backing_store_scroll_full_offset_set(Evas_Object* o, Evas_Coord x, Evas_Coord y);
-bool ewk_tiled_backing_store_scroll_full_offset_add(Evas_Object* o, Evas_Coord dx, Evas_Coord dy);
-bool ewk_tiled_backing_store_scroll_inner_offset_add(Evas_Object* o, Evas_Coord dx, Evas_Coord dy, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h);
-
-bool ewk_tiled_backing_store_zoom_set(Evas_Object* o, float* zoom, Evas_Coord cx, Evas_Coord cy, Evas_Coord* offx, Evas_Coord* offy);
-bool ewk_tiled_backing_store_zoom_weak_set(Evas_Object* o, float zoom, Evas_Coord cx, Evas_Coord cy);
-void ewk_tiled_backing_store_fix_offsets(Evas_Object* o, Evas_Coord w, Evas_Coord h);
-void ewk_tiled_backing_store_zoom_weak_smooth_scale_set(Evas_Object* o, bool smooth_scale);
-void ewk_tiled_backing_store_alpha_set(Evas_Object* o, bool has_alpha);
-bool ewk_tiled_backing_store_update(Evas_Object* o, const Eina_Rectangle* update);
-void ewk_tiled_backing_store_updates_process_pre_set(Evas_Object* o, void* (*cb)(void* data, Evas_Object* o), const void* data);
-void ewk_tiled_backing_store_updates_process_post_set(Evas_Object* o, void* (*cb)(void* data, void* pre_data, Evas_Object* o), const void* data);
-void ewk_tiled_backing_store_updates_process(Evas_Object* o);
-void ewk_tiled_backing_store_updates_clear(Evas_Object* o);
-void ewk_tiled_backing_store_contents_resize(Evas_Object* o, Evas_Coord width, Evas_Coord height);
-void ewk_tiled_backing_store_disabled_update_set(Evas_Object* o, bool value);
-void ewk_tiled_backing_store_flush(Evas_Object* o);
-void ewk_tiled_backing_store_enable_scale_set(Evas_Object* o, bool value);
-
-Ewk_Tile_Unused_Cache* ewk_tiled_backing_store_tile_unused_cache_get(const Evas_Object* o);
-void ewk_tiled_backing_store_tile_unused_cache_set(Evas_Object* o, Ewk_Tile_Unused_Cache* tuc);
-
-bool ewk_tiled_backing_store_pre_render_region(Evas_Object* o, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, float zoom);
-bool ewk_tiled_backing_store_pre_render_relative_radius(Evas_Object* o, unsigned int n, float zoom);
-bool ewk_tiled_backing_store_pre_render_spiral_queue(Evas_Object* o, Eina_Rectangle* view_rect, Eina_Rectangle* render_rect, int max_memory, float zoom);
-void ewk_tiled_backing_store_pre_render_cancel(Evas_Object* o);
-
-bool ewk_tiled_backing_store_disable_render(Evas_Object* o);
-bool ewk_tiled_backing_store_enable_render(Evas_Object* o);
-
-#endif // ewk_tiled_backing_store_h
diff --git a/Source/WebKit/efl/ewk/ewk_tiled_matrix.cpp b/Source/WebKit/efl/ewk/ewk_tiled_matrix.cpp
deleted file mode 100644 (file)
index 6fabf78..0000000
+++ /dev/null
@@ -1,697 +0,0 @@
-/*
-    Copyright (C) 2009-2010 Samsung Electronics
-    Copyright (C) 2009-2010 ProFUSION embedded systems
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
-*/
-
-#define __STDC_FORMAT_MACROS
-#include "config.h"
-
-#include "ewk_private.h"
-#include "ewk_tiled_backing_store_private.h"
-#include "ewk_tiled_matrix_private.h"
-#include "ewk_tiled_model_private.h"
-#include <Eina.h>
-#include <errno.h>
-#include <inttypes.h>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
-
-struct Ewk_Tile_Matrix_Entry {
-    EINA_INLIST;
-    float zoom;
-    unsigned long count;
-    Eina_Matrixsparse* matrix;
-};
-
-struct _Ewk_Tile_Matrix {
-    Eina_Matrixsparse* matrix;
-    Eina_Inlist* matrices;
-    Ewk_Tile_Unused_Cache* tileUnusedCache;
-    Evas_Colorspace cspace;
-    struct {
-        void (*callback)(void* data, Ewk_Tile* tile, const Eina_Rectangle* update);
-        void* data;
-    } render;
-    unsigned int frozen;
-    Eina_List* updates;
-    struct {
-        Evas_Coord width, height;
-    } tile;
-#ifdef DEBUG_MEM_LEAKS
-    struct {
-        struct {
-            uint64_t allocated, freed;
-        } tiles, bytes;
-    } stats;
-#endif
-};
-
-// Default 40 MB size of newly created cache
-static const size_t DEFAULT_CACHE_SIZE = 40 * 1024 * 1024;
-
-#ifdef DEBUG_MEM_LEAKS
-static uint64_t tiles_leaked = 0;
-static uint64_t bytes_leaked = 0;
-#endif
-
-static Ewk_Tile_Matrix_Entry* ewk_tile_matrix_entry_get(Ewk_Tile_Matrix* tileMatrix, float zoom)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileMatrix, 0);
-
-    Ewk_Tile_Matrix_Entry* it;
-    EINA_INLIST_FOREACH(tileMatrix->matrices, it) {
-        if (it->zoom == zoom)
-            return it;
-    }
-
-    return 0;
-}
-
-/* called when matrixsparse is resized or freed */
-static void _ewk_tile_matrix_cell_free(void* userData, void* cellData)
-{
-    Ewk_Tile_Matrix* tileMatrix = static_cast<Ewk_Tile_Matrix*>(userData);
-    Ewk_Tile* tile = static_cast<Ewk_Tile*>(cellData);
-
-    if (!tile)
-        return;
-
-    ewk_tile_unused_cache_freeze(tileMatrix->tileUnusedCache);
-
-    if (tile->updates || tile->stats.full_update)
-        tileMatrix->updates = eina_list_remove(tileMatrix->updates, tile);
-
-    if (tile->visible)
-        ERR("freeing cell that is visible, leaking tile %p", tile);
-    else {
-        if (ewk_tile_unused_cache_tile_get(tileMatrix->tileUnusedCache, tile)) {
-            DBG("tile cell does not exist anymore, free it %p", tile);
-#ifdef DEBUG_MEM_LEAKS
-            tileMatrix->stats.bytes.freed += tile->bytes;
-            tileMatrix->stats.tiles.freed++;
-#endif
-            Ewk_Tile_Matrix_Entry* entry = ewk_tile_matrix_entry_get(tileMatrix, tile->zoom);
-            if (!entry)
-                ERR("can't find matrix for zoom %0.3f", tile->zoom);
-            else
-                --entry->count;
-
-            ewk_tile_free(tile);
-        } else
-            ERR("tile %p was not in cache %p? leaking...", tile, tileMatrix->tileUnusedCache);
-    }
-
-    ewk_tile_unused_cache_thaw(tileMatrix->tileUnusedCache);
-}
-
-/* called when cache of unused tile is flushed */
-static void _ewk_tile_matrix_tile_free(void* data, Ewk_Tile* tile)
-{
-    Ewk_Tile_Matrix* tileMatrix = static_cast<Ewk_Tile_Matrix*>(data);
-
-    Ewk_Tile_Matrix_Entry* entry = ewk_tile_matrix_entry_get(tileMatrix, tile->zoom);
-    if (!entry) {
-        ERR("removing tile %p that was not in any matrix? Leaking...", tile);
-        return;
-    }
-
-    Eina_Matrixsparse_Cell* cell;
-    if (!eina_matrixsparse_cell_idx_get(entry->matrix, tile->row, tile->column, &cell)) {
-        ERR("removing tile %p that was not in the matrix? Leaking...", tile);
-        return;
-    }
-
-    if (!cell) {
-        ERR("removing tile %p that was not in the matrix? Leaking...", tile);
-        return;
-    }
-
-    if (tile->updates || tile->stats.full_update)
-        tileMatrix->updates = eina_list_remove(tileMatrix->updates, tile);
-
-    /* set to null to avoid double free */
-    eina_matrixsparse_cell_data_replace(cell, 0, 0);
-    eina_matrixsparse_cell_clear(cell);
-
-    if (EINA_UNLIKELY(!!tile->visible)) {
-        ERR("cache of unused tiles requesting deletion of used tile %p? "
-            "Leaking...", tile);
-        return;
-    }
-
-#ifdef DEBUG_MEM_LEAKS
-    tileMatrix->stats.bytes.freed += tile->bytes;
-    tileMatrix->stats.tiles.freed++;
-#endif
-
-    --entry->count;
-    if (!entry->count && entry->matrix != tileMatrix->matrix) {
-        eina_matrixsparse_free(entry->matrix);
-        tileMatrix->matrices = eina_inlist_remove(tileMatrix->matrices, EINA_INLIST_GET(entry));
-        delete entry;
-    }
-
-    ewk_tile_free(tile);
-}
-
-/**
- * Creates a new matrix of tiles.
- *
- * The tile matrix is responsible for keeping tiles around and
- * providing fast access to them. One can use it to retrieve new or
- * existing tiles and give them back, allowing them to be
- * freed/replaced by the cache.
- *
- * @param tileUnusedCache cache of unused tiles or @c 0 to create one
- *        automatically.
- * @param columns number of columns in the matrix.
- * @param rows number of rows in the matrix.
- * @param zoomLevel zoom level for the matrix.
- * @param cspace the color space used to create tiles in this matrix.
- * @param render_cb function used to render given tile update.
- * @param render_data context to give back to @a render_cb.
- *
- * @return newly allocated instance on success, @c 0 on failure.
- */
-Ewk_Tile_Matrix* ewk_tile_matrix_new(Ewk_Tile_Unused_Cache* tileUnusedCache, unsigned long columns, unsigned long rows, float zoomLevel, Evas_Colorspace colorSpace, void (*renderCallback)(void* data, Ewk_Tile* tile, const Eina_Rectangle* update), const void* renderData)
-{
-    OwnPtr<Ewk_Tile_Matrix> tileMatrix = adoptPtr(new Ewk_Tile_Matrix);
-
-    tileMatrix->matrices = 0;
-    if (!ewk_tile_matrix_zoom_level_set(tileMatrix.get(), zoomLevel))
-        ewk_tile_matrix_entry_new(tileMatrix.get(), zoomLevel);
-    ewk_tile_matrix_resize(tileMatrix.get(), columns, rows);
-
-    if (tileUnusedCache)
-        tileMatrix->tileUnusedCache = ewk_tile_unused_cache_ref(tileUnusedCache);
-    else {
-        tileMatrix->tileUnusedCache = ewk_tile_unused_cache_new(DEFAULT_CACHE_SIZE);
-        if (!tileMatrix->tileUnusedCache) {
-            ERR("no cache of unused tile!");
-            eina_matrixsparse_free(tileMatrix->matrix);
-            return 0;
-        }
-    }
-
-    tileMatrix->cspace = colorSpace;
-    tileMatrix->render.callback = renderCallback;
-    tileMatrix->render.data = (void*)renderData;
-    tileMatrix->tile.width = defaultTileWidth;
-    tileMatrix->tile.height = defaultTileHeigth;
-    tileMatrix->frozen = 0;
-    tileMatrix->updates = 0;
-
-#ifdef DEBUG_MEM_LEAKS
-    tileMatrix->stats.tiles.allocated = 0;
-    tileMatrix->stats.tiles.freed = 0;
-    tileMatrix->stats.bytes.allocated = 0;
-    tileMatrix->stats.bytes.freed = 0;
-#endif
-    return tileMatrix.leakPtr();
-}
-
-/**
- * Find the matrix with the same zoom and set it as current matrix.
- *
- * @param tileMatrix tile matrix to search the matrix in.
- * @param zoom zoom factor to find the same matrix with it in matrices.
- *
- * @return @c true if found, @c false otherwise.
- */
-bool ewk_tile_matrix_zoom_level_set(Ewk_Tile_Matrix* tileMatrix, float zoom)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileMatrix, false);
-
-    Ewk_Tile_Matrix_Entry* it;
-    EINA_INLIST_FOREACH(tileMatrix->matrices, it) {
-        if (it->zoom == zoom) {
-            tileMatrix->matrices = eina_inlist_promote(tileMatrix->matrices, EINA_INLIST_GET(it));
-            tileMatrix->matrix = it->matrix;
-
-            return true;
-        }
-    }
-    return false;
-}
-
-void ewk_tile_matrix_entry_new(Ewk_Tile_Matrix* tileMatrix, float zoom)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    OwnPtr<Ewk_Tile_Matrix_Entry> entry = adoptPtr(new Ewk_Tile_Matrix_Entry);
-    entry->zoom = zoom;
-    entry->count = 0;
-    entry->matrix = eina_matrixsparse_new(1, 1, _ewk_tile_matrix_cell_free, tileMatrix);
-    if (!entry->matrix) {
-        ERR("could not create sparse matrix.");
-        return;
-    }
-    tileMatrix->matrix = entry->matrix;
-    tileMatrix->matrices = eina_inlist_prepend(tileMatrix->matrices, EINA_INLIST_GET(entry.leakPtr()));
-}
-
-void ewk_tile_matrix_invalidate(Ewk_Tile_Matrix* tileMatrix)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    Eina_Inlist* matrixList = tileMatrix->matrices;
-    while (matrixList) {
-        Ewk_Tile_Matrix_Entry* it = EINA_INLIST_CONTAINER_GET(matrixList, Ewk_Tile_Matrix_Entry);
-        Eina_Inlist* next = matrixList->next;
-
-        if (it->matrix != tileMatrix->matrix) {
-            eina_matrixsparse_free(it->matrix);
-            tileMatrix->matrices = eina_inlist_remove(tileMatrix->matrices, matrixList);
-            delete it;
-        }
-
-        matrixList = next;
-    }
-}
-
-/**
- * Destroys tiles matrix, releasing its resources.
- *
- * The cache instance is unreferenced, possibly freeing it.
- */
-void ewk_tile_matrix_free(Ewk_Tile_Matrix* tileMatrix)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    ewk_tile_unused_cache_freeze(tileMatrix->tileUnusedCache);
-    ewk_tile_matrix_invalidate(tileMatrix);
-    Ewk_Tile_Matrix_Entry* entry = EINA_INLIST_CONTAINER_GET(tileMatrix->matrices, Ewk_Tile_Matrix_Entry);
-    eina_matrixsparse_free(entry->matrix);
-    tileMatrix->matrices = eina_inlist_remove(tileMatrix->matrices, reinterpret_cast<Eina_Inlist*>(entry));
-    tileMatrix->matrices = 0;
-    delete entry;
-
-    ewk_tile_unused_cache_thaw(tileMatrix->tileUnusedCache);
-    ewk_tile_unused_cache_unref(tileMatrix->tileUnusedCache);
-
-#ifdef DEBUG_MEM_LEAKS
-    uint64_t tiles = tileMatrix->stats.tiles.allocated - tileMatrix->stats.tiles.freed;
-    uint64_t bytes = tileMatrix->stats.bytes.allocated - tileMatrix->stats.bytes.freed;
-
-    tiles_leaked += tiles;
-    bytes_leaked += bytes;
-
-    if (tiles || bytes)
-        ERR("tiled matrix leaked: tiles[+%" PRIu64 ",-%" PRIu64 ":%" PRIu64 "] "
-            "bytes[+%" PRIu64 ",-%" PRIu64 ":%" PRIu64 "]",
-            tileMatrix->stats.tiles.allocated, tileMatrix->stats.tiles.freed, tiles,
-            tileMatrix->stats.bytes.allocated, tileMatrix->stats.bytes.freed, bytes);
-    else if (tiles_leaked || bytes_leaked)
-        WARN("tiled matrix had no leaks: tiles[+%" PRIu64 ",-%" PRIu64 "] "
-            "bytes[+%" PRIu64 ",-%" PRIu64 "], but some other leaked "
-            "%" PRIu64 " tiles (%" PRIu64 " bytes)",
-            tileMatrix->stats.tiles.allocated, tileMatrix->stats.tiles.freed,
-            tileMatrix->stats.bytes.allocated, tileMatrix->stats.bytes.freed,
-            tiles_leaked, bytes_leaked);
-    else
-        INFO("tiled matrix had no leaks: tiles[+%" PRIu64 ",-%" PRIu64 "] "
-            "bytes[+%" PRIu64 ",-%" PRIu64 "]",
-            tileMatrix->stats.tiles.allocated, tileMatrix->stats.tiles.freed,
-            tileMatrix->stats.bytes.allocated, tileMatrix->stats.bytes.freed);
-#endif
-
-    delete tileMatrix;
-}
-
-/**
- * Resize matrix to given number of rows and columns.
- */
-void ewk_tile_matrix_resize(Ewk_Tile_Matrix* tileMatrix, unsigned long cols, unsigned long rows)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    eina_matrixsparse_size_set(tileMatrix->matrix, rows, cols);
-}
-
-void ewk_tile_matrix_size_get(Ewk_Tile_Matrix* tileMatrix, unsigned long* columns, unsigned long* rows)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    eina_matrixsparse_size_get(tileMatrix->matrix, rows, columns);
-}
-
-/**
- * Get the cache of unused tiles in use by given matrix.
- *
- * No reference is taken to the cache.
- */
-Ewk_Tile_Unused_Cache* ewk_tile_matrix_unused_cache_get(const Ewk_Tile_Matrix* tileMatrix)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileMatrix, 0);
-
-    return tileMatrix->tileUnusedCache;
-}
-
-/**
- * Get the exact tile for the given position and zoom.
- *
- * If the tile.widthas unused then it's removed from the cache.
- *
- * After usage, please give it back using
- * ewk_tile_matrix_tile_put(). If you just want to check if it exists,
- * then use ewk_tile_matrix_tile_exact_exists().
- *
- * @param tileMatrix the tile matrix to get tile from.
- * @param column the column number.
- * @param row the row number.
- * @param zoom the exact zoom to use.
- *
- * @return The tile instance or @c 0 if none is found. If the tile
- *         was in the unused cache it will be @b removed (thus
- *         considered used) and one should give it back with
- *         ewk_tile_matrix_tile_put() afterwards.
- *
- * @see ewk_tile_matrix_tile_exact_get()
- */
-Ewk_Tile* ewk_tile_matrix_tile_exact_get(Ewk_Tile_Matrix* tileMatrix, unsigned long column, unsigned long row, float zoom)
-{
-    Ewk_Tile* tile = static_cast<Ewk_Tile*>(eina_matrixsparse_data_idx_get(tileMatrix->matrix, row, column));
-    if (!tile)
-        return 0;
-
-    if (tile->zoom != zoom)
-        return 0;
-
-#ifndef NDEBUG
-    if (!tile->visible) {
-        if (!ewk_tile_unused_cache_tile_get(tileMatrix->tileUnusedCache, tile))
-            WARN("Ewk_Tile was unused but not in cache? bug!");
-    }
-#endif
-
-    return tile;
-}
-
-/**
- * Checks if tile of given zoom exists in matrix.
- *
- * @param tileMatrix the tile matrix to check tile existence.
- * @param column the column number.
- * @param row the row number.
- * @param zoom the exact zoom to query.
- *
- * @return @c true if found, @c false otherwise.
- *
- * @see ewk_tile_matrix_tile_exact_get()
- */
-bool ewk_tile_matrix_tile_exact_exists(Ewk_Tile_Matrix* tileMatrix, unsigned long column, unsigned long row, float zoom)
-{
-    return ewk_tile_matrix_tile_exact_get(tileMatrix, column, row, zoom);
-}
-
-/**
- * Create a new tile at given position and zoom level in the matrix.
- *
- * The newly created tile is considered in use and not put into cache
- * of unused tiles. After it is used one should call
- * ewk_tile_matrix_tile_put() to give it back to matrix.
- *
- * @param tileMatrix the tile matrix to create tile on.
- * @param column the column number.
- * @param row the row number.
- * @param zoom the level to create tile, used to determine tile size.
- */
-Ewk_Tile* ewk_tile_matrix_tile_new(Ewk_Tile_Matrix* tileMatrix, Evas* canvas, unsigned long column, unsigned long row, float zoom)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileMatrix, 0);
-    EINA_SAFETY_ON_FALSE_RETURN_VAL(zoom > 0.0, 0);
-
-    Ewk_Tile_Matrix_Entry* entry = ewk_tile_matrix_entry_get(tileMatrix, zoom);
-    if (!entry) {
-        ERR("could not get matrix at zoom %f for tile", zoom);
-        return 0;
-    }
-    ++entry->count;
-
-    Evas_Coord tileWidth = tileMatrix->tile.width;
-    Evas_Coord tileHeight = tileMatrix->tile.height;
-
-    Ewk_Tile* tile = ewk_tile_new(canvas, tileWidth, tileHeight, zoom, tileMatrix->cspace);
-    if (!tile) {
-        ERR("could not create tile %dx%d at %f, cspace=%d", tileWidth, tileHeight, (double)zoom, tileMatrix->cspace);
-        return 0;
-    }
-
-    if (!eina_matrixsparse_data_idx_set(tileMatrix->matrix, row, column, tile)) {
-        ERR("could not set matrix cell, row/col outside matrix dimensions!");
-        ewk_tile_free(tile);
-        return 0;
-    }
-
-    tile->column = column;
-    tile->row = row;
-    tile->x = column * tileWidth;
-    tile->y = row * tileHeight;
-    tile->stats.full_update = true;
-    tileMatrix->updates = eina_list_append(tileMatrix->updates, tile);
-
-#ifdef DEBUG_MEM_LEAKS
-    tileMatrix->stats.bytes.allocated += tile->bytes;
-    tileMatrix->stats.tiles.allocated++;
-#endif
-
-    return tile;
-}
-
-/**
- * Gives back the tile to the tile matrix.
- *
- * This will report the tile is no longer in use by the one that got
- * it with ewk_tile_matrix_tile_exact_get().
- *
- * Any previous reference to tile should be released
- * (ewk_tile.heightide()) before calling this function, so it will
- * be known if it is not visibile anymore and thus can be put into the
- * unused cache.
- *
- * @param tileMatrix the tile matrix to return tile to.
- * @param tile the tile instance to return, must @b not be @c 0.
- * @param last_used time in which tile.widthas last used.
- *
- * @return #true on success or #false on failure.
- */
-bool ewk_tile_matrix_tile_put(Ewk_Tile_Matrix* tileMatrix, Ewk_Tile* tile, double lastUsed)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileMatrix, false);
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tile, false);
-
-    if (tile->visible)
-        return true;
-
-    tile->stats.last_used = lastUsed;
-    return ewk_tile_unused_cache_tile_put(tileMatrix->tileUnusedCache, tile, _ewk_tile_matrix_tile_free, tileMatrix);
-}
-
-void ewk_tile_matrix_tile_updates_clear(Ewk_Tile_Matrix* tileMatrix, Ewk_Tile* tile)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    if (!tile->updates && !tile->stats.full_update)
-        return;
-
-    ewk_tile_updates_clear(tile);
-    tileMatrix->updates = eina_list_remove(tileMatrix->updates, tile);
-}
-
-static bool _ewk_tile_matrix_slicer_setup(Ewk_Tile_Matrix* tileMatrix, const Eina_Rectangle* area, float zoom, Eina_Tile_Grid_Slicer* slicer)
-{
-    UNUSED_PARAM(zoom);
-    if (area->w <= 0 || area->h <= 0) {
-        WARN("invalid area region: %d,%d+%dx%d.", area->x, area->y, area->w, area->h);
-        return false;
-    }
-
-    Evas_Coord x = area->x;
-    Evas_Coord y = area->y;
-    Evas_Coord width = area->w;
-    Evas_Coord height = area->h;
-
-    Evas_Coord tileWidth = tileMatrix->tile.width;
-    Evas_Coord tileHeight = tileMatrix->tile.height;
-
-    // cropping area region to fit matrix
-    unsigned long rows, cols;
-    eina_matrixsparse_size_get(tileMatrix->matrix, &rows, &cols);
-    if (x < 0) {
-        width += x;
-        x = 0;
-    }
-    if (y < 0) {
-        height += y;
-        y = 0;
-    }
-
-    if (y + height - 1 > static_cast<long>(rows * tileHeight))
-        height = rows * tileHeight - y;
-    if (x + width - 1 > static_cast<long>(cols * tileWidth))
-        width = cols * tileWidth - x;
-
-    return eina_tile_grid_slicer_setup(slicer, x, y, width, height, tileWidth, tileHeight);
-}
-
-
-bool ewk_tile_matrix_update(Ewk_Tile_Matrix* tileMatrix, const Eina_Rectangle* update, float zoom)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileMatrix, false);
-    EINA_SAFETY_ON_NULL_RETURN_VAL(update, false);
-
-    if (update->w < 1 || update->h < 1) {
-        DBG("Why we get updates with empty areas? %d,%d+%dx%d at zoom %f", update->x, update->y, update->w, update->h, zoom);
-        return true;
-    }
-
-    Eina_Tile_Grid_Slicer slicer;
-    if (!_ewk_tile_matrix_slicer_setup(tileMatrix, update, zoom, &slicer)) {
-        ERR("Could not setup slicer for update %d,%d+%dx%d at zoom %f", update->x, update->y, update->w, update->h, zoom);
-        return false;
-    }
-
-    const Eina_Tile_Grid_Info* info;
-    while (eina_tile_grid_slicer_next(&slicer, &info)) {
-        Ewk_Tile* tile = static_cast<Ewk_Tile*>(eina_matrixsparse_data_idx_get(tileMatrix->matrix, info->row, info->col));
-        if (!tile)
-            continue;
-
-        if (!tile->updates && !tile->stats.full_update)
-            tileMatrix->updates = eina_list_append(tileMatrix->updates, tile);
-        if (info->full)
-            ewk_tile_update_full(tile);
-        else
-            ewk_tile_update_area(tile, &info->rect);
-    }
-
-
-    return true;
-}
-
-void ewk_tile_matrix_updates_process(Ewk_Tile_Matrix* tileMatrix)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    // process updates, unflag tiles
-    Eina_List* list, *listNext;
-    void* item;
-    EINA_LIST_FOREACH_SAFE(tileMatrix->updates, list, listNext, item) {
-        Ewk_Tile* tile = static_cast<Ewk_Tile*>(item);
-        ewk_tile_updates_process(tile, tileMatrix->render.callback, tileMatrix->render.data);
-        if (tile->visible) {
-            ewk_tile_updates_clear(tile);
-            tileMatrix->updates = eina_list_remove_list(tileMatrix->updates, list);
-        }
-    }
-}
-
-void ewk_tile_matrix_updates_clear(Ewk_Tile_Matrix* tileMatrix)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    void* item;
-    EINA_LIST_FREE(tileMatrix->updates, item)
-        ewk_tile_updates_clear(static_cast<Ewk_Tile*>(item));
-    tileMatrix->updates = 0;
-}
-
-#ifdef DEBUG_MEM_LEAKS
-// remove me later!
-void ewk_tile_matrix_dbg(const Ewk_Tile_Matrix* tileMatrix)
-{
-    Eina_Iterator* it = eina_matrixsparse_iterator_complete_new(tileMatrix->matrix);
-    Eina_Matrixsparse_Cell* cell;
-    bool wasPreviousEmpty = false;
-
-    printf("Ewk_Tile Matrix: tiles[+%" PRIu64 ",-%" PRIu64 ":%" PRIu64 "] "
-           "bytes[+%" PRIu64 ",-%" PRIu64 ":%" PRIu64 "]\n",
-           tileMatrix->stats.tiles.allocated, tileMatrix->stats.tiles.freed,
-           tileMatrix->stats.tiles.allocated - tileMatrix->stats.tiles.freed,
-           tileMatrix->stats.bytes.allocated, tileMatrix->stats.bytes.freed,
-           tileMatrix->stats.bytes.allocated - tileMatrix->stats.bytes.freed);
-
-    EINA_ITERATOR_FOREACH(it, cell) {
-        unsigned long row, column;
-        eina_matrixsparse_cell_position_get(cell, &row, &column);
-
-        Ewk_Tile* tile = static_cast<Ewk_Tile*>(eina_matrixsparse_cell_data_get(cell));
-        if (!tile) {
-            if (!wasPreviousEmpty) {
-                wasPreviousEmpty = true;
-                printf("Empty:");
-            }
-            printf(" [%lu,%lu]", column, row);
-        } else {
-            if (wasPreviousEmpty) {
-                wasPreviousEmpty = false;
-                printf("\n");
-            }
-            printf("%3lu,%3lu %10p:", column, row, tile);
-            printf(" [%3lu,%3lu + %dx%d @ %0.3f]%c", tile->column, tile->row, tile->width, tile->height, tile->zoom, tile->visible ? '*' : ' ');
-            printf("\n");
-        }
-    }
-    if (wasPreviousEmpty)
-        printf("\n");
-    eina_iterator_free(it);
-
-    ewk_tile_unused_cache_dbg(tileMatrix->tileUnusedCache);
-}
-#endif
-
-/**
- * Freeze matrix to not do maintenance tasks.
- *
- * Maintenance tasks optimize usage, but maybe we know we should hold
- * on them until we do the last operation, in this case we freeze
- * while operating and then thaw when we're done.
- *
- * @see ewk_tile_matrix_thaw()
- */
-void ewk_tile_matrix_freeze(Ewk_Tile_Matrix* tileMatrix)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    if (!tileMatrix->frozen)
-        ewk_tile_unused_cache_freeze(tileMatrix->tileUnusedCache);
-    ++tileMatrix->frozen;
-}
-
-/**
- * Unfreezes maintenance tasks.
- *
- * If this is the last counterpart of freeze, then maintenance tasks
- * will run immediately.
- */
-void ewk_tile_matrix_thaw(Ewk_Tile_Matrix* tileMatrix)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileMatrix);
-
-    if (!tileMatrix->frozen) {
-        ERR("thawing more than freezing!");
-        return;
-    }
-
-    --tileMatrix->frozen;
-    if (!tileMatrix->frozen)
-        ewk_tile_unused_cache_thaw(tileMatrix->tileUnusedCache);
-}
diff --git a/Source/WebKit/efl/ewk/ewk_tiled_matrix_private.h b/Source/WebKit/efl/ewk/ewk_tiled_matrix_private.h
deleted file mode 100644 (file)
index 99a95d4..0000000
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-    Copyright (C) 2009-2010 Samsung Electronics
-    Copyright (C) 2009-2010 ProFUSION embedded systems
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
-*/
-
-#ifndef ewk_tiled_matrix_private_h
-#define ewk_tiled_matrix_private_h
-
-#include "ewk_tiled_backing_store_private.h"
-#include "ewk_tiled_matrix_private.h"
-
-#include <Evas.h>
-
-/* matrix of tiles */
-Ewk_Tile_Matrix* ewk_tile_matrix_new(Ewk_Tile_Unused_Cache* tuc, unsigned long cols, unsigned long rows, float zoom_level, Evas_Colorspace color_space, void (*render_callback)(void* data, Ewk_Tile* t, const Eina_Rectangle* update), const void* render_data);
-void ewk_tile_matrix_entry_new(Ewk_Tile_Matrix* tm, float zoom);
-void ewk_tile_matrix_free(Ewk_Tile_Matrix* tm);
-
-void ewk_tile_matrix_resize(Ewk_Tile_Matrix* tm, unsigned long cols, unsigned long rows);
-void ewk_tile_matrix_size_get(Ewk_Tile_Matrix* tm, unsigned long* cols, unsigned long* rows);
-bool ewk_tile_matrix_zoom_level_set(Ewk_Tile_Matrix* tm, float zoom);
-void ewk_tile_matrix_invalidate(Ewk_Tile_Matrix* tm);
-
-Ewk_Tile_Unused_Cache* ewk_tile_matrix_unused_cache_get(const Ewk_Tile_Matrix* tm);
-
-Ewk_Tile* ewk_tile_matrix_tile_exact_get(Ewk_Tile_Matrix* tm, unsigned long col, unsigned long row, float zoom);
-bool ewk_tile_matrix_tile_exact_exists(Ewk_Tile_Matrix* tm, unsigned long col, unsigned long row, float zoom);
-Ewk_Tile* ewk_tile_matrix_tile_nearest_get(Ewk_Tile_Matrix* tm, unsigned long col, unsigned long row, float zoom);
-Ewk_Tile* ewk_tile_matrix_tile_new(Ewk_Tile_Matrix* tm, Evas* evas, unsigned long col, unsigned long row, float zoom);
-bool ewk_tile_matrix_tile_put(Ewk_Tile_Matrix* tm, Ewk_Tile* t, double last_used);
-
-void ewk_tile_matrix_tile_updates_clear(Ewk_Tile_Matrix* tm, Ewk_Tile* t);
-
-bool ewk_tile_matrix_update(Ewk_Tile_Matrix* tm, const Eina_Rectangle* update, float zoom);
-void ewk_tile_matrix_updates_process(Ewk_Tile_Matrix* tm);
-void ewk_tile_matrix_updates_clear(Ewk_Tile_Matrix* tm);
-void ewk_tile_matrix_freeze(Ewk_Tile_Matrix* tm);
-void ewk_tile_matrix_thaw(Ewk_Tile_Matrix* tm);
-
-// remove me!
-void ewk_tile_matrix_dbg(const Ewk_Tile_Matrix* tm);
-void ewk_tile_unused_cache_dbg(const Ewk_Tile_Unused_Cache* tuc);
-void ewk_tile_accounting_dbg();
-
-#endif // ewk_tiled_matrix_private_h
diff --git a/Source/WebKit/efl/ewk/ewk_tiled_model.cpp b/Source/WebKit/efl/ewk/ewk_tiled_model.cpp
deleted file mode 100644 (file)
index 7fdf63f..0000000
+++ /dev/null
@@ -1,759 +0,0 @@
-/*
-    Copyright (C) 2009-2010 Samsung Electronics
-    Copyright (C) 2009-2010 ProFUSION embedded systems
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
-*/
-
-#define __STDC_FORMAT_MACROS
-#include "config.h"
-
-#include "ewk_private.h"
-#include "ewk_tiled_backing_store_private.h"
-#include "ewk_tiled_model_private.h"
-#include <Ecore_Evas.h>
-#include <Eina.h>
-#include <eina_safety_checks.h>
-#include <errno.h>
-#include <inttypes.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef TILE_STATS_ACCOUNT_RENDER_TIME
-#include <sys/time.h>
-#endif
-
-#define IDX(col, row, rowspan) (col + (rowidth * rowspan))
-
-#ifdef DEBUG_MEM_LEAKS
-static uint64_t tiles_allocated = 0;
-static uint64_t tiles_freed = 0;
-static uint64_t bytes_allocated = 0;
-static uint64_t bytes_freed = 0;
-
-struct tile_account {
-    Evas_Coord size;
-    struct {
-        uint64_t allocated;
-        uint64_t freed;
-    } tiles, bytes;
-};
-
-static size_t accounting_len = 0;
-static struct tile_account* accounting = 0;
-
-static inline struct tile_account* _ewk_tile_account_get(const Ewk_Tile* tile)
-{
-    struct tile_account* acc;
-
-    for (size_t i = 0; i < accounting_len; i++) {
-        if (accounting[i].size == tile->width)
-            return accounting + i;
-    }
-
-    accounting = static_cast<struct tile_account*>(realloc(accounting, sizeof(struct tile_account) * (accounting_len + 1)));
-
-    acc = accounting + accounting_len;
-    acc->size = tile->width;
-    acc->tiles.allocated = 0;
-    acc->tiles.freed = 0;
-    acc->bytes.allocated = 0;
-    acc->bytes.freed = 0;
-
-    accounting_len++;
-
-    return acc;
-}
-
-static inline void _ewk_tile_account_allocated(const Ewk_Tile* tile)
-{
-    struct tile_account* acc = _ewk_tile_account_get(tile);
-    if (!acc)
-        return;
-    acc->bytes.allocated += tile->bytes;
-    acc->tiles.allocated++;
-
-    bytes_allocated += tile->bytes;
-    tiles_allocated++;
-}
-
-static inline void _ewk_tile_account_freed(const Ewk_Tile* tile)
-{
-    struct tile_account* acc = _ewk_tile_account_get(tile);
-    if (!acc)
-        return;
-
-    acc->bytes.freed += tile->bytes;
-    acc->tiles.freed++;
-
-    bytes_freed += tile->bytes;
-    tiles_freed++;
-}
-
-void ewk_tile_accounting_dbg()
-{
-    struct tile_account* acc;
-    struct tile_account* acc_end;
-
-    printf("TILE BALANCE: tiles[+%" PRIu64 ",-%" PRIu64 ":%" PRIu64 "] "
-           "bytes[+%" PRIu64 ",-%" PRIu64 ":%" PRIu64 "]\n",
-           tiles_allocated, tiles_freed, tiles_allocated - tiles_freed,
-           bytes_allocated, bytes_freed, bytes_allocated - bytes_freed);
-
-    if (!accounting_len)
-        return;
-
-    acc = accounting;
-    acc_end = acc + accounting_len;
-    printf("BEGIN: TILE BALANCE DETAILS (TO THIS MOMENT!):\n");
-    for (; acc < acc_end; acc++) {
-        uint64_t tiles, bytes;
-
-        tiles = acc->tiles.allocated - acc->tiles.freed;
-        bytes = acc->bytes.allocated - acc->bytes.freed;
-
-        printf("   %4d: tiles[+%4" PRIu64 ",-%4" PRIu64 ":%4" PRIu64 "] "
-               "bytes[+%8" PRIu64 ",-%8" PRIu64 ":%8" PRIu64 "]%s\n",
-               acc->size,
-               acc->tiles.allocated, acc->tiles.freed, tiles,
-               acc->bytes.allocated, acc->bytes.freed, bytes,
-               (bytes || tiles) ? " POSSIBLE LEAK" : "");
-    }
-    printf("END: TILE BALANCE DETAILS (TO THIS MOMENT!):\n");
-}
-#else
-
-static inline void _ewk_tile_account_allocated(const Ewk_Tile*) { }
-static inline void _ewk_tile_account_freed(const Ewk_Tile*) { }
-
-void ewk_tile_accounting_dbg()
-{
-    printf("compile webkit with DEBUG_MEM_LEAKS defined!\n");
-}
-#endif
-
-/**
- * Create a new tile of given size, zoom level and colorspace.
- *
- * After created these properties are immutable as they're the basic
- * characteristic of the tile and any change will lead to invalid
- * memory access.
- *
- * Other members are of free-access and no getters/setters are
- * provided in orderr to avoid expensive operations on those, however
- * some are better manipulated with provided functions, such as
- * ewk_tile_show() and ewk_tile_hide() to change
- * @c visible or ewk_tile_update_full(), ewk_tile_update_area(),
- * ewk_tile_updates_clear() to change @c stats.misses,
- * @c stats.full_update and @c updates.
- */
-Ewk_Tile* ewk_tile_new(Evas* evas, Evas_Coord width, Evas_Coord height, float zoom, Evas_Colorspace colorSpace)
-{
-    Evas_Coord* evasCoord;
-    Evas_Colorspace* evasColorSpace;
-    float* tileZoom;
-    size_t* tileSize;
-    Ewk_Tile* tile;
-    unsigned int area;
-    size_t bytes;
-    Ecore_Evas* ecoreEvas;
-    const char* engine;
-
-    area = width * height;
-
-    if (colorSpace == EVAS_COLORSPACE_ARGB8888)
-        bytes = area * 4;
-    else if (colorSpace == EVAS_COLORSPACE_RGB565_A5P)
-        bytes = area * 2;
-    else {
-        ERR("unknown color space: %d", colorSpace);
-        return 0;
-    }
-
-    DBG("size: %dx%d (%d), zoom: %f, cspace=%d", width, height, area, (double)zoom, colorSpace);
-
-    tile = static_cast<Ewk_Tile*>(malloc(sizeof(Ewk_Tile)));
-    if (!tile)
-        return 0;
-
-    tile->image = evas_object_image_add(evas);
-
-    ecoreEvas = ecore_evas_ecore_evas_get(evas);
-    engine = ecore_evas_engine_name_get(ecoreEvas);
-    if (engine && !strcmp(engine, "opengl_x11"))
-        evas_object_image_content_hint_set(tile->image, EVAS_IMAGE_CONTENT_HINT_DYNAMIC);
-
-    tile->visible = 0;
-    tile->updates = 0;
-
-    memset(&tile->stats, 0, sizeof(Ewk_Tile_Stats));
-    tile->stats.area = area;
-
-    /* ugly, but let's avoid at all costs having users to modify those */
-    evasCoord = (Evas_Coord*)&tile->width;
-    *evasCoord = width;
-
-    evasCoord = (Evas_Coord*)&tile->height;
-    *evasCoord = height;
-
-    evasColorSpace = (Evas_Colorspace*)&tile->cspace;
-    *evasColorSpace = colorSpace;
-
-    tileZoom = (float*)&tile->zoom;
-    *tileZoom = zoom;
-
-    tileSize = (size_t*)&tile->bytes;
-    *tileSize = bytes;
-
-    evas_object_image_size_set(tile->image, tile->width, tile->height);
-    evas_object_image_colorspace_set(tile->image, tile->cspace);
-    _ewk_tile_account_allocated(tile);
-
-    return tile;
-}
-
-/**
- * Free tile memory.
- */
-void ewk_tile_free(Ewk_Tile* tile)
-{
-    _ewk_tile_account_freed(tile);
-
-    if (tile->updates)
-        eina_tiler_free(tile->updates);
-
-    evas_object_del(tile->image);
-    free(tile);
-}
-
-/**
- * @internal
- * Returns memory size used by given tile
- *
- * @param t tile to size check
- * @return Returns used memory or zero if object is NULL.
- */
-size_t ewk_tile_memory_size_get(const Ewk_Tile* tile)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tile, 0);
-    return sizeof(Ewk_Tile) + tile->bytes;
-}
-
-/**
- * Make the tile visible, incrementing its counter.
- */
-void ewk_tile_show(Ewk_Tile* tile)
-{
-    tile->visible++;
-    evas_object_show(tile->image);
-}
-
-/**
- * Decrement the visibility counter, making it invisible if necessary.
- */
-void ewk_tile_hide(Ewk_Tile* tile)
-{
-    tile->visible--;
-    if (!tile->visible)
-        evas_object_hide(tile->image);
-}
-
-/**
- * Returns true if the tile is visible, false otherwise.
- */
-Eina_Bool ewk_tile_visible_get(Ewk_Tile* tile)
-{
-    return !!tile->visible;
-}
-
-/**
- * Mark whole tile as dirty and requiring update.
- */
-void ewk_tile_update_full(Ewk_Tile* tile)
-{
-    /* TODO: list of tiles pending updates? */
-    tile->stats.misses++;
-
-    if (!tile->stats.full_update) {
-        tile->stats.full_update = true;
-        if (tile->updates) {
-            eina_tiler_free(tile->updates);
-            tile->updates = 0;
-        }
-    }
-}
-
-/**
- * Mark the specific subarea as dirty and requiring update.
- */
-void ewk_tile_update_area(Ewk_Tile* tile, const Eina_Rectangle* rect)
-{
-    /* TODO: list of tiles pending updates? */
-    tile->stats.misses++;
-
-    if (tile->stats.full_update)
-        return;
-
-    if (!rect->x && !rect->y && rect->w == tile->width && rect->h == tile->height) {
-        tile->stats.full_update = true;
-        if (tile->updates) {
-            eina_tiler_free(tile->updates);
-            tile->updates = 0;
-        }
-        return;
-    }
-
-    if (!tile->updates) {
-        tile->updates = eina_tiler_new(tile->width, tile->height);
-        if (!tile->updates) {
-            CRITICAL("could not create eina_tiler %dx%d.", tile->width, tile->height);
-            return;
-        }
-    }
-
-    eina_tiler_rect_add(tile->updates, rect);
-}
-
-/**
- * For each updated region, call the given function.
- *
- * This will not change the tile statistics or clear the processed
- * updates, use ewk_tile_updates_clear() for that.
- */
-void ewk_tile_updates_process(Ewk_Tile* tile, void (*callback)(void* data, Ewk_Tile* tile, const Eina_Rectangle* update), const void* data)
-{
-    if (tile->stats.full_update) {
-        Eina_Rectangle rect;
-        rect.x = 0;
-        rect.y = 0;
-        rect.w = tile->width;
-        rect.h = tile->height;
-#ifdef TILE_STATS_ACCOUNT_RENDER_TIME
-        struct timeval timev;
-        double renderStartTime;
-        gettimeofday(&timev, 0);
-        renderStartTime = (double)timev.tv_sec +
-                       (((double)timev.tv_usec) / 1000000);
-#endif
-        callback((void*)data, tile, &rect);
-#ifdef TILE_STATS_ACCOUNT_RENDER_TIME
-        gettimeofday(&timev, 0);
-        tile->stats.render_time = (double)timev.tv_sec +
-                               (((double)timev.tv_usec) / 1000000) - renderStartTime;
-#endif
-    } else if (tile->updates) {
-        Eina_Iterator* itr = eina_tiler_iterator_new(tile->updates);
-        Eina_Rectangle* rect;
-        if (!itr) {
-            CRITICAL("could not create tiler iterator!");
-            return;
-        }
-        EINA_ITERATOR_FOREACH(itr, rect)
-            callback((void*)data, tile, rect);
-        eina_iterator_free(itr);
-    }
-}
-
-/**
- * Clear all updates in region, if any.
- *
- * This will change the tile statistics, specially zero stat.misses
- * and unset stats.full_update. If tile->updates existed, then it will be
- * destroyed.
- *
- * This function is usually called after ewk_tile_updates_process() is
- * called.
- */
-void ewk_tile_updates_clear(Ewk_Tile* tile)
-{
-    /* TODO: remove from list of pending updates? */
-    tile->stats.misses = 0;
-
-    if (tile->stats.full_update)
-        tile->stats.full_update = 0;
-    else if (tile->updates) {
-        eina_tiler_free(tile->updates);
-        tile->updates = 0;
-    }
-}
-
-typedef struct _Ewk_Tile_Unused_Cache_Entry Ewk_Tile_Unused_Cache_Entry;
-struct _Ewk_Tile_Unused_Cache_Entry {
-    Ewk_Tile* tile;
-    int weight;
-    struct {
-        void (*callback)(void* data, Ewk_Tile* tile);
-        void* data;
-    } tile_free;
-};
-
-struct _Ewk_Tile_Unused_Cache {
-    struct {
-        Eina_List* list;
-        size_t count;
-        size_t allocated;
-    } entries;
-    struct {
-        size_t max;  /**< watermark (in bytes) to start freeing tiles */
-        size_t used; /**< in bytes, maybe more than max. */
-    } memory;
-    struct {
-        Evas_Coord x, y, width, height;
-        float zoom;
-        Eina_Bool locked;
-    } locked;
-    int references;
-    unsigned int frozen;
-};
-
-static const size_t TILE_UNUSED_CACHE_ALLOCATE_INITIAL = 128;
-static const size_t TILE_UNUSED_CACHE_ALLOCATE_STEP = 16;
-static const size_t TILE_UNUSED_CACHE_MAX_FREE = 32;
-
-/**
- * Cache of unused tiles (those that are not visible).
- *
- * The cache of unused tiles.
- *
- * @param max cache size in bytes.
- *
- * @return newly allocated cache of unused tiles, use
- *         ewk_tile_unused_cache_free() to release resources. If not
- *         possible to allocate memory, @c 0 is returned.
- */
-Ewk_Tile_Unused_Cache* ewk_tile_unused_cache_new(size_t max)
-{
-    Ewk_Tile_Unused_Cache* tileUnusedCache;
-
-    tileUnusedCache = new Ewk_Tile_Unused_Cache;
-    memset(tileUnusedCache, 0, sizeof(Ewk_Tile_Unused_Cache));
-
-    DBG("tileUnusedCache=%p", tileUnusedCache);
-    tileUnusedCache->memory.max = max;
-    tileUnusedCache->references = 1;
-    return tileUnusedCache;
-}
-
-void ewk_tile_unused_cache_lock_area(Ewk_Tile_Unused_Cache* tileUnusedCache, Evas_Coord x, Evas_Coord y, Evas_Coord width, Evas_Coord height, float zoom)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileUnusedCache);
-
-    tileUnusedCache->locked.locked = true;
-    tileUnusedCache->locked.x = x;
-    tileUnusedCache->locked.y = y;
-    tileUnusedCache->locked.width = width;
-    tileUnusedCache->locked.height = height;
-    tileUnusedCache->locked.zoom = zoom;
-}
-
-void ewk_tile_unused_cache_unlock_area(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileUnusedCache);
-
-    tileUnusedCache->locked.locked = false;
-}
-
-/**
- * Free cache of unused tiles.
- *
- * This function should be only called by ewk_tile_unused_cache_unref
- * function. Calling this function without considering reference counting
- * may lead to unknown results.
- *
- * Those tiles that are still visible will remain live. The unused
- * tiles will be freed.
- *
- * @see ewk_tile_unused_cache_unref()
- */
-static void _ewk_tile_unused_cache_free(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileUnusedCache);
-
-    DBG("tileUnusedCache=%p, "
-        "entries=(count:%zd, allocated:%zd), "
-        "memory=(max:%zd, used:%zd)",
-        tileUnusedCache, tileUnusedCache->entries.count, tileUnusedCache->entries.allocated,
-        tileUnusedCache->memory.max, tileUnusedCache->memory.used);
-
-    ewk_tile_unused_cache_clear(tileUnusedCache);
-    delete tileUnusedCache;
-}
-
-/**
- * Clear cache of unused tiles.
- *
- * Any tiles that are in the cache are freed. The only tiles that are
- * kept are those that aren't in the cache (i.e. that are visible).
- */
-void ewk_tile_unused_cache_clear(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileUnusedCache);
-
-    if (!tileUnusedCache->entries.count)
-        return;
-
-    void* item;
-    EINA_LIST_FREE(tileUnusedCache->entries.list, item) {
-        Ewk_Tile_Unused_Cache_Entry* itr = static_cast<Ewk_Tile_Unused_Cache_Entry*>(item);
-        itr->tile_free.callback(itr->tile_free.data, itr->tile);
-        delete itr;
-    }
-
-    tileUnusedCache->memory.used = 0;
-    tileUnusedCache->entries.count = 0;
-}
-
-/**
- * Hold reference to cache.
- *
- * @return same pointer as taken.
- *
- * @see ewk_tile_unused_cache_unref()
- */
-Ewk_Tile_Unused_Cache* ewk_tile_unused_cache_ref(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileUnusedCache, 0);
-    tileUnusedCache->references++;
-    return tileUnusedCache;
-}
-
-/**
- * Release cache reference, freeing it if it drops to zero.
- *
- * @see ewk_tile_unused_cache_ref()
- * @see ewk_tile_unused_cache_free()
- */
-void ewk_tile_unused_cache_unref(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileUnusedCache);
-    tileUnusedCache->references--;
-    if (!tileUnusedCache->references)
-        _ewk_tile_unused_cache_free(tileUnusedCache);
-}
-
-void ewk_tile_unused_cache_max_set(Ewk_Tile_Unused_Cache* tileUnusedCache, size_t max)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileUnusedCache);
-    size_t oldMax = tileUnusedCache->memory.max;
-    tileUnusedCache->memory.max = max;
-    /* Cache flush when new max is lower then old one */
-    if (oldMax > max)
-        ewk_tile_unused_cache_auto_flush(tileUnusedCache);
-}
-
-size_t ewk_tile_unused_cache_max_get(const Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileUnusedCache, 0);
-    return tileUnusedCache->memory.max;
-}
-
-size_t ewk_tile_unused_cache_used_get(const Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileUnusedCache, 0);
-    return tileUnusedCache->memory.used;
-}
-
-size_t ewk_tile_unused_cache_flush(Ewk_Tile_Unused_Cache* tileUnusedCache, size_t bytes)
-{
-    Eina_List* list, * listNext;
-    EINA_SAFETY_ON_NULL_RETURN_VAL(tileUnusedCache, 0);
-    size_t done;
-    unsigned int count;
-
-    if (!tileUnusedCache->entries.count)
-        return 0;
-    if (bytes < 1)
-        return 0;
-
-    /*
-     * NOTE: the cache is a FIFO queue currently.
-     * Don't need to sort any more.
-     */
-
-    void* item;
-    done = 0;
-    count = 0;
-    EINA_LIST_FOREACH_SAFE(tileUnusedCache->entries.list, list, listNext, item) {
-        Ewk_Tile_Unused_Cache_Entry* itr = static_cast<Ewk_Tile_Unused_Cache_Entry*>(item);
-        Ewk_Tile* tile = itr->tile;
-        if (done > bytes)
-            break;
-        if (tileUnusedCache->locked.locked
-            && tile->x + tile->width > tileUnusedCache->locked.x
-            && tile->y + tile->height > tileUnusedCache->locked.y
-            && tile->x < tileUnusedCache->locked.x + tileUnusedCache->locked.width
-            && tile->y < tileUnusedCache->locked.y + tileUnusedCache->locked.height
-            && tile->zoom == tileUnusedCache->locked.zoom) {
-            continue;
-        }
-        done += ewk_tile_memory_size_get(itr->tile);
-        itr->tile_free.callback(itr->tile_free.data, itr->tile);
-        tileUnusedCache->entries.list = eina_list_remove_list(tileUnusedCache->entries.list, list);
-        delete itr;
-        count++;
-    }
-
-    tileUnusedCache->memory.used -= done;
-    tileUnusedCache->entries.count -= count;
-
-    return done;
-}
-
-void ewk_tile_unused_cache_auto_flush(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    EINA_SAFETY_ON_NULL_RETURN(tileUnusedCache);
-    if (tileUnusedCache->memory.used <= tileUnusedCache->memory.max)
-        return;
-    ewk_tile_unused_cache_flush(tileUnusedCache, tileUnusedCache->memory.used - tileUnusedCache->memory.max);
-    if (tileUnusedCache->memory.used > tileUnusedCache->memory.max)
-        CRITICAL("Cache still using too much memory: %zd KB; max: %zd KB",
-                 tileUnusedCache->memory.used, tileUnusedCache->memory.max);
-}
-
-/**
- * Freeze cache to not do maintenance tasks.
- *
- * Maintenance tasks optimize cache usage, but maybe we know we should
- * hold on them until we do the last operation, in this case we freeze
- * while operating and then thaw when we're done.
- *
- * @see ewk_tile_unused_cache_thaw()
- */
-void ewk_tile_unused_cache_freeze(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    tileUnusedCache->frozen++;
-}
-
-/**
- * Unfreezes maintenance tasks.
- *
- * If this is the last counterpart of freeze, then maintenance tasks
- * will run immediately.
- */
-void ewk_tile_unused_cache_thaw(Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    if (!tileUnusedCache->frozen) {
-        ERR("thawing more than freezing!");
-        return;
-    }
-
-    tileUnusedCache->frozen--;
-}
-
-/**
- * Get tile from cache of unused tiles, removing it from the cache.
- *
- * If the tile is used, then it's not in cache of unused tiles, so it
- * is removed from the cache and may be given back with
- * ewk_tile_unused_cache_tile_put().
- *
- * @param tileUnusedCache cache of unused tiles
- * @param tile the tile to be removed from Ewk_Tile_Unused_Cache.
- *
- * @return #true on success, #false otherwise.
- */
-Eina_Bool ewk_tile_unused_cache_tile_get(Ewk_Tile_Unused_Cache* tileUnusedCache, Ewk_Tile* tile)
-{
-    Eina_List* iterateEntry;
-    void* item;
-
-    EINA_LIST_FOREACH(tileUnusedCache->entries.list, iterateEntry, item) {
-        Ewk_Tile_Unused_Cache_Entry* entry = static_cast<Ewk_Tile_Unused_Cache_Entry*>(item);
-        if (entry->tile == tile) {
-            tileUnusedCache->entries.count--;
-            tileUnusedCache->memory.used -= ewk_tile_memory_size_get(tile);
-            tileUnusedCache->entries.list = eina_list_remove_list(tileUnusedCache->entries.list, iterateEntry);
-            delete entry;
-
-            return true;
-        }
-    }
-
-    ERR("tile %p not found in cache %p", tile, tileUnusedCache);
-    return false;
-}
-
-/**
- * Put tile into cache of unused tiles, adding it to the cache.
- *
- * This should be called when @c tile->visible is @c 0 and no objects are
- * using the tile anymore, making it available to be expired and have
- * its memory replaced.
- *
- * Note that tiles are not automatically deleted if cache is full,
- * instead the cache will have more bytes used than maximum and one
- * can call ewk_tile_unused_cache_auto_flush() to free them. This is done
- * because usually we want a lazy operation for better performance.
- *
- * @param tileUnusedCache cache of unused tiles
- * @param tile tile to be added to cache.
- * @param tileFreeCallback function used to free tiles.
- * @param data context to give back to @a tile_free_cb as first argument.
- *
- * @return #true on success, #false otherwise. If @c tile->visible
- *         is not #false, then it will return #false.
- *
- * @see ewk_tile_unused_cache_auto_flush()
- */
-Eina_Bool ewk_tile_unused_cache_tile_put(Ewk_Tile_Unused_Cache* tileUnusedCache, Ewk_Tile* tile, void (* tileFreeCallback)(void* data, Ewk_Tile* tile), const void* data)
-{
-    Ewk_Tile_Unused_Cache_Entry* unusedCacheEntry;
-
-    if (tile->visible) {
-        ERR("tile=%p is not unused (visible=%d)", tile, tile->visible);
-        return false;
-    }
-
-    unusedCacheEntry = new Ewk_Tile_Unused_Cache_Entry;
-
-    tileUnusedCache->entries.list = eina_list_append(tileUnusedCache->entries.list, unusedCacheEntry);
-    if (eina_error_get()) {
-        ERR("List allocation failed");
-        return false;
-    }
-
-    unusedCacheEntry->tile = tile;
-    unusedCacheEntry->weight = 0; /* calculated just before sort */
-    unusedCacheEntry->tile_free.callback = tileFreeCallback;
-    unusedCacheEntry->tile_free.data = (void*)data;
-
-    tileUnusedCache->entries.count++;
-    tileUnusedCache->memory.used += ewk_tile_memory_size_get(tile);
-
-    return true;
-}
-
-void ewk_tile_unused_cache_dbg(const Ewk_Tile_Unused_Cache* tileUnusedCache)
-{
-    void* item;
-    Eina_List* list;
-    int count = 0;
-    printf("Cache of unused tiles: entries: %zu/%zu, memory: %zu/%zu\n",
-           tileUnusedCache->entries.count, tileUnusedCache->entries.allocated,
-           tileUnusedCache->memory.used, tileUnusedCache->memory.max);
-
-    EINA_LIST_FOREACH(tileUnusedCache->entries.list, list, item) {
-        const Ewk_Tile* tile = static_cast<Ewk_Tile_Unused_Cache_Entry*>(item)->tile;
-        printf(" [%3lu,%3lu + %dx%d @ %0.3f]%c",
-               tile->column, tile->row, tile->width, tile->height, tile->zoom,
-               tile->visible ? '*' : ' ');
-
-        if (!(count % 4))
-            printf("\n");
-    }
-
-    printf("\n");
-}
diff --git a/Source/WebKit/efl/ewk/ewk_tiled_model_private.h b/Source/WebKit/efl/ewk/ewk_tiled_model_private.h
deleted file mode 100644 (file)
index c5f6d72..0000000
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-    Copyright (C) 2009-2010 Samsung Electronics
-    Copyright (C) 2009-2010 ProFUSION embedded systems
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
-*/
-
-#ifndef ewk_tiled_model_private_h
-#define ewk_tiled_model_private_h
-
-#include "ewk_tiled_backing_store_private.h"
-
-#include <Evas.h>
-
-/* model */
-Ewk_Tile *ewk_tile_new(Evas *evas, Evas_Coord w, Evas_Coord h, float zoom, Evas_Colorspace cspace);
-void ewk_tile_free(Ewk_Tile *t);
-void ewk_tile_unused_cache_clear(Ewk_Tile_Unused_Cache *tuc);
-void ewk_tile_show(Ewk_Tile *t);
-void ewk_tile_hide(Ewk_Tile *t);
-size_t ewk_tile_memory_size_get(const Ewk_Tile *t);
-Eina_Bool ewk_tile_visible_get(Ewk_Tile *t);
-void ewk_tile_update_full(Ewk_Tile *t);
-void ewk_tile_update_area(Ewk_Tile *t, const Eina_Rectangle *r);
-void ewk_tile_updates_process(Ewk_Tile *t, void (*cb)(void *data, Ewk_Tile *t, const Eina_Rectangle *update), const void *data);
-void ewk_tile_updates_clear(Ewk_Tile *t);
-
-/* cache of unused tiles */
-Ewk_Tile_Unused_Cache *ewk_tile_unused_cache_new(size_t max);
-void ewk_tile_unused_cache_lock_area(Ewk_Tile_Unused_Cache *tuc, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h, float zoom);
-void ewk_tile_unused_cache_unlock_area(Ewk_Tile_Unused_Cache *tuc);
-Ewk_Tile_Unused_Cache *ewk_tile_unused_cache_ref(Ewk_Tile_Unused_Cache *tuc);
-void ewk_tile_unused_cache_unref(Ewk_Tile_Unused_Cache *tuc);
-
-void ewk_tile_unused_cache_dirty(Ewk_Tile_Unused_Cache *tuc);
-
-void ewk_tile_unused_cache_freeze(Ewk_Tile_Unused_Cache *tuc);
-void ewk_tile_unused_cache_thaw(Ewk_Tile_Unused_Cache *tuc);
-
-Eina_Bool ewk_tile_unused_cache_tile_get(Ewk_Tile_Unused_Cache *tuc, Ewk_Tile *t);
-Eina_Bool ewk_tile_unused_cache_tile_put(Ewk_Tile_Unused_Cache *tuc, Ewk_Tile *t, void (* tile_free_cb)(void *data, Ewk_Tile *t), const void *data);
-
-#endif // ewk_tiled_model_private_h
index 49e6211..cdb0937 100644 (file)
@@ -3431,22 +3431,6 @@ void ewk_view_add_console_message(Evas_Object* ewkView, const char* message, uns
     smartData->api->add_console_message(smartData, message, lineNumber, sourceID);
 }
 
-/**
- * @internal
- *
- * Reports that FrameView object has been created.
- * Allows to repaint the frame completely even if the areas are out of the screen
- * when @ewkView is an instance of ewk_view_tiled.
- *
- * @param ewkView view object
- */
-void ewk_view_frame_view_creation_notify(Evas_Object* ewkView)
-{
-    EWK_VIEW_TYPE_CHECK_OR_RETURN(ewkView, ewkViewTiledName);
-    EWK_VIEW_SD_GET_OR_RETURN(ewkView, smartData);
-    ewk_frame_paint_full_set(smartData->main_frame, true);
-}
-
 bool ewk_view_focus_can_cycle(Evas_Object* ewkView, Ewk_Focus_Direction direction)
 {
     DBG("ewkView=%p direction=%d", ewkView, direction);
index eb3c74e..9c90886 100644 (file)
@@ -501,84 +501,6 @@ enum _Ewk_Editor_Command {
 typedef enum _Ewk_Editor_Command Ewk_Editor_Command;
 
 /**
- * @brief Creates a type name for @a _Ewk_Tile_Unused_Cache.
- *
- * Cache (pool) that contains unused tiles for ewk_view_tiled.
- *
- * This cache will maintain unused tiles and flush them when the total
- * memory exceeds the set amount when
- * ewk_tile_unused_cache_auto_flush() or explicitly set value when
- * ewk_tile_unused_cache_flush() is called.
- *
- * The tile may be shared among different ewk_view_tiled instances to
- * group maximum unused memory resident in the system.
- */
-typedef struct _Ewk_Tile_Unused_Cache Ewk_Tile_Unused_Cache;
-
-/**
- * Changes cache capacity of unused tiles.
- *
- * @param tuc cache of unused tiles to set a new capacity of unused tiles
- *
- * @param max a new capacity of cache, in bytes
- *
- * @note This will not flush cache, use ewk_tile_unused_cache_flush() or
- * ewk_tile_unused_cache_auto_flush() to do so.
- */
-EAPI void   ewk_tile_unused_cache_max_set(Ewk_Tile_Unused_Cache *tuc, size_t max);
-
-/**
- * Retrieves maximum cache capacity of unused tiles.
- *
- * @param tuc cache of unused tiles to get maximum cache capacity of unused tiles
- *
- * @return maximum cache capacity, in bytes on success or @c 0 on failure
- */
-EAPI size_t ewk_tile_unused_cache_max_get(const Ewk_Tile_Unused_Cache *tuc);
-
-/**
- * Retrieves the used cache capacity of unused tiles.
- *
- * @param tuc cache of unused tiles to get used cache capacity of unused tiles
- *
- * @return used cache capacity, in bytes on success or @c 0 on failure
- */
-EAPI size_t ewk_tile_unused_cache_used_get(const Ewk_Tile_Unused_Cache *tuc);
-
-/**
- * Flushes given amount of bytes from cache of unused tiles.
- *
- * After calling this function, near @a bytes are freed from cache. It
- * may be less if cache did not contain that amount of bytes (ie: an
- * empty cache has nothing to free!) or more if the cache just
- * contained objects that were larger than the requested amount (this
- * is usually the case).
- *
- * @param tuc cache of unused tiles to flush @bytes from cache
- * @param bytes amount bytes to free
- *
- * @return amount really freed bytes
- *
- * @see ewk_tile_unused_cache_used_get()
- */
-EAPI size_t ewk_tile_unused_cache_flush(Ewk_Tile_Unused_Cache *tuc, size_t bytes);
-
-/**
- * Flushes enough bytes to make cache of unused tiles usage lower than maximum.
- *
- * Just like ewk_tile_unused_cache_flush(), but this will make the cache
- * free enough tiles to respect maximum cache size as defined with
- * ewk_tile_unused_cache_max_set().
- *
- * This function is usually called when system becomes idle. This way
- * we keep memory low but do not impact performance when
- * creating/deleting tiles.
- *
- * @param tuc cache of unused tiles to flush cache of unused tiles
- */
-EAPI void   ewk_tile_unused_cache_auto_flush(Ewk_Tile_Unused_Cache *tuc);
-
-/**
  * Sets the smart class api without any backing store, enabling view
  * to be inherited.
  *
@@ -595,7 +517,6 @@ EAPI void   ewk_tile_unused_cache_auto_flush(Ewk_Tile_Unused_Cache *tuc);
  *         version mismatch)
  *
  * @see ewk_view_single_smart_set()
- * @see ewk_view_tiled_smart_set()
  */
 EAPI Eina_Bool    ewk_view_base_smart_set(Ewk_View_Smart_Class *api);
 
@@ -620,26 +541,6 @@ EAPI Eina_Bool    ewk_view_base_smart_set(Ewk_View_Smart_Class *api);
 EAPI Eina_Bool    ewk_view_single_smart_set(Ewk_View_Smart_Class *api);
 
 /**
- * Sets the smart class api using tiled backing store, enabling view
- * to be inherited.
- *
- * @param api class definition to set, all members with the
- *        exception of @a Evas_Smart_Class->data may be overridden, must
- *        @b not be @c NULL
- *
- * @note @a Evas_Smart_Class->data is used to implement type checking and
- *       is not supposed to be changed/overridden. If you need extra
- *       data for your smart class to work, just extend
- *       Ewk_View_Smart_Class instead.
- *
- * @return @c EINA_TRUE on success or @c EINA_FALSE on failure (probably
- *         version mismatch)
- *
- * @see ewk_view_base_smart_set()
- */
-EAPI Eina_Bool    ewk_view_tiled_smart_set(Ewk_View_Smart_Class *api);
-
-/**
  * Creates a new EFL WebKit View object.
  *
  * View objects are the recommended way to deal with EFL WebKit as it
@@ -658,47 +559,6 @@ EAPI Eina_Bool    ewk_view_tiled_smart_set(Ewk_View_Smart_Class *api);
 EAPI Evas_Object *ewk_view_single_add(Evas *e);
 
 /**
- * Creates a new EFL WebKit View object using tiled backing store.
- *
- * View objects are the recommended way to deal with EFL WebKit as it
- * abstracts the complex pieces of the process.
- *
- * This object is almost the same as the one returned by the ewk_view_single_add()
- * function, but it uses the tiled backing store instead of the default
- * backing store.
- *
- * @param e canvas object where to create the view object
- *
- * @return the view object on success or @c NULL on failure
- *
- * @see ewk_view_uri_set()
- */
-EAPI Evas_Object *ewk_view_tiled_add(Evas *e);
-
-/**
- * Gets the cache object of unused tiles used by this view.
- *
- * @param o the view object to get the cache object
- *
- * @return the cache object of unused tiles or @c NULL on failure
- */
-EAPI Ewk_Tile_Unused_Cache *ewk_view_tiled_unused_cache_get(const Evas_Object *o);
-
-/**
- * Sets the cache object of unused tiles used by this view.
- *
- * It can be used to share a single cache amongst different views.
- * The tiles from one view will not be used by the other!
- * This is just to limit the group with amount of unused memory.
- *
- * @note If @c NULL is provided as a @a cache, then a new one is created.
- *
- * @param o the view object to set the cache object
- * @param the cache object of unused tiles
- */
-EAPI void                   ewk_view_tiled_unused_cache_set(Evas_Object *o, Ewk_Tile_Unused_Cache *cache);
-
-/**
  * Sets a fixed layout size to be used, dissociating it from viewport size.
  *
  * Setting a width different than zero enables fixed layout on that
index 445c1dd..2ddbc24 100644 (file)
@@ -130,7 +130,6 @@ void ewk_view_editor_client_contents_changed(Evas_Object* ewkView);
 void ewk_view_editor_client_selection_changed(Evas_Object* ewkView);
 
 bool ewk_view_focus_can_cycle(Evas_Object* ewkView, Ewk_Focus_Direction direction);
-void ewk_view_frame_view_creation_notify(Evas_Object* ewkView);
 
 Eina_Bool ewk_view_paint(Ewk_View_Private_Data* priv, Ewk_Paint_Context* context, const Eina_Rectangle* area);
 Eina_Bool ewk_view_paint_contents(Ewk_View_Private_Data* priv, Ewk_Paint_Context* context, const Eina_Rectangle* area);
diff --git a/Source/WebKit/efl/ewk/ewk_view_tiled.cpp b/Source/WebKit/efl/ewk/ewk_view_tiled.cpp
deleted file mode 100644 (file)
index 43a1ddf..0000000
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
-    Copyright (C) 2009-2010 Samsung Electronics
-    Copyright (C) 2009-2010 ProFUSION embedded systems
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public License
-    along with this library; see the file COPYING.LIB.  If not, write to
-    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301, USA.
-*/
-
-#include "config.h"
-#include "ewk_view.h"
-
-#include "ewk_private.h"
-#include "ewk_tiled_backing_store_private.h"
-#include "ewk_view_private.h"
-#include <Evas.h>
-#include <eina_safety_checks.h>
-
-static Ewk_View_Smart_Class _parent_sc = EWK_VIEW_SMART_CLASS_INIT_NULL;
-
-static bool _ewk_view_tiled_render_cb(void* data, Ewk_Tile* tile, const Eina_Rectangle* area)
-{
-    Ewk_View_Private_Data* priv = static_cast<Ewk_View_Private_Data*>(data);
-    Eina_Rectangle rect = {area->x + tile->x, area->y + tile->y, area->w, area->h};
-
-    uint8_t* pixels = static_cast<uint8_t*>(evas_object_image_data_get(tile->image, true));
-    Ewk_Paint_Context* context = ewk_paint_context_from_image_data_new(pixels, tile->width, tile->height, tile->cspace);
-
-    ewk_paint_context_translate(context, -tile->x, -tile->y);
-    bool result = ewk_view_paint_contents(priv, context, &rect);
-    ewk_paint_context_free(context);
-
-    evas_object_image_data_set(tile->image, pixels);
-
-    return result;
-}
-
-static void* _ewk_view_tiled_updates_process_pre(void* data, Evas_Object*)
-{
-    Ewk_View_Private_Data* priv = static_cast<Ewk_View_Private_Data*>(data);
-    ewk_view_layout_if_needed_recursive(priv);
-    return 0;
-}
-
-static Evas_Object* _ewk_view_tiled_smart_backing_store_add(Ewk_View_Smart_Data* smartData)
-{
-    Evas_Object* backingStore = ewk_tiled_backing_store_add(smartData->base.evas);
-    ewk_tiled_backing_store_render_cb_set(backingStore, _ewk_view_tiled_render_cb, smartData->_priv);
-    ewk_tiled_backing_store_updates_process_pre_set
-        (backingStore, _ewk_view_tiled_updates_process_pre, smartData->_priv);
-    return backingStore;
-}
-
-static void
-_ewk_view_tiled_contents_size_changed_cb(void* data, Evas_Object*, void* eventInfo)
-{
-    Evas_Coord* size = static_cast<Evas_Coord*>(eventInfo);
-    Ewk_View_Smart_Data* smartData = static_cast<Ewk_View_Smart_Data*>(data);
-
-    ewk_tiled_backing_store_contents_resize
-        (smartData->backing_store, size[0], size[1]);
-}
-
-static void _ewk_view_tiled_smart_add(Evas_Object* ewkView)
-{
-    Ewk_View_Smart_Data* smartData;
-
-    _parent_sc.sc.add(ewkView);
-
-    smartData = static_cast<Ewk_View_Smart_Data*>(evas_object_smart_data_get(ewkView));
-    if (!smartData)
-        return;
-
-    evas_object_smart_callback_add(
-        smartData->main_frame, "contents,size,changed",
-        _ewk_view_tiled_contents_size_changed_cb, smartData);
-}
-
-static Eina_Bool _ewk_view_tiled_smart_scrolls_process(Ewk_View_Smart_Data* smartData)
-{
-    const WTF::Vector<WebCore::IntSize>& scrollOffset = ewk_view_scroll_offsets_get(smartData->_priv);
-    for (size_t i = 0; i < scrollOffset.size(); ++i)
-        ewk_tiled_backing_store_scroll_full_offset_add(smartData->backing_store, scrollOffset[i].width(), scrollOffset[i].height());
-
-    return true;
-}
-
-static Eina_Bool _ewk_view_tiled_smart_repaints_process(Ewk_View_Smart_Data* smartData)
-{
-    const Eina_Rectangle* paintRect, * endOfpaintRect;
-    size_t count;
-    int scrollX, scrollY;
-
-    ewk_frame_scroll_pos_get(smartData->main_frame, &scrollX, &scrollY);
-
-    paintRect = ewk_view_repaints_pop(smartData->_priv, &count);
-    endOfpaintRect = paintRect + count;
-    for (; paintRect < endOfpaintRect; paintRect++) {
-        Eina_Rectangle rect;
-        rect.x = paintRect->x + scrollX;
-        rect.y = paintRect->y + scrollY;
-        rect.w = paintRect->w;
-        rect.h = paintRect->h;
-        ewk_tiled_backing_store_update(smartData->backing_store, &rect);
-    }
-    ewk_tiled_backing_store_updates_process(smartData->backing_store);
-
-    return true;
-}
-
-static Eina_Bool _ewk_view_tiled_smart_contents_resize(Ewk_View_Smart_Data* smartData, int width, int height)
-{
-    ewk_tiled_backing_store_contents_resize(smartData->backing_store, width, height);
-    return true;
-}
-
-static Eina_Bool _ewk_view_tiled_smart_zoom_set(Ewk_View_Smart_Data* smartData, float zoom, Evas_Coord centerX, Evas_Coord centerY)
-{
-    Evas_Coord x, y, width, height;
-    Eina_Bool result;
-    result = ewk_tiled_backing_store_zoom_set(smartData->backing_store,
-                                         &zoom, centerX, centerY, &x, &y);
-    if (!result)
-        return result;
-    ewk_tiled_backing_store_disabled_update_set(smartData->backing_store, true);
-    result = _parent_sc.zoom_set(smartData, zoom, centerX, centerY);
-    ewk_frame_scroll_set(smartData->main_frame, -x, -y);
-    ewk_frame_scroll_size_get(smartData->main_frame, &width, &height);
-    ewk_tiled_backing_store_fix_offsets(smartData->backing_store, width, height);
-    ewk_view_scrolls_process(smartData);
-    evas_object_smart_calculate(smartData->backing_store);
-    evas_object_smart_calculate(smartData->self);
-    ewk_tiled_backing_store_disabled_update_set(smartData->backing_store, false);
-    return result;
-}
-
-static Eina_Bool _ewk_view_tiled_smart_zoom_weak_set(Ewk_View_Smart_Data* smartData, float zoom, Evas_Coord centerX, Evas_Coord centerY)
-{
-    return ewk_tiled_backing_store_zoom_weak_set(smartData->backing_store, zoom, centerX, centerY);
-}
-
-static void _ewk_view_tiled_smart_zoom_weak_smooth_scale_set(Ewk_View_Smart_Data* smartData, Eina_Bool smoothScale)
-{
-    ewk_tiled_backing_store_zoom_weak_smooth_scale_set(smartData->backing_store, smoothScale);
-}
-
-static void _ewk_view_tiled_smart_bg_color_set(Ewk_View_Smart_Data* smartData, unsigned char /*red*/, unsigned char /*green*/, unsigned char /*blue*/, unsigned char alpha)
-{
-    ewk_tiled_backing_store_alpha_set(smartData->backing_store, alpha < 255);
-}
-
-static void _ewk_view_tiled_smart_flush(Ewk_View_Smart_Data* smartData)
-{
-    ewk_tiled_backing_store_flush(smartData->backing_store);
-    _parent_sc.flush(smartData);
-}
-
-static Eina_Bool _ewk_view_tiled_smart_pre_render_region(Ewk_View_Smart_Data* smartData, Evas_Coord x, Evas_Coord y, Evas_Coord width, Evas_Coord height, float zoom)
-{
-    return ewk_tiled_backing_store_pre_render_region
-               (smartData->backing_store, x, y, width, height, zoom);
-}
-
-static Eina_Bool _ewk_view_tiled_smart_pre_render_relative_radius(Ewk_View_Smart_Data* smartData, unsigned int n, float zoom)
-{
-    return ewk_tiled_backing_store_pre_render_relative_radius
-               (smartData->backing_store, n, zoom);
-}
-
-static inline int _ewk_view_tiled_rect_collision_check(Eina_Rectangle destination, Eina_Rectangle source)
-{
-    int direction = 0;
-    if (destination.x < source.x)
-        direction = direction | (1 << 0); // 0 bit shift, left
-    if (destination.y < source.y)
-        direction = direction | (1 << 1); // 1 bit shift, top
-    if (destination.x + destination.w > source.x + source.w)
-        direction = direction | (1 << 2); // 2 bit shift, right
-    if (destination.y + destination.h > source.y + source.h)
-        direction = direction | (1 << 3); // 3 bit shift, bottom
-    DBG("check collision %d\r\n", direction);
-    return direction;
-}
-
-static inline void _ewk_view_tiled_rect_collision_resolve(int direction, Eina_Rectangle* destination, Eina_Rectangle source)
-{
-    if (direction & (1 << 0)) // 0 bit shift, left
-        destination->x = source.x;
-    if (direction & (1 << 1)) // 1 bit shift, top
-        destination->y = source.y;
-    if (direction & (1 << 2)) // 2 bit shift, right
-        destination->x = destination->x - ((destination->x + destination->w) - (source.x + source.w));
-    if (direction & (1 << 3)) // 3 bit shift, bottom
-        destination->y = destination->y - ((destination->y + destination->h) - (source.y + source.h));
-}
-
-static Eina_Bool _ewk_view_tiled_smart_pre_render_start(Ewk_View_Smart_Data* smartData)
-{
-    int contentWidth, contentHeight;
-    ewk_frame_contents_size_get(smartData->main_frame, &contentWidth, &contentHeight);
-
-    int viewX, viewY, viewWidth, viewHeight;
-    ewk_frame_visible_content_geometry_get(smartData->main_frame, false, &viewX, &viewY, &viewWidth, &viewHeight);
-
-    if (viewWidth <= 0 || viewHeight <= 0 || contentWidth <= 0 || contentHeight <= 0)
-        return false;
-
-    if (viewWidth >= contentWidth && viewHeight >= contentHeight)
-        return false;
-
-    int previousViewX, previousViewY;
-    previousViewX = smartData->previousView.x;
-    previousViewY = smartData->previousView.y;
-
-    if (previousViewX < 0 || previousViewX > contentWidth || previousViewY < 0 || previousViewY > contentHeight)
-        previousViewX = previousViewY = 0;
-
-    float currentViewZoom = ewk_view_zoom_get(smartData->self);
-
-    // pre-render works when two conditions are met.
-    // zoom has been changed.
-    // and the view has been moved more than tile size.
-    if (abs(previousViewX - viewX) < defaultTileWidth
-        && abs(previousViewY - viewY) < defaultTileHeigth
-        && smartData->previousView.zoom == currentViewZoom) {
-        return false;
-    }
-
-    // store previous view position and zoom.
-    smartData->previousView.x = viewX;
-    smartData->previousView.y = viewY;
-    smartData->previousView.zoom = currentViewZoom;
-
-    // cancelling previous pre-rendering list if exists.
-    ewk_view_pre_render_cancel(smartData->self);
-
-    Ewk_Tile_Unused_Cache* tileUnusedCache = ewk_view_tiled_unused_cache_get(smartData->self);
-    int maxMemory = ewk_tile_unused_cache_max_get(tileUnusedCache);
-    if (maxMemory <= viewWidth * viewHeight * EWK_ARGB_BYTES_SIZE)
-        return false;
-
-    Eina_Rectangle viewRect = {viewX, viewY, viewWidth, viewHeight};
-    Eina_Rectangle contentRect = {0, 0, contentWidth, contentHeight};
-
-    // get a base render rect.
-    const int contentMemory = contentWidth * contentHeight * EWK_ARGB_BYTES_SIZE;
-
-    // get render rect's width and height.
-    Eina_Rectangle renderRect;
-    if (maxMemory > contentMemory)
-        renderRect = contentRect;
-    else {
-        // Make a base rectangle as big as possible with using maxMemory.
-        // and then reshape the base rectangle to fit to contents.
-        const int baseSize = static_cast<int>(sqrt(maxMemory / 4.0f));
-        const float widthRate = (viewRect.w + (defaultTileWidth * 2)) / static_cast<float>(baseSize);
-        const float heightRate = baseSize / static_cast<float>(contentHeight);
-        const float rectRate = std::max(widthRate, heightRate);
-
-        renderRect.w = static_cast<int>(baseSize * rectRate);
-        renderRect.h = static_cast<int>(baseSize / rectRate);
-        renderRect.x = viewRect.x + (viewRect.w / 2) - (renderRect.w / 2);
-        renderRect.y = viewRect.y + (viewRect.h / 2) - (renderRect.h / 2);
-
-        // reposition of renderRect, if the renderRect overlapped the content rect, this code moves the renderRect inside the content rect.
-        int collisionSide = _ewk_view_tiled_rect_collision_check(renderRect, contentRect);
-        if (collisionSide > 0)
-            _ewk_view_tiled_rect_collision_resolve(collisionSide, &renderRect, contentRect);
-
-        // check abnormal render rect
-        if (renderRect.x < 0)
-            renderRect.x = 0;
-        if (renderRect.y < 0)
-            renderRect.y = 0;
-        if (renderRect.w > contentWidth)
-            renderRect.w = contentWidth;
-        if (renderRect.h > contentHeight)
-            renderRect.h = contentHeight;
-    }
-
-    // enqueue tiles into tiled backing store in spiral order.
-    ewk_tiled_backing_store_pre_render_spiral_queue(smartData->backing_store, &viewRect, &renderRect, maxMemory, currentViewZoom);
-
-    return true;
-}
-
-static void _ewk_view_tiled_smart_pre_render_cancel(Ewk_View_Smart_Data* smartData)
-{
-    ewk_tiled_backing_store_pre_render_cancel(smartData->backing_store);
-}
-
-static Eina_Bool _ewk_view_tiled_smart_disable_render(Ewk_View_Smart_Data* smartData)
-{
-    return ewk_tiled_backing_store_disable_render(smartData->backing_store);
-}
-
-static Eina_Bool _ewk_view_tiled_smart_enable_render(Ewk_View_Smart_Data* smartData)
-{
-    return ewk_tiled_backing_store_enable_render(smartData->backing_store);
-}
-
-Eina_Bool ewk_view_tiled_smart_set(Ewk_View_Smart_Class* api)
-{
-    if (!ewk_view_base_smart_set(api))
-        return false;
-
-    if (EINA_UNLIKELY(!_parent_sc.sc.add)) {
-        _parent_sc.sc.name = ewkViewTiledName;
-        ewk_view_base_smart_set(&_parent_sc);
-        api->sc.parent = reinterpret_cast<Evas_Smart_Class*>(&_parent_sc);
-    }
-
-    api->sc.add = _ewk_view_tiled_smart_add;
-
-    api->backing_store_add = _ewk_view_tiled_smart_backing_store_add;
-    api->scrolls_process = _ewk_view_tiled_smart_scrolls_process;
-    api->repaints_process = _ewk_view_tiled_smart_repaints_process;
-    api->contents_resize = _ewk_view_tiled_smart_contents_resize;
-    api->zoom_set = _ewk_view_tiled_smart_zoom_set;
-    api->zoom_weak_set = _ewk_view_tiled_smart_zoom_weak_set;
-    api->zoom_weak_smooth_scale_set = _ewk_view_tiled_smart_zoom_weak_smooth_scale_set;
-    api->bg_color_set = _ewk_view_tiled_smart_bg_color_set;
-    api->flush = _ewk_view_tiled_smart_flush;
-    api->pre_render_region = _ewk_view_tiled_smart_pre_render_region;
-    api->pre_render_relative_radius = _ewk_view_tiled_smart_pre_render_relative_radius;
-    api->pre_render_start = _ewk_view_tiled_smart_pre_render_start;
-    api->pre_render_cancel = _ewk_view_tiled_smart_pre_render_cancel;
-    api->disable_render = _ewk_view_tiled_smart_disable_render;
-    api->enable_render = _ewk_view_tiled_smart_enable_render;
-    return true;
-}
-
-static inline Evas_Smart* _ewk_view_tiled_smart_class_new(void)
-{
-    static Ewk_View_Smart_Class api = EWK_VIEW_SMART_CLASS_INIT_NAME_VERSION(ewkViewTiledName);
-    static Evas_Smart* smart = 0;
-
-    if (EINA_UNLIKELY(!smart)) {
-        ewk_view_tiled_smart_set(&api);
-        smart = evas_smart_class_new(&api.sc);
-    }
-
-    return smart;
-}
-
-Evas_Object* ewk_view_tiled_add(Evas* canvas)
-{
-    return evas_object_smart_add(canvas, _ewk_view_tiled_smart_class_new());
-}
-
-Ewk_Tile_Unused_Cache* ewk_view_tiled_unused_cache_get(const Evas_Object* ewkView)
-{
-    EWK_VIEW_TYPE_CHECK_OR_RETURN(ewkView, ewkViewTiledName, 0);
-    Ewk_View_Smart_Data* smartData = ewk_view_smart_data_get(ewkView);
-    EINA_SAFETY_ON_NULL_RETURN_VAL(smartData, 0);
-    return ewk_tiled_backing_store_tile_unused_cache_get(smartData->backing_store);
-}
-
-void ewk_view_tiled_unused_cache_set(Evas_Object* ewkView, Ewk_Tile_Unused_Cache* cache)
-{
-    EWK_VIEW_TYPE_CHECK_OR_RETURN(ewkView, ewkViewTiledName);
-    Ewk_View_Smart_Data* smartData = ewk_view_smart_data_get(ewkView);
-    EINA_SAFETY_ON_NULL_RETURN(smartData);
-    ewk_tiled_backing_store_tile_unused_cache_set(smartData->backing_store, cache);
-}
index a17bfa4..ef14f6a 100644 (file)
@@ -42,19 +42,13 @@ bool EWKTestView::init(EwkViewType testViewType, int width, int height)
     if (!evas)
         return false;
 
-    switch (testViewType) {
-    case SingleView:
-        m_webView = adoptRef(ewk_view_single_add(evas));
-        break;
-
-    case TiledView:
-        m_webView = adoptRef(ewk_view_tiled_add(evas));
-        break;
-    }
-
+    m_webView = adoptRef(ewk_view_single_add(evas));
     if (!m_webView)
         return false;
 
+    if (testViewType == TiledView)
+        ewk_view_setting_tiled_backing_store_enabled_set(m_webView.get(), EINA_TRUE);
+
     ewk_view_theme_set(m_webView.get(), Config::defaultThemePath);
 
     evas_object_resize(m_webView.get(), width, height);
index a5902e8..b39db47 100644 (file)
@@ -1,3 +1,21 @@
+2013-12-29  Ryuan Choi  <ryuan.choi@samsung.com>
+
+        [EFL] Remove ewk_view_tiled
+        https://bugs.webkit.org/show_bug.cgi?id=125961
+
+        Reviewed by Gyuyoung Kim.
+
+        * DumpRenderTree/efl/DumpRenderTreeChrome.cpp:
+        (shouldUseTiledBackingStore):
+        Moved from DumpRenderTreeChrome to enable WebCore's TiledBackingStore
+        instead of switching ewk_view_tiled.
+        (DumpRenderTreeChrome::createView):
+        * DumpRenderTree/efl/DumpRenderTreeView.cpp:
+        (drtViewAdd):
+        * EWebLauncher/main.c: Removed ewk_view_tiled option.
+        (windowCreate):
+        (parseUserArguments):
+
 2013-12-29  Alexey Proskuryakov  <ap@apple.com>
 
         Pending revision popover is slightly misplaced at build.webkit.org/dashboard
index 5f8b4dc..5bf316a 100644 (file)
@@ -95,12 +95,21 @@ Evas_Object* DumpRenderTreeChrome::createNewWindow()
     return newView;
 }
 
+static bool shouldUseTiledBackingStore()
+{
+    const char* useTiledBackingStore = getenv("DRT_USE_TILED_BACKING_STORE");
+    return useTiledBackingStore && *useTiledBackingStore == '1';
+}
+
 Evas_Object* DumpRenderTreeChrome::createView() const
 {
     Evas_Object* view = drtViewAdd(m_evas);
     if (!view)
         return 0;
 
+    if (shouldUseTiledBackingStore())
+        ewk_view_setting_tiled_backing_store_enabled_set(view, EINA_TRUE);
+
     ewk_view_theme_set(view, TEST_THEME_DIR "/default.edj");
 
     evas_object_smart_callback_add(view, "download,request", onDownloadRequest, 0);
index 6f3cc49..43c9836 100644 (file)
@@ -172,17 +172,6 @@ static int64_t onExceededApplicationCacheQuota(Ewk_View_Smart_Data*, Ewk_Securit
     return defaultOriginQuota;
 }
 
-static bool shouldUseTiledBackingStore()
-{
-    const char* useTiledBackingStore = getenv("DRT_USE_TILED_BACKING_STORE");
-    return useTiledBackingStore && *useTiledBackingStore == '1';
-}
-
-static bool chooseAndInitializeAppropriateSmartClass(Ewk_View_Smart_Class* api)
-{
-    return !shouldUseTiledBackingStore() ? ewk_view_single_smart_set(api) : ewk_view_tiled_smart_set(api);
-}
-
 // Taken from the file "WebKit/Tools/DumpRenderTree/chromium/WebViewHost.cpp".
 static inline const char* navigationTypeToString(const Ewk_Navigation_Type type)
 {
@@ -227,7 +216,7 @@ Evas_Object* drtViewAdd(Evas* evas)
 {
     static Ewk_View_Smart_Class api = EWK_VIEW_SMART_CLASS_INIT_NAME_VERSION("DRT_View");
 
-    if (!chooseAndInitializeAppropriateSmartClass(&api))
+    if (!ewk_view_single_smart_set(&api))
         return 0;
 
     if (EINA_UNLIKELY(!gParentSmartClass.sc.add))
index 79eb81b..30190e9 100644 (file)
@@ -113,8 +113,6 @@ static const Ecore_Getopt options = {
         ECORE_GETOPT_CALLBACK_NOARGS
             ('E', "list-engines", "list ecore-evas engines.",
              ecore_getopt_callback_ecore_evas_list_engines, NULL),
-        ECORE_GETOPT_CHOICE
-            ('b', "backing-store", "choose backing store to use.", backingStores),
         ECORE_GETOPT_STORE_DOUBLE
             ('r', "device-pixel-ratio", "Ratio between the CSS units and device pixels."),
         ECORE_GETOPT_STORE_DEF_BOOL
@@ -149,7 +147,6 @@ static const Ecore_Getopt options = {
 typedef struct _User_Arguments {
     char *engine;
     Eina_Bool quitOption;
-    char *backingStore;
     double device_pixel_ratio;
     Eina_Bool enableEncodingDetector;
     Eina_Bool enableTiledBackingStore;
@@ -849,15 +846,8 @@ windowCreate(User_Arguments *userArgs)
         return NULL;
     }
 
-    if (userArgs->backingStore && !strcasecmp(userArgs->backingStore, "tiled")) {
-        app->browser = ewk_view_tiled_add(app->evas);
-        info("backing store: tiled");
-    } else {
-        app->browser = ewk_view_single_add(app->evas);
-        info("backing store: single");
-
-        ewk_view_setting_tiled_backing_store_enabled_set(app->browser, userArgs->enableTiledBackingStore);
-    }
+    app->browser = ewk_view_single_add(app->evas);
+    ewk_view_setting_tiled_backing_store_enabled_set(app->browser, userArgs->enableTiledBackingStore);
 
     ewk_view_theme_set(app->browser, themePath);
     if (userArgs->userAgent)
@@ -941,7 +931,6 @@ parseUserArguments(int argc, char *argv[], User_Arguments *userArgs)
 
     userArgs->engine = NULL;
     userArgs->quitOption = EINA_FALSE;
-    userArgs->backingStore = (char *)backingStores[1];
     userArgs->device_pixel_ratio = 1.0;
     userArgs->enableEncodingDetector = EINA_FALSE;
     userArgs->enableTiledBackingStore = EINA_FALSE;
@@ -957,7 +946,6 @@ parseUserArguments(int argc, char *argv[], User_Arguments *userArgs)
     Ecore_Getopt_Value values[] = {
         ECORE_GETOPT_VALUE_STR(userArgs->engine),
         ECORE_GETOPT_VALUE_BOOL(userArgs->quitOption),
-        ECORE_GETOPT_VALUE_STR(userArgs->backingStore),
         ECORE_GETOPT_VALUE_DOUBLE(userArgs->device_pixel_ratio),
         ECORE_GETOPT_VALUE_BOOL(userArgs->enableEncodingDetector),
         ECORE_GETOPT_VALUE_BOOL(userArgs->isFlattening),