44500 2010-08-24 01:40:24 -0700 [EFL] API for Dump Render Tree application 2011-09-15 00:05:25 -0700 1 1 1 Unclassified WebKit WebKit EFL 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Enhancement --- 1 k.czech webkit-unassigned abarth antognolli+webkit donggwan.kim eric gyuyoung.kim leandro lucas.de.marchi rakuco sangseok.lim tonikitoo oldest_to_newest 268399 0 k.czech 2010-08-24 01:40:24 -0700 New API that are used by Dump Render Tree application 268413 1 65240 k.czech 2010-08-24 01:53:59 -0700 Created attachment 65240 Enhancements for WebKit-EFL port, that are used by Dump Render Tree application 268437 2 gyuyoung.kim 2010-08-24 02:23:58 -0700 Hello Krzysztof, I think you need to fill doxyzen for new methods. 268492 3 65258 k.czech 2010-08-24 05:28:04 -0700 Created attachment 65258 Enhancements for WebKit-EFL port, that are used by Dump Render Tree application 269450 4 lucas.de.marchi 2010-08-25 12:58:24 -0700 Before reviewing, just a side note: when you submit patches, clear the flags on previous patch and mark it as obsolete (if it's meant to replace the previous one). If you use WebKitTools/Scripts/webkit-patch to send patches, this will be done automatically for you and your life will be easier ;-) 269739 5 tonikitoo 2010-08-25 23:29:28 -0700 First, I would like to hear from the other EFL guys how the additions like, API-wise. 269891 6 lucas.de.marchi 2010-08-26 08:16:47 -0700 (In reply to comment #5) > First, I would like to hear from the other EFL guys how the additions like, API-wise. I like it, but there are some problems that I'll address in my review (as for example the function names) 269946 7 65258 lucas.de.marchi 2010-08-26 10:31:15 -0700 Comment on attachment 65258 Enhancements for WebKit-EFL port, that are used by Dump Render Tree application > diff --git a/WebKit/efl/ChangeLog b/WebKit/efl/ChangeLog > index de65885..8ea8baa 100644 > --- a/WebKit/efl/ChangeLog > +++ b/WebKit/efl/ChangeLog > @@ -1,3 +1,36 @@ > +2010-08-24 Krzysztof Czech <k.czech@samsung.com> > + > + Reviewed by NOBODY (OOPS!). > + > + [EFL] WebKit API for Dump Render Tree application > + https://bugs.webkit.org/show_bug.cgi?id=44500 > + > + Enhancements for WebKit-EFL port, that are used > + by Dump Render Tree application > + > + * ewk/ewk_frame.cpp: > + (ewk_frame_get_inner_text): > + (ewk_frame_get_dump_render_tree): > + (ewk_frame_get_children): > + (ewk_frame_page_number_for_element_by_id): > + (ewk_frame_page_number_of_pages): > + (ewk_frame_counter_value_for_element_by_id): > + (ewk_frame_web_layout): > + (ewk_frame_pause_animation): > + (ewk_frame_pause_transition): > + (ewk_frame_pause_svg_animation): > + (ewk_frame_number_of_active_animations): > + (ewk_frame_get_response_mime_type): > + (ewk_gc_collect_javascript_objects): > + (ewk_gc_collect_javascript_objects_on_alternate_thread): > + (ewk_gc_count_javascript_objects): > + (ewk_worker_thread_count): We use the verb as the last word in function names (with a few exceptions). Look in other functions in this same file; for example: It's ewk_frame_inner_text_get, not ewk_frame_inner_text_get > + * ewk/ewk_frame.h: > + * ewk/ewk_view.cpp: > + (ewk_view_load_started): > + (ewk_view_window_object_cleared): These are ok. > diff --git a/WebKit/efl/ewk/ewk_frame.cpp b/WebKit/efl/ewk/ewk_frame.cpp > index 296c261..d86692c 100644 > --- a/WebKit/efl/ewk/ewk_frame.cpp > +++ b/WebKit/efl/ewk/ewk_frame.cpp > @@ -1950,3 +1959,272 @@ WTF::PassRefPtr<WebCore::Widget> ewk_frame_plugin_create(Evas_Object* o, const W > { > return 0; > } > +/** > + * Dumps webpage's layout as a plain text > + * > + * @param o Frame > + * > + * @return returns textual representation of dumped page > +*/ > +char* ewk_frame_get_inner_text(Evas_Object* o) const Evas_Object* o > +{ > + EWK_FRAME_SD_GET_OR_RETURN(o, sd, 0); > + > + WebCore::FrameView* frameView = sd->frame->view(); > + if (frameView && frameView->layoutPending()) > + frameView->layout(); > + > + WebCore::Element* docElement = sd->frame->document()->documentElement(); > + WTF::String innerText = docElement->innerText(); > + > + return strdup(innerText.utf8().data()); When you return a struct that you dynamically allocate or, as in this case, strdup, you have to document it in doxygen. For example, in this file ewk_frame_selection_get() document it as: @return newly allocated string or @c NULL if nothing is selected or failure. Otherwise user would have to check the implementation in order to know it must free the returned var. > +} > +/** > + * Dumps webpage's layout as a tree representation > + * > + * @param o Frame > + * > + * @return returns textual representation of dumped page > + */ > +char* ewk_frame_get_dump_render_tree(Evas_Object* o) cont > +{ > + EWK_FRAME_SD_GET_OR_RETURN(o, sd, 0); > + > + WebCore::FrameView* frameView = sd->frame->view(); > + if (frameView && frameView->layoutPending()) > + frameView->layout(); > + > + WTF::String renderText = WebCore::externalRepresentation(sd->frame); > + > + return strdup(renderText.utf8().data()); same as above. > +} > +/** > + * Returns child frames if exists > + * > + * @param o Frame > + * > + * @return returns list of child frames, or @c NULL empty list document the type (Evas_Object) and that the user must free the list nodes (and *not* data) after use. > +/** > + * Returns number of page element > + * > + * @param o Frame > + * @param element_id element id > + * @param pageWidth page width > + * @param pageHeight page height > + * > + * @return number of page element or @c 0 > + */ > +int ewk_frame_page_number_for_element_by_id(Evas_Object* o, char* element_id, float pageWidth, float pageHeight) const Evas_Object*, const char* > +/** > + * Returns number of pages > + * > + * @param o Frame > + * @param pageWidth page width > + * @param pageHeight page height > + * > + * @return returns number of pages > + */ > +int ewk_frame_page_number_of_pages(Evas_Object* o, float pageWidth, float pageHeight) const.. > +/** > + * Returns counter value for element > + * > + * @param o Frame > + * @param element_id element id > + * > + * @return returns textual value or @c NULL > + */ > +char* ewk_frame_counter_value_for_element_by_id(Evas_Object* o, char* element_id) consts + document strdup. > +/** > + * Returns true if frame layout > + * > + * @param o Frame > + * > + * @return return @c TRUE if frame's layout, or @c FALSE if something went wrong > + */ > +Eina_Bool ewk_frame_web_layout(Evas_Object* o) I didn't get what this function does. Are you sure you meant "frame *is* layout" ? > +{ > + EWK_FRAME_SD_GET_OR_RETURN(o, sd, 0); > + > + WebCore::FrameView* frameView = sd->frame->view(); > + > + if (!frameView) > + return false; You are just returning false if frame has a view and true otherwise. > +/** > + * Set pause on frame's animation > + * > + * @param name name > + * @param element_id element id > + * @double time time > + * > + * @return returns @c TRUE pause is set, @c FALSE pause is not set > + */ > +Eina_Bool ewk_frame_pause_animation(Evas_Object* o, const char* name, const char* elementId, double time) > +{ > + EWK_FRAME_SD_GET_OR_RETURN(o, sd, 0); > + > + WebCore::Element* element = sd->frame->document()->getElementById(WTF::AtomicString(elementId)); > + if (!element || !element->renderer()) > + return false; > + > + return sd->frame->animation()->pauseAnimationAtTime(element->renderer(), WTF::AtomicString(name), time); > +} Missing space between functions here. > +/** > + * Pause transition > + * > + * @param o Frame > + * @param name > + * @param elementId > + * @param time > + * > + * @return returns @c TRUE pause is set, or @c FALSE pause is not set Also in other doxygens: we don't need "@return returns", use just 1 > + */ > +Eina_Bool ewk_frame_pause_transition(Evas_Object* o, const char* name, const char* elementId, double time) > +{ > + EWK_FRAME_SD_GET_OR_RETURN(o, sd, 0); > + > + WebCore::Element* element = sd->frame->document()->getElementById(WTF::AtomicString(elementId)); > + if (!element || !element->renderer()) > + return false; > + > + return sd->frame->animation()->pauseTransitionAtTime(element->renderer(), WTF::AtomicString(name), time); > +} > +/** > + * Pause svg animation > + * > + * @param o Frame > + * @param animationId > + * @param elementId > + * @param time > + * > + * @return returns @c TRUE pause is set or @c FALSE pause is not set > + */ > +Eina_Bool ewk_frame_pause_svg_animation(Evas_Object* o, const char* animationId, const char* elementId, double time) > +{ > + EWK_FRAME_SD_GET_OR_RETURN(o, sd, 0); > + > + WebCore::Document* document = sd->frame->document(); > + if (!document && !document->svgExtensions()) > + return false; > + > + WebCore::Element* element = document->getElementById(WTF::AtomicString(animationId)); > + if (!element && !WebCore::SVGSMILElement::isSMILElement(element)) > + return false; > + > + return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<WebCore::SVGSMILElement*>(element), time); > +} > +/** > + * Returns number of active animations > + * > + * @param o Frame > + * > + * @return returns number of active animations, or @c 0 if something went wrong > + */ > +unsigned ewk_frame_number_of_active_animations(Evas_Object* o) > +{ > + EWK_FRAME_SD_GET_OR_RETURN(o, sd, 0); > + > + WebCore::AnimationController* aController = sd->frame->animation(); > + if (!aController) > + return false; > + > + return aController->numberOfActiveAnimations(); > +} > +/** > + * Gets response mi type typo here. > + * > + * @param o Frame > + * > + * @return returns mime type or @c NULL if something went wrong > + */ > +char* ewk_frame_get_response_mime_type(Evas_Object* o) const + doc about strdup [...] > + return strdup(mimeType.utf8().data()); > + > + return 0; > +} missing blank line > +/** > + * Collec javascript objects > + */ > +void ewk_gc_collect_javascript_objects() > +{ > + WebCore::gcController().garbageCollectNow(); > +} > +/** > + * Collect javascript object on alternate thread > + * > + * @param waitUntilDone > + */ > +void ewk_gc_collect_javascript_objects_on_alternate_thread(Eina_Bool waitUntilDone) https://bugs.webkit.org/attachment.cgi?id=65258 > diff --git a/WebKit/efl/ewk/ewk_view.cpp b/WebKit/efl/ewk/ewk_view.cpp > index 7a98bac..c55c2d1 100644 > --- a/WebKit/efl/ewk/ewk_view.cpp > +++ b/WebKit/efl/ewk/ewk_view.cpp > @@ -3139,6 +3139,18 @@ void ewk_view_load_started(Evas_Object* o) > { > DBG("o=%p", o); > evas_object_smart_callback_call(o, "load,started", 0); > + > + ewk_view_window_object_cleared(o); Why do you need this here? I think this is part of another patch, not this one. > +} > + > +/** > + * @param o View > + * Used by layout tests to initialize some JavaScript properties > + * Emits,signal: "window,object,cleared" woth no parameters] typo > + */ > +void ewk_view_window_object_cleared(Evas_Object* o) > +{ > + evas_object_smart_callback_call(o, "window,object,cleared", 0); It's only used on the same file. If you really want this callback, you could put this function in ewk_view_load_started(), though I'm not sure if this is the right place. > } > > /** > diff --git a/WebKit/efl/ewk/ewk_view.h b/WebKit/efl/ewk/ewk_view.h > index 8dd6178..aa07926 100644 > --- a/WebKit/efl/ewk/ewk_view.h > +++ b/WebKit/efl/ewk/ewk_view.h > @@ -480,6 +480,8 @@ EAPI float ewk_view_zoom_range_max_get(Evas_Object* o); > EAPI void ewk_view_user_scalable_set(Evas_Object* o, Eina_Bool user_scalable); > EAPI Eina_Bool ewk_view_user_scalable_get(Evas_Object* o); > > +EAPI void ewk_view_window_object_cleared(Evas_Object* o); Why is this an exported function? 271753 8 65258 abarth 2010-08-30 16:39:38 -0700 Comment on attachment 65258 Enhancements for WebKit-EFL port, that are used by Dump Render Tree application Please address the informal review comments above and submit a new patch. 286067 9 gyuyoung.kim 2010-09-27 22:30:10 -0700 Hello Krzysztof, I wonder when you report new patch again. 301084 10 k.czech 2010-10-28 08:26:26 -0700 > + */ > +void ewk_view_window_object_cleared(Evas_Object* o) > +{ > + evas_object_smart_callback_call(o, "window,object,cleared", 0); Yes, this callback could be moved to the ewk_view_load_started(). > +EAPI void ewk_view_window_object_cleared(Evas_Object* o); Yes, this should not be exported. This function calls only one callback so I moved its body to the ewk_view_load_started(). Previously this function was called from ewk_view_load_started(). 385481 11 gyuyoung.kim 2011-04-13 20:42:37 -0700 EFL port should have DRT for LayoutTest. So, we should land this patch. Krzysztof, if you are busy, I think it is better to make this patch by other developer. How do you think about it ? 385568 12 k.czech 2011-04-14 00:33:21 -0700 (In reply to comment #11) > EFL port should have DRT for LayoutTest. So, we should land this patch. Krzysztof, if you are busy, I think it is better to make this patch by other developer. How do you think about it ? Hello Gyuyoung, Indeed I am pretty busy, but recently I have started updating this patch. I am in a middle of a work, so as soon as I finish it, I will provide a patch. 385571 13 gyuyoung.kim 2011-04-14 00:40:41 -0700 (In reply to comment #12) > (In reply to comment #11) > > EFL port should have DRT for LayoutTest. So, we should land this patch. Krzysztof, if you are busy, I think it is better to make this patch by other developer. How do you think about it ? > > Hello Gyuyoung, > Indeed I am pretty busy, but recently I have started updating this patch. I am in a middle of a work, so as soon as I finish it, I will provide a patch. Good. I finish to prepare to buy servers for EFL layout test. If DRT is run on EFL, I will start to setup EFL layout test server. Please hurry up. :-) 467109 14 leandro 2011-09-14 10:24:48 -0700 Closing bug as FIXED: feature is being implemented in a different way. 65240 2010-08-24 01:53:59 -0700 2010-08-25 23:27:53 -0700 Enhancements for WebKit-EFL port, that are used by Dump Render Tree application webkit_efl_ewk.patch text/plain 11493 k.czech ZGlmZiAtLWdpdCBhL1dlYktpdC9lZmwvQ2hhbmdlTG9nIGIvV2ViS2l0L2VmbC9DaGFuZ2VMb2cK aW5kZXggZGU2NTg4NS4uYWU3NWFiNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2VmbC9DaGFuZ2VMb2cK KysrIGIvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAxMC0wOC0yNCAg S3J6eXN6dG9mIEN6ZWNoICA8ay5jemVjaEBzYW1zdW5nLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbRUZMXSBBUEkgZm9yIER1bXAgUmVuZGVy IFRyZWUgYXBwbGljYXRpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ0NTAwCisKKyAgICAgICAgRW5oYW5jZW1lbnRzIGZvciBXZWJLaXQtRUZMIHBv cnQsIHRoYXQgYXJlIHVzZWQKKyAgICAgICAgYnkgRHVtcCBSZW5kZXIgVHJlZSBhcHBsaWNhdGlv biAKKworICAgICAgICAqIGV3ay9ld2tfZnJhbWUuY3BwOgorICAgICAgICAoZXdrX2ZyYW1lX2dl dF9pbm5lcl90ZXh0KToKKyAgICAgICAgKGV3a19mcmFtZV9nZXRfZHVtcF9yZW5kZXJfdHJlZSk6 CisgICAgICAgIChld2tfZnJhbWVfZ2V0X2NoaWxkcmVuKToKKyAgICAgICAgKGV3a19mcmFtZV9w YWdlX251bWJlcl9mb3JfZWxlbWVudF9ieV9pZCk6CisgICAgICAgIChld2tfZnJhbWVfcGFnZV9u dW1iZXJfb2ZfcGFnZXMpOgorICAgICAgICAoZXdrX2ZyYW1lX2NvdW50ZXJfdmFsdWVfZm9yX2Vs ZW1lbnRfYnlfaWQpOgorICAgICAgICAoZXdrX2ZyYW1lX3dlYl9sYXlvdXQpOgorICAgICAgICAo ZXdrX2ZyYW1lX3BhdXNlX2FuaW1hdGlvbik6CisgICAgICAgIChld2tfZnJhbWVfcGF1c2VfdHJh bnNpdGlvbik6CisgICAgICAgIChld2tfZnJhbWVfcGF1c2Vfc3ZnX2FuaW1hdGlvbik6CisgICAg ICAgIChld2tfZnJhbWVfbnVtYmVyX29mX2FjdGl2ZV9hbmltYXRpb25zKToKKyAgICAgICAgKGV3 a19mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKToKKyAgICAgICAgKGV3a19nY19jb2xsZWN0 X2phdmFzY3JpcHRfb2JqZWN0cyk6CisgICAgICAgIChld2tfZ2NfY29sbGVjdF9qYXZhc2NyaXB0 X29iamVjdHNfb25fYWx0ZXJuYXRlX3RocmVhZCk6CisgICAgICAgIChld2tfZ2NfY291bnRfamF2 YXNjcmlwdF9vYmplY3RzKToKKyAgICAgICAgKGV3a193b3JrZXJfdGhyZWFkX2NvdW50KToKKyAg ICAgICAgKiBld2svZXdrX2ZyYW1lLmg6CisgICAgICAgICogZXdrL2V3a192aWV3LmNwcDoKKyAg ICAgICAgKGV3a192aWV3X2xvYWRfc3RhcnRlZCk6CisgICAgICAgIChld2tfdmlld193aW5kb3df b2JqZWN0X2NsZWFyZWQpOgorICAgICAgICAqIGV3ay9ld2tfdmlldy5oOgorCiAyMDEwLTA4LTE1 ICBHeXV5b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgQW50b25pbyBHb21lcy4KZGlmZiAtLWdpdCBhL1dlYktpdC9lZmwvZXdrL2V3a19m cmFtZS5jcHAgYi9XZWJLaXQvZWZsL2V3ay9ld2tfZnJhbWUuY3BwCmluZGV4IDI5NmMyNjEuLjVj YTg5MWQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9lZmwvZXdrL2V3a19mcmFtZS5jcHAKKysrIGIvV2Vi S2l0L2VmbC9ld2svZXdrX2ZyYW1lLmNwcApAQCAtMjQsMzQgKzI0LDQzIEBACiAjaW5jbHVkZSAi Y29uZmlnLmgiCiAjaW5jbHVkZSAiZXdrX2ZyYW1lLmgiCiAKKyNpbmNsdWRlICJBbmltYXRpb25D b250cm9sbGVyLmgiCisjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIuaCIKICNpbmNsdWRlICJFV2Vi S2l0LmgiCiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCisjaW5jbHVkZSAiRmxvYXRTaXplLmgi CiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGll bnRFZmwuaCIKICNpbmNsdWRlICJGcmFtZVRyZWUuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIK KyNpbmNsdWRlICJHQ0NvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJIVE1MUGx1Z0luRWxlbWVudC5o IgogI2luY2x1ZGUgIkhpc3RvcnlJdGVtLmgiCiAjaW5jbHVkZSAiSGl0VGVzdFJlc3VsdC5oIgor I2luY2x1ZGUgIkpTRE9NV2luZG93LmgiCiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBs YXRmb3JtS2V5Ym9hcmRFdmVudC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtTW91c2VFdmVudC5oIgog I2luY2x1ZGUgIlBsYXRmb3JtV2hlZWxFdmVudC5oIgorI2luY2x1ZGUgIlByaW50Q29udGV4dC5o IgogI2luY2x1ZGUgIlByb2dyZXNzVHJhY2tlci5oIgogI2luY2x1ZGUgIlJlZlB0ci5oIgogI2lu Y2x1ZGUgIlJlbmRlclRoZW1lLmgiCisjaW5jbHVkZSAiUmVuZGVyVHJlZUFzVGV4dC5oIgogI2lu Y2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgogI2luY2x1ZGUgIlNjcmlwdFZhbHVlLmgiCiAjaW5j bHVkZSAiU2hhcmVkQnVmZmVyLmgiCiAjaW5jbHVkZSAiU3Vic3RpdHV0ZURhdGEuaCIKLSNpbmNs dWRlICJab29tTW9kZS5oIgogI2luY2x1ZGUgIldpbmRvd3NLZXlib2FyZENvZGVzLmgiCisjaW5j bHVkZSAiWm9vbU1vZGUuaCIKKyNpbmNsdWRlICJhbmltYXRpb24vU1ZHU01JTEVsZW1lbnQuaCIK ICNpbmNsdWRlICJld2tfcHJpdmF0ZS5oIgotI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJpbmcuaD4K KyNpbmNsdWRlICJ3b3JrZXJzL1dvcmtlclRocmVhZC5oIgogCiAjaW5jbHVkZSA8RWluYS5oPgog I2luY2x1ZGUgPEV2YXMuaD4KICNpbmNsdWRlIDxlaW5hX3NhZmV0eV9jaGVja3MuaD4KKyNpbmNs dWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CiAKIHN0YXRpYyBjb25zdCBjaGFyIEVXS19GUkFNRV9U WVBFX1NUUltdID0gIkVXS19GcmFtZSI7CiAKQEAgLTE5NTAsMyArMTk1OSwyMTcgQEAgV1RGOjpQ YXNzUmVmUHRyPFdlYkNvcmU6OldpZGdldD4gZXdrX2ZyYW1lX3BsdWdpbl9jcmVhdGUoRXZhc19P YmplY3QqIG8sIGNvbnN0IFcKIHsKICAgICByZXR1cm4gMDsKIH0KKworY2hhciogZXdrX2ZyYW1l X2dldF9pbm5lcl90ZXh0KEV2YXNfT2JqZWN0KiBvKQoreworICAgIEVXS19GUkFNRV9TRF9HRVRf T1JfUkVUVVJOKG8sIHNkLCAwKTsKKworICAgIFdlYkNvcmU6OkZyYW1lVmlldyogZnJhbWVWaWV3 ID0gc2QtPmZyYW1lLT52aWV3KCk7CisgICAgaWYgKGZyYW1lVmlldyAmJiBmcmFtZVZpZXctPmxh eW91dFBlbmRpbmcoKSkKKyAgICAgICAgZnJhbWVWaWV3LT5sYXlvdXQoKTsKKworICAgIFdlYkNv cmU6OkVsZW1lbnQqIGRvY0VsZW1lbnQgPSBzZC0+ZnJhbWUtPmRvY3VtZW50KCktPmRvY3VtZW50 RWxlbWVudCgpOworICAgIFdURjo6U3RyaW5nIGlubmVyVGV4dCA9IGRvY0VsZW1lbnQtPmlubmVy VGV4dCgpOworCisgICAgcmV0dXJuIHN0cmR1cChpbm5lclRleHQudXRmOCgpLmRhdGEoKSk7Cit9 CisvKioKKyAqCisgKgorICovCitjaGFyKiBld2tfZnJhbWVfZ2V0X2R1bXBfcmVuZGVyX3RyZWUo RXZhc19PYmplY3QqIG8pCit7CisgICAgRVdLX0ZSQU1FX1NEX0dFVF9PUl9SRVRVUk4obywgc2Qs IDApOworCisgICAgV2ViQ29yZTo6RnJhbWVWaWV3KiBmcmFtZVZpZXcgPSBzZC0+ZnJhbWUtPnZp ZXcoKTsKKyAgICBpZiAoZnJhbWVWaWV3ICYmIGZyYW1lVmlldy0+bGF5b3V0UGVuZGluZygpKQor ICAgICAgICBmcmFtZVZpZXctPmxheW91dCgpOworCisgICAgV1RGOjpTdHJpbmcgcmVuZGVyVGV4 dCA9IFdlYkNvcmU6OmV4dGVybmFsUmVwcmVzZW50YXRpb24oc2QtPmZyYW1lKTsKKworICAgIHJl dHVybiBzdHJkdXAocmVuZGVyVGV4dC51dGY4KCkuZGF0YSgpKTsKK30KKy8qKgorICoKKyAqCisg Ki8KK0VpbmFfTGlzdCogZXdrX2ZyYW1lX2dldF9jaGlsZHJlbihFdmFzX09iamVjdCogbykKK3sK KyAgICBFV0tfRlJBTUVfU0RfR0VUX09SX1JFVFVSTihvLCBzZCwgMCk7CisKKyAgICBFaW5hX0xp c3QqIGNoaWxkRnJhbWVzID0gMDsKKworICAgIGZvciAodW5zaWduZWQgaW5kZXggPSAwOyBpbmRl eCA8IHNkLT5mcmFtZS0+dHJlZSgpLT5jaGlsZENvdW50KCk7IGluZGV4KyspIHsKKyAgICAgICAg V2ViQ29yZTo6RnJhbWUqIGNoaWxkRnJhbWUgPSBzZC0+ZnJhbWUtPnRyZWUoKS0+Y2hpbGQoaW5k ZXgpOworICAgICAgICBXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudEVmbCogY2xpZW50ID0gc3Rh dGljX2Nhc3Q8V2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRFZmwqPihjaGlsZEZyYW1lLT5sb2Fk ZXIoKS0+Y2xpZW50KCkpOworICAgICAgICBpZiAoIWNsaWVudCkKKyAgICAgICAgICAgIGNvbnRp bnVlOworICAgICAgICBjaGlsZEZyYW1lcyA9IGVpbmFfbGlzdF9hcHBlbmQoY2hpbGRGcmFtZXMs IGNsaWVudC0+d2ViRnJhbWUoKSk7CisgICAgfQorCisgICAgcmV0dXJuIGNoaWxkRnJhbWVzOwor fQorLyoqCisgKgorICoKKyAqLworaW50IGV3a19mcmFtZV9wYWdlX251bWJlcl9mb3JfZWxlbWVu dF9ieV9pZChFdmFzX09iamVjdCogbywgY2hhciogZWxlbWVudF9pZCwgZmxvYXQgcGFnZVdpZHRo LCBmbG9hdCBwYWdlSGVpZ2h0KQoreworICAgIEVXS19GUkFNRV9TRF9HRVRfT1JfUkVUVVJOKG8s IHNkLCAwKTsKKyAgICBXZWJDb3JlOjpFbGVtZW50KiBlbGVtZW50ID0gc2QtPmZyYW1lLT5kb2N1 bWVudCgpLT5nZXRFbGVtZW50QnlJZChXVEY6OkF0b21pY1N0cmluZyhlbGVtZW50X2lkKSk7Cisg ICAgaWYgKCFlbGVtZW50KQorICAgICAgICByZXR1cm4gLTE7CisKKyAgICByZXR1cm4gV2ViQ29y ZTo6UHJpbnRDb250ZXh0OjpwYWdlTnVtYmVyRm9yRWxlbWVudChlbGVtZW50LCBXZWJDb3JlOjpG bG9hdFNpemUocGFnZVdpZHRoLCBwYWdlSGVpZ2h0KSk7Cit9CisvKioKKyAqCisgKgorICovCitp bnQgZXdrX2ZyYW1lX3BhZ2VfbnVtYmVyX29mX3BhZ2VzKEV2YXNfT2JqZWN0KiBvLCBmbG9hdCBw YWdlV2lkdGgsIGZsb2F0IHBhZ2VIZWlnaHQpCit7CisgICAgRVdLX0ZSQU1FX1NEX0dFVF9PUl9S RVRVUk4obywgc2QsIDApOworCisgICAgcmV0dXJuIFdlYkNvcmU6OlByaW50Q29udGV4dDo6bnVt YmVyT2ZQYWdlcyhzZC0+ZnJhbWUsIFdlYkNvcmU6OkZsb2F0U2l6ZShwYWdlV2lkdGgsIHBhZ2VI ZWlnaHQpKTsKK30KKy8qKgorICoKKyAqIAorICovCitjaGFyKiBld2tfZnJhbWVfY291bnRlcl92 YWx1ZV9mb3JfZWxlbWVudF9ieV9pZChFdmFzX09iamVjdCogbywgY2hhciogZWxlbWVudF9pZCkK K3sKKyAgICBFV0tfRlJBTUVfU0RfR0VUX09SX1JFVFVSTihvLCBzZCwgMCk7CisKKyAgICBXZWJD b3JlOjpFbGVtZW50KiBlbGVtZW50ID0gc2QtPmZyYW1lLT5kb2N1bWVudCgpLT5nZXRFbGVtZW50 QnlJZChXVEY6OkF0b21pY1N0cmluZyhlbGVtZW50X2lkKSk7CisgICAgaWYgKCFlbGVtZW50KQor ICAgICAgICByZXR1cm4gMDsKKworICAgIFdURjo6U3RyaW5nIGNvdW50ZXJWYWx1ZSA9IFdlYkNv cmU6OmNvdW50ZXJWYWx1ZUZvckVsZW1lbnQoZWxlbWVudCk7CisgICAgcmV0dXJuIHN0cmR1cChj b3VudGVyVmFsdWUudXRmOCgpLmRhdGEoKSk7Cit9CisvKioKKyAqCisgKgorICovCitFaW5hX0Jv b2wgZXdrX2ZyYW1lX3dlYl9sYXlvdXQoRXZhc19PYmplY3QqIG8pCit7CisgICAgRVdLX0ZSQU1F X1NEX0dFVF9PUl9SRVRVUk4obywgc2QsIDApOworCisgICAgV2ViQ29yZTo6RnJhbWVWaWV3KiBm cmFtZVZpZXcgPSBzZC0+ZnJhbWUtPnZpZXcoKTsKKworICAgIGlmICghZnJhbWVWaWV3KQorICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBmcmFtZVZpZXctPmxheW91dCgpOworICAgIHJldHVy biB0cnVlOworfQorLyoqCisgKgorICoKKyAqLworRWluYV9Cb29sIGV3a19mcmFtZV9wYXVzZV9h bmltYXRpb24oRXZhc19PYmplY3QqIG8sIGNvbnN0IGNoYXIqIG5hbWUsIGNvbnN0IGNoYXIqIGVs ZW1lbnRJZCwgZG91YmxlIHRpbWUpCit7CisgICAgRVdLX0ZSQU1FX1NEX0dFVF9PUl9SRVRVUk4o bywgc2QsIDApOworCisgICAgV2ViQ29yZTo6RWxlbWVudCogZWxlbWVudCA9IHNkLT5mcmFtZS0+ ZG9jdW1lbnQoKS0+Z2V0RWxlbWVudEJ5SWQoV1RGOjpBdG9taWNTdHJpbmcoZWxlbWVudElkKSk7 CisgICAgaWYgKCFlbGVtZW50IHx8ICFlbGVtZW50LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICByZXR1cm4gc2QtPmZyYW1lLT5hbmltYXRpb24oKS0+cGF1c2VBbmlt YXRpb25BdFRpbWUoZWxlbWVudC0+cmVuZGVyZXIoKSwgV1RGOjpBdG9taWNTdHJpbmcobmFtZSks IHRpbWUpOworfQorLyoqCisgKgorICoKKyAqLworRWluYV9Cb29sIGV3a19mcmFtZV9wYXVzZV90 cmFuc2l0aW9uKEV2YXNfT2JqZWN0KiBvLCBjb25zdCBjaGFyKiBuYW1lLCBjb25zdCBjaGFyKiBl bGVtZW50SWQsIGRvdWJsZSB0aW1lKQoreworICAgIEVXS19GUkFNRV9TRF9HRVRfT1JfUkVUVVJO KG8sIHNkLCAwKTsKKworICAgIFdlYkNvcmU6OkVsZW1lbnQqIGVsZW1lbnQgPSBzZC0+ZnJhbWUt PmRvY3VtZW50KCktPmdldEVsZW1lbnRCeUlkKFdURjo6QXRvbWljU3RyaW5nKGVsZW1lbnRJZCkp OworICAgIGlmICghZWxlbWVudCB8fCAhZWxlbWVudC0+cmVuZGVyZXIoKSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworCisgICAgcmV0dXJuIHNkLT5mcmFtZS0+YW5pbWF0aW9uKCktPnBhdXNlVHJh bnNpdGlvbkF0VGltZShlbGVtZW50LT5yZW5kZXJlcigpLCBXVEY6OkF0b21pY1N0cmluZyhuYW1l KSwgdGltZSk7Cit9CisvKioKKyAqCisgKgorICovCitFaW5hX0Jvb2wgZXdrX2ZyYW1lX3BhdXNl X3N2Z19hbmltYXRpb24oRXZhc19PYmplY3QqIG8sIGNvbnN0IGNoYXIqIGFuaW1hdGlvbklkLCBj b25zdCBjaGFyKiBlbGVtZW50SWQsIGRvdWJsZSB0aW1lKQoreworICAgIEVXS19GUkFNRV9TRF9H RVRfT1JfUkVUVVJOKG8sIHNkLCAwKTsKKworICAgIFdlYkNvcmU6OkRvY3VtZW50KiBkb2N1bWVu dCA9IHNkLT5mcmFtZS0+ZG9jdW1lbnQoKTsKKyAgICBpZiAoIWRvY3VtZW50ICYmICFkb2N1bWVu dC0+c3ZnRXh0ZW5zaW9ucygpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBXZWJDb3Jl OjpFbGVtZW50KiBlbGVtZW50ID0gZG9jdW1lbnQtPmdldEVsZW1lbnRCeUlkKFdURjo6QXRvbWlj U3RyaW5nKGFuaW1hdGlvbklkKSk7CisgICAgaWYgKCFlbGVtZW50ICYmICFXZWJDb3JlOjpTVkdT TUlMRWxlbWVudDo6aXNTTUlMRWxlbWVudChlbGVtZW50KSkKKyAgICAgICAgcmV0dXJuIGZhbHNl OworCisgICAgcmV0dXJuIGRvY3VtZW50LT5hY2Nlc3NTVkdFeHRlbnNpb25zKCktPnNhbXBsZUFu aW1hdGlvbkF0VGltZShlbGVtZW50SWQsIHN0YXRpY19jYXN0PFdlYkNvcmU6OlNWR1NNSUxFbGVt ZW50Kj4oZWxlbWVudCksIHRpbWUpOworfQorLyoqCisgKgorICoKKyAqLwordW5zaWduZWQgZXdr X2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhFdmFzX09iamVjdCogbykKK3sKKyAg ICBFV0tfRlJBTUVfU0RfR0VUX09SX1JFVFVSTihvLCBzZCwgMCk7CisKKyAgICBXZWJDb3JlOjpB bmltYXRpb25Db250cm9sbGVyKiBhQ29udHJvbGxlciA9IHNkLT5mcmFtZS0+YW5pbWF0aW9uKCk7 CisgICAgaWYgKCFhQ29udHJvbGxlcikKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0 dXJuIGFDb250cm9sbGVyLT5udW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnMoKTsKK30KKy8qKgorICoK KyAqCisgKi8KK2NoYXIqIGV3a19mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKEV2YXNfT2Jq ZWN0KiBvKQoreworICAgIEVXS19GUkFNRV9TRF9HRVRfT1JfUkVUVVJOKG8sIHNkLCAwKTsKKwor ICAgIFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiBkb2NMb2FkZXIgPSBzZC0+ZnJhbWUtPmxvYWRl cigpLT5kb2N1bWVudExvYWRlcigpOworICAgIGlmICghZG9jTG9hZGVyKQorICAgICAgICByZXR1 cm4gMDsKKworICAgIFdURjo6U3RyaW5nIG1pbWVUeXBlID0gZG9jTG9hZGVyLT5yZXNwb25zZU1J TUVUeXBlKCk7CisgICAgaWYgKG1pbWVUeXBlLmxlbmd0aCgpID4gMCkKKyAgICAgICAgcmV0dXJu IHN0cmR1cChtaW1lVHlwZS51dGY4KCkuZGF0YSgpKTsKKworICAgIHJldHVybiAwOworfQorLyoq CisgKgorICoKKyAqLwordm9pZCBld2tfZ2NfY29sbGVjdF9qYXZhc2NyaXB0X29iamVjdHMoKQor eworICAgIFdlYkNvcmU6OmdjQ29udHJvbGxlcigpLmdhcmJhZ2VDb2xsZWN0Tm93KCk7Cit9Cisv KioKKyAqCisgKgorICovCit2b2lkIGV3a19nY19jb2xsZWN0X2phdmFzY3JpcHRfb2JqZWN0c19v bl9hbHRlcm5hdGVfdGhyZWFkKEVpbmFfQm9vbCB3YWl0VW50aWxEb25lKQoreworICAgIFdlYkNv cmU6OmdjQ29udHJvbGxlcigpLmdhcmJhZ2VDb2xsZWN0T25BbHRlcm5hdGVUaHJlYWRGb3JEZWJ1 Z2dpbmcod2FpdFVudGlsRG9uZSk7Cit9CisvKioKKyAqCisgKgorICovCit1bnNpZ25lZCBld2tf Z2NfY291bnRfamF2YXNjcmlwdF9vYmplY3RzKCkKK3sKKyAgICByZXR1cm4gV2ViQ29yZTo6SlNE T01XaW5kb3c6OmNvbW1vbkpTR2xvYmFsRGF0YSgpLT5oZWFwLm9iamVjdENvdW50KCk7Cit9Cisv KioKKyAqCisgKgorICovCit1bnNpZ25lZCBld2tfd29ya2VyX3RocmVhZF9jb3VudCgpCit7Cisg ICAgcmV0dXJuIFdlYkNvcmU6OldvcmtlclRocmVhZDo6d29ya2VyVGhyZWFkQ291bnQoKTsKK30K ZGlmZiAtLWdpdCBhL1dlYktpdC9lZmwvZXdrL2V3a19mcmFtZS5oIGIvV2ViS2l0L2VmbC9ld2sv ZXdrX2ZyYW1lLmgKaW5kZXggMWE5ZmU4MS4uNjdmMDM2ZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2Vm bC9ld2svZXdrX2ZyYW1lLmgKKysrIGIvV2ViS2l0L2VmbC9ld2svZXdrX2ZyYW1lLmgKQEAgLTIw Miw2ICsyMDIsMjcgQEAgRUFQSSBFaW5hX0Jvb2wgICAgZXdrX2ZyYW1lX2ZlZWRfbW91c2VfbW92 ZShFdmFzX09iamVjdCAqbywgY29uc3QgRXZhc19FdmVudF9Nb3UKIEVBUEkgRWluYV9Cb29sICAg IGV3a19mcmFtZV9mZWVkX2tleV9kb3duKEV2YXNfT2JqZWN0ICpvLCBjb25zdCBFdmFzX0V2ZW50 X0tleV9Eb3duICpldik7CiBFQVBJIEVpbmFfQm9vbCAgICBld2tfZnJhbWVfZmVlZF9rZXlfdXAo RXZhc19PYmplY3QgKm8sIGNvbnN0IEV2YXNfRXZlbnRfS2V5X1VwICpldik7CiAKK0VBUEkgY2hh ciAgICAgICAgICpld2tfZnJhbWVfZ2V0X2lubmVyX3RleHQoRXZhc19PYmplY3QqIG8pOworRUFQ SSBjaGFyICAgICAgICAgKmV3a19mcmFtZV9nZXRfZHVtcF9yZW5kZXJfdHJlZShFdmFzX09iamVj dCogbyk7CitFQVBJIEVpbmFfTGlzdCAgICAqZXdrX2ZyYW1lX2dldF9jaGlsZHJlbihFdmFzX09i amVjdCogbyk7CitFQVBJIGludCAgICAgICAgICBld2tfZnJhbWVfcGFnZV9udW1iZXJfZm9yX2Vs ZW1lbnRfYnlfaWQoRXZhc19PYmplY3QqIG8sIGNoYXIqIGVsZW1lbnRfaWQsIGZsb2F0IHBhZ2VX aWR0aCwgZmxvYXQgcGFnZUhlaWdodCk7CitFQVBJIGludCAgICAgICAgICBld2tfZnJhbWVfcGFn ZV9udW1iZXJfb2ZfcGFnZXMoRXZhc19PYmplY3QqIG8sIGZsb2F0IHBhZ2VXaWR0aCwgZmxvYXQg cGFnZUhlaWdodCk7CitFQVBJIGNoYXIgICAgICAgICAqZXdrX2ZyYW1lX2NvdW50ZXJfdmFsdWVf Zm9yX2VsZW1lbnRfYnlfaWQoRXZhc19PYmplY3QqIG8sIGNoYXIqIGVsZW1lbnRfaWQpOworRUFQ SSBFaW5hX0Jvb2wgICAgZXdrX2ZyYW1lX3dlYl9sYXlvdXQoRXZhc19PYmplY3QqIG8pOworCitF QVBJIEVpbmFfQm9vbCAgICBld2tfZnJhbWVfcGF1c2VfdHJhbnNpdGlvbihFdmFzX09iamVjdCog bywgY29uc3QgY2hhciogbmFtZSwgY29uc3QgY2hhciogZWxlbWVudElkLCBkb3VibGUgdGltZSk7 CisKK0VBUEkgRWluYV9Cb29sICAgIGV3a19mcmFtZV9wYXVzZV9hbmltYXRpb24oRXZhc19PYmpl Y3QqIG8sIGNvbnN0IGNoYXIqIG5hbWUsIGNvbnN0IGNoYXIqIGVsZW1lbnRJZCwgZG91YmxlIHRp bWUpOworCitFQVBJIEVpbmFfQm9vbCAgICBld2tfZnJhbWVfcGF1c2Vfc3ZnX2FuaW1hdGlvbihF dmFzX09iamVjdCogbywgY29uc3QgY2hhciogYW5pbWF0aW9uSWQsIGNvbnN0IGNoYXIqIGVsZW1l bnRJZCwgZG91YmxlIHRpbWUpOworCitFQVBJIHVuc2lnbmVkICAgICBld2tfZnJhbWVfbnVtYmVy X29mX2FjdGl2ZV9hbmltYXRpb25zKEV2YXNfT2JqZWN0KiBvKTsKK0VBUEkgY2hhciAgICAgICAg ICpld2tfZnJhbWVfZ2V0X3Jlc3BvbnNlX21pbWVfdHlwZShFdmFzX09iamVjdCogbyk7CisKK0VB UEkgdm9pZCAgICAgICAgIGV3a19nY19jb2xsZWN0X2phdmFzY3JpcHRfb2JqZWN0cygpOworRUFQ SSB2b2lkICAgICAgICAgZXdrX2djX2NvbGxlY3RfamF2YXNjcmlwdF9vYmplY3RzX29uX2FsdGVy bmF0ZV90aHJlYWQoRWluYV9Cb29sIHdhaXRVbnRpbERvbmUpOworRUFQSSB1bnNpZ25lZCAgICAg ZXdrX2djX2NvdW50X2phdmFzY3JpcHRfb2JqZWN0cygpOworRUFQSSB1bnNpZ25lZCAgICAgZXdr X3dvcmtlcl90aHJlYWRfY291bnQoKTsKIAogI2lmZGVmIF9fY3BsdXNwbHVzCiB9CmRpZmYgLS1n aXQgYS9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5jcHAgYi9XZWJLaXQvZWZsL2V3ay9ld2tfdmll dy5jcHAKaW5kZXggN2E5OGJhYy4uYzU1YzJkMSAxMDA2NDQKLS0tIGEvV2ViS2l0L2VmbC9ld2sv ZXdrX3ZpZXcuY3BwCisrKyBiL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcApAQCAtMzEzOSw2 ICszMTM5LDE4IEBAIHZvaWQgZXdrX3ZpZXdfbG9hZF9zdGFydGVkKEV2YXNfT2JqZWN0KiBvKQog ewogICAgIERCRygibz0lcCIsIG8pOwogICAgIGV2YXNfb2JqZWN0X3NtYXJ0X2NhbGxiYWNrX2Nh bGwobywgImxvYWQsc3RhcnRlZCIsIDApOworCisgICAgZXdrX3ZpZXdfd2luZG93X29iamVjdF9j bGVhcmVkKG8pOworfQorCisvKioKKyAqIEBwYXJhbSBvIFZpZXcKKyAqIFVzZWQgYnkgbGF5b3V0 IHRlc3RzIHRvIGluaXRpYWxpemUgc29tZSBKYXZhU2NyaXB0IHByb3BlcnRpZXMKKyAqIEVtaXRz LHNpZ25hbDogIndpbmRvdyxvYmplY3QsY2xlYXJlZCIgd290aCBubyBwYXJhbWV0ZXJzCisgKi8K K3ZvaWQgZXdrX3ZpZXdfd2luZG93X29iamVjdF9jbGVhcmVkKEV2YXNfT2JqZWN0KiBvKQorewor ICAgIGV2YXNfb2JqZWN0X3NtYXJ0X2NhbGxiYWNrX2NhbGwobywgIndpbmRvdyxvYmplY3QsY2xl YXJlZCIsIDApOwogfQogCiAvKioKZGlmZiAtLWdpdCBhL1dlYktpdC9lZmwvZXdrL2V3a192aWV3 LmggYi9XZWJLaXQvZWZsL2V3ay9ld2tfdmlldy5oCmluZGV4IDhkZDYxNzguLmFhMDc5MjYgMTAw NjQ0Ci0tLSBhL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKKysrIGIvV2ViS2l0L2VmbC9ld2sv ZXdrX3ZpZXcuaApAQCAtNDgwLDYgKzQ4MCw4IEBAIEVBUEkgZmxvYXQgZXdrX3ZpZXdfem9vbV9y YW5nZV9tYXhfZ2V0KEV2YXNfT2JqZWN0KiBvKTsKIEVBUEkgdm9pZCBld2tfdmlld191c2VyX3Nj YWxhYmxlX3NldChFdmFzX09iamVjdCogbywgRWluYV9Cb29sIHVzZXJfc2NhbGFibGUpOwogRUFQ SSBFaW5hX0Jvb2wgZXdrX3ZpZXdfdXNlcl9zY2FsYWJsZV9nZXQoRXZhc19PYmplY3QqIG8pOwog CitFQVBJIHZvaWQgZXdrX3ZpZXdfd2luZG93X29iamVjdF9jbGVhcmVkKEV2YXNfT2JqZWN0KiBv KTsKKwogI2lmZGVmIF9fY3BsdXNwbHVzCiB9CiAjZW5kaWYK 65258 2010-08-24 05:28:04 -0700 2010-08-30 16:39:38 -0700 Enhancements for WebKit-EFL port, that are used by Dump Render Tree application webkit_efl_ewk.patch text/plain 13499 k.czech ZGlmZiAtLWdpdCBhL1dlYktpdC9lZmwvQ2hhbmdlTG9nIGIvV2ViS2l0L2VmbC9DaGFuZ2VMb2cK aW5kZXggZGU2NTg4NS4uOGVhOGJhYSAxMDA2NDQKLS0tIGEvV2ViS2l0L2VmbC9DaGFuZ2VMb2cK KysrIGIvV2ViS2l0L2VmbC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAxMC0wOC0yNCAg S3J6eXN6dG9mIEN6ZWNoICA8ay5jemVjaEBzYW1zdW5nLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbRUZMXSBXZWJLaXQgQVBJIGZvciBEdW1w IFJlbmRlciBUcmVlIGFwcGxpY2F0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD00NDUwMAorCisgICAgICAgIEVuaGFuY2VtZW50cyBmb3IgV2ViS2l0 LUVGTCBwb3J0LCB0aGF0IGFyZSB1c2VkCisgICAgICAgIGJ5IER1bXAgUmVuZGVyIFRyZWUgYXBw bGljYXRpb24gCisKKyAgICAgICAgKiBld2svZXdrX2ZyYW1lLmNwcDoKKyAgICAgICAgKGV3a19m cmFtZV9nZXRfaW5uZXJfdGV4dCk6CisgICAgICAgIChld2tfZnJhbWVfZ2V0X2R1bXBfcmVuZGVy X3RyZWUpOgorICAgICAgICAoZXdrX2ZyYW1lX2dldF9jaGlsZHJlbik6CisgICAgICAgIChld2tf ZnJhbWVfcGFnZV9udW1iZXJfZm9yX2VsZW1lbnRfYnlfaWQpOgorICAgICAgICAoZXdrX2ZyYW1l X3BhZ2VfbnVtYmVyX29mX3BhZ2VzKToKKyAgICAgICAgKGV3a19mcmFtZV9jb3VudGVyX3ZhbHVl X2Zvcl9lbGVtZW50X2J5X2lkKToKKyAgICAgICAgKGV3a19mcmFtZV93ZWJfbGF5b3V0KToKKyAg ICAgICAgKGV3a19mcmFtZV9wYXVzZV9hbmltYXRpb24pOgorICAgICAgICAoZXdrX2ZyYW1lX3Bh dXNlX3RyYW5zaXRpb24pOgorICAgICAgICAoZXdrX2ZyYW1lX3BhdXNlX3N2Z19hbmltYXRpb24p OgorICAgICAgICAoZXdrX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyk6CisgICAg ICAgIChld2tfZnJhbWVfZ2V0X3Jlc3BvbnNlX21pbWVfdHlwZSk6CisgICAgICAgIChld2tfZ2Nf Y29sbGVjdF9qYXZhc2NyaXB0X29iamVjdHMpOgorICAgICAgICAoZXdrX2djX2NvbGxlY3RfamF2 YXNjcmlwdF9vYmplY3RzX29uX2FsdGVybmF0ZV90aHJlYWQpOgorICAgICAgICAoZXdrX2djX2Nv dW50X2phdmFzY3JpcHRfb2JqZWN0cyk6CisgICAgICAgIChld2tfd29ya2VyX3RocmVhZF9jb3Vu dCk6CisgICAgICAgICogZXdrL2V3a19mcmFtZS5oOgorICAgICAgICAqIGV3ay9ld2tfdmlldy5j cHA6CisgICAgICAgIChld2tfdmlld19sb2FkX3N0YXJ0ZWQpOgorICAgICAgICAoZXdrX3ZpZXdf d2luZG93X29iamVjdF9jbGVhcmVkKToKKyAgICAgICAgKiBld2svZXdrX3ZpZXcuaDoKKwogMjAx MC0wOC0xNSAgR3l1eW91bmcgS2ltICA8Z3l1eW91bmcua2ltQHNhbXN1bmcuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEFudG9uaW8gR29tZXMuCmRpZmYgLS1naXQgYS9XZWJLaXQvZWZsL2V3 ay9ld2tfZnJhbWUuY3BwIGIvV2ViS2l0L2VmbC9ld2svZXdrX2ZyYW1lLmNwcAppbmRleCAyOTZj MjYxLi5kODY2OTJjIDEwMDY0NAotLS0gYS9XZWJLaXQvZWZsL2V3ay9ld2tfZnJhbWUuY3BwCisr KyBiL1dlYktpdC9lZmwvZXdrL2V3a19mcmFtZS5jcHAKQEAgLTI0LDM0ICsyNCw0MyBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgImV3a19mcmFtZS5oIgogCisjaW5jbHVkZSAiQW5p bWF0aW9uQ29udHJvbGxlci5oIgorI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyLmgiCiAjaW5jbHVk ZSAiRVdlYktpdC5oIgogI2luY2x1ZGUgIkV2ZW50SGFuZGxlci5oIgorI2luY2x1ZGUgIkZsb2F0 U2l6ZS5oIgogI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkZyYW1lTG9h ZGVyQ2xpZW50RWZsLmgiCiAjaW5jbHVkZSAiRnJhbWVUcmVlLmgiCiAjaW5jbHVkZSAiRnJhbWVW aWV3LmgiCisjaW5jbHVkZSAiR0NDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiSFRNTFBsdWdJbkVs ZW1lbnQuaCIKICNpbmNsdWRlICJIaXN0b3J5SXRlbS5oIgogI2luY2x1ZGUgIkhpdFRlc3RSZXN1 bHQuaCIKKyNpbmNsdWRlICJKU0RPTVdpbmRvdy5oIgogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNs dWRlICJQbGF0Zm9ybUtleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybU1vdXNlRXZl bnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQuaCIKKyNpbmNsdWRlICJQcmludENv bnRleHQuaCIKICNpbmNsdWRlICJQcm9ncmVzc1RyYWNrZXIuaCIKICNpbmNsdWRlICJSZWZQdHIu aCIKICNpbmNsdWRlICJSZW5kZXJUaGVtZS5oIgorI2luY2x1ZGUgIlJlbmRlclRyZWVBc1RleHQu aCIKICNpbmNsdWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKICNpbmNsdWRlICJTY3JpcHRWYWx1ZS5o IgogI2luY2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgogI2luY2x1ZGUgIlN1YnN0aXR1dGVEYXRhLmgi Ci0jaW5jbHVkZSAiWm9vbU1vZGUuaCIKICNpbmNsdWRlICJXaW5kb3dzS2V5Ym9hcmRDb2Rlcy5o IgorI2luY2x1ZGUgIlpvb21Nb2RlLmgiCisjaW5jbHVkZSAiYW5pbWF0aW9uL1NWR1NNSUxFbGVt ZW50LmgiCiAjaW5jbHVkZSAiZXdrX3ByaXZhdGUuaCIKLSNpbmNsdWRlIDx3dGYvdGV4dC9DU3Ry aW5nLmg+CisjaW5jbHVkZSAid29ya2Vycy9Xb3JrZXJUaHJlYWQuaCIKIAogI2luY2x1ZGUgPEVp bmEuaD4KICNpbmNsdWRlIDxFdmFzLmg+CiAjaW5jbHVkZSA8ZWluYV9zYWZldHlfY2hlY2tzLmg+ CisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgogCiBzdGF0aWMgY29uc3QgY2hhciBFV0tf RlJBTUVfVFlQRV9TVFJbXSA9ICJFV0tfRnJhbWUiOwogCkBAIC0xOTUwLDMgKzE5NTksMjcyIEBA IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpXaWRnZXQ+IGV3a19mcmFtZV9wbHVnaW5fY3JlYXRl KEV2YXNfT2JqZWN0KiBvLCBjb25zdCBXCiB7CiAgICAgcmV0dXJuIDA7CiB9CisvKioKKyAqIER1 bXBzIHdlYnBhZ2UncyBsYXlvdXQgYXMgYSBwbGFpbiB0ZXh0CisgKgorICogQHBhcmFtIG8gRnJh bWUKKyAqCisgKiBAcmV0dXJuIHJldHVybnMgdGV4dHVhbCByZXByZXNlbnRhdGlvbiBvZiBkdW1w ZWQgcGFnZQorKi8KK2NoYXIqIGV3a19mcmFtZV9nZXRfaW5uZXJfdGV4dChFdmFzX09iamVjdCog bykKK3sKKyAgICBFV0tfRlJBTUVfU0RfR0VUX09SX1JFVFVSTihvLCBzZCwgMCk7CisKKyAgICBX ZWJDb3JlOjpGcmFtZVZpZXcqIGZyYW1lVmlldyA9IHNkLT5mcmFtZS0+dmlldygpOworICAgIGlm IChmcmFtZVZpZXcgJiYgZnJhbWVWaWV3LT5sYXlvdXRQZW5kaW5nKCkpCisgICAgICAgIGZyYW1l Vmlldy0+bGF5b3V0KCk7CisKKyAgICBXZWJDb3JlOjpFbGVtZW50KiBkb2NFbGVtZW50ID0gc2Qt PmZyYW1lLT5kb2N1bWVudCgpLT5kb2N1bWVudEVsZW1lbnQoKTsKKyAgICBXVEY6OlN0cmluZyBp bm5lclRleHQgPSBkb2NFbGVtZW50LT5pbm5lclRleHQoKTsKKworICAgIHJldHVybiBzdHJkdXAo aW5uZXJUZXh0LnV0ZjgoKS5kYXRhKCkpOworfQorLyoqCisgKiBEdW1wcyB3ZWJwYWdlJ3MgbGF5 b3V0IGFzIGEgdHJlZSByZXByZXNlbnRhdGlvbgorICoKKyAqIEBwYXJhbSBvIEZyYW1lCisgKgor ICogQHJldHVybiByZXR1cm5zIHRleHR1YWwgcmVwcmVzZW50YXRpb24gb2YgZHVtcGVkIHBhZ2UK KyAqLworY2hhciogZXdrX2ZyYW1lX2dldF9kdW1wX3JlbmRlcl90cmVlKEV2YXNfT2JqZWN0KiBv KQoreworICAgIEVXS19GUkFNRV9TRF9HRVRfT1JfUkVUVVJOKG8sIHNkLCAwKTsKKworICAgIFdl YkNvcmU6OkZyYW1lVmlldyogZnJhbWVWaWV3ID0gc2QtPmZyYW1lLT52aWV3KCk7CisgICAgaWYg KGZyYW1lVmlldyAmJiBmcmFtZVZpZXctPmxheW91dFBlbmRpbmcoKSkKKyAgICAgICAgZnJhbWVW aWV3LT5sYXlvdXQoKTsKKworICAgIFdURjo6U3RyaW5nIHJlbmRlclRleHQgPSBXZWJDb3JlOjpl eHRlcm5hbFJlcHJlc2VudGF0aW9uKHNkLT5mcmFtZSk7CisKKyAgICByZXR1cm4gc3RyZHVwKHJl bmRlclRleHQudXRmOCgpLmRhdGEoKSk7Cit9CisvKioKKyAqIFJldHVybnMgY2hpbGQgZnJhbWVz IGlmIGV4aXN0cworICoKKyAqIEBwYXJhbSBvIEZyYW1lCisgKgorICogQHJldHVybiByZXR1cm5z IGxpc3Qgb2YgY2hpbGQgZnJhbWVzLCBvciBAYyBOVUxMIGVtcHR5IGxpc3QKKyAqLworRWluYV9M aXN0KiBld2tfZnJhbWVfZ2V0X2NoaWxkcmVuKEV2YXNfT2JqZWN0KiBvKQoreworICAgIEVXS19G UkFNRV9TRF9HRVRfT1JfUkVUVVJOKG8sIHNkLCAwKTsKKworICAgIEVpbmFfTGlzdCogY2hpbGRG cmFtZXMgPSAwOworCisgICAgZm9yICh1bnNpZ25lZCBpbmRleCA9IDA7IGluZGV4IDwgc2QtPmZy YW1lLT50cmVlKCktPmNoaWxkQ291bnQoKTsgaW5kZXgrKykgeworICAgICAgICBXZWJDb3JlOjpG cmFtZSogY2hpbGRGcmFtZSA9IHNkLT5mcmFtZS0+dHJlZSgpLT5jaGlsZChpbmRleCk7CisgICAg ICAgIFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50RWZsKiBjbGllbnQgPSBzdGF0aWNfY2FzdDxX ZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudEVmbCo+KGNoaWxkRnJhbWUtPmxvYWRlcigpLT5jbGll bnQoKSk7CisgICAgICAgIGlmICghY2xpZW50KQorICAgICAgICAgICAgY29udGludWU7CisgICAg ICAgIGNoaWxkRnJhbWVzID0gZWluYV9saXN0X2FwcGVuZChjaGlsZEZyYW1lcywgY2xpZW50LT53 ZWJGcmFtZSgpKTsKKyAgICB9CisKKyAgICByZXR1cm4gY2hpbGRGcmFtZXM7Cit9CisvKioKKyAq IFJldHVybnMgbnVtYmVyIG9mIHBhZ2UgZWxlbWVudAorICoKKyAqIEBwYXJhbSBvIEZyYW1lCisg KiBAcGFyYW0gZWxlbWVudF9pZCBlbGVtZW50IGlkCisgKiBAcGFyYW0gcGFnZVdpZHRoIHBhZ2Ug d2lkdGgKKyAqIEBwYXJhbSBwYWdlSGVpZ2h0IHBhZ2UgaGVpZ2h0CisgKgorICogQHJldHVybiBu dW1iZXIgb2YgcGFnZSBlbGVtZW50IG9yIEBjIDAKKyAqLworaW50IGV3a19mcmFtZV9wYWdlX251 bWJlcl9mb3JfZWxlbWVudF9ieV9pZChFdmFzX09iamVjdCogbywgY2hhciogZWxlbWVudF9pZCwg ZmxvYXQgcGFnZVdpZHRoLCBmbG9hdCBwYWdlSGVpZ2h0KQoreworICAgIEVXS19GUkFNRV9TRF9H RVRfT1JfUkVUVVJOKG8sIHNkLCAwKTsKKyAgICBXZWJDb3JlOjpFbGVtZW50KiBlbGVtZW50ID0g c2QtPmZyYW1lLT5kb2N1bWVudCgpLT5nZXRFbGVtZW50QnlJZChXVEY6OkF0b21pY1N0cmluZyhl bGVtZW50X2lkKSk7CisgICAgaWYgKCFlbGVtZW50KQorICAgICAgICByZXR1cm4gMDsKKworICAg IHJldHVybiBXZWJDb3JlOjpQcmludENvbnRleHQ6OnBhZ2VOdW1iZXJGb3JFbGVtZW50KGVsZW1l bnQsIFdlYkNvcmU6OkZsb2F0U2l6ZShwYWdlV2lkdGgsIHBhZ2VIZWlnaHQpKTsKK30KKy8qKgor ICogUmV0dXJucyBudW1iZXIgb2YgcGFnZXMKKyAqCisgKiBAcGFyYW0gbyBGcmFtZQorICogQHBh cmFtIHBhZ2VXaWR0aCBwYWdlIHdpZHRoCisgKiBAcGFyYW0gcGFnZUhlaWdodCBwYWdlIGhlaWdo dAorICoKKyAqIEByZXR1cm4gcmV0dXJucyBudW1iZXIgb2YgcGFnZXMKKyAqLworaW50IGV3a19m cmFtZV9wYWdlX251bWJlcl9vZl9wYWdlcyhFdmFzX09iamVjdCogbywgZmxvYXQgcGFnZVdpZHRo LCBmbG9hdCBwYWdlSGVpZ2h0KQoreworICAgIEVXS19GUkFNRV9TRF9HRVRfT1JfUkVUVVJOKG8s IHNkLCAwKTsKKworICAgIHJldHVybiBXZWJDb3JlOjpQcmludENvbnRleHQ6Om51bWJlck9mUGFn ZXMoc2QtPmZyYW1lLCBXZWJDb3JlOjpGbG9hdFNpemUocGFnZVdpZHRoLCBwYWdlSGVpZ2h0KSk7 Cit9CisvKioKKyAqIFJldHVybnMgY291bnRlciB2YWx1ZSBmb3IgZWxlbWVudAorICoKKyAqIEBw YXJhbSBvIEZyYW1lCisgKiBAcGFyYW0gZWxlbWVudF9pZCBlbGVtZW50IGlkCisgKgorICogQHJl dHVybiByZXR1cm5zIHRleHR1YWwgdmFsdWUgb3IgQGMgTlVMTAorICovCitjaGFyKiBld2tfZnJh bWVfY291bnRlcl92YWx1ZV9mb3JfZWxlbWVudF9ieV9pZChFdmFzX09iamVjdCogbywgY2hhciog ZWxlbWVudF9pZCkKK3sKKyAgICBFV0tfRlJBTUVfU0RfR0VUX09SX1JFVFVSTihvLCBzZCwgMCk7 CisKKyAgICBXZWJDb3JlOjpFbGVtZW50KiBlbGVtZW50ID0gc2QtPmZyYW1lLT5kb2N1bWVudCgp LT5nZXRFbGVtZW50QnlJZChXVEY6OkF0b21pY1N0cmluZyhlbGVtZW50X2lkKSk7CisgICAgaWYg KCFlbGVtZW50KQorICAgICAgICByZXR1cm4gMDsKKworICAgIFdURjo6U3RyaW5nIGNvdW50ZXJW YWx1ZSA9IFdlYkNvcmU6OmNvdW50ZXJWYWx1ZUZvckVsZW1lbnQoZWxlbWVudCk7CisgICAgcmV0 dXJuIHN0cmR1cChjb3VudGVyVmFsdWUudXRmOCgpLmRhdGEoKSk7Cit9CisvKioKKyAqIFJldHVy bnMgdHJ1ZSBpZiBmcmFtZSBsYXlvdXQKKyAqIAorICogQHBhcmFtIG8gRnJhbWUKKyAqIAorICog QHJldHVybiByZXR1cm4gQGMgVFJVRSBpZiBmcmFtZSdzIGxheW91dCwgb3IgQGMgRkFMU0UgaWYg c29tZXRoaW5nIHdlbnQgd3JvbmcKKyAqLworRWluYV9Cb29sIGV3a19mcmFtZV93ZWJfbGF5b3V0 KEV2YXNfT2JqZWN0KiBvKQoreworICAgIEVXS19GUkFNRV9TRF9HRVRfT1JfUkVUVVJOKG8sIHNk LCAwKTsKKworICAgIFdlYkNvcmU6OkZyYW1lVmlldyogZnJhbWVWaWV3ID0gc2QtPmZyYW1lLT52 aWV3KCk7CisKKyAgICBpZiAoIWZyYW1lVmlldykKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisg ICAgZnJhbWVWaWV3LT5sYXlvdXQoKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKy8qKgorICogU2V0 IHBhdXNlIG9uIGZyYW1lJ3MgYW5pbWF0aW9uCisgKgorICogQHBhcmFtIG5hbWUgbmFtZQorICog QHBhcmFtIGVsZW1lbnRfaWQgZWxlbWVudCBpZAorICogQGRvdWJsZSB0aW1lIHRpbWUKKyAqCisg KiBAcmV0dXJuIHJldHVybnMgQGMgVFJVRSBwYXVzZSBpcyBzZXQsIEBjIEZBTFNFIHBhdXNlIGlz IG5vdCBzZXQKKyAqLworRWluYV9Cb29sIGV3a19mcmFtZV9wYXVzZV9hbmltYXRpb24oRXZhc19P YmplY3QqIG8sIGNvbnN0IGNoYXIqIG5hbWUsIGNvbnN0IGNoYXIqIGVsZW1lbnRJZCwgZG91Ymxl IHRpbWUpCit7CisgICAgRVdLX0ZSQU1FX1NEX0dFVF9PUl9SRVRVUk4obywgc2QsIDApOworCisg ICAgV2ViQ29yZTo6RWxlbWVudCogZWxlbWVudCA9IHNkLT5mcmFtZS0+ZG9jdW1lbnQoKS0+Z2V0 RWxlbWVudEJ5SWQoV1RGOjpBdG9taWNTdHJpbmcoZWxlbWVudElkKSk7CisgICAgaWYgKCFlbGVt ZW50IHx8ICFlbGVtZW50LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAg ICByZXR1cm4gc2QtPmZyYW1lLT5hbmltYXRpb24oKS0+cGF1c2VBbmltYXRpb25BdFRpbWUoZWxl bWVudC0+cmVuZGVyZXIoKSwgV1RGOjpBdG9taWNTdHJpbmcobmFtZSksIHRpbWUpOworfQorLyoq CisgKiBQYXVzZSB0cmFuc2l0aW9uCisgKgorICogQHBhcmFtIG8gRnJhbWUKKyAqIEBwYXJhbSBu YW1lCisgKiBAcGFyYW0gZWxlbWVudElkCisgKiBAcGFyYW0gdGltZQorICoKKyAqIEByZXR1cm4g cmV0dXJucyBAYyBUUlVFIHBhdXNlIGlzIHNldCwgb3IgQGMgRkFMU0UgcGF1c2UgaXMgbm90IHNl dAorICovCitFaW5hX0Jvb2wgZXdrX2ZyYW1lX3BhdXNlX3RyYW5zaXRpb24oRXZhc19PYmplY3Qq IG8sIGNvbnN0IGNoYXIqIG5hbWUsIGNvbnN0IGNoYXIqIGVsZW1lbnRJZCwgZG91YmxlIHRpbWUp Cit7CisgICAgRVdLX0ZSQU1FX1NEX0dFVF9PUl9SRVRVUk4obywgc2QsIDApOworCisgICAgV2Vi Q29yZTo6RWxlbWVudCogZWxlbWVudCA9IHNkLT5mcmFtZS0+ZG9jdW1lbnQoKS0+Z2V0RWxlbWVu dEJ5SWQoV1RGOjpBdG9taWNTdHJpbmcoZWxlbWVudElkKSk7CisgICAgaWYgKCFlbGVtZW50IHx8 ICFlbGVtZW50LT5yZW5kZXJlcigpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICByZXR1 cm4gc2QtPmZyYW1lLT5hbmltYXRpb24oKS0+cGF1c2VUcmFuc2l0aW9uQXRUaW1lKGVsZW1lbnQt PnJlbmRlcmVyKCksIFdURjo6QXRvbWljU3RyaW5nKG5hbWUpLCB0aW1lKTsKK30KKy8qKgorICog UGF1c2Ugc3ZnIGFuaW1hdGlvbgorICogCisgKiBAcGFyYW0gbyBGcmFtZQorICogQHBhcmFtIGFu aW1hdGlvbklkCisgKiBAcGFyYW0gZWxlbWVudElkCisgKiBAcGFyYW0gdGltZQorICoKKyAqIEBy ZXR1cm4gcmV0dXJucyBAYyBUUlVFIHBhdXNlIGlzIHNldCBvciBAYyBGQUxTRSBwYXVzZSBpcyBu b3Qgc2V0CisgKi8KK0VpbmFfQm9vbCBld2tfZnJhbWVfcGF1c2Vfc3ZnX2FuaW1hdGlvbihFdmFz X09iamVjdCogbywgY29uc3QgY2hhciogYW5pbWF0aW9uSWQsIGNvbnN0IGNoYXIqIGVsZW1lbnRJ ZCwgZG91YmxlIHRpbWUpCit7CisgICAgRVdLX0ZSQU1FX1NEX0dFVF9PUl9SRVRVUk4obywgc2Qs IDApOworCisgICAgV2ViQ29yZTo6RG9jdW1lbnQqIGRvY3VtZW50ID0gc2QtPmZyYW1lLT5kb2N1 bWVudCgpOworICAgIGlmICghZG9jdW1lbnQgJiYgIWRvY3VtZW50LT5zdmdFeHRlbnNpb25zKCkp CisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIFdlYkNvcmU6OkVsZW1lbnQqIGVsZW1lbnQg PSBkb2N1bWVudC0+Z2V0RWxlbWVudEJ5SWQoV1RGOjpBdG9taWNTdHJpbmcoYW5pbWF0aW9uSWQp KTsKKyAgICBpZiAoIWVsZW1lbnQgJiYgIVdlYkNvcmU6OlNWR1NNSUxFbGVtZW50Ojppc1NNSUxF bGVtZW50KGVsZW1lbnQpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICByZXR1cm4gZG9j dW1lbnQtPmFjY2Vzc1NWR0V4dGVuc2lvbnMoKS0+c2FtcGxlQW5pbWF0aW9uQXRUaW1lKGVsZW1l bnRJZCwgc3RhdGljX2Nhc3Q8V2ViQ29yZTo6U1ZHU01JTEVsZW1lbnQqPihlbGVtZW50KSwgdGlt ZSk7Cit9CisvKioKKyAqIFJldHVybnMgbnVtYmVyIG9mIGFjdGl2ZSBhbmltYXRpb25zCisgKiAK KyAqIEBwYXJhbSBvIEZyYW1lCisgKgorICogQHJldHVybiByZXR1cm5zIG51bWJlciBvZiBhY3Rp dmUgYW5pbWF0aW9ucywgb3IgQGMgMCBpZiBzb21ldGhpbmcgd2VudCB3cm9uZworICovCit1bnNp Z25lZCBld2tfZnJhbWVfbnVtYmVyX29mX2FjdGl2ZV9hbmltYXRpb25zKEV2YXNfT2JqZWN0KiBv KQoreworICAgIEVXS19GUkFNRV9TRF9HRVRfT1JfUkVUVVJOKG8sIHNkLCAwKTsKKworICAgIFdl YkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXIqIGFDb250cm9sbGVyID0gc2QtPmZyYW1lLT5hbmlt YXRpb24oKTsKKyAgICBpZiAoIWFDb250cm9sbGVyKQorICAgICAgICByZXR1cm4gZmFsc2U7CisK KyAgICByZXR1cm4gYUNvbnRyb2xsZXItPm51bWJlck9mQWN0aXZlQW5pbWF0aW9ucygpOworfQor LyoqCisgKiBHZXRzIHJlc3BvbnNlIG1pIHR5cGUKKyAqCisgKiBAcGFyYW0gbyBGcmFtZQorICoK KyAqIEByZXR1cm4gcmV0dXJucyBtaW1lIHR5cGUgb3IgQGMgTlVMTCBpZiBzb21ldGhpbmcgd2Vu dCB3cm9uZworICovCitjaGFyKiBld2tfZnJhbWVfZ2V0X3Jlc3BvbnNlX21pbWVfdHlwZShFdmFz X09iamVjdCogbykKK3sKKyAgICBFV0tfRlJBTUVfU0RfR0VUX09SX1JFVFVSTihvLCBzZCwgMCk7 CisKKyAgICBXZWJDb3JlOjpEb2N1bWVudExvYWRlciogZG9jTG9hZGVyID0gc2QtPmZyYW1lLT5s b2FkZXIoKS0+ZG9jdW1lbnRMb2FkZXIoKTsKKyAgICBpZiAoIWRvY0xvYWRlcikKKyAgICAgICAg cmV0dXJuIDA7CisKKyAgICBXVEY6OlN0cmluZyBtaW1lVHlwZSA9IGRvY0xvYWRlci0+cmVzcG9u c2VNSU1FVHlwZSgpOworICAgIGlmIChtaW1lVHlwZS5sZW5ndGgoKSA+IDApCisgICAgICAgIHJl dHVybiBzdHJkdXAobWltZVR5cGUudXRmOCgpLmRhdGEoKSk7CisKKyAgICByZXR1cm4gMDsKK30K Ky8qKgorICogQ29sbGVjIGphdmFzY3JpcHQgb2JqZWN0cworICovCit2b2lkIGV3a19nY19jb2xs ZWN0X2phdmFzY3JpcHRfb2JqZWN0cygpCit7CisgICAgV2ViQ29yZTo6Z2NDb250cm9sbGVyKCku Z2FyYmFnZUNvbGxlY3ROb3coKTsKK30KKy8qKgorICogQ29sbGVjdCBqYXZhc2NyaXB0IG9iamVj dCBvbiBhbHRlcm5hdGUgdGhyZWFkCisgKgorICogQHBhcmFtIHdhaXRVbnRpbERvbmUKKyAqLwor dm9pZCBld2tfZ2NfY29sbGVjdF9qYXZhc2NyaXB0X29iamVjdHNfb25fYWx0ZXJuYXRlX3RocmVh ZChFaW5hX0Jvb2wgd2FpdFVudGlsRG9uZSkKK3sKKyAgICBXZWJDb3JlOjpnY0NvbnRyb2xsZXIo KS5nYXJiYWdlQ29sbGVjdE9uQWx0ZXJuYXRlVGhyZWFkRm9yRGVidWdnaW5nKHdhaXRVbnRpbERv bmUpOworfQorLyoqCisgKiBDb3VudHMgamF2YXNjcmlwdCBvYmplY3RzCisgKgorICogQHJldHVy biByZXR1cm5zIG51bWJlciBvZiBqYXZhc2NyaXB0IG9iamVjdHMKKyAqLwordW5zaWduZWQgZXdr X2djX2NvdW50X2phdmFzY3JpcHRfb2JqZWN0cygpCit7CisgICAgcmV0dXJuIFdlYkNvcmU6OkpT RE9NV2luZG93Ojpjb21tb25KU0dsb2JhbERhdGEoKS0+aGVhcC5vYmplY3RDb3VudCgpOworfQor LyoqCisgKiBDb3VudCB0aHJlYWQgd29ya2VycworICogCisgKiBAcmV0dXJuIHJldHVybnMgbnVt YmVyIG9mIHRocmVhZCB3b3JrZXJzCisgKi8KK3Vuc2lnbmVkIGV3a193b3JrZXJfdGhyZWFkX2Nv dW50KCkKK3sKKyAgICByZXR1cm4gV2ViQ29yZTo6V29ya2VyVGhyZWFkOjp3b3JrZXJUaHJlYWRD b3VudCgpOworfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2VmbC9ld2svZXdrX2ZyYW1lLmggYi9XZWJL aXQvZWZsL2V3ay9ld2tfZnJhbWUuaAppbmRleCAxYTlmZTgxLi42N2YwMzZlIDEwMDY0NAotLS0g YS9XZWJLaXQvZWZsL2V3ay9ld2tfZnJhbWUuaAorKysgYi9XZWJLaXQvZWZsL2V3ay9ld2tfZnJh bWUuaApAQCAtMjAyLDYgKzIwMiwyNyBAQCBFQVBJIEVpbmFfQm9vbCAgICBld2tfZnJhbWVfZmVl ZF9tb3VzZV9tb3ZlKEV2YXNfT2JqZWN0ICpvLCBjb25zdCBFdmFzX0V2ZW50X01vdQogRUFQSSBF aW5hX0Jvb2wgICAgZXdrX2ZyYW1lX2ZlZWRfa2V5X2Rvd24oRXZhc19PYmplY3QgKm8sIGNvbnN0 IEV2YXNfRXZlbnRfS2V5X0Rvd24gKmV2KTsKIEVBUEkgRWluYV9Cb29sICAgIGV3a19mcmFtZV9m ZWVkX2tleV91cChFdmFzX09iamVjdCAqbywgY29uc3QgRXZhc19FdmVudF9LZXlfVXAgKmV2KTsK IAorRUFQSSBjaGFyICAgICAgICAgKmV3a19mcmFtZV9nZXRfaW5uZXJfdGV4dChFdmFzX09iamVj dCogbyk7CitFQVBJIGNoYXIgICAgICAgICAqZXdrX2ZyYW1lX2dldF9kdW1wX3JlbmRlcl90cmVl KEV2YXNfT2JqZWN0KiBvKTsKK0VBUEkgRWluYV9MaXN0ICAgICpld2tfZnJhbWVfZ2V0X2NoaWxk cmVuKEV2YXNfT2JqZWN0KiBvKTsKK0VBUEkgaW50ICAgICAgICAgIGV3a19mcmFtZV9wYWdlX251 bWJlcl9mb3JfZWxlbWVudF9ieV9pZChFdmFzX09iamVjdCogbywgY2hhciogZWxlbWVudF9pZCwg ZmxvYXQgcGFnZVdpZHRoLCBmbG9hdCBwYWdlSGVpZ2h0KTsKK0VBUEkgaW50ICAgICAgICAgIGV3 a19mcmFtZV9wYWdlX251bWJlcl9vZl9wYWdlcyhFdmFzX09iamVjdCogbywgZmxvYXQgcGFnZVdp ZHRoLCBmbG9hdCBwYWdlSGVpZ2h0KTsKK0VBUEkgY2hhciAgICAgICAgICpld2tfZnJhbWVfY291 bnRlcl92YWx1ZV9mb3JfZWxlbWVudF9ieV9pZChFdmFzX09iamVjdCogbywgY2hhciogZWxlbWVu dF9pZCk7CitFQVBJIEVpbmFfQm9vbCAgICBld2tfZnJhbWVfd2ViX2xheW91dChFdmFzX09iamVj dCogbyk7CisKK0VBUEkgRWluYV9Cb29sICAgIGV3a19mcmFtZV9wYXVzZV90cmFuc2l0aW9uKEV2 YXNfT2JqZWN0KiBvLCBjb25zdCBjaGFyKiBuYW1lLCBjb25zdCBjaGFyKiBlbGVtZW50SWQsIGRv dWJsZSB0aW1lKTsKKworRUFQSSBFaW5hX0Jvb2wgICAgZXdrX2ZyYW1lX3BhdXNlX2FuaW1hdGlv bihFdmFzX09iamVjdCogbywgY29uc3QgY2hhciogbmFtZSwgY29uc3QgY2hhciogZWxlbWVudElk LCBkb3VibGUgdGltZSk7CisKK0VBUEkgRWluYV9Cb29sICAgIGV3a19mcmFtZV9wYXVzZV9zdmdf YW5pbWF0aW9uKEV2YXNfT2JqZWN0KiBvLCBjb25zdCBjaGFyKiBhbmltYXRpb25JZCwgY29uc3Qg Y2hhciogZWxlbWVudElkLCBkb3VibGUgdGltZSk7CisKK0VBUEkgdW5zaWduZWQgICAgIGV3a19m cmFtZV9udW1iZXJfb2ZfYWN0aXZlX2FuaW1hdGlvbnMoRXZhc19PYmplY3QqIG8pOworRUFQSSBj aGFyICAgICAgICAgKmV3a19mcmFtZV9nZXRfcmVzcG9uc2VfbWltZV90eXBlKEV2YXNfT2JqZWN0 KiBvKTsKKworRUFQSSB2b2lkICAgICAgICAgZXdrX2djX2NvbGxlY3RfamF2YXNjcmlwdF9vYmpl Y3RzKCk7CitFQVBJIHZvaWQgICAgICAgICBld2tfZ2NfY29sbGVjdF9qYXZhc2NyaXB0X29iamVj dHNfb25fYWx0ZXJuYXRlX3RocmVhZChFaW5hX0Jvb2wgd2FpdFVudGlsRG9uZSk7CitFQVBJIHVu c2lnbmVkICAgICBld2tfZ2NfY291bnRfamF2YXNjcmlwdF9vYmplY3RzKCk7CitFQVBJIHVuc2ln bmVkICAgICBld2tfd29ya2VyX3RocmVhZF9jb3VudCgpOwogCiAjaWZkZWYgX19jcGx1c3BsdXMK IH0KZGlmZiAtLWdpdCBhL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmNwcCBiL1dlYktpdC9lZmwv ZXdrL2V3a192aWV3LmNwcAppbmRleCA3YTk4YmFjLi5jNTVjMmQxIDEwMDY0NAotLS0gYS9XZWJL aXQvZWZsL2V3ay9ld2tfdmlldy5jcHAKKysrIGIvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuY3Bw CkBAIC0zMTM5LDYgKzMxMzksMTggQEAgdm9pZCBld2tfdmlld19sb2FkX3N0YXJ0ZWQoRXZhc19P YmplY3QqIG8pCiB7CiAgICAgREJHKCJvPSVwIiwgbyk7CiAgICAgZXZhc19vYmplY3Rfc21hcnRf Y2FsbGJhY2tfY2FsbChvLCAibG9hZCxzdGFydGVkIiwgMCk7CisKKyAgICBld2tfdmlld193aW5k b3dfb2JqZWN0X2NsZWFyZWQobyk7Cit9CisKKy8qKgorICogQHBhcmFtIG8gVmlldworICogVXNl ZCBieSBsYXlvdXQgdGVzdHMgdG8gaW5pdGlhbGl6ZSBzb21lIEphdmFTY3JpcHQgcHJvcGVydGll cworICogRW1pdHMsc2lnbmFsOiAid2luZG93LG9iamVjdCxjbGVhcmVkIiB3b3RoIG5vIHBhcmFt ZXRlcnMKKyAqLwordm9pZCBld2tfdmlld193aW5kb3dfb2JqZWN0X2NsZWFyZWQoRXZhc19PYmpl Y3QqIG8pCit7CisgICAgZXZhc19vYmplY3Rfc21hcnRfY2FsbGJhY2tfY2FsbChvLCAid2luZG93 LG9iamVjdCxjbGVhcmVkIiwgMCk7CiB9CiAKIC8qKgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2VmbC9l d2svZXdrX3ZpZXcuaCBiL1dlYktpdC9lZmwvZXdrL2V3a192aWV3LmgKaW5kZXggOGRkNjE3OC4u YWEwNzkyNiAxMDA2NDQKLS0tIGEvV2ViS2l0L2VmbC9ld2svZXdrX3ZpZXcuaAorKysgYi9XZWJL aXQvZWZsL2V3ay9ld2tfdmlldy5oCkBAIC00ODAsNiArNDgwLDggQEAgRUFQSSBmbG9hdCBld2tf dmlld196b29tX3JhbmdlX21heF9nZXQoRXZhc19PYmplY3QqIG8pOwogRUFQSSB2b2lkIGV3a192 aWV3X3VzZXJfc2NhbGFibGVfc2V0KEV2YXNfT2JqZWN0KiBvLCBFaW5hX0Jvb2wgdXNlcl9zY2Fs YWJsZSk7CiBFQVBJIEVpbmFfQm9vbCBld2tfdmlld191c2VyX3NjYWxhYmxlX2dldChFdmFzX09i amVjdCogbyk7CiAKK0VBUEkgdm9pZCBld2tfdmlld193aW5kb3dfb2JqZWN0X2NsZWFyZWQoRXZh c19PYmplY3QqIG8pOworCiAjaWZkZWYgX19jcGx1c3BsdXMKIH0KICNlbmRpZgo=