45939 2010-09-16 18:09:48 -0700 Add entry points to GraphicsContext3D needed for Chromium compositor port 2010-09-30 06:48:28 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 45912 1 kbr kbr cmarrin darin hausmann jamesr senorblanco vangelis webkit.review.bot oldest_to_newest 280489 0 kbr 2010-09-16 18:09:48 -0700 In order to host Chromium's compositor on top of GraphicsContext3D, a couple of Chromium-specific extensions need to be exposed, and an additional boolean argument to the constructor is needed indicating whether the GraphicsContext3D instance is supposed to render directly to the passed HostWindow, or be treated as an off-screen context per the current semantics. 280493 1 67871 kbr 2010-09-16 18:20:12 -0700 Created attachment 67871 Patch From the ChangeLog: Added entry points for two Chromium-specific extensions, and added a flag to the GraphicsContext3D constructor, currently unsupported by all ports (including Chromium), indicating whether the context should render directly to the passed HostWindow or off-screen per the current semantics. The switch to use GraphicsContext3D in Chromium's compositor will follow in a subsequent patch. No new tests; functionality is unchanged. Built and tested Chromium and WebKit on Mac OS X. 280495 2 webkit.review.bot 2010-09-16 18:23:17 -0700 Attachment 67871 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style']" exit_code: 1 WebKit/chromium/src/GraphicsContext3D.cpp:56: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 1 in 10 files If any of these errors are false positives, please file a bug against check-webkit-style. 280499 3 67871 jamesr 2010-09-16 18:29:23 -0700 Comment on attachment 67871 Patch Looks good, just a few nits to address before landing: - this patch uses UNUSED_PARAM() many times when it doesn't need to. If all permutations of a function will not use a parameter you can just avoid naming the parameter in the .cpp. UNUSED_PARAM is more for this case: void foo(int parameter) { #ifdef SOMETHING bar(parameter); #else UNUSED_PARAM(parameter); #endif } Also, consider changing renderDirectlyToHostWindow from a bool to an enum. View in context: https://bugs.webkit.org/attachment.cgi?id=67871&action=prettypatch > WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:103 > + UNUSED_PARAM(renderDirectlyToHostWindow); instead of UNUSED_PARAM() just don't name the parameter > WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp:506 > +GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool renderDirectlyToHostWindow) > : m_internal(new GraphicsContext3DInternal(attrs, hostWindow)) > { > + UNUSED_PARAM(renderDirectlyToHostWindow); instead of using UNUSED_PARAM() here, just don't name the parameter 280503 4 kbr 2010-09-16 18:45:41 -0700 (In reply to comment #3) > (From update of attachment 67871 [details]) > Looks good, just a few nits to address before landing: > > - this patch uses UNUSED_PARAM() many times when it doesn't need to. If all permutations of a function will not use a parameter you can just avoid naming the parameter in the .cpp. UNUSED_PARAM is more for this case: > > void foo(int parameter) { > #ifdef SOMETHING > bar(parameter); > #else > UNUSED_PARAM(parameter); > #endif > } I didn't realize this worked for function definitions as well as declarations. Will fix upon landing. Removing the inclusion of UNUSED_PARAM will also fix the style violation. > Also, consider changing renderDirectlyToHostWindow from a bool to an enum. Good idea; will do. > View in context: https://bugs.webkit.org/attachment.cgi?id=67871&action=prettypatch > > > WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:103 > > + UNUSED_PARAM(renderDirectlyToHostWindow); > > instead of UNUSED_PARAM() just don't name the parameter Will do. > > WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp:506 > > +GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool renderDirectlyToHostWindow) > > : m_internal(new GraphicsContext3DInternal(attrs, hostWindow)) > > { > > + UNUSED_PARAM(renderDirectlyToHostWindow); > > instead of using UNUSED_PARAM() here, just don't name the parameter Will do. 280504 5 kbr 2010-09-16 18:53:58 -0700 Committed r67690: <http://trac.webkit.org/changeset/67690> 280613 6 67871 cmarrin 2010-09-17 05:13:31 -0700 Comment on attachment 67871 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=67871&action=prettypatch I really think it is a mistake to commit this change in its current state. Please consider backing it out and following my recommendations. > WebCore/platform/graphics/GraphicsContext3D.h:772 > + I don't like having explicit 'supports' calls like this. If you want to start implementing an extension mechanism, you should do it the way we've defined it in WebGL. Make a base class called Extension3D or something and add a getExtension() call which returns one. Then make a concrete subclass for your extension and add the appropriate calls to that. You can then cast the return from getExtension to this subclass and use it. It would probably be best to not keep a reference to the GC3D in this class to avoid lifetime issues. You can just have the API pass it for each call. You should also be consistent about using the GL_ prefix with all your extensions. >>> WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:103 >>> + UNUSED_PARAM(renderDirectlyToHostWindow); >> >> instead of UNUSED_PARAM() just don't name the parameter > > Will do. I disagree. This is the right way to handle this, especially since this is a boolean. It's better for documentation. >>> WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp:506 >>> + UNUSED_PARAM(renderDirectlyToHostWindow); >> >> instead of using UNUSED_PARAM() here, just don't name the parameter > > Will do. Again, doing it this way is better for documentation. 280700 7 kbr 2010-09-17 10:09:32 -0700 (In reply to comment #6) > (From update of attachment 67871 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67871&action=prettypatch > > I really think it is a mistake to commit this change in its current state. Please consider backing it out and following my recommendations. > > > WebCore/platform/graphics/GraphicsContext3D.h:772 > > + > > I don't like having explicit 'supports' calls like this. If you want to start implementing an extension mechanism, you should do it the way we've defined it in WebGL. Make a base class called Extension3D or something and add a getExtension() call which returns one. Then make a concrete subclass for your extension and add the appropriate calls to that. You can then cast the return from getExtension to this subclass and use it. It would probably be best to not keep a reference to the GC3D in this class to avoid lifetime issues. You can just have the API pass it for each call. I really don't like this suggested structure. For WebGL we made a deliberate decision to expose OpenGL extensions in an object-oriented fashion, but to do it cleanly at the GraphicsContext3D level would really require both Extension3D and GraphicsContext3D to be RefCounted, and Extension3D objects to use a RefPtr to refer to their GraphicsContext3D. Forcing all of the API entry points of the Extension3D subclasses to take a GraphicsContext3D as the first argument as a hack to avoid making everything RefCounted is just gross. WebGLRenderingContext is reference counted, as will be its extension objects. Having them bottom out into explicitly and easily callable entry points on GraphicsContext3D makes implementing them much simpler. Adding Extension3D classes at this level is going to add a *lot* of boilerplate code, duplicated per platform where the extensions are implemented per platform. > You should also be consistent about using the GL_ prefix with all your extensions. I don't understand this comment. GraphicsContext3D stripped the gl prefix to function names and GL_ prefix to enum values. The newly added enums here come from desktop OpenGL which didn't use a vendor suffix, which is why they're READ_ONLY rather than READ_ONLY_CHROMIUM, etc. The new extension entry points use a vendor suffix just like they would in OpenGL for C. > >>> WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:103 > >>> + UNUSED_PARAM(renderDirectlyToHostWindow); > >> > >> instead of UNUSED_PARAM() just don't name the parameter > > > > Will do. > > I disagree. This is the right way to handle this, especially since this is a boolean. It's better for documentation. The WebKit style guide is mum on this issue but a quick grep through the source tree does show, as James pointed out, that UNUSED_PARAM is in many places used in conjunction with #ifdefs. Also, this parameter is no longer a boolean but an enum. I prefer the current structure as it saves a lot of lines of code. > >>> WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp:506 > >>> + UNUSED_PARAM(renderDirectlyToHostWindow); > >> > >> instead of using UNUSED_PARAM() here, just don't name the parameter > > > > Will do. > > Again, doing it this way is better for documentation. 280703 8 darin 2010-09-17 10:11:16 -0700 (In reply to comment #6) > >>> WebCore/platform/graphics/mac/GraphicsContext3DMac.mm:103 > >>> + UNUSED_PARAM(renderDirectlyToHostWindow); > >> > >> instead of UNUSED_PARAM() just don't name the parameter > > > > Will do. > > I disagree. This is the right way to handle this, especially since this is a boolean. It's better for documentation. Chris, I agree with James on this and disagree with you. This is not the WebKit style way to handle it. We want to avoid using the UNUSED_PARAM macro in almost every case. It’s both inelegant and doesn’t work. You can say UNUSED_PARAM and then go ahead and use the parameter, which is not good! If we feel the need to name an parameter for clarity then we can put it in /* */ comments at the top of the function definition. I think this clarity is what you mean by “documentation”. In many cases, having the name of the parameter does not increase clarity, but the technique with the /* */ comment works fine for cases where it does. 280735 9 cmarrin 2010-09-17 10:48:48 -0700 (In reply to comment #7) > (In reply to comment #6) > > (From update of attachment 67871 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=67871&action=prettypatch > > > > I really think it is a mistake to commit this change in its current state. Please consider backing it out and following my recommendations. > > > > > WebCore/platform/graphics/GraphicsContext3D.h:772 > > > + > > > > I don't like having explicit 'supports' calls like this. If you want to start implementing an extension mechanism, you should do it the way we've defined it in WebGL. Make a base class called Extension3D or something and add a getExtension() call which returns one. Then make a concrete subclass for your extension and add the appropriate calls to that. You can then cast the return from getExtension to this subclass and use it. It would probably be best to not keep a reference to the GC3D in this class to avoid lifetime issues. You can just have the API pass it for each call. > > I really don't like this suggested structure. For WebGL we made a deliberate decision to expose OpenGL extensions in an object-oriented fashion, but to do it cleanly at the GraphicsContext3D level would really require both Extension3D and GraphicsContext3D to be RefCounted, and Extension3D objects to use a RefPtr to refer to their GraphicsContext3D. Forcing all of the API entry points of the Extension3D subclasses to take a GraphicsContext3D as the first argument as a hack to avoid making everything RefCounted is just gross. > > WebGLRenderingContext is reference counted, as will be its extension objects. Having them bottom out into explicitly and easily callable entry points on GraphicsContext3D makes implementing them much simpler. Adding Extension3D classes at this level is going to add a *lot* of boilerplate code, duplicated per platform where the extensions are implemented per platform. I understand you don't like my design proposal, but we have to do something different from what you've checked in. We can't have functions like mapBufferSubDataCHROMIUM() in the cross-platform API of GraphicsContext3D. That's a function that is specific to your implementation needs and should be in platform dependent code. In fact, it is actually implemented in your GraphicsContext3DInternal object, so why not just give access to that? I'm all for formalizing the extension mechanism, but doing it by constantly expanding the GC3D API will eventually be crushed under its own weight. Here's another idea. What if we had a single Extension3D object, returned as a const pointer from a getExtensions() function in GC3D. The concrete implementation of this object would be platform specific, so you'd do something like: static_cast<const Extensions3DChromium*>(ctx->getExtensions())->mapBufferSubData(...); The Extensions3D class could have its own API for the extensions common to all platforms. GC3D could also have a hasExtension(string) function to test whether a particular implementation had a particular extension. Since you wouldn't ever keep a persistent reference to the Extensions3D object, its lifetime would match that of GC3D, and it could keep a GC3D pointer to make it easy to implement the extension API. How would that work? I don't follow you. > > > You should also be consistent about using the GL_ prefix with all your extensions. > > I don't understand this comment. GraphicsContext3D stripped the gl prefix to function names and GL_ prefix to enum values. The newly added enums here come from desktop OpenGL which didn't use a vendor suffix, which is why they're READ_ONLY rather than READ_ONLY_CHROMIUM, etc. The new extension entry points use a vendor suffix just like they would in OpenGL for C. I'm just referring to the fact that you use EXT_texture_format_BGRA8888 and GL_CHROMIUM_map_sub. You should use GL_ on both or neither. 287283 10 kbr 2010-09-29 18:16:19 -0700 (In reply to comment #9) > (In reply to comment #7) > > (In reply to comment #6) > > > (From update of attachment 67871 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=67871&action=prettypatch > > > > > > I really think it is a mistake to commit this change in its current state. Please consider backing it out and following my recommendations. > > > > > > > WebCore/platform/graphics/GraphicsContext3D.h:772 > > > > + > > > > > > I don't like having explicit 'supports' calls like this. If you want to start implementing an extension mechanism, you should do it the way we've defined it in WebGL. Make a base class called Extension3D or something and add a getExtension() call which returns one. Then make a concrete subclass for your extension and add the appropriate calls to that. You can then cast the return from getExtension to this subclass and use it. It would probably be best to not keep a reference to the GC3D in this class to avoid lifetime issues. You can just have the API pass it for each call. > > > > I really don't like this suggested structure. For WebGL we made a deliberate decision to expose OpenGL extensions in an object-oriented fashion, but to do it cleanly at the GraphicsContext3D level would really require both Extension3D and GraphicsContext3D to be RefCounted, and Extension3D objects to use a RefPtr to refer to their GraphicsContext3D. Forcing all of the API entry points of the Extension3D subclasses to take a GraphicsContext3D as the first argument as a hack to avoid making everything RefCounted is just gross. > > > > WebGLRenderingContext is reference counted, as will be its extension objects. Having them bottom out into explicitly and easily callable entry points on GraphicsContext3D makes implementing them much simpler. Adding Extension3D classes at this level is going to add a *lot* of boilerplate code, duplicated per platform where the extensions are implemented per platform. > > I understand you don't like my design proposal, but we have to do something different from what you've checked in. We can't have functions like mapBufferSubDataCHROMIUM() in the cross-platform API of GraphicsContext3D. That's a function that is specific to your implementation needs and should be in platform dependent code. In fact, it is actually implemented in your GraphicsContext3DInternal object, so why not just give access to that? That suggestion doesn't work in the Chromium port. Chromium's GraphicsContext3D implementation needs to bridge out to code in the surrounding browser, and the GraphicsContext3DInternal needs to refer to types in Chromium's WebKit API (WebKit/chromium/public). These references can't be made from WebCore. > I'm all for formalizing the extension mechanism, but doing it by constantly expanding the GC3D API will eventually be crushed under its own weight. I think this is an exaggeration. At least for Chromium we have no desire or intention to add more extensions and in fact aim to remove GL_CHROMIUM_copy_texture_to_parent_texture as soon as possible. In the WebGL working group discussions there are only a fairly small number of OpenGL ES 2.0 extensions that are under consideration for addition. > Here's another idea. What if we had a single Extension3D object, returned as a const pointer from a getExtensions() function in GC3D. The concrete implementation of this object would be platform specific, so you'd do something like: > > static_cast<const Extensions3DChromium*>(ctx->getExtensions())->mapBufferSubData(...); > > The Extensions3D class could have its own API for the extensions common to all platforms. GC3D could also have a hasExtension(string) function to test whether a particular implementation had a particular extension. I agree that we should probably get rid of the explicit supportsXYZ() calls in favor of hasExtension(String). > Since you wouldn't ever keep a persistent reference to the Extensions3D object, its lifetime would match that of GC3D, and it could keep a GC3D pointer to make it easy to implement the extension API. > > How would that work? It's possible to make this work. Doing so will require adding Extensions3D (which needs a per-port create() function), Extensions3DChromium, associated Internal classes, etc. Extensions3D will need a weak reference to GraphicsContext3D and friend declarations will need to be made to allow the extension implementation to refer to the GraphicsContext3D internals. There will be a fair amount of replicated code per platform, as there is in GraphicsContext3D. I'm willing to do the work but don't really believe it is worth the effort -- or, at least, I think there is higher priority work to be done toward finishing the WebGL implementation. If you feel strongly about it then I will file another bug to do this refactoring and assign it to myself. > > > You should also be consistent about using the GL_ prefix with all your extensions. > > > > I don't understand this comment. GraphicsContext3D stripped the gl prefix to function names and GL_ prefix to enum values. The newly added enums here come from desktop OpenGL which didn't use a vendor suffix, which is why they're READ_ONLY rather than READ_ONLY_CHROMIUM, etc. The new extension entry points use a vendor suffix just like they would in OpenGL for C. > > I'm just referring to the fact that you use EXT_texture_format_BGRA8888 and GL_CHROMIUM_map_sub. You should use GL_ on both or neither. I see. Depending on the decision of how to handle these extension functions I'll either do this cleanup in GraphicsContext3D or Extensions3D. 287523 11 cmarrin 2010-09-30 06:48:28 -0700 (In reply to comment #10) > ... > > > I'm all for formalizing the extension mechanism, but doing it by constantly expanding the GC3D API will eventually be crushed under its own weight. > > I think this is an exaggeration. At least for Chromium we have no desire or intention to add more extensions and in fact aim to remove GL_CHROMIUM_copy_texture_to_parent_texture as soon as possible. In the WebGL working group discussions there are only a fairly small number of OpenGL ES 2.0 extensions that are under consideration for addition. It's not an exaggeration if you think about how this will look 5 years down the line. And what if someone wants to do some experimentation, adding some crazy extension for a single platform. Adding that to GraphicsContext3D will be cumbersome at best. I really think we need a better mechanism. > > > Here's another idea. What if we had a single Extension3D object, returned as a const pointer from a getExtensions() function in GC3D. The concrete implementation of this object would be platform specific, so you'd do something like: > > > > static_cast<const Extensions3DChromium*>(ctx->getExtensions())->mapBufferSubData(...); > > > > The Extensions3D class could have its own API for the extensions common to all platforms. GC3D could also have a hasExtension(string) function to test whether a particular implementation had a particular extension. > > I agree that we should probably get rid of the explicit supportsXYZ() calls in favor of hasExtension(String). > > > Since you wouldn't ever keep a persistent reference to the Extensions3D object, its lifetime would match that of GC3D, and it could keep a GC3D pointer to make it easy to implement the extension API. > > > > How would that work? > > It's possible to make this work. Doing so will require adding Extensions3D (which needs a per-port create() function), Extensions3DChromium, associated Internal classes, etc. Extensions3D will need a weak reference to GraphicsContext3D and friend declarations will need to be made to allow the extension implementation to refer to the GraphicsContext3D internals. There will be a fair amount of replicated code per platform, as there is in GraphicsContext3D. I'm willing to do the work but don't really believe it is worth the effort -- or, at least, I think there is higher priority work to be done toward finishing the WebGL implementation. If you feel strongly about it then I will file another bug to do this refactoring and assign it to myself. I feel strongly that going further down this path is a mistake. Adding hackery for expediency just incurs greater cost down the road. We not only have to fix the problem, but the memory of why it was done in the first place has faded, so it's more expensive to figure out the right fix. I've opened a new bug for this: https://bugs.webkit.org/show_bug.cgi?id=46894. Let's continue the conversation there. The proposal I made there is different in that it only has a single Extension3D object which all extensions for a given platform hang off of. That will make the platform specific code less cumbersome. And since many extensions will be exposing OpenGL functionality, we can put a lot of this in a single Extension3DOpenGL subclass which can be shared by any platform using OpenGL (or maybe even ANGLE). Let me know what you think... 67871 2010-09-16 18:20:12 -0700 2010-09-17 05:13:31 -0700 Patch gc3d-entry-points.patch text/plain 17841 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NzY4MikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzggQEAKKzIwMTAtMDktMTYgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCBlbnRyeSBwb2ludHMgdG8gR3JhcGhpY3NDb250ZXh0M0QgbmVlZGVkIGZvciBDaHJvbWl1bSBj b21wb3NpdG9yIHBvcnQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQ1OTM5CisKKyAgICAgICAgQWRkZWQgZW50cnkgcG9pbnRzIGZvciB0d28gQ2hyb21p dW0tc3BlY2lmaWMgZXh0ZW5zaW9ucywgYW5kIGFkZGVkCisgICAgICAgIGEgZmxhZyB0byB0aGUg R3JhcGhpY3NDb250ZXh0M0QgY29uc3RydWN0b3IsIGN1cnJlbnRseSB1bnN1cHBvcnRlZAorICAg ICAgICBieSBhbGwgcG9ydHMgKGluY2x1ZGluZyBDaHJvbWl1bSksIGluZGljYXRpbmcgd2hldGhl ciB0aGUgY29udGV4dAorICAgICAgICBzaG91bGQgcmVuZGVyIGRpcmVjdGx5IHRvIHRoZSBwYXNz ZWQgSG9zdFdpbmRvdyBvciBvZmYtc2NyZWVuIHBlcgorICAgICAgICB0aGUgY3VycmVudCBzZW1h bnRpY3MuIFRoZSBzd2l0Y2ggdG8gdXNlIEdyYXBoaWNzQ29udGV4dDNEIGluCisgICAgICAgIENo cm9taXVtJ3MgY29tcG9zaXRvciB3aWxsIGZvbGxvdyBpbiBhIHN1YnNlcXVlbnQgcGF0Y2guCisK KyAgICAgICAgTm8gbmV3IHRlc3RzOyBmdW5jdGlvbmFsaXR5IGlzIHVuY2hhbmdlZC4gQnVpbHQg YW5kIHRlc3RlZAorICAgICAgICBDaHJvbWl1bSBhbmQgV2ViS2l0IG9uIE1hYyBPUyBYLgorCisg ICAgICAgICogaHRtbC9jYW52YXMvV2ViR0xSZW5kZXJpbmdDb250ZXh0LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OldlYkdMUmVuZGVyaW5nQ29udGV4dDo6Y3JlYXRlKToKKyAgICAgICAgKiBwbGF0 Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpH cmFwaGljc0NvbnRleHQzRDo6c3VwcG9ydHNNYXBTdWJDSFJPTUlVTSk6CisgICAgICAgIChXZWJD b3JlOjpHcmFwaGljc0NvbnRleHQzRDo6bWFwQnVmZmVyU3ViRGF0YUNIUk9NSVVNKToKKyAgICAg ICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjp1bm1hcEJ1ZmZlclN1YkRhdGFDSFJPTUlV TSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRDo6bWFwVGV4U3ViSW1hZ2Uy RENIUk9NSVVNKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjp1bm1hcFRl eFN1YkltYWdlMkRDSFJPTUlVTSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQz RDo6c3VwcG9ydHNDb3B5VGV4dHVyZVRvUGFyZW50VGV4dHVyZUNIUk9NSVVNKToKKyAgICAgICAg KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjpjb3B5VGV4dHVyZVRvUGFyZW50VGV4dHVyZUNI Uk9NSVVNKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5o OgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL21hYy9HcmFwaGljc0NvbnRleHQzRE1hYy5t bToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUpOgorICAgICAg ICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6OkdyYXBoaWNzQ29udGV4dDNEKToKKyAgICAg ICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9xdC9HcmFwaGljc0NvbnRleHQzRFF0LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29y ZTo6R3JhcGhpY3NDb250ZXh0M0Q6OkdyYXBoaWNzQ29udGV4dDNEKToKKwogMjAxMC0wOS0xNiAg U2ltb24gRnJhc2VyICA8c2ltb24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdl ZCBieSBKYW1lcyBSb2JpbnNvbi4KSW5kZXg6IFdlYkNvcmUvaHRtbC9jYW52YXMvV2ViR0xSZW5k ZXJpbmdDb250ZXh0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvY2FudmFzL1dlYkdM UmVuZGVyaW5nQ29udGV4dC5jcHAJKHJldmlzaW9uIDY3NjgxKQorKysgV2ViQ29yZS9odG1sL2Nh bnZhcy9XZWJHTFJlbmRlcmluZ0NvbnRleHQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04OCw3ICs4 OCw3IEBAIFBhc3NPd25QdHI8V2ViR0xSZW5kZXJpbmdDb250ZXh0PiBXZWJHTFIKIHsKICAgICBI b3N0V2luZG93KiBob3N0V2luZG93ID0gY2FudmFzLT5kb2N1bWVudCgpLT52aWV3KCktPnJvb3Qo KS0+aG9zdFdpbmRvdygpOwogICAgIEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGVtcHR5 QXR0cmlidXRlczsKLSAgICBPd25QdHI8R3JhcGhpY3NDb250ZXh0M0Q+IGNvbnRleHQoR3JhcGhp Y3NDb250ZXh0M0Q6OmNyZWF0ZShhdHRycyA/IGF0dHJzLT5hdHRyaWJ1dGVzKCkgOiBlbXB0eUF0 dHJpYnV0ZXMsIGhvc3RXaW5kb3cpKTsKKyAgICBPd25QdHI8R3JhcGhpY3NDb250ZXh0M0Q+IGNv bnRleHQoR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZShhdHRycyA/IGF0dHJzLT5hdHRyaWJ1dGVz KCkgOiBlbXB0eUF0dHJpYnV0ZXMsIGhvc3RXaW5kb3csIGZhbHNlKSk7CiAKICAgICBpZiAoIWNv bnRleHQpCiAgICAgICAgIHJldHVybiAwOwpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9HcmFwaGljc0NvbnRleHQzRC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5jcHAJKHJldmlzaW9uIDY3NjgxKQorKysgV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTMzLDYgKzMzLDcgQEAKICNpbmNsdWRlICJBcnJheUJ1ZmZlclZpZXcuaCIKICNpbmNsdWRl ICJJbWFnZS5oIgogI2luY2x1ZGUgIkltYWdlRGF0YS5oIgorI2luY2x1ZGUgPHd0Zi9VbnVzZWRQ YXJhbS5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTgzMCw2ICs4MzEsNTcgQEAgYm9v bCBHcmFwaGljc0NvbnRleHQzRDo6c3VwcG9ydHNCR1JBKCkKICAgICAvLyBSZXR1cm5pbmcgZmFs c2UgZm9yIG5vdyB0byBiZSBzYWZlLgogICAgIHJldHVybiBmYWxzZTsKIH0KKworYm9vbCBHcmFw aGljc0NvbnRleHQzRDo6c3VwcG9ydHNNYXBTdWJDSFJPTUlVTSgpCit7CisgICAgLy8gV2UgZG9u J3QgY2xhaW0gc3VwcG9ydCBmb3IgdGhpcyBleHRlbnNpb24gYXQgdGhpcyB0aW1lLgorICAgIHJl dHVybiBmYWxzZTsKK30KKwordm9pZCogR3JhcGhpY3NDb250ZXh0M0Q6Om1hcEJ1ZmZlclN1YkRh dGFDSFJPTUlVTSh1bnNpZ25lZCB0YXJnZXQsIGludCBvZmZzZXQsIGludCBzaXplLCB1bnNpZ25l ZCBhY2Nlc3MpCit7CisgICAgVU5VU0VEX1BBUkFNKHRhcmdldCk7CisgICAgVU5VU0VEX1BBUkFN KG9mZnNldCk7CisgICAgVU5VU0VEX1BBUkFNKHNpemUpOworICAgIFVOVVNFRF9QQVJBTShhY2Nl c3MpOworICAgIHJldHVybiAwOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDNEOjp1bm1hcEJ1 ZmZlclN1YkRhdGFDSFJPTUlVTShjb25zdCB2b2lkKiBtZW0pCit7CisgICAgVU5VU0VEX1BBUkFN KG1lbSk7Cit9CisKK3ZvaWQqIEdyYXBoaWNzQ29udGV4dDNEOjptYXBUZXhTdWJJbWFnZTJEQ0hS T01JVU0odW5zaWduZWQgdGFyZ2V0LCBpbnQgbGV2ZWwsIGludCB4b2Zmc2V0LCBpbnQgeW9mZnNl dCwgaW50IHdpZHRoLCBpbnQgaGVpZ2h0LCB1bnNpZ25lZCBmb3JtYXQsIHVuc2lnbmVkIHR5cGUs IHVuc2lnbmVkIGFjY2VzcykKK3sKKyAgICBVTlVTRURfUEFSQU0odGFyZ2V0KTsKKyAgICBVTlVT RURfUEFSQU0obGV2ZWwpOworICAgIFVOVVNFRF9QQVJBTSh4b2Zmc2V0KTsKKyAgICBVTlVTRURf UEFSQU0oeW9mZnNldCk7CisgICAgVU5VU0VEX1BBUkFNKHdpZHRoKTsKKyAgICBVTlVTRURfUEFS QU0oaGVpZ2h0KTsKKyAgICBVTlVTRURfUEFSQU0oZm9ybWF0KTsKKyAgICBVTlVTRURfUEFSQU0o dHlwZSk7CisgICAgVU5VU0VEX1BBUkFNKGFjY2Vzcyk7CisgICAgcmV0dXJuIDA7Cit9CisKK3Zv aWQgR3JhcGhpY3NDb250ZXh0M0Q6OnVubWFwVGV4U3ViSW1hZ2UyRENIUk9NSVVNKGNvbnN0IHZv aWQqIG1lbSkKK3sKKyAgICBVTlVTRURfUEFSQU0obWVtKTsKK30KKworYm9vbCBHcmFwaGljc0Nv bnRleHQzRDo6c3VwcG9ydHNDb3B5VGV4dHVyZVRvUGFyZW50VGV4dHVyZUNIUk9NSVVNKCkKK3sK KyAgICAvLyBXZSBkb24ndCBjbGFpbSBzdXBwb3J0IGZvciB0aGlzIGV4dGVuc2lvbiBhdCB0aGlz IHRpbWUuCisgICAgcmV0dXJuIGZhbHNlOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDNEOjpj b3B5VGV4dHVyZVRvUGFyZW50VGV4dHVyZUNIUk9NSVVNKHVuc2lnbmVkIHRleHR1cmUsIHVuc2ln bmVkIHBhcmVudFRleHR1cmUpCit7CisgICAgVU5VU0VEX1BBUkFNKHRleHR1cmUpOworICAgIFVO VVNFRF9QQVJBTShwYXJlbnRUZXh0dXJlKTsKK30KICNlbmRpZgogCiB9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNE LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRl eHQzRC5oCShyZXZpc2lvbiA2NzY4MSkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3Jh cGhpY3NDb250ZXh0M0QuaAkod29ya2luZyBjb3B5KQpAQCAtNDA0LDcgKzQwNCwxMiBAQCBwdWJs aWM6CiAgICAgICAgIFVOUEFDS19GTElQX1lfV0VCR0wgPSAweDkyNDAsCiAgICAgICAgIFVOUEFD S19QUkVNVUxUSVBMWV9BTFBIQV9XRUJHTCA9IDB4OTI0MSwKIAotICAgICAgICBCR1JBX0VYVCA9 IDB4ODBFMQorICAgICAgICAvLyBHTF9FWFRfdGV4dHVyZV9mb3JtYXRfQkdSQTg4ODgKKyAgICAg ICAgQkdSQV9FWFQgPSAweDgwRTEsCisKKyAgICAgICAgLy8gR0xfQ0hST01JVU1fbWFwX3N1YiAo ZW51bXMgaW5oZXJpdGVkIGZyb20gR0xfQVJCX3ZlcnRleF9idWZmZXJfb2JqZWN0KQorICAgICAg ICBSRUFEX09OTFkgPSAweDg4QjgsCisgICAgICAgIFdSSVRFX09OTFkgPSAweDg4QjkKICAgICB9 OwogCiAgICAgLy8gQ29udGV4dCBjcmVhdGlvbiBhdHRyaWJ1dGVzLgpAQCAtNDI1LDcgKzQzMCw3 IEBAIHB1YmxpYzoKICAgICAgICAgYm9vbCBwcmVtdWx0aXBsaWVkQWxwaGE7CiAgICAgfTsKIAot ICAgIHN0YXRpYyBQYXNzT3duUHRyPEdyYXBoaWNzQ29udGV4dDNEPiBjcmVhdGUoQXR0cmlidXRl cyBhdHRycywgSG9zdFdpbmRvdyogaG9zdFdpbmRvdyk7CisgICAgc3RhdGljIFBhc3NPd25QdHI8 R3JhcGhpY3NDb250ZXh0M0Q+IGNyZWF0ZShBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93KiBo b3N0V2luZG93LCBib29sIHJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93KTsKICAgICB2aXJ0dWFs IH5HcmFwaGljc0NvbnRleHQzRCgpOwogCiAjaWYgUExBVEZPUk0oTUFDKQpAQCAtNzUxLDEwICs3 NTYsMjIgQEAgcHVibGljOgogICAgIC8vIGdldEVycm9yIGluIHRoZSBvcmRlciB0aGV5IHdlcmUg YWRkZWQuCiAgICAgdm9pZCBzeW50aGVzaXplR0xFcnJvcih1bnNpZ25lZCBsb25nIGVycm9yKTsK IAorICAgIC8vIEVYVF90ZXh0dXJlX2Zvcm1hdF9CR1JBODg4OAogICAgIGJvb2wgc3VwcG9ydHNC R1JBKCk7CiAKKyAgICAvLyBHTF9DSFJPTUlVTV9tYXBfc3ViCisgICAgYm9vbCBzdXBwb3J0c01h cFN1YkNIUk9NSVVNKCk7CisgICAgdm9pZCogbWFwQnVmZmVyU3ViRGF0YUNIUk9NSVVNKHVuc2ln bmVkIHRhcmdldCwgaW50IG9mZnNldCwgaW50IHNpemUsIHVuc2lnbmVkIGFjY2Vzcyk7CisgICAg dm9pZCB1bm1hcEJ1ZmZlclN1YkRhdGFDSFJPTUlVTShjb25zdCB2b2lkKik7CisgICAgdm9pZCog bWFwVGV4U3ViSW1hZ2UyRENIUk9NSVVNKHVuc2lnbmVkIHRhcmdldCwgaW50IGxldmVsLCBpbnQg eG9mZnNldCwgaW50IHlvZmZzZXQsIGludCB3aWR0aCwgaW50IGhlaWdodCwgdW5zaWduZWQgZm9y bWF0LCB1bnNpZ25lZCB0eXBlLCB1bnNpZ25lZCBhY2Nlc3MpOworICAgIHZvaWQgdW5tYXBUZXhT dWJJbWFnZTJEQ0hST01JVU0oY29uc3Qgdm9pZCopOworCisgICAgLy8gR0xfQ0hST01JVU1fY29w eV90ZXh0dXJlX3RvX3BhcmVudF90ZXh0dXJlCisgICAgYm9vbCBzdXBwb3J0c0NvcHlUZXh0dXJl VG9QYXJlbnRUZXh0dXJlQ0hST01JVU0oKTsKKyAgICB2b2lkIGNvcHlUZXh0dXJlVG9QYXJlbnRU ZXh0dXJlQ0hST01JVU0odW5zaWduZWQgdGV4dHVyZSwgdW5zaWduZWQgcGFyZW50VGV4dHVyZSk7 CisKICAgcHJpdmF0ZToKLSAgICBHcmFwaGljc0NvbnRleHQzRChBdHRyaWJ1dGVzIGF0dHJzLCBI b3N0V2luZG93KiBob3N0V2luZG93KTsKKyAgICBHcmFwaGljc0NvbnRleHQzRChBdHRyaWJ1dGVz IGF0dHJzLCBIb3N0V2luZG93KiBob3N0V2luZG93LCBib29sIHJlbmRlckRpcmVjdGx5VG9Ib3N0 V2luZG93KTsKIAogICAgIC8vIEVhY2ggcGxhdGZvcm0gbXVzdCBwcm92aWRlIGFuIGltcGxlbWVu dGF0aW9uIG9mIHRoaXMgbWV0aG9kLgogICAgIC8vCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL21hYy9HcmFwaGljc0NvbnRleHQzRE1hYy5tbQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL21hYy9HcmFwaGljc0NvbnRleHQzRE1hYy5tbQkocmV2aXNpb24g Njc2ODEpCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL21hYy9HcmFwaGljc0NvbnRleHQz RE1hYy5tbQkod29ya2luZyBjb3B5KQpAQCAtNzcsMTMgKzc3LDE2IEBAIHN0YXRpYyB2b2lkIHNl dFBpeGVsRm9ybWF0KFZlY3RvcjxDR0xQaXgKICAgICBhdHRyaWJzLmFwcGVuZChzdGF0aWNfY2Fz dDxDR0xQaXhlbEZvcm1hdEF0dHJpYnV0ZT4oMCkpOwogfQogCi1QYXNzT3duUHRyPEdyYXBoaWNz Q29udGV4dDNEPiBHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKEdyYXBoaWNzQ29udGV4dDNEOjpB dHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93KiBob3N0V2luZG93KQorUGFzc093blB0cjxHcmFw aGljc0NvbnRleHQzRD4gR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZShHcmFwaGljc0NvbnRleHQz RDo6QXR0cmlidXRlcyBhdHRycywgSG9zdFdpbmRvdyogaG9zdFdpbmRvdywgYm9vbCByZW5kZXJE aXJlY3RseVRvSG9zdFdpbmRvdykKIHsKLSAgICBPd25QdHI8R3JhcGhpY3NDb250ZXh0M0Q+IGNv bnRleHQobmV3IEdyYXBoaWNzQ29udGV4dDNEKGF0dHJzLCBob3N0V2luZG93KSk7CisgICAgLy8g VGhpcyBpbXBsZW1lbnRhdGlvbiBkb2Vzbid0IGN1cnJlbnRseSBzdXBwb3J0IHJlbmRlcmluZyBk aXJlY3RseSB0byB0aGUgSG9zdFdpbmRvdy4KKyAgICBpZiAocmVuZGVyRGlyZWN0bHlUb0hvc3RX aW5kb3cpCisgICAgICAgIHJldHVybiAwOworICAgIE93blB0cjxHcmFwaGljc0NvbnRleHQzRD4g Y29udGV4dChuZXcgR3JhcGhpY3NDb250ZXh0M0QoYXR0cnMsIGhvc3RXaW5kb3csIHJlbmRlckRp cmVjdGx5VG9Ib3N0V2luZG93KSk7CiAgICAgcmV0dXJuIGNvbnRleHQtPm1fY29udGV4dE9iaiA/ IGNvbnRleHQucmVsZWFzZSgpIDogMDsKIH0KIAotR3JhcGhpY3NDb250ZXh0M0Q6OkdyYXBoaWNz Q29udGV4dDNEKEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93 KiBob3N0V2luZG93KQorR3JhcGhpY3NDb250ZXh0M0Q6OkdyYXBoaWNzQ29udGV4dDNEKEdyYXBo aWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93KiBob3N0V2luZG93LCBi b29sIHJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93KQogICAgIDogbV9jdXJyZW50V2lkdGgoMCkK ICAgICAsIG1fY3VycmVudEhlaWdodCgwKQogICAgICwgbV9hdHRycyhhdHRycykKQEAgLTk3LDYg KzEwMCw3IEBAIEdyYXBoaWNzQ29udGV4dDNEOjpHcmFwaGljc0NvbnRleHQzRChHcmEKICAgICAs IG1fbXVsdGlzYW1wbGVDb2xvckJ1ZmZlcigwKQogewogICAgIFVOVVNFRF9QQVJBTShob3N0V2lu ZG93KTsKKyAgICBVTlVTRURfUEFSQU0ocmVuZGVyRGlyZWN0bHlUb0hvc3RXaW5kb3cpOwogCiAg ICAgVmVjdG9yPENHTFBpeGVsRm9ybWF0QXR0cmlidXRlPiBhdHRyaWJzOwogICAgIENHTFBpeGVs Rm9ybWF0T2JqIHBpeGVsRm9ybWF0T2JqID0gMDsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvcXQvR3JhcGhpY3NDb250ZXh0M0RRdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9xdC9HcmFwaGljc0NvbnRleHQzRFF0LmNwcAkocmV2aXNpb24gNjc2 ODEpCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3F0L0dyYXBoaWNzQ29udGV4dDNEUXQu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC00OTEsMTUgKzQ5MSwxOSBAQCB2b2lkKiBHcmFwaGljc0Nv bnRleHQzREludGVybmFsOjpnZXRQcm9jCiAgICAgcmV0dXJuIDA7CiB9CiAKLVBhc3NPd25QdHI8 R3JhcGhpY3NDb250ZXh0M0Q+IEdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUoR3JhcGhpY3NDb250 ZXh0M0Q6OkF0dHJpYnV0ZXMgYXR0cnMsIEhvc3RXaW5kb3cqIGhvc3RXaW5kb3cpCitQYXNzT3du UHRyPEdyYXBoaWNzQ29udGV4dDNEPiBHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKEdyYXBoaWNz Q29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93KiBob3N0V2luZG93LCBib29s IHJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93KQogewotICAgIE93blB0cjxHcmFwaGljc0NvbnRl eHQzRD4gY29udGV4dChuZXcgR3JhcGhpY3NDb250ZXh0M0QoYXR0cnMsIGhvc3RXaW5kb3cpKTsK KyAgICAvLyBUaGlzIGltcGxlbWVudGF0aW9uIGRvZXNuJ3QgY3VycmVudGx5IHN1cHBvcnQgcmVu ZGVyaW5nIGRpcmVjdGx5IHRvIHRoZSBIb3N0V2luZG93LgorICAgIGlmIChyZW5kZXJEaXJlY3Rs eVRvSG9zdFdpbmRvdykKKyAgICAgICAgcmV0dXJuIDA7CisgICAgT3duUHRyPEdyYXBoaWNzQ29u dGV4dDNEPiBjb250ZXh0KG5ldyBHcmFwaGljc0NvbnRleHQzRChhdHRycywgaG9zdFdpbmRvdywg cmVuZGVyRGlyZWN0bHlUb0hvc3RXaW5kb3cpKTsKICAgICByZXR1cm4gY29udGV4dC0+bV9pbnRl cm5hbCA/IGNvbnRleHQucmVsZWFzZSgpIDogMDsKIH0KIAotR3JhcGhpY3NDb250ZXh0M0Q6Okdy YXBoaWNzQ29udGV4dDNEKEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0 V2luZG93KiBob3N0V2luZG93KQorR3JhcGhpY3NDb250ZXh0M0Q6OkdyYXBoaWNzQ29udGV4dDNE KEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93KiBob3N0V2lu ZG93LCBib29sIHJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93KQogICAgIDogbV9pbnRlcm5hbChu ZXcgR3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbChhdHRycywgaG9zdFdpbmRvdykpCiB7CisgICAg VU5VU0VEX1BBUkFNKHJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93KTsKICAgICBpZiAoIW1faW50 ZXJuYWwtPmlzQ29udGV4dFZhbGlkKCkpIAogICAgICAgICBtX2ludGVybmFsID0gMDsKIH0KSW5k ZXg6IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZwkocmV2aXNpb24gNjc2ODIpCisrKyBXZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjcgQEAKKzIwMTAtMDktMTYgIEtlbm5ldGgg UnVzc2VsbCAgPGtickBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZCBlbnRyeSBwb2ludHMgdG8gR3JhcGhpY3NDb250ZXh0M0Qg bmVlZGVkIGZvciBDaHJvbWl1bSBjb21wb3NpdG9yIHBvcnQKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1OTM5CisKKyAgICAgICAgQWRkZWQgZW50cnkg cG9pbnRzIGZvciB0d28gQ2hyb21pdW0tc3BlY2lmaWMgZXh0ZW5zaW9ucywgYW5kIGFkZGVkCisg ICAgICAgIGEgZmxhZyB0byB0aGUgR3JhcGhpY3NDb250ZXh0M0QgY29uc3RydWN0b3IsIGN1cnJl bnRseSB1bnN1cHBvcnRlZAorICAgICAgICBieSBhbGwgcG9ydHMgKGluY2x1ZGluZyBDaHJvbWl1 bSksIGluZGljYXRpbmcgd2hldGhlciB0aGUgY29udGV4dAorICAgICAgICBzaG91bGQgcmVuZGVy IGRpcmVjdGx5IHRvIHRoZSBwYXNzZWQgSG9zdFdpbmRvdyBvciBvZmYtc2NyZWVuIHBlcgorICAg ICAgICB0aGUgY3VycmVudCBzZW1hbnRpY3MuIFRoZSBzd2l0Y2ggdG8gdXNlIEdyYXBoaWNzQ29u dGV4dDNEIGluCisgICAgICAgIENocm9taXVtJ3MgY29tcG9zaXRvciB3aWxsIGZvbGxvdyBpbiBh IHN1YnNlcXVlbnQgcGF0Y2guCisKKyAgICAgICAgTm8gbmV3IHRlc3RzOyBmdW5jdGlvbmFsaXR5 IGlzIHVuY2hhbmdlZC4gQnVpbHQgYW5kIHRlc3RlZAorICAgICAgICBDaHJvbWl1bSBhbmQgV2Vi S2l0IG9uIE1hYyBPUyBYLgorCisgICAgICAgICogc3JjL0dyYXBoaWNzQ29udGV4dDNELmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjpHcmFwaGljc0NvbnRleHQzRCk6 CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKToKKyAgICAgICAg KiBzcmMvR3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbC5oOgorICAgICAgICAqIHNyYy9XZWJWaWV3 SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpnZXRTaGFyZWRHcmFwaGlj c0NvbnRleHQzRCk6CisKIDIwMTAtMDktMTYgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEphbWVzIFJvYmluc29uLgpJbmRleDogV2ViS2l0 L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRC5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRC5jcHAJKHJldmlzaW9uIDY3NjgxKQorKysg V2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRC5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTUzLDYgKzUzLDcgQEAKICNpbmNsdWRlIDxzdGRpby5oPgogI2luY2x1ZGUgPHd0Zi9GYXN0 TWFsbG9jLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5oPgorI2luY2x1ZGUgPHd0Zi9V bnVzZWRQYXJhbS5oPgogCiAjaWYgUExBVEZPUk0oQ0cpCiAjaW5jbHVkZSAiR3JhcGhpY3NDb250 ZXh0LmgiCkBAIC02MSw4ICs2Miw2IEBACiAjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHSW1hZ2Uu aD4KICNlbmRpZgogCi0vLyB1c2luZyBuYW1lc3BhY2Ugc3RkOwotCiAvLyBUaGVyZSBhcmUgdHdv IGxldmVscyBvZiBkZWxlZ2F0aW9uIGluIHRoaXMgZmlsZToKIC8vCiAvLyAgIDEuIEdyYXBoaWNz Q29udGV4dDNEIGRlbGVnYXRlcyB0byBHcmFwaGljc0NvbnRleHQzREludGVybmFsLiBUaGlzIGlz IGRvbmUKQEAgLTgwLDYgKzc5LDkgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisvLy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KKy8vIEdyYXBoaWNzQ29udGV4dDNESW50ZXJuYWwKKwogR3JhcGhpY3NDb250ZXh0 M0RJbnRlcm5hbDo6R3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbCgpCiAgICAgOiBtX3dlYlZpZXdJ bXBsKDApCiAjaWYgUExBVEZPUk0oU0tJQSkKQEAgLTI5Myw2ICsyOTUsMTIgQEAgdm9pZCBHcmFw aGljc0NvbnRleHQzREludGVybmFsOjpuYW1lKHQxIAogICAgIG1faW1wbC0+bmFtZShhMSwgYTIs IGEzLCBhNCk7ICAgICAgICAgICAgICBcCiB9CiAKKyNkZWZpbmUgREVMRUdBVEVfVE9fSU1QTF80 UihuYW1lLCB0MSwgdDIsIHQzLCB0NCwgcnQpICAgICAgIFwKK3J0IEdyYXBoaWNzQ29udGV4dDNE SW50ZXJuYWw6Om5hbWUodDEgYTEsIHQyIGEyLCB0MyBhMywgdDQgYTQpICAgICAgICBcCit7IFwK KyAgICByZXR1cm4gbV9pbXBsLT5uYW1lKGExLCBhMiwgYTMsIGE0KTsgICAgICAgICAgIFwKK30K KwogI2RlZmluZSBERUxFR0FURV9UT19JTVBMXzUobmFtZSwgdDEsIHQyLCB0MywgdDQsIHQ1KSAg ICAgIFwKIHZvaWQgR3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbDo6bmFtZSh0MSBhMSwgdDIgYTIs IHQzIGEzLCB0NCBhNCwgdDUgYTUpICAgICAgICBcCiB7IFwKQEAgLTY2Myw2ICs2NzEsMTMgQEAg REVMRUdBVEVfVE9fSU1QTF8xKGRlbGV0ZVRleHR1cmUsIHVuc2lnbgogCiBERUxFR0FURV9UT19J TVBMXzEoc3ludGhlc2l6ZUdMRXJyb3IsIHVuc2lnbmVkIGxvbmcpCiBERUxFR0FURV9UT19JTVBM X1Ioc3VwcG9ydHNCR1JBLCBib29sKQorREVMRUdBVEVfVE9fSU1QTF9SKHN1cHBvcnRzTWFwU3Vi Q0hST01JVU0sIGJvb2wpCitERUxFR0FURV9UT19JTVBMXzRSKG1hcEJ1ZmZlclN1YkRhdGFDSFJP TUlVTSwgdW5zaWduZWQsIGludCwgaW50LCB1bnNpZ25lZCwgdm9pZCopCitERUxFR0FURV9UT19J TVBMXzEodW5tYXBCdWZmZXJTdWJEYXRhQ0hST01JVU0sIGNvbnN0IHZvaWQqKQorREVMRUdBVEVf VE9fSU1QTF85UihtYXBUZXhTdWJJbWFnZTJEQ0hST01JVU0sIHVuc2lnbmVkLCBpbnQsIGludCwg aW50LCBpbnQsIGludCwgdW5zaWduZWQsIHVuc2lnbmVkLCB1bnNpZ25lZCwgdm9pZCopCitERUxF R0FURV9UT19JTVBMXzEodW5tYXBUZXhTdWJJbWFnZTJEQ0hST01JVU0sIGNvbnN0IHZvaWQqKQor REVMRUdBVEVfVE9fSU1QTF9SKHN1cHBvcnRzQ29weVRleHR1cmVUb1BhcmVudFRleHR1cmVDSFJP TUlVTSwgYm9vbCkKK0RFTEVHQVRFX1RPX0lNUExfMihjb3B5VGV4dHVyZVRvUGFyZW50VGV4dHVy ZUNIUk9NSVVNLCB1bnNpZ25lZCwgdW5zaWduZWQpCiAKIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogLy8gR3Jh cGhpY3NDb250ZXh0M0QKQEAgLTcyNSw2ICs3NDAsMTIgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQz RDo6bmFtZSh0MSBhMSwgdDIgYQogICAgIG1faW50ZXJuYWwtPm5hbWUoYTEsIGEyLCBhMywgYTQp OyAgICAgICAgICAgICAgXAogfQogCisjZGVmaW5lIERFTEVHQVRFX1RPX0lOVEVSTkFMXzRSKG5h bWUsIHQxLCB0MiwgdDMsIHQ0LCBydCkgICAgXAorcnQgR3JhcGhpY3NDb250ZXh0M0Q6Om5hbWUo dDEgYTEsIHQyIGEyLCB0MyBhMywgdDQgYTQpICBcCit7IFwKKyAgICByZXR1cm4gbV9pbnRlcm5h bC0+bmFtZShhMSwgYTIsIGEzLCBhNCk7ICAgICAgICAgICBcCit9CisKICNkZWZpbmUgREVMRUdB VEVfVE9fSU5URVJOQUxfNShuYW1lLCB0MSwgdDIsIHQzLCB0NCwgdDUpICAgICAgXAogdm9pZCBH cmFwaGljc0NvbnRleHQzRDo6bmFtZSh0MSBhMSwgdDIgYTIsIHQzIGEzLCB0NCBhNCwgdDUgYTUp ICAgICAgICBcCiB7IFwKQEAgLTc2Nyw3ICs3ODgsNyBAQCBydCBHcmFwaGljc0NvbnRleHQzRDo6 bmFtZSh0MSBhMSwgdDIgYTIsCiAgICAgcmV0dXJuIG1faW50ZXJuYWwtPm5hbWUoYTEsIGEyLCBh MywgYTQsIGE1LCBhNiwgYTcsIGE4LCBhOSk7ICAgXAogfQogCi1HcmFwaGljc0NvbnRleHQzRDo6 R3JhcGhpY3NDb250ZXh0M0QoR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMsIEhvc3RXaW5k b3cqKQorR3JhcGhpY3NDb250ZXh0M0Q6OkdyYXBoaWNzQ29udGV4dDNEKEdyYXBoaWNzQ29udGV4 dDNEOjpBdHRyaWJ1dGVzLCBIb3N0V2luZG93KiwgYm9vbCkKIHsKIH0KIApAQCAtNzc1LDE1ICs3 OTYsMTcgQEAgR3JhcGhpY3NDb250ZXh0M0Q6On5HcmFwaGljc0NvbnRleHQzRCgpCiB7CiB9CiAK LVBhc3NPd25QdHI8R3JhcGhpY3NDb250ZXh0M0Q+IEdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUo R3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMgYXR0cnMsIEhvc3RXaW5kb3cqIGhvc3RXaW5k b3cpCitQYXNzT3duUHRyPEdyYXBoaWNzQ29udGV4dDNEPiBHcmFwaGljc0NvbnRleHQzRDo6Y3Jl YXRlKEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93KiBob3N0 V2luZG93LCBib29sIHJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93KQogewotICAgIEdyYXBoaWNz Q29udGV4dDNESW50ZXJuYWwqIGludGVybmFsID0gbmV3IEdyYXBoaWNzQ29udGV4dDNESW50ZXJu YWwoKTsKKyAgICAvLyBGSVhNRTogbXVzdCBwYXNzIGRvd24gcmVuZGVyRGlyZWN0bHlUb0hvc3RX aW5kb3cgYXJndW1lbnQgd2hlbiBzd2l0Y2hpbmcgY29tcG9zaXRvciB0byBHcmFwaGljc0NvbnRl eHQzRC4KKyAgICBpZiAocmVuZGVyRGlyZWN0bHlUb0hvc3RXaW5kb3cpCisgICAgICAgIHJldHVy biAwOworICAgIE93blB0cjxHcmFwaGljc0NvbnRleHQzREludGVybmFsPiBpbnRlcm5hbCA9IGFk b3B0UHRyKG5ldyBHcmFwaGljc0NvbnRleHQzREludGVybmFsKCkpOwogICAgIGlmICghaW50ZXJu YWwtPmluaXRpYWxpemUoYXR0cnMsIGhvc3RXaW5kb3cpKSB7Ci0gICAgICAgIGRlbGV0ZSBpbnRl cm5hbDsKICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQotICAgIFBhc3NPd25QdHI8R3JhcGhpY3ND b250ZXh0M0Q+IHJlc3VsdCA9IG5ldyBHcmFwaGljc0NvbnRleHQzRChhdHRycywgaG9zdFdpbmRv dyk7Ci0gICAgcmVzdWx0LT5tX2ludGVybmFsLnNldChpbnRlcm5hbCk7CisgICAgUGFzc093blB0 cjxHcmFwaGljc0NvbnRleHQzRD4gcmVzdWx0ID0gbmV3IEdyYXBoaWNzQ29udGV4dDNEKGF0dHJz LCBob3N0V2luZG93LCByZW5kZXJEaXJlY3RseVRvSG9zdFdpbmRvdyk7CisgICAgcmVzdWx0LT5t X2ludGVybmFsID0gaW50ZXJuYWwucmVsZWFzZSgpOwogICAgIHJldHVybiByZXN1bHQ7CiB9CiAK QEAgLTk5OSw2ICsxMDIyLDEzIEBAIERFTEVHQVRFX1RPX0lOVEVSTkFMXzEoZGVsZXRlVGV4dHVy ZSwgdW4KIAogREVMRUdBVEVfVE9fSU5URVJOQUxfMShzeW50aGVzaXplR0xFcnJvciwgdW5zaWdu ZWQgbG9uZykKIERFTEVHQVRFX1RPX0lOVEVSTkFMX1Ioc3VwcG9ydHNCR1JBLCBib29sKQorREVM RUdBVEVfVE9fSU5URVJOQUxfUihzdXBwb3J0c01hcFN1YkNIUk9NSVVNLCBib29sKQorREVMRUdB VEVfVE9fSU5URVJOQUxfNFIobWFwQnVmZmVyU3ViRGF0YUNIUk9NSVVNLCB1bnNpZ25lZCwgaW50 LCBpbnQsIHVuc2lnbmVkLCB2b2lkKikKK0RFTEVHQVRFX1RPX0lOVEVSTkFMXzEodW5tYXBCdWZm ZXJTdWJEYXRhQ0hST01JVU0sIGNvbnN0IHZvaWQqKQorREVMRUdBVEVfVE9fSU5URVJOQUxfOVIo bWFwVGV4U3ViSW1hZ2UyRENIUk9NSVVNLCB1bnNpZ25lZCwgaW50LCBpbnQsIGludCwgaW50LCBp bnQsIHVuc2lnbmVkLCB1bnNpZ25lZCwgdW5zaWduZWQsIHZvaWQqKQorREVMRUdBVEVfVE9fSU5U RVJOQUxfMSh1bm1hcFRleFN1YkltYWdlMkRDSFJPTUlVTSwgY29uc3Qgdm9pZCopCitERUxFR0FU RV9UT19JTlRFUk5BTF9SKHN1cHBvcnRzQ29weVRleHR1cmVUb1BhcmVudFRleHR1cmVDSFJPTUlV TSwgYm9vbCkKK0RFTEVHQVRFX1RPX0lOVEVSTkFMXzIoY29weVRleHR1cmVUb1BhcmVudFRleHR1 cmVDSFJPTUlVTSwgdW5zaWduZWQsIHVuc2lnbmVkKQogCiBib29sIEdyYXBoaWNzQ29udGV4dDNE Ojppc0dMRVMyQ29tcGxpYW50KCkgY29uc3QKIHsKSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9zcmMv R3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9jaHJvbWl1 bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbC5oCShyZXZpc2lvbiA2NzY4MSkKKysrIFdl YktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RJbnRlcm5hbC5oCSh3b3JraW5nIGNv cHkpCkBAIC0yNTcsOCArMjU3LDIwIEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc3dhcEJ1ZmZlcnMo KTsKIAorICAgIC8vIEVYVF90ZXh0dXJlX2Zvcm1hdF9CR1JBODg4OAogICAgIGJvb2wgc3VwcG9y dHNCR1JBKCk7CiAKKyAgICAvLyBHTF9DSFJPTUlVTV9tYXBfc3ViCisgICAgYm9vbCBzdXBwb3J0 c01hcFN1YkNIUk9NSVVNKCk7CisgICAgdm9pZCogbWFwQnVmZmVyU3ViRGF0YUNIUk9NSVVNKHVu c2lnbmVkIHRhcmdldCwgaW50IG9mZnNldCwgaW50IHNpemUsIHVuc2lnbmVkIGFjY2Vzcyk7Cisg ICAgdm9pZCB1bm1hcEJ1ZmZlclN1YkRhdGFDSFJPTUlVTShjb25zdCB2b2lkKik7CisgICAgdm9p ZCogbWFwVGV4U3ViSW1hZ2UyRENIUk9NSVVNKHVuc2lnbmVkIHRhcmdldCwgaW50IGxldmVsLCBp bnQgeG9mZnNldCwgaW50IHlvZmZzZXQsIGludCB3aWR0aCwgaW50IGhlaWdodCwgdW5zaWduZWQg Zm9ybWF0LCB1bnNpZ25lZCB0eXBlLCB1bnNpZ25lZCBhY2Nlc3MpOworICAgIHZvaWQgdW5tYXBU ZXhTdWJJbWFnZTJEQ0hST01JVU0oY29uc3Qgdm9pZCopOworCisgICAgLy8gR0xfQ0hST01JVU1f Y29weV90ZXh0dXJlX3RvX3BhcmVudF90ZXh0dXJlCisgICAgYm9vbCBzdXBwb3J0c0NvcHlUZXh0 dXJlVG9QYXJlbnRUZXh0dXJlQ0hST01JVU0oKTsKKyAgICB2b2lkIGNvcHlUZXh0dXJlVG9QYXJl bnRUZXh0dXJlQ0hST01JVU0odW5zaWduZWQgdGV4dHVyZSwgdW5zaWduZWQgcGFyZW50VGV4dHVy ZSk7CisKIHByaXZhdGU6CiAgICAgT3duUHRyPFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q+ IG1faW1wbDsKICAgICBXZWJLaXQ6OldlYlZpZXdJbXBsKiBtX3dlYlZpZXdJbXBsOwpJbmRleDog V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAJKHJldmlzaW9uIDY3NjgxKQorKysgV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI0MjgsNyAr MjQyOCw3IEBAIFNoYXJlZEdyYXBoaWNzQ29udGV4dDNEKiBXZWJWaWV3SW1wbDo6Z2UKIHsKICAg ICBpZiAoIW1fc2hhcmVkQ29udGV4dDNEKSB7CiAgICAgICAgIEdyYXBoaWNzQ29udGV4dDNEOjpB dHRyaWJ1dGVzIGF0dHI7Ci0gICAgICAgIE93blB0cjxHcmFwaGljc0NvbnRleHQzRD4gY29udGV4 dCA9IEdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUoYXR0ciwgbV9wYWdlLT5jaHJvbWUoKSk7Cisg ICAgICAgIE93blB0cjxHcmFwaGljc0NvbnRleHQzRD4gY29udGV4dCA9IEdyYXBoaWNzQ29udGV4 dDNEOjpjcmVhdGUoYXR0ciwgbV9wYWdlLT5jaHJvbWUoKSwgZmFsc2UpOwogICAgICAgICBpZiAo IWNvbnRleHQpCiAgICAgICAgICAgICByZXR1cm4gMDsKICAgICAgICAgbV9zaGFyZWRDb250ZXh0 M0QgPSBTaGFyZWRHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKGNvbnRleHQucmVsZWFzZSgpKTsK