69441 2011-10-05 10:37:19 -0700 [chromium] Keep track of the paint rect in layers 2011-10-18 12:09:29 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 67341 69443 1 shawnsingh shawnsingh enne jamesr nduca vangelis webkit.review.bot oldest_to_newest 478483 0 shawnsingh 2011-10-05 10:37:19 -0700 This is part 1 of adding compositor support for --show-paint-rects. Note that the "dirty rect" (area marked as needing repaint) is not necessarily the same as the "paint rect" (area that is actually repainted), even though they will often be the same. In addition to visualizing paint rects, keeping track of this will be useful for computing a good scissor rect as well. 479309 1 109982 shawnsingh 2011-10-06 11:19:55 -0700 Created attachment 109982 Patch 479310 2 shawnsingh 2011-10-06 11:22:38 -0700 Reviewers please look closely at changes in TiledLayerChromium... the "contentRectToLayerRect" conversion may do clipping as a side effect. Is this still correct, or is it more correct to manually translate the rect without clipping? 479313 3 109982 jamesr 2011-10-06 11:24:50 -0700 Comment on attachment 109982 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=109982&action=review I think that this should be the return value of whatever function is calculating it and not state on the layer. > Source/WebCore/platform/graphics/chromium/LayerChromium.h:218 > + FloatRect m_actuallyRepaintedRect; This isn't really state on the layer, is it? Isn't it an output from updateCompositorResources()? Also I'm a bit confused about the name - if this is about repainting, why isn't it calculated by paintContentsIfDirty()? It sounds more like this is talking about the portion of the layer that was changed due to texture uploads and the like, which isn't necessarily the same thing as the portion that was painted. 479361 4 shawnsingh 2011-10-06 12:00:18 -0700 (In reply to comment #3) > (From update of attachment 109982 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=109982&action=review > > I think that this should be the return value of whatever function is calculating it and not state on the layer. I disagree... it really is part of the state of the layer. This rect is going to be pushed to the CCLayerImpl, and would eventually affect scissor and draw rects. Even if we use a return value, we have to store this value so it can be propagated in pushPropertiesTo. The CCLayerTreeHost, which calls paintContentsIfDirty and updateCompositorResources, is not the right place to receive those values. > > > Source/WebCore/platform/graphics/chromium/LayerChromium.h:218 > > + FloatRect m_actuallyRepaintedRect; > > This isn't really state on the layer, is it? Isn't it an output from updateCompositorResources()? > > Also I'm a bit confused about the name - if this is about repainting, why isn't it calculated by paintContentsIfDirty()? It sounds more like this is talking about the portion of the layer that was changed due to texture uploads and the like, which isn't necessarily the same thing as the portion that was painted. It will be more efficient to discuss this in person first =) 479449 5 110013 shawnsingh 2011-10-06 13:55:32 -0700 Created attachment 110013 renamed repaint to update 479454 6 shawnsingh 2011-10-06 13:58:38 -0700 Please note my original question about contentRectToLayerRect. Discussed offline with jamesr. As I understand, we agreed that the rest of the patch is good the way it is; cleaning up the way we manage "transient state" will need to be done in a separate change. Please let me know if that's not what we agreed. 479482 7 110013 jamesr 2011-10-06 14:25:12 -0700 Comment on attachment 110013 renamed repaint to update View in context: https://bugs.webkit.org/attachment.cgi?id=110013&action=review Getting close! You probably want to read the feedback bottom up as the interesting comments are near the bottom of the patch. > Source/WebCore/ChangeLog:4 > + Added a FloatRect to LayerChromium that tracks what region was actually > + updated in a layer. bug titles should ideally describe what the patch is doing or what problem it's solving, not how. also, it's very helpful to tag chromium-specific patches with [chromium] so that people looking through the commit log for regressions on other platforms (for example) can know that this patch only impacts chromium. so maybe something like "[chromium] Track the updated portion of the layer in updateCompositingResources()" > Source/WebCore/ChangeLog:10 > + Tests will be added in a separate patch after the > + GraphicsContext3D and allocator can be mocked. FYI we can mock out GraphicsContext3D today I believe - take a look at MockGraphicsContext3D and CompositorMockGraphicsContext3D in WebKit/chromium/tests/. TextureAllocator is pretty thin and designed to be mocked easily if you're so inclined. I'm not sure if there's all that much to test here though since the value's not being used for anything. > Source/WebCore/platform/graphics/chromium/Canvas2DLayerChromium.cpp:84 > + m_actuallyUpdatedRect = FloatRect(0.0f, 0.0f, bounds().width(), bounds().height()); Could be FloatRect(FloatPoint::zero(), bounds()); > Source/WebCore/platform/graphics/chromium/LayerChromium.h:218 > + FloatRect m_actuallyUpdatedRect; sorry to rathole on the name but this still feels awkward. why isn't this m_updatedRect? is there another variable that we are trying to distinguish this from with the 'actually' qualifier? > Source/WebCore/platform/graphics/chromium/PluginLayerChromium.cpp:71 > + m_actuallyUpdatedRect = FloatRect(0.0f, 0.0f, bounds().width(), bounds().height()); could be written as: FloatRect(FloatPoint::zero(), bounds()); > Source/WebCore/platform/graphics/chromium/VideoLayerChromium.cpp:140 > + m_actuallyUpdatedRect = FloatRect(0.0f, 0.0f, bounds().width(), bounds().height()); same here - this could be written as FloatRect(FloatPoint::zero(), bounds()); > Source/WebCore/platform/graphics/chromium/WebGLLayerChromium.cpp:95 > + m_actuallyUpdatedRect = FloatRect(0.0f, 0.0f, bounds().width(), bounds().height()); ditto re: FloatRect(). since this is repeated 4x should it be in the base class to be the default behavior so that subclasses can override it with more specific bounds if they have it? if we add a new layer type we'll have to remember to add this incantation. maybe one way to do this would be to have a virtual updatedRect() getter on LayerChromium that returns this and override that in TiledLayerChromium with a function that calculates the value it uses. 479733 8 110013 vangelis 2011-10-06 19:24:24 -0700 Comment on attachment 110013 renamed repaint to update View in context: https://bugs.webkit.org/attachment.cgi?id=110013&action=review You'll need some code to clear out the update rects every update cycle, otherwise they'll stick around. You'll probably need to do this in CCLayerTreeHost::updateCompositorResources() before calling updateCompositorResources(layer, context, allocator) > Source/WebCore/platform/graphics/chromium/PluginLayerChromium.cpp:70 > + // Plugin layers do their own repainting, so we assume it updates the entire layer on every update. I'm not sure I agree with this one. Unlike other layers, for plugins we have no way of knowing whether any updates too place, at least not here. I would not mark it as updated. > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:209 > + totalUpdatedContent.unite(sourceRect); I don't think you need to aggregate the individual tiles. m_updateRect is the rect you need. 479756 9 shawnsingh 2011-10-06 20:07:26 -0700 Actually I think the new patch (coming in a few moments) might have indirectly addressed some of your comments, since those points in code are no longer needed. However there are 2 things to point out: - We will need to keep the update rect until we have the opportunity to push it to the CCLayerImpl during commit - The new patch also proposes to re-name "m_updateRect" in the TiledLayerChromium, because it is currently a misnomer. That rect is really just a temporary content rect needed for re-computing tile indices, valid only between prepareToUpdate and updateCompositorResources. What we really want is the m_paintRect, which happens to be the same as the update rect for TiledLayerChromium. (In reply to comment #8) > (From update of attachment 110013 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=110013&action=review > > You'll need some code to clear out the update rects every update cycle, otherwise they'll stick around. You'll probably need to do this in CCLayerTreeHost::updateCompositorResources() before calling updateCompositorResources(layer, context, allocator) > > > Source/WebCore/platform/graphics/chromium/PluginLayerChromium.cpp:70 > > + // Plugin layers do their own repainting, so we assume it updates the entire layer on every update. > > I'm not sure I agree with this one. Unlike other layers, for plugins we have no way of knowing whether any updates too place, at least not here. I would not mark it as updated. > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:209 > > + totalUpdatedContent.unite(sourceRect); > > I don't think you need to aggregate the individual tiles. m_updateRect is the rect you need. 479761 10 110084 shawnsingh 2011-10-06 20:20:40 -0700 Created attachment 110084 Patch 480154 11 110084 vangelis 2011-10-07 11:21:15 -0700 Comment on attachment 110084 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=110084&action=review A high level comment: Overall for our purposes, we really want to track what areas of the layer get repainted as painting is an expensive operation. It so happens that for TiledLayerChromium's, the repaint rects are (almost?) identical to the upload rects (what we use to upload the texture contents, which is what you're tracking now). So, for tiled layers m_paintRect is actually the most correct region to keep track of as that's what's getting sent to the texture updater that triggers a webkit repaint. Image layers don't cost much in terms of repainting but it would be good to keep track of when we upload new textures for them which can be done in ImageLayerChromium::updateTextureRect() . Similarly with Canvas2DLayerChromium and WebGLLayerChromium, we can catch the rects they upload on their updateCompositorResources() call. PluginLayerChromium is the one I'm a bit uncertain of as I'm not sure how we'll know whether it gets a new texture or not. To avoid having to make a distinction between paintedRect and updatedRect we can call this new rect something like modifiedRect to actually capture the intersection of the two that's useful for us. > Source/WebCore/platform/graphics/chromium/LayerChromium.h:113 > + virtual const FloatRect updateRect() const { return FloatRect(FloatPoint::zero(), bounds()); } Canvas2D, WebGL and Image layers don't always update their contents. Their updateRect should be set based on whether they actually did change. > Source/WebCore/platform/graphics/chromium/LayerChromium.h:165 > + virtual void updateCompositorResources(GraphicsContext3D*, TextureAllocator*) { ASSERT_NOT_REACHED(); } I suspect this assert will now trigger at least for PluginLayerChromium's > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:92 > + m_contentToPaint = IntRect(); Not a huge fan of this new name. It's been conventional to use the Rect suffix for variables that hold rects. Also, how do we now get the updateRect for tiled layers? > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.h:90 > + // The original rect that indicates what should be painted Not sure I fully understand what you mean by the "original" 480294 12 shawnsingh 2011-10-07 13:53:09 -0700 Thanks for the comments. Here is my summary response: - So clearly the virtual function approach does not work - oops. I'll revert the approach to the previous patch. - I'm not clear on what you meant by the "intersection" of paint rect and update rect. Can you please clarify? If you are OK with it, I would prefer to stick with "paint rect" and "update rect" only, adding a "modified rect" may be further confusing. - I think at this point, the right thing to do is simply track both paint rect and update rect. Its quite straightforward, and I'm working on it right now. - Can you please suggest a better name for the rect "m_contentToPaint"? how about "m_contentRect"? The only purpose of this rect is simply to store the content rect temporarily so that we can iterate over tile indices properly. 480312 13 jamesr 2011-10-07 14:22:41 -0700 (In reply to comment #11) > (From update of attachment 110084 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=110084&action=review > > A high level comment: Overall for our purposes, we really want to track what areas of the layer get repainted as painting is an expensive operation. It so happens that for TiledLayerChromium's, the repaint rects are (almost?) identical to the upload rects (what we use to upload the texture contents, which is what you're tracking now). So, for tiled layers m_paintRect is actually the most correct region to keep track of as that's what's getting sent to the texture updater that triggers a webkit repaint. > > Image layers don't cost much in terms of repainting but it would be good to keep track of when we upload new textures for them which can be done in ImageLayerChromium::updateTextureRect() . Similarly with Canvas2DLayerChromium and WebGLLayerChromium, we can catch the rects they upload on their updateCompositorResources() call. PluginLayerChromium is the one I'm a bit uncertain of as I'm not sure how we'll know whether it gets a new texture or not. > So now I don't know what we are trying to track here. What's this for? If it's for the scissoring optimization then we need to know what parts of the layer may be different from previous frames, since they have to be drawn. If we're trying to track paint time for some sort of development tool then that sounds like something different. Can you describe the use case that you think this data will be used for? I'd much rather start with use cases and then figure out what data we need vs adding some data without a clear use for it. 480320 14 shawnsingh 2011-10-07 14:41:24 -0700 I think both your use cases are intended. Here's a summary of the two goals: 1. analysis of various performance overheads. It is useful to visualize dirty rects, paint rects, update rects, draw rects, and the scissor rect. Each one (and the combination of them) helps narrow down the cause of performance issues. I personally have already found these rects useful to find bugs (for example, https://bugs.webkit.org/show_bug.cgi?id=67009) and performance overheads. As we try to improve performance, these rects will be useful, both human visualization and automated (like computing overdraw) for debugging and testing our performance improvements. 2. computing a scissor rect. (others are waiting on this optimization, so this is priority) The scissor rect depends on draw rects. the draw rects can be optimized by knowing the update rects (and dirty rects, since the flow of information will not be perfect) In order to move forward with these use cases, we want to track the update rect. Vangelis wants to make available visualizing paint rects, because this information will immediately help other groups. So, I think the solution is to track both, and this one small patch can easily do that =) Also just discussed offline with Vangelis and agreed on tracking and visualizing both. James, does all this sound good to you? 480364 15 jamesr 2011-10-07 16:13:39 -0700 What exactly does "tracking" mean for 1? Is something other than the compositor the consumer of that data? Who will be doing the tracking (us, web developers, someone else?) There are lots of interesting things to track depending on who is consuming the data and what they are tracking. Should we hook that up to the tracing system perhaps? For scissoring the thing we need to know is what portion of each layer has changed in the updateCompositorResources() call. For contents textures this is easy - we directly control what textures get uploaded. The situation is more complicated for plugin layers since the model there is that the texture ID is owned by the plugin. The plugin notifies the compositor when the texture is updated, but it's possible that we haven't yet received that notification when we go to draw from the texture. Maybe we need to add a copy here? I think we'll get into the same place here for video layers soon as well when using a h/w stack. 480405 16 shawnsingh 2011-10-07 17:12:21 -0700 (In reply to comment #15) > What exactly does "tracking" mean for 1? Is something other than the compositor the consumer of that data? Who will be doing the tracking (us, web developers, someone else?) There are lots of interesting things to track depending on who is consuming the data and what they are tracking. Should we hook that up to the tracing system perhaps? > by "tracking" actually I just meant simply that we have to add that state in the classes. Examples of "consumers" of this information: the compositor (including our HUD and scissor rect), the Inspector for web devs to analyze their page performance, and unit tests. > For scissoring the thing we need to know is what portion of each layer has changed in the updateCompositorResources() call. For contents textures this is easy - we directly control what textures get uploaded. The situation is more complicated for plugin layers since the model there is that the texture ID is owned by the plugin. The plugin notifies the compositor when the texture is updated, but it's possible that we haven't yet received that notification when we go to draw from the texture. Maybe we need to add a copy here? I think we'll get into the same place here for video layers soon as well when using a h/w stack. My thoughts on this: Overall I think what you're talking about are secondary optimizations. Any scissoring is better than no scissoring. The most critical one is the root layer (i.e. tiled layer). In my old version of the scissor, it was good enough to use the dirty rect, because webkit safely marked video/webgl/plugin/canvas as the entire layer being dirty. However, piping the dirty rect the way that I originally did was not a good idea. The cleanest yet realistic approach is to compute scissor based on update rect, and when that information is not available, assume that the entire layer needs redraw (which is what webkit's dirty rects were doing anyway). Of course those rects may still be culled by visibility/overdraw/etc. on the impl side. Optimizing canvas (and maybe plugin) could be a useful secondary gain. And optimizing webGL and video, should be low priority for now, because most likely when they exist, the entire layer changes most of the time anyway. I'm not sure what copy you're referring to... but I'm quite certain that no texture copies will be necessary, right? New patch should be coming soon... =) 480440 17 jamesr 2011-10-07 19:10:32 -0700 If we always assume the entire plugin layer has changed for the purpose of calculating the scissor, then no I don't think we'll need to add a copy. 480487 18 110258 shawnsingh 2011-10-07 22:39:30 -0700 Created attachment 110258 Patch 480488 19 shawnsingh 2011-10-07 22:39:43 -0700 Notes about this most recent patch: (1) After discussing with Vangelis offline, we realized that the sourceRect aggregation in TiledLayerChromium.cpp should probably stay there, because it may result in a updateRect that is different from paintRect. However, i'm not clear on what case this is true? (2) m_paintRect is actually updated by existing code, which is why it doesn't appear in the patch. m_paintRect currently is only applicable to TiledLayerChromium, and is updated in prepareToUpdate() (which occurs during paintContentsIfDirty()). (3) There is one last design choice I would like to discuss. Instead of putting m_paintRect directly in the base class, maybe it is appropriate where it originally was, in the TiledLayerChromium... because that is currently the only layer type that uses the concept of a paint rect. If we do that, then the paint rect changes would disappear in this patch, but in the part 2 (visualization) patch, we will have to add a specialized pushPropertiesTo for the TiledLayerChromium to give the paint rect to the draw side of things. I can see arguments on both design choices. I'm leaning towards the latter (removing paint rect from this patch). What do you all think? 481227 20 shawnsingh 2011-10-10 15:26:32 -0700 Can reviewers please answer point #3 in the previous comment? If the answer is "no, keep it the way it is", then can you please review this? Otherwise I will submit a new patch ASAP... 481229 21 jamesr 2011-10-10 15:29:17 -0700 For the way we're using the term "paint" meaning "call into WebCore via a paintContents() callback", it only makes sense on TiledLayerChromium so I think that it makes sense to move the m_paintRect down to that class. 481289 22 110435 shawnsingh 2011-10-10 16:44:20 -0700 Created attachment 110435 Patch 481310 23 110435 enne 2011-10-10 17:09:17 -0700 Comment on attachment 110435 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=110435&action=review > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:215 > + // FIXME: Prove/disprove whether totalUpdatedContent will always be the same as m_paint. For now, assuming its not. > + m_updateRect = FloatRect(m_tiler->contentRectToLayerRect(totalUpdatedContent)); This seems like something you should figure out before you land this patch. It's my assumption that the paint rect will be identical to the update rect. We can't update something we haven't painted, and we consider all tiles that we've painted when doing updates. 481321 24 shawnsingh 2011-10-10 17:12:47 -0700 (In reply to comment #23) > (From update of attachment 110435 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=110435&action=review > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:215 > > + // FIXME: Prove/disprove whether totalUpdatedContent will always be the same as m_paint. For now, assuming its not. > > + m_updateRect = FloatRect(m_tiler->contentRectToLayerRect(totalUpdatedContent)); > > This seems like something you should figure out before you land this patch. It's my assumption that the paint rect will be identical to the update rect. We can't update something we haven't painted, and we consider all tiles that we've painted when doing updates. Yeah, I agree. Vangelis, since we had discussed this earlier, what do you think? After our discussion I had second thoughts and could not think of the case where they are different. I think they are the same. If they are the same, then I'll remove that aggregation put m_update = FloatRect(m_paint); 481357 25 vangelis 2011-10-10 17:51:40 -0700 (In reply to comment #24) > (In reply to comment #23) > > (From update of attachment 110435 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=110435&action=review > > > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:215 > > > + // FIXME: Prove/disprove whether totalUpdatedContent will always be the same as m_paint. For now, assuming its not. > > > + m_updateRect = FloatRect(m_tiler->contentRectToLayerRect(totalUpdatedContent)); > > > > This seems like something you should figure out before you land this patch. It's my assumption that the paint rect will be identical to the update rect. We can't update something we haven't painted, and we consider all tiles that we've painted when doing updates. > > > Yeah, I agree. Vangelis, since we had discussed this earlier, what do you think? After our discussion I had second thoughts and could not think of the case where they are different. I think they are the same. > > If they are the same, then I'll remove that aggregation put m_update = FloatRect(m_paint); I agree that the updateRect computed as a union of update rects is the same as the paint rect but it's not an accurate measure of how many pixels we've uploaded as textures, if that's what we're after. It's really the bounding box around the updated area. For example, consider this layer: X X X X O X X X X where X are dirty tiles and O is a clean tile. Uploads will only happen for the dirty tiles so there will be a total of 8 tile-sized texture uploads whereas the updateRect, being a union of all the X's will contain the surface of 9 tiles. That said, if we regard the update rect as the region of the layer that changed within the last frame, then I think it makes sense to track it separately from the paint rect (which tracks the area that we asked webkit to redraw). In that case, for tiled layers, paintRect == updateRect but for WebGL, canvas, video paintRect = 0 and updateRect is equal to the entire layer when something changes in it (a new video frame, webgl / canvas marked dirty). 481362 26 jamesr 2011-10-10 18:00:23 -0700 (In reply to comment #25) > (In reply to comment #24) > I agree that the updateRect computed as a union of update rects is the same as the paint rect but it's not an accurate measure of how many pixels we've uploaded as textures, if that's what we're after. It's really the bounding box around the updated area. For example, consider this layer: > > X X X > X O X > X X X > > where X are dirty tiles and O is a clean tile. Uploads will only happen for the dirty tiles so there will be a total of 8 tile-sized texture uploads whereas the updateRect, being a union of all the X's will contain the surface of 9 tiles. > Actually I'm pretty sure we paint and upload all 9 in this case because we union damage when it's received and we union 'damage' from evicted tiles. 481368 27 110435 vangelis 2011-10-10 18:12:14 -0700 Comment on attachment 110435 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=110435&action=review > Source/WebCore/ChangeLog:3 > + [chromium] Tracking paint rects and update rects in LayerChromium. I'm not seeing where the paint rects are being tracked. > Source/WebCore/platform/graphics/chromium/LayerChromium.cpp:306 > + m_updateRect = FloatRect(); Don't you want to push the update rect over to the impl side before you clear it? > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.h:88 > + IntRect m_contentRect; I think a better name for this would be m_visibleContentRect. m_contentRect as used elsewhere in the code usually stores the entire content area of the layer. We could also change the parameter name in TiledLayerChromium::prepareToUpdate() to match it. > Source/WebCore/platform/graphics/chromium/VideoLayerChromium.cpp:139 > + m_updateRect = FloatRect(FloatPoint::zero(), bounds()); I think it makes sense for the update rect to capture the area that was changed between frames so in the case of the video layer it would be the entire frame, if it was marked dirty. 481371 28 vangelis 2011-10-10 18:14:29 -0700 (In reply to comment #26) > (In reply to comment #25) > > (In reply to comment #24) > > > I agree that the updateRect computed as a union of update rects is the same as the paint rect but it's not an accurate measure of how many pixels we've uploaded as textures, if that's what we're after. It's really the bounding box around the updated area. For example, consider this layer: > > > > X X X > > X O X > > X X X > > > > where X are dirty tiles and O is a clean tile. Uploads will only happen for the dirty tiles so there will be a total of 8 tile-sized texture uploads whereas the updateRect, being a union of all the X's will contain the surface of 9 tiles. > > > > Actually I'm pretty sure we paint and upload all 9 in this case because we union damage when it's received and we union 'damage' from evicted tiles. Ah yes, you're right! 481375 29 shawnsingh 2011-10-10 18:24:50 -0700 Alright then, I'll upload the (hopefully) final patch tonight, where m_updateRect = m_paintRect. (In reply to comment #27) > (From update of attachment 110435 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=110435&action=review > > > Source/WebCore/ChangeLog:3 > > + [chromium] Tracking paint rects and update rects in LayerChromium. > > I'm not seeing where the paint rects are being tracked. > Vestigal cruft, I'll remove it. > > Source/WebCore/platform/graphics/chromium/LayerChromium.cpp:306 > > + m_updateRect = FloatRect(); > > Don't you want to push the update rect over to the impl side before you clear it? > I was going to wait until part 2 for that. I had originally intended this first patch to be very brief and quick... But yes, it will be pushed once we add the same property to CCLayerImpl. > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.h:88 > > + IntRect m_contentRect; > > I think a better name for this would be m_visibleContentRect. m_contentRect as used elsewhere in the code usually stores the entire content area of the layer. We could also change the parameter name in TiledLayerChromium::prepareToUpdate() to match it. > OK will change > > Source/WebCore/platform/graphics/chromium/VideoLayerChromium.cpp:139 > > + m_updateRect = FloatRect(FloatPoint::zero(), bounds()); > > I think it makes sense for the update rect to capture the area that was changed between frames so in the case of the video layer it would be the entire frame, if it was marked dirty. This code is already a rect that represents the entire layer, right? point (0,0) and bounds (width,height) Same should be true for WebGL and canvas2D... Did I overlook something? 481378 30 110435 vangelis 2011-10-10 18:27:30 -0700 Comment on attachment 110435 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=110435&action=review >>> Source/WebCore/platform/graphics/chromium/VideoLayerChromium.cpp:139 >>> + m_updateRect = FloatRect(FloatPoint::zero(), bounds()); >> >> I think it makes sense for the update rect to capture the area that was changed between frames so in the case of the video layer it would be the entire frame, if it was marked dirty. > > This code is already a rect that represents the entire layer, right? point (0,0) and bounds (width,height) > Same should be true for WebGL and canvas2D... Did I overlook something? Doh, sorry, I misread the code! You are right. 481405 31 110463 shawnsingh 2011-10-10 19:48:46 -0700 Created attachment 110463 Patch 483550 32 shawnsingh 2011-10-13 15:19:10 -0700 Can someone please review this latest version? Hopefully it could be the final version. 484436 33 111114 shawnsingh 2011-10-14 17:41:25 -0700 Created attachment 111114 Added update rect to CCLayerImpl also 485533 34 111114 jamesr 2011-10-17 14:53:29 -0700 Comment on attachment 111114 Added update rect to CCLayerImpl also View in context: https://bugs.webkit.org/attachment.cgi?id=111114&action=review I think the updateRect for tiled layers is wrong - shouldn't it be in layer space? The easiest way to check this is to see what the expected and actual update rectangle are for an animated image layer that's scaled in CSS. > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:211 > + m_updateRect = FloatRect(m_paintRect); m_paintRect is in content space, not layer space. Is that what we expect? All of the other m_updateRects are in layer space, not content space. > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:251 > + // Reset any state that should be cleared for the next update. > + m_paintRect = IntRect(); Why do we clear the paint rect here? We didn't push that to the CCLayerImpl > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:350 > +void TiledLayerChromium::prepareToUpdate(const IntRect& visibleContentRect) Now that the parameter name and member variable have nearly the same name (modulo the "m_") I find this function much harder to read. I think the original name was actually better - the caller was requesting that we prepare to update the region corresponding with a given content rect. The fact that the content rect represents a visible area is the caller's concern, not the concern of this function - and in fact when we start doing tile prerendering the passed-in content rect will not necessarily have much to do with what's currently visible. I think the parameter name 'contentRect' was better and the member variable should be something like 'requestedUpdateRect' to reflect that we might not end up actually updating that exact rectangle. > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.h:69 > // Prepare data needed to update textures that intersect with contentRect. > - void prepareToUpdate(const IntRect& contentRect); > - // Update invalid textures that intersect with contentRect provided in prepareToUpdate(). > - void updateRect(GraphicsContext3D*, LayerTextureUpdater*); > + void prepareToUpdate(const IntRect& visibleContentRect); The comment and signature are out of sync 486185 35 111472 shawnsingh 2011-10-18 11:21:31 -0700 Created attachment 111472 addressed all of jamesr comments 486189 36 111472 jamesr 2011-10-18 11:27:46 -0700 Comment on attachment 111472 addressed all of jamesr comments R=me 486213 37 111472 webkit.review.bot 2011-10-18 12:09:23 -0700 Comment on attachment 111472 addressed all of jamesr comments Clearing flags on attachment: 111472 Committed r97780: <http://trac.webkit.org/changeset/97780> 486214 38 webkit.review.bot 2011-10-18 12:09:29 -0700 All reviewed patches have been landed. Closing bug. 109982 2011-10-06 11:19:55 -0700 2011-10-06 13:55:27 -0700 Patch bug-69441-20111006111954.patch text/plain 8860 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTY3ODEKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA5MjZiMmVlYTFiZGNkNWY3 YTVlNzg5ZjEyZjdmYzM4MWEwODQ3ZDQyLi4wNmE4NzA0MDM0ZTMwMDdjY2YxOGQ0M2M3Mjc2NmZk MTE5Y2Q3OWU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTEtMTAtMDYgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkZWQgYSBGbG9h dFJlY3QgdG8gTGF5ZXJDaHJvbWl1bSB0aGF0IHRyYWNrcyB3aGF0IHJlZ2lvbiB3YXMgYWN0dWFs bHkKKyAgICAgICAgcmVwYWludGVkIGluIGEgbGF5ZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02OTQ0MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3RzIHdpbGwgYmUgYWRkZWQgaW4gYSBzZXBhcmF0 ZSBwYXRjaCBhZnRlciB0aGUKKyAgICAgICAgR3JhcGhpY3NDb250ZXh0M0QgYW5kIGFsbG9jYXRv ciBjYW4gYmUgbW9ja2VkLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Q2FudmFzMkRMYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNhbnZhczJETGF5 ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oOgorICAgICAgICAoV2ViQ29yZTo6 TGF5ZXJDaHJvbWl1bTo6ZGlydHlSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyQ2hyb21p dW06OmFjdHVhbGx5UmVwYWludGVkUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllckNocm9t aXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9QbHVnaW5MYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OlBsdWdpbkxheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMpOgorICAgICAg ICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uaDoKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3Bw OgorICAgICAgICAoV2ViQ29yZTo6VGlsZWRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9y UmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xh eWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VmlkZW9MYXllckNocm9taXVtOjp1 cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xM YXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKwogMjAxMS0xMC0wNSAg Q2hyaXMgUm9nZXJzICA8Y3JvZ2Vyc0Bnb29nbGUuY29tPgogCiAgICAgICAgIERlZmluZSBhIGxv ZzJmKCkgZnVuY3Rpb24gZm9yIFdpbmRvd3MgaW4gd3RmL01hdGhFeHRyYXMuaApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXll ckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggMGUwZGE4MDRiNjFkNjQ2NWY0MTQyZWNh N2JhMjcxM2NhNTc1YmI4ZC4uNjQyMjI0NThmM2YzNDdjZGIzNzQ4MGM1NjVhMmI5M2FjYTM3ZjI4 ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Q2FudmFzMkRMYXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwCkBAIC03OSw2ICs3OSw5 IEBAIHZvaWQgQ2FudmFzMkRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2Vz KEdyYXBoaWNzQ29udGV4dDNEKiwgVGV4dHVyCiAjZW5kaWYKICAgICAgICAgbV9jb250ZXh0LT5m bHVzaCgpOwogICAgIH0KKworICAgIC8vIEZvciBub3csIGFzc3VtZSB0aGUgZW50aXJlIGNhbnZh czJEIGxheWVyIGlzIHJlcGFpbnRlZCBvbiBldmVyeSB1cGRhdGUuCisgICAgbV9hY3R1YWxseVJl cGFpbnRlZFJlY3QgPSBGbG9hdFJlY3QoMC4wZiwgMC4wZiwgYm91bmRzKCkud2lkdGgoKSwgYm91 bmRzKCkuaGVpZ2h0KCkpOwogICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiB9CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21p dW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hy b21pdW0uaAppbmRleCBiZTBlNzk2MDZiYjI5M2JjMDBmYjNmZThkZDJmMjVlNjM2ZDhkYmQ5Li5i MDkxY2NlN2UwNjhlYzA1YTc1MWEwNWMzNWY0OWM0YWY0MWM1NDAzIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1 bS5oCkBAIC0xMDYsOSArMTA2LDExIEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc2V0TmVlZHNEaXNw bGF5KGNvbnN0IEZsb2F0UmVjdCYgZGlydHlSZWN0KTsKICAgICB2b2lkIHNldE5lZWRzRGlzcGxh eSgpOwotICAgIGNvbnN0IEZsb2F0UmVjdCYgZGlydHlSZWN0KCkgY29uc3QgeyByZXR1cm4gbV9k aXJ0eVJlY3Q7IH0KICAgICB2b2lkIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiAKKyAgICBjb25zdCBG bG9hdFJlY3QmIGRpcnR5UmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fZGlydHlSZWN0OyB9CisgICAg Y29uc3QgRmxvYXRSZWN0JiBhY3R1YWxseVJlcGFpbnRlZFJlY3QoKSBjb25zdCB7IHJldHVybiBt X2FjdHVhbGx5UmVwYWludGVkUmVjdDsgfQorCiAgICAgdm9pZCBzZXRPcGFjaXR5KGZsb2F0IG9w YWNpdHkpIHsgbV9vcGFjaXR5ID0gb3BhY2l0eTsgc2V0TmVlZHNDb21taXQoKTsgfQogICAgIGZs b2F0IG9wYWNpdHkoKSBjb25zdCB7IHJldHVybiBtX29wYWNpdHk7IH0KIApAQCAtMTU5LDcgKzE2 MSw3IEBAIHB1YmxpYzoKICAgICAvLyBUaGVzZSBtZXRob2RzIHR5cGljYWxseSBuZWVkIHRvIGJl IG92ZXJ3cml0dGVuIGJ5IGRlcml2ZWQgY2xhc3Nlcy4KICAgICB2aXJ0dWFsIGJvb2wgZHJhd3ND b250ZW50KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFsIHZvaWQgcGFpbnRD b250ZW50c0lmRGlydHkoKSB7IH0KLSAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlQ29tcG9zaXRvclJl c291cmNlcyhHcmFwaGljc0NvbnRleHQzRCosIFRleHR1cmVBbGxvY2F0b3IqKSB7IH0KKyAgICB2 aXJ0dWFsIHZvaWQgdXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCos IFRleHR1cmVBbGxvY2F0b3IqKSB7IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CiAgICAgdmlydHVh bCB2b2lkIHNldElzTWFzayhib29sKSB7fQogICAgIHZpcnR1YWwgdm9pZCB1bnJlc2VydmVDb250 ZW50c1RleHR1cmUoKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgYmluZENvbnRlbnRzVGV4dHVyZSgp IHsgfQpAQCAtMjA4LDcgKzIxMCwxMiBAQCBwcm90ZWN0ZWQ6CiAgICAgLy8gaG9sZCBjb250ZXh0 LWRlcGVuZGVudCByZXNvdXJjZXMgc3VjaCBhcyB0ZXh0dXJlcy4KICAgICB2aXJ0dWFsIHZvaWQg Y2xlYW51cFJlc291cmNlcygpOwogCisgICAgLy8gTm90ZSB0aGF0IHRoZSByZWdpb24gdGhhdCB3 YXMgYWN0dWFsbHkgcmVwYWludGVkIGlzIG5vdCBuZWNlc3NhcmlseSB0aGUgc2FtZSBhcyB3aGF0 IHdhcworICAgIC8vIG1hcmtlZCBkaXJ0eS4gU29tZSBleGFtcGxlczogdGlsZXMgbWF5IGJlIG9m ZiBzY3JlZW4sIHBvcnRpb25zIG9mIGEgbGF5ZXIgbWF5IGJlIGNsaXBwZWQsCisgICAgLy8gYSBs YXllciBtYXkgY2hvb3NlIHRvIHJlcGFpbnQgdGhlIGVudGlyZSBsYXllciBhbnl3YXksIG9yIGEg bGF5ZXIgbWF5IGludGVsbGlnZW50bHkKKyAgICAvLyByZXBhaW50IGxlc3MgdGhhbiB3aGF0IHdh cyBkaXJ0eS4KICAgICBGbG9hdFJlY3QgbV9kaXJ0eVJlY3Q7CisgICAgRmxvYXRSZWN0IG1fYWN0 dWFsbHlSZXBhaW50ZWRSZWN0OwogCiAgICAgUmVmUHRyPExheWVyQ2hyb21pdW0+IG1fbWFza0xh eWVyOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9QbHVnaW5MYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uY3BwCmluZGV4IDIwMTQ2ODc1NTgz MTFkZjA4NTczNGM0YmM1OGI0YTdiZGEzMDdmMmUuLjZhZTkyMTNiMWY1OGYwYWFiMjkxNGU2MjRi MDUyODQzNDk2OWMyNmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uY3BwCkBAIC02 NSw1ICs2NSwxMSBAQCB2b2lkIFBsdWdpbkxheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8o Q0NMYXllckltcGwqIGxheWVyKQogICAgIHBsdWdpbkxheWVyLT5zZXRUZXh0dXJlSWQobV90ZXh0 dXJlSWQpOwogfQogCit2b2lkIFBsdWdpbkxheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JS ZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJlQWxsb2NhdG9yKikKK3sKKyAgICAv LyBQbHVnaW4gbGF5ZXJzIGRvIHRoZWlyIG93biB1cGRhdGluZywgc28gd2UgYXNzdW1lIGl0IHJl cGFpbnRzIHRoZSBlbnRpcmUgbGF5ZXIgb24gZXZlcnkgdXBkYXRlLgorICAgIG1fYWN0dWFsbHlS ZXBhaW50ZWRSZWN0ID0gRmxvYXRSZWN0KDAuMGYsIDAuMGYsIGJvdW5kcygpLndpZHRoKCksIGJv dW5kcygpLmhlaWdodCgpKTsKK30KKwogfQogI2VuZGlmIC8vIFVTRShBQ0NFTEVSQVRFRF9DT01Q T1NJVElORykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uaAppbmRleCAxODM0ZGZkODI2Yjlk MTI0MmQyZjk0NDIzOTc1ODRlNzVhY2U2NGRkLi5iMGFkZTUxM2E4MzFhNDMzZTMzOTc5NzEyOWM2 MmNkMWY1N2UwZTcyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9QbHVnaW5MYXllckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vUGx1Z2luTGF5ZXJDaHJvbWl1bS5oCkBAIC00NCw2ICs0 NCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldFRleHR1cmVJZCh1bnNpZ25lZCB0ZXh0dXJlSWQp OwogICAgIHVuc2lnbmVkIHRleHR1cmVJZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGV4dHVyZUlkOyB9 CiAKKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0Nv bnRleHQzRCosIFRleHR1cmVBbGxvY2F0b3IqKTsKICAgICB2aXJ0dWFsIHZvaWQgcHVzaFByb3Bl cnRpZXNUbyhDQ0xheWVySW1wbCopOwogCiBwcml2YXRlOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJv bWl1bS5jcHAKaW5kZXggYWY0OWM4YzBhNGRhYWM1NTVmODc2YTQ0MTM1NDYyYjdlNDU0MWRlMC4u ZDMzNDA1NTAzYjRmNDE2YTI0NmE0ZGEyMzRlMGQ0OWY2OTY4ZGZjYSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVt LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxl ZExheWVyQ2hyb21pdW0uY3BwCkBAIC0xNTcsNiArMTU3LDggQEAgdm9pZCBUaWxlZExheWVyQ2hy b21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRl eHQsIFQKICAgICBpZiAobV9za2lwc0RyYXcgfHwgbV91cGRhdGVSZWN0LmlzRW1wdHkoKSB8fCAh bV90aWxlci0+bnVtVGlsZXMoKSkKICAgICAgICAgcmV0dXJuOwogCisgICAgSW50UmVjdCB0b3Rh bFJlcGFpbnRlZENvbnRlbnQ7CisKICAgICBpbnQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tOwog ICAgIG1fdGlsZXItPmNvbnRlbnRSZWN0VG9UaWxlSW5kaWNlcyhtX3VwZGF0ZVJlY3QsIGxlZnQs IHRvcCwgcmlnaHQsIGJvdHRvbSk7CiAgICAgZm9yIChpbnQgaiA9IHRvcDsgaiA8PSBib3R0b207 ICsraikgewpAQCAtMjA0LDkgKzIwNiwxMiBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6dXBk YXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVAogICAg ICAgICAgICAgR0xDKGNvbnRleHQsIGNvbnRleHQtPmJpbmRUZXh0dXJlKEdyYXBoaWNzQ29udGV4 dDNEOjpURVhUVVJFXzJELCAwKSk7CiAKICAgICAgICAgICAgIHRleHR1cmVVcGRhdGVyKCktPnVw ZGF0ZVRleHR1cmVSZWN0KGNvbnRleHQsIGFsbG9jYXRvciwgdGlsZS0+dGV4dHVyZSgpLCBzb3Vy Y2VSZWN0LCBkZXN0UmVjdCk7CisgICAgICAgICAgICB0b3RhbFJlcGFpbnRlZENvbnRlbnQudW5p dGUoc291cmNlUmVjdCk7CiAgICAgICAgICAgICB0aWxlLT5jbGVhckRpcnR5KCk7CiAgICAgICAg IH0KICAgICB9CisKKyAgICBtX2FjdHVhbGx5UmVwYWludGVkUmVjdCA9IEZsb2F0UmVjdChtX3Rp bGVyLT5jb250ZW50UmVjdFRvTGF5ZXJSZWN0KHRvdGFsUmVwYWludGVkQ29udGVudCkpOwogfQog CiB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6c2V0VGlsaW5nT3B0aW9uKFRpbGluZ09wdGlvbiB0 aWxpbmdPcHRpb24pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmNwcAppbmRleCA4ZTkyOWRk MzZhZmFlNzNmYmY0MTk5MzUyNDI2ZjZmNGZjNTA1MDkwLi44NGQ3MTMxNjMyZTBhMzBmYWU1NTQ4 ZDI2NjJjYmMwZWM4YmM2MzVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5jcHAKQEAg LTEzNiw2ICsxMzYsOCBAQCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRv clJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVAogICAgIG1fcGxhbmVzID0g ZnJhbWUtPnBsYW5lcygpOwogICAgIEFTU0VSVChtX3BsYW5lcyA8PSBNYXhQbGFuZXMpOwogCisg ICAgLy8gRm9yIHZpZGVvIGxheWVycywgdGhlIGVudGlyZSBsYXllciBpcyBjb3BpZWQgZm9yIGV2 ZXJ5IHVwZGF0ZS4KKyAgICBtX2FjdHVhbGx5UmVwYWludGVkUmVjdCA9IEZsb2F0UmVjdCgwLjBm LCAwLjBmLCBib3VuZHMoKS53aWR0aCgpLCBib3VuZHMoKS5oZWlnaHQoKSk7CiAgICAgcmVzZXRO ZWVkc0Rpc3BsYXkoKTsKIAogICAgIG1fcHJvdmlkZXItPnB1dEN1cnJlbnRGcmFtZShmcmFtZSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9X ZWJHTExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcAppbmRleCAzMmJhNmEzYmVlNWEwMjRmNTVj YzAyNzYyMjUyYjkzYjU4MDRlMGU0Li4yNDRiNjY2OWZmMWE4ZWM2Mzk1MGE2MzA3ZTBhZmI3NzZk MWQ3ZTgwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTkwLDYgKzkwLDEw IEBAIHZvaWQgV2ViR0xMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKEdy YXBoaWNzQ29udGV4dDNEKiByZW5kZXJlckNvCiAgICAgICAgIC8vCiAgICAgICAgIG1fY29udGV4 dC0+cHJlcGFyZVRleHR1cmUoKTsKICAgICAgICAgbV9jb250ZXh0LT5tYXJrTGF5ZXJDb21wb3Np dGVkKCk7CisKKyAgICAgICAgLy8gRm9yIHdlYkdMIGxheWVycywgdGhlIGVudGlyZSBsYXllciBp cyBjb3BpZWQgZm9yIGV2ZXJ5IHVwZGF0ZS4KKyAgICAgICAgbV9hY3R1YWxseVJlcGFpbnRlZFJl Y3QgPSBGbG9hdFJlY3QoMC4wZiwgMC4wZiwgYm91bmRzKCkud2lkdGgoKSwgYm91bmRzKCkuaGVp Z2h0KCkpOworCiAgICAgICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiAgICAgICAgIG1fdGV4dHVy ZVVwZGF0ZWQgPSBmYWxzZTsKICAgICB9Cg== 110013 2011-10-06 13:55:32 -0700 2011-10-06 20:20:36 -0700 renamed repaint to update bug-69441-20111006135531.patch text/plain 8806 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTY3ODEKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA5MjZiMmVlYTFiZGNkNWY3 YTVlNzg5ZjEyZjdmYzM4MWEwODQ3ZDQyLi4zNTE1NGYxOTNjMmMzN2JjY2MyOTJmOWZkMzI0NTM4 ODk4ZDY1YzUzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTEtMTAtMDYgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWRkZWQgYSBGbG9h dFJlY3QgdG8gTGF5ZXJDaHJvbWl1bSB0aGF0IHRyYWNrcyB3aGF0IHJlZ2lvbiB3YXMgYWN0dWFs bHkKKyAgICAgICAgdXBkYXRlZCBpbiBhIGxheWVyLgorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Njk0NDEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0cyB3aWxsIGJlIGFkZGVkIGluIGEgc2VwYXJhdGUg cGF0Y2ggYWZ0ZXIgdGhlCisgICAgICAgIEdyYXBoaWNzQ29udGV4dDNEIGFuZCBhbGxvY2F0b3Ig Y2FuIGJlIG1vY2tlZC4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDYW52YXMyRExheWVy Q2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMpOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uaDoKKyAgICAgICAgKFdlYkNvcmU6Okxh eWVyQ2hyb21pdW06OmRpcnR5UmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpMYXllckNocm9taXVt OjphY3R1YWxseVJlcGFpbnRlZFJlY3QpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJDaHJvbWl1 bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vUGx1Z2luTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQ bHVnaW5MYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9QbHVnaW5MYXllckNocm9taXVtLmg6CisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJl c291cmNlcyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXll ckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlZpZGVvTGF5ZXJDaHJvbWl1bTo6dXBk YXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldlYkdMTGF5 ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisKIDIwMTEtMTAtMDUgIENo cmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xlLmNvbT4KIAogICAgICAgICBEZWZpbmUgYSBsb2cy ZigpIGZ1bmN0aW9uIGZvciBXaW5kb3dzIGluIHd0Zi9NYXRoRXh0cmFzLmgKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJD aHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9D YW52YXMyRExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDBlMGRhODA0YjYxZDY0NjVmNDE0MmVjYTdi YTI3MTNjYTU3NWJiOGQuLmJhZmU1OTY2YjU3Y2FlM2RkNjI2MTEyMWQzNzA3NDY3YThmOTQ3MGYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcApAQCAtNzksNiArNzksOSBA QCB2b2lkIENhbnZhczJETGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhH cmFwaGljc0NvbnRleHQzRCosIFRleHR1cgogI2VuZGlmCiAgICAgICAgIG1fY29udGV4dC0+Zmx1 c2goKTsKICAgICB9CisKKyAgICAvLyBGb3Igbm93LCB0aGUgZW50aXJlIGNhbnZhcyBsYXllciBp cyB1cGRhdGVkLgorICAgIG1fYWN0dWFsbHlVcGRhdGVkUmVjdCA9IEZsb2F0UmVjdCgwLjBmLCAw LjBmLCBib3VuZHMoKS53aWR0aCgpLCBib3VuZHMoKS5oZWlnaHQoKSk7CiAgICAgcmVzZXROZWVk c0Rpc3BsYXkoKTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oCmluZGV4IGJlMGU3OTYwNmJiMjkzYmMw MGZiM2ZlOGRkMmYyNWU2MzZkOGRiZDkuLmM4MTZmYTE5ZjZmNzI1YTA5ZDU0ZWZlNDY4Mzg2NDhh YTBhYzdhOTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyQ2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKQEAgLTEwNiw5ICsxMDYsMTEgQEAgcHVibGlj OgogCiAgICAgdm9pZCBzZXROZWVkc0Rpc3BsYXkoY29uc3QgRmxvYXRSZWN0JiBkaXJ0eVJlY3Qp OwogICAgIHZvaWQgc2V0TmVlZHNEaXNwbGF5KCk7Ci0gICAgY29uc3QgRmxvYXRSZWN0JiBkaXJ0 eVJlY3QoKSBjb25zdCB7IHJldHVybiBtX2RpcnR5UmVjdDsgfQogICAgIHZvaWQgcmVzZXROZWVk c0Rpc3BsYXkoKTsKIAorICAgIGNvbnN0IEZsb2F0UmVjdCYgZGlydHlSZWN0KCkgY29uc3QgeyBy ZXR1cm4gbV9kaXJ0eVJlY3Q7IH0KKyAgICBjb25zdCBGbG9hdFJlY3QmIGFjdHVhbGx5VXBkYXRl ZFJlY3QoKSBjb25zdCB7IHJldHVybiBtX2FjdHVhbGx5VXBkYXRlZFJlY3Q7IH0KKwogICAgIHZv aWQgc2V0T3BhY2l0eShmbG9hdCBvcGFjaXR5KSB7IG1fb3BhY2l0eSA9IG9wYWNpdHk7IHNldE5l ZWRzQ29tbWl0KCk7IH0KICAgICBmbG9hdCBvcGFjaXR5KCkgY29uc3QgeyByZXR1cm4gbV9vcGFj aXR5OyB9CiAKQEAgLTE1OSw3ICsxNjEsNyBAQCBwdWJsaWM6CiAgICAgLy8gVGhlc2UgbWV0aG9k cyB0eXBpY2FsbHkgbmVlZCB0byBiZSBvdmVyd3JpdHRlbiBieSBkZXJpdmVkIGNsYXNzZXMuCiAg ICAgdmlydHVhbCBib29sIGRyYXdzQ29udGVudCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAg ICAgdmlydHVhbCB2b2lkIHBhaW50Q29udGVudHNJZkRpcnR5KCkgeyB9Ci0gICAgdmlydHVhbCB2 b2lkIHVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJl QWxsb2NhdG9yKikgeyB9CisgICAgdmlydHVhbCB2b2lkIHVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJj ZXMoR3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJlQWxsb2NhdG9yKikgeyBBU1NFUlRfTk9UX1JF QUNIRUQoKTsgfQogICAgIHZpcnR1YWwgdm9pZCBzZXRJc01hc2soYm9vbCkge30KICAgICB2aXJ0 dWFsIHZvaWQgdW5yZXNlcnZlQ29udGVudHNUZXh0dXJlKCkgeyB9CiAgICAgdmlydHVhbCB2b2lk IGJpbmRDb250ZW50c1RleHR1cmUoKSB7IH0KQEAgLTIwOCw3ICsyMTAsMTIgQEAgcHJvdGVjdGVk OgogICAgIC8vIGhvbGQgY29udGV4dC1kZXBlbmRlbnQgcmVzb3VyY2VzIHN1Y2ggYXMgdGV4dHVy ZXMuCiAgICAgdmlydHVhbCB2b2lkIGNsZWFudXBSZXNvdXJjZXMoKTsKIAorICAgIC8vIE5vdGUg dGhhdCB0aGUgcmVnaW9uIHRoYXQgd2FzIGFjdHVhbGx5IHVwZGF0ZWQgaXMgbm90IG5lY2Vzc2Fy aWx5IHRoZSBzYW1lIGFzIHdoYXQgd2FzCisgICAgLy8gbWFya2VkIGRpcnR5LiBTb21lIGV4YW1w bGVzOiB0aWxlcyBtYXkgYmUgb2ZmIHNjcmVlbiwgcG9ydGlvbnMgb2YgYSBsYXllciBtYXkgYmUg Y2xpcHBlZCwKKyAgICAvLyBhIGxheWVyIG1heSBjaG9vc2UgdG8gcmVwYWludCB0aGUgZW50aXJl IGxheWVyIGFueXdheSwgb3IgYSBsYXllciBtYXkgaW50ZWxsaWdlbnRseQorICAgIC8vIHJlcGFp bnQgbGVzcyB0aGFuIHdoYXQgd2FzIGRpcnR5LgogICAgIEZsb2F0UmVjdCBtX2RpcnR5UmVjdDsK KyAgICBGbG9hdFJlY3QgbV9hY3R1YWxseVVwZGF0ZWRSZWN0OwogCiAgICAgUmVmUHRyPExheWVy Q2hyb21pdW0+IG1fbWFza0xheWVyOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9QbHVnaW5MYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uY3Bw CmluZGV4IDIwMTQ2ODc1NTgzMTFkZjA4NTczNGM0YmM1OGI0YTdiZGEzMDdmMmUuLjcyZWYyYzM5 OTM1ZDZmNzkyMWVjNjY1ZDE2NDFlYWFmM2IyYjk5NzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVy Q2hyb21pdW0uY3BwCkBAIC02NSw1ICs2NSwxMSBAQCB2b2lkIFBsdWdpbkxheWVyQ2hyb21pdW06 OnB1c2hQcm9wZXJ0aWVzVG8oQ0NMYXllckltcGwqIGxheWVyKQogICAgIHBsdWdpbkxheWVyLT5z ZXRUZXh0dXJlSWQobV90ZXh0dXJlSWQpOwogfQogCit2b2lkIFBsdWdpbkxheWVyQ2hyb21pdW06 OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJlQWxs b2NhdG9yKikKK3sKKyAgICAvLyBQbHVnaW4gbGF5ZXJzIGRvIHRoZWlyIG93biByZXBhaW50aW5n LCBzbyB3ZSBhc3N1bWUgaXQgdXBkYXRlcyB0aGUgZW50aXJlIGxheWVyIG9uIGV2ZXJ5IHVwZGF0 ZS4KKyAgICBtX2FjdHVhbGx5VXBkYXRlZFJlY3QgPSBGbG9hdFJlY3QoMC4wZiwgMC4wZiwgYm91 bmRzKCkud2lkdGgoKSwgYm91bmRzKCkuaGVpZ2h0KCkpOworfQorCiB9CiAjZW5kaWYgLy8gVVNF KEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vUGx1Z2luTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vUGx1Z2luTGF5ZXJDaHJvbWl1bS5oCmlu ZGV4IDE4MzRkZmQ4MjZiOWQxMjQyZDJmOTQ0MjM5NzU4NGU3NWFjZTY0ZGQuLmIwYWRlNTEzYTgz MWE0MzNlMzM5Nzk3MTI5YzYyY2QxZjU3ZTBlNzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1BsdWdpbkxheWVyQ2hyb21pdW0uaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9QbHVnaW5MYXllckNocm9t aXVtLmgKQEAgLTQ0LDYgKzQ0LDcgQEAgcHVibGljOgogICAgIHZvaWQgc2V0VGV4dHVyZUlkKHVu c2lnbmVkIHRleHR1cmVJZCk7CiAgICAgdW5zaWduZWQgdGV4dHVyZUlkKCkgY29uc3QgeyByZXR1 cm4gbV90ZXh0dXJlSWQ7IH0KIAorICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVDb21wb3NpdG9yUmVz b3VyY2VzKEdyYXBoaWNzQ29udGV4dDNEKiwgVGV4dHVyZUFsbG9jYXRvciopOwogICAgIHZpcnR1 YWwgdm9pZCBwdXNoUHJvcGVydGllc1RvKENDTGF5ZXJJbXBsKik7CiAKIHByaXZhdGU6CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExh eWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCBhZjQ5YzhjMGE0ZGFhYzU1NWY4NzZhNDQx MzU0NjJiN2U0NTQxZGUwLi5iZDRlMTFmZGM0NWRmNjIxZDQzZWJjYzc4OGQyYzE3ZGUxNTVkM2Y1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTE1Nyw2ICsxNTcsOCBAQCB2 b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGlj c0NvbnRleHQzRCogY29udGV4dCwgVAogICAgIGlmIChtX3NraXBzRHJhdyB8fCBtX3VwZGF0ZVJl Y3QuaXNFbXB0eSgpIHx8ICFtX3RpbGVyLT5udW1UaWxlcygpKQogICAgICAgICByZXR1cm47CiAK KyAgICBJbnRSZWN0IHRvdGFsVXBkYXRlZENvbnRlbnQ7CisKICAgICBpbnQgbGVmdCwgdG9wLCBy aWdodCwgYm90dG9tOwogICAgIG1fdGlsZXItPmNvbnRlbnRSZWN0VG9UaWxlSW5kaWNlcyhtX3Vw ZGF0ZVJlY3QsIGxlZnQsIHRvcCwgcmlnaHQsIGJvdHRvbSk7CiAgICAgZm9yIChpbnQgaiA9IHRv cDsgaiA8PSBib3R0b207ICsraikgewpAQCAtMjA0LDkgKzIwNiwxMiBAQCB2b2lkIFRpbGVkTGF5 ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCog Y29udGV4dCwgVAogICAgICAgICAgICAgR0xDKGNvbnRleHQsIGNvbnRleHQtPmJpbmRUZXh0dXJl KEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCAwKSk7CiAKICAgICAgICAgICAgIHRleHR1 cmVVcGRhdGVyKCktPnVwZGF0ZVRleHR1cmVSZWN0KGNvbnRleHQsIGFsbG9jYXRvciwgdGlsZS0+ dGV4dHVyZSgpLCBzb3VyY2VSZWN0LCBkZXN0UmVjdCk7CisgICAgICAgICAgICB0b3RhbFVwZGF0 ZWRDb250ZW50LnVuaXRlKHNvdXJjZVJlY3QpOwogICAgICAgICAgICAgdGlsZS0+Y2xlYXJEaXJ0 eSgpOwogICAgICAgICB9CiAgICAgfQorCisgICAgbV9hY3R1YWxseVVwZGF0ZWRSZWN0ID0gRmxv YXRSZWN0KG1fdGlsZXItPmNvbnRlbnRSZWN0VG9MYXllclJlY3QodG90YWxVcGRhdGVkQ29udGVu dCkpOwogfQogCiB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6c2V0VGlsaW5nT3B0aW9uKFRpbGlu Z09wdGlvbiB0aWxpbmdPcHRpb24pCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmNwcAppbmRl eCA4ZTkyOWRkMzZhZmFlNzNmYmY0MTk5MzUyNDI2ZjZmNGZjNTA1MDkwLi40NGYwMjkzMjE5ODQ0 MjAzNjkzYTA4Mjc3MzhiYTUzODVjMTlkZTVjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1 bS5jcHAKQEAgLTEzNiw2ICsxMzYsOCBAQCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6dXBkYXRl Q29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVAogICAgIG1f cGxhbmVzID0gZnJhbWUtPnBsYW5lcygpOwogICAgIEFTU0VSVChtX3BsYW5lcyA8PSBNYXhQbGFu ZXMpOwogCisgICAgLy8gRm9yIHZpZGVvIGxheWVycywgdGhlIGVudGlyZSBsYXllciBpcyBjb3Bp ZWQgb24gZXZlcnkgdXBkYXRlLgorICAgIG1fYWN0dWFsbHlVcGRhdGVkUmVjdCA9IEZsb2F0UmVj dCgwLjBmLCAwLjBmLCBib3VuZHMoKS53aWR0aCgpLCBib3VuZHMoKS5oZWlnaHQoKSk7CiAgICAg cmVzZXROZWVkc0Rpc3BsYXkoKTsKIAogICAgIG1fcHJvdmlkZXItPnB1dEN1cnJlbnRGcmFtZShm cmFtZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcAppbmRleCAzMmJhNmEzYmVlNWEw MjRmNTVjYzAyNzYyMjUyYjkzYjU4MDRlMGU0Li4xZjQxNWU2MDk1NjNjYjAwNmI5ZDY5M2NlMzNl NGY1Nzc1Mjk4ZjFmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTkwLDYg KzkwLDEwIEBAIHZvaWQgV2ViR0xMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3Vy Y2VzKEdyYXBoaWNzQ29udGV4dDNEKiByZW5kZXJlckNvCiAgICAgICAgIC8vCiAgICAgICAgIG1f Y29udGV4dC0+cHJlcGFyZVRleHR1cmUoKTsKICAgICAgICAgbV9jb250ZXh0LT5tYXJrTGF5ZXJD b21wb3NpdGVkKCk7CisKKyAgICAgICAgLy8gRm9yIHdlYkdMIGxheWVycywgdGhlIGVudGlyZSBs YXllciBpcyBjb3BpZWQgb24gZXZlcnkgdXBkYXRlLgorICAgICAgICBtX2FjdHVhbGx5VXBkYXRl ZFJlY3QgPSBGbG9hdFJlY3QoMC4wZiwgMC4wZiwgYm91bmRzKCkud2lkdGgoKSwgYm91bmRzKCku aGVpZ2h0KCkpOworCiAgICAgICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiAgICAgICAgIG1fdGV4 dHVyZVVwZGF0ZWQgPSBmYWxzZTsKICAgICB9Cg== 110084 2011-10-06 20:20:40 -0700 2011-10-07 22:39:26 -0700 Patch bug-69441-20111006202038.patch text/plain 6622 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTY3ODEKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA5MjZiMmVlYTFiZGNkNWY3 YTVlNzg5ZjEyZjdmYzM4MWEwODQ3ZDQyLi5hMTZjYzliODEyNWY4YjRmNzRjZWE2ODM4NTE3YWRj ZTkyZDcxZjJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTEtMTAtMDYgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBL ZWVwIHRyYWNrIG9mIHRoZSByZWN0IHRoYXQgd2FzIGFjdHVhbGx5CisgICAgICAgIHVwZGF0ZWQg Zm9yIGNvbXBvc2l0ZWQgbGF5ZXJzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9Njk0NDEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0u aDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyQ2hyb21pdW06OmRpcnR5UmVjdCk6CisgICAgICAg IChXZWJDb3JlOjpMYXllckNocm9taXVtOjp1cGRhdGVSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6 OkxheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMpOgorICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJjZXMpOgorICAgICAg ICAoV2ViQ29yZTo6VGlsZWRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2Vz KToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRl KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21p dW0uaDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6dXBkYXRlUmVjdCk6 CisKIDIwMTEtMTAtMDUgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xlLmNvbT4KIAogICAg ICAgICBEZWZpbmUgYSBsb2cyZigpIGZ1bmN0aW9uIGZvciBXaW5kb3dzIGluIHd0Zi9NYXRoRXh0 cmFzLmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyQ2hyb21pdW0uaAppbmRleCBiZTBlNzk2MDZiYjI5M2JjMDBmYjNmZThkZDJm MjVlNjM2ZDhkYmQ5Li42ZjQ0MzJhYjBlZDk3NTQ5MWU0YjA4ZWFjNTE0ZDFjYTM5YWMzNWMxIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXll ckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTGF5ZXJDaHJvbWl1bS5oCkBAIC0xMDYsOSArMTA2LDEyIEBAIHB1YmxpYzoKIAogICAgIHZv aWQgc2V0TmVlZHNEaXNwbGF5KGNvbnN0IEZsb2F0UmVjdCYgZGlydHlSZWN0KTsKICAgICB2b2lk IHNldE5lZWRzRGlzcGxheSgpOwotICAgIGNvbnN0IEZsb2F0UmVjdCYgZGlydHlSZWN0KCkgY29u c3QgeyByZXR1cm4gbV9kaXJ0eVJlY3Q7IH0KICAgICB2b2lkIHJlc2V0TmVlZHNEaXNwbGF5KCk7 CiAKKyAgICBjb25zdCBGbG9hdFJlY3QmIGRpcnR5UmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fZGly dHlSZWN0OyB9CisgICAgLy8gdXBkYXRlUmVjdCBpcyB0aGUgcmVnaW9uIG9mIHRoZSBsYXllciB0 aGF0IHdhcyBhY3R1YWxseSB1cGRhdGVkLCBhZnRlciB1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2Vz KCkuCisgICAgdmlydHVhbCBjb25zdCBGbG9hdFJlY3QgdXBkYXRlUmVjdCgpIGNvbnN0IHsgcmV0 dXJuIEZsb2F0UmVjdChGbG9hdFBvaW50Ojp6ZXJvKCksIGJvdW5kcygpKTsgfQorCiAgICAgdm9p ZCBzZXRPcGFjaXR5KGZsb2F0IG9wYWNpdHkpIHsgbV9vcGFjaXR5ID0gb3BhY2l0eTsgc2V0TmVl ZHNDb21taXQoKTsgfQogICAgIGZsb2F0IG9wYWNpdHkoKSBjb25zdCB7IHJldHVybiBtX29wYWNp dHk7IH0KIApAQCAtMTU5LDcgKzE2Miw3IEBAIHB1YmxpYzoKICAgICAvLyBUaGVzZSBtZXRob2Rz IHR5cGljYWxseSBuZWVkIHRvIGJlIG92ZXJ3cml0dGVuIGJ5IGRlcml2ZWQgY2xhc3Nlcy4KICAg ICB2aXJ0dWFsIGJvb2wgZHJhd3NDb250ZW50KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAg ICB2aXJ0dWFsIHZvaWQgcGFpbnRDb250ZW50c0lmRGlydHkoKSB7IH0KLSAgICB2aXJ0dWFsIHZv aWQgdXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCosIFRleHR1cmVB bGxvY2F0b3IqKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlQ29tcG9zaXRvclJlc291cmNl cyhHcmFwaGljc0NvbnRleHQzRCosIFRleHR1cmVBbGxvY2F0b3IqKSB7IEFTU0VSVF9OT1RfUkVB Q0hFRCgpOyB9CiAgICAgdmlydHVhbCB2b2lkIHNldElzTWFzayhib29sKSB7fQogICAgIHZpcnR1 YWwgdm9pZCB1bnJlc2VydmVDb250ZW50c1RleHR1cmUoKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQg YmluZENvbnRlbnRzVGV4dHVyZSgpIHsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAK aW5kZXggYWY0OWM4YzBhNGRhYWM1NTVmODc2YTQ0MTM1NDYyYjdlNDU0MWRlMC4uODE3MTliMTY0 YjFlM2QxNzI5YWRiNWIwOTJiNzg3ODM2MmRhMGNhMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hy b21pdW0uY3BwCkBAIC04OSw3ICs4OSw3IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpjbGVh bnVwUmVzb3VyY2VzKCkKICAgICBtX3RpbGVyLmNsZWFyKCk7CiAgICAgbV91bnVzZWRUaWxlcy5j bGVhcigpOwogICAgIG1fcGFpbnRSZWN0ID0gSW50UmVjdCgpOwotICAgIG1fdXBkYXRlUmVjdCA9 IEludFJlY3QoKTsKKyAgICBtX2NvbnRlbnRUb1BhaW50ID0gSW50UmVjdCgpOwogfQogCiB2b2lk IFRpbGVkTGF5ZXJDaHJvbWl1bTo6dXBkYXRlVGlsZVNpemVBbmRUaWxpbmdPcHRpb24oKQpAQCAt MTU0LDExICsxNTQsMTEgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnNldExheWVyVHJlZUhv c3QoQ0NMYXllclRyZWVIb3N0KiBob3N0KQogdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnVwZGF0 ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFRleHR1cmVB bGxvY2F0b3IqIGFsbG9jYXRvcikKIHsKICAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21w b3NpdGluZyB0byBnZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBi ZWNvbWUgaW52YWxpZGF0ZWQgbWlkLXVwZGF0ZS4KLSAgICBpZiAobV9za2lwc0RyYXcgfHwgbV91 cGRhdGVSZWN0LmlzRW1wdHkoKSB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSkKKyAgICBpZiAobV9z a2lwc0RyYXcgfHwgbV9jb250ZW50VG9QYWludC5pc0VtcHR5KCkgfHwgIW1fdGlsZXItPm51bVRp bGVzKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGludCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0 b207Ci0gICAgbV90aWxlci0+Y29udGVudFJlY3RUb1RpbGVJbmRpY2VzKG1fdXBkYXRlUmVjdCwg bGVmdCwgdG9wLCByaWdodCwgYm90dG9tKTsKKyAgICBtX3RpbGVyLT5jb250ZW50UmVjdFRvVGls ZUluZGljZXMobV9jb250ZW50VG9QYWludCwgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tKTsKICAg ICBmb3IgKGludCBqID0gdG9wOyBqIDw9IGJvdHRvbTsgKytqKSB7CiAgICAgICAgIGZvciAoaW50 IGkgPSBsZWZ0OyBpIDw9IHJpZ2h0OyArK2kpIHsKICAgICAgICAgICAgIFVwZGF0YWJsZVRpbGUq IHRpbGUgPSB0aWxlQXQoaSwgaik7CkBAIC0zNDksNyArMzQ5LDcgQEAgdm9pZCBUaWxlZExheWVy Q2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkKICAg ICBtX3NraXBzRHJhdyA9IGZhbHNlOwogCiAgICAgaWYgKGNvbnRlbnRSZWN0LmlzRW1wdHkoKSkg ewotICAgICAgICBtX3VwZGF0ZVJlY3QgPSBJbnRSZWN0KCk7CisgICAgICAgIG1fY29udGVudFRv UGFpbnQgPSBJbnRSZWN0KCk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKQEAgLTM1OSw3ICsz NTksNyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlKGNvbnN0IElu dFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIG1fdGlsZXItPmdyb3dMYXllclRvQ29udGFpbihjb250 ZW50UmVjdCk7CiAKICAgICBpZiAoIW1fdGlsZXItPm51bVRpbGVzKCkpIHsKLSAgICAgICAgbV91 cGRhdGVSZWN0ID0gSW50UmVjdCgpOworICAgICAgICBtX2NvbnRlbnRUb1BhaW50ID0gSW50UmVj dCgpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC0zOTAsNyArMzkwLDcgQEAgdm9pZCBU aWxlZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50 UmVjdCkKICAgICAvLyBEdWUgdG8gYm9yZGVycywgd2hlbiB0aGUgcGFpbnQgcmVjdCBpcyBleHRl bmRlZCB0byB0aWxlIGJvdW5kYXJpZXMsIGl0CiAgICAgLy8gbWF5IGVuZCB1cCBvdmVybGFwcGlu ZyBtb3JlIHRpbGVzIHRoYW4gdGhlIG9yaWdpbmFsIGNvbnRlbnQgcmVjdC4gUmVjb3JkCiAgICAg Ly8gdGhhdCBvcmlnaW5hbCByZWN0IHNvIHdlIGRvbid0IHVwbG9hZCBtb3JlIHRpbGVzIHRoYW4g bmVjZXNzYXJ5LgotICAgIG1fdXBkYXRlUmVjdCA9IGNvbnRlbnRSZWN0OworICAgIG1fY29udGVu dFRvUGFpbnQgPSBjb250ZW50UmVjdDsKIAogICAgIG1fcGFpbnRSZWN0ID0gbV90aWxlci0+bGF5 ZXJSZWN0VG9Db250ZW50UmVjdChkaXJ0eUxheWVyUmVjdCk7CiAgICAgaWYgKGRpcnR5TGF5ZXJS ZWN0LmlzRW1wdHkoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKaW5kZXggMWU4NDk0YTli N2QzMmYyNjE3NzQyODAwMDhhNDVjODBmOWNiOTAzZC4uZTNiZmRkZDlkMzVhYTZlOGUxNzQ0Y2Y0 YzZkZDY5OWU5MjA1ZWFiNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKQEAgLTUwLDYg KzUwLDggQEAgcHVibGljOgogCiAgICAgdmlydHVhbCBib29sIGRyYXdzQ29udGVudCgpIGNvbnN0 OwogCisgICAgdmlydHVhbCBjb25zdCBGbG9hdFJlY3QgdXBkYXRlUmVjdCgpIGNvbnN0IHsgcmV0 dXJuIEZsb2F0UmVjdChtX3BhaW50UmVjdCk7IH0KKwogICAgIC8vIFJlc2VydmVzIGFsbCBleGlz dGluZyBhbmQgdmFsaWQgdGlsZSB0ZXh0dXJlcyB0byBwcm90ZWN0IHRoZW0gZnJvbSBiZWluZwog ICAgIC8vIHJlY3ljbGVkIGJ5IHRoZSB0ZXh0dXJlIG1hbmFnZXIuCiAgICAgdm9pZCBwcm90ZWN0 VGlsZVRleHR1cmVzKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KTsKQEAgLTg1LDkgKzg3LDEz IEBAIHByaXZhdGU6CiAKICAgICBUZXh0dXJlTWFuYWdlciogdGV4dHVyZU1hbmFnZXIoKSBjb25z dDsKIAotICAgIC8vIFN0YXRlIGhlbGQgYmV0d2VlbiB1cGRhdGUgYW5kIHVwbG9hZC4KKyAgICAv LyBUaGUgb3JpZ2luYWwgcmVjdCB0aGF0IGluZGljYXRlcyB3aGF0IHNob3VsZCBiZSBwYWludGVk CisgICAgLy8gVGhpcyByZWN0IGlzIHRlbXBvcmFyeSBzdGF0ZSwgaGVsZCBiZXR3ZWVuIHBhaW50 aW5nIChpbiBwcmVwYXJlVG9VcGRhdGUpIGFuZCB1cGRhdGluZyAoaW4gdXBkYXRlQ29tcG9zaXRv clJlc291cmNlcykKKyAgICBJbnRSZWN0IG1fY29udGVudFRvUGFpbnQ7CisKKyAgICAvLyBUaGUg YWN0dWFsIHJlY3QgdGhhdCBpcyBwYWludGVkLiBUaGlzIG1heSBiZSBsYXJnZXIgdGhhbiBjb250 ZW50VG9QYWludCwgYmVjYXVzZSBvZiB0aWxpbmcuCisgICAgLy8gQ3VycmVudGx5LCBpdCBpcyBh bHNvIHRoZSBzYW1lIGFzIHRoZSB1cGRhdGVSZWN0ICh0aGUgcmVnaW9uIHRoYXQgaXMgdXBkYXRl ZCBpbiB0aGUgY29tcG9zaXRvciByZXNvdXJjZXMpCiAgICAgSW50UmVjdCBtX3BhaW50UmVjdDsK LSAgICBJbnRSZWN0IG1fdXBkYXRlUmVjdDsKIAogICAgIC8vIFRpZ2h0bHkgcGFja2VkIHNldCBv ZiB1bnVzZWQgdGlsZXMuCiAgICAgVmVjdG9yPFJlZlB0cjxVcGRhdGFibGVUaWxlPiA+IG1fdW51 c2VkVGlsZXM7Cg== 110258 2011-10-07 22:39:30 -0700 2011-10-10 16:44:16 -0700 Patch bug-69441-20111007223929.patch text/plain 10903 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTY4NTMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1MTA1NWJhMjE5N2IzMDBi NGI0N2M5YmUxNWI0MDc5OTBlNTgzODkxLi44NjM0NzllZjEwYmVjODhmZmRhN2VmYmMzNGJhMWU3 N2U0NTA3ZThlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTEtMTAtMDcgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBU cmFja2luZyBwYWludCByZWN0cyBhbmQgdXBkYXRlIHJlY3RzIGluIExheWVyQ2hyb21pdW0uCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02OTQ0MQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2gg ZG9lcyBub3QgZG8gbXVjaCBvbiBpdHMgb3duLCBidXQgaXMganVzdCBwYXJ0IDEgb2YgYQorICAg ICAgICBzdHJpbmcgb2Ygb3RoZXIgcGF0Y2hlcyB3aGljaCB3aWxsIHVzZSB0aGVzZSByZWN0cyBm b3IKKyAgICAgICAgdmlzdWFsaXphdGlvbiBhbmQgc2Npc3NvcmluZy4gIFRoZSBhcHByb3ByaWF0 ZSB0ZXN0aW5nIHdpbGwgYmUKKyAgICAgICAgYXNzb2NpYXRlZCB3aXRoIHRob3NlIHBhdGNoZXMu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hy b21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzMkRMYXllckNocm9taXVtOjp1cGRh dGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyQ2hyb21pdW06 OnJlc2V0UGFpbnRBbmRVcGRhdGVSZWN0cyk6CisgICAgICAgIChXZWJDb3JlOjpMYXllckNocm9t aXVtOjpwdXNoUHJvcGVydGllc1RvKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllckNocm9taXVtLmg6CisgICAgICAgIChXZWJDb3JlOjpMYXllckNocm9taXVtOjpk aXJ0eVJlY3QpOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJDaHJvbWl1bTo6cGFpbnRSZWN0KToK KyAgICAgICAgKFdlYkNvcmU6OkxheWVyQ2hyb21pdW06OnVwZGF0ZVJlY3QpOgorICAgICAgICAq IHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJjZXMpOgorICAg ICAgICAoV2ViQ29yZTo6VGlsZWRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3Vy Y2VzKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBk YXRlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hy b21pdW0uaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVy Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VmlkZW9MYXllckNocm9taXVtOjp1cGRh dGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViR0xMYXll ckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKwogMjAxMS0xMC0wNiAgR2F2 aW4gUGV0ZXJzICA8Z2F2aW5wQGNocm9taXVtLm9yZz4KIAogICAgICAgICBjb25kaXRpb25hbGl6 ZSBtX2NhY2hlZFNjcmlwdCBzdGFja3MgdG8ganVzdCBDaHJvbWl1bSBwb3J0CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVy Q2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Q2FudmFzMkRMYXllckNocm9taXVtLmNwcAppbmRleCAwZTBkYTgwNGI2MWQ2NDY1ZjQxNDJlY2E3 YmEyNzEzY2E1NzViYjhkLi5mODU2ZjEzYjg5Y2EzM2UxMjlmNzM2ODg3N2ZhNjYzZjFkMjhlMzNh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9D YW52YXMyRExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTc5LDYgKzc5LDgg QEAgdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMo R3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXIKICNlbmRpZgogICAgICAgICBtX2NvbnRleHQtPmZs dXNoKCk7CiAgICAgfQorCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KEZsb2F0UG9pbnQ6 Onplcm8oKSwgYm91bmRzKCkpOwogICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiB9CiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hy b21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJDaHJvbWl1bS5jcHAKaW5kZXggZmUyY2Q0ZWIxNWRmNGRkM2ZmNjE3MGI2YWFjZGRlMGU5MGQz MmEzOC4uMDk3ODJkNjEwZmY4ZjM5YTRkMTFkYmFmYjVjNjNjOGFjOThjMGQwMyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1 bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5 ZXJDaHJvbWl1bS5jcHAKQEAgLTI3Niw2ICsyNzYsMTIgQEAgdm9pZCBMYXllckNocm9taXVtOjpy ZXNldE5lZWRzRGlzcGxheSgpCiAgICAgbV9kaXJ0eVJlY3QgPSBGbG9hdFJlY3QoKTsKIH0KIAor dm9pZCBMYXllckNocm9taXVtOjpyZXNldFBhaW50QW5kVXBkYXRlUmVjdHMoKQoreworICAgIG1f cGFpbnRSZWN0ID0gSW50UmVjdCgpOworICAgIG1fdXBkYXRlUmVjdCA9IEZsb2F0UmVjdCgpOwor fQorCiB2b2lkIExheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8oQ0NMYXllckltcGwqIGxh eWVyKQogewogICAgIGxheWVyLT5zZXRBbmNob3JQb2ludChtX2FuY2hvclBvaW50KTsKQEAgLTMw MSw2ICszMDcsOCBAQCB2b2lkIExheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8oQ0NMYXll ckltcGwqIGxheWVyKQogICAgICAgICBtYXNrTGF5ZXIoKS0+cHVzaFByb3BlcnRpZXNUbyhsYXll ci0+bWFza0xheWVyKCkpOwogICAgIGlmIChyZXBsaWNhTGF5ZXIoKSkKICAgICAgICAgcmVwbGlj YUxheWVyKCktPnB1c2hQcm9wZXJ0aWVzVG8obGF5ZXItPnJlcGxpY2FMYXllcigpKTsKKworICAg IHJlc2V0UGFpbnRBbmRVcGRhdGVSZWN0cygpOwogfQogCiBQYXNzUmVmUHRyPENDTGF5ZXJJbXBs PiBMYXllckNocm9taXVtOjpjcmVhdGVDQ0xheWVySW1wbCgpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKaW5k ZXggYmUwZTc5NjA2YmIyOTNiYzAwZmIzZmU4ZGQyZjI1ZTYzNmQ4ZGJkOS4uMDA4ZWY3MzFmOTE5 MWVkMWExMTBjZDM3YWY0MjMxZmIzZjI1ZjhmOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uaApAQCAtMTA2 LDkgKzEwNiwxMyBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHNldE5lZWRzRGlzcGxheShjb25zdCBG bG9hdFJlY3QmIGRpcnR5UmVjdCk7CiAgICAgdm9pZCBzZXROZWVkc0Rpc3BsYXkoKTsKLSAgICBj b25zdCBGbG9hdFJlY3QmIGRpcnR5UmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fZGlydHlSZWN0OyB9 CiAgICAgdm9pZCByZXNldE5lZWRzRGlzcGxheSgpOwogCisgICAgY29uc3QgRmxvYXRSZWN0JiBk aXJ0eVJlY3QoKSBjb25zdCB7IHJldHVybiBtX2RpcnR5UmVjdDsgfQorICAgIGNvbnN0IEludFJl Y3QmIHBhaW50UmVjdCgpIGNvbnN0IHsgcmV0dXJuIG1fcGFpbnRSZWN0OyB9CisgICAgY29uc3Qg RmxvYXRSZWN0JiB1cGRhdGVSZWN0KCkgY29uc3QgeyByZXR1cm4gbV91cGRhdGVSZWN0OyB9Cisg ICAgdm9pZCByZXNldFBhaW50QW5kVXBkYXRlUmVjdHMoKTsKKwogICAgIHZvaWQgc2V0T3BhY2l0 eShmbG9hdCBvcGFjaXR5KSB7IG1fb3BhY2l0eSA9IG9wYWNpdHk7IHNldE5lZWRzQ29tbWl0KCk7 IH0KICAgICBmbG9hdCBvcGFjaXR5KCkgY29uc3QgeyByZXR1cm4gbV9vcGFjaXR5OyB9CiAKQEAg LTIwOCw3ICsyMTIsMTYgQEAgcHJvdGVjdGVkOgogICAgIC8vIGhvbGQgY29udGV4dC1kZXBlbmRl bnQgcmVzb3VyY2VzIHN1Y2ggYXMgdGV4dHVyZXMuCiAgICAgdmlydHVhbCB2b2lkIGNsZWFudXBS ZXNvdXJjZXMoKTsKIAorICAgIC8vIFRoZSBkaXJ0eSByZWN0IGlzIHRoZSB1bmlvbiBvZiBkYW1h Z2VkIHJlZ2lvbnMgdGhhdCBuZWVkIHJlcGFpbnRpbmcvdXBkYXRpbmcuCiAgICAgRmxvYXRSZWN0 IG1fZGlydHlSZWN0OworICAgIC8vIFRoZSBwYWludCByZWN0IGlzIHRoZSByZWdpb24gdGhhdCBp cyBhY3R1YWxseSByZXBhaW50ZWQgKmJ5IHRoZSBjb21wb3NpdG9yKi4gVGhpcyBjb3VsZCBiZSBs YXJnZXIgb3Igc21hbGxlciB0aGFuIHdoYXQgd2FzIG1hcmtlZCBhcyBkaXJ0eS4KKyAgICAvLyBG b3IgbGF5ZXJzIHRoYXQgbWF5IGRvIHBhaW50aW5nIG91dHNpZGUgb2YgdGhlIGNvbXBvc2l0b3In cyBjb250cm9sIChzdWNoIGFzIHdlYkdMIG9yIHBsdWdpbnMpLCB0aGlzIGluZm9ybWF0aW9uIGlz IG5vdCBhdmFpbGFibGUgYW5kIHRoZSBwYWludAorICAgIC8vIHJlY3Qgd2lsbCByZW1haW4gZW1w dHkuCisgICAgSW50UmVjdCBtX3BhaW50UmVjdDsKKyAgICAvLyBUaGUgdXBkYXRlIHJlY3QgaXMg dGhlIHJlZ2lvbiBvZiBjb21wb3NpdG9yIHJlc291cmNlIHRoYXQgd2FzIGFjdHVhbGx5IHVwZGF0 ZWQgKmJ5IHRoZSBjb21wb3NpdG9yKi4gSXQgaXMgbm90IG5lY2Vzc2FyaWx5IHRoZSBzYW1lIGFz CisgICAgLy8gdGhlIHBhaW50IHJlY3QsIGJ1dCBpcyBvZnRlbiB0aGUgc2FtZS4gRm9yIGxheWVy cyB0aGF0IG1heSBkbyB1cGRhdGluZyBvdXRzaWRlIHRoZSBjb21wb3NpdG9yJ3MgY29udHJvbCAo c3VjaCBhcyBwbHVnaW5zKSwgdGhpcyBpbmZvcm1hdGlvbgorICAgIC8vIGlzIG5vdCBhdmFpbGFi bGUgYW5kIHRoZSB1cGRhdGUgcmVjdCB3aWxsIHJlbWFpbiBlbXB0eS4KKyAgICBGbG9hdFJlY3Qg bV91cGRhdGVSZWN0OwogCiAgICAgUmVmUHRyPExheWVyQ2hyb21pdW0+IG1fbWFza0xheWVyOwog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCBhZjQ5YzhjMGE0ZGFhYzU1NWY4 NzZhNDQxMzU0NjJiN2U0NTQxZGUwLi5iMjNiN2VjZjFkMmFlZjIzNjJkN2U0ZWI1ZjU0NWQ3YjA5 YWJiZmQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTg5LDcgKzg5LDcg QEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJjZXMoKQogICAgIG1fdGls ZXIuY2xlYXIoKTsKICAgICBtX3VudXNlZFRpbGVzLmNsZWFyKCk7CiAgICAgbV9wYWludFJlY3Qg PSBJbnRSZWN0KCk7Ci0gICAgbV91cGRhdGVSZWN0ID0gSW50UmVjdCgpOworICAgIG1fY29udGVu dFJlY3QgPSBJbnRSZWN0KCk7CiB9CiAKIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjp1cGRhdGVU aWxlU2l6ZUFuZFRpbGluZ09wdGlvbigpCkBAIC0xNTQsMTEgKzE1NCwxMyBAQCB2b2lkIFRpbGVk TGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3QqIGhvc3QpCiB2 b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGlj c0NvbnRleHQzRCogY29udGV4dCwgVGV4dHVyZUFsbG9jYXRvciogYWxsb2NhdG9yKQogewogICAg IC8vIFBhaW50aW5nIGNvdWxkIGNhdXNlIGNvbXBvc2l0aW5nIHRvIGdldCB0dXJuZWQgb2ZmLCB3 aGljaCBtYXkgY2F1c2UgdGhlIHRpbGVyIHRvIGJlY29tZSBpbnZhbGlkYXRlZCBtaWQtdXBkYXRl LgotICAgIGlmIChtX3NraXBzRHJhdyB8fCBtX3VwZGF0ZVJlY3QuaXNFbXB0eSgpIHx8ICFtX3Rp bGVyLT5udW1UaWxlcygpKQorICAgIGlmIChtX3NraXBzRHJhdyB8fCBtX2NvbnRlbnRSZWN0Lmlz RW1wdHkoKSB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSkKICAgICAgICAgcmV0dXJuOwogCisgICAg SW50UmVjdCB0b3RhbFVwZGF0ZWRDb250ZW50OworCiAgICAgaW50IGxlZnQsIHRvcCwgcmlnaHQs IGJvdHRvbTsKLSAgICBtX3RpbGVyLT5jb250ZW50UmVjdFRvVGlsZUluZGljZXMobV91cGRhdGVS ZWN0LCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b20pOworICAgIG1fdGlsZXItPmNvbnRlbnRSZWN0 VG9UaWxlSW5kaWNlcyhtX2NvbnRlbnRSZWN0LCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b20pOwog ICAgIGZvciAoaW50IGogPSB0b3A7IGogPD0gYm90dG9tOyArK2opIHsKICAgICAgICAgZm9yIChp bnQgaSA9IGxlZnQ7IGkgPD0gcmlnaHQ7ICsraSkgewogICAgICAgICAgICAgVXBkYXRhYmxlVGls ZSogdGlsZSA9IHRpbGVBdChpLCBqKTsKQEAgLTIwNCw5ICsyMDYsMTMgQEAgdm9pZCBUaWxlZExh eWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0Qq IGNvbnRleHQsIFQKICAgICAgICAgICAgIEdMQyhjb250ZXh0LCBjb250ZXh0LT5iaW5kVGV4dHVy ZShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgMCkpOwogCiAgICAgICAgICAgICB0ZXh0 dXJlVXBkYXRlcigpLT51cGRhdGVUZXh0dXJlUmVjdChjb250ZXh0LCBhbGxvY2F0b3IsIHRpbGUt PnRleHR1cmUoKSwgc291cmNlUmVjdCwgZGVzdFJlY3QpOworICAgICAgICAgICAgdG90YWxVcGRh dGVkQ29udGVudC51bml0ZShzb3VyY2VSZWN0KTsKICAgICAgICAgICAgIHRpbGUtPmNsZWFyRGly dHkoKTsKICAgICAgICAgfQogICAgIH0KKworICAgIC8vIEZJWE1FOiB3ZSBzaG91bGQgdmVyaWZ5 IHdoZXRoZXIgdGhlcmUgYXJlIHNwZWNpYWwgY2FzZXMgdGhhdCB0aGlzIGlzIGFjdHVhbGx5IGRp ZmZlcmVudCBmcm9tIEZsb2F0UmVjdChtX3BhaW50UmVjdCkuCisgICAgbV91cGRhdGVSZWN0ID0g RmxvYXRSZWN0KG1fdGlsZXItPmNvbnRlbnRSZWN0VG9MYXllclJlY3QodG90YWxVcGRhdGVkQ29u dGVudCkpOwogfQogCiB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6c2V0VGlsaW5nT3B0aW9uKFRp bGluZ09wdGlvbiB0aWxpbmdPcHRpb24pCkBAIC0zNDksNyArMzU1LDcgQEAgdm9pZCBUaWxlZExh eWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkK ICAgICBtX3NraXBzRHJhdyA9IGZhbHNlOwogCiAgICAgaWYgKGNvbnRlbnRSZWN0LmlzRW1wdHko KSkgewotICAgICAgICBtX3VwZGF0ZVJlY3QgPSBJbnRSZWN0KCk7CisgICAgICAgIG1fY29udGVu dFJlY3QgPSBJbnRSZWN0KCk7CiAgICAgICAgIHJldHVybjsKICAgICB9CiAKQEAgLTM1OSw3ICsz NjUsNyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlKGNvbnN0IElu dFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIG1fdGlsZXItPmdyb3dMYXllclRvQ29udGFpbihjb250 ZW50UmVjdCk7CiAKICAgICBpZiAoIW1fdGlsZXItPm51bVRpbGVzKCkpIHsKLSAgICAgICAgbV91 cGRhdGVSZWN0ID0gSW50UmVjdCgpOworICAgICAgICBtX2NvbnRlbnRSZWN0ID0gSW50UmVjdCgp OwogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC0zOTAsNyArMzk2LDcgQEAgdm9pZCBUaWxl ZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVj dCkKICAgICAvLyBEdWUgdG8gYm9yZGVycywgd2hlbiB0aGUgcGFpbnQgcmVjdCBpcyBleHRlbmRl ZCB0byB0aWxlIGJvdW5kYXJpZXMsIGl0CiAgICAgLy8gbWF5IGVuZCB1cCBvdmVybGFwcGluZyBt b3JlIHRpbGVzIHRoYW4gdGhlIG9yaWdpbmFsIGNvbnRlbnQgcmVjdC4gUmVjb3JkCiAgICAgLy8g dGhhdCBvcmlnaW5hbCByZWN0IHNvIHdlIGRvbid0IHVwbG9hZCBtb3JlIHRpbGVzIHRoYW4gbmVj ZXNzYXJ5LgotICAgIG1fdXBkYXRlUmVjdCA9IGNvbnRlbnRSZWN0OworICAgIG1fY29udGVudFJl Y3QgPSBjb250ZW50UmVjdDsKIAogICAgIG1fcGFpbnRSZWN0ID0gbV90aWxlci0+bGF5ZXJSZWN0 VG9Db250ZW50UmVjdChkaXJ0eUxheWVyUmVjdCk7CiAgICAgaWYgKGRpcnR5TGF5ZXJSZWN0Lmlz RW1wdHkoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKaW5kZXggMWU4NDk0YTliN2QzMmYy NjE3NzQyODAwMDhhNDVjODBmOWNiOTAzZC4uNWFlZGY3NDZhMTI2NTlkZTE4OTkwN2NkMjUyOWNm Yzg3NjViNDYyMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKQEAgLTg1LDkgKzg1LDgg QEAgcHJpdmF0ZToKIAogICAgIFRleHR1cmVNYW5hZ2VyKiB0ZXh0dXJlTWFuYWdlcigpIGNvbnN0 OwogCi0gICAgLy8gU3RhdGUgaGVsZCBiZXR3ZWVuIHVwZGF0ZSBhbmQgdXBsb2FkLgotICAgIElu dFJlY3QgbV9wYWludFJlY3Q7Ci0gICAgSW50UmVjdCBtX3VwZGF0ZVJlY3Q7CisgICAgLy8gVGhp cyByZWN0IGlzIHRlbXBvcmFyeSBzdGF0ZSBoZWxkIGJldHdlZW4gcHJlcGFyZVRvVXBkYXRlKCkg YW5kIHVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoKS4KKyAgICBJbnRSZWN0IG1fY29udGVudFJl Y3Q7CiAKICAgICAvLyBUaWdodGx5IHBhY2tlZCBzZXQgb2YgdW51c2VkIHRpbGVzLgogICAgIFZl Y3RvcjxSZWZQdHI8VXBkYXRhYmxlVGlsZT4gPiBtX3VudXNlZFRpbGVzOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9t aXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVv TGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggOGU5MjlkZDM2YWZhZTczZmJmNDE5OTM1MjQyNmY2ZjRm YzUwNTA5MC4uZjRjNjZjMmQyZTQzZTcwNjRiYWRjMjdiNmYxYTJmYzg5OThhMzZiZSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXll ckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCkBAIC0xMzYsNiArMTM2LDcgQEAgdm9pZCBWaWRl b0xheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0 M0QqIGNvbnRleHQsIFQKICAgICBtX3BsYW5lcyA9IGZyYW1lLT5wbGFuZXMoKTsKICAgICBBU1NF UlQobV9wbGFuZXMgPD0gTWF4UGxhbmVzKTsKIAorICAgIG1fdXBkYXRlUmVjdCA9IEZsb2F0UmVj dChGbG9hdFBvaW50Ojp6ZXJvKCksIGJvdW5kcygpKTsKICAgICByZXNldE5lZWRzRGlzcGxheSgp OwogCiAgICAgbV9wcm92aWRlci0+cHV0Q3VycmVudEZyYW1lKGZyYW1lKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJv bWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9XZWJH TExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDMyYmE2YTNiZWU1YTAyNGY1NWNjMDI3NjIyNTJiOTNi NTgwNGUwZTQuLjY1ZWY2NjI5ODczZmRhYjhhZGZjMmIzMmRiOTcyNjM0OTBiNzVhYzggMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5 ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcApAQCAtOTAsNiArOTAsNyBAQCB2b2lkIFdlYkdM TGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQz RCogcmVuZGVyZXJDbwogICAgICAgICAvLwogICAgICAgICBtX2NvbnRleHQtPnByZXBhcmVUZXh0 dXJlKCk7CiAgICAgICAgIG1fY29udGV4dC0+bWFya0xheWVyQ29tcG9zaXRlZCgpOworICAgICAg ICBtX3VwZGF0ZVJlY3QgPSBGbG9hdFJlY3QoRmxvYXRQb2ludDo6emVybygpLCBib3VuZHMoKSk7 CiAgICAgICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiAgICAgICAgIG1fdGV4dHVyZVVwZGF0ZWQg PSBmYWxzZTsKICAgICB9Cg== 110435 2011-10-10 16:44:20 -0700 2011-10-10 19:48:40 -0700 Patch bug-69441-20111010164419.patch text/plain 10465 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTcwNjAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAyZjdlYWQyOWFkODEyYTg2 MzlkOGE0MGU3M2IyZjNkZDdiNzAyNWI0Li5mNGI3N2NkMjcxYTZmOTZhYmM2OGJjOTJiODQxMDJk YmJlODdhZDVmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTEtMTAtMTAgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBU cmFja2luZyBwYWludCByZWN0cyBhbmQgdXBkYXRlIHJlY3RzIGluIExheWVyQ2hyb21pdW0uCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02OTQ0MQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2gg ZG9lcyBub3QgZG8gbXVjaCBvbiBpdHMgb3duLCBidXQgaXMganVzdCBwYXJ0IDEgb2YgYQorICAg ICAgICBzdHJpbmcgb2Ygb3RoZXIgcGF0Y2hlcyB3aGljaCB3aWxsIHVzZSB0aGVzZSByZWN0cyBm b3IKKyAgICAgICAgdmlzdWFsaXphdGlvbiBhbmQgc2Npc3NvcmluZy4gIFRoZSBhcHByb3ByaWF0 ZSB0ZXN0aW5nIHdpbGwgYmUKKyAgICAgICAgYXNzb2NpYXRlZCB3aXRoIHRob3NlIHBhdGNoZXMu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hy b21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzMkRMYXllckNocm9taXVtOjp1cGRh dGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyQ2hyb21pdW06 OnB1c2hQcm9wZXJ0aWVzVG8pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyQ2hyb21pdW0uaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aWxlZExheWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGlsZWRMYXllckNocm9t aXVtOjpjbGVhbnVwUmVzb3VyY2VzKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJv bWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisgICAgICAgIChXZWJDb3JlOjpUaWxl ZExheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8pOgorICAgICAgICAoV2ViQ29yZTo6VGls ZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpWaWRlb0xheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMpOgorICAg ICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpXZWJHTExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JS ZXNvdXJjZXMpOgorCiAyMDExLTEwLTEwICBDYXJ5IENsYXJrICA8Y2FyeWNsYXJrQGdvb2dsZS5j b20+CiAKICAgICAgICAgW1NraWEgb24gQ2hyb21pdW0gTWFjXSBTZXQgY2FuRXhwYW5kQXJvdW5k SWRlb2dyYXBoc0luQ29tcGxleFRleHQgdG8gdHJ1ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJD aHJvbWl1bS5jcHAKaW5kZXggMGUwZGE4MDRiNjFkNjQ2NWY0MTQyZWNhN2JhMjcxM2NhNTc1YmI4 ZC4uZjg1NmYxM2I4OWNhMzNlMTI5ZjczNjg4NzdmYTY2M2YxZDI4ZTMzYSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNo cm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwCkBAIC03OSw2ICs3OSw4IEBAIHZvaWQgQ2FudmFz MkRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4 dDNEKiwgVGV4dHVyCiAjZW5kaWYKICAgICAgICAgbV9jb250ZXh0LT5mbHVzaCgpOwogICAgIH0K KworICAgIG1fdXBkYXRlUmVjdCA9IEZsb2F0UmVjdChGbG9hdFBvaW50Ojp6ZXJvKCksIGJvdW5k cygpKTsKICAgICByZXNldE5lZWRzRGlzcGxheSgpOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uY3Bw CmluZGV4IGZlMmNkNGViMTVkZjRkZDNmZjYxNzBiNmFhY2RkZTBlOTBkMzJhMzguLjcwNDIzMWZh OTI0NDI4Yjk5MjE4ZWNlNmRhNWI1YTVkY2QwNDFkZGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uY3Bw CkBAIC0zMDEsNiArMzAxLDkgQEAgdm9pZCBMYXllckNocm9taXVtOjpwdXNoUHJvcGVydGllc1Rv KENDTGF5ZXJJbXBsKiBsYXllcikKICAgICAgICAgbWFza0xheWVyKCktPnB1c2hQcm9wZXJ0aWVz VG8obGF5ZXItPm1hc2tMYXllcigpKTsKICAgICBpZiAocmVwbGljYUxheWVyKCkpCiAgICAgICAg IHJlcGxpY2FMYXllcigpLT5wdXNoUHJvcGVydGllc1RvKGxheWVyLT5yZXBsaWNhTGF5ZXIoKSk7 CisKKyAgICAvLyBSZXNldCBhbnkgc3RhdGUgdGhhdCBzaG91bGQgYmUgY2xlYXJlZCBmb3IgdGhl IG5leHQgdXBkYXRlLgorICAgIG1fdXBkYXRlUmVjdCA9IEZsb2F0UmVjdCgpOwogfQogCiBQYXNz UmVmUHRyPENDTGF5ZXJJbXBsPiBMYXllckNocm9taXVtOjpjcmVhdGVDQ0xheWVySW1wbCgpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXll ckNocm9taXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9M YXllckNocm9taXVtLmgKaW5kZXggYmUwZTc5NjA2YmIyOTNiYzAwZmIzZmU4ZGQyZjI1ZTYzNmQ4 ZGJkOS4uMzNlYjI0MGY1NTFkMzNmYTYwMmM5YjJkYWQ3OTZmM2ZhNTRjMjIwOSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1 bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVy Q2hyb21pdW0uaApAQCAtMjA4LDggKzIwOCwxNCBAQCBwcm90ZWN0ZWQ6CiAgICAgLy8gaG9sZCBj b250ZXh0LWRlcGVuZGVudCByZXNvdXJjZXMgc3VjaCBhcyB0ZXh0dXJlcy4KICAgICB2aXJ0dWFs IHZvaWQgY2xlYW51cFJlc291cmNlcygpOwogCisgICAgLy8gVGhlIGRpcnR5IHJlY3QgaXMgdGhl IHVuaW9uIG9mIGRhbWFnZWQgcmVnaW9ucyB0aGF0IG5lZWQgcmVwYWludGluZy91cGRhdGluZy4K ICAgICBGbG9hdFJlY3QgbV9kaXJ0eVJlY3Q7CiAKKyAgICAvLyBUaGUgdXBkYXRlIHJlY3QgaXMg dGhlIHJlZ2lvbiBvZiB0aGUgY29tcG9zaXRvciByZXNvdXJjZSB0aGF0IHdhcyBhY3R1YWxseSB1 cGRhdGVkIGJ5IHRoZSBjb21wb3NpdG9yLgorICAgIC8vIEZvciBsYXllcnMgdGhhdCBtYXkgZG8g dXBkYXRpbmcgb3V0c2lkZSB0aGUgY29tcG9zaXRvcidzIGNvbnRyb2wgKGkuZS4gcGx1Z2luIGxh eWVycyksIHRoaXMgaW5mb3JtYXRpb24KKyAgICAvLyBpcyBub3QgYXZhaWxhYmxlIGFuZCB0aGUg dXBkYXRlIHJlY3Qgd2lsbCByZW1haW4gZW1wdHkuCisgICAgRmxvYXRSZWN0IG1fdXBkYXRlUmVj dDsKKwogICAgIFJlZlB0cjxMYXllckNocm9taXVtPiBtX21hc2tMYXllcjsKIAogICAgIGZyaWVu ZCBjbGFzcyBUcmVlU3luY2hyb25pemVyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAK aW5kZXggYWY0OWM4YzBhNGRhYWM1NTVmODc2YTQ0MTM1NDYyYjdlNDU0MWRlMC4uOWQ3ZGZiYWYy MDZlM2Y3ZThjYjgyNTgxZjQ5ZjYxOTEwZDQyOTliYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hy b21pdW0uY3BwCkBAIC04OSw3ICs4OSw3IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpjbGVh bnVwUmVzb3VyY2VzKCkKICAgICBtX3RpbGVyLmNsZWFyKCk7CiAgICAgbV91bnVzZWRUaWxlcy5j bGVhcigpOwogICAgIG1fcGFpbnRSZWN0ID0gSW50UmVjdCgpOwotICAgIG1fdXBkYXRlUmVjdCA9 IEludFJlY3QoKTsKKyAgICBtX2NvbnRlbnRSZWN0ID0gSW50UmVjdCgpOwogfQogCiB2b2lkIFRp bGVkTGF5ZXJDaHJvbWl1bTo6dXBkYXRlVGlsZVNpemVBbmRUaWxpbmdPcHRpb24oKQpAQCAtMTU0 LDExICsxNTQsMTMgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnNldExheWVyVHJlZUhvc3Qo Q0NMYXllclRyZWVIb3N0KiBob3N0KQogdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnVwZGF0ZUNv bXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFRleHR1cmVBbGxv Y2F0b3IqIGFsbG9jYXRvcikKIHsKICAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21wb3Np dGluZyB0byBnZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBiZWNv bWUgaW52YWxpZGF0ZWQgbWlkLXVwZGF0ZS4KLSAgICBpZiAobV9za2lwc0RyYXcgfHwgbV91cGRh dGVSZWN0LmlzRW1wdHkoKSB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSkKKyAgICBpZiAobV9za2lw c0RyYXcgfHwgbV9jb250ZW50UmVjdC5pc0VtcHR5KCkgfHwgIW1fdGlsZXItPm51bVRpbGVzKCkp CiAgICAgICAgIHJldHVybjsKIAorICAgIEludFJlY3QgdG90YWxVcGRhdGVkQ29udGVudDsKKwog ICAgIGludCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b207Ci0gICAgbV90aWxlci0+Y29udGVudFJl Y3RUb1RpbGVJbmRpY2VzKG1fdXBkYXRlUmVjdCwgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tKTsK KyAgICBtX3RpbGVyLT5jb250ZW50UmVjdFRvVGlsZUluZGljZXMobV9jb250ZW50UmVjdCwgbGVm dCwgdG9wLCByaWdodCwgYm90dG9tKTsKICAgICBmb3IgKGludCBqID0gdG9wOyBqIDw9IGJvdHRv bTsgKytqKSB7CiAgICAgICAgIGZvciAoaW50IGkgPSBsZWZ0OyBpIDw9IHJpZ2h0OyArK2kpIHsK ICAgICAgICAgICAgIFVwZGF0YWJsZVRpbGUqIHRpbGUgPSB0aWxlQXQoaSwgaik7CkBAIC0yMDQs OSArMjA2LDEzIEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVz b3VyY2VzKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0LCBUCiAgICAgICAgICAgICBHTEMoY29u dGV4dCwgY29udGV4dC0+YmluZFRleHR1cmUoR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQs IDApKTsKIAogICAgICAgICAgICAgdGV4dHVyZVVwZGF0ZXIoKS0+dXBkYXRlVGV4dHVyZVJlY3Qo Y29udGV4dCwgYWxsb2NhdG9yLCB0aWxlLT50ZXh0dXJlKCksIHNvdXJjZVJlY3QsIGRlc3RSZWN0 KTsKKyAgICAgICAgICAgIHRvdGFsVXBkYXRlZENvbnRlbnQudW5pdGUoc291cmNlUmVjdCk7CiAg ICAgICAgICAgICB0aWxlLT5jbGVhckRpcnR5KCk7CiAgICAgICAgIH0KICAgICB9CisKKyAgICAv LyBGSVhNRTogUHJvdmUvZGlzcHJvdmUgd2hldGhlciB0b3RhbFVwZGF0ZWRDb250ZW50IHdpbGwg YWx3YXlzIGJlIHRoZSBzYW1lIGFzIG1fcGFpbnQuIEZvciBub3csIGFzc3VtaW5nIGl0cyBub3Qu CisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KG1fdGlsZXItPmNvbnRlbnRSZWN0VG9MYXll clJlY3QodG90YWxVcGRhdGVkQ29udGVudCkpOwogfQogCiB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1 bTo6c2V0VGlsaW5nT3B0aW9uKFRpbGluZ09wdGlvbiB0aWxpbmdPcHRpb24pCkBAIC0yNDQsNiAr MjUwLDkgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8oQ0NMYXll ckltcGwqIGxheWVyKQogCiAgICAgICAgIHRpbGVkTGF5ZXItPnN5bmNUZXh0dXJlSWQoaSwgaiwg dGlsZS0+dGV4dHVyZSgpLT50ZXh0dXJlSWQoKSk7CiAgICAgfQorCisgICAgLy8gUmVzZXQgYW55 IHN0YXRlIHRoYXQgc2hvdWxkIGJlIGNsZWFyZWQgZm9yIHRoZSBuZXh0IHVwZGF0ZS4KKyAgICBt X3BhaW50UmVjdCA9IEludFJlY3QoKTsKIH0KIAogVGV4dHVyZU1hbmFnZXIqIFRpbGVkTGF5ZXJD aHJvbWl1bTo6dGV4dHVyZU1hbmFnZXIoKSBjb25zdApAQCAtMzQ5LDcgKzM1OCw3IEBAIHZvaWQg VGlsZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUoY29uc3QgSW50UmVjdCYgY29udGVu dFJlY3QpCiAgICAgbV9za2lwc0RyYXcgPSBmYWxzZTsKIAogICAgIGlmIChjb250ZW50UmVjdC5p c0VtcHR5KCkpIHsKLSAgICAgICAgbV91cGRhdGVSZWN0ID0gSW50UmVjdCgpOworICAgICAgICBt X2NvbnRlbnRSZWN0ID0gSW50UmVjdCgpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC0z NTksNyArMzY4LDcgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShj b25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkKICAgICBtX3RpbGVyLT5ncm93TGF5ZXJUb0NvbnRh aW4oY29udGVudFJlY3QpOwogCiAgICAgaWYgKCFtX3RpbGVyLT5udW1UaWxlcygpKSB7Ci0gICAg ICAgIG1fdXBkYXRlUmVjdCA9IEludFJlY3QoKTsKKyAgICAgICAgbV9jb250ZW50UmVjdCA9IElu dFJlY3QoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApAQCAtMzkwLDcgKzM5OSw3IEBAIHZv aWQgVGlsZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUoY29uc3QgSW50UmVjdCYgY29u dGVudFJlY3QpCiAgICAgLy8gRHVlIHRvIGJvcmRlcnMsIHdoZW4gdGhlIHBhaW50IHJlY3QgaXMg ZXh0ZW5kZWQgdG8gdGlsZSBib3VuZGFyaWVzLCBpdAogICAgIC8vIG1heSBlbmQgdXAgb3Zlcmxh cHBpbmcgbW9yZSB0aWxlcyB0aGFuIHRoZSBvcmlnaW5hbCBjb250ZW50IHJlY3QuIFJlY29yZAog ICAgIC8vIHRoYXQgb3JpZ2luYWwgcmVjdCBzbyB3ZSBkb24ndCB1cGxvYWQgbW9yZSB0aWxlcyB0 aGFuIG5lY2Vzc2FyeS4KLSAgICBtX3VwZGF0ZVJlY3QgPSBjb250ZW50UmVjdDsKKyAgICBtX2Nv bnRlbnRSZWN0ID0gY29udGVudFJlY3Q7CiAKICAgICBtX3BhaW50UmVjdCA9IG1fdGlsZXItPmxh eWVyUmVjdFRvQ29udGVudFJlY3QoZGlydHlMYXllclJlY3QpOwogICAgIGlmIChkaXJ0eUxheWVy UmVjdC5pc0VtcHR5KCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCmluZGV4IDFlODQ5NGE5 YjdkMzJmMjYxNzc0MjgwMDA4YTQ1YzgwZjljYjkwM2QuLjMzZGNiYTg2ZGE1MTYwNjFhNjQ5OTZm MDBlOTY3YTdkYWJhNDQ4MTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCkBAIC02Nyw4 ICs2Nyw3IEBAIHByb3RlY3RlZDoKICAgICB2b2lkIGludmFsaWRhdGVSZWN0KGNvbnN0IEludFJl Y3QmIGNvbnRlbnRSZWN0KTsKICAgICAvLyBQcmVwYXJlIGRhdGEgbmVlZGVkIHRvIHVwZGF0ZSB0 ZXh0dXJlcyB0aGF0IGludGVyc2VjdCB3aXRoIGNvbnRlbnRSZWN0LgogICAgIHZvaWQgcHJlcGFy ZVRvVXBkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KTsKLSAgICAvLyBVcGRhdGUgaW52 YWxpZCB0ZXh0dXJlcyB0aGF0IGludGVyc2VjdCB3aXRoIGNvbnRlbnRSZWN0IHByb3ZpZGVkIGlu IHByZXBhcmVUb1VwZGF0ZSgpLgotICAgIHZvaWQgdXBkYXRlUmVjdChHcmFwaGljc0NvbnRleHQz RCosIExheWVyVGV4dHVyZVVwZGF0ZXIqKTsKKwogICAgIHZpcnR1YWwgdm9pZCBwcm90ZWN0Vmlz aWJsZVRpbGVUZXh0dXJlcygpOwogCiBwcml2YXRlOgpAQCAtODUsOSArODQsMTEgQEAgcHJpdmF0 ZToKIAogICAgIFRleHR1cmVNYW5hZ2VyKiB0ZXh0dXJlTWFuYWdlcigpIGNvbnN0OwogCi0gICAg Ly8gU3RhdGUgaGVsZCBiZXR3ZWVuIHVwZGF0ZSBhbmQgdXBsb2FkLgorICAgIC8vIFRlbXBvcmFy eSBzdGF0ZSBoZWxkIGJldHdlZW4gcHJlcGFyZVRvVXBkYXRlKCkgYW5kIHVwZGF0ZUNvbXBvc2l0 b3JSZXNvdXJjZXMoKS4KKyAgICBJbnRSZWN0IG1fY29udGVudFJlY3Q7CisgICAgLy8gU3RhdGUg aGVsZCBiZXR3ZWVuIHByZXBhcmVUb1VwZGF0ZSgpIGFuZCBwdXNoUHJvcGVydGllc1RvKCkuIFRo aXMgcmVwcmVzZW50cyB0aGUgYXJlYQorICAgIC8vIG9mIHRoZSBsYXllciB0aGF0IGlzIGFjdHVh bGx5IHJlLXBhaW50ZWQgYnkgV2ViS2l0LgogICAgIEludFJlY3QgbV9wYWludFJlY3Q7Ci0gICAg SW50UmVjdCBtX3VwZGF0ZVJlY3Q7CiAKICAgICAvLyBUaWdodGx5IHBhY2tlZCBzZXQgb2YgdW51 c2VkIHRpbGVzLgogICAgIFZlY3RvcjxSZWZQdHI8VXBkYXRhYmxlVGlsZT4gPiBtX3VudXNlZFRp bGVzOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vVmlkZW9MYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggOGU5MjlkZDM2YWZhZTcz ZmJmNDE5OTM1MjQyNmY2ZjRmYzUwNTA5MC4uZjRjNjZjMmQyZTQzZTcwNjRiYWRjMjdiNmYxYTJm Yzg5OThhMzZiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCkBAIC0xMzYsNiAr MTM2LDcgQEAgdm9pZCBWaWRlb0xheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJj ZXMoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFQKICAgICBtX3BsYW5lcyA9IGZyYW1lLT5w bGFuZXMoKTsKICAgICBBU1NFUlQobV9wbGFuZXMgPD0gTWF4UGxhbmVzKTsKIAorICAgIG1fdXBk YXRlUmVjdCA9IEZsb2F0UmVjdChGbG9hdFBvaW50Ojp6ZXJvKCksIGJvdW5kcygpKTsKICAgICBy ZXNldE5lZWRzRGlzcGxheSgpOwogCiAgICAgbV9wcm92aWRlci0+cHV0Q3VycmVudEZyYW1lKGZy YW1lKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDMyYmE2YTNiZWU1YTAy NGY1NWNjMDI3NjIyNTJiOTNiNTgwNGUwZTQuLjY1ZWY2NjI5ODczZmRhYjhhZGZjMmIzMmRiOTcy NjM0OTBiNzVhYzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcApAQCAtOTAsNiAr OTAsNyBAQCB2b2lkIFdlYkdMTGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNl cyhHcmFwaGljc0NvbnRleHQzRCogcmVuZGVyZXJDbwogICAgICAgICAvLwogICAgICAgICBtX2Nv bnRleHQtPnByZXBhcmVUZXh0dXJlKCk7CiAgICAgICAgIG1fY29udGV4dC0+bWFya0xheWVyQ29t cG9zaXRlZCgpOworICAgICAgICBtX3VwZGF0ZVJlY3QgPSBGbG9hdFJlY3QoRmxvYXRQb2ludDo6 emVybygpLCBib3VuZHMoKSk7CiAgICAgICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiAgICAgICAg IG1fdGV4dHVyZVVwZGF0ZWQgPSBmYWxzZTsKICAgICB9Cg== 110463 2011-10-10 19:48:46 -0700 2011-10-14 17:41:21 -0700 Patch bug-69441-20111010194845.patch text/plain 11109 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTcwNjAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAyZjdlYWQyOWFkODEyYTg2 MzlkOGE0MGU3M2IyZjNkZDdiNzAyNWI0Li4xMWY1MzE1YTBhNTZmZjNhMDM2MTAzNmNiZGY5ZDQ0 ZTg1MmNhYTAzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTEtMTAtMTAgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBU cmFja2luZyB1cGRhdGUgcmVjdHMgaW4gTGF5ZXJDaHJvbWl1bS4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY5NDQxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBwYXRjaCBkb2VzIG5vdCBkbyBtdWNo IG9uIGl0cyBvd24sIGJ1dCBpcyBqdXN0IHBhcnQgMSBvZiBhCisgICAgICAgIHN0cmluZyBvZiBv dGhlciBwYXRjaGVzIHdoaWNoIHdpbGwgdXNlIHRoZXNlIHJlY3RzIGZvcgorICAgICAgICB2aXN1 YWxpemF0aW9uIGFuZCBzY2lzc29yaW5nLiAgVGhlIGFwcHJvcHJpYXRlIHRlc3Rpbmcgd2lsbCBi ZQorICAgICAgICBhc3NvY2lhdGVkIHdpdGggdGhvc2UgcGF0Y2hlcy4KKworICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpDYW52YXMyRExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNv dXJjZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21p dW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJDaHJvbWl1bTo6cHVzaFByb3BlcnRpZXNU byk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5o OgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1 bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNv dXJjZXMpOgorICAgICAgICAoV2ViQ29yZTo6VGlsZWRMYXllckNocm9taXVtOjp1cGRhdGVDb21w b3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6 cHVzaFByb3BlcnRpZXNUbyk6CisgICAgICAgIChXZWJDb3JlOjpUaWxlZExheWVyQ2hyb21pdW06 OnByZXBhcmVUb1VwZGF0ZSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v VGlsZWRMYXllckNocm9taXVtLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vVmlkZW9MYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlZpZGVvTGF5ZXJD aHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OldlYkdMTGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisKIDIw MTEtMTAtMTAgIENhcnkgQ2xhcmsgIDxjYXJ5Y2xhcmtAZ29vZ2xlLmNvbT4KIAogICAgICAgICBb U2tpYSBvbiBDaHJvbWl1bSBNYWNdIFNldCBjYW5FeHBhbmRBcm91bmRJZGVvZ3JhcGhzSW5Db21w bGV4VGV4dCB0byB0cnVlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcAppbmRl eCAwZTBkYTgwNGI2MWQ2NDY1ZjQxNDJlY2E3YmEyNzEzY2E1NzViYjhkLi5mODU2ZjEzYjg5Y2Ez M2UxMjlmNzM2ODg3N2ZhNjYzZjFkMjhlMzNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJD aHJvbWl1bS5jcHAKQEAgLTc5LDYgKzc5LDggQEAgdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06 OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXIKICNl bmRpZgogICAgICAgICBtX2NvbnRleHQtPmZsdXNoKCk7CiAgICAgfQorCisgICAgbV91cGRhdGVS ZWN0ID0gRmxvYXRSZWN0KEZsb2F0UG9pbnQ6Onplcm8oKSwgYm91bmRzKCkpOwogICAgIHJlc2V0 TmVlZHNEaXNwbGF5KCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggZmUyY2Q0ZWIx NWRmNGRkM2ZmNjE3MGI2YWFjZGRlMGU5MGQzMmEzOC4uNzA0MjMxZmE5MjQ0MjhiOTkyMThlY2U2 ZGE1YjVhNWRjZDA0MWRkZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTMwMSw2ICszMDEs OSBAQCB2b2lkIExheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8oQ0NMYXllckltcGwqIGxh eWVyKQogICAgICAgICBtYXNrTGF5ZXIoKS0+cHVzaFByb3BlcnRpZXNUbyhsYXllci0+bWFza0xh eWVyKCkpOwogICAgIGlmIChyZXBsaWNhTGF5ZXIoKSkKICAgICAgICAgcmVwbGljYUxheWVyKCkt PnB1c2hQcm9wZXJ0aWVzVG8obGF5ZXItPnJlcGxpY2FMYXllcigpKTsKKworICAgIC8vIFJlc2V0 IGFueSBzdGF0ZSB0aGF0IHNob3VsZCBiZSBjbGVhcmVkIGZvciB0aGUgbmV4dCB1cGRhdGUuCisg ICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KCk7CiB9CiAKIFBhc3NSZWZQdHI8Q0NMYXllcklt cGw+IExheWVyQ2hyb21pdW06OmNyZWF0ZUNDTGF5ZXJJbXBsKCkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uaApp bmRleCBiZTBlNzk2MDZiYjI5M2JjMDBmYjNmZThkZDJmMjVlNjM2ZDhkYmQ5Li4zM2ViMjQwZjU1 MWQzM2ZhNjAyYzliMmRhZDc5NmYzZmE1NGMyMjA5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oCkBAIC0y MDgsOCArMjA4LDE0IEBAIHByb3RlY3RlZDoKICAgICAvLyBob2xkIGNvbnRleHQtZGVwZW5kZW50 IHJlc291cmNlcyBzdWNoIGFzIHRleHR1cmVzLgogICAgIHZpcnR1YWwgdm9pZCBjbGVhbnVwUmVz b3VyY2VzKCk7CiAKKyAgICAvLyBUaGUgZGlydHkgcmVjdCBpcyB0aGUgdW5pb24gb2YgZGFtYWdl ZCByZWdpb25zIHRoYXQgbmVlZCByZXBhaW50aW5nL3VwZGF0aW5nLgogICAgIEZsb2F0UmVjdCBt X2RpcnR5UmVjdDsKIAorICAgIC8vIFRoZSB1cGRhdGUgcmVjdCBpcyB0aGUgcmVnaW9uIG9mIHRo ZSBjb21wb3NpdG9yIHJlc291cmNlIHRoYXQgd2FzIGFjdHVhbGx5IHVwZGF0ZWQgYnkgdGhlIGNv bXBvc2l0b3IuCisgICAgLy8gRm9yIGxheWVycyB0aGF0IG1heSBkbyB1cGRhdGluZyBvdXRzaWRl IHRoZSBjb21wb3NpdG9yJ3MgY29udHJvbCAoaS5lLiBwbHVnaW4gbGF5ZXJzKSwgdGhpcyBpbmZv cm1hdGlvbgorICAgIC8vIGlzIG5vdCBhdmFpbGFibGUgYW5kIHRoZSB1cGRhdGUgcmVjdCB3aWxs IHJlbWFpbiBlbXB0eS4KKyAgICBGbG9hdFJlY3QgbV91cGRhdGVSZWN0OworCiAgICAgUmVmUHRy PExheWVyQ2hyb21pdW0+IG1fbWFza0xheWVyOwogCiAgICAgZnJpZW5kIGNsYXNzIFRyZWVTeW5j aHJvbml6ZXI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCBhZjQ5YzhjMGE0 ZGFhYzU1NWY4NzZhNDQxMzU0NjJiN2U0NTQxZGUwLi4wYTBkMDg4NTBjOTIyZGY5MjhhYjgwMGFm MzNjODQ3NjMwNDQ5YTY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTg5 LDcgKzg5LDcgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJjZXMoKQog ICAgIG1fdGlsZXIuY2xlYXIoKTsKICAgICBtX3VudXNlZFRpbGVzLmNsZWFyKCk7CiAgICAgbV9w YWludFJlY3QgPSBJbnRSZWN0KCk7Ci0gICAgbV91cGRhdGVSZWN0ID0gSW50UmVjdCgpOworICAg IG1fdmlzaWJsZUNvbnRlbnRSZWN0ID0gSW50UmVjdCgpOwogfQogCiB2b2lkIFRpbGVkTGF5ZXJD aHJvbWl1bTo6dXBkYXRlVGlsZVNpemVBbmRUaWxpbmdPcHRpb24oKQpAQCAtMTU0LDExICsxNTQs MTEgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnNldExheWVyVHJlZUhvc3QoQ0NMYXllclRy ZWVIb3N0KiBob3N0KQogdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JS ZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFRleHR1cmVBbGxvY2F0b3IqIGFs bG9jYXRvcikKIHsKICAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21wb3NpdGluZyB0byBn ZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBiZWNvbWUgaW52YWxp ZGF0ZWQgbWlkLXVwZGF0ZS4KLSAgICBpZiAobV9za2lwc0RyYXcgfHwgbV91cGRhdGVSZWN0Lmlz RW1wdHkoKSB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSkKKyAgICBpZiAobV9za2lwc0RyYXcgfHwg bV92aXNpYmxlQ29udGVudFJlY3QuaXNFbXB0eSgpIHx8ICFtX3RpbGVyLT5udW1UaWxlcygpKQog ICAgICAgICByZXR1cm47CiAKICAgICBpbnQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tOwotICAg IG1fdGlsZXItPmNvbnRlbnRSZWN0VG9UaWxlSW5kaWNlcyhtX3VwZGF0ZVJlY3QsIGxlZnQsIHRv cCwgcmlnaHQsIGJvdHRvbSk7CisgICAgbV90aWxlci0+Y29udGVudFJlY3RUb1RpbGVJbmRpY2Vz KG1fdmlzaWJsZUNvbnRlbnRSZWN0LCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b20pOwogICAgIGZv ciAoaW50IGogPSB0b3A7IGogPD0gYm90dG9tOyArK2opIHsKICAgICAgICAgZm9yIChpbnQgaSA9 IGxlZnQ7IGkgPD0gcmlnaHQ7ICsraSkgewogICAgICAgICAgICAgVXBkYXRhYmxlVGlsZSogdGls ZSA9IHRpbGVBdChpLCBqKTsKQEAgLTIwNyw2ICsyMDcsOCBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJv bWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4 dCwgVAogICAgICAgICAgICAgdGlsZS0+Y2xlYXJEaXJ0eSgpOwogICAgICAgICB9CiAgICAgfQor CisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KG1fcGFpbnRSZWN0KTsKIH0KIAogdm9pZCBU aWxlZExheWVyQ2hyb21pdW06OnNldFRpbGluZ09wdGlvbihUaWxpbmdPcHRpb24gdGlsaW5nT3B0 aW9uKQpAQCAtMjQ0LDYgKzI0Niw5IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwdXNoUHJv cGVydGllc1RvKENDTGF5ZXJJbXBsKiBsYXllcikKIAogICAgICAgICB0aWxlZExheWVyLT5zeW5j VGV4dHVyZUlkKGksIGosIHRpbGUtPnRleHR1cmUoKS0+dGV4dHVyZUlkKCkpOwogICAgIH0KKwor ICAgIC8vIFJlc2V0IGFueSBzdGF0ZSB0aGF0IHNob3VsZCBiZSBjbGVhcmVkIGZvciB0aGUgbmV4 dCB1cGRhdGUuCisgICAgbV9wYWludFJlY3QgPSBJbnRSZWN0KCk7CiB9CiAKIFRleHR1cmVNYW5h Z2VyKiBUaWxlZExheWVyQ2hyb21pdW06OnRleHR1cmVNYW5hZ2VyKCkgY29uc3QKQEAgLTM0Miwy NCArMzQ3LDI0IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwcm90ZWN0VGlsZVRleHR1cmVz KGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIH0KIH0KIAotdm9pZCBUaWxlZExheWVy Q2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkKK3Zv aWQgVGlsZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUoY29uc3QgSW50UmVjdCYgdmlz aWJsZUNvbnRlbnRSZWN0KQogewogICAgIEFTU0VSVChtX3RpbGVyKTsKIAogICAgIG1fc2tpcHNE cmF3ID0gZmFsc2U7CiAKLSAgICBpZiAoY29udGVudFJlY3QuaXNFbXB0eSgpKSB7Ci0gICAgICAg IG1fdXBkYXRlUmVjdCA9IEludFJlY3QoKTsKKyAgICBpZiAodmlzaWJsZUNvbnRlbnRSZWN0Lmlz RW1wdHkoKSkgeworICAgICAgICBtX3Zpc2libGVDb250ZW50UmVjdCA9IEludFJlY3QoKTsKICAg ICAgICAgcmV0dXJuOwogICAgIH0KIAogICAgIC8vIEludmFsaWRhdGUgb2xkIHRpbGVzIHRoYXQg d2VyZSBwcmV2aW91c2x5IHVzZWQgYnV0IGFyZW4ndCBpbiB1c2UgdGhpcwogICAgIC8vIGZyYW1l IHNvIHRoYXQgdGhleSBjYW4gZ2V0IHJldXNlZCBmb3IgbmV3IHRpbGVzLgotICAgIGludmFsaWRh dGVUaWxlcyhjb250ZW50UmVjdCk7Ci0gICAgbV90aWxlci0+Z3Jvd0xheWVyVG9Db250YWluKGNv bnRlbnRSZWN0KTsKKyAgICBpbnZhbGlkYXRlVGlsZXModmlzaWJsZUNvbnRlbnRSZWN0KTsKKyAg ICBtX3RpbGVyLT5ncm93TGF5ZXJUb0NvbnRhaW4odmlzaWJsZUNvbnRlbnRSZWN0KTsKIAogICAg IGlmICghbV90aWxlci0+bnVtVGlsZXMoKSkgewotICAgICAgICBtX3VwZGF0ZVJlY3QgPSBJbnRS ZWN0KCk7CisgICAgICAgIG1fdmlzaWJsZUNvbnRlbnRSZWN0ID0gSW50UmVjdCgpOwogICAgICAg ICByZXR1cm47CiAgICAgfQogCkBAIC0zNjcsNyArMzcyLDcgQEAgdm9pZCBUaWxlZExheWVyQ2hy b21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkKICAgICAv LyB0aGUgZGlydHkgcmVnaW9ucyBjdXJyZW50bHkgYmVpbmcgZHJhd24uCiAgICAgSW50UmVjdCBk aXJ0eUxheWVyUmVjdDsKICAgICBpbnQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tOwotICAgIG1f dGlsZXItPmNvbnRlbnRSZWN0VG9UaWxlSW5kaWNlcyhjb250ZW50UmVjdCwgbGVmdCwgdG9wLCBy aWdodCwgYm90dG9tKTsKKyAgICBtX3RpbGVyLT5jb250ZW50UmVjdFRvVGlsZUluZGljZXModmlz aWJsZUNvbnRlbnRSZWN0LCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b20pOwogICAgIGZvciAoaW50 IGogPSB0b3A7IGogPD0gYm90dG9tOyArK2opIHsKICAgICAgICAgZm9yIChpbnQgaSA9IGxlZnQ7 IGkgPD0gcmlnaHQ7ICsraSkgewogICAgICAgICAgICAgVXBkYXRhYmxlVGlsZSogdGlsZSA9IHRp bGVBdChpLCBqKTsKQEAgLTM5MCw3ICszOTUsNyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6 cHJlcGFyZVRvVXBkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIC8vIER1ZSB0 byBib3JkZXJzLCB3aGVuIHRoZSBwYWludCByZWN0IGlzIGV4dGVuZGVkIHRvIHRpbGUgYm91bmRh cmllcywgaXQKICAgICAvLyBtYXkgZW5kIHVwIG92ZXJsYXBwaW5nIG1vcmUgdGlsZXMgdGhhbiB0 aGUgb3JpZ2luYWwgY29udGVudCByZWN0LiBSZWNvcmQKICAgICAvLyB0aGF0IG9yaWdpbmFsIHJl Y3Qgc28gd2UgZG9uJ3QgdXBsb2FkIG1vcmUgdGlsZXMgdGhhbiBuZWNlc3NhcnkuCi0gICAgbV91 cGRhdGVSZWN0ID0gY29udGVudFJlY3Q7CisgICAgbV92aXNpYmxlQ29udGVudFJlY3QgPSB2aXNp YmxlQ29udGVudFJlY3Q7CiAKICAgICBtX3BhaW50UmVjdCA9IG1fdGlsZXItPmxheWVyUmVjdFRv Q29udGVudFJlY3QoZGlydHlMYXllclJlY3QpOwogICAgIGlmIChkaXJ0eUxheWVyUmVjdC5pc0Vt cHR5KCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9UaWxlZExheWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCmluZGV4IDFlODQ5NGE5YjdkMzJmMjYx Nzc0MjgwMDA4YTQ1YzgwZjljYjkwM2QuLmZjNWYxZDg0NDZiYjYyODIzZjcyYmE4MmM2YWRiNGRj ZDI1ODQxMDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCkBAIC02Niw5ICs2Niw4IEBA IHByb3RlY3RlZDoKICAgICAvLyBTZXQgaW52YWxpZGF0aW9ucyB0byBiZSBwb3RlbnRpYWxseSBy ZXBhaW50ZWQgZHVyaW5nIHVwZGF0ZSgpLgogICAgIHZvaWQgaW52YWxpZGF0ZVJlY3QoY29uc3Qg SW50UmVjdCYgY29udGVudFJlY3QpOwogICAgIC8vIFByZXBhcmUgZGF0YSBuZWVkZWQgdG8gdXBk YXRlIHRleHR1cmVzIHRoYXQgaW50ZXJzZWN0IHdpdGggY29udGVudFJlY3QuCi0gICAgdm9pZCBw cmVwYXJlVG9VcGRhdGUoY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QpOwotICAgIC8vIFVwZGF0 ZSBpbnZhbGlkIHRleHR1cmVzIHRoYXQgaW50ZXJzZWN0IHdpdGggY29udGVudFJlY3QgcHJvdmlk ZWQgaW4gcHJlcGFyZVRvVXBkYXRlKCkuCi0gICAgdm9pZCB1cGRhdGVSZWN0KEdyYXBoaWNzQ29u dGV4dDNEKiwgTGF5ZXJUZXh0dXJlVXBkYXRlciopOworICAgIHZvaWQgcHJlcGFyZVRvVXBkYXRl KGNvbnN0IEludFJlY3QmIHZpc2libGVDb250ZW50UmVjdCk7CisKICAgICB2aXJ0dWFsIHZvaWQg cHJvdGVjdFZpc2libGVUaWxlVGV4dHVyZXMoKTsKIAogcHJpdmF0ZToKQEAgLTg1LDkgKzg0LDEx IEBAIHByaXZhdGU6CiAKICAgICBUZXh0dXJlTWFuYWdlciogdGV4dHVyZU1hbmFnZXIoKSBjb25z dDsKIAotICAgIC8vIFN0YXRlIGhlbGQgYmV0d2VlbiB1cGRhdGUgYW5kIHVwbG9hZC4KKyAgICAv LyBUZW1wb3Jhcnkgc3RhdGUgaGVsZCBiZXR3ZWVuIHByZXBhcmVUb1VwZGF0ZSgpIGFuZCB1cGRh dGVDb21wb3NpdG9yUmVzb3VyY2VzKCkuCisgICAgSW50UmVjdCBtX3Zpc2libGVDb250ZW50UmVj dDsKKyAgICAvLyBTdGF0ZSBoZWxkIGJldHdlZW4gcHJlcGFyZVRvVXBkYXRlKCkgYW5kIHB1c2hQ cm9wZXJ0aWVzVG8oKS4gVGhpcyByZXByZXNlbnRzIHRoZSBhcmVhCisgICAgLy8gb2YgdGhlIGxh eWVyIHRoYXQgaXMgYWN0dWFsbHkgcmUtcGFpbnRlZCBieSBXZWJLaXQuCiAgICAgSW50UmVjdCBt X3BhaW50UmVjdDsKLSAgICBJbnRSZWN0IG1fdXBkYXRlUmVjdDsKIAogICAgIC8vIFRpZ2h0bHkg cGFja2VkIHNldCBvZiB1bnVzZWQgdGlsZXMuCiAgICAgVmVjdG9yPFJlZlB0cjxVcGRhdGFibGVU aWxlPiA+IG1fdW51c2VkVGlsZXM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmNwcAppbmRl eCA4ZTkyOWRkMzZhZmFlNzNmYmY0MTk5MzUyNDI2ZjZmNGZjNTA1MDkwLi5mNGM2NmMyZDJlNDNl NzA2NGJhZGMyN2I2ZjFhMmZjODk5OGEzNmJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1 bS5jcHAKQEAgLTEzNiw2ICsxMzYsNyBAQCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6dXBkYXRl Q29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVAogICAgIG1f cGxhbmVzID0gZnJhbWUtPnBsYW5lcygpOwogICAgIEFTU0VSVChtX3BsYW5lcyA8PSBNYXhQbGFu ZXMpOwogCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KEZsb2F0UG9pbnQ6Onplcm8oKSwg Ym91bmRzKCkpOwogICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiAKICAgICBtX3Byb3ZpZGVyLT5w dXRDdXJyZW50RnJhbWUoZnJhbWUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAKaW5k ZXggMzJiYTZhM2JlZTVhMDI0ZjU1Y2MwMjc2MjI1MmI5M2I1ODA0ZTBlNC4uNjVlZjY2Mjk4NzNm ZGFiOGFkZmMyYjMyZGI5NzI2MzQ5MGI3NWFjOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21p dW0uY3BwCkBAIC05MCw2ICs5MCw3IEBAIHZvaWQgV2ViR0xMYXllckNocm9taXVtOjp1cGRhdGVD b21wb3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4dDNEKiByZW5kZXJlckNvCiAgICAgICAg IC8vCiAgICAgICAgIG1fY29udGV4dC0+cHJlcGFyZVRleHR1cmUoKTsKICAgICAgICAgbV9jb250 ZXh0LT5tYXJrTGF5ZXJDb21wb3NpdGVkKCk7CisgICAgICAgIG1fdXBkYXRlUmVjdCA9IEZsb2F0 UmVjdChGbG9hdFBvaW50Ojp6ZXJvKCksIGJvdW5kcygpKTsKICAgICAgICAgcmVzZXROZWVkc0Rp c3BsYXkoKTsKICAgICAgICAgbV90ZXh0dXJlVXBkYXRlZCA9IGZhbHNlOwogICAgIH0K 111114 2011-10-14 17:41:25 -0700 2011-10-18 11:21:27 -0700 Added update rect to CCLayerImpl also bug-69441-20111014174124.patch text/plain 12736 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTc0NjcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0MGMwZTFjOTRjZDY2ZmFj NWI1MjNlNzVlMGQ4ZDA5YjcwZmFhNTkxLi45MzBmZWRmYjlkY2Y3NWM5ZmJhMGY0ZWFmMWM4NjE3 OTA1NDBkNWNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTEtMTAtMTQgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBU cmFja2luZyB1cGRhdGUgcmVjdHMgaW4gTGF5ZXJDaHJvbWl1bSBhbmQgQ0NMYXllckltcGwuCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02OTQ0MQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2gg ZG9lcyBub3QgZG8gbXVjaCBvbiBpdHMgb3duLCBidXQgaXMganVzdCBwYXJ0IDEgb2YgYQorICAg ICAgICBzdHJpbmcgb2Ygb3RoZXIgcGF0Y2hlcyB3aGljaCB3aWxsIHVzZSB0aGVzZSByZWN0cyBm b3IKKyAgICAgICAgdmlzdWFsaXphdGlvbiBhbmQgc2Npc3NvcmluZy4gIFRoZSBhcHByb3ByaWF0 ZSB0ZXN0aW5nIHdpbGwgYmUKKyAgICAgICAgYXNzb2NpYXRlZCB3aXRoIHRob3NlIHBhdGNoZXMu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hy b21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzMkRMYXllckNocm9taXVtOjp1cGRh dGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyQ2hyb21pdW06 OnB1c2hQcm9wZXJ0aWVzVG8pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyQ2hyb21pdW0uaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aWxlZExheWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGlsZWRMYXllckNocm9t aXVtOjpjbGVhbnVwUmVzb3VyY2VzKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJv bWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisgICAgICAgIChXZWJDb3JlOjpUaWxl ZExheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8pOgorICAgICAgICAoV2ViQ29yZTo6VGls ZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpWaWRlb0xheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMpOgorICAg ICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpXZWJHTExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JS ZXNvdXJjZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5 ZXJJbXBsLmg6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVySW1wbDo6dXBkYXRlUmVjdCk6Cisg ICAgICAgIChXZWJDb3JlOjpDQ0xheWVySW1wbDo6c2V0VXBkYXRlUmVjdCk6CisKIDIwMTEtMTAt MTQgIEFuZHJlYXMgS2xpbmcgIDxrbGluZ0B3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3 ZWQsIGFjdHVhbGx5IHJlbW92ZSBTdHlsZUxpc3QuKiBhZnRlciByOTc2NDAuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVy Q2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Q2FudmFzMkRMYXllckNocm9taXVtLmNwcAppbmRleCAwZTBkYTgwNGI2MWQ2NDY1ZjQxNDJlY2E3 YmEyNzEzY2E1NzViYjhkLi5mY2FjMjYyOTZkZjhlZGM5ODQ4MTcyZDQ2NDY1OWI0YjBhZDEyNDdl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9D YW52YXMyRExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTc5LDYgKzc5LDgg QEAgdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMo R3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXIKICNlbmRpZgogICAgICAgICBtX2NvbnRleHQtPmZs dXNoKCk7CiAgICAgfQorCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KEZsb2F0UG9pbnQo KSwgYm91bmRzKCkpOwogICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiB9CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0u Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJv bWl1bS5jcHAKaW5kZXggZmUyY2Q0ZWIxNWRmNGRkM2ZmNjE3MGI2YWFjZGRlMGU5MGQzMmEzOC4u OWU3NDI4MDc0MDQ2YzM2ZWE5ZjE1MjFkM2MwNGUzMWIyMWI3ODlkMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJv bWl1bS5jcHAKQEAgLTI5NiwxMSArMjk2LDE1IEBAIHZvaWQgTGF5ZXJDaHJvbWl1bTo6cHVzaFBy b3BlcnRpZXNUbyhDQ0xheWVySW1wbCogbGF5ZXIpCiAgICAgbGF5ZXItPnNldFNjcm9sbFBvc2l0 aW9uKG1fc2Nyb2xsUG9zaXRpb24pOwogICAgIGxheWVyLT5zZXRTdWJsYXllclRyYW5zZm9ybSht X3N1YmxheWVyVHJhbnNmb3JtKTsKICAgICBsYXllci0+c2V0VHJhbnNmb3JtKG1fdHJhbnNmb3Jt KTsKKyAgICBsYXllci0+c2V0VXBkYXRlUmVjdChtX3VwZGF0ZVJlY3QpOwogCiAgICAgaWYgKG1h c2tMYXllcigpKQogICAgICAgICBtYXNrTGF5ZXIoKS0+cHVzaFByb3BlcnRpZXNUbyhsYXllci0+ bWFza0xheWVyKCkpOwogICAgIGlmIChyZXBsaWNhTGF5ZXIoKSkKICAgICAgICAgcmVwbGljYUxh eWVyKCktPnB1c2hQcm9wZXJ0aWVzVG8obGF5ZXItPnJlcGxpY2FMYXllcigpKTsKKworICAgIC8v IFJlc2V0IGFueSBzdGF0ZSB0aGF0IHNob3VsZCBiZSBjbGVhcmVkIGZvciB0aGUgbmV4dCB1cGRh dGUuCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KCk7CiB9CiAKIFBhc3NSZWZQdHI8Q0NM YXllckltcGw+IExheWVyQ2hyb21pdW06OmNyZWF0ZUNDTGF5ZXJJbXBsKCkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0u aCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21p dW0uaAppbmRleCBiZTBlNzk2MDZiYjI5M2JjMDBmYjNmZThkZDJmMjVlNjM2ZDhkYmQ5Li4zM2Vi MjQwZjU1MWQzM2ZhNjAyYzliMmRhZDc5NmYzZmE1NGMyMjA5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5o CkBAIC0yMDgsOCArMjA4LDE0IEBAIHByb3RlY3RlZDoKICAgICAvLyBob2xkIGNvbnRleHQtZGVw ZW5kZW50IHJlc291cmNlcyBzdWNoIGFzIHRleHR1cmVzLgogICAgIHZpcnR1YWwgdm9pZCBjbGVh bnVwUmVzb3VyY2VzKCk7CiAKKyAgICAvLyBUaGUgZGlydHkgcmVjdCBpcyB0aGUgdW5pb24gb2Yg ZGFtYWdlZCByZWdpb25zIHRoYXQgbmVlZCByZXBhaW50aW5nL3VwZGF0aW5nLgogICAgIEZsb2F0 UmVjdCBtX2RpcnR5UmVjdDsKIAorICAgIC8vIFRoZSB1cGRhdGUgcmVjdCBpcyB0aGUgcmVnaW9u IG9mIHRoZSBjb21wb3NpdG9yIHJlc291cmNlIHRoYXQgd2FzIGFjdHVhbGx5IHVwZGF0ZWQgYnkg dGhlIGNvbXBvc2l0b3IuCisgICAgLy8gRm9yIGxheWVycyB0aGF0IG1heSBkbyB1cGRhdGluZyBv dXRzaWRlIHRoZSBjb21wb3NpdG9yJ3MgY29udHJvbCAoaS5lLiBwbHVnaW4gbGF5ZXJzKSwgdGhp cyBpbmZvcm1hdGlvbgorICAgIC8vIGlzIG5vdCBhdmFpbGFibGUgYW5kIHRoZSB1cGRhdGUgcmVj dCB3aWxsIHJlbWFpbiBlbXB0eS4KKyAgICBGbG9hdFJlY3QgbV91cGRhdGVSZWN0OworCiAgICAg UmVmUHRyPExheWVyQ2hyb21pdW0+IG1fbWFza0xheWVyOwogCiAgICAgZnJpZW5kIGNsYXNzIFRy ZWVTeW5jaHJvbml6ZXI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCBhZjQ5 YzhjMGE0ZGFhYzU1NWY4NzZhNDQxMzU0NjJiN2U0NTQxZGUwLi4wYTBkMDg4NTBjOTIyZGY5Mjhh YjgwMGFmMzNjODQ3NjMwNDQ5YTY2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAK QEAgLTg5LDcgKzg5LDcgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJj ZXMoKQogICAgIG1fdGlsZXIuY2xlYXIoKTsKICAgICBtX3VudXNlZFRpbGVzLmNsZWFyKCk7CiAg ICAgbV9wYWludFJlY3QgPSBJbnRSZWN0KCk7Ci0gICAgbV91cGRhdGVSZWN0ID0gSW50UmVjdCgp OworICAgIG1fdmlzaWJsZUNvbnRlbnRSZWN0ID0gSW50UmVjdCgpOwogfQogCiB2b2lkIFRpbGVk TGF5ZXJDaHJvbWl1bTo6dXBkYXRlVGlsZVNpemVBbmRUaWxpbmdPcHRpb24oKQpAQCAtMTU0LDEx ICsxNTQsMTEgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnNldExheWVyVHJlZUhvc3QoQ0NM YXllclRyZWVIb3N0KiBob3N0KQogdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBv c2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFRleHR1cmVBbGxvY2F0 b3IqIGFsbG9jYXRvcikKIHsKICAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21wb3NpdGlu ZyB0byBnZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBiZWNvbWUg aW52YWxpZGF0ZWQgbWlkLXVwZGF0ZS4KLSAgICBpZiAobV9za2lwc0RyYXcgfHwgbV91cGRhdGVS ZWN0LmlzRW1wdHkoKSB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSkKKyAgICBpZiAobV9za2lwc0Ry YXcgfHwgbV92aXNpYmxlQ29udGVudFJlY3QuaXNFbXB0eSgpIHx8ICFtX3RpbGVyLT5udW1UaWxl cygpKQogICAgICAgICByZXR1cm47CiAKICAgICBpbnQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9t OwotICAgIG1fdGlsZXItPmNvbnRlbnRSZWN0VG9UaWxlSW5kaWNlcyhtX3VwZGF0ZVJlY3QsIGxl ZnQsIHRvcCwgcmlnaHQsIGJvdHRvbSk7CisgICAgbV90aWxlci0+Y29udGVudFJlY3RUb1RpbGVJ bmRpY2VzKG1fdmlzaWJsZUNvbnRlbnRSZWN0LCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b20pOwog ICAgIGZvciAoaW50IGogPSB0b3A7IGogPD0gYm90dG9tOyArK2opIHsKICAgICAgICAgZm9yIChp bnQgaSA9IGxlZnQ7IGkgPD0gcmlnaHQ7ICsraSkgewogICAgICAgICAgICAgVXBkYXRhYmxlVGls ZSogdGlsZSA9IHRpbGVBdChpLCBqKTsKQEAgLTIwNyw2ICsyMDcsOCBAQCB2b2lkIFRpbGVkTGF5 ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCog Y29udGV4dCwgVAogICAgICAgICAgICAgdGlsZS0+Y2xlYXJEaXJ0eSgpOwogICAgICAgICB9CiAg ICAgfQorCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KG1fcGFpbnRSZWN0KTsKIH0KIAog dm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnNldFRpbGluZ09wdGlvbihUaWxpbmdPcHRpb24gdGls aW5nT3B0aW9uKQpAQCAtMjQ0LDYgKzI0Niw5IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpw dXNoUHJvcGVydGllc1RvKENDTGF5ZXJJbXBsKiBsYXllcikKIAogICAgICAgICB0aWxlZExheWVy LT5zeW5jVGV4dHVyZUlkKGksIGosIHRpbGUtPnRleHR1cmUoKS0+dGV4dHVyZUlkKCkpOwogICAg IH0KKworICAgIC8vIFJlc2V0IGFueSBzdGF0ZSB0aGF0IHNob3VsZCBiZSBjbGVhcmVkIGZvciB0 aGUgbmV4dCB1cGRhdGUuCisgICAgbV9wYWludFJlY3QgPSBJbnRSZWN0KCk7CiB9CiAKIFRleHR1 cmVNYW5hZ2VyKiBUaWxlZExheWVyQ2hyb21pdW06OnRleHR1cmVNYW5hZ2VyKCkgY29uc3QKQEAg LTM0MiwyNCArMzQ3LDI0IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwcm90ZWN0VGlsZVRl eHR1cmVzKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIH0KIH0KIAotdm9pZCBUaWxl ZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVj dCkKK3ZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUoY29uc3QgSW50UmVj dCYgdmlzaWJsZUNvbnRlbnRSZWN0KQogewogICAgIEFTU0VSVChtX3RpbGVyKTsKIAogICAgIG1f c2tpcHNEcmF3ID0gZmFsc2U7CiAKLSAgICBpZiAoY29udGVudFJlY3QuaXNFbXB0eSgpKSB7Ci0g ICAgICAgIG1fdXBkYXRlUmVjdCA9IEludFJlY3QoKTsKKyAgICBpZiAodmlzaWJsZUNvbnRlbnRS ZWN0LmlzRW1wdHkoKSkgeworICAgICAgICBtX3Zpc2libGVDb250ZW50UmVjdCA9IEludFJlY3Qo KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAogICAgIC8vIEludmFsaWRhdGUgb2xkIHRpbGVz IHRoYXQgd2VyZSBwcmV2aW91c2x5IHVzZWQgYnV0IGFyZW4ndCBpbiB1c2UgdGhpcwogICAgIC8v IGZyYW1lIHNvIHRoYXQgdGhleSBjYW4gZ2V0IHJldXNlZCBmb3IgbmV3IHRpbGVzLgotICAgIGlu dmFsaWRhdGVUaWxlcyhjb250ZW50UmVjdCk7Ci0gICAgbV90aWxlci0+Z3Jvd0xheWVyVG9Db250 YWluKGNvbnRlbnRSZWN0KTsKKyAgICBpbnZhbGlkYXRlVGlsZXModmlzaWJsZUNvbnRlbnRSZWN0 KTsKKyAgICBtX3RpbGVyLT5ncm93TGF5ZXJUb0NvbnRhaW4odmlzaWJsZUNvbnRlbnRSZWN0KTsK IAogICAgIGlmICghbV90aWxlci0+bnVtVGlsZXMoKSkgewotICAgICAgICBtX3VwZGF0ZVJlY3Qg PSBJbnRSZWN0KCk7CisgICAgICAgIG1fdmlzaWJsZUNvbnRlbnRSZWN0ID0gSW50UmVjdCgpOwog ICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC0zNjcsNyArMzcyLDcgQEAgdm9pZCBUaWxlZExh eWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkK ICAgICAvLyB0aGUgZGlydHkgcmVnaW9ucyBjdXJyZW50bHkgYmVpbmcgZHJhd24uCiAgICAgSW50 UmVjdCBkaXJ0eUxheWVyUmVjdDsKICAgICBpbnQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tOwot ICAgIG1fdGlsZXItPmNvbnRlbnRSZWN0VG9UaWxlSW5kaWNlcyhjb250ZW50UmVjdCwgbGVmdCwg dG9wLCByaWdodCwgYm90dG9tKTsKKyAgICBtX3RpbGVyLT5jb250ZW50UmVjdFRvVGlsZUluZGlj ZXModmlzaWJsZUNvbnRlbnRSZWN0LCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b20pOwogICAgIGZv ciAoaW50IGogPSB0b3A7IGogPD0gYm90dG9tOyArK2opIHsKICAgICAgICAgZm9yIChpbnQgaSA9 IGxlZnQ7IGkgPD0gcmlnaHQ7ICsraSkgewogICAgICAgICAgICAgVXBkYXRhYmxlVGlsZSogdGls ZSA9IHRpbGVBdChpLCBqKTsKQEAgLTM5MCw3ICszOTUsNyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJv bWl1bTo6cHJlcGFyZVRvVXBkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIC8v IER1ZSB0byBib3JkZXJzLCB3aGVuIHRoZSBwYWludCByZWN0IGlzIGV4dGVuZGVkIHRvIHRpbGUg Ym91bmRhcmllcywgaXQKICAgICAvLyBtYXkgZW5kIHVwIG92ZXJsYXBwaW5nIG1vcmUgdGlsZXMg dGhhbiB0aGUgb3JpZ2luYWwgY29udGVudCByZWN0LiBSZWNvcmQKICAgICAvLyB0aGF0IG9yaWdp bmFsIHJlY3Qgc28gd2UgZG9uJ3QgdXBsb2FkIG1vcmUgdGlsZXMgdGhhbiBuZWNlc3NhcnkuCi0g ICAgbV91cGRhdGVSZWN0ID0gY29udGVudFJlY3Q7CisgICAgbV92aXNpYmxlQ29udGVudFJlY3Qg PSB2aXNpYmxlQ29udGVudFJlY3Q7CiAKICAgICBtX3BhaW50UmVjdCA9IG1fdGlsZXItPmxheWVy UmVjdFRvQ29udGVudFJlY3QoZGlydHlMYXllclJlY3QpOwogICAgIGlmIChkaXJ0eUxheWVyUmVj dC5pc0VtcHR5KCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCmluZGV4IDFlODQ5NGE5Yjdk MzJmMjYxNzc0MjgwMDA4YTQ1YzgwZjljYjkwM2QuLmZjNWYxZDg0NDZiYjYyODIzZjcyYmE4MmM2 YWRiNGRjZDI1ODQxMDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCkBAIC02Niw5ICs2 Niw4IEBAIHByb3RlY3RlZDoKICAgICAvLyBTZXQgaW52YWxpZGF0aW9ucyB0byBiZSBwb3RlbnRp YWxseSByZXBhaW50ZWQgZHVyaW5nIHVwZGF0ZSgpLgogICAgIHZvaWQgaW52YWxpZGF0ZVJlY3Qo Y29uc3QgSW50UmVjdCYgY29udGVudFJlY3QpOwogICAgIC8vIFByZXBhcmUgZGF0YSBuZWVkZWQg dG8gdXBkYXRlIHRleHR1cmVzIHRoYXQgaW50ZXJzZWN0IHdpdGggY29udGVudFJlY3QuCi0gICAg dm9pZCBwcmVwYXJlVG9VcGRhdGUoY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QpOwotICAgIC8v IFVwZGF0ZSBpbnZhbGlkIHRleHR1cmVzIHRoYXQgaW50ZXJzZWN0IHdpdGggY29udGVudFJlY3Qg cHJvdmlkZWQgaW4gcHJlcGFyZVRvVXBkYXRlKCkuCi0gICAgdm9pZCB1cGRhdGVSZWN0KEdyYXBo aWNzQ29udGV4dDNEKiwgTGF5ZXJUZXh0dXJlVXBkYXRlciopOworICAgIHZvaWQgcHJlcGFyZVRv VXBkYXRlKGNvbnN0IEludFJlY3QmIHZpc2libGVDb250ZW50UmVjdCk7CisKICAgICB2aXJ0dWFs IHZvaWQgcHJvdGVjdFZpc2libGVUaWxlVGV4dHVyZXMoKTsKIAogcHJpdmF0ZToKQEAgLTg1LDkg Kzg0LDExIEBAIHByaXZhdGU6CiAKICAgICBUZXh0dXJlTWFuYWdlciogdGV4dHVyZU1hbmFnZXIo KSBjb25zdDsKIAotICAgIC8vIFN0YXRlIGhlbGQgYmV0d2VlbiB1cGRhdGUgYW5kIHVwbG9hZC4K KyAgICAvLyBUZW1wb3Jhcnkgc3RhdGUgaGVsZCBiZXR3ZWVuIHByZXBhcmVUb1VwZGF0ZSgpIGFu ZCB1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKCkuCisgICAgSW50UmVjdCBtX3Zpc2libGVDb250 ZW50UmVjdDsKKyAgICAvLyBTdGF0ZSBoZWxkIGJldHdlZW4gcHJlcGFyZVRvVXBkYXRlKCkgYW5k IHB1c2hQcm9wZXJ0aWVzVG8oKS4gVGhpcyByZXByZXNlbnRzIHRoZSBhcmVhCisgICAgLy8gb2Yg dGhlIGxheWVyIHRoYXQgaXMgYWN0dWFsbHkgcmUtcGFpbnRlZCBieSBXZWJLaXQuCiAgICAgSW50 UmVjdCBtX3BhaW50UmVjdDsKLSAgICBJbnRSZWN0IG1fdXBkYXRlUmVjdDsKIAogICAgIC8vIFRp Z2h0bHkgcGFja2VkIHNldCBvZiB1bnVzZWQgdGlsZXMuCiAgICAgVmVjdG9yPFJlZlB0cjxVcGRh dGFibGVUaWxlPiA+IG1fdW51c2VkVGlsZXM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmNw cAppbmRleCBhY2U2MzA4OGFhM2JhZTIxY2UzNTZhYmI2ODc0OTdhYTE1NmU0ZmZkLi4wZWI2Y2Zi ODM0OGE0OTllZGM5YWFjZjkwYjM4Yjk1ODUyODBiMDI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJD aHJvbWl1bS5jcHAKQEAgLTEzNCw2ICsxMzQsNyBAQCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6 dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVAog ICAgIG1fcGxhbmVzID0gZnJhbWUtPnBsYW5lcygpOwogICAgIEFTU0VSVChtX3BsYW5lcyA8PSBN YXhQbGFuZXMpOwogCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KEZsb2F0UG9pbnQoKSwg Ym91bmRzKCkpOwogICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiAKICAgICBtX3Byb3ZpZGVyLT5w dXRDdXJyZW50RnJhbWUoZnJhbWUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAKaW5k ZXggMzJiYTZhM2JlZTVhMDI0ZjU1Y2MwMjc2MjI1MmI5M2I1ODA0ZTBlNC4uNWNmYjY2YWM5Yzcx ZDA5OWEyNGZjYmE5MDc0ZTliN2RiODZkNGQ3YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21p dW0uY3BwCkBAIC05MCw2ICs5MCw3IEBAIHZvaWQgV2ViR0xMYXllckNocm9taXVtOjp1cGRhdGVD b21wb3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4dDNEKiByZW5kZXJlckNvCiAgICAgICAg IC8vCiAgICAgICAgIG1fY29udGV4dC0+cHJlcGFyZVRleHR1cmUoKTsKICAgICAgICAgbV9jb250 ZXh0LT5tYXJrTGF5ZXJDb21wb3NpdGVkKCk7CisgICAgICAgIG1fdXBkYXRlUmVjdCA9IEZsb2F0 UmVjdChGbG9hdFBvaW50KCksIGJvdW5kcygpKTsKICAgICAgICAgcmVzZXROZWVkc0Rpc3BsYXko KTsKICAgICAgICAgbV90ZXh0dXJlVXBkYXRlZCA9IGZhbHNlOwogICAgIH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJJbXBs LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVy SW1wbC5oCmluZGV4IDE1YmU3NTE1NmM3NzgwMDE0NDk4ZGI2ZTQ3OGFkNjM2NzA4ZDhiNjAuLjM5 YzZmOGUxMGJhMGY4NzdiOTJhZmExMzBmNDExODQzNGZhNWVjYTQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJJbXBsLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllcklt cGwuaApAQCAtMTY5LDYgKzE2OSw4IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldFNjcmVlblNwYWNl VHJhbnNmb3JtKGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0cml4JiBtYXRyaXgpIHsgbV9zY3JlZW5T cGFjZVRyYW5zZm9ybSA9IG1hdHJpeDsgfQogICAgIGNvbnN0IEludFJlY3QmIGRyYXdhYmxlQ29u dGVudFJlY3QoKSBjb25zdCB7IHJldHVybiBtX2RyYXdhYmxlQ29udGVudFJlY3Q7IH0KICAgICB2 b2lkIHNldERyYXdhYmxlQ29udGVudFJlY3QoY29uc3QgSW50UmVjdCYgcmVjdCkgeyBtX2RyYXdh YmxlQ29udGVudFJlY3QgPSByZWN0OyB9CisgICAgY29uc3QgRmxvYXRSZWN0JiB1cGRhdGVSZWN0 KCkgY29uc3QgeyByZXR1cm4gbV91cGRhdGVSZWN0OyB9CisgICAgdm9pZCBzZXRVcGRhdGVSZWN0 KGNvbnN0IEZsb2F0UmVjdCYgdXBkYXRlUmVjdCkgeyBtX3VwZGF0ZVJlY3QgPSB1cGRhdGVSZWN0 OyB9CiAKICAgICBTdHJpbmcgbGF5ZXJUcmVlQXNUZXh0KCkgY29uc3Q7CiAKQEAgLTI1Niw2ICsy NTgsMTAgQEAgcHJpdmF0ZToKIAogICAgIC8vIEhpZXJhcmNoaWNhbCBib3VuZGluZyByZWN0IGNv bnRhaW5pbmcgdGhlIGxheWVyIGFuZCBpdHMgZGVzY2VuZGFudHMuCiAgICAgSW50UmVjdCBtX2Ry YXdhYmxlQ29udGVudFJlY3Q7CisKKyAgICAvLyBSZWN0IGluZGljYXRpbmcgd2hhdCB3YXMgcmVw YWludGVkL3VwZGF0ZWQgZHVyaW5nIHVwZGF0ZS4KKyAgICAvLyBOb3RlIHRoYXQgcGx1Z2luIGxh eWVycyBieXBhc3MgdGhpcyBhbmQgbGVhdmUgaXQgZW1wdHkuCisgICAgRmxvYXRSZWN0IG1fdXBk YXRlUmVjdDsKIH07CiAKIHZvaWQgc29ydExheWVycyhWZWN0b3I8UmVmUHRyPENDTGF5ZXJJbXBs PiA+OjppdGVyYXRvciBmaXJzdCwgVmVjdG9yPFJlZlB0cjxDQ0xheWVySW1wbD4gPjo6aXRlcmF0 b3IgZW5kLCBDQ0xheWVyU29ydGVyKik7Cg== 111472 2011-10-18 11:21:31 -0700 2011-10-18 12:09:23 -0700 addressed all of jamesr comments bug-69441-20111018112130.patch text/plain 11392 shawnsingh U3VidmVyc2lvbiBSZXZpc2lvbjogOTc0NjcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0MGMwZTFjOTRjZDY2ZmFj NWI1MjNlNzVlMGQ4ZDA5YjcwZmFhNTkxLi45MzBmZWRmYjlkY2Y3NWM5ZmJhMGY0ZWFmMWM4NjE3 OTA1NDBkNWNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTEtMTAtMTQgIFNoYXdu IFNpbmdoICA8c2hhd25zaW5naEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBU cmFja2luZyB1cGRhdGUgcmVjdHMgaW4gTGF5ZXJDaHJvbWl1bSBhbmQgQ0NMYXllckltcGwuCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02OTQ0MQorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2gg ZG9lcyBub3QgZG8gbXVjaCBvbiBpdHMgb3duLCBidXQgaXMganVzdCBwYXJ0IDEgb2YgYQorICAg ICAgICBzdHJpbmcgb2Ygb3RoZXIgcGF0Y2hlcyB3aGljaCB3aWxsIHVzZSB0aGVzZSByZWN0cyBm b3IKKyAgICAgICAgdmlzdWFsaXphdGlvbiBhbmQgc2Npc3NvcmluZy4gIFRoZSBhcHByb3ByaWF0 ZSB0ZXN0aW5nIHdpbGwgYmUKKyAgICAgICAgYXNzb2NpYXRlZCB3aXRoIHRob3NlIHBhdGNoZXMu CisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hy b21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzMkRMYXllckNocm9taXVtOjp1cGRh dGVDb21wb3NpdG9yUmVzb3VyY2VzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkxheWVyQ2hyb21pdW06 OnB1c2hQcm9wZXJ0aWVzVG8pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyQ2hyb21pdW0uaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aWxlZExheWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGlsZWRMYXllckNocm9t aXVtOjpjbGVhbnVwUmVzb3VyY2VzKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJv bWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyk6CisgICAgICAgIChXZWJDb3JlOjpUaWxl ZExheWVyQ2hyb21pdW06OnB1c2hQcm9wZXJ0aWVzVG8pOgorICAgICAgICAoV2ViQ29yZTo6VGls ZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oOgorICAgICAgICAqIHBsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpWaWRlb0xheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMpOgorICAg ICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpXZWJHTExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JS ZXNvdXJjZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5 ZXJJbXBsLmg6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVySW1wbDo6dXBkYXRlUmVjdCk6Cisg ICAgICAgIChXZWJDb3JlOjpDQ0xheWVySW1wbDo6c2V0VXBkYXRlUmVjdCk6CisKIDIwMTEtMTAt MTQgIEFuZHJlYXMgS2xpbmcgIDxrbGluZ0B3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3 ZWQsIGFjdHVhbGx5IHJlbW92ZSBTdHlsZUxpc3QuKiBhZnRlciByOTc2NDAuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVy Q2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Q2FudmFzMkRMYXllckNocm9taXVtLmNwcAppbmRleCAwZTBkYTgwNGI2MWQ2NDY1ZjQxNDJlY2E3 YmEyNzEzY2E1NzViYjhkLi5mY2FjMjYyOTZkZjhlZGM5ODQ4MTcyZDQ2NDY1OWI0YjBhZDEyNDdl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9D YW52YXMyRExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTc5LDYgKzc5LDgg QEAgdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMo R3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXIKICNlbmRpZgogICAgICAgICBtX2NvbnRleHQtPmZs dXNoKCk7CiAgICAgfQorCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KEZsb2F0UG9pbnQo KSwgYm91bmRzKCkpOwogICAgIHJlc2V0TmVlZHNEaXNwbGF5KCk7CiB9CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0u Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJv bWl1bS5jcHAKaW5kZXggZmUyY2Q0ZWIxNWRmNGRkM2ZmNjE3MGI2YWFjZGRlMGU5MGQzMmEzOC4u OWU3NDI4MDc0MDQ2YzM2ZWE5ZjE1MjFkM2MwNGUzMWIyMWI3ODlkMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJv bWl1bS5jcHAKQEAgLTI5NiwxMSArMjk2LDE1IEBAIHZvaWQgTGF5ZXJDaHJvbWl1bTo6cHVzaFBy b3BlcnRpZXNUbyhDQ0xheWVySW1wbCogbGF5ZXIpCiAgICAgbGF5ZXItPnNldFNjcm9sbFBvc2l0 aW9uKG1fc2Nyb2xsUG9zaXRpb24pOwogICAgIGxheWVyLT5zZXRTdWJsYXllclRyYW5zZm9ybSht X3N1YmxheWVyVHJhbnNmb3JtKTsKICAgICBsYXllci0+c2V0VHJhbnNmb3JtKG1fdHJhbnNmb3Jt KTsKKyAgICBsYXllci0+c2V0VXBkYXRlUmVjdChtX3VwZGF0ZVJlY3QpOwogCiAgICAgaWYgKG1h c2tMYXllcigpKQogICAgICAgICBtYXNrTGF5ZXIoKS0+cHVzaFByb3BlcnRpZXNUbyhsYXllci0+ bWFza0xheWVyKCkpOwogICAgIGlmIChyZXBsaWNhTGF5ZXIoKSkKICAgICAgICAgcmVwbGljYUxh eWVyKCktPnB1c2hQcm9wZXJ0aWVzVG8obGF5ZXItPnJlcGxpY2FMYXllcigpKTsKKworICAgIC8v IFJlc2V0IGFueSBzdGF0ZSB0aGF0IHNob3VsZCBiZSBjbGVhcmVkIGZvciB0aGUgbmV4dCB1cGRh dGUuCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KCk7CiB9CiAKIFBhc3NSZWZQdHI8Q0NM YXllckltcGw+IExheWVyQ2hyb21pdW06OmNyZWF0ZUNDTGF5ZXJJbXBsKCkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0u aCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21p dW0uaAppbmRleCBiZTBlNzk2MDZiYjI5M2JjMDBmYjNmZThkZDJmMjVlNjM2ZDhkYmQ5Li4zM2Vi MjQwZjU1MWQzM2ZhNjAyYzliMmRhZDc5NmYzZmE1NGMyMjA5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5o CkBAIC0yMDgsOCArMjA4LDE0IEBAIHByb3RlY3RlZDoKICAgICAvLyBob2xkIGNvbnRleHQtZGVw ZW5kZW50IHJlc291cmNlcyBzdWNoIGFzIHRleHR1cmVzLgogICAgIHZpcnR1YWwgdm9pZCBjbGVh bnVwUmVzb3VyY2VzKCk7CiAKKyAgICAvLyBUaGUgZGlydHkgcmVjdCBpcyB0aGUgdW5pb24gb2Yg ZGFtYWdlZCByZWdpb25zIHRoYXQgbmVlZCByZXBhaW50aW5nL3VwZGF0aW5nLgogICAgIEZsb2F0 UmVjdCBtX2RpcnR5UmVjdDsKIAorICAgIC8vIFRoZSB1cGRhdGUgcmVjdCBpcyB0aGUgcmVnaW9u IG9mIHRoZSBjb21wb3NpdG9yIHJlc291cmNlIHRoYXQgd2FzIGFjdHVhbGx5IHVwZGF0ZWQgYnkg dGhlIGNvbXBvc2l0b3IuCisgICAgLy8gRm9yIGxheWVycyB0aGF0IG1heSBkbyB1cGRhdGluZyBv dXRzaWRlIHRoZSBjb21wb3NpdG9yJ3MgY29udHJvbCAoaS5lLiBwbHVnaW4gbGF5ZXJzKSwgdGhp cyBpbmZvcm1hdGlvbgorICAgIC8vIGlzIG5vdCBhdmFpbGFibGUgYW5kIHRoZSB1cGRhdGUgcmVj dCB3aWxsIHJlbWFpbiBlbXB0eS4KKyAgICBGbG9hdFJlY3QgbV91cGRhdGVSZWN0OworCiAgICAg UmVmUHRyPExheWVyQ2hyb21pdW0+IG1fbWFza0xheWVyOwogCiAgICAgZnJpZW5kIGNsYXNzIFRy ZWVTeW5jaHJvbml6ZXI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCBhZjQ5 YzhjMGE0ZGFhYzU1NWY4NzZhNDQxMzU0NjJiN2U0NTQxZGUwLi5kODA3NGZmYWRiZTQ4ZDNjNTIy ZGE5NjY4MTNkOTlhYThjNWY5NGEwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAK QEAgLTg5LDcgKzg5LDcgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJj ZXMoKQogICAgIG1fdGlsZXIuY2xlYXIoKTsKICAgICBtX3VudXNlZFRpbGVzLmNsZWFyKCk7CiAg ICAgbV9wYWludFJlY3QgPSBJbnRSZWN0KCk7Ci0gICAgbV91cGRhdGVSZWN0ID0gSW50UmVjdCgp OworICAgIG1fcmVxdWVzdGVkVXBkYXRlUmVjdCA9IEludFJlY3QoKTsKIH0KIAogdm9pZCBUaWxl ZExheWVyQ2hyb21pdW06OnVwZGF0ZVRpbGVTaXplQW5kVGlsaW5nT3B0aW9uKCkKQEAgLTE1NCwx MSArMTU0LDExIEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpzZXRMYXllclRyZWVIb3N0KEND TGF5ZXJUcmVlSG9zdCogaG9zdCkKIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjp1cGRhdGVDb21w b3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0LCBUZXh0dXJlQWxsb2Nh dG9yKiBhbGxvY2F0b3IpCiB7CiAgICAgLy8gUGFpbnRpbmcgY291bGQgY2F1c2UgY29tcG9zaXRp bmcgdG8gZ2V0IHR1cm5lZCBvZmYsIHdoaWNoIG1heSBjYXVzZSB0aGUgdGlsZXIgdG8gYmVjb21l IGludmFsaWRhdGVkIG1pZC11cGRhdGUuCi0gICAgaWYgKG1fc2tpcHNEcmF3IHx8IG1fdXBkYXRl UmVjdC5pc0VtcHR5KCkgfHwgIW1fdGlsZXItPm51bVRpbGVzKCkpCisgICAgaWYgKG1fc2tpcHNE cmF3IHx8IG1fcmVxdWVzdGVkVXBkYXRlUmVjdC5pc0VtcHR5KCkgfHwgIW1fdGlsZXItPm51bVRp bGVzKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGludCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0 b207Ci0gICAgbV90aWxlci0+Y29udGVudFJlY3RUb1RpbGVJbmRpY2VzKG1fdXBkYXRlUmVjdCwg bGVmdCwgdG9wLCByaWdodCwgYm90dG9tKTsKKyAgICBtX3RpbGVyLT5jb250ZW50UmVjdFRvVGls ZUluZGljZXMobV9yZXF1ZXN0ZWRVcGRhdGVSZWN0LCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b20p OwogICAgIGZvciAoaW50IGogPSB0b3A7IGogPD0gYm90dG9tOyArK2opIHsKICAgICAgICAgZm9y IChpbnQgaSA9IGxlZnQ7IGkgPD0gcmlnaHQ7ICsraSkgewogICAgICAgICAgICAgVXBkYXRhYmxl VGlsZSogdGlsZSA9IHRpbGVBdChpLCBqKTsKQEAgLTIwNyw2ICsyMDcsOCBAQCB2b2lkIFRpbGVk TGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQz RCogY29udGV4dCwgVAogICAgICAgICAgICAgdGlsZS0+Y2xlYXJEaXJ0eSgpOwogICAgICAgICB9 CiAgICAgfQorCisgICAgbV91cGRhdGVSZWN0ID0gRmxvYXRSZWN0KG1fdGlsZXItPmNvbnRlbnRS ZWN0VG9MYXllclJlY3QobV9wYWludFJlY3QpKTsKIH0KIAogdm9pZCBUaWxlZExheWVyQ2hyb21p dW06OnNldFRpbGluZ09wdGlvbihUaWxpbmdPcHRpb24gdGlsaW5nT3B0aW9uKQpAQCAtMzQ5LDcg KzM1MSw3IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGUoY29uc3Qg SW50UmVjdCYgY29udGVudFJlY3QpCiAgICAgbV9za2lwc0RyYXcgPSBmYWxzZTsKIAogICAgIGlm IChjb250ZW50UmVjdC5pc0VtcHR5KCkpIHsKLSAgICAgICAgbV91cGRhdGVSZWN0ID0gSW50UmVj dCgpOworICAgICAgICBtX3JlcXVlc3RlZFVwZGF0ZVJlY3QgPSBJbnRSZWN0KCk7CiAgICAgICAg IHJldHVybjsKICAgICB9CiAKQEAgLTM1OSw3ICszNjEsNyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJv bWl1bTo6cHJlcGFyZVRvVXBkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIG1f dGlsZXItPmdyb3dMYXllclRvQ29udGFpbihjb250ZW50UmVjdCk7CiAKICAgICBpZiAoIW1fdGls ZXItPm51bVRpbGVzKCkpIHsKLSAgICAgICAgbV91cGRhdGVSZWN0ID0gSW50UmVjdCgpOworICAg ICAgICBtX3JlcXVlc3RlZFVwZGF0ZVJlY3QgPSBJbnRSZWN0KCk7CiAgICAgICAgIHJldHVybjsK ICAgICB9CiAKQEAgLTM5MCw3ICszOTIsNyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJl cGFyZVRvVXBkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogICAgIC8vIER1ZSB0byBi b3JkZXJzLCB3aGVuIHRoZSBwYWludCByZWN0IGlzIGV4dGVuZGVkIHRvIHRpbGUgYm91bmRhcmll cywgaXQKICAgICAvLyBtYXkgZW5kIHVwIG92ZXJsYXBwaW5nIG1vcmUgdGlsZXMgdGhhbiB0aGUg b3JpZ2luYWwgY29udGVudCByZWN0LiBSZWNvcmQKICAgICAvLyB0aGF0IG9yaWdpbmFsIHJlY3Qg c28gd2UgZG9uJ3QgdXBsb2FkIG1vcmUgdGlsZXMgdGhhbiBuZWNlc3NhcnkuCi0gICAgbV91cGRh dGVSZWN0ID0gY29udGVudFJlY3Q7CisgICAgbV9yZXF1ZXN0ZWRVcGRhdGVSZWN0ID0gY29udGVu dFJlY3Q7CiAKICAgICBtX3BhaW50UmVjdCA9IG1fdGlsZXItPmxheWVyUmVjdFRvQ29udGVudFJl Y3QoZGlydHlMYXllclJlY3QpOwogICAgIGlmIChkaXJ0eUxheWVyUmVjdC5pc0VtcHR5KCkpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxl ZExheWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCmluZGV4IDFlODQ5NGE5YjdkMzJmMjYxNzc0MjgwMDA4 YTQ1YzgwZjljYjkwM2QuLjNlYzgyYmZmYjVmNDkwNjg2MzBjYjkyNTViYTBjZWIwZDcyYzAwNzEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1Rp bGVkTGF5ZXJDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCkBAIC02Nyw4ICs2Nyw3IEBAIHByb3RlY3Rl ZDoKICAgICB2b2lkIGludmFsaWRhdGVSZWN0KGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KTsK ICAgICAvLyBQcmVwYXJlIGRhdGEgbmVlZGVkIHRvIHVwZGF0ZSB0ZXh0dXJlcyB0aGF0IGludGVy c2VjdCB3aXRoIGNvbnRlbnRSZWN0LgogICAgIHZvaWQgcHJlcGFyZVRvVXBkYXRlKGNvbnN0IElu dFJlY3QmIGNvbnRlbnRSZWN0KTsKLSAgICAvLyBVcGRhdGUgaW52YWxpZCB0ZXh0dXJlcyB0aGF0 IGludGVyc2VjdCB3aXRoIGNvbnRlbnRSZWN0IHByb3ZpZGVkIGluIHByZXBhcmVUb1VwZGF0ZSgp LgotICAgIHZvaWQgdXBkYXRlUmVjdChHcmFwaGljc0NvbnRleHQzRCosIExheWVyVGV4dHVyZVVw ZGF0ZXIqKTsKKwogICAgIHZpcnR1YWwgdm9pZCBwcm90ZWN0VmlzaWJsZVRpbGVUZXh0dXJlcygp OwogCiBwcml2YXRlOgpAQCAtODUsOSArODQsMTEgQEAgcHJpdmF0ZToKIAogICAgIFRleHR1cmVN YW5hZ2VyKiB0ZXh0dXJlTWFuYWdlcigpIGNvbnN0OwogCi0gICAgLy8gU3RhdGUgaGVsZCBiZXR3 ZWVuIHVwZGF0ZSBhbmQgdXBsb2FkLgorICAgIC8vIFRlbXBvcmFyeSBzdGF0ZSBoZWxkIGJldHdl ZW4gcHJlcGFyZVRvVXBkYXRlKCkgYW5kIHVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoKS4KKyAg ICBJbnRSZWN0IG1fcmVxdWVzdGVkVXBkYXRlUmVjdDsKKyAgICAvLyBTdGF0ZSBoZWxkIGJldHdl ZW4gcHJlcGFyZVRvVXBkYXRlKCkgYW5kIHB1c2hQcm9wZXJ0aWVzVG8oKS4gVGhpcyByZXByZXNl bnRzIHRoZSBhcmVhCisgICAgLy8gb2YgdGhlIGxheWVyIHRoYXQgaXMgYWN0dWFsbHkgcmUtcGFp bnRlZCBieSBXZWJLaXQuCiAgICAgSW50UmVjdCBtX3BhaW50UmVjdDsKLSAgICBJbnRSZWN0IG1f dXBkYXRlUmVjdDsKIAogICAgIC8vIFRpZ2h0bHkgcGFja2VkIHNldCBvZiB1bnVzZWQgdGlsZXMu CiAgICAgVmVjdG9yPFJlZlB0cjxVcGRhdGFibGVUaWxlPiA+IG1fdW51c2VkVGlsZXM7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xh eWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vVmlkZW9MYXllckNocm9taXVtLmNwcAppbmRleCBhY2U2MzA4OGFhM2JhZTIxY2UzNTZhYmI2 ODc0OTdhYTE1NmU0ZmZkLi4wZWI2Y2ZiODM0OGE0OTllZGM5YWFjZjkwYjM4Yjk1ODUyODBiMDI0 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9W aWRlb0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTEzNCw2ICsxMzQsNyBAQCB2 b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGlj c0NvbnRleHQzRCogY29udGV4dCwgVAogICAgIG1fcGxhbmVzID0gZnJhbWUtPnBsYW5lcygpOwog ICAgIEFTU0VSVChtX3BsYW5lcyA8PSBNYXhQbGFuZXMpOwogCisgICAgbV91cGRhdGVSZWN0ID0g RmxvYXRSZWN0KEZsb2F0UG9pbnQoKSwgYm91bmRzKCkpOwogICAgIHJlc2V0TmVlZHNEaXNwbGF5 KCk7CiAKICAgICBtX3Byb3ZpZGVyLT5wdXRDdXJyZW50RnJhbWUoZnJhbWUpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNo cm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dl YkdMTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggMzJiYTZhM2JlZTVhMDI0ZjU1Y2MwMjc2MjI1MmI5 M2I1ODA0ZTBlNC4uNWNmYjY2YWM5YzcxZDA5OWEyNGZjYmE5MDc0ZTliN2RiODZkNGQ3YiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xM YXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCkBAIC05MCw2ICs5MCw3IEBAIHZvaWQgV2Vi R0xMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4 dDNEKiByZW5kZXJlckNvCiAgICAgICAgIC8vCiAgICAgICAgIG1fY29udGV4dC0+cHJlcGFyZVRl eHR1cmUoKTsKICAgICAgICAgbV9jb250ZXh0LT5tYXJrTGF5ZXJDb21wb3NpdGVkKCk7CisgICAg ICAgIG1fdXBkYXRlUmVjdCA9IEZsb2F0UmVjdChGbG9hdFBvaW50KCksIGJvdW5kcygpKTsKICAg ICAgICAgcmVzZXROZWVkc0Rpc3BsYXkoKTsKICAgICAgICAgbV90ZXh0dXJlVXBkYXRlZCA9IGZh bHNlOwogICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDTGF5ZXJJbXBsLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0xheWVySW1wbC5oCmluZGV4IDE1YmU3NTE1NmM3NzgwMDE0NDk4 ZGI2ZTQ3OGFkNjM2NzA4ZDhiNjAuLjM5YzZmOGUxMGJhMGY4NzdiOTJhZmExMzBmNDExODQzNGZh NWVjYTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDTGF5ZXJJbXBsLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NMYXllckltcGwuaApAQCAtMTY5LDYgKzE2OSw4IEBAIHB1YmxpYzoK ICAgICB2b2lkIHNldFNjcmVlblNwYWNlVHJhbnNmb3JtKGNvbnN0IFRyYW5zZm9ybWF0aW9uTWF0 cml4JiBtYXRyaXgpIHsgbV9zY3JlZW5TcGFjZVRyYW5zZm9ybSA9IG1hdHJpeDsgfQogICAgIGNv bnN0IEludFJlY3QmIGRyYXdhYmxlQ29udGVudFJlY3QoKSBjb25zdCB7IHJldHVybiBtX2RyYXdh YmxlQ29udGVudFJlY3Q7IH0KICAgICB2b2lkIHNldERyYXdhYmxlQ29udGVudFJlY3QoY29uc3Qg SW50UmVjdCYgcmVjdCkgeyBtX2RyYXdhYmxlQ29udGVudFJlY3QgPSByZWN0OyB9CisgICAgY29u c3QgRmxvYXRSZWN0JiB1cGRhdGVSZWN0KCkgY29uc3QgeyByZXR1cm4gbV91cGRhdGVSZWN0OyB9 CisgICAgdm9pZCBzZXRVcGRhdGVSZWN0KGNvbnN0IEZsb2F0UmVjdCYgdXBkYXRlUmVjdCkgeyBt X3VwZGF0ZVJlY3QgPSB1cGRhdGVSZWN0OyB9CiAKICAgICBTdHJpbmcgbGF5ZXJUcmVlQXNUZXh0 KCkgY29uc3Q7CiAKQEAgLTI1Niw2ICsyNTgsMTAgQEAgcHJpdmF0ZToKIAogICAgIC8vIEhpZXJh cmNoaWNhbCBib3VuZGluZyByZWN0IGNvbnRhaW5pbmcgdGhlIGxheWVyIGFuZCBpdHMgZGVzY2Vu ZGFudHMuCiAgICAgSW50UmVjdCBtX2RyYXdhYmxlQ29udGVudFJlY3Q7CisKKyAgICAvLyBSZWN0 IGluZGljYXRpbmcgd2hhdCB3YXMgcmVwYWludGVkL3VwZGF0ZWQgZHVyaW5nIHVwZGF0ZS4KKyAg ICAvLyBOb3RlIHRoYXQgcGx1Z2luIGxheWVycyBieXBhc3MgdGhpcyBhbmQgbGVhdmUgaXQgZW1w dHkuCisgICAgRmxvYXRSZWN0IG1fdXBkYXRlUmVjdDsKIH07CiAKIHZvaWQgc29ydExheWVycyhW ZWN0b3I8UmVmUHRyPENDTGF5ZXJJbXBsPiA+OjppdGVyYXRvciBmaXJzdCwgVmVjdG9yPFJlZlB0 cjxDQ0xheWVySW1wbD4gPjo6aXRlcmF0b3IgZW5kLCBDQ0xheWVyU29ydGVyKik7Cg==