88821 2012-06-11 17:10:44 -0700 [chromium] Quad list IPC infrastructure 2013-04-15 07:50:21 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 90582 90736 1 aelias aelias abarth aelias cc-bugs danakj dglazkov fishd jamesr piman schenney tkent+wkapi webkit.review.bot oldest_to_newest 646445 0 aelias 2012-06-11 17:10:44 -0700 [chromium] Quad list IPC infrastructure 646446 1 146970 aelias 2012-06-11 17:13:06 -0700 Created attachment 146970 Patch 646449 2 webkit.review.bot 2012-06-11 17:17:38 -0700 Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, fishd@chromium.org, jamesr@chromium.org or tkent@chromium.org before submitting, as this patch contains changes to the Chromium public API. See also https://trac.webkit.org/wiki/ChromiumWebKitAPI. 646453 3 146970 danakj 2012-06-11 17:20:28 -0700 Comment on attachment 146970 Patch I'm not sure what this patch is meant to do, and the changelog didn't help so some questions. Why is this changing InputHandler stuff? And why is a frame a single RenderPass? 646459 4 146970 jamesr 2012-06-11 17:24:13 -0700 Comment on attachment 146970 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=146970&action=review > Source/WebKit/chromium/public/WebCompositorFrame.h:40 > +struct WebCompositorMatrix { would using WebTransformationMatrix instead work for you? we should not need two matrix types > Source/WebKit/chromium/public/WebCompositorFrame.h:59 > +struct WebCompositorQuad { One type per header, please > Source/WebKit/chromium/public/WebCompositorFrame.h:72 > +struct WebCompositorFrame { This is misplaced - this should live in Platform/chromium/... so the compositor implementation can depend on it directly. it doesn't depend on any other WebKit client API notions > Source/WebKit/chromium/public/WebCompositorInputHandlerClient.h:52 > + virtual void sendCompositorFrame(const WebCompositorFrame&) = 0; This isn't an input handling concern, it shouldn't live on the input handler interface. instead, we should wire up a peer class for "other" compositor thread stuff. One possible refactoring, closer to the original design, would be to have WebCompositor::fromIdentifier() return a class with tear-offs for input handling and for whatever we're calling this > Source/WebKit/chromium/src/WebCompositorInputHandlerImpl.cpp:345 > + WTF::Vector<WebCompositorQuad> destQuadList; nit: you pretty much never say WTF:: in WebKit code, <wtf/Vector.h> has a using statement that pulls WTF::Vector into the global namespace so you can use it as just "Vector" 646468 5 aelias 2012-06-11 17:34:55 -0700 See also Chromium side: https://chromiumcodereview.appspot.com/10546115 You guys beat me to review because of the auto-CC, I was going to post some initial comments explaining some of this :) This is an initial version I've tested works to pipe a quad from LayerRendererChromium to RenderWidgetHostImpl. It takes the simplest approach of using the same structures for going across the WebKit->Chromium boundary and IPC boundary. This involves the following tradeoffs: - We need to introduce yet another matrix data structure because WebTransformationMatrix is hostile to being pickled. - The data format will get bloated because the WebCompositorQuad will need to include every possible field for a derived quad. (In reply to comment #4) > (From update of attachment 146970 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=146970&action=review > > > Source/WebKit/chromium/public/WebCompositorFrame.h:40 > > +struct WebCompositorMatrix { > > would using WebTransformationMatrix instead work for you? we should not need two matrix types I tried to add message_traits to WebTransformationMatrix to pickle it, but it didn't work -- the ownership semantics of the internal pointer are strange, and I'm not sure it's even allowed to have a WebCore object living in another process. The alternative to introducing this new matrix type would be to make ui/gfx/transformation.h picklable and introduce yet another quad data structure on the Chromium side. > > Source/WebKit/chromium/public/WebCompositorInputHandlerClient.h:52 > > + virtual void sendCompositorFrame(const WebCompositorFrame&) = 0; > > This isn't an input handling concern, it shouldn't live on the input handler interface. instead, we should wire up a peer class for "other" compositor thread stuff. Agreed it's an abuse of the class as currently named, but it makes sense at some level because it's an IPC going in the opposite direction, and InputHandler is essentially there to handle IPCs. I was thinking that we could rename it to IPCHandler? 646477 6 jamesr 2012-06-11 17:42:38 -0700 I think it's more trouble than it's worth to try to design a WebKit API type that is complex, pickleable, and makes sense as WebKit API. I would rather design a nice-looking WebKit API and figure out how to pickle/unpickle it in chromium code. 646481 7 danakj 2012-06-11 17:44:15 -0700 (In reply to comment #5) > - The data format will get bloated because the WebCompositorQuad will need to include every possible field for a derived quad. This makes me kinda sad, I'm doing work to split quads up to be more specific so the drawing code is more clear - but then they can be even smaller for IPC too. I think the quads can be entirely opaque to anything outside of the compositor, right? Can we make a TransportQuad thing, that has an enum (type of quad), a size, and a block of opaque memory of said size? And we just stick the quad into this opaque block of memory.. Maybe this is not very IPC friendly? Is there some way we can do better than this? 646484 8 jamesr 2012-06-11 17:47:17 -0700 (In reply to comment #5) > > > Source/WebKit/chromium/public/WebCompositorInputHandlerClient.h:52 > > > + virtual void sendCompositorFrame(const WebCompositorFrame&) = 0; > > > > This isn't an input handling concern, it shouldn't live on the input handler interface. instead, we should wire up a peer class for "other" compositor thread stuff. > > Agreed it's an abuse of the class as currently named, but it makes sense at some level because it's an IPC going in the opposite direction, and InputHandler is essentially there to handle IPCs. I was thinking that we could rename it to IPCHandler? InputHandler is there to handle input events. The fact that IPCs are involved (or that IPC is a thing that exists at all) is not a concern of the API or of WebKit at all. WebKit::WebCompositor is intended to be the interface to the compositor thread - I think it's fine to have other handler functions accessible through that API. 646499 9 aelias 2012-06-11 18:03:22 -0700 Okay, seems reasonable. I knew this patch was questionable and just wanted to put an initial version out for comments before working on it further. (In reply to comment #7) > (In reply to comment #5) > > - The data format will get bloated because the WebCompositorQuad will need to include every possible field for a derived quad. > > This makes me kinda sad, I'm doing work to split quads up to be more specific so the drawing code is more clear - but then they can be even smaller for IPC too. > > I think the quads can be entirely opaque to anything outside of the compositor, right? Can we make a TransportQuad thing, that has an enum (type of quad), a size, and a block of opaque memory of said size? And we just stick the quad into this opaque block of memory.. Maybe this is not very IPC friendly? Is there some way we can do better than this? Well, this would mean basically reinventing pickling. Which makes a degree of sense because the types of structures pickling supports are not very rich for our purposes (no pointers or inheritance). If we are going to use an alternate transfer mechanism, another alternative would be to use protocol buffers, which support dropping arbitrary fields. Alternately, I was thinking one way to make pickling work without bloating the quads would be for the top-level WebCompositorFrame have a different vector for each type of quad, and have the SharedQuadState referred to by ID. This would be way too ugly for WebKit API though. 646504 10 jamesr 2012-06-11 18:05:44 -0700 (In reply to comment #9) > Okay, seems reasonable. I knew this patch was questionable and just wanted to put an initial version out for comments before working on it further. > Always a good idea! > (In reply to comment #7) > > (In reply to comment #5) > > > - The data format will get bloated because the WebCompositorQuad will need to include every possible field for a derived quad. > > > > This makes me kinda sad, I'm doing work to split quads up to be more specific so the drawing code is more clear - but then they can be even smaller for IPC too. > > > > I think the quads can be entirely opaque to anything outside of the compositor, right? Can we make a TransportQuad thing, that has an enum (type of quad), a size, and a block of opaque memory of said size? And we just stick the quad into this opaque block of memory.. Maybe this is not very IPC friendly? Is there some way we can do better than this? > > Well, this would mean basically reinventing pickling. Which makes a degree of sense because the types of structures pickling supports are not very rich for our purposes (no pointers or inheritance). If we are going to use an alternate transfer mechanism, another alternative would be to use protocol buffers, which support dropping arbitrary fields. > > Alternately, I was thinking one way to make pickling work without bloating the quads would be for the top-level WebCompositorFrame have a different vector for each type of quad, and have the SharedQuadState referred to by ID. This would be way too ugly for WebKit API though. Oh, what a pickle! The combination of API and repository boundaries are quite a pain in the butt here. Maybe we could sync up offline and talk about timelines to see if there's some way to relax one of these constraints? 646565 11 aelias 2012-06-11 19:40:59 -0700 OK, after talking offline, we agreed to use the same trick as InputEvents to have variable-length pickling. That should solve the bloat problem while still allowing us to pickle the WebKit API objects directly. 646567 12 aelias 2012-06-11 19:51:19 -0700 Hmm, but the pickled std::vector's really not going to work. It has to be a vector of pointers. I now think we have to write a custom pickler for the top-level WebCompositorFrame object. Then we don't need the quads to contain a size field and we can use pointers everywhere. The big custom pickler will take care of everything and we can have a perfectly clean WebKit API. 646616 13 146970 webkit.review.bot 2012-06-11 21:47:55 -0700 Comment on attachment 146970 Patch Attachment 146970 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/12935929 646697 14 fishd 2012-06-12 00:16:10 -0700 NOTE: We usually don't let IPC concerns leak into WebKit. If a WebKit type is POD, then we can easily write an IPC::ParamTraits<> specialization for it, but otherwise, we typically create a mirror struct on the Chromium side for non-POD WebKit types. 664667 15 146970 fishd 2012-07-08 23:17:24 -0700 Comment on attachment 146970 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=146970&action=review > Source/WebCore/ChangeLog:3 > + [chromium] Quad list IPC infrastructure For Chromium, we try to keep IPC details out of WebKit. This means that the code we add to WebKit should make sense without anyone having to think about IPC details, ideally. >>> Source/WebKit/chromium/public/WebCompositorInputHandlerClient.h:52 >>> + virtual void sendCompositorFrame(const WebCompositorFrame&) = 0; >> >> This isn't an input handling concern, it shouldn't live on the input handler interface. instead, we should wire up a peer class for "other" compositor thread stuff. >> >> One possible refactoring, closer to the original design, would be to have WebCompositor::fromIdentifier() return a class with tear-offs for input handling and for whatever we're calling this > > Agreed it's an abuse of the class as currently named, but it makes sense at some level because it's an IPC going in the opposite direction, and InputHandler is essentially there to handle IPCs. I was thinking that we could rename it to IPCHandler? As mentioned above, please avoid IPC-specific details at the WebKit level. A class named IPCHandler definitely conflicts with that goal :) Catch-all routing classes tend to be problematic because they can easily grow unwieldy. It is helpful when classes/interfaces have related methods. In Chrome, RenderWidgetHelper is a good example of a catch-all routing class that has a number of unrelated methods. It is a bit messy to have so many different concerns all jumbled up together. 664905 16 146970 aelias 2012-07-09 09:11:03 -0700 Comment on attachment 146970 Patch Based on this feedback, I split this patch into somewhat bigger compositor refactorings that result in a cleaner WebKit API: see Bug 90582 and Bug 90736. Cancelling review on this one. 146970 2012-06-11 17:13:06 -0700 2012-07-09 09:11:03 -0700 Patch bug-88821-20120611171306.patch text/plain 10200 aelias U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwMDE4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjgxNmYxZTVkN2ExODYy OTcyYWU3NGNjNTEzOGU5NDdhY2NlZDNhOC4uNGQ3OWNkNGMwYjUzYzI0YWNjYWU4Y2JjNzA3YTc1 MDU4OGE3NTkwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEyLTA2LTExICBBbGV4 YW5kcmUgRWxpYXMgIDxhZWxpYXNAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIFF1 YWQgbGlzdCBJUEMgaW5mcmFzdHJ1Y3R1cmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTg4ODIxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoUGVuZGluZykKKworICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDSW5wdXRIYW5kbGVyLmg6CisgICAgICAgIChX ZWJDb3JlKToKKyAgICAgICAgKENDSW5wdXRIYW5kbGVyKToKKwogMjAxMi0wNi0xMSAgTWF4IEZl aWwgIDxtZmVpbEByaW0uY29tPgogCiAgICAgICAgIFtCbGFja0JlcnJ5XSBVbmV4cGVjdGVkIHJl cGVhdHMgb2Ygc2hvcnQgbWVkaWEKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMzdlMjJm YTUyOTQ0MGJlMThkNjUwYjQ0OGJjNTMyZTljNWMxMTYxZS4uMmUwYTkwNWY2YzhjNDg5Mjc5NjAw ODkxNTY5OWY4YzAzMDU5MmExMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyNiBAQAorMjAxMi0wNi0xMSAgQWxleGFuZHJlIEVsaWFzICA8YWVsaWFzQGdvb2dsZS5jb20+ CisKKyAgICAgICAgW2Nocm9taXVtXSBRdWFkIGxpc3QgSVBDIGluZnJhc3RydWN0dXJlCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04ODgyMQorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL1dlYkNv bXBvc2l0b3JGcmFtZS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJD b21wb3NpdG9yTWF0cml4KToKKyAgICAgICAgKFdlYkNvbXBvc2l0b3JRdWFkKToKKyAgICAgICAg KFdlYkNvbXBvc2l0b3JGcmFtZSk6CisgICAgICAgICogcHVibGljL1dlYkNvbXBvc2l0b3JJbnB1 dEhhbmRsZXJDbGllbnQuaDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJDb21wb3Np dG9ySW5wdXRIYW5kbGVyQ2xpZW50KToKKyAgICAgICAgKiBzcmMvV2ViQ29tcG9zaXRvcklucHV0 SGFuZGxlckltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjptYXRyaXhUb1dlYkNvbXBvc2l0b3JN YXRyaXgpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViQ29tcG9zaXRv cklucHV0SGFuZGxlckltcGw6OnNlbmRDb21wb3NpdG9yRnJhbWUpOgorICAgICAgICAqIHNyYy9X ZWJDb21wb3NpdG9ySW5wdXRIYW5kbGVySW1wbC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAg ICAgIChXZWJDb21wb3NpdG9ySW5wdXRIYW5kbGVySW1wbCk6CisKIDIwMTItMDYtMTEgIERhbmEg SmFuc2VucyAgPGRhbmFrakBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW2Nocm9taXVtXSBTZXBh cmF0ZSBDQ1ZpZGVvRHJhd1F1YWQgYW5kIGZyb20gdGhlIGxheWVyIHRyZWUgYW5kIHZpZGVvIHBy b3ZpZGVyIGJ5IHJlbW92aW5nIE1hbmFnZWRUZXh0dXJlIGFuZCBXZWJWaWRlb0ZyYW1lIHBvaW50 ZXJzIGZyb20gdGhlIHF1YWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL2NjL0NDSW5wdXRIYW5kbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0lucHV0SGFuZGxlci5oCmluZGV4IDc2NjA4ZDlm YzFkMGRhMTM5YTQ5MzBiYzUwNDdjMDhhZWI4YjJkZjQuLmVmZWViYTUyYjlhNTI4ZTlmYjViYTk3 NmYyNjAzYjViM2FhYjQxZGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL2NjL0NDSW5wdXRIYW5kbGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NJbnB1dEhhbmRsZXIuaApAQCAtMzEsNiAr MzEsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENDQWN0aXZlR2VzdHVyZUFuaW1h dGlvbjsKIGNsYXNzIENDR2VzdHVyZUN1cnZlVGFyZ2V0OworY2xhc3MgQ0NSZW5kZXJQYXNzOwog Y2xhc3MgSW50UG9pbnQ7CiBjbGFzcyBJbnRTaXplOwogCkBAIC05NCw2ICs5NSw3IEBAIHB1Ymxp YzoKIAogICAgIHZpcnR1YWwgaW50IGlkZW50aWZpZXIoKSBjb25zdCA9IDA7CiAgICAgdmlydHVh bCB2b2lkIGFuaW1hdGUoZG91YmxlIG1vbm90b25pY1RpbWUpID0gMDsKKyAgICB2aXJ0dWFsIHZv aWQgc2VuZENvbXBvc2l0b3JGcmFtZShjb25zdCBDQ1JlbmRlclBhc3MmKSA9IDA7CiAKIHByb3Rl Y3RlZDoKICAgICBDQ0lucHV0SGFuZGxlcigpIHsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tcG9zaXRvckZyYW1lLmggYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3B1YmxpYy9XZWJDb21wb3NpdG9yRnJhbWUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yYTVlMTA3NmIx N2ZiMmFkYjc4YjE4NzgyOWI5NWM2Y2FmMTMxNzcwCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tcG9zaXRvckZyYW1lLmgKQEAgLTAsMCArMSw3 OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoK KyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBp biB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2ds ZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0 d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09O VFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJ RVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIg UFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAor ICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBP RiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpZm5kZWYgV2ViQ29tcG9zaXRvckZyYW1lX2gKKyNkZWZpbmUgV2ViQ29tcG9zaXRvckZy YW1lX2gKKworI2luY2x1ZGUgInBsYXRmb3JtL1dlYkZsb2F0UmVjdC5oIgorI2luY2x1ZGUgInBs YXRmb3JtL1dlYlJlY3QuaCIKKyNpbmNsdWRlICJwbGF0Zm9ybS9XZWJWZWN0b3IuaCIKKworbmFt ZXNwYWNlIFdlYktpdCB7CisKK3N0cnVjdCBXZWJDb21wb3NpdG9yTWF0cml4IHsKKyAgICBkb3Vi bGUgbTExOworICAgIGRvdWJsZSBtMTI7CisgICAgZG91YmxlIG0xMzsKKyAgICBkb3VibGUgbTE0 OworICAgIGRvdWJsZSBtMjE7CisgICAgZG91YmxlIG0yMjsKKyAgICBkb3VibGUgbTIzOworICAg IGRvdWJsZSBtMjQ7CisgICAgZG91YmxlIG0zMTsKKyAgICBkb3VibGUgbTMyOworICAgIGRvdWJs ZSBtMzM7CisgICAgZG91YmxlIG0zNDsKKyAgICBkb3VibGUgbTQxOworICAgIGRvdWJsZSBtNDI7 CisgICAgZG91YmxlIG00MzsKKyAgICBkb3VibGUgbTQ0OworfTsKKworc3RydWN0IFdlYkNvbXBv c2l0b3JRdWFkIHsKKyAgICBXZWJDb21wb3NpdG9yTWF0cml4IHF1YWRUcmFuc2Zvcm07CisgICAg V2ViQ29tcG9zaXRvck1hdHJpeCBsYXllclRyYW5zZm9ybTsKKyAgICBXZWJSZWN0IGxheWVyUmVj dDsKKyAgICBXZWJSZWN0IHNjaXNzb3JSZWN0OworICAgIGZsb2F0IG9wYWNpdHk7CisgICAgYm9v bCBvcGFxdWU7CisKKyAgICBXZWJSZWN0IHF1YWRSZWN0OworICAgIFdlYlJlY3QgcXVhZFZpc2li bGVSZWN0OworICAgIFdlYlJlY3Qgb3BhcXVlUmVjdDsKK307CisKK3N0cnVjdCBXZWJDb21wb3Np dG9yRnJhbWUgeworICAgIFdlYlZlY3RvcjxXZWJDb21wb3NpdG9yUXVhZD4gcXVhZExpc3Q7Cisg ICAgV2ViRmxvYXRSZWN0IGZyYW1lYnVmZmVyT3V0cHV0UmVjdDsKK307CisKK30gLy8gbmFtZXNw YWNlIFdlYktpdAorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYkNvbXBvc2l0b3JJbnB1dEhhbmRsZXJDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYkNvbXBvc2l0b3JJbnB1dEhhbmRsZXJDbGllbnQuaAppbmRleCA3 YzkxMWQ4ZjhlYzAzMDFkNmUxZWFhNTI2NDcyODc1YzI0ZDg5YjNhLi45MzA3NWY5NTEyMTE4YzZl YzAxZDJiM2Q0MzAwMjkzZDBjZmJkY2NkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJDb21wb3NpdG9ySW5wdXRIYW5kbGVyQ2xpZW50LmgKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tcG9zaXRvcklucHV0SGFuZGxlckNsaWVudC5o CkBAIC0yOSw2ICsyOSw3IEBACiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogc3RydWN0IFdlYkFjdGl2 ZVdoZWVsRmxpbmdQYXJhbWV0ZXJzOworc3RydWN0IFdlYkNvbXBvc2l0b3JGcmFtZTsKIAogY2xh c3MgV2ViQ29tcG9zaXRvcklucHV0SGFuZGxlckNsaWVudCB7CiBwdWJsaWM6CkBAIC00OCw2ICs0 OSw3IEBAIHB1YmxpYzoKICAgICAvLyBGSVhNRTogTWFrZSBwdXJlIHZpcnR1YWwgb25jZSBpbXBs ZW1lbnRhdGlvbiBsYW5kcyBvbiBDaHJvbWl1bSBzaWRlLgogICAgIHZpcnR1YWwgdm9pZCB0cmFu c2ZlckFjdGl2ZVdoZWVsRmxpbmdBbmltYXRpb24oY29uc3QgV2ViQWN0aXZlV2hlZWxGbGluZ1Bh cmFtZXRlcnMmKSB7IH0KIAorICAgIHZpcnR1YWwgdm9pZCBzZW5kQ29tcG9zaXRvckZyYW1lKGNv bnN0IFdlYkNvbXBvc2l0b3JGcmFtZSYpID0gMDsKIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIH5X ZWJDb21wb3NpdG9ySW5wdXRIYW5kbGVyQ2xpZW50KCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViQ29tcG9zaXRvcklucHV0SGFuZGxlckltcGwuY3Bw IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViQ29tcG9zaXRvcklucHV0SGFuZGxlcklt cGwuY3BwCmluZGV4IDhlMGM2MTNhNDJhMzk2NjdlYTYzZTY1ZTkyNWEyMmE3YTM0YjE0OWQuLjEy ZDhmNzIzNzQ0ZTgwNzU5MDlmMjJmZTk4NmM4YTRmZDU5NDllNDQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkNvbXBvc2l0b3JJbnB1dEhhbmRsZXJJbXBsLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJDb21wb3NpdG9ySW5wdXRIYW5kbGVy SW1wbC5jcHAKQEAgLTMwLDEyICszMCwxNCBAQAogI2luY2x1ZGUgIlBsYXRmb3JtR2VzdHVyZUN1 cnZlVGFyZ2V0LmgiCiAjaW5jbHVkZSAiVG91Y2hwYWRGbGluZ1BsYXRmb3JtR2VzdHVyZUN1cnZl LmgiCiAjaW5jbHVkZSAiVHJhY2VFdmVudC5oIgorI2luY2x1ZGUgIldlYkNvbXBvc2l0b3JGcmFt ZS5oIgogI2luY2x1ZGUgIldlYkNvbXBvc2l0b3JJbXBsLmgiCiAjaW5jbHVkZSAiV2ViQ29tcG9z aXRvcklucHV0SGFuZGxlckNsaWVudC5oIgogI2luY2x1ZGUgIldlYklucHV0RXZlbnQuaCIKICNp bmNsdWRlICJXZWJLaXQuaCIKICNpbmNsdWRlICJjYy9DQ0FjdGl2ZUdlc3R1cmVBbmltYXRpb24u aCIKICNpbmNsdWRlICJjYy9DQ1Byb3h5LmgiCisjaW5jbHVkZSAiY2MvQ0NSZW5kZXJQYXNzLmgi CiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViS2l0UGxhdGZvcm1TdXBwb3J0LmgiCiAjaW5jbHVkZSA8 d3RmL1RocmVhZGluZ1ByaW1pdGl2ZXMuaD4KIApAQCAtMzE0LDYgKzMxNiw1NSBAQCB2b2lkIFdl YkNvbXBvc2l0b3JJbnB1dEhhbmRsZXJJbXBsOjphbmltYXRlKGRvdWJsZSBtb25vdG9uaWNUaW1l KQogICAgIH0KIH0KIAorc3RhdGljIHZvaWQgbWF0cml4VG9XZWJDb21wb3NpdG9yTWF0cml4KFdl YkNvbXBvc2l0b3JNYXRyaXgqIGRlc3RNYXRyaXgsIGNvbnN0IFdlYlRyYW5zZm9ybWF0aW9uTWF0 cml4JiBzcmNNYXRyaXgpCit7CisgICAgZGVzdE1hdHJpeC0+bTExID0gc3JjTWF0cml4Lm0xMSgp OworICAgIGRlc3RNYXRyaXgtPm0xMiA9IHNyY01hdHJpeC5tMTIoKTsKKyAgICBkZXN0TWF0cml4 LT5tMTMgPSBzcmNNYXRyaXgubTEzKCk7CisgICAgZGVzdE1hdHJpeC0+bTE0ID0gc3JjTWF0cml4 Lm0xNCgpOworICAgIGRlc3RNYXRyaXgtPm0yMSA9IHNyY01hdHJpeC5tMjEoKTsKKyAgICBkZXN0 TWF0cml4LT5tMjIgPSBzcmNNYXRyaXgubTIyKCk7CisgICAgZGVzdE1hdHJpeC0+bTIzID0gc3Jj TWF0cml4Lm0yMygpOworICAgIGRlc3RNYXRyaXgtPm0yNCA9IHNyY01hdHJpeC5tMjQoKTsKKyAg ICBkZXN0TWF0cml4LT5tMzEgPSBzcmNNYXRyaXgubTMxKCk7CisgICAgZGVzdE1hdHJpeC0+bTMy ID0gc3JjTWF0cml4Lm0zMigpOworICAgIGRlc3RNYXRyaXgtPm0zMyA9IHNyY01hdHJpeC5tMzMo KTsKKyAgICBkZXN0TWF0cml4LT5tMzQgPSBzcmNNYXRyaXgubTM0KCk7CisgICAgZGVzdE1hdHJp eC0+bTQxID0gc3JjTWF0cml4Lm00MSgpOworICAgIGRlc3RNYXRyaXgtPm00MiA9IHNyY01hdHJp eC5tNDIoKTsKKyAgICBkZXN0TWF0cml4LT5tNDMgPSBzcmNNYXRyaXgubTQzKCk7CisgICAgZGVz dE1hdHJpeC0+bTQ0ID0gc3JjTWF0cml4Lm00NCgpOworfQorCit2b2lkIFdlYkNvbXBvc2l0b3JJ bnB1dEhhbmRsZXJJbXBsOjpzZW5kQ29tcG9zaXRvckZyYW1lKGNvbnN0IFdlYkNvcmU6OkNDUmVu ZGVyUGFzcyYgcGFzcykKK3sKKyAgICBXZWJDb21wb3NpdG9yRnJhbWUgZnJhbWU7CisKKyAgICBj b25zdCBXZWJDb3JlOjpDQ1F1YWRMaXN0JiBxdWFkTGlzdCA9IHBhc3MucXVhZExpc3QoKTsKKwor ICAgIFdURjo6VmVjdG9yPFdlYkNvbXBvc2l0b3JRdWFkPiBkZXN0UXVhZExpc3Q7CisgICAgZm9y ICh1bnNpZ25lZCBpbnQgaSA9IDA7IGkgPCBxdWFkTGlzdC5zaXplKCk7IGkrKykgeworICAgICAg ICBjb25zdCBXZWJDb3JlOjpDQ0RyYXdRdWFkJiBzcmNRdWFkID0gKnF1YWRMaXN0W2ldLmdldCgp OworICAgICAgICBXZWJDb21wb3NpdG9yUXVhZCBkZXN0UXVhZDsKKyAgICAgICAgbWF0cml4VG9X ZWJDb21wb3NpdG9yTWF0cml4KCZkZXN0UXVhZC5xdWFkVHJhbnNmb3JtLCBzcmNRdWFkLnF1YWRU cmFuc2Zvcm0oKSk7CisgICAgICAgIG1hdHJpeFRvV2ViQ29tcG9zaXRvck1hdHJpeCgmZGVzdFF1 YWQubGF5ZXJUcmFuc2Zvcm0sIHNyY1F1YWQubGF5ZXJUcmFuc2Zvcm0oKSk7CisgICAgICAgIGRl c3RRdWFkLmxheWVyUmVjdCA9IHNyY1F1YWQubGF5ZXJSZWN0KCk7CisgICAgICAgIGRlc3RRdWFk LnNjaXNzb3JSZWN0ID0gc3JjUXVhZC5zY2lzc29yUmVjdCgpOworICAgICAgICBkZXN0UXVhZC5v cGFjaXR5ID0gc3JjUXVhZC5vcGFjaXR5KCk7CisKKyAgICAgICAgZGVzdFF1YWQucXVhZFJlY3Qg PSBzcmNRdWFkLnF1YWRSZWN0KCk7CisgICAgICAgIGRlc3RRdWFkLnF1YWRWaXNpYmxlUmVjdCA9 IHNyY1F1YWQucXVhZFZpc2libGVSZWN0KCk7CisgICAgICAgIGRlc3RRdWFkLm9wYXF1ZVJlY3Qg PSBzcmNRdWFkLm9wYXF1ZVJlY3QoKTsKKworICAgICAgICBkZXN0UXVhZExpc3QuYXBwZW5kKGRl c3RRdWFkKTsKKyAgICB9CisKKyAgICBmcmFtZS5xdWFkTGlzdCA9IGRlc3RRdWFkTGlzdDsKKyAg ICBmcmFtZS5mcmFtZWJ1ZmZlck91dHB1dFJlY3QgPSBwYXNzLmZyYW1lYnVmZmVyT3V0cHV0UmVj dCgpOworCisgICAgbV9jbGllbnQtPnNlbmRDb21wb3NpdG9yRnJhbWUoZnJhbWUpOworfQorCiBi b29sIFdlYkNvbXBvc2l0b3JJbnB1dEhhbmRsZXJJbXBsOjpjYW5jZWxDdXJyZW50RmxpbmcoKQog ewogICAgIGJvb2wgaGFkRmxpbmdBbmltYXRpb24gPSBtX3doZWVsRmxpbmdBbmltYXRpb247CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJDb21wb3NpdG9ySW5wdXRI YW5kbGVySW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViQ29tcG9zaXRvcklu cHV0SGFuZGxlckltcGwuaAppbmRleCA2NDY0NzEwNWIwM2M3MmRkYzc2Yjk4ZmU5OThlMjhiY2U3 ZjI3ZDM3Li5jODliMmUzYzE1NmI0ODI4NzRiNzg0ZjY3ZDA2YWQ1NGUyOWRhNzE1IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJDb21wb3NpdG9ySW5wdXRIYW5kbGVy SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkNvbXBvc2l0b3JJbnB1 dEhhbmRsZXJJbXBsLmgKQEAgLTQ0LDYgKzQ0LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogY2xh c3MgSW50UG9pbnQ7CiBjbGFzcyBDQ0dlc3R1cmVDdXJ2ZVRhcmdldDsKIGNsYXNzIENDSW5wdXRI YW5kbGVyQ2xpZW50OworY2xhc3MgQ0NSZW5kZXJQYXNzOwogY2xhc3MgQ0NUaHJlYWQ7CiB9CiAK QEAgLTY2LDYgKzY3LDcgQEAgcHVibGljOgogICAgIC8vIFdlYkNvcmU6OkNDSW5wdXRIYW5kbGVy IGltcGxlbWVudGF0aW9uLgogICAgIHZpcnR1YWwgaW50IGlkZW50aWZpZXIoKSBjb25zdDsKICAg ICB2aXJ0dWFsIHZvaWQgYW5pbWF0ZShkb3VibGUgbW9ub3RvbmljVGltZSk7CisgICAgdmlydHVh bCB2b2lkIHNlbmRDb21wb3NpdG9yRnJhbWUoY29uc3QgV2ViQ29yZTo6Q0NSZW5kZXJQYXNzJik7 CiAKICAgICAvLyBXZWJDb3JlOjpDQ0dlc3R1cmVDdXJ2ZVRhcmdldCBpbXBsZW1lbnRhdGlvbi4K ICAgICB2aXJ0dWFsIHZvaWQgc2Nyb2xsQnkoY29uc3QgV2ViQ29yZTo6SW50UG9pbnQmKTsK