ChangeLog

2011-10-26  Gyuyoung Kim  <gyuyoung.kim@samsung.com>

        [EFL}  Use template functions instead of memory allocation of C functions.

        https://bugs.webkit.org/show_bug.cgi?id=70883

        Reviewed by NOBODY (OOPS!).

        This is a fourth step in order to be more compliant with WebKit coding style.

        Use memory macros instead of malloc, calloc and realloc directly. It makes efl port

        is more close to C++ coding style.

        * ewk/ewk_auth_soup.cpp:

        * ewk/ewk_contextmenu.cpp:

        * ewk/ewk_frame.cpp:

        * ewk/ewk_js.cpp:

        * ewk/ewk_memory_allocation.h: Added.

        * ewk/ewk_tiled_backing_store.cpp:

        * ewk/ewk_tiled_model.cpp:

        * ewk/ewk_view.cpp:

        * ewk/ewk_window_features.cpp:

2011-10-25  KwangHyuk Kim  <hyuki.kim@samsung.com>

        Fix occurrence of unpainted tiles while scrolling and zooming.

Source/WebKit/efl/ewk/ewk_auth_soup.cpp

#include "EWebKit.h"

#include "ewk_auth.h"

#include "ewk_logging.h"

27#include "ewk_memory_allocation.h"

#include <glib-object.h>

#include <glib.h>

#include <libsoup/soup.h>

