22551 2008-11-29 01:08:16 -0800 [GTK] API to start inspector for a WebView 2009-10-28 15:58:01 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED FIXED Gtk P2 Normal --- 1 zuh webkit-unassigned christian gustavo jmalonzo xan.lopez oldest_to_newest 100681 0 zuh 2008-11-29 01:08:16 -0800 The only way to open the inspector currently in the GTK+ port is to use the context menu. This is kind of hard to find, and in any case it would be nice to initiate the inspector from a keyboard shortcut or a button/menuitem in the client UI, specially when the context menu isn't available (touchscreen UI for example). So we need an API to do that for a WebView. 100683 1 25589 zuh 2008-11-29 01:14:50 -0800 Created attachment 25589 New API: void webkit_web_view_inspect(WebKitWebView* web_view) The inspect() method starts the inspector with the document node of either the focused frame or the main frame for the view. I think that's a sane default thing to do... It would be nice to have API to inspect a certain node too, but since we don't have suitable DOM bindings ready yet, that needs to wait. 100685 2 25590 zuh 2008-11-29 01:16:46 -0800 Created attachment 25590 A simple patch for GtkLauncher to test the API 100707 3 zecke 2008-11-29 05:54:20 -0800 Why did you put this in WebKitWebView and not in the WebKitWebInspector? 100708 4 zuh 2008-11-29 07:15:47 -0800 (In reply to comment #3) > Why did you put this in WebKitWebView and not in the WebKitWebInspector? I operated purely on instinct. :) "inspect this view" was the task I set out to accomplish, and webkit_web_view_inspect() seemed the natural way to do that. Logically of course the method does belong to the inspector, the only bad side of that is that it introduces a otherwise (seemingly) worthless get() call (which usually sucks in C API). But I guess it's better to put the implementation where it belongs so I'll just redo the patch to add the API on the inspector. 101677 5 elle.uca 2008-12-06 13:59:40 -0800 Just a question/request: could you extend the API in order to open a specific section of Web Inspector? Something like webkit_web_view_inspect (view, INSPECTOR_RESOURCES); to directly open the Resources section of Web Inspector, (by now the inspector opens in Element section). This could be used by applications like Epiphany to provide a Safari-like "Develop" menu, as well as in features like View->Page Source (see [1] for this) [1] http://bugzilla.gnome.org/show_bug.cgi?id=562446#c7 101697 6 christian 2008-12-06 17:12:48 -0800 (In reply to comment #5) > Just a question/request: could you extend the API in order to open a specific > section of Web Inspector? Something like > > webkit_web_view_inspect (view, INSPECTOR_RESOURCES); > > to directly open the Resources section of Web Inspector, (by now the inspector > opens in Element section). I like that idea very much. I'd like that to also switch an existing inspector to the specified section. I wonder if the 'section' should be a string, since pages might be added in the future or even by the user, I remember seeing that described on a website. Which makes me think of native integration of the inspector. If the artifical toolbar could be hidden, the application could add its own, and merge other application specific views in the same interface. 101978 7 gustavo 2008-12-09 08:41:52 -0800 (In reply to comment #6) > I like that idea very much. I'd like that to also switch an existing inspector > to the specified section. I wonder if the 'section' should be a string, since > pages might be added in the future or even by the user, I remember seeing that > described on a website. The panel seems to currently be indexed by an enum, in the inspector controller. The client doesn't provide facilities for that. What do you suggest for indexing the panel, if not strings? typedef enum { CurrentPanel, ConsolePanel, DatabasesPanel, ElementsPanel, ProfilesPanel, ResourcesPanel, ScriptsPanel } SpecialPanels; > Which makes me think of native integration of the inspector. If the artifical > toolbar could be hidden, the application could add its own, and merge other > application specific views in the same interface. I would love that, yeah. I'm not sure how feasible that is. 101987 8 christian 2008-12-09 10:08:16 -0800 (In reply to comment #7) > (In reply to comment #6) > > I like that idea very much. I'd like that to also switch an existing inspector > > to the specified section. I wonder if the 'section' should be a string, since > > pages might be added in the future or even by the user, I remember seeing that > > described on a website. > > The panel seems to currently be indexed by an enum, in the inspector > controller. The client doesn't provide facilities for that. What do you suggest > for indexing the panel, if not strings? I actually assumed an enumeration when I read the suggestion, so I suggested a string. > > Which makes me think of native integration of the inspector. If the artifical > > toolbar could be hidden, the application could add its own, and merge other > > application specific views in the same interface. > > I would love that, yeah. I'm not sure how feasible that is. I think it should be easy enough. What I'm more worried about is the controls inside the inspector, that is WebKit doesn't support native elements to the extend the inspector would need it. So maybe it would actually be more useful to investigate that and for instance if the toolbar and statusbar had a (mostly) native appearance, we could avoid such workarounds. 118106 9 gustavo 2009-04-20 07:51:08 -0700 I suggest adding this API as proposed, since having a way to programatically open the inspector is important. I agree that providing more flexibility regarding what to inspect, and what tab to open the inspector on are good to have features, but we could add those as APIs to the inspector object, instead, after we work out the dependencies (DOM bindings, and how to specify the "tab"). If nobody is against, I'll r+ this patch. 118111 10 christian 2009-04-20 08:01:13 -0700 (In reply to comment #9) > I suggest adding this API as proposed, since having a way to programatically > open the inspector is important. I agree that providing more flexibility > regarding what to inspect, and what tab to open the inspector on are good to > have features, but we could add those as APIs to the inspector object, instead, > after we work out the dependencies (DOM bindings, and how to specify the > "tab"). If nobody is against, I'll r+ this patch. I'm fine with it. No sense in blocking patches forever. 118114 11 xan.lopez 2009-04-20 08:10:54 -0700 I think I'd rather have all the API in one place, so if there's a consensus that this should go in WebKitWebInspector I think we should put it there to begin with. We can later add functions to inspect specific nodes or to open it in specific pages. 118115 12 xan.lopez 2009-04-20 08:12:32 -0700 (In reply to comment #11) > I think I'd rather have all the API in one place, so if there's a consensus > that this should go in WebKitWebInspector I think we should put it there to > begin with. > > We can later add functions to inspect specific nodes or to open it in specific > pages. > Well, and that being said, is there a reason for not only having the API to open it in a specific page? I don't think that depends on anything, and we could do just that unless somebody thinks having one parameter-less "open in the default page" is a big win. 118117 13 christian 2009-04-20 08:21:41 -0700 (In reply to comment #12) > (In reply to comment #11) > > I think I'd rather have all the API in one place, so if there's a consensus > > that this should go in WebKitWebInspector I think we should put it there to > > begin with. > > > > We can later add functions to inspect specific nodes or to open it in specific > > pages. > > > > Well, and that being said, is there a reason for not only having the API to > open it in a specific page? I don't think that depends on anything, and we > could do just that unless somebody thinks having one parameter-less "open in > the default page" is a big win. I think Gustavo mainly didn't want to let the bug vanish rot, and after the question of choosing pages was raised nobody replied anymore. For what I want, we can have webkit_web_inspector_open (const gchar* page) if that works for you. Using a string to specify the page was suggested earlier and to me seems like the way to go. 118145 14 zuh 2009-04-20 12:10:04 -0700 (In reply to comment #13) > (In reply to comment #12) > > Well, and that being said, is there a reason for not only having the API to > > open it in a specific page? I don't think that depends on anything, and we > > could do just that unless somebody thinks having one parameter-less "open in > > the default page" is a big win. > > I think Gustavo mainly didn't want to let the bug vanish rot, and after the > question of choosing pages was raised nobody replied anymore. > > For what I want, we can have webkit_web_inspector_open (const gchar* page) if > that works for you. Using a string to specify the page was suggested earlier > and to me seems like the way to go. It's slightly nasty, but does give a bit more future- and change-proof API. So something like this perhaps: /** * webkit_web_inspector_inspect: * @web_inspector: a #WebKitWebInspector * @inspector_panel: a string identifying the panel to show * * Activates the #WebKitWebInspector and switches it to the specified inspector * panel. The inspector is activated with the document node of the currently * focused or the main frame of the associated #WebKitWebView. If the panel * string is NULL or specifies an unkown panel, no switching will occur. * * Since: 1.1.6 **/ void webkit_web_inspector_inspect(WebKitWebInspector *web_inspector, const gchar *inspector_panel) followed by inspect_element(web_inspector, inspector_panel, dom_element) as soon as the dom bindings are available. If the above is ok, I'll redo the patch accordingly. Actually I started already, but it's going to take few nights since someone forgot to add the 12 extra hours to a day so there's good time for feedback... 118147 15 25589 zuh 2009-04-20 12:10:51 -0700 Comment on attachment 25589 New API: void webkit_web_view_inspect(WebKitWebView* web_view) Will be redone 118317 16 gustavo 2009-04-21 15:29:54 -0700 (In reply to comment #14) > /** > * webkit_web_inspector_inspect: > * @web_inspector: a #WebKitWebInspector > * @inspector_panel: a string identifying the panel to show > * > * Activates the #WebKitWebInspector and switches it to the specified inspector > * panel. The inspector is activated with the document node of the currently > * focused or the main frame of the associated #WebKitWebView. If the panel > * string is NULL or specifies an unkown panel, no switching will occur. > * > * Since: 1.1.6 > **/ > void webkit_web_inspector_inspect(WebKitWebInspector *web_inspector, > const gchar *inspector_panel) That sounds good to me, but I think the verb has to be changed from inspect to something else. The best option I could come up with up to now is 'start'; I had considered things such as 'show', 'launch', 'present', but these have well-defined meanings in GTK+ already, so I propose using 'start' or 'open' as suggested by Christian, whatever works best for you. > followed by inspect_element(web_inspector, inspector_panel, dom_element) as > soon as the dom bindings are available. Right =). > If the above is ok, I'll redo the patch accordingly. Actually I started > already, but it's going to take few nights since someone forgot to add the 12 > extra hours to a day so there's good time for feedback... Thanks! 118368 17 zuh 2009-04-22 01:19:36 -0700 (In reply to comment #16) > (In reply to comment #14) > > /** > > * webkit_web_inspector_inspect: > > * @web_inspector: a #WebKitWebInspector > > * @inspector_panel: a string identifying the panel to show > > * > > * Activates the #WebKitWebInspector and switches it to the specified inspector > > * panel. The inspector is activated with the document node of the currently > > * focused or the main frame of the associated #WebKitWebView. If the panel > > * string is NULL or specifies an unkown panel, no switching will occur. > > * > > * Since: 1.1.6 > > **/ > > void webkit_web_inspector_inspect(WebKitWebInspector *web_inspector, > > const gchar *inspector_panel) > > That sounds good to me, but I think the verb has to be changed from inspect to > something else. Oh, good point. It worked for the view API but is clearly wrong here. > The best option I could come up with up to now is 'start'; I > had considered things such as 'show', 'launch', 'present', but these have > well-defined meanings in GTK+ already, so I propose using 'start' or 'open' as > suggested by Christian, whatever works best for you. What about _activate()? It would then make sense to use this method to switch the panel in the already visible inspector. And maybe then provide _activate_panel() if someone wants a version that doesn't imply activating the inspector itself. Though _open() works for that too... 118458 18 gustavo 2009-04-22 18:45:56 -0700 (In reply to comment #17) > > The best option I could come up with up to now is 'start'; I > > had considered things such as 'show', 'launch', 'present', but these have > > well-defined meanings in GTK+ already, so I propose using 'start' or 'open' as > > suggested by Christian, whatever works best for you. > > What about _activate()? It would then make sense to use this method to switch > the panel in the already visible inspector. And maybe then provide > _activate_panel() if someone wants a version that doesn't imply activating the > inspector itself. Though _open() works for that too... Could be confused with the activate signal (or at least with its meaning). Ok, I vote for open. 148585 19 christian 2009-09-20 17:29:24 -0700 At this point have webkit_web_inspector_open (inspector, string) would be crucial now that implementing a context menu in the application is feasible. 158140 20 41940 gustavo 2009-10-27 03:09:36 -0700 Created attachment 41940 proposed API Here's my take on it. I propose we start with this simple coordinates-based API, and later on we can add more APIs to inspect with a tab already open, and to inspect a specific DOM element. 158141 21 41941 gustavo 2009-10-27 03:10:56 -0700 Created attachment 41941 Epiphany usage for the API As usual, a patch for Epiphany to use the new API. 158144 22 41940 jmalonzo 2009-10-27 03:28:58 -0700 Comment on attachment 41940 proposed API > +void webkit_web_inspector_inspect_coordinates(WebKitWebInspector* webInspector, gdouble x, gdouble y) What do you think of inspect_node? Also, does x & y need to be (g)doubles? > > +WEBKIT_API void > +webkit_web_inspector_inspect_coordinates(WebKitWebInspector* web_inspector, gdouble x, gdouble y); With this patch, I suppose we can also start enabling the WebInspector tests (which are currently Skipped)? 158153 23 gustavo 2009-10-27 05:13:47 -0700 (In reply to comment #22) > (From update of attachment 41940 [details]) > > +void webkit_web_inspector_inspect_coordinates(WebKitWebInspector* webInspector, gdouble x, gdouble y) > > What do you think of inspect_node? Also, does x & y need to be (g)doubles? I think inspect_node should be reserved for when we have DOM bindings and can give it a proper GDOMNode or something. I am using gdoubles here to match GdkEvent. > > +WEBKIT_API void > > +webkit_web_inspector_inspect_coordinates(WebKitWebInspector* web_inspector, gdouble x, gdouble y); > > With this patch, I suppose we can also start enabling the WebInspector tests > (which are currently Skipped)? Hrm. I'll look at that, good catch! =) 158186 24 41940 xan.lopez 2009-10-27 07:23:54 -0700 Comment on attachment 41940 proposed API >+/** >+ * webkit_web_inspector_inspect_coordinates: >+ * @web_inspector: the #WebKitWebInspector that will do the inspection >+ * @x: the X coordinate of the node to be inspected >+ * @y: the Y coordinate of the node to be inspected >+ * >+ * Causes the Web Inspector to inspect the node that is located at the >+ * given coordinates. >+ */ Missing the "Since:" stuff. >+void webkit_web_inspector_inspect_coordinates(WebKitWebInspector* webInspector, gdouble x, gdouble y) >+{ >+ g_return_if_fail(WEBKIT_IS_WEB_INSPECTOR(webInspector)); Perhaps you could check the coordinates are not negative, while you are it. >+ >+ WebKitWebInspectorPrivate* priv = webInspector->priv; >+ >+ Frame* frame = priv->page->focusController()->focusedOrMainFrame(); >+ FrameView* view = frame->view(); >+ >+ if (!view) >+ return; >+ >+ HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active); >+ IntPoint documentPoint = view->windowToContents(IntPoint(static_cast<int>(x), static_cast<int>(y))); >+ HitTestResult result(documentPoint); >+ >+ frame->contentRenderer()->layer()->hitTest(request, result); >+ priv->page->inspectorController()->inspect(result.innerNonSharedNode()); >+} Looks good to me otherwise, you have my 1/2 r+. 158428 25 41996 gustavo 2009-10-27 17:20:50 -0700 Created attachment 41996 take 2 Now with tests being enabled - required two more APIs, I decided to make one of them public, and the other private, but we may consider making close() private if we are not sure about it. 158448 26 41996 jmalonzo 2009-10-27 18:52:34 -0700 Comment on attachment 41996 take 2 > + // Make the Web Inspector work when running tests > + if (g_file_test("WebCore/inspector/front-end/inspector.html", G_FILE_TEST_EXISTS)) { I believe this will fail in srcdir != builddir scenario when running the tests. Ditto with localizedStrings.js. > +/** > + * webkit_web_inspector_inspect_coordinates: > + * @web_inspector: the #WebKitWebInspector that will do the inspection > + * @x: the X coordinate of the node to be inspected > + * @y: the Y coordinate of the node to be inspected > + * > + * Causes the Web Inspector to inspect the node that is located at the > + * given coordinates. It would be nice to put a note here where to get those coordinates from, and valid values of x & y. > + * > + * Since: 1.1.17 > + */ > +void webkit_web_inspector_inspect_coordinates(WebKitWebInspector* webInspector, gdouble x, gdouble y) > +{ > + g_return_if_fail(WEBKIT_IS_WEB_INSPECTOR(webInspector)); > + g_return_if_fail((x >= 0) && (y >= 0)); I really think we should just make x & y guints so we don't need to do checks like these and the int casts below. The usage in the epiphany patch also casts the int to double unnecessarily. > + HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active); > + IntPoint documentPoint = view->windowToContents(IntPoint(static_cast<int>(x), static_cast<int>(y))); > + HitTestResult result(documentPoint); > + 158511 27 gustavo 2009-10-28 04:04:37 -0700 (In reply to comment #26) > (From update of attachment 41996 [details]) > > + // Make the Web Inspector work when running tests > > + if (g_file_test("WebCore/inspector/front-end/inspector.html", G_FILE_TEST_EXISTS)) { > > I believe this will fail in srcdir != builddir scenario when running the tests. > Ditto with localizedStrings.js. It should work fine, I am testing in such a scenario - the same used by the buildbot. The only thing that needs to happen is you need to be at the $srcdir when running the tests (which is what happens in the bot). I would prefer doing something more flexible, but have no idea of how. > > + * Causes the Web Inspector to inspect the node that is located at the > > + * given coordinates. > > It would be nice to put a note here where to get those coordinates from, and > valid values of x & y. Sounds fair. The most common way would be getting them from a mouse press GdkEvent, I believe (coming from handling the button_press_event). > > + g_return_if_fail(WEBKIT_IS_WEB_INSPECTOR(webInspector)); > > + g_return_if_fail((x >= 0) && (y >= 0)); > > I really think we should just make x & y guints so we don't need to do checks > like these and the int casts below. > The usage in the epiphany patch also casts the int to double unnecessarily. I don't have a too strong opinion on this. I am just following what's in GdkEvent, really. In Epiphany we have to cast back because the EphyEmbedEvent object stores this information as int. I am assuming that is a historical artifact from gecko times, and most API users would instead use GdkEvent directly. http://library.gnome.org/devel/gdk/unstable/gdk-Events.html#gdk-event-get-coords Xan, do you want to untie this? =) 158512 28 xan.lopez 2009-10-28 04:11:29 -0700 (In reply to comment #27) > I don't have a too strong opinion on this. I am just following what's in > GdkEvent, really. In Epiphany we have to cast back because the EphyEmbedEvent > object stores this information as int. I am assuming that is a historical > artifact from gecko times, and most API users would instead use GdkEvent > directly. > > http://library.gnome.org/devel/gdk/unstable/gdk-Events.html#gdk-event-get-coords > > Xan, do you want to untie this? =) Since doubles are used in GTK+ to store coordinates I prefer having the API accept doubles. Better for us to cast it than having everyone do so. Also, + g_return_if_fail((x >= 0) && (y >= 0)); Unneeded parenthesis. +void webkit_web_inspector_execute_script(WebKitWebInspector* webInspector, long callId, const gchar* script) +{ + g_return_if_fail(WEBKIT_IS_WEB_INSPECTOR(webInspector)); That could at least test script is not NULL, I guess? 158526 29 42014 gustavo 2009-10-28 05:32:12 -0700 Created attachment 42014 take 3 Improved docs, and checks as requested by Jan, and Xan. 158652 30 jmalonzo 2009-10-28 12:00:12 -0700 (In reply to comment #27) > (In reply to comment #26) > > (From update of attachment 41996 [details] [details]) > > > + // Make the Web Inspector work when running tests > > > + if (g_file_test("WebCore/inspector/front-end/inspector.html", G_FILE_TEST_EXISTS)) { > > > > I believe this will fail in srcdir != builddir scenario when running the tests. > > Ditto with localizedStrings.js. > > It should work fine, I am testing in such a scenario - the same used by the > buildbot. The only thing that needs to happen is you need to be at the $srcdir > when running the tests (which is what happens in the bot). I would prefer doing > something more flexible, but have no idea of how. It's ok for now. r=me. 158759 31 gustavo 2009-10-28 15:58:01 -0700 Landed as r50245. 25589 2008-11-29 01:14:50 -0800 2009-04-20 12:10:51 -0700 New API: void webkit_web_view_inspect(WebKitWebView* web_view) webview-inspect-api.diff text/plain 2140 zuh ZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cK aW5kZXggNTdhNjQ3OS4uNDViZDFiNiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cK KysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMiBAQAorMjAwOC0xMS0yOSAg S2FsbGUgVmFobG1hbiAgPGthbGxlLnZhaGxtYW5AbW92aWFsLmNvbT4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgR1RLKyBBUEkgdG8gaW5pdGlh dGUgdGhlIFdlYkluc3BlY3RvciBwcm9ncmFtbWF0aWNhbGx5IGZvciBhIFdlYlZpZXcuCisKKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisgICAgICAgICogd2Via2l0L3dlYmtp dHdlYnZpZXcuaDoKKwogMjAwOC0xMS0yOCAgSG9sZ2VyIEhhbnMgUGV0ZXIgRnJleXRoZXIgIDx6 ZWNrZUBzZWxmaXNoLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBOaWtvbGFzIFppbW1lcm1h bm4uCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IGI2MzZkZDUuLjI3MTYxMDUg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0xNzA0LDYgKzE3MDQsMjYgQEAg V2ViS2l0V2ViSW5zcGVjdG9yKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3RvcihXZWJLaXRX ZWJWaWV3KiB3ZWJWaWV3KQogfQogCiAvKioKKyAqIHdlYmtpdF93ZWJfdmlld19pbnNwZWN0Ogor ICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJWaWV3CisgKgorICogQWN0aXZhdGVzIHRoZSAjV2Vi S2l0V2ViSW5zcGVjdG9yIGFzc29jaWF0ZWQgd2l0aCB0aGUKKyAqICNXZWJLaXRXZWJWaWV3LiBU aGUgaW5zcGVjdG9yIGlzIHN0YXJ0ZWQgd2l0aCB0aGUgZG9jdW1lbnQKKyAqIG5vZGUgb2YgdGhl IGN1cnJlbnRseSBmb2N1c2VkIGZyYW1lLCBvciB0aGUgbWFpbiBmcmFtZSBvZgorICogdGhlICNX ZWJLaXRXZWJWaWV3LgorICoKKyAqIFNpbmNlOiAxLjAuMworICovCit2b2lkIHdlYmtpdF93ZWJf dmlld19pbnNwZWN0KFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCit7CisgICAgZ19yZXR1cm5faWZf ZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViVmlldykpOworCisgICAgRnJhbWUqIGZyYW1lID0g Y29yZSh3ZWJWaWV3KS0+Zm9jdXNDb250cm9sbGVyKCktPmZvY3VzZWRPck1haW5GcmFtZSgpOwor CisgICAgY29yZSh3ZWJWaWV3KS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLT5pbnNwZWN0KGZyYW1l LT5kb2N1bWVudCgpKTsKK30KKworLyoqCiAgKiB3ZWJraXRfd2ViX3ZpZXdfc2V0X3dpbmRvd19m ZWF0dXJlcwogICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJWaWV3CiAgKiBAd2luZG93X2ZlYXR1 cmVzOiBhICNXZWJLaXRXZWJXaW5kb3dGZWF0dXJlcwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2Vidmlldy5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5o CmluZGV4IDIxOGJmNzguLjlhZmU5ZWEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKQEAg LTI1Myw2ICsyNTMsOSBAQCBXRUJLSVRfQVBJIFdlYktpdFdlYkluc3BlY3RvciAqCiB3ZWJraXRf d2ViX3ZpZXdfZ2V0X2luc3BlY3RvciAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAg ICAgICAgKndlYl92aWV3KTsKIAogV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfd2ViX3ZpZXdfaW5z cGVjdCAgICAgICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92 aWV3KTsKKworV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X3dpbmRvd19mZWF0 dXJlcyAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3LAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdlYktpdFdlYldpbmRv d0ZlYXR1cmVzICp3aW5kb3dfZmVhdHVyZXMpOwogCg== 25590 2008-11-29 01:16:46 -0800 2009-10-27 03:10:56 -0700 A simple patch for GtkLauncher to test the API webview-inspect-gtklauncher.diff text/plain 977 zuh ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYyBiL1dlYktpdFRvb2xz L0d0a0xhdW5jaGVyL21haW4uYwppbmRleCA0YzdiYmE4Li44ZWI0ZjQ2IDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKKysrIGIvV2ViS2l0VG9vbHMvR3RrTGF1bmNo ZXIvbWFpbi5jCkBAIC0zNiw2ICszNiwxMyBAQCBzdGF0aWMgZ2ludCBsb2FkX3Byb2dyZXNzOwog c3RhdGljIGd1aW50IHN0YXR1c19jb250ZXh0X2lkOwogc3RhdGljIEd0a1dpZGdldCogaW5zcGVj dG9yX3dpbmRvdzsKIAorCitzdGF0aWMgdm9pZAorYWN0aXZhdGVfaW5zcGVjdG9yX2NiIChHdGtX aWRnZXQqIGVudHJ5LCBncG9pbnRlciBkYXRhKQoreworICAgIHdlYmtpdF93ZWJfdmlld19pbnNw ZWN0ICh3ZWJfdmlldyk7Cit9CisKIHN0YXRpYyB2b2lkCiBhY3RpdmF0ZV91cmlfZW50cnlfY2Ig KEd0a1dpZGdldCogZW50cnksIGdwb2ludGVyIGRhdGEpCiB7CkBAIC0yNTcsNiArMjY0LDExIEBA IGNyZWF0ZV90b29sYmFyICgpCiAgICAgZ19zaWduYWxfY29ubmVjdF9zd2FwcGVkIChHX09CSkVD VCAoaXRlbSksICJjbGlja2VkIiwgR19DQUxMQkFDSyAoYWN0aXZhdGVfdXJpX2VudHJ5X2NiKSwg KGdwb2ludGVyKXVyaV9lbnRyeSk7CiAgICAgZ3RrX3Rvb2xiYXJfaW5zZXJ0IChHVEtfVE9PTEJB UiAodG9vbGJhciksIGl0ZW0sIC0xKTsKIAorICAgIC8qIFRoZSBnbyBidXR0b24gKi8KKyAgICBp dGVtID0gZ3RrX3Rvb2xfYnV0dG9uX25ld19mcm9tX3N0b2NrIChHVEtfU1RPQ0tfRklORCk7Cisg ICAgZ19zaWduYWxfY29ubmVjdCAoR19PQkpFQ1QgKGl0ZW0pLCAiY2xpY2tlZCIsIEdfQ0FMTEJB Q0sgKGFjdGl2YXRlX2luc3BlY3Rvcl9jYiksIE5VTEwpOworICAgIGd0a190b29sYmFyX2luc2Vy dCAoR1RLX1RPT0xCQVIgKHRvb2xiYXIpLCBpdGVtLCAtMSk7CisKICAgICByZXR1cm4gdG9vbGJh cjsKIH0KIAo= 41940 2009-10-27 03:09:36 -0700 2009-10-27 17:20:50 -0700 proposed API 0001-Provide-a-simple-coordinates-based-API-to-start-the-.patch text/plain 4101 gustavo RnJvbSBhNjViNGY2MzU2YzU5M2ExY2E3MWU1ZTk1OWQ1ZDk3MjVjNjg1ZTMyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMDg6MDc6MzggLTAyMDAK U3ViamVjdDogW1BBVENIXSBQcm92aWRlIGEgc2ltcGxlLCBjb29yZGluYXRlcy1iYXNlZCBBUEkg dG8gc3RhcnQgdGhlIGluc3BlY3Rvci4KCi0tLQogV2ViS2l0L2d0ay9DaGFuZ2VMb2cgICAgICAg ICAgICAgICAgICAgICB8ICAgMTMgKysrKysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJpbnNwZWN0b3IuY3BwIHwgICA0MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrLQogV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmggICB8ICAgIDMgKysKIDMgZmlsZXMg Y2hhbmdlZCwgNTYgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9X ZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IDZlZmVkYjIu LmNlMDJlZDIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9n dGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDktMTAtMjcgIEd1c3Rhdm8gTm9yb25o YSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10gQVBJIHRvIHN0YXJ0IGlu c3BlY3RvciBmb3IgYSBXZWJWaWV3CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMjU1MQorCisgICAgICAgIFByb3ZpZGUgYSBzaW1wbGUsIGNvb3JkaW5h dGVzLWJhc2VkIEFQSSB0byBzdGFydCB0aGUgaW5zcGVjdG9yLgorCisgICAgICAgICogd2Via2l0 L3dlYmtpdHdlYmluc3BlY3Rvci5jcHA6CisgICAgICAgICh3ZWJraXRfd2ViX2luc3BlY3Rvcl9p bnNwZWN0X2Nvb3JkaW5hdGVzKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9y Lmg6CisKIDIwMDktMTAtMjYgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CiAKICAgICAgICAgVW5yZXZpZXdlZC4gVXBkYXRlIGRvY3VtZW50 YXRpb24gY29udHJvbCBmaWxlcyBmb3IgMS4xLjE2LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl Ymluc3BlY3Rvci5jcHAKaW5kZXggNGU0ZjhkZS4uNGM1NDI3MSAxMDA2NDQKLS0tIGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJpbnNwZWN0b3IuY3BwCkBAIC0xLDYgKzEsNyBAQAogLyoKICAqIENvcHlyaWdo dCAoQykgMjAwOCBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKICAqIENvcHlyaWdodCAoQykgMjAwOCwg MjAwOSBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgorICogQ29weXJpZ2h0IChDKSAyMDA5IENv bGxhYm9yYSBMdGQuCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTE5LDExICsyMCwxOCBAQAogICov CiAKICNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJ3ZWJraXR3ZWJpbnNwZWN0b3IuaCIK IAorI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgorI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5j bHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KLSNpbmNsdWRlICJ3ZWJraXR3ZWJpbnNwZWN0b3IuaCIK LSNpbmNsdWRlICJ3ZWJraXRtYXJzaGFsLmgiCisjaW5jbHVkZSAiSGl0VGVzdFJlcXVlc3QuaCIK KyNpbmNsdWRlICJIaXRUZXN0UmVzdWx0LmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9yQ2xpZW50R3Rr LmgiCisjaW5jbHVkZSAiSW50UG9pbnQuaCIKKyNpbmNsdWRlICJQYWdlLmgiCisjaW5jbHVkZSAi UmVuZGVyVmlldy5oIgorI2luY2x1ZGUgIndlYmtpdG1hcnNoYWwuaCIKICNpbmNsdWRlICJ3ZWJr aXRwcml2YXRlLmgiCiAKIC8qKgpAQCAtNTYsNiArNjQsNyBAQAogICovCiAKIHVzaW5nIG5hbWVz cGFjZSBXZWJLaXQ7Cit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIAogZW51bSB7CiAgICAgSU5T UEVDVF9XRUJfVklFVywKQEAgLTQyNiwzICs0MzUsMzIgQEAgd2Via2l0X3dlYl9pbnNwZWN0b3Jf c2V0X2luc3BlY3Rvcl9jbGllbnQoV2ViS2l0V2ViSW5zcGVjdG9yKiB3ZWJfaW5zcGVjdG9yLCBX ZWIKIAogICAgIHByaXYtPnBhZ2UgPSBwYWdlOwogfQorCisvKioKKyAqIHdlYmtpdF93ZWJfaW5z cGVjdG9yX2luc3BlY3RfY29vcmRpbmF0ZXM6CisgKiBAd2ViX2luc3BlY3RvcjogdGhlICNXZWJL aXRXZWJJbnNwZWN0b3IgdGhhdCB3aWxsIGRvIHRoZSBpbnNwZWN0aW9uCisgKiBAeDogdGhlIFgg Y29vcmRpbmF0ZSBvZiB0aGUgbm9kZSB0byBiZSBpbnNwZWN0ZWQKKyAqIEB5OiB0aGUgWSBjb29y ZGluYXRlIG9mIHRoZSBub2RlIHRvIGJlIGluc3BlY3RlZAorICoKKyAqIENhdXNlcyB0aGUgV2Vi IEluc3BlY3RvciB0byBpbnNwZWN0IHRoZSBub2RlIHRoYXQgaXMgbG9jYXRlZCBhdCB0aGUKKyAq IGdpdmVuIGNvb3JkaW5hdGVzLgorICovCit2b2lkIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2luc3Bl Y3RfY29vcmRpbmF0ZXMoV2ViS2l0V2ViSW5zcGVjdG9yKiB3ZWJJbnNwZWN0b3IsIGdkb3VibGUg eCwgZ2RvdWJsZSB5KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9JTlNQ RUNUT1Iod2ViSW5zcGVjdG9yKSk7CisKKyAgICBXZWJLaXRXZWJJbnNwZWN0b3JQcml2YXRlKiBw cml2ID0gd2ViSW5zcGVjdG9yLT5wcml2OworCisgICAgRnJhbWUqIGZyYW1lID0gcHJpdi0+cGFn ZS0+Zm9jdXNDb250cm9sbGVyKCktPmZvY3VzZWRPck1haW5GcmFtZSgpOworICAgIEZyYW1lVmll dyogdmlldyA9IGZyYW1lLT52aWV3KCk7CisKKyAgICBpZiAoIXZpZXcpCisgICAgICAgIHJldHVy bjsKKworICAgIEhpdFRlc3RSZXF1ZXN0IHJlcXVlc3QoSGl0VGVzdFJlcXVlc3Q6OlJlYWRPbmx5 IHwgSGl0VGVzdFJlcXVlc3Q6OkFjdGl2ZSk7CisgICAgSW50UG9pbnQgZG9jdW1lbnRQb2ludCA9 IHZpZXctPndpbmRvd1RvQ29udGVudHMoSW50UG9pbnQoc3RhdGljX2Nhc3Q8aW50Pih4KSwgc3Rh dGljX2Nhc3Q8aW50Pih5KSkpOworICAgIEhpdFRlc3RSZXN1bHQgcmVzdWx0KGRvY3VtZW50UG9p bnQpOworCisgICAgZnJhbWUtPmNvbnRlbnRSZW5kZXJlcigpLT5sYXllcigpLT5oaXRUZXN0KHJl cXVlc3QsIHJlc3VsdCk7CisgICAgcHJpdi0+cGFnZS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLT5p bnNwZWN0KHJlc3VsdC5pbm5lck5vblNoYXJlZE5vZGUoKSk7Cit9CmRpZmYgLS1naXQgYS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJpbnNwZWN0b3IuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYmluc3BlY3Rvci5oCmluZGV4IDkwMTBlMjYuLjAzNTE4OTkgMTAwNjQ0Ci0tLSBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmluc3BlY3Rvci5oCisrKyBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYmluc3BlY3Rvci5oCkBAIC02MCw2ICs2MCw5IEBAIHdlYmtpdF93ZWJfaW5z cGVjdG9yX2dldF93ZWJfdmlldyhXZWJLaXRXZWJJbnNwZWN0b3IqIHdlYl9pbnNwZWN0b3IpOwog V0VCS0lUX0FQSSBjb25zdCBnY2hhcioKIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2dldF9pbnNwZWN0 ZWRfdXJpKFdlYktpdFdlYkluc3BlY3Rvciogd2ViX2luc3BlY3Rvcik7CiAKK1dFQktJVF9BUEkg dm9pZAord2Via2l0X3dlYl9pbnNwZWN0b3JfaW5zcGVjdF9jb29yZGluYXRlcyhXZWJLaXRXZWJJ bnNwZWN0b3IqIHdlYl9pbnNwZWN0b3IsIGdkb3VibGUgeCwgZ2RvdWJsZSB5KTsKKwogR19FTkRf REVDTFMKIAogI2VuZGlmIC8qIHdlYmtpdHdlYmluc3BlY3Rvcl9oICovCi0tIAoxLjYuNQoK 41941 2009-10-27 03:10:56 -0700 2009-10-27 03:10:56 -0700 Epiphany usage for the API 0001-Provide-the-Inspect-Element-menu-item-again.patch text/plain 4436 gustavo RnJvbSA4NTNlMDMxMjYwODYyYjZlOTY3ZGM4NmFjNDRjYmI4MTgyNmFjMGIxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGduc0Bnbm9tZS5vcmc+ CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMDg6MDk6NTcgLTAyMDAKU3ViamVjdDogW1BBVENIXSBQ cm92aWRlIHRoZSBJbnNwZWN0IEVsZW1lbnQgbWVudSBpdGVtIGFnYWluCgotLS0KIGRhdGEvdWkv ZXBpcGhhbnktdWkueG1sIHwgICAgOCArKysrKysrKwogc3JjL2VwaHktd2luZG93LmMgICAgICAg fCAgICA5ICsrKysrKysrKwogc3JjL3BvcHVwLWNvbW1hbmRzLmMgICAgfCAgIDIxICsrKysrKysr KysrKysrKysrKysrKwogc3JjL3BvcHVwLWNvbW1hbmRzLmggICAgfCAgICAzICsrKwogNCBmaWxl cyBjaGFuZ2VkLCA0MSBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L2RhdGEvdWkvZXBpcGhhbnktdWkueG1sIGIvZGF0YS91aS9lcGlwaGFueS11aS54bWwKaW5kZXgg MWYzZGNhYy4uMTdhZTdmNSAxMDA2NDQKLS0tIGEvZGF0YS91aS9lcGlwaGFueS11aS54bWwKKysr IGIvZGF0YS91aS9lcGlwaGFueS11aS54bWwKQEAgLTExNyw2ICsxMTcsOCBAQAogCQk8bWVudWl0 ZW0gbmFtZT0iU2F2ZUltYWdlQXNJUCIgYWN0aW9uPSJTYXZlSW1hZ2VBcyIvPgogCQk8bWVudWl0 ZW0gbmFtZT0iU2V0SW1hZ2VBc0JhY2tncm91bmRJUCIgYWN0aW9uPSJTZXRJbWFnZUFzQmFja2dy b3VuZCIvPgogCQk8bWVudWl0ZW0gbmFtZT0iQ29weUltYWdlTG9jYXRpb25JUCIgYWN0aW9uPSJD b3B5SW1hZ2VMb2NhdGlvbiIvPgorICAgICAgICAgICAgICAgIDxzZXBhcmF0b3IgLz4KKwkJPG1l bnVpdGVtIG5hbWU9Ikluc3BlY3RFbGVtZW50SVAiIGFjdGlvbj0iSW5zcGVjdEVsZW1lbnQiLz4K IAk8L3BvcHVwPgogCiAJPHBvcHVwIG5hbWU9IkVwaHlEb2N1bWVudFBvcHVwIiBhY3Rpb249IlBv cHVwQWN0aW9uIj4KQEAgLTEzNCw2ICsxMzYsOCBAQAogCQk8bWVudWl0ZW0gbmFtZT0iU2F2ZUlt YWdlQXNEUCIgYWN0aW9uPSJTYXZlSW1hZ2VBcyIvPgogCQk8bWVudWl0ZW0gbmFtZT0iU2V0SW1h Z2VBc0JhY2tncm91bmREUCIgYWN0aW9uPSJTZXRJbWFnZUFzQmFja2dyb3VuZCIvPgogCQk8bWVu dWl0ZW0gbmFtZT0iQ29weUltYWdlTG9jYXRpb25EUCIgYWN0aW9uPSJDb3B5SW1hZ2VMb2NhdGlv biIvPgorICAgICAgICAgICAgICAgIDxzZXBhcmF0b3IgLz4KKwkJPG1lbnVpdGVtIG5hbWU9Iklu c3BlY3RFbGVtZW50RFAiIGFjdGlvbj0iSW5zcGVjdEVsZW1lbnQiLz4KIAk8L3BvcHVwPgogCiAJ PHBvcHVwIG5hbWU9IkVwaHlMaW5rUG9wdXAiIGFjdGlvbj0iUG9wdXBBY3Rpb24iPgpAQCAtMTUy LDYgKzE1Niw4IEBACiAJCTxtZW51aXRlbSBuYW1lPSJTYXZlSW1hZ2VBc0xQIiBhY3Rpb249IlNh dmVJbWFnZUFzIi8+CiAJCTxtZW51aXRlbSBuYW1lPSJTZXRJbWFnZUFzQmFja2dyb3VuZExQIiBh Y3Rpb249IlNldEltYWdlQXNCYWNrZ3JvdW5kIi8+CiAJCTxtZW51aXRlbSBuYW1lPSJDb3B5SW1h Z2VMb2NhdGlvbkxQIiBhY3Rpb249IkNvcHlJbWFnZUxvY2F0aW9uIi8+CisgICAgICAgICAgICAg ICAgPHNlcGFyYXRvciAvPgorCQk8bWVudWl0ZW0gbmFtZT0iSW5zcGVjdEVsZW1lbnRMUCIgYWN0 aW9uPSJJbnNwZWN0RWxlbWVudCIvPgogCTwvcG9wdXA+CiAKIAk8cG9wdXAgbmFtZT0iRXBoeUVt YWlsTGlua1BvcHVwIiBhY3Rpb249IlBvcHVwQWN0aW9uIj4KQEAgLTE2NCw2ICsxNzAsOCBAQAog CQk8bWVudWl0ZW0gbmFtZT0iU2F2ZUltYWdlQXNFTFAiIGFjdGlvbj0iU2F2ZUltYWdlQXMiLz4K IAkJPG1lbnVpdGVtIG5hbWU9IlNldEltYWdlQXNCYWNrZ3JvdW5kRUxQIiBhY3Rpb249IlNldElt YWdlQXNCYWNrZ3JvdW5kIi8+CiAJCTxtZW51aXRlbSBuYW1lPSJDb3B5SW1hZ2VMb2NhdGlvbkVM UCIgYWN0aW9uPSJDb3B5SW1hZ2VMb2NhdGlvbiIvPgorICAgICAgICAgICAgICAgIDxzZXBhcmF0 b3IgLz4KKwkJPG1lbnVpdGVtIG5hbWU9Ikluc3BlY3RFbGVtZW50RUxQIiBhY3Rpb249Ikluc3Bl Y3RFbGVtZW50Ii8+CiAJPC9wb3B1cD4KIAogCTxwb3B1cCBuYW1lPSJFcGh5Tm90ZWJvb2tQb3B1 cCIgYWN0aW9uPSJOb3RlYm9va1BvcHVwQWN0aW9uIj4KZGlmZiAtLWdpdCBhL3NyYy9lcGh5LXdp bmRvdy5jIGIvc3JjL2VwaHktd2luZG93LmMKaW5kZXggZGYwYzdkZi4uMGFlYzdiZiAxMDA2NDQK LS0tIGEvc3JjL2VwaHktd2luZG93LmMKKysrIGIvc3JjL2VwaHktd2luZG93LmMKQEAgLTM0NSw2 ICszNDUsMTAgQEAgc3RhdGljIGNvbnN0IEd0a0FjdGlvbkVudHJ5IGVwaHlfcG9wdXBzX2VudHJp ZXMgW10gPSB7CiAJICBOVUxMLCBOVUxMIH0sCiAJeyAiU3RvcEltYWdlQW5pbWF0aW9uIiwgTlVM TCwgTl8oIlN0X29wIEFuaW1hdGlvbiIpLCBOVUxMLAogCSAgTlVMTCwgTlVMTCB9LAorCisJLyog SW5zcGVjdG9yICovCisJeyAiSW5zcGVjdEVsZW1lbnQiLCBOVUxMLCBOXygiSW5zcGVjdCBFbGVt ZW50IiksIE5VTEwsCisJICBOVUxMLCBHX0NBTExCQUNLIChwb3B1cF9jbWRfaW5zcGVjdF9lbGVt ZW50KSB9LAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdApAQCAtMTExOSw2ICsxMTIzLDcgQEAg dXBkYXRlX3BvcHVwX2FjdGlvbnNfdmlzaWJpbGl0eSAoRXBoeVdpbmRvdyAqd2luZG93LAogewog CUd0a0FjdGlvbiAqYWN0aW9uOwogCUd0a0FjdGlvbkdyb3VwICphY3Rpb25fZ3JvdXA7CisJZ2Jv b2xlYW4gaW5zcGVjdG9yX2VuYWJsZWQ7CiAKIAlhY3Rpb25fZ3JvdXAgPSB3aW5kb3ctPnByaXYt PnBvcHVwc19hY3Rpb25fZ3JvdXA7CiAKQEAgLTExMzMsNiArMTEzOCwxMCBAQCB1cGRhdGVfcG9w dXBfYWN0aW9uc192aXNpYmlsaXR5IChFcGh5V2luZG93ICp3aW5kb3csCiAKIAlhY3Rpb24gPSBn dGtfYWN0aW9uX2dyb3VwX2dldF9hY3Rpb24gKGFjdGlvbl9ncm91cCwgIk9wZW5GcmFtZSIpOwog CWd0a19hY3Rpb25fc2V0X3Zpc2libGUgKGFjdGlvbiwgaXNfZnJhbWUpOworCisJaW5zcGVjdG9y X2VuYWJsZWQgPSBlZWxfZ2NvbmZfZ2V0X2Jvb2xlYW4gKENPTkZfV0VCX0lOU1BFQ1RPUl9FTkFC TEVEKTsKKwlhY3Rpb24gPSBndGtfYWN0aW9uX2dyb3VwX2dldF9hY3Rpb24gKGFjdGlvbl9ncm91 cCwgIkluc3BlY3RFbGVtZW50Iik7CisJZ3RrX2FjdGlvbl9zZXRfdmlzaWJsZSAoYWN0aW9uLCBp bnNwZWN0b3JfZW5hYmxlZCk7CiB9CiAKIHN0YXRpYyB2b2lkCmRpZmYgLS1naXQgYS9zcmMvcG9w dXAtY29tbWFuZHMuYyBiL3NyYy9wb3B1cC1jb21tYW5kcy5jCmluZGV4IGNiYWYxZTQuLjc1NTgx N2UgMTAwNjQ0Ci0tLSBhL3NyYy9wb3B1cC1jb21tYW5kcy5jCisrKyBiL3NyYy9wb3B1cC1jb21t YW5kcy5jCkBAIC01MjEsMyArNTIxLDI0IEBAIHBvcHVwX2NtZF9vcGVuX2ltYWdlIChHdGtBY3Rp b24gKmFjdGlvbiwKIAlnX3ZhbHVlX3Vuc2V0ICgmdmFsdWUpOwogCWdfZnJlZSAoc2NoZW1lKTsK IH0KKwordm9pZAorcG9wdXBfY21kX2luc3BlY3RfZWxlbWVudCAoR3RrQWN0aW9uICphY3Rpb24s IEVwaHlXaW5kb3cgKndpbmRvdykKK3sKKwlFcGh5RW1iZWRFdmVudCAqZXZlbnQ7CisJRXBoeUVt YmVkICplbWJlZDsKKwlXZWJLaXRXZWJJbnNwZWN0b3IgKmluc3BlY3RvcjsKKwlndWludCB4LCB5 OworCisJZW1iZWQgPSBlcGh5X2VtYmVkX2NvbnRhaW5lcl9nZXRfYWN0aXZlX2NoaWxkCisJCShF UEhZX0VNQkVEX0NPTlRBSU5FUiAod2luZG93KSk7CisKKwlldmVudCA9IGVwaHlfd2luZG93X2dl dF9jb250ZXh0X2V2ZW50ICh3aW5kb3cpOworCWdfcmV0dXJuX2lmX2ZhaWwgKGV2ZW50ICE9IE5V TEwpOworCisJaW5zcGVjdG9yID0gd2Via2l0X3dlYl92aWV3X2dldF9pbnNwZWN0b3IKKwkJKEVQ SFlfR0VUX1dFQktJVF9XRUJfVklFV19GUk9NX0VNQkVEIChlbWJlZCkpOworCisJZXBoeV9lbWJl ZF9ldmVudF9nZXRfY29vcmRzIChldmVudCwgJngsICZ5KTsKKwl3ZWJraXRfd2ViX2luc3BlY3Rv cl9pbnNwZWN0X2Nvb3JkaW5hdGVzIChpbnNwZWN0b3IsIChnZG91YmxlKXgsIChnZG91YmxlKXkp OworfQpkaWZmIC0tZ2l0IGEvc3JjL3BvcHVwLWNvbW1hbmRzLmggYi9zcmMvcG9wdXAtY29tbWFu ZHMuaAppbmRleCBiMTUzMWJkLi5kZGZjNjc2IDEwMDY0NAotLS0gYS9zcmMvcG9wdXAtY29tbWFu ZHMuaAorKysgYi9zcmMvcG9wdXAtY29tbWFuZHMuaApAQCAtNjUsMyArNjUsNiBAQCB2b2lkIHBv cHVwX2NtZF9kb3dubG9hZF9saW5rCQkoR3RrQWN0aW9uICphY3Rpb24sCiAKIHZvaWQgcG9wdXBf Y21kX3NhdmVfaW1hZ2VfYXMJCShHdGtBY3Rpb24gKmFjdGlvbiwKIAkJCQkJIEVwaHlXaW5kb3cg KndpbmRvdyk7CisKK3ZvaWQgcG9wdXBfY21kX2luc3BlY3RfZWxlbWVudAkJKEd0a0FjdGlvbiAq YWN0aW9uLAorCQkJCQkgRXBoeVdpbmRvdyAqd2luZG93KTsKLS0gCjEuNi41Cgo= 41996 2009-10-27 17:20:50 -0700 2009-10-28 05:32:12 -0700 take 2 0001-Provide-a-simple-coordinates-based-API-to-start-the-.patch text/plain 14299 gustavo RnJvbSA4YWVlOGZlMDM1ODk4NGUxNDQ2NzM3YjhkYmI0NzBlODMwNWM0ZGFiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMDg6MDc6MzggLTAyMDAK U3ViamVjdDogW1BBVENIXSBQcm92aWRlIGEgc2ltcGxlLCBjb29yZGluYXRlcy1iYXNlZCBBUEkg dG8gc3RhcnQgdGhlIGluc3BlY3Rvci4KCi0tLQogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDExICsrKwogTGF5b3V0VGVzdHMvcGxhdGZvcm0v Z3RrL1NraXBwZWQgICAgICAgICAgICAgICAgICAgfCAgICA5IC0tLQogV2ViS2l0L2d0ay9DaGFu Z2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIwICsrKysrKwogV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9JbnNwZWN0b3JDbGllbnRHdGsuY3BwICAgfCAgIDI2ICsrKysr Ky0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCAgICAgICAgICAgICAgICAgIHwg ICAgNCArCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJpbnNwZWN0b3IuY3BwICAgICAgICAg ICB8ICAgNjkgKysrKysrKysrKysrKysrKysrKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl Ymluc3BlY3Rvci5oICAgICAgICAgICAgIHwgICAgNiArKwogV2ViS2l0VG9vbHMvQ2hhbmdlTG9n ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE4ICsrKysrCiBXZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwICB8ICAgIDggKysKIC4uLi9EdW1w UmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3BwIHwgICAyMiArKysrKyst CiAxMCBmaWxlcyBjaGFuZ2VkLCAxNzUgaW5zZXJ0aW9ucygrKSwgMTggZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CmluZGV4IDkwMTkxOGUuLmJiZTU1ZmYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxv ZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAwOS0xMC0y NyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51 az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR1RL XSBBUEkgdG8gc3RhcnQgaW5zcGVjdG9yIGZvciBhIFdlYlZpZXcKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNTUxCisKKyAgICAgICAgVW5za2lwIGlu c3BlY3RvciB0ZXN0cyB0aGF0IHdlIGFyZSBub3cgYWJsZSB0byBydW4uCisKKyAgICAgICAgKiBw bGF0Zm9ybS9ndGsvU2tpcHBlZDoKKwogMjAwOS0xMC0yNyAgUnlvc3VrZSBOaXdhICA8cm5pd2FA d2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRlbC4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkIGIvTGF5b3V0VGVzdHMvcGxhdGZv cm0vZ3RrL1NraXBwZWQKaW5kZXggNGJiZjVhZi4uOWJhNmRkMSAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3Rr L1NraXBwZWQKQEAgLTM1NzIsMTUgKzM1NzIsNiBAQCBodHRwL3Rlc3RzL3dlYmFyY2hpdmUvdGVz dC1jc3MtdXJsLWVuY29kaW5nLXV0Zi04Lmh0bWwKIGh0dHAvdGVzdHMvd2ViYXJjaGl2ZS90ZXN0 LWNzcy11cmwtZW5jb2RpbmcuaHRtbAogaHR0cC90ZXN0cy93ZWJhcmNoaXZlL3Rlc3QtcHJlbG9h ZC1yZXNvdXJjZXMuaHRtbAogCi0jIFRlc3RzIGluIGluc3BlY3Rvci8gZGlyZWN0b3J5Ci0jICAg VGVzdHMgZmFpbGluZwotaW5zcGVjdG9yL2NvbnNvbGUtZGlyLmh0bWwKLWluc3BlY3Rvci9jb25z b2xlLWRpcnhtbC5odG1sCi1pbnNwZWN0b3IvY29uc29sZS1mb3JtYXQuaHRtbAotaW5zcGVjdG9y L2NvbnNvbGUtdGVzdHMuaHRtbAotaW5zcGVjdG9yL2VsZW1lbnRzLXBhbmVsLXN0cnVjdHVyZS5o dG1sCi1pbnNwZWN0b3IvZXZhbHVhdGUtaW4tZnJvbnRlbmQuaHRtbAotCiAjIFRlc3RzIGluIG1l ZGlhLyBkaXJlY3RvcnkKICMgICBUZXN0cyBmYWlsaW5nCiBtZWRpYS92aWRlby1jb250cm9scy10 cmFuc2Zvcm1lZC5odG1sCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktp dC9ndGsvQ2hhbmdlTG9nCmluZGV4IDZlZmVkYjIuLjg3OGYxYzYgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMg QEAKKzIwMDktMTAtMjcgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBj b2xsYWJvcmEuY28udWs+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgW0dUS10gQVBJIHRvIHN0YXJ0IGluc3BlY3RvciBmb3IgYSBXZWJWaWV3CisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjU1MQorCisgICAg ICAgIFByb3ZpZGUgYSBzaW1wbGUsIGNvb3JkaW5hdGVzLWJhc2VkIEFQSSB0byBzdGFydCB0aGUg aW5zcGVjdG9yLgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvSW5zcGVjdG9yQ2xpZW50R3Rr LmNwcDoKKyAgICAgICAgKFdlYktpdDo6SW5zcGVjdG9yQ2xpZW50OjpjcmVhdGVQYWdlKTogVXNl IGZpbGVzIGZyb20gdGhlIHNvdXJjZQorICAgICAgICB0cmVlIHdoZW4gcnVubmluZyBmcm9tIHRo ZSB0b3Agb2YgdGhlIHNvdXJjZSBkaXJlY3RvcnkuCisgICAgICAgIChXZWJLaXQ6Okluc3BlY3Rv ckNsaWVudDo6bG9jYWxpemVkU3RyaW5nc1VSTCk6IERpdHRvLgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYmluc3BlY3Rvci5jcHA6 CisgICAgICAgICh3ZWJraXRfd2ViX2luc3BlY3Rvcl9pbnNwZWN0X2Nvb3JkaW5hdGVzKToKKyAg ICAgICAgKHdlYmtpdF93ZWJfaW5zcGVjdG9yX2Nsb3NlKToKKyAgICAgICAgKHdlYmtpdF93ZWJf aW5zcGVjdG9yX2V4ZWN1dGVfc2NyaXB0KToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViaW5z cGVjdG9yLmg6CisKIDIwMDktMTAtMjYgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8u bm9yb25oYUBjb2xsYWJvcmEuY28udWs+CiAKICAgICAgICAgVW5yZXZpZXdlZC4gVXBkYXRlIGRv Y3VtZW50YXRpb24gY29udHJvbCBmaWxlcyBmb3IgMS4xLjE2LgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9JbnNwZWN0b3JDbGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9X ZWJDb3JlU3VwcG9ydC9JbnNwZWN0b3JDbGllbnRHdGsuY3BwCmluZGV4IGZlZjA3YzEuLjc4ZjU1 NDMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvSW5zcGVjdG9yQ2xpZW50 R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0luc3BlY3RvckNsaWVudEd0 ay5jcHAKQEAgLTk3LDkgKzk3LDE3IEBAIFBhZ2UqIEluc3BlY3RvckNsaWVudDo6Y3JlYXRlUGFn ZSgpCiAgICAgZ19zaWduYWxfY29ubmVjdChtX3dlYlZpZXcsICJkZXN0cm95IiwKICAgICAgICAg ICAgICAgICAgICAgIEdfQ0FMTEJBQ0sobm90aWZ5V2ViVmlld0Rlc3Ryb3llZCksIChncG9pbnRl cil0aGlzKTsKIAotICAgIGdjaGFyKiBpbnNwZWN0b3JVUkkgPSBnX2ZpbGVuYW1lX3RvX3VyaShE QVRBX0RJUiIvd2Via2l0LTEuMC93ZWJpbnNwZWN0b3IvaW5zcGVjdG9yLmh0bWwiLCBOVUxMLCBO VUxMKTsKLSAgICB3ZWJraXRfd2ViX3ZpZXdfbG9hZF91cmkobV93ZWJWaWV3LCBpbnNwZWN0b3JV UkkpOwotICAgIGdfZnJlZShpbnNwZWN0b3JVUkkpOworICAgIEdPd25QdHI8Z2NoYXI+IGluc3Bl Y3RvclVSSTsKKworICAgIC8vIE1ha2UgdGhlIFdlYiBJbnNwZWN0b3Igd29yayB3aGVuIHJ1bm5p bmcgdGVzdHMKKyAgICBpZiAoZ19maWxlX3Rlc3QoIldlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC9pbnNwZWN0b3IuaHRtbCIsIEdfRklMRV9URVNUX0VYSVNUUykpIHsKKyAgICAgICAgR093blB0 cjxnY2hhcj4gY3VycmVudERpcmVjdG9yeShnX2dldF9jdXJyZW50X2RpcigpKTsKKyAgICAgICAg R093blB0cjxnY2hhcj4gZnVsbFBhdGgoZ19zdHJkdXBfcHJpbnRmKCIlcy9XZWJDb3JlL2luc3Bl Y3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWwiLCBjdXJyZW50RGlyZWN0b3J5LmdldCgpKSk7 CisgICAgICAgIGluc3BlY3RvclVSSS5zZXQoZ19maWxlbmFtZV90b191cmkoZnVsbFBhdGguZ2V0 KCksIE5VTEwsIE5VTEwpKTsKKyAgICB9IGVsc2UKKyAgICAgICAgaW5zcGVjdG9yVVJJLnNldChn X2ZpbGVuYW1lX3RvX3VyaShEQVRBX0RJUiIvd2Via2l0LTEuMC93ZWJpbnNwZWN0b3IvaW5zcGVj dG9yLmh0bWwiLCBOVUxMLCBOVUxMKSk7CisKKyAgICB3ZWJraXRfd2ViX3ZpZXdfbG9hZF91cmko bV93ZWJWaWV3LCBpbnNwZWN0b3JVUkkuZ2V0KCkpOwogCiAgICAgZ3RrX3dpZGdldF9zaG93KEdU S19XSURHRVQobV93ZWJWaWV3KSk7CiAKQEAgLTEwOCw4ICsxMTYsMTggQEAgUGFnZSogSW5zcGVj dG9yQ2xpZW50OjpjcmVhdGVQYWdlKCkKIAogU3RyaW5nIEluc3BlY3RvckNsaWVudDo6bG9jYWxp emVkU3RyaW5nc1VSTCgpCiB7CisgICAgR093blB0cjxnY2hhcj4gVVJMOworCisgICAgLy8gTWFr ZSB0aGUgV2ViIEluc3BlY3RvciB3b3JrIHdoZW4gcnVubmluZyB0ZXN0cworICAgIGlmIChnX2Zp bGVfdGVzdCgiV2ViQ29yZS9FbmdsaXNoLmxwcm9qL2xvY2FsaXplZFN0cmluZ3MuanMiLCBHX0ZJ TEVfVEVTVF9FWElTVFMpKSB7CisgICAgICAgIEdPd25QdHI8Z2NoYXI+IGN1cnJlbnREaXJlY3Rv cnkoZ19nZXRfY3VycmVudF9kaXIoKSk7CisgICAgICAgIEdPd25QdHI8Z2NoYXI+IGZ1bGxQYXRo KGdfc3RyZHVwX3ByaW50ZigiJXMvV2ViQ29yZS9FbmdsaXNoLmxwcm9qL2xvY2FsaXplZFN0cmlu Z3MuanMiLCBjdXJyZW50RGlyZWN0b3J5LmdldCgpKSk7CisgICAgICAgIFVSTC5zZXQoZ19maWxl bmFtZV90b191cmkoZnVsbFBhdGguZ2V0KCksIE5VTEwsIE5VTEwpKTsKKyAgICB9IGVsc2UKKyAg ICAgICAgVVJMLnNldChnX2ZpbGVuYW1lX3RvX3VyaShEQVRBX0RJUiIvd2Via2l0LTEuMC93ZWJp bnNwZWN0b3IvbG9jYWxpemVkU3RyaW5ncy5qcyIsIE5VTEwsIE5VTEwpKTsKKwogICAgIC8vIEZJ WE1FOiBzdXBwb3J0IGwxMG4gb2YgbG9jYWxpemVkU3RyaW5ncy5qcwotICAgIHJldHVybiBTdHJp bmc6OmZyb21VVEY4KGdfZmlsZW5hbWVfdG9fdXJpKERBVEFfRElSIi93ZWJraXQtMS4wL3dlYmlu c3BlY3Rvci9sb2NhbGl6ZWRTdHJpbmdzLmpzIiwgTlVMTCwgTlVMTCkpOworICAgIHJldHVybiBT dHJpbmc6OmZyb21VVEY4KFVSTC5nZXQoKSk7CiB9CiAKIFN0cmluZyBJbnNwZWN0b3JDbGllbnQ6 OmhpZGRlblBhbmVscygpCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXggNDRkYWMwNC4u YTU1OWMzZCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisr KyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtMjI0LDYgKzIyNCwxMCBA QCBleHRlcm4gIkMiIHsKICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl9pbnNwZWN0b3Jfc2V0X2lu c3BlY3RlZF91cmkoV2ViS2l0V2ViSW5zcGVjdG9yKiB3ZWJfaW5zcGVjdG9yLCBjb25zdCBnY2hh ciogaW5zcGVjdGVkX3VyaSk7CiAKKyAgICBXRUJLSVRfQVBJIHZvaWQKKyAgICB3ZWJraXRfd2Vi X2luc3BlY3Rvcl9leGVjdXRlX3NjcmlwdChXZWJLaXRXZWJJbnNwZWN0b3IqIGluc3BlY3Rvciwg bG9uZyBjYWxsSWQsIGNvbnN0IGdjaGFyKiBzY3JpcHQpOworCisKICAgICBXZWJLaXRXZWJXaW5k b3dGZWF0dXJlcyoKICAgICB3ZWJraXRfd2ViX3dpbmRvd19mZWF0dXJlc19uZXdfZnJvbV9jb3Jl X2ZlYXR1cmVzIChjb25zdCBXZWJDb3JlOjpXaW5kb3dGZWF0dXJlcyYgZmVhdHVyZXMpOwogCmRp ZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJpbnNwZWN0b3IuY3BwIGIvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmNwcAppbmRleCA0ZTRmOGRlLi5jMDMx OGExIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJpbnNwZWN0b3IuY3Bw CisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmluc3BlY3Rvci5jcHAKQEAgLTEsNiAr MSw3IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQog ICogQ29weXJpZ2h0IChDKSAyMDA4LCAyMDA5IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVyCisg KiBDb3B5cmlnaHQgKEMpIDIwMDkgQ29sbGFib3JhIEx0ZC4KICAqCiAgKiBUaGlzIGxpYnJhcnkg aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2Rp ZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpA QCAtMTksMTEgKzIwLDE4IEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IndlYmtpdHdlYmluc3BlY3Rvci5oIgogCisjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCisj aW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlIDxnbGliL2dpMThuLWxpYi5oPgotI2luY2x1ZGUg IndlYmtpdHdlYmluc3BlY3Rvci5oIgotI2luY2x1ZGUgIndlYmtpdG1hcnNoYWwuaCIKKyNpbmNs dWRlICJIaXRUZXN0UmVxdWVzdC5oIgorI2luY2x1ZGUgIkhpdFRlc3RSZXN1bHQuaCIKICNpbmNs dWRlICJJbnNwZWN0b3JDbGllbnRHdGsuaCIKKyNpbmNsdWRlICJJbnRQb2ludC5oIgorI2luY2x1 ZGUgIlBhZ2UuaCIKKyNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisjaW5jbHVkZSAid2Via2l0bWFy c2hhbC5oIgogI2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKIAogLyoqCkBAIC01Niw2ICs2NCw3 IEBACiAgKi8KIAogdXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKK3VzaW5nIG5hbWVzcGFjZSBXZWJD b3JlOwogCiBlbnVtIHsKICAgICBJTlNQRUNUX1dFQl9WSUVXLApAQCAtNDI2LDMgKzQzNSw1OSBA QCB3ZWJraXRfd2ViX2luc3BlY3Rvcl9zZXRfaW5zcGVjdG9yX2NsaWVudChXZWJLaXRXZWJJbnNw ZWN0b3IqIHdlYl9pbnNwZWN0b3IsIFdlYgogCiAgICAgcHJpdi0+cGFnZSA9IHBhZ2U7CiB9CisK Ky8qKgorICogd2Via2l0X3dlYl9pbnNwZWN0b3JfaW5zcGVjdF9jb29yZGluYXRlczoKKyAqIEB3 ZWJfaW5zcGVjdG9yOiB0aGUgI1dlYktpdFdlYkluc3BlY3RvciB0aGF0IHdpbGwgZG8gdGhlIGlu c3BlY3Rpb24KKyAqIEB4OiB0aGUgWCBjb29yZGluYXRlIG9mIHRoZSBub2RlIHRvIGJlIGluc3Bl Y3RlZAorICogQHk6IHRoZSBZIGNvb3JkaW5hdGUgb2YgdGhlIG5vZGUgdG8gYmUgaW5zcGVjdGVk CisgKgorICogQ2F1c2VzIHRoZSBXZWIgSW5zcGVjdG9yIHRvIGluc3BlY3QgdGhlIG5vZGUgdGhh dCBpcyBsb2NhdGVkIGF0IHRoZQorICogZ2l2ZW4gY29vcmRpbmF0ZXMuCisgKgorICogU2luY2U6 IDEuMS4xNworICovCit2b2lkIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2luc3BlY3RfY29vcmRpbmF0 ZXMoV2ViS2l0V2ViSW5zcGVjdG9yKiB3ZWJJbnNwZWN0b3IsIGdkb3VibGUgeCwgZ2RvdWJsZSB5 KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9JTlNQRUNUT1Iod2ViSW5z cGVjdG9yKSk7CisgICAgZ19yZXR1cm5faWZfZmFpbCgoeCA+PSAwKSAmJiAoeSA+PSAwKSk7CisK KyAgICBXZWJLaXRXZWJJbnNwZWN0b3JQcml2YXRlKiBwcml2ID0gd2ViSW5zcGVjdG9yLT5wcml2 OworCisgICAgRnJhbWUqIGZyYW1lID0gcHJpdi0+cGFnZS0+Zm9jdXNDb250cm9sbGVyKCktPmZv Y3VzZWRPck1haW5GcmFtZSgpOworICAgIEZyYW1lVmlldyogdmlldyA9IGZyYW1lLT52aWV3KCk7 CisKKyAgICBpZiAoIXZpZXcpCisgICAgICAgIHJldHVybjsKKworICAgIEhpdFRlc3RSZXF1ZXN0 IHJlcXVlc3QoSGl0VGVzdFJlcXVlc3Q6OlJlYWRPbmx5IHwgSGl0VGVzdFJlcXVlc3Q6OkFjdGl2 ZSk7CisgICAgSW50UG9pbnQgZG9jdW1lbnRQb2ludCA9IHZpZXctPndpbmRvd1RvQ29udGVudHMo SW50UG9pbnQoc3RhdGljX2Nhc3Q8aW50Pih4KSwgc3RhdGljX2Nhc3Q8aW50Pih5KSkpOworICAg IEhpdFRlc3RSZXN1bHQgcmVzdWx0KGRvY3VtZW50UG9pbnQpOworCisgICAgZnJhbWUtPmNvbnRl bnRSZW5kZXJlcigpLT5sYXllcigpLT5oaXRUZXN0KHJlcXVlc3QsIHJlc3VsdCk7CisgICAgcHJp di0+cGFnZS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLT5pbnNwZWN0KHJlc3VsdC5pbm5lck5vblNo YXJlZE5vZGUoKSk7Cit9CisKKy8qKgorICogd2Via2l0X3dlYl9pbnNwZWN0b3JfY2xvc2U6Cisg KiBAd2ViX2luc3BlY3RvcjogdGhlICNXZWJLaXRXZWJJbnNwZWN0b3IgdGhhdCB3aWxsIGJlIGNs b3NlZAorICoKKyAqIENhdXNlcyB0aGUgV2ViIEluc3BlY3RvciB0byBiZSBjbG9zZWQuCisgKgor ICogU2luY2U6IDEuMS4xNworICovCit2b2lkIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2Nsb3NlKFdl YktpdFdlYkluc3BlY3Rvciogd2ViSW5zcGVjdG9yKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwo V0VCS0lUX0lTX1dFQl9JTlNQRUNUT1Iod2ViSW5zcGVjdG9yKSk7CisKKyAgICBXZWJLaXRXZWJJ bnNwZWN0b3JQcml2YXRlKiBwcml2ID0gd2ViSW5zcGVjdG9yLT5wcml2OworICAgIHByaXYtPnBh Z2UtPmluc3BlY3RvckNvbnRyb2xsZXIoKS0+Y2xvc2UoKTsKK30KKwordm9pZCB3ZWJraXRfd2Vi X2luc3BlY3Rvcl9leGVjdXRlX3NjcmlwdChXZWJLaXRXZWJJbnNwZWN0b3IqIHdlYkluc3BlY3Rv ciwgbG9uZyBjYWxsSWQsIGNvbnN0IGdjaGFyKiBzY3JpcHQpCit7CisgICAgZ19yZXR1cm5faWZf ZmFpbChXRUJLSVRfSVNfV0VCX0lOU1BFQ1RPUih3ZWJJbnNwZWN0b3IpKTsKKworICAgIFdlYktp dFdlYkluc3BlY3RvclByaXZhdGUqIHByaXYgPSB3ZWJJbnNwZWN0b3ItPnByaXY7CisgICAgcHJp di0+cGFnZS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLT5ldmFsdWF0ZUZvclRlc3RJbkZyb250ZW5k KGNhbGxJZCwgc2NyaXB0KTsKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYmluc3BlY3Rvci5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmgK aW5kZXggOTAxMGUyNi4uOTRmZDgwNiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2ViaW5zcGVjdG9yLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViaW5zcGVj dG9yLmgKQEAgLTYwLDYgKzYwLDEyIEBAIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2dldF93ZWJfdmll dyhXZWJLaXRXZWJJbnNwZWN0b3IqIHdlYl9pbnNwZWN0b3IpOwogV0VCS0lUX0FQSSBjb25zdCBn Y2hhcioKIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2dldF9pbnNwZWN0ZWRfdXJpKFdlYktpdFdlYklu c3BlY3Rvciogd2ViX2luc3BlY3Rvcik7CiAKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl9p bnNwZWN0b3JfaW5zcGVjdF9jb29yZGluYXRlcyhXZWJLaXRXZWJJbnNwZWN0b3IqIHdlYl9pbnNw ZWN0b3IsIGdkb3VibGUgeCwgZ2RvdWJsZSB5KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRf d2ViX2luc3BlY3Rvcl9jbG9zZShXZWJLaXRXZWJJbnNwZWN0b3IqIHdlYkluc3BlY3Rvcik7CisK IEdfRU5EX0RFQ0xTCiAKICNlbmRpZiAvKiB3ZWJraXR3ZWJpbnNwZWN0b3JfaCAqLwpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4 IGNhNjc5YmMuLjQxYzFhZjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZworKysg Yi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAwOS0xMC0yNyAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR1RLXSBBUEkg dG8gc3RhcnQgaW5zcGVjdG9yIGZvciBhIFdlYlZpZXcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNTUxCisKKyAgICAgICAgVXNlIHRoZSBuZXcgaW5z cGVjdG9yIEFQSSB0byBpbXBsZW1lbnQgdGhlIExheW91dFRlc3RDb250cm9sbGVyCisgICAgICAg IGludGVyZmFjZXMgdXNlZCB0byB0ZXN0IHRoZSBpbnNwZWN0b3IuCisKKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwOgorICAgICAgICAod2ViSW5zcGVjdG9y SW5zcGVjdFdlYlZpZXcpOgorICAgICAgICAoY3JlYXRlV2ViVmlldyk6CisgICAgICAgICogRHVt cFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoKKyAgICAgICAgKExh eW91dFRlc3RDb250cm9sbGVyOjpzaG93V2ViSW5zcGVjdG9yKToKKyAgICAgICAgKExheW91dFRl c3RDb250cm9sbGVyOjpjbG9zZVdlYkluc3BlY3Rvcik6CisgICAgICAgIChMYXlvdXRUZXN0Q29u dHJvbGxlcjo6ZXZhbHVhdGVJbldlYkluc3BlY3Rvcik6CisKIDIwMDktMTAtMjcgIEtlbm5ldGgg Um9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPgogCiAgICAgICAgIFJ1YmJl cnN0YW1wZWQgYnkgT2xpdmVyIEh1bnQuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAppbmRleCBjZjg2YjMwLi40ZWQ2ZTM2IDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCisr KyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAKQEAg LTcwOCw2ICs3MDgsMTEgQEAgc3RhdGljIHZvaWQgZGF0YWJhc2VRdW90YUV4Y2VlZGVkKFdlYktp dFdlYlZpZXcqIHZpZXcsIFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgV2UKIAogc3RhdGljIFdlYktp dFdlYlZpZXcqIHdlYlZpZXdDcmVhdGUoV2ViS2l0V2ViVmlldyosIFdlYktpdFdlYkZyYW1lKik7 CiAKK3N0YXRpYyBXZWJLaXRXZWJWaWV3KiB3ZWJJbnNwZWN0b3JJbnNwZWN0V2ViVmlldyhXZWJL aXRXZWJJbnNwZWN0b3IqLCBncG9pbnRlciBkYXRhKQoreworICAgIHJldHVybiBXRUJLSVRfV0VC X1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKK30KKwogc3RhdGljIFdlYktpdFdlYlZpZXcq IGNyZWF0ZVdlYlZpZXcoKQogewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSBXRUJLSVRfV0VC X1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKQEAgLTczMiw2ICs3MzcsOSBAQCBzdGF0aWMg V2ViS2l0V2ViVmlldyogY3JlYXRlV2ViVmlldygpCiAgICAgICAgICAgICAgICAgICAgICAic2ln bmFsOjpkYXRhYmFzZS1xdW90YS1leGNlZWRlZCIsIGRhdGFiYXNlUXVvdGFFeGNlZWRlZCwgMCwK ICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOwogCisgICAgV2ViS2l0V2ViSW5zcGVjdG9yKiBp bnNwZWN0b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih2aWV3KTsKKyAgICBnX3Np Z25hbF9jb25uZWN0KGluc3BlY3RvciwgImluc3BlY3Qtd2ViLXZpZXciLCBHX0NBTExCQUNLKHdl Ykluc3BlY3Rvckluc3BlY3RXZWJWaWV3KSwgMCk7CisKICAgICByZXR1cm4gdmlldzsKIH0KIApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250 cm9sbGVyR3RrLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0 Q29udHJvbGxlckd0ay5jcHAKaW5kZXggYjAxZGNmNC4uMzVlNzQ3MCAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJH dGsuY3BwCkBAIC01Miw2ICs1Miw3IEBAIHVuc2lnbmVkIGludCB3ZWJraXRfd2ViX2ZyYW1lX251 bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJGcmFtZSogZnJhbWUpCiB2b2lkIHdl YmtpdF9hcHBsaWNhdGlvbl9jYWNoZV9zZXRfbWF4aW11bV9zaXplKHVuc2lnbmVkIGxvbmcgbG9u ZyBzaXplKTsKIHVuc2lnbmVkIGludCB3ZWJraXRfd29ya2VyX3RocmVhZF9jb3VudCh2b2lkKTsK IHZvaWQgd2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX2Zyb21fb3JpZ2luKGNvbnN0IGdjaGFyKiBz b3VyY2VPcmlnaW4sIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlvblByb3RvY29sLCBjb25zdCBnY2hh ciogZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGluYXRpb25TdWJkb21haW5zKTsKK3Zv aWQgd2Via2l0X3dlYl9pbnNwZWN0b3JfZXhlY3V0ZV9zY3JpcHQoV2ViS2l0V2ViSW5zcGVjdG9y KiBpbnNwZWN0b3IsIGxvbmcgY2FsbElkLCBjb25zdCBnY2hhciogc2NyaXB0KTsKIH0KIAogc3Rh dGljIGdjaGFyKiBjb3B5V2ViU2V0dGluZ0tleShnY2hhciogcHJlZmVyZW5jZUtleSkKQEAgLTQ3 NCwxNyArNDc1LDMyIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmFkZFVzZXJTdHlsZVNo ZWV0KEpTU3RyaW5nUmVmIHNvdXJjZSkKIAogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2hv d1dlYkluc3BlY3RvcigpCiB7Ci0gICAgLy8gRklYTUU6IEltcGxlbWVudCB0aGlzLgorICAgIFdl YktpdFdlYlZpZXcqIHdlYlZpZXcgPSB3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhtYWlu RnJhbWUpOworICAgIFdlYktpdFdlYlNldHRpbmdzKiB3ZWJTZXR0aW5ncyA9IHdlYmtpdF93ZWJf dmlld19nZXRfc2V0dGluZ3Mod2ViVmlldyk7CisgICAgV2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNw ZWN0b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih3ZWJWaWV3KTsKKworICAgIGdf b2JqZWN0X3NldCh3ZWJTZXR0aW5ncywgImVuYWJsZS1kZXZlbG9wZXItZXh0cmFzIiwgVFJVRSwg TlVMTCk7CisgICAgd2Via2l0X3dlYl9pbnNwZWN0b3JfaW5zcGVjdF9jb29yZGluYXRlcyhpbnNw ZWN0b3IsIDAsIDApOwogfQogCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpjbG9zZVdlYklu c3BlY3RvcigpCiB7Ci0gICAgLy8gRklYTUU6IEltcGxlbWVudCB0aGlzLgorICAgIFdlYktpdFdl YlZpZXcqIHdlYlZpZXcgPSB3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhtYWluRnJhbWUp OworICAgIFdlYktpdFdlYlNldHRpbmdzKiB3ZWJTZXR0aW5ncyA9IHdlYmtpdF93ZWJfdmlld19n ZXRfc2V0dGluZ3Mod2ViVmlldyk7CisgICAgV2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0b3Ig PSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih3ZWJWaWV3KTsKKworICAgIHdlYmtpdF93 ZWJfaW5zcGVjdG9yX2Nsb3NlKGluc3BlY3Rvcik7CisgICAgZ19vYmplY3Rfc2V0KHdlYlNldHRp bmdzLCAiZW5hYmxlLWRldmVsb3Blci1leHRyYXMiLCBGQUxTRSwgTlVMTCk7CiB9CiAKIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OmV2YWx1YXRlSW5XZWJJbnNwZWN0b3IobG9uZyBjYWxsSWQs IEpTU3RyaW5nUmVmIHNjcmlwdCkKIHsKLSAgICAvLyBGSVhNRTogSW1wbGVtZW50IHRoaXMuCisg ICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IHdlYmtpdF93ZWJfZnJhbWVfZ2V0X3dlYl92aWV3 KG1haW5GcmFtZSk7CisgICAgV2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0b3IgPSB3ZWJraXRf d2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih3ZWJWaWV3KTsKKyAgICBjaGFyKiBzY3JpcHRTdHJpbmcg PSBKU1N0cmluZ0NvcHlVVEY4Q1N0cmluZyhzY3JpcHQpOworCisgICAgd2Via2l0X3dlYl9pbnNw ZWN0b3JfZXhlY3V0ZV9zY3JpcHQoaW5zcGVjdG9yLCBjYWxsSWQsIHNjcmlwdFN0cmluZyk7Cisg ICAgZ19mcmVlKHNjcmlwdFN0cmluZyk7CiB9CiAKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6 OmV2YWx1YXRlU2NyaXB0SW5Jc29sYXRlZFdvcmxkKHVuc2lnbmVkIHdvcmxkSUQsIEpTT2JqZWN0 UmVmIGdsb2JhbE9iamVjdCwgSlNTdHJpbmdSZWYgc2NyaXB0KQotLSAKMS42LjUKCg== 42014 2009-10-28 05:32:12 -0700 2009-10-28 12:01:15 -0700 take 3 0001-Provide-a-simple-coordinates-based-API-to-start-the-.patch text/plain 15004 gustavo RnJvbSA4ZTI0ZWIwMjdhMDRkZDk3NzE5MTk0N2Q3MTZjMjc3MDEwZDVjNDIyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMDg6MDc6MzggLTAyMDAK U3ViamVjdDogW1BBVENIXSBQcm92aWRlIGEgc2ltcGxlLCBjb29yZGluYXRlcy1iYXNlZCBBUEkg dG8gc3RhcnQgdGhlIGluc3BlY3Rvci4KCi0tLQogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDExICsrKwogTGF5b3V0VGVzdHMvcGxhdGZvcm0v Z3RrL1NraXBwZWQgICAgICAgICAgICAgICAgICAgfCAgICA5IC0tLQogV2ViS2l0L2d0ay9DaGFu Z2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIwICsrKysrCiBXZWJLaXQv Z3RrL1dlYkNvcmVTdXBwb3J0L0luc3BlY3RvckNsaWVudEd0ay5jcHAgICB8ICAgMjYgKysrKysr LQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgICAgICAgfCAg ICA0ICsKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmluc3BlY3Rvci5jcHAgICAgICAgICAg IHwgICA3NiArKysrKysrKysrKysrKysrKysrLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vi aW5zcGVjdG9yLmggICAgICAgICAgICAgfCAgICA2ICsrCiBXZWJLaXRUb29scy9DaGFuZ2VMb2cg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTggKysrKysKIFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAgIHwgICAgOCArKwogLi4uL0R1bXBS ZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAgfCAgIDIzICsrKysrLQog MTAgZmlsZXMgY2hhbmdlZCwgMTgzIGluc2VydGlvbnMoKyksIDE4IGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpp bmRleCA5MDE5MThlLi5iYmU1NWZmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cK KysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMTAtMjcg IEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0dUS10g QVBJIHRvIHN0YXJ0IGluc3BlY3RvciBmb3IgYSBXZWJWaWV3CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjU1MQorCisgICAgICAgIFVuc2tpcCBpbnNw ZWN0b3IgdGVzdHMgdGhhdCB3ZSBhcmUgbm93IGFibGUgdG8gcnVuLgorCisgICAgICAgICogcGxh dGZvcm0vZ3RrL1NraXBwZWQ6CisKIDIwMDktMTAtMjcgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdl YmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZCBiL0xheW91dFRlc3RzL3BsYXRmb3Jt L2d0ay9Ta2lwcGVkCmluZGV4IDRiYmY1YWYuLjliYTZkZDEgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9T a2lwcGVkCkBAIC0zNTcyLDE1ICszNTcyLDYgQEAgaHR0cC90ZXN0cy93ZWJhcmNoaXZlL3Rlc3Qt Y3NzLXVybC1lbmNvZGluZy11dGYtOC5odG1sCiBodHRwL3Rlc3RzL3dlYmFyY2hpdmUvdGVzdC1j c3MtdXJsLWVuY29kaW5nLmh0bWwKIGh0dHAvdGVzdHMvd2ViYXJjaGl2ZS90ZXN0LXByZWxvYWQt cmVzb3VyY2VzLmh0bWwKIAotIyBUZXN0cyBpbiBpbnNwZWN0b3IvIGRpcmVjdG9yeQotIyAgIFRl c3RzIGZhaWxpbmcKLWluc3BlY3Rvci9jb25zb2xlLWRpci5odG1sCi1pbnNwZWN0b3IvY29uc29s ZS1kaXJ4bWwuaHRtbAotaW5zcGVjdG9yL2NvbnNvbGUtZm9ybWF0Lmh0bWwKLWluc3BlY3Rvci9j b25zb2xlLXRlc3RzLmh0bWwKLWluc3BlY3Rvci9lbGVtZW50cy1wYW5lbC1zdHJ1Y3R1cmUuaHRt bAotaW5zcGVjdG9yL2V2YWx1YXRlLWluLWZyb250ZW5kLmh0bWwKLQogIyBUZXN0cyBpbiBtZWRp YS8gZGlyZWN0b3J5CiAjICAgVGVzdHMgZmFpbGluZwogbWVkaWEvdmlkZW8tY29udHJvbHMtdHJh bnNmb3JtZWQuaHRtbApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQv Z3RrL0NoYW5nZUxvZwppbmRleCA2ZWZlZGIyLi44NzhmMWM2IDEwMDY0NAotLS0gYS9XZWJLaXQv Z3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBA CisyMDA5LTEwLTI3ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29s bGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFtHVEtdIEFQSSB0byBzdGFydCBpbnNwZWN0b3IgZm9yIGEgV2ViVmlldworICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI1NTEKKworICAgICAg ICBQcm92aWRlIGEgc2ltcGxlLCBjb29yZGluYXRlcy1iYXNlZCBBUEkgdG8gc3RhcnQgdGhlIGlu c3BlY3Rvci4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0luc3BlY3RvckNsaWVudEd0ay5j cHA6CisgICAgICAgIChXZWJLaXQ6Okluc3BlY3RvckNsaWVudDo6Y3JlYXRlUGFnZSk6IFVzZSBm aWxlcyBmcm9tIHRoZSBzb3VyY2UKKyAgICAgICAgdHJlZSB3aGVuIHJ1bm5pbmcgZnJvbSB0aGUg dG9wIG9mIHRoZSBzb3VyY2UgZGlyZWN0b3J5LgorICAgICAgICAoV2ViS2l0OjpJbnNwZWN0b3JD bGllbnQ6OmxvY2FsaXplZFN0cmluZ3NVUkwpOiBEaXR0by4KKyAgICAgICAgKiB3ZWJraXQvd2Vi a2l0cHJpdmF0ZS5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJpbnNwZWN0b3IuY3BwOgor ICAgICAgICAod2Via2l0X3dlYl9pbnNwZWN0b3JfaW5zcGVjdF9jb29yZGluYXRlcyk6CisgICAg ICAgICh3ZWJraXRfd2ViX2luc3BlY3Rvcl9jbG9zZSk6CisgICAgICAgICh3ZWJraXRfd2ViX2lu c3BlY3Rvcl9leGVjdXRlX3NjcmlwdCk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYmluc3Bl Y3Rvci5oOgorCiAyMDA5LTEwLTI2ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5v cm9uaGFAY29sbGFib3JhLmNvLnVrPgogCiAgICAgICAgIFVucmV2aWV3ZWQuIFVwZGF0ZSBkb2N1 bWVudGF0aW9uIGNvbnRyb2wgZmlsZXMgZm9yIDEuMS4xNi4KZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvV2ViQ29yZVN1cHBvcnQvSW5zcGVjdG9yQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2Vi Q29yZVN1cHBvcnQvSW5zcGVjdG9yQ2xpZW50R3RrLmNwcAppbmRleCBmZWYwN2MxLi43OGY1NTQz IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0luc3BlY3RvckNsaWVudEd0 ay5jcHAKKysrIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9JbnNwZWN0b3JDbGllbnRHdGsu Y3BwCkBAIC05Nyw5ICs5NywxNyBAQCBQYWdlKiBJbnNwZWN0b3JDbGllbnQ6OmNyZWF0ZVBhZ2Uo KQogICAgIGdfc2lnbmFsX2Nvbm5lY3QobV93ZWJWaWV3LCAiZGVzdHJveSIsCiAgICAgICAgICAg ICAgICAgICAgICBHX0NBTExCQUNLKG5vdGlmeVdlYlZpZXdEZXN0cm95ZWQpLCAoZ3BvaW50ZXIp dGhpcyk7CiAKLSAgICBnY2hhciogaW5zcGVjdG9yVVJJID0gZ19maWxlbmFtZV90b191cmkoREFU QV9ESVIiL3dlYmtpdC0xLjAvd2ViaW5zcGVjdG9yL2luc3BlY3Rvci5odG1sIiwgTlVMTCwgTlVM TCk7Ci0gICAgd2Via2l0X3dlYl92aWV3X2xvYWRfdXJpKG1fd2ViVmlldywgaW5zcGVjdG9yVVJJ KTsKLSAgICBnX2ZyZWUoaW5zcGVjdG9yVVJJKTsKKyAgICBHT3duUHRyPGdjaGFyPiBpbnNwZWN0 b3JVUkk7CisKKyAgICAvLyBNYWtlIHRoZSBXZWIgSW5zcGVjdG9yIHdvcmsgd2hlbiBydW5uaW5n IHRlc3RzCisgICAgaWYgKGdfZmlsZV90ZXN0KCJXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQv aW5zcGVjdG9yLmh0bWwiLCBHX0ZJTEVfVEVTVF9FWElTVFMpKSB7CisgICAgICAgIEdPd25QdHI8 Z2NoYXI+IGN1cnJlbnREaXJlY3RvcnkoZ19nZXRfY3VycmVudF9kaXIoKSk7CisgICAgICAgIEdP d25QdHI8Z2NoYXI+IGZ1bGxQYXRoKGdfc3RyZHVwX3ByaW50ZigiJXMvV2ViQ29yZS9pbnNwZWN0 b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sIiwgY3VycmVudERpcmVjdG9yeS5nZXQoKSkpOwor ICAgICAgICBpbnNwZWN0b3JVUkkuc2V0KGdfZmlsZW5hbWVfdG9fdXJpKGZ1bGxQYXRoLmdldCgp LCBOVUxMLCBOVUxMKSk7CisgICAgfSBlbHNlCisgICAgICAgIGluc3BlY3RvclVSSS5zZXQoZ19m aWxlbmFtZV90b191cmkoREFUQV9ESVIiL3dlYmtpdC0xLjAvd2ViaW5zcGVjdG9yL2luc3BlY3Rv ci5odG1sIiwgTlVMTCwgTlVMTCkpOworCisgICAgd2Via2l0X3dlYl92aWV3X2xvYWRfdXJpKG1f d2ViVmlldywgaW5zcGVjdG9yVVJJLmdldCgpKTsKIAogICAgIGd0a193aWRnZXRfc2hvdyhHVEtf V0lER0VUKG1fd2ViVmlldykpOwogCkBAIC0xMDgsOCArMTE2LDE4IEBAIFBhZ2UqIEluc3BlY3Rv ckNsaWVudDo6Y3JlYXRlUGFnZSgpCiAKIFN0cmluZyBJbnNwZWN0b3JDbGllbnQ6OmxvY2FsaXpl ZFN0cmluZ3NVUkwoKQogeworICAgIEdPd25QdHI8Z2NoYXI+IFVSTDsKKworICAgIC8vIE1ha2Ug dGhlIFdlYiBJbnNwZWN0b3Igd29yayB3aGVuIHJ1bm5pbmcgdGVzdHMKKyAgICBpZiAoZ19maWxl X3Rlc3QoIldlYkNvcmUvRW5nbGlzaC5scHJvai9sb2NhbGl6ZWRTdHJpbmdzLmpzIiwgR19GSUxF X1RFU1RfRVhJU1RTKSkgeworICAgICAgICBHT3duUHRyPGdjaGFyPiBjdXJyZW50RGlyZWN0b3J5 KGdfZ2V0X2N1cnJlbnRfZGlyKCkpOworICAgICAgICBHT3duUHRyPGdjaGFyPiBmdWxsUGF0aChn X3N0cmR1cF9wcmludGYoIiVzL1dlYkNvcmUvRW5nbGlzaC5scHJvai9sb2NhbGl6ZWRTdHJpbmdz LmpzIiwgY3VycmVudERpcmVjdG9yeS5nZXQoKSkpOworICAgICAgICBVUkwuc2V0KGdfZmlsZW5h bWVfdG9fdXJpKGZ1bGxQYXRoLmdldCgpLCBOVUxMLCBOVUxMKSk7CisgICAgfSBlbHNlCisgICAg ICAgIFVSTC5zZXQoZ19maWxlbmFtZV90b191cmkoREFUQV9ESVIiL3dlYmtpdC0xLjAvd2ViaW5z cGVjdG9yL2xvY2FsaXplZFN0cmluZ3MuanMiLCBOVUxMLCBOVUxMKSk7CisKICAgICAvLyBGSVhN RTogc3VwcG9ydCBsMTBuIG9mIGxvY2FsaXplZFN0cmluZ3MuanMKLSAgICByZXR1cm4gU3RyaW5n Ojpmcm9tVVRGOChnX2ZpbGVuYW1lX3RvX3VyaShEQVRBX0RJUiIvd2Via2l0LTEuMC93ZWJpbnNw ZWN0b3IvbG9jYWxpemVkU3RyaW5ncy5qcyIsIE5VTEwsIE5VTEwpKTsKKyAgICByZXR1cm4gU3Ry aW5nOjpmcm9tVVRGOChVUkwuZ2V0KCkpOwogfQogCiBTdHJpbmcgSW5zcGVjdG9yQ2xpZW50Ojpo aWRkZW5QYW5lbHMoKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0 ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDQ0ZGFjMDQuLmE1 NTljM2QgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysg Yi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAgLTIyNCw2ICsyMjQsMTAgQEAg ZXh0ZXJuICJDIiB7CiAgICAgdm9pZAogICAgIHdlYmtpdF93ZWJfaW5zcGVjdG9yX3NldF9pbnNw ZWN0ZWRfdXJpKFdlYktpdFdlYkluc3BlY3Rvciogd2ViX2luc3BlY3RvciwgY29uc3QgZ2NoYXIq IGluc3BlY3RlZF91cmkpOwogCisgICAgV0VCS0lUX0FQSSB2b2lkCisgICAgd2Via2l0X3dlYl9p bnNwZWN0b3JfZXhlY3V0ZV9zY3JpcHQoV2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0b3IsIGxv bmcgY2FsbElkLCBjb25zdCBnY2hhciogc2NyaXB0KTsKKworCiAgICAgV2ViS2l0V2ViV2luZG93 RmVhdHVyZXMqCiAgICAgd2Via2l0X3dlYl93aW5kb3dfZmVhdHVyZXNfbmV3X2Zyb21fY29yZV9m ZWF0dXJlcyAoY29uc3QgV2ViQ29yZTo6V2luZG93RmVhdHVyZXMmIGZlYXR1cmVzKTsKIApkaWZm IC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmNwcCBiL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYmluc3BlY3Rvci5jcHAKaW5kZXggNGU0ZjhkZS4uZWUyODE1 YyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmNwcAor KysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJpbnNwZWN0b3IuY3BwCkBAIC0xLDYgKzEs NyBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKICAq IENvcHlyaWdodCAoQykgMjAwOCwgMjAwOSBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgorICog Q29weXJpZ2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCiAgKgogICogVGhpcyBsaWJyYXJ5IGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAg LTE5LDExICsyMCwxOCBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJ3 ZWJraXR3ZWJpbnNwZWN0b3IuaCIKIAorI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgorI2lu Y2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KLSNpbmNsdWRlICJ3 ZWJraXR3ZWJpbnNwZWN0b3IuaCIKLSNpbmNsdWRlICJ3ZWJraXRtYXJzaGFsLmgiCisjaW5jbHVk ZSAiSGl0VGVzdFJlcXVlc3QuaCIKKyNpbmNsdWRlICJIaXRUZXN0UmVzdWx0LmgiCiAjaW5jbHVk ZSAiSW5zcGVjdG9yQ2xpZW50R3RrLmgiCisjaW5jbHVkZSAiSW50UG9pbnQuaCIKKyNpbmNsdWRl ICJQYWdlLmgiCisjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgorI2luY2x1ZGUgIndlYmtpdG1hcnNo YWwuaCIKICNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCiAKIC8qKgpAQCAtNTYsNiArNjQsNyBA QAogICovCiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJLaXQ7Cit1c2luZyBuYW1lc3BhY2UgV2ViQ29y ZTsKIAogZW51bSB7CiAgICAgSU5TUEVDVF9XRUJfVklFVywKQEAgLTQyNiwzICs0MzUsNjYgQEAg d2Via2l0X3dlYl9pbnNwZWN0b3Jfc2V0X2luc3BlY3Rvcl9jbGllbnQoV2ViS2l0V2ViSW5zcGVj dG9yKiB3ZWJfaW5zcGVjdG9yLCBXZWIKIAogICAgIHByaXYtPnBhZ2UgPSBwYWdlOwogfQorCisv KioKKyAqIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2luc3BlY3RfY29vcmRpbmF0ZXM6CisgKiBAd2Vi X2luc3BlY3RvcjogdGhlICNXZWJLaXRXZWJJbnNwZWN0b3IgdGhhdCB3aWxsIGRvIHRoZSBpbnNw ZWN0aW9uCisgKiBAeDogdGhlIFggY29vcmRpbmF0ZSBvZiB0aGUgbm9kZSB0byBiZSBpbnNwZWN0 ZWQKKyAqIEB5OiB0aGUgWSBjb29yZGluYXRlIG9mIHRoZSBub2RlIHRvIGJlIGluc3BlY3RlZAor ICoKKyAqIENhdXNlcyB0aGUgV2ViIEluc3BlY3RvciB0byBpbnNwZWN0IHRoZSBub2RlIHRoYXQg aXMgbG9jYXRlZCBhdCB0aGUKKyAqIGdpdmVuIGNvb3JkaW5hdGVzIG9mIHRoZSB3aWRnZXQuIFRo ZSBjb29yZGluYXRlcyBzaG91bGQgYmUgcmVsYXRpdmUKKyAqIHRvIHRoZSAjV2ViS2l0V2ViVmll dyB3aWRnZXQsIG5vdCB0byB0aGUgc2Nyb2xsYWJsZSBjb250ZW50LCBhbmQKKyAqIG1heSBiZSBv YnRhaW5lZCBmcm9tIGEgI0dka0V2ZW50IGRpcmVjdGx5LgorICoKKyAqIFRoaXMgbWVhbnMgQHgs IGFuZCBAeSBiZWluZyB6ZXJvIGRvZXNuJ3QgZ3VhcmFudGVlIHlvdSB3aWxsIGhpdCB0aGUKKyAq IGxlZnQtbW9zdCB0b3AgY29ybmVyIG9mIHRoZSBjb250ZW50LCBzaW5jZSB0aGUgY29udGVudHMg bWF5IGhhdmUKKyAqIGJlZW4gc2Nyb2xsZWQuCisgKgorICogU2luY2U6IDEuMS4xNworICovCit2 b2lkIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2luc3BlY3RfY29vcmRpbmF0ZXMoV2ViS2l0V2ViSW5z cGVjdG9yKiB3ZWJJbnNwZWN0b3IsIGdkb3VibGUgeCwgZ2RvdWJsZSB5KQoreworICAgIGdfcmV0 dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9JTlNQRUNUT1Iod2ViSW5zcGVjdG9yKSk7CisgICAg Z19yZXR1cm5faWZfZmFpbCh4ID49IDAgJiYgeSA+PSAwKTsKKworICAgIFdlYktpdFdlYkluc3Bl Y3RvclByaXZhdGUqIHByaXYgPSB3ZWJJbnNwZWN0b3ItPnByaXY7CisKKyAgICBGcmFtZSogZnJh bWUgPSBwcml2LT5wYWdlLT5mb2N1c0NvbnRyb2xsZXIoKS0+Zm9jdXNlZE9yTWFpbkZyYW1lKCk7 CisgICAgRnJhbWVWaWV3KiB2aWV3ID0gZnJhbWUtPnZpZXcoKTsKKworICAgIGlmICghdmlldykK KyAgICAgICAgcmV0dXJuOworCisgICAgSGl0VGVzdFJlcXVlc3QgcmVxdWVzdChIaXRUZXN0UmVx dWVzdDo6UmVhZE9ubHkgfCBIaXRUZXN0UmVxdWVzdDo6QWN0aXZlKTsKKyAgICBJbnRQb2ludCBk b2N1bWVudFBvaW50ID0gdmlldy0+d2luZG93VG9Db250ZW50cyhJbnRQb2ludChzdGF0aWNfY2Fz dDxpbnQ+KHgpLCBzdGF0aWNfY2FzdDxpbnQ+KHkpKSk7CisgICAgSGl0VGVzdFJlc3VsdCByZXN1 bHQoZG9jdW1lbnRQb2ludCk7CisKKyAgICBmcmFtZS0+Y29udGVudFJlbmRlcmVyKCktPmxheWVy KCktPmhpdFRlc3QocmVxdWVzdCwgcmVzdWx0KTsKKyAgICBwcml2LT5wYWdlLT5pbnNwZWN0b3JD b250cm9sbGVyKCktPmluc3BlY3QocmVzdWx0LmlubmVyTm9uU2hhcmVkTm9kZSgpKTsKK30KKwor LyoqCisgKiB3ZWJraXRfd2ViX2luc3BlY3Rvcl9jbG9zZToKKyAqIEB3ZWJfaW5zcGVjdG9yOiB0 aGUgI1dlYktpdFdlYkluc3BlY3RvciB0aGF0IHdpbGwgYmUgY2xvc2VkCisgKgorICogQ2F1c2Vz IHRoZSBXZWIgSW5zcGVjdG9yIHRvIGJlIGNsb3NlZC4KKyAqCisgKiBTaW5jZTogMS4xLjE3Cisg Ki8KK3ZvaWQgd2Via2l0X3dlYl9pbnNwZWN0b3JfY2xvc2UoV2ViS2l0V2ViSW5zcGVjdG9yKiB3 ZWJJbnNwZWN0b3IpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfV0VCX0lOU1BF Q1RPUih3ZWJJbnNwZWN0b3IpKTsKKworICAgIFdlYktpdFdlYkluc3BlY3RvclByaXZhdGUqIHBy aXYgPSB3ZWJJbnNwZWN0b3ItPnByaXY7CisgICAgcHJpdi0+cGFnZS0+aW5zcGVjdG9yQ29udHJv bGxlcigpLT5jbG9zZSgpOworfQorCit2b2lkIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2V4ZWN1dGVf c2NyaXB0KFdlYktpdFdlYkluc3BlY3Rvciogd2ViSW5zcGVjdG9yLCBsb25nIGNhbGxJZCwgY29u c3QgZ2NoYXIqIHNjcmlwdCkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19XRUJf SU5TUEVDVE9SKHdlYkluc3BlY3RvcikpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwoc2NyaXB0KTsK KworICAgIFdlYktpdFdlYkluc3BlY3RvclByaXZhdGUqIHByaXYgPSB3ZWJJbnNwZWN0b3ItPnBy aXY7CisgICAgcHJpdi0+cGFnZS0+aW5zcGVjdG9yQ29udHJvbGxlcigpLT5ldmFsdWF0ZUZvclRl c3RJbkZyb250ZW5kKGNhbGxJZCwgc2NyaXB0KTsKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYmluc3BlY3Rvci5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vi aW5zcGVjdG9yLmgKaW5kZXggOTAxMGUyNi4uOTRmZDgwNiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0d2ViaW5zcGVjdG9yLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2ViaW5zcGVjdG9yLmgKQEAgLTYwLDYgKzYwLDEyIEBAIHdlYmtpdF93ZWJfaW5zcGVjdG9y X2dldF93ZWJfdmlldyhXZWJLaXRXZWJJbnNwZWN0b3IqIHdlYl9pbnNwZWN0b3IpOwogV0VCS0lU X0FQSSBjb25zdCBnY2hhcioKIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2dldF9pbnNwZWN0ZWRfdXJp KFdlYktpdFdlYkluc3BlY3Rvciogd2ViX2luc3BlY3Rvcik7CiAKK1dFQktJVF9BUEkgdm9pZAor d2Via2l0X3dlYl9pbnNwZWN0b3JfaW5zcGVjdF9jb29yZGluYXRlcyhXZWJLaXRXZWJJbnNwZWN0 b3IqIHdlYl9pbnNwZWN0b3IsIGdkb3VibGUgeCwgZ2RvdWJsZSB5KTsKKworV0VCS0lUX0FQSSB2 b2lkCit3ZWJraXRfd2ViX2luc3BlY3Rvcl9jbG9zZShXZWJLaXRXZWJJbnNwZWN0b3IqIHdlYklu c3BlY3Rvcik7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZiAvKiB3ZWJraXR3ZWJpbnNwZWN0b3Jf aCAqLwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hh bmdlTG9nCmluZGV4IGNhNjc5YmMuLjQxYzFhZjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0No YW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAw OS0xMC0yNyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9y YS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBbR1RLXSBBUEkgdG8gc3RhcnQgaW5zcGVjdG9yIGZvciBhIFdlYlZpZXcKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNTUxCisKKyAgICAgICAgVXNl IHRoZSBuZXcgaW5zcGVjdG9yIEFQSSB0byBpbXBsZW1lbnQgdGhlIExheW91dFRlc3RDb250cm9s bGVyCisgICAgICAgIGludGVyZmFjZXMgdXNlZCB0byB0ZXN0IHRoZSBpbnNwZWN0b3IuCisKKyAg ICAgICAgKiBEdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwOgorICAgICAgICAo d2ViSW5zcGVjdG9ySW5zcGVjdFdlYlZpZXcpOgorICAgICAgICAoY3JlYXRlV2ViVmlldyk6Cisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcDoK KyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpzaG93V2ViSW5zcGVjdG9yKToKKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjpjbG9zZVdlYkluc3BlY3Rvcik6CisgICAgICAgIChM YXlvdXRUZXN0Q29udHJvbGxlcjo6ZXZhbHVhdGVJbldlYkluc3BlY3Rvcik6CisKIDIwMDktMTAt MjcgIEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPgogCiAg ICAgICAgIFJ1YmJlcnN0YW1wZWQgYnkgT2xpdmVyIEh1bnQuCmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAppbmRleCBjZjg2YjMwLi40ZWQ2 ZTM2IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRl clRyZWUuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVy VHJlZS5jcHAKQEAgLTcwOCw2ICs3MDgsMTEgQEAgc3RhdGljIHZvaWQgZGF0YWJhc2VRdW90YUV4 Y2VlZGVkKFdlYktpdFdlYlZpZXcqIHZpZXcsIFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgV2UKIAog c3RhdGljIFdlYktpdFdlYlZpZXcqIHdlYlZpZXdDcmVhdGUoV2ViS2l0V2ViVmlldyosIFdlYktp dFdlYkZyYW1lKik7CiAKK3N0YXRpYyBXZWJLaXRXZWJWaWV3KiB3ZWJJbnNwZWN0b3JJbnNwZWN0 V2ViVmlldyhXZWJLaXRXZWJJbnNwZWN0b3IqLCBncG9pbnRlciBkYXRhKQoreworICAgIHJldHVy biBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKK30KKwogc3RhdGljIFdl YktpdFdlYlZpZXcqIGNyZWF0ZVdlYlZpZXcoKQogewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcg PSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKQEAgLTczMiw2ICs3Mzcs OSBAQCBzdGF0aWMgV2ViS2l0V2ViVmlldyogY3JlYXRlV2ViVmlldygpCiAgICAgICAgICAgICAg ICAgICAgICAic2lnbmFsOjpkYXRhYmFzZS1xdW90YS1leGNlZWRlZCIsIGRhdGFiYXNlUXVvdGFF eGNlZWRlZCwgMCwKICAgICAgICAgICAgICAgICAgICAgIE5VTEwpOwogCisgICAgV2ViS2l0V2Vi SW5zcGVjdG9yKiBpbnNwZWN0b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih2aWV3 KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KGluc3BlY3RvciwgImluc3BlY3Qtd2ViLXZpZXciLCBH X0NBTExCQUNLKHdlYkluc3BlY3Rvckluc3BlY3RXZWJWaWV3KSwgMCk7CisKICAgICByZXR1cm4g dmlldzsKIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xh eW91dFRlc3RDb250cm9sbGVyR3RrLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0 ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHAKaW5kZXggYjAxZGNmNC4uMzllZmQ3YSAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9s bGVyR3RrLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVz dENvbnRyb2xsZXJHdGsuY3BwCkBAIC0zLDYgKzMsNyBAQAogICogQ29weXJpZ2h0IChDKSAyMDA3 IEVyaWMgU2VpZGVsIDxlcmljQHdlYmtpdC5vcmc+CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggTnVh bnRpIEx0ZC4KICAqIENvcHlyaWdodCAoQykgMjAwOSBKYW4gTWljaGFlbCBBbG9uem8gPGptYWxv bnpvQGdtYWlsLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBDb2xsYWJvcmEgTHRkLgogICoK ICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC01Miw2ICs1Myw3IEBAIHVuc2lnbmVkIGlu dCB3ZWJraXRfd2ViX2ZyYW1lX251bWJlcl9vZl9hY3RpdmVfYW5pbWF0aW9ucyhXZWJLaXRXZWJG cmFtZSogZnJhbWUpCiB2b2lkIHdlYmtpdF9hcHBsaWNhdGlvbl9jYWNoZV9zZXRfbWF4aW11bV9z aXplKHVuc2lnbmVkIGxvbmcgbG9uZyBzaXplKTsKIHVuc2lnbmVkIGludCB3ZWJraXRfd29ya2Vy X3RocmVhZF9jb3VudCh2b2lkKTsKIHZvaWQgd2Via2l0X3doaXRlX2xpc3RfYWNjZXNzX2Zyb21f b3JpZ2luKGNvbnN0IGdjaGFyKiBzb3VyY2VPcmlnaW4sIGNvbnN0IGdjaGFyKiBkZXN0aW5hdGlv blByb3RvY29sLCBjb25zdCBnY2hhciogZGVzdGluYXRpb25Ib3N0LCBib29sIGFsbG93RGVzdGlu YXRpb25TdWJkb21haW5zKTsKK3ZvaWQgd2Via2l0X3dlYl9pbnNwZWN0b3JfZXhlY3V0ZV9zY3Jp cHQoV2ViS2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0b3IsIGxvbmcgY2FsbElkLCBjb25zdCBnY2hh ciogc2NyaXB0KTsKIH0KIAogc3RhdGljIGdjaGFyKiBjb3B5V2ViU2V0dGluZ0tleShnY2hhciog cHJlZmVyZW5jZUtleSkKQEAgLTQ3NCwxNyArNDc2LDMyIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRy b2xsZXI6OmFkZFVzZXJTdHlsZVNoZWV0KEpTU3RyaW5nUmVmIHNvdXJjZSkKIAogdm9pZCBMYXlv dXRUZXN0Q29udHJvbGxlcjo6c2hvd1dlYkluc3BlY3RvcigpCiB7Ci0gICAgLy8gRklYTUU6IElt cGxlbWVudCB0aGlzLgorICAgIFdlYktpdFdlYlZpZXcqIHdlYlZpZXcgPSB3ZWJraXRfd2ViX2Zy YW1lX2dldF93ZWJfdmlldyhtYWluRnJhbWUpOworICAgIFdlYktpdFdlYlNldHRpbmdzKiB3ZWJT ZXR0aW5ncyA9IHdlYmtpdF93ZWJfdmlld19nZXRfc2V0dGluZ3Mod2ViVmlldyk7CisgICAgV2Vi S2l0V2ViSW5zcGVjdG9yKiBpbnNwZWN0b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rv cih3ZWJWaWV3KTsKKworICAgIGdfb2JqZWN0X3NldCh3ZWJTZXR0aW5ncywgImVuYWJsZS1kZXZl bG9wZXItZXh0cmFzIiwgVFJVRSwgTlVMTCk7CisgICAgd2Via2l0X3dlYl9pbnNwZWN0b3JfaW5z cGVjdF9jb29yZGluYXRlcyhpbnNwZWN0b3IsIDAsIDApOwogfQogCiB2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpjbG9zZVdlYkluc3BlY3RvcigpCiB7Ci0gICAgLy8gRklYTUU6IEltcGxlbWVu dCB0aGlzLgorICAgIFdlYktpdFdlYlZpZXcqIHdlYlZpZXcgPSB3ZWJraXRfd2ViX2ZyYW1lX2dl dF93ZWJfdmlldyhtYWluRnJhbWUpOworICAgIFdlYktpdFdlYlNldHRpbmdzKiB3ZWJTZXR0aW5n cyA9IHdlYmtpdF93ZWJfdmlld19nZXRfc2V0dGluZ3Mod2ViVmlldyk7CisgICAgV2ViS2l0V2Vi SW5zcGVjdG9yKiBpbnNwZWN0b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih3ZWJW aWV3KTsKKworICAgIHdlYmtpdF93ZWJfaW5zcGVjdG9yX2Nsb3NlKGluc3BlY3Rvcik7CisgICAg Z19vYmplY3Rfc2V0KHdlYlNldHRpbmdzLCAiZW5hYmxlLWRldmVsb3Blci1leHRyYXMiLCBGQUxT RSwgTlVMTCk7CiB9CiAKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OmV2YWx1YXRlSW5XZWJJ bnNwZWN0b3IobG9uZyBjYWxsSWQsIEpTU3RyaW5nUmVmIHNjcmlwdCkKIHsKLSAgICAvLyBGSVhN RTogSW1wbGVtZW50IHRoaXMuCisgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IHdlYmtpdF93 ZWJfZnJhbWVfZ2V0X3dlYl92aWV3KG1haW5GcmFtZSk7CisgICAgV2ViS2l0V2ViSW5zcGVjdG9y KiBpbnNwZWN0b3IgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X2luc3BlY3Rvcih3ZWJWaWV3KTsKKyAg ICBjaGFyKiBzY3JpcHRTdHJpbmcgPSBKU1N0cmluZ0NvcHlVVEY4Q1N0cmluZyhzY3JpcHQpOwor CisgICAgd2Via2l0X3dlYl9pbnNwZWN0b3JfZXhlY3V0ZV9zY3JpcHQoaW5zcGVjdG9yLCBjYWxs SWQsIHNjcmlwdFN0cmluZyk7CisgICAgZ19mcmVlKHNjcmlwdFN0cmluZyk7CiB9CiAKIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OmV2YWx1YXRlU2NyaXB0SW5Jc29sYXRlZFdvcmxkKHVuc2ln bmVkIHdvcmxkSUQsIEpTT2JqZWN0UmVmIGdsb2JhbE9iamVjdCwgSlNTdHJpbmdSZWYgc2NyaXB0 KQotLSAKMS42LjUKCg==