115871 2013-05-09 13:18:27 -0700 [WK2] Make it possible to read Viewport information from WKViewportAttributes 2013-05-29 12:48:26 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) Unspecified Unspecified ASSIGNED P2 Normal --- 110463 1 jesus jesus benjamin cmarcelo hugo.lima kenneth kling luciano.wolf marcelo.lira menard mikhail.pozdnyakov nick.diego noam oldest_to_newest 887048 0 jesus 2013-05-09 13:18:27 -0700 WKViewClient (from WKView.h) has a callback defined as: typedef void (*WKViewPageDidChangeViewportAttributesCallback)(WKViewRef view, WKViewportAttributesRef, const void* clientInfo); However, currently it isn't possible to read any information from WKViewportAttributes. 887050 1 201269 jesus 2013-05-09 13:25:20 -0700 Created attachment 201269 Patch 887052 2 201269 benjamin 2013-05-09 13:33:09 -0700 Comment on attachment 201269 Patch Common C APIs should have tests. 887243 3 201269 mikhail.pozdnyakov 2013-05-09 23:37:43 -0700 Comment on attachment 201269 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=201269&action=review > Source/WebKit2/UIProcess/API/C/WKViewportAttributes.h:40 > +WK_EXPORT float WKViewportAttributesGetHeight(WKViewportAttributesRef); maybe WKViewportAttributesGetLayoutSize instead of 2 functions? > Source/WebKit2/UIProcess/API/C/WKViewportAttributes.h:44 > +WK_EXPORT bool WKViewportAttributesGetIsUserScalable(WKViewportAttributesRef); I remember we had a discussion about whether spec-compliant 'zoom' shall be used rather than 'scale' 887295 4 201269 jesus 2013-05-10 05:05:00 -0700 Comment on attachment 201269 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=201269&action=review >> Source/WebKit2/UIProcess/API/C/WKViewportAttributes.h:40 >> +WK_EXPORT float WKViewportAttributesGetHeight(WKViewportAttributesRef); > > maybe WKViewportAttributesGetLayoutSize instead of 2 functions? Having both avoid us creating a WKSize, but this is not a hot path anyway. >> Source/WebKit2/UIProcess/API/C/WKViewportAttributes.h:44 >> +WK_EXPORT bool WKViewportAttributesGetIsUserScalable(WKViewportAttributesRef); > > I remember we had a discussion about whether spec-compliant 'zoom' shall be used rather than 'scale' The spec says user-scalable, so does ViewportAttributes.h. I would rather keep it like this. 887444 5 201367 jesus 2013-05-10 11:25:11 -0700 Created attachment 201367 Patch 887448 6 jesus 2013-05-10 11:31:04 -0700 (In reply to comment #2) > (From update of attachment 201269 [details]) > Common C APIs should have tests. Yes, the problem about this one is that WKViewportAttributes has no "setters" and the only API using it is didChangeViewportAttributes from WKViewClient (API/C/CoordinatedGraphics/WKView.h). There is no other API using a WKViewportAttributesRef. 887463 7 mikhail.pozdnyakov 2013-05-10 11:46:25 -0700 (In reply to comment #6) > (In reply to comment #2) > > (From update of attachment 201269 [details] [details]) > > Common C APIs should have tests. > > Yes, the problem about this one is that WKViewportAttributes has no "setters" and the only API using it is didChangeViewportAttributes from WKViewClient (API/C/CoordinatedGraphics/WKView.h). There is no other API using a WKViewportAttributesRef. yeah, but it is still possible to test the API if you load a test page having viewport meta tag (or css viewport descriptors) and handle WKViewClient callback. 887470 8 jesus 2013-05-10 11:54:16 -0700 (In reply to comment #7) > (In reply to comment #6) > > (In reply to comment #2) > > > (From update of attachment 201269 [details] [details] [details]) > > > Common C APIs should have tests. > > > > Yes, the problem about this one is that WKViewportAttributes has no "setters" and the only API using it is didChangeViewportAttributes from WKViewClient (API/C/CoordinatedGraphics/WKView.h). There is no other API using a WKViewportAttributesRef. > > yeah, but it is still possible to test the API if you load a test page having viewport meta tag (or css viewport descriptors) and handle WKViewClient callback. Sure, but that would be testing the API only for ports using CoordinatedGraphics WKView. That means, on trunk, testing it only for EFL. And, by the way, Tests/WebKit2/efl/WKViewClientWebProcessCallbacks.cpp is only testing 2 of the WKViewClient callbacks (webProcessCrashed and webProcessDidRelaunch) anyway. What I mean is that there is no way to test this as a Common C API test. 887624 9 201367 benjamin 2013-05-10 14:35:02 -0700 Comment on attachment 201367 Patch I discussed this a bit with Jesus. Exposing raw viewport attribute is a bad idea. The computation of the view parameter depending on the page parameter is complex and it should be common to all the ports. It is really easy to fuck that up. The design of this should be such that mistakes are difficult to make. 887769 10 noam 2013-05-11 03:04:24 -0700 (In reply to comment #9) > (From update of attachment 201367 [details]) > I discussed this a bit with Jesus. > > Exposing raw viewport attribute is a bad idea. The computation of the view parameter depending on the page parameter is complex and it should be common to all the ports. > It is really easy to fuck that up. The design of this should be such that mistakes are difficult to make. Is the handling of viewport attributes completely deterministic? when I look at PageViewportController.cpp there are a lot of decisions there that seem heuristic/experience driven. It would be nice to share them but it doesn't seem absolutely mandatory. The idea of externalizing this is not about what code could be shared, it is that some of this is more of a browser-space experience decision than a library decision. btw isn't Apple doing all of this in browser space and not webkit space? 888207 11 jesus 2013-05-13 06:01:55 -0700 (In reply to comment #10) > Is the handling of viewport attributes completely deterministic? > when I look at PageViewportController.cpp there are a lot of decisions there that seem heuristic/experience driven. It would be nice to share them but it doesn't seem absolutely mandatory. > The idea of externalizing this is not about what code could be shared, it is that some of this is more of a browser-space experience decision than a library decision. > btw isn't Apple doing all of this in browser space and not webkit space? Good point... If the problem here is adding the APIs to WKViewportAttributes.h, which is a common header, then I will propose that we modify WKViewPageDidChangeViewportAttributesCallback to receive: (WKViewRef view, float width, float height, float minimumScale, float maximumScale, float initialScale, int userScalable, const void* clientInfo) instead of: (WKViewRef view, WKViewportAttributesRef, const void* clientInfo). This will be affecting only a CoordinatedGraphics specific API. Furthermore, by doing this we can also remove WKViewportAttributes.h from the WK2 C API entirely, as no one seems to be using this. What do you reviewers prefer? 888485 12 benjamin 2013-05-13 13:06:25 -0700 (In reply to comment #10) > Is the handling of viewport attributes completely deterministic? > when I look at PageViewportController.cpp there are a lot of decisions there that seem heuristic/experience driven. It would be nice to share them but it doesn't seem absolutely mandatory. > The idea of externalizing this is not about what code could be shared, it is that some of this is more of a browser-space experience decision than a library decision. Is the behavior completely defined by specifications? Unfortunately no. Would it be better for the Web to have a single behavior? yes. I don't want to limit the freedom you have to tweak the UX. But when it comes to computing the standard parameters and the layout size, WebKit should really align with iOS and Android. > btw isn't Apple doing all of this in browser space and not webkit space? No. 888487 13 benjamin 2013-05-13 13:07:52 -0700 > (WKViewRef view, float width, float height, float minimumScale, float maximumScale, float initialScale, int userScalable, const void* clientInfo) > > instead of: > > (WKViewRef view, WKViewportAttributesRef, const void* clientInfo). > > This will be affecting only a CoordinatedGraphics specific API. Furthermore, by doing this we can also remove WKViewportAttributes.h from the WK2 C API entirely, as no one seems to be using this. That was not my point at all. Sweeping stuff under the rug is not okay. 888571 14 noam 2013-05-13 16:24:59 -0700 > > This will be affecting only a CoordinatedGraphics specific API. Furthermore, by doing this we can also remove WKViewportAttributes.h from the WK2 C API entirely, as no one seems to be using this. > > That was not my point at all. > > Sweeping stuff under the rug is not okay. Nobody wants to sweep stuff under the rug. The discussion here is about whether this is browser space or webkit space. 888829 15 jesus 2013-05-14 07:30:37 -0700 (In reply to comment #14) > Nobody wants to sweep stuff under the rug. The discussion here is about whether this is browser space or webkit space. I had another chat about this with Benjamin last night. The summary, at least the way I see it, is that even for their use case (i.e.g. iOS does some sort of "computation" and then let WebKit know about the computed values, EFL uses PageViewportController, etc) a callback is missing in WK2. But, even after the computation this callback would need to expose: (WKViewRef view, float minimumScale, float maximumScale, float initialScale, int userScalable, const void* clientInfo); That is exposing everything related to Viewport but the layout size. What Benjamin insisted is that the mistake here is exposing "raw" viewport values and not the "computed" ones. The computed ones would avoid a conflicting set of inputs or unrealistic values (e.g. infinite initial scale), besides dealing with all the viewport hardcore computation. My point here persists: no matter if a port is doing some computation between its PageClient and its WebView, the C API is still missing a callback that gives the necessary information to the upper level. For example, the application needs to know if that content is user scalable or not so it can prevent the user from zooming in/out. 889829 16 noam 2013-05-16 08:09:43 -0700 (In reply to comment #15) > (In reply to comment #14) > My point here persists: no matter if a port is doing some computation between its PageClient and its WebView, the C API is still missing a callback that gives the necessary information to the upper level. For example, the application needs to know if that content is user scalable or not so it can prevent the user from zooming in/out. I tend to agree. This API is necessary for implementing e.g. pinch-to-zoom outside WebKit code. I don't see how you would implement pinch-to-zoom without knowing the minimum scale, max scale, user-scalable attributes and the viewport size. Benjamin, I think that this approach is right, though if it doesn't fit with Apple's API approach, I suggest that we either put it in API/CoordinatedGraphics or if you have more concrete details to share about how this could be done in a different way we'd love to see. 894484 17 marcelo.lira 2013-05-28 13:36:24 -0700 So? 894499 18 benjamin 2013-05-28 13:53:49 -0700 You should go forward if that blocks you, but not make APIs. Just use the internal objects directly. I also think WKViewportAttributesRef should go away. 894507 19 marcelo.lira 2013-05-28 14:17:09 -0700 (In reply to comment #18) > You should go forward if that blocks you, but not make APIs. Just use the internal objects directly. > > I also think WKViewportAttributesRef should go away. I wanted to access those values from an application, a MiniBrowser, outside WebKit. The exact case Noam mentioned: I want to know if zoom is allowed and how much, so that I know how the UI will handle pinching. 894509 20 benjamin 2013-05-28 14:19:15 -0700 (In reply to comment #19) > I wanted to access those values from an application, a MiniBrowser, outside WebKit. The exact case Noam mentioned: I want to know if zoom is allowed and how much, so that I know how the UI will handle pinching. Then expose a private API for your particular port. 895162 21 marcelo.lira 2013-05-29 12:48:26 -0700 (In reply to comment #20) > (In reply to comment #19) > > I wanted to access those values from an application, a MiniBrowser, outside WebKit. The exact case Noam mentioned: I want to know if zoom is allowed and how much, so that I know how the UI will handle pinching. > > Then expose a private API for your particular port. Ok. Works for me. 201269 2013-05-09 13:25:20 -0700 2013-05-10 11:25:00 -0700 Patch bug-115871-20130509172157.patch text/plain 4482 jesus U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ5ODM2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZTU0ZTk0ODM0YzYyYWRm ZTFiNjkyYjFkNDBhMmU2OGMwYmRkZjBmMy4uNjEwY2Y5MTlhMGI3YWY4Nzg5NGI4YzUwZTNkODVm MzU4Mjk2OTVmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEzLTA1LTA5ICBKZXN1 cyBTYW5jaGV6LVBhbGVuY2lhICA8amVzdXMucGFsZW5jaWFAb3BlbmJvc3NhLm9yZz4KKworICAg ICAgICBbV0syXSBNYWtlIGl0IHBvc3NpYmxlIHRvIHJlYWQgVmlld3BvcnQgaW5mb3JtYXRpb24g ZnJvbSBXS1ZpZXdwb3J0QXR0cmlidXRlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTE1ODcxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgV0tWaWV3Q2xpZW50LCBkZWZpbmVkIGluIFdLVmlldy5oLCBoYXMg YSBkaWRDaGFuZ2VWaWV3cG9ydEF0dHJpYnV0ZXMgY2FsbGJhY2sKKyAgICAgICAgd2hpY2ggaGFu ZGxlcyBhIFdLVmlld3BvcnRBdHRyaWJ1dGUuIFRoaXMgcGF0Y2ggYWRkIGZ1bmN0aW9ucyBzbyBv bmUgY2FuIHJlYWQKKyAgICAgICAgaW5mb3JtYXRpb24gZnJvbSBhIFdLVmlld3BvcnRBdHRyaWJ1 dGVzUmVmLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9DL1dLVmlld3BvcnRBdHRyaWJ1dGVz LmNwcDoKKyAgICAgICAgKFdLVmlld3BvcnRBdHRyaWJ1dGVzR2V0V2lkdGgpOgorICAgICAgICAo V0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRIZWlnaHQpOgorICAgICAgICAoV0tWaWV3cG9ydEF0dHJp YnV0ZXNHZXRNaW5pbXVtU2NhbGUpOgorICAgICAgICAoV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRN YXhpbXVtU2NhbGUpOgorICAgICAgICAoV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRJbml0aWFsU2Nh bGUpOgorICAgICAgICAoV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRJc1VzZXJTY2FsYWJsZSk6Cisg ICAgICAgIChXS1ZpZXdwb3J0QXR0cmlidXRlc0dldE9yaWVudGF0aW9uKToKKyAgICAgICAgKiBV SVByb2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0ZXMuaDoKKwogMjAxMy0wNS0wOSAgQW5k ZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFVzZSBleHBsaWNp dCBxdWFsaWZpZXJzIGZvciBuYW1lcyBpbiB0aGUgc3RkOjogbmFtZXNwYWNlCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0ZXMuY3Bw IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9DL1dLVmlld3BvcnRBdHRyaWJ1dGVzLmNw cAppbmRleCBlMzBhZjU2NjYwZTNjNGE2ZDkxNTJmNDI0YzljNTYxYjdlZTU0OGQ2Li5iMjAzNzk0 ZDg1ZGQ0NmExMjNlYmZiYWEyMzRiNzc3ZTM5YTA5NDhlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0ZXMuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvQy9XS1ZpZXdwb3J0QXR0cmlidXRlcy5jcHAKQEAgLTEs NSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDEzIEludGVsIENvcnBvcmF0aW9uLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDEzIE5va2lhIENvcnBvcmF0 aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKS4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucwpAQCAtMzUsMyArMzYsMzggQEAgV0tUeXBlSUQgV0tWaWV3cG9ydEF0dHJpYnV0ZXNH ZXRUeXBlSUQoKQogewogICAgIHJldHVybiB0b0FQSShXZWJWaWV3cG9ydEF0dHJpYnV0ZXM6OkFQ SVR5cGUpOwogfQorCitmbG9hdCBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldFdpZHRoKFdLVmlld3Bv cnRBdHRyaWJ1dGVzUmVmIGF0dHJpYnV0ZXNSZWYpCit7CisgICAgcmV0dXJuIHRvSW1wbChhdHRy aWJ1dGVzUmVmKS0+b3JpZ2luYWxBdHRyaWJ1dGVzKCkubGF5b3V0U2l6ZS53aWR0aCgpOworfQor CitmbG9hdCBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldEhlaWdodChXS1ZpZXdwb3J0QXR0cmlidXRl c1JlZiBhdHRyaWJ1dGVzUmVmKQoreworICAgIHJldHVybiB0b0ltcGwoYXR0cmlidXRlc1JlZikt Pm9yaWdpbmFsQXR0cmlidXRlcygpLmxheW91dFNpemUuaGVpZ2h0KCk7Cit9CisKK2Zsb2F0IFdL Vmlld3BvcnRBdHRyaWJ1dGVzR2V0TWluaW11bVNjYWxlKFdLVmlld3BvcnRBdHRyaWJ1dGVzUmVm IGF0dHJpYnV0ZXNSZWYpCit7CisgICAgcmV0dXJuIHRvSW1wbChhdHRyaWJ1dGVzUmVmKS0+b3Jp Z2luYWxBdHRyaWJ1dGVzKCkubWluaW11bVNjYWxlOworfQorCitmbG9hdCBXS1ZpZXdwb3J0QXR0 cmlidXRlc0dldE1heGltdW1TY2FsZShXS1ZpZXdwb3J0QXR0cmlidXRlc1JlZiBhdHRyaWJ1dGVz UmVmKQoreworICAgIHJldHVybiB0b0ltcGwoYXR0cmlidXRlc1JlZiktPm9yaWdpbmFsQXR0cmli dXRlcygpLm1heGltdW1TY2FsZTsKK30KKworZmxvYXQgV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRJ bml0aWFsU2NhbGUoV0tWaWV3cG9ydEF0dHJpYnV0ZXNSZWYgYXR0cmlidXRlc1JlZikKK3sKKyAg ICByZXR1cm4gdG9JbXBsKGF0dHJpYnV0ZXNSZWYpLT5vcmlnaW5hbEF0dHJpYnV0ZXMoKS5pbml0 aWFsU2NhbGU7Cit9CisKK2Jvb2wgV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRJc1VzZXJTY2FsYWJs ZShXS1ZpZXdwb3J0QXR0cmlidXRlc1JlZiBhdHRyaWJ1dGVzUmVmKQoreworICAgIHJldHVybiB0 b0ltcGwoYXR0cmlidXRlc1JlZiktPm9yaWdpbmFsQXR0cmlidXRlcygpLnVzZXJTY2FsYWJsZTsK K30KKworZmxvYXQgV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRPcmllbnRhdGlvbihXS1ZpZXdwb3J0 QXR0cmlidXRlc1JlZiBhdHRyaWJ1dGVzUmVmKQoreworICAgIHJldHVybiB0b0ltcGwoYXR0cmli dXRlc1JlZiktPm9yaWdpbmFsQXR0cmlidXRlcygpLm9yaWVudGF0aW9uOworfQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9DL1dLVmlld3BvcnRBdHRyaWJ1dGVzLmgg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0ZXMuaApp bmRleCAxMjViMDljYzQwZWYxMGFiMTRlMWEwNGYyMTJjZTgyNTZlYjBmOTdjLi45YjljMzNiZTAz Y2M4YTA4M2VhNWQ3MDQ2OWVjYmIxMGFlYzcyOTJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0ZXMuaAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0ZXMuaApAQCAtMSw1ICsxLDYg QEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMTMgSW50ZWwgQ29ycG9yYXRpb24uIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTMgTm9raWEgQ29ycG9yYXRpb24gYW5k L29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CkBAIC0zNSw2ICszNiwxNCBAQCBleHRlcm4gIkMiIHsKIAogV0tfRVhQT1JUIFdLVHlwZUlEIFdL Vmlld3BvcnRBdHRyaWJ1dGVzR2V0VHlwZUlEKCk7CiAKK1dLX0VYUE9SVCBmbG9hdCBXS1ZpZXdw b3J0QXR0cmlidXRlc0dldFdpZHRoKFdLVmlld3BvcnRBdHRyaWJ1dGVzUmVmKTsKK1dLX0VYUE9S VCBmbG9hdCBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldEhlaWdodChXS1ZpZXdwb3J0QXR0cmlidXRl c1JlZik7CitXS19FWFBPUlQgZmxvYXQgV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRNaW5pbXVtU2Nh bGUoV0tWaWV3cG9ydEF0dHJpYnV0ZXNSZWYpOworV0tfRVhQT1JUIGZsb2F0IFdLVmlld3BvcnRB dHRyaWJ1dGVzR2V0TWF4aW11bVNjYWxlKFdLVmlld3BvcnRBdHRyaWJ1dGVzUmVmKTsKK1dLX0VY UE9SVCBmbG9hdCBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldEluaXRpYWxTY2FsZShXS1ZpZXdwb3J0 QXR0cmlidXRlc1JlZik7CitXS19FWFBPUlQgYm9vbCBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldElz VXNlclNjYWxhYmxlKFdLVmlld3BvcnRBdHRyaWJ1dGVzUmVmKTsKK1dLX0VYUE9SVCBmbG9hdCBX S1ZpZXdwb3J0QXR0cmlidXRlc0dldE9yaWVudGF0aW9uKFdLVmlld3BvcnRBdHRyaWJ1dGVzUmVm KTsKKwogI2lmZGVmIF9fY3BsdXNwbHVzCiB9CiAjZW5kaWYK 201367 2013-05-10 11:25:11 -0700 2013-05-10 14:35:02 -0700 Patch bug-115871-20130510152147.patch text/plain 4083 jesus U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ5MTk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZTRhZDZiNTM3MGRhNDM1 Mjk5NDRiNTNiODcyNmZiOTUzYjJkZTRlYi4uZjNkOGM5MGRjYjIyY2RmNDFiZjhhMTAwNTM3ZjQz MWQ1ZjFkYTk3MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDEzLTA1LTA5ICBKZXN1 cyBTYW5jaGV6LVBhbGVuY2lhICA8amVzdXMucGFsZW5jaWFAb3BlbmJvc3NhLm9yZz4KKworICAg ICAgICBbV0syXSBNYWtlIGl0IHBvc3NpYmxlIHRvIHJlYWQgVmlld3BvcnQgaW5mb3JtYXRpb24g ZnJvbSBXS1ZpZXdwb3J0QXR0cmlidXRlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTE1ODcxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgV0tWaWV3Q2xpZW50LCBkZWZpbmVkIGluIFdLVmlldy5oLCBoYXMg YSBkaWRDaGFuZ2VWaWV3cG9ydEF0dHJpYnV0ZXMgY2FsbGJhY2sKKyAgICAgICAgd2hpY2ggaGFu ZGxlcyBhIFdLVmlld3BvcnRBdHRyaWJ1dGUuIFRoaXMgcGF0Y2ggYWRkIGZ1bmN0aW9ucyBzbyBv bmUgY2FuIHJlYWQKKyAgICAgICAgaW5mb3JtYXRpb24gZnJvbSBhIFdLVmlld3BvcnRBdHRyaWJ1 dGVzUmVmLgorCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9DL1dLVmlld3BvcnRBdHRyaWJ1dGVz LmNwcDoKKyAgICAgICAgKFdLVmlld3BvcnRBdHRyaWJ1dGVzR2V0U2l6ZSk6CisgICAgICAgIChX S1ZpZXdwb3J0QXR0cmlidXRlc0dldE1pbmltdW1TY2FsZSk6CisgICAgICAgIChXS1ZpZXdwb3J0 QXR0cmlidXRlc0dldE1heGltdW1TY2FsZSk6CisgICAgICAgIChXS1ZpZXdwb3J0QXR0cmlidXRl c0dldEluaXRpYWxTY2FsZSk6CisgICAgICAgIChXS1ZpZXdwb3J0QXR0cmlidXRlc0dldElzVXNl clNjYWxhYmxlKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0 ZXMuaDoKKwogMjAxMy0wNC0yNiAgQWxleGV5IFByb3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4K IAogICAgICAgICBCbG9icyBhcmUgbm90IGFzc29jaWF0ZWQgd2l0aCBjb25uZWN0aW9uIHdoZW4g dGhlcmUgYXJlIG5vIHNhbmRib3ggZXh0ZW5zaW9ucwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL0FQSS9DL1dLVmlld3BvcnRBdHRyaWJ1dGVzLmNwcCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9BUEkvQy9XS1ZpZXdwb3J0QXR0cmlidXRlcy5jcHAKaW5kZXggZTMwYWY1 NjY2MGUzYzRhNmQ5MTUyZjQyNGM5YzU2MWI3ZWU1NDhkNi4uZGM1YzVmN2EwZDlmZTI1ZWM0NjJj NjNkZTEwYzAwYzc1NGMzNzY4NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L0FQSS9DL1dLVmlld3BvcnRBdHRyaWJ1dGVzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQVBJL0MvV0tWaWV3cG9ydEF0dHJpYnV0ZXMuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoK ICAqIENvcHlyaWdodCAoQykgMjAxMyBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAxMyBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRz IHN1YnNpZGlhcnkoLWllcykuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTM1 LDMgKzM2LDI5IEBAIFdLVHlwZUlEIFdLVmlld3BvcnRBdHRyaWJ1dGVzR2V0VHlwZUlEKCkKIHsK ICAgICByZXR1cm4gdG9BUEkoV2ViVmlld3BvcnRBdHRyaWJ1dGVzOjpBUElUeXBlKTsKIH0KKwor V0tfRVhQT1JUIFdLU2l6ZSBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldFNpemUoV0tWaWV3cG9ydEF0 dHJpYnV0ZXNSZWYgYXR0cmlidXRlc1JlZikKK3sKKyAgICBXZWJDb3JlOjpWaWV3cG9ydEF0dHJp YnV0ZXMgb3JpZ2luYWxBdHRyaWJ1dGVzID0gdG9JbXBsKGF0dHJpYnV0ZXNSZWYpLT5vcmlnaW5h bEF0dHJpYnV0ZXMoKTsKKyAgICByZXR1cm4gV0tTaXplTWFrZShvcmlnaW5hbEF0dHJpYnV0ZXMu bGF5b3V0U2l6ZS53aWR0aCgpLCBvcmlnaW5hbEF0dHJpYnV0ZXMubGF5b3V0U2l6ZS5oZWlnaHQo KSk7Cit9CisKK2RvdWJsZSBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldE1pbmltdW1TY2FsZShXS1Zp ZXdwb3J0QXR0cmlidXRlc1JlZiBhdHRyaWJ1dGVzUmVmKQoreworICAgIHJldHVybiB0b0ltcGwo YXR0cmlidXRlc1JlZiktPm9yaWdpbmFsQXR0cmlidXRlcygpLm1pbmltdW1TY2FsZTsKK30KKwor ZG91YmxlIFdLVmlld3BvcnRBdHRyaWJ1dGVzR2V0TWF4aW11bVNjYWxlKFdLVmlld3BvcnRBdHRy aWJ1dGVzUmVmIGF0dHJpYnV0ZXNSZWYpCit7CisgICAgcmV0dXJuIHRvSW1wbChhdHRyaWJ1dGVz UmVmKS0+b3JpZ2luYWxBdHRyaWJ1dGVzKCkubWF4aW11bVNjYWxlOworfQorCitkb3VibGUgV0tW aWV3cG9ydEF0dHJpYnV0ZXNHZXRJbml0aWFsU2NhbGUoV0tWaWV3cG9ydEF0dHJpYnV0ZXNSZWYg YXR0cmlidXRlc1JlZikKK3sKKyAgICByZXR1cm4gdG9JbXBsKGF0dHJpYnV0ZXNSZWYpLT5vcmln aW5hbEF0dHJpYnV0ZXMoKS5pbml0aWFsU2NhbGU7Cit9CisKK2Jvb2wgV0tWaWV3cG9ydEF0dHJp YnV0ZXNHZXRJc1VzZXJTY2FsYWJsZShXS1ZpZXdwb3J0QXR0cmlidXRlc1JlZiBhdHRyaWJ1dGVz UmVmKQoreworICAgIHJldHVybiB0b0ltcGwoYXR0cmlidXRlc1JlZiktPm9yaWdpbmFsQXR0cmli dXRlcygpLnVzZXJTY2FsYWJsZTsKK30KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvQy9XS1ZpZXdwb3J0QXR0cmlidXRlcy5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0FQSS9DL1dLVmlld3BvcnRBdHRyaWJ1dGVzLmgKaW5kZXggMTI1YjA5Y2M0MGVmMTBhYjE0 ZTFhMDRmMjEyY2U4MjU2ZWIwZjk3Yy4uNGRmODZiNzMwYjY2NmQ4NDdlZmNjOTBiNTA1N2NlZjli NTM4ZWYyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9DL1dLVmll d3BvcnRBdHRyaWJ1dGVzLmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9DL1dL Vmlld3BvcnRBdHRyaWJ1dGVzLmgKQEAgLTEsNSArMSw2IEBACiAvKgogICogQ29weXJpZ2h0IChD KSAyMDEzIEludGVsIENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJp Z2h0IChDKSAyMDEzIE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVz KS4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMzUsNiArMzYsMTIgQEAgZXh0 ZXJuICJDIiB7CiAKIFdLX0VYUE9SVCBXS1R5cGVJRCBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldFR5 cGVJRCgpOwogCitXS19FWFBPUlQgV0tTaXplIFdLVmlld3BvcnRBdHRyaWJ1dGVzR2V0U2l6ZShX S1ZpZXdwb3J0QXR0cmlidXRlc1JlZik7CitXS19FWFBPUlQgZG91YmxlIFdLVmlld3BvcnRBdHRy aWJ1dGVzR2V0TWluaW11bVNjYWxlKFdLVmlld3BvcnRBdHRyaWJ1dGVzUmVmKTsKK1dLX0VYUE9S VCBkb3VibGUgV0tWaWV3cG9ydEF0dHJpYnV0ZXNHZXRNYXhpbXVtU2NhbGUoV0tWaWV3cG9ydEF0 dHJpYnV0ZXNSZWYpOworV0tfRVhQT1JUIGRvdWJsZSBXS1ZpZXdwb3J0QXR0cmlidXRlc0dldElu aXRpYWxTY2FsZShXS1ZpZXdwb3J0QXR0cmlidXRlc1JlZik7CitXS19FWFBPUlQgYm9vbCBXS1Zp ZXdwb3J0QXR0cmlidXRlc0dldElzVXNlclNjYWxhYmxlKFdLVmlld3BvcnRBdHRyaWJ1dGVzUmVm KTsKKwogI2lmZGVmIF9fY3BsdXNwbHVzCiB9CiAjZW5kaWYK