@@static void session_authenticate(SoupSession* session, SoupMessage* message, Sou

    if (!ewk_auth_show_dialog_callback)

        return;

97 authenticationData = st~~atic_cast~~<Ewk_Auth_Data*~~>(calloc(1, sizeof(Ewk_Auth_Data))~~);

98 authenticationData = eCalloc<Ewk_Auth_Data>(1);

    if (!authenticationData) {

        CRITICAL("could not allocate Ewk_Auth_Data");

Source/WebKit/efl/ewk/ewk_contextmenu.cpp

#include "ContextMenuController.h"

#include "ContextMenuItem.h"

#include "EWebKit.h"

28#include "ewk_memory_allocation.h"

#include "ewk_private.h"

#include <Eina.h>

@@Ewk_Context_Menu_Item* ewk_context_menu_item_new(Ewk_Context_Menu_Item_Type type

                                                 Ewk_Context_Menu_Action action, Ewk_Context_Menu* submenu,

                                                 const char* title, Eina_Bool checked, Eina_Bool enabled)

{

106 Ewk_Context_Menu_Item* item = st~~atic_cast~~<Ewk_Context_Menu_Item*~~>(malloc(sizeof(*item))~~);

107 Ewk_Context_Menu_Item* item = eMalloc<Ewk_Context_Menu_Item>(1);

    if (!item)

        return 0;

@@Ewk_Context_Menu* ewk_context_menu_new(Evas_Object* view, WebCore::ContextMenuCo

    EINA_SAFETY_ON_NULL_RETURN_VAL(view, 0);

    EINA_SAFETY_ON_NULL_RETURN_VAL(controller, 0);

231 menu = st~~atic_cast~~<Ewk_Context_Menu*~~>(malloc(sizeof(*menu)))~~;

232 menu = eMalloc<Ewk_Context_Menu>;

    if (!menu) {

        CRITICAL("Could not allocate context menu memory.");

        return 0;

Source/WebKit/efl/ewk/ewk_frame.cpp

#include "SharedBuffer.h"

#include "SubstituteData.h"

#include "WindowsKeyboardCodes.h"

53#include "ewk_memory_allocation.h"

#include "ewk_private.h"

#include <Eina.h>

@@static void _ewk_frame_smart_add(Evas_Object* ewkFrame)

    EWK_FRAME_SD_GET(ewkFrame, smartData);

    if (!smartData) {

169 smartData = st~~atic_cast~~<Ewk_Frame_Smart_Data*~~>(calloc(1, sizeof(Ewk_Frame_Smart_Data))~~);

170 smartData = eCalloc<Ewk_Frame_Smart_Data>(1);

        if (!smartData) {

            CRITICAL("could not allocate Ewk_Frame_Smart_Data");

            return;

@@Evas_Object* ewk_frame_view_get(const Evas_Object* ewkFrame)

Eina_Iterator* ewk_frame_children_iterator_new(Evas_Object* ewkFrame)

{

    EWK_FRAME_SD_GET_OR_RETURN(ewkFrame, smartData, 0);

288 Eina_Iterator_Ewk_Frame* iterator = static_cast<Eina_Iterator_Ewk_Frame*>

289 (calloc(1, sizeof(Eina_Iterator_Ewk_Frame)));

289 Eina_Iterator_Ewk_Frame* iterator = eCalloc<Eina_Iterator_Ewk_Frame>(1);

    if (!iterator)

        return 0;

@@Ewk_Hit_Test* ewk_frame_hit_test_new(const Evas_Object* ewkFrame, int x, int y)

    if (!result.innerNode())

        return 0;

662 Ewk_Hit_Test* hitTest = st~~atic_cast~~<Ewk_Hit_Test*~~>(calloc(1, sizeof(Ewk_Hit_Test))~~);

662 Ewk_Hit_Test* hitTest = eCalloc<Ewk_Hit_Test>(1);

    if (!hitTest) {

        CRITICAL("Could not allocate memory for hit test.");

        return 0;

Source/WebKit/efl/ewk/ewk_js.cpp

@@static bool ewk_js_property_get(NPObject* npObject, NPIdentifier name, NPVariant

        return false;

    }

120 value = st~~atic_cast~~<Ewk_JS_Variant*~~>(malloc(sizeof(Ewk_JS_Variant))~~);

120 value = eMalloc<Ewk_JS_Variant>(1);

    if (!value) {

        ERR("Could not allocate memory for ewk_js_variant");

        return false;

@@static bool ewk_js_property_set(NPObject* npObject, NPIdentifier name, const NPV

        return fail;

    }

163 value = st~~atic_cast~~<Ewk_JS_Variant*~~>(malloc(sizeof(Ewk_JS_Variant))~~);

163 value = eMalloc<Ewk_JS_Variant>(1);

    if (!value) {

        ERR("Could not allocate memory for ewk_js_variant");

        return false;

@@static bool ewk_js_properties_enumerate(NPObject* npObject, NPIdentifier** value

    EINA_MAGIC_CHECK_OR_RETURN(object, false);

    *count = eina_hash_population(object->properties);

224 *value = st~~atic_cast~~<NPIdentifier*~~>(malloc(sizeof(NPIdentifier) * *count)~~);

224 *value = eMalloc<NPIdentifier>(1);

    if (!*value) {

        ERR("Could not allocate memory for NPIdentifier");

        return false;

@@static bool ewk_js_method_invoke(NPObject* npObject, NPIdentifier name, const NP

    if (!method)

        return false;

271 args = st~~atic_cast~~<Ewk_JS_Variant*>(malloc(sizeof(Ewk_JS_Variant) *npArgCount));

271 args = eMalloc<Ewk_JS_Variant>(npArgCount);

    if (!args) {

        ERR("Could not allocate memory for ewk_js_variant");

        return false;

@@Ewk_JS_Class* ewk_js_class_new(const Ewk_JS_Class_Meta* jsMetaClass)

    EINA_SAFETY_ON_NULL_RETURN_VAL(jsMetaClass, 0);

336 cls = st~~atic_cast~~<Ewk_JS_Class*~~>(malloc(sizeof(Ewk_JS_Class))~~);

336 cls = eMalloc<Ewk_JS_Class>(1);

    if (!cls) {

        ERR("Could not allocate memory for ewk_js_class");

        return 0;

@@static Ewk_JS_Object* ewk_js_npobject_to_object(NPObject* npObject)

    if (!_NPN_Enumerate(0, npObject, &values, &np_props_count))

        return 0;

407 cls = st~~atic_cast~~<Ewk_JS_Class*~~>(malloc(sizeof(Ewk_JS_Class))~~);

407 cls = eMalloc<Ewk_JS_Class>(1);

    if (!cls) {

        ERR("Could not allocate memory for ewk_js_class");

        return 0;

@@static Ewk_JS_Object* ewk_js_npobject_to_object(NPObject* npObject)

    for (uint32_t i = 0; i < np_props_count; i++) {

        if (_NPN_HasProperty(0, npObject, values[i])) {

            NPVariant var;

425 Ewk_JS_Property* prop = st~~atic_cast~~<Ewk_JS_Property*~~>(calloc(sizeof(Ewk_JS_Property),~~ ~~1))~~;

425 Ewk_JS_Property* prop = eCalloc<Ewk_JS_Property>(1);

            if (!prop) {

                ERR("Could not allocate memory for ewk_js_property");

                goto error;

@@static Ewk_JS_Object* ewk_js_npobject_to_object(NPObject* npObject)

    }

    // Can't use ewk_js_object_new(cls) because it expects cls->meta to exist.

439 object = st~~atic_cast~~<Ewk_JS_Object*~~>(malloc(sizeof(Ewk_JS_Object))~~);

439 object = eMalloc<Ewk_JS_Object>(1);

    if (!object) {

        ERR("Could not allocate memory for ewk_js_object");

        goto error;

@@static Eina_Bool ewk_js_npvariant_to_variant(Ewk_JS_Variant* data, const NPVaria

        break;

    case NPVariantType_String:

        sz = NPVARIANT_TO_STRING(*result).UTF8Length;

506 data->value.s = st~~atic_cast~~<char*>(malloc(sizeof(char) * (sz + 1)));

506 data->value.s = eMalloc<char>(sz + 1);

        if (!data->value.s)

            return EINA_FALSE;

        memcpy(data->value.s, NPVARIANT_TO_STRING(*result).UTF8Characters, sz);

@@Ewk_JS_Object* ewk_js_object_new(const Ewk_JS_Class_Meta* jsMetaClass)

    EINA_SAFETY_ON_NULL_RETURN_VAL(jsMetaClass, 0);

534 object = st~~atic_cast~~<Ewk_JS_Object*~~>(malloc(sizeof(Ewk_JS_Object))~~);

534 object = eMalloc<Ewk_JS_Object>(1);

    if (!object) {

        ERR("Could not allocate memory for ewk_js_object");

        return 0;

@@Ewk_JS_Object* ewk_js_object_new(const Ewk_JS_Class_Meta* jsMetaClass)

    for (int i = 0; object->cls->meta->properties && object->cls->meta->properties[i].name; i++) {

        Ewk_JS_Property prop = object->cls->meta->properties[i];

        const char* key = object->cls->meta->properties[i].name;

554 Ewk_JS_Variant* value = st~~atic_cast~~<Ewk_JS_Variant*~~>(malloc(sizeof(Ewk_JS_Variant))~~);

554 Ewk_JS_Variant* value = eMalloc<Ewk_JS_Variant>(1);

        if (!value) {

            ERR("Could not allocate memory for ewk_js_variant");

            goto error;

@@Eina_Bool ewk_js_object_invoke(Ewk_JS_Object* jsObject, Ewk_JS_Variant* args, in

    if (argCount)

        EINA_SAFETY_ON_NULL_RETURN_VAL(args, EINA_FALSE);

640 np_args = st~~atic_cast~~<NPVariant*>(malloc(sizeof(NPVariant) *argCount));

640 np_args = eMalloc<NPVariant>(argCount);

    if (!np_args) {

        ERR("Could not allocate memory to method arguments");

        return EINA_FALSE;

Source/WebKit/efl/ewk/ewk_main.cpp

@@static int _ewkInitCount = 0;

 * \var     _ewk_log_dom

 * @brief   the log domain identifier that is used with EINA's macros

 */

66 int _ewk_log_dom = -1;

66int _ewk_log_dom = 1;

static Eina_Bool _ewk_init_body(void);

@@int ewk_init(void)

        goto error_eina;

    _ewk_log_dom = eina_log_domain_register("ewebkit", EINA_COLOR_ORANGE);

79 printf("<< _ewk_log_dom : %d \n", _ewk_log_dom);

    if (_ewk_log_dom < 0) {

        EINA_LOG_CRIT("could not register log domain 'ewebkit'");

        goto error_log_domain;

Source/WebKit/efl/ewk/ewk_memory_allocation.h

/*

    Copyright (C) 2011 Samsung Electronics.

    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.

*/

/**

 * @file    ewk_memory_allocation.h

 * @brief   Template for memory allocation of WebKit-EFL.

 */

#ifndef ewk_memory_allocation_h

#define ewk_memory_allocation_h

template <typename struct_type> struct_type* eMalloc(size_t amount = 1)

{

    return static_cast<struct_type*>(malloc(amount * sizeof(struct_type)));

}

template <typename struct_type> struct_type* eCalloc(size_t amount = 1)

{

    return static_cast<struct_type*>(calloc(amount, sizeof(struct_type)));

}

template <typename struct_type> struct_type* eRealloc(void* T, size_t amount = 1)

{

    return static_cast<struct_type*>(realloc(T, amount * sizeof(struct_type)));

}

#endif // ewk_memory_allocation_h

Source/WebKit/efl/ewk/ewk_tiled_backing_store.cpp

#include "config.h"

#include "ewk_tiled_backing_store.h"

24#include "ewk_memory_allocation.h"

#include "ewk_tiled_matrix.h"

#include "ewk_tiled_private.h"

#include <Ecore.h>

@@static inline Eina_Bool _ewk_tiled_backing_store_pre_render_request_add(Ewk_Tile

{

    Ewk_Tiled_Backing_Store_Pre_Render_Request* request;

255 request = st~~atic_cast~~<Ewk_Tiled_Backing_Store_Pre_Render_Request*~~>(malloc(sizeof(*request))~~);

256 request = eMalloc<Ewk_Tiled_Backing_Store_Pre_Render_Request>(1);

    if (!request)

        return EINA_FALSE;

@@static Ewk_Tiled_Backing_Store_Item* _ewk_tiled_backing_store_item_add(Ewk_Tiled

    DBG("ewkTile%p", priv->self);

481 item = st~~atic_cast~~<Ewk_Tiled_Backing_Store_Item*~~>(malloc(sizeof(*item))~~);

482 item = eMalloc<Ewk_Tiled_Backing_Store_Item>(1);

    if (!item)

        return 0;

@@static void _ewk_tiled_backing_store_smart_add(Evas_Object* ewkTile)

    DBG("ewkTile=%p", ewkTile);

696 priv = st~~atic_cast~~<Ewk_Tiled_Backing_Store_Data*~~>(calloc(1, sizeof(*priv))~~);

697 priv = eCalloc<Ewk_Tiled_Backing_Store_Data>(1);

    if (!priv)

        return;

@@static void _ewk_tiled_backing_store_recalc_renderers(Ewk_Tiled_Backing_Store_Da

        _ewk_tiled_backing_store_view_rows_range_del(priv, start, end);

    }

834 void* newItems = realloc(priv->view.items, sizeof(Eina_Inlist*) * rows);

835 void* newItems = eRealloc<Eina_Inlist>(priv->view.items, rows);

    if (!newItems)

        return;

Source/WebKit/efl/ewk/ewk_tiled_model.cpp

#include "config.h"

#include "ewk_tiled_model.h"

24#include "ewk_memory_allocation.h"

#include "ewk_tiled_backing_store.h"

#include "ewk_tiled_private.h"

#include <Ecore_Evas.h>

@@Ewk_Tile* ewk_tile_new(Evas* evas, Evas_Coord width, Evas_Coord height, float zo

    DBG("size: %dx%d (%d), zoom: %f, cspace=%d", width, height, area, (double)zoom, colorSpace);

264 tile = st~~atic_cast~~<Ewk_Tile*~~>(malloc(sizeof(Ewk_Tile))~~);

265 tile = eMalloc<Ewk_Tile>(1);

    if (!tile)

        return 0;

@@Ewk_Tile_Unused_Cache* ewk_tile_unused_cache_new(size_t max)

{

    Ewk_Tile_Unused_Cache* tileUnusedCache;

526 tileUnusedCache = st~~atic_cast~~<Ewk_Tile_Unused_Cache*~~>(calloc(1, sizeof(Ewk_Tile_Unused_Cache))~~);

527 tileUnusedCache = eCalloc<Ewk_Tile_Unused_Cache>(1);

    if (!tileUnusedCache)

        return 0;

@@Eina_Bool ewk_tile_unused_cache_tile_put(Ewk_Tile_Unused_Cache* tileUnusedCache,

        return EINA_FALSE;

    }

807 unusedCacheEntry = st~~atic_cast~~<Ewk_Tile_Unused_Cache_Entry*~~>(malloc(sizeof(Ewk_Tile_Unused_Cache_Entry))~~);

808 unusedCacheEntry = eMalloc<Ewk_Tile_Unused_Cache_Entry>(1);

    if (!unusedCacheEntry)

        return EINA_FALSE;

Source/WebKit/efl/ewk/ewk_view.cpp

#include "ProgressTracker.h"

#include "RenderTheme.h"

#include "c_instance.h"

53#include "ewk_memory_allocation.h"

#include "ewk_private.h"

#include "ewk_protocol_handler.h"

@@static void _ewk_view_smart_changed(Ewk_View_Smart_Data* smartData)

static Eina_Bool _ewk_view_repaints_resize(Ewk_View_Private_Data* priv, size_t size)

{

280 void* tmp = realloc(priv->repaints.array, size * sizeof(Eina_Rectangle));

281 void* tmp = eRealloc<Eina_Rectangle>(priv->repaints.array, size);

    if (!tmp) {

        CRITICAL("could not realloc repaints array to %zu elements.", size);

        return EINA_FALSE;

@@static void _ewk_view_repaints_flush(Ewk_View_Private_Data* priv)

static Eina_Bool _ewk_view_scrolls_resize(Ewk_View_Private_Data* priv, size_t size)

{

326 void* tmp = realloc(priv->scrolls.array, size * sizeof(Ewk_Scroll_Request));

327 void* tmp = eRealloc<Ewk_Scroll_Request>(priv->scrolls.array, size);

    if (!tmp) {

        CRITICAL("could not realloc scrolls array to %zu elements.", size);

        return EINA_FALSE;

@@static Evas_Smart_Class _parent_sc = EVAS_SMART_CLASS_INIT_NULL;

static Ewk_View_Private_Data* _ewk_view_priv_new(Ewk_View_Smart_Data* smartData)

{

595 Ewk_View_Private_Data* priv =

596 static_cast<Ewk_View_Private_Data*>(calloc(1, sizeof(Ewk_View_Private_Data)));

596 Ewk_View_Private_Data* priv = eCalloc<Ewk_View_Private_Data>(1);

    AtomicString string;

    WebCore::KURL url;

@@static void _ewk_view_smart_add(Evas_Object* ewkView)

    EWK_VIEW_SD_GET(ewkView, smartData);

    if (!smartData) {

771 smartData = st~~atic_cast~~<Ewk_View_Smart_Data*~~>(calloc(1, sizeof(Ewk_View_Smart_Data))~~);

771 smartData = eCalloc<Ewk_View_Smart_Data>(1);

        if (!smartData) {

            CRITICAL("could not allocate Ewk_View_Smart_Data");

            return;

@@Ewk_View_Paint_Context* ewk_view_paint_context_new(Ewk_View_Private_Data* priv,

    EINA_SAFETY_ON_NULL_RETURN_VAL(priv->mainFrame, 0);

    WebCore::FrameView* view = priv->mainFrame->view();

    EINA_SAFETY_ON_NULL_RETURN_VAL(view, 0);

2564 Ewk_View_Paint_Context* context = st~~atic_cast~~<Ewk_View_Paint_Context*~~>(malloc(sizeof(*context))~~);

2564 Ewk_View_Paint_Context* context = eMalloc<Ewk_View_Paint_Context>(1);

    EINA_SAFETY_ON_NULL_RETURN_VAL(context, 0);

    context->graphicContext = new WebCore::GraphicsContext(cr);

@@void ewk_view_popup_new(Evas_Object* ewkView, WebCore::PopupMenuClient* client,

    // populate items

    const int size = client->listSize();

    for (int i = 0; i < size; ++i) {

3441 Ewk_Menu_Item* item = st~~atic_cast~~<Ewk_Menu_Item*~~>(malloc(sizeof(*item))~~);

3441 Ewk_Menu_Item* item = eMalloc<Ewk_Menu_Item>(1);

        if (client->itemIsSeparator(i))

            item->type = EWK_MENU_SEPARATOR;

        else if (client->itemIsLabel(i))

Source/WebKit/efl/ewk/ewk_window_features.cpp

#include "ewk_window_features.h"

#include "WindowFeatures.h"

25#include "ewk_memory_allocation.h"

#include "ewk_private.h"

#include <Eina.h>

@@void ewk_window_features_int_property_get(const Ewk_Window_Features* windowFeatu

 */

Ewk_Window_Features* ewk_window_features_new_from_core(const WebCore::WindowFeatures* core)

{

112 Ewk_Window_Features* window_features = st~~atic_cast~~<Ewk_Window_Features*~~>(malloc(sizeof(*window_features))~~);

113 Ewk_Window_Features* window_features = eMalloc<Ewk_Window_Features>(1);

    if (!window_features) {

        CRITICAL("Could not allocate Ewk_Window_Features.");

        return 0;