77135 2012-01-26 13:22:11 -0800 [chromium] canvas demo is slow due to unnecessary resource cleanups 2012-02-06 18:24:52 -0800 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED http://jsgamebench.com/ P2 Normal --- 77655 1 alokp alokp cc-bugs enne jamesr nduca vangelis webkit.review.bot oldest_to_newest 543425 0 alokp 2012-01-26 13:22:11 -0800 JSGameBench updates the FPS by calling innerHTML on the parentFPS div every frame. This in turn removes a layer from the compositing layer tree. When WebCore::FrameView::updateCompositingLayers() is called on the next layout, it tries to add the new FPS div by adding it to the tree through GraphicsLayer::setChildren(), which removes all child layers even though some of them will be added right back. As soon as we remove a layer from the tree we also evict all associated texture resources. This means we are unnecessarily deleting and updating a huge tiled layer every frame. Relevant call stack: WebCore::TiledLayerChromium::cleanupResources() Line 98 WebCore::TiledLayerChromium::setLayerTreeHost(WebCore::CCLayerTreeHost * host=0x00000000) Line 182 + 0xf bytes WebCore::LayerChromium::setParent(WebCore::LayerChromium * layer=0x00000000) Line 146 + 0x33 bytes WebCore::LayerChromium::removeChild(WebCore::LayerChromium * child=0x0f27c680) Line 185 WebCore::LayerChromium::removeFromParent() Line 176 WebCore::GraphicsLayerChromium::removeFromParent() Line 162 WebCore::GraphicsLayer::removeAllChildren() Line 223 + 0xf bytes WebCore::GraphicsLayer::setChildren(const WTF::Vector<WebCore::GraphicsLayer *,0> & newChildren={...}) Line 128 WebCore::GraphicsLayerChromium::setChildren(const WTF::Vector<WebCore::GraphicsLayer *,0> & children={...}) Line 115 + 0xc bytes WebCore::RenderLayerCompositor::rebuildCompositingLayerTree(WebCore::RenderLayer * layer=0x0cd9b30c, WTF::Vector<WebCore::GraphicsLayer *,0> & childLayersOfEnclosingLayer={...}) Line 922 + 0x1e bytes WebCore::RenderLayerCompositor::rebuildCompositingLayerTree(WebCore::RenderLayer * layer=0x0cd9bb0c, WTF::Vector<WebCore::GraphicsLayer *,0> & childLayersOfEnclosingLayer={...}) Line 912 WebCore::RenderLayerCompositor::rebuildCompositingLayerTree(WebCore::RenderLayer * layer=0x0cd9ba0c, WTF::Vector<WebCore::GraphicsLayer *,0> & childLayersOfEnclosingLayer={...}) Line 912 WebCore::RenderLayerCompositor::updateCompositingLayers(WebCore::CompositingUpdateType updateType=CompositingUpdateAfterLayoutOrStyleChange, WebCore::RenderLayer * updateRoot=0x0cd9ba0c) Line 323 WebCore::FrameView::updateCompositingLayers() Line 669 WebCore::FrameView::layout(bool allowSubtree=true) Line 1154 WebCore::FrameView::updateLayoutAndStyleIfNeededRecursive() Line 2974 WebKit::WebFrameImpl::layout() Line 2076 WebKit::WebViewImpl::layout() Line 1184 RenderWidget::DoDeferredUpdate() Line 768 + 0x17 bytes RenderWidget::DoDeferredUpdateAndSendInputAck() Line 734 RenderWidget::OnSwapBuffersComplete() Line 460 RenderViewImpl::OnViewContextSwapBuffersComplete() Line 4292 543428 1 alokp 2012-01-26 13:27:27 -0800 I am investigating if we can avoid calling TiledLayerChromium::setLayerTreeHost(0) when LayerChromium::setParent(0) is called. Nat points that it could be tricky since we have ref-ptr cycle between CCLayerTreeHost and LayerChromium. 543543 2 jamesr 2012-01-26 15:17:56 -0800 I think the real problem here is the weak pointer relationship between ManagedTextures (which layers own) and TextureManager (which the CCLayerTreeHost owns). ManagedTextures are associated with a TextureManager and have a weak pointer to them. Layers can become detached from LTHs and in some cases outlive the LTH, but we don't want to let the ManagedTexture continue pointing to a bogus TextureManager after the LTH goes away. We maintain this today by saying that whenever a layer leaves the LTH, we destroy all ManagedTextures. We could refine this and only destroy the ManagedTextures when the layer becomes associated with a different LTH so that if a layer leaves and then reenters the same LTH it keeps the same ManagedTexture alive, but we'd still have to do something about the case where a layer becomes detached and then outlives the destruction of the LTH that it was associated with. 543578 3 124196 alokp 2012-01-26 15:35:56 -0800 Created attachment 124196 proposed patch This patch fixes the JSGameBench canvas demo. I am still testing if it has other unintended consequences. 543689 4 124196 jamesr 2012-01-26 17:37:48 -0800 Comment on attachment 124196 proposed patch This won't work if the LayerChromium is detached and then the CCLayerTreeHost is destroyed before the LayerChromium is since the LayerChromium's destructor will try to tear down ManagedTextures which still have a raw pointer to the TextureManager, which died when the host died. 543766 5 alokp 2012-01-26 20:00:31 -0800 (In reply to comment #4) > (From update of attachment 124196 [details]) > This won't work if the LayerChromium is detached and then the CCLayerTreeHost is destroyed before the LayerChromium is since the LayerChromium's destructor will try to tear down ManagedTextures which still have a raw pointer to the TextureManager, which died when the host died. CCLayerTreeHost cannot be destroyed because LayerChromium holds a ref-ptr to the LTH. http://trac.webkit.org/browser/trunk/Source/WebCore/platform/graphics/chromium/LayerChromium.h#L245 But I agree this is a very flimsy design, and this patch makes it even worse. BTW do you know of a case where a Layer is not destroyed after being removed from a tree, i.e. the layer either moves to another tree or just stays detached forever. 543811 6 jamesr 2012-01-26 21:12:22 -0800 It's fairly common for a layer to outlive the LTH. WebGLRenderingContexts have DrawingBuffers which have PlatformLayers (WebGLLayerChromiums). The context itself is held alive via a javascript reference which is often garbage collected after the page containing the canvas is navigated away from or destroyed. 2D canvas has the same thing with the reference chain HTMLCanvasElement -> ImageBuffer -> ImageBufferData::m_platformLayer. I'm not completely sure about video / plugin layers off the top of my head, but it wouldn't shock me if they outlived the page in some circumstances. I agree this is a pile of poo. Let's figure out what we can do that works for now, and then keep notes of what to improve for the future. What if we treated GraphicsLayer::setChildren() as more of a bulk operation rather than as a serieis of individual operations that have to all maintain internal invariants? Could we do something smarter there? 544178 7 alokp 2012-01-27 10:48:24 -0800 (In reply to comment #6) > It's fairly common for a layer to outlive the LTH. WebGLRenderingContexts have DrawingBuffers which have PlatformLayers (WebGLLayerChromiums). The context itself is held alive via a javascript reference which is often garbage collected after the page containing the canvas is navigated away from or destroyed. 2D canvas has the same thing with the reference chain HTMLCanvasElement -> ImageBuffer -> ImageBufferData::m_platformLayer. I'm not completely sure about video / plugin layers off the top of my head, but it wouldn't shock me if they outlived the page in some circumstances. > > I agree this is a pile of poo. Let's figure out what we can do that works for now, and then keep notes of what to improve for the future. This patch works. As I noted in my previous response, LTH will not get destroyed because the layer keeps a ref-ptr. Note that I am not calling setLayerTreeHost(0) when the layer is removed from the tree. > What if we treated GraphicsLayer::setChildren() as more of a bulk operation rather than as a serieis of individual operations that have to all maintain internal invariants? Could we do something smarter there? Yes we could make setChildren() smarter by not removing the layers common between the current child-list and new child-list. But we would also need to fix other functions that move layers in the tree. RenderLayer::removeOnlyThisLayer() is one such example. 544235 8 jamesr 2012-01-27 12:00:44 -0800 (In reply to comment #7) > (In reply to comment #6) > > It's fairly common for a layer to outlive the LTH. WebGLRenderingContexts have DrawingBuffers which have PlatformLayers (WebGLLayerChromiums). The context itself is held alive via a javascript reference which is often garbage collected after the page containing the canvas is navigated away from or destroyed. 2D canvas has the same thing with the reference chain HTMLCanvasElement -> ImageBuffer -> ImageBufferData::m_platformLayer. I'm not completely sure about video / plugin layers off the top of my head, but it wouldn't shock me if they outlived the page in some circumstances. > > > > I agree this is a pile of poo. Let's figure out what we can do that works for now, and then keep notes of what to improve for the future. > > This patch works. As I noted in my previous response, LTH will not get destroyed because the layer keeps a ref-ptr. Note that I am not calling setLayerTreeHost(0) when the layer is removed from the tree. > "Works" is a stretch - I think this patch breaks other things. We rely on "have LTH pointer set" meaning "currently in the compositing tree" in other places in the code, for example for canvas / webgl rate limiting, triggering new frames for canvas / webgl / video / plugins, and probably a few other things that I'm forgetting. I don't think it's value to simply leave the pointer there when a layer leaves the tree and hope that everything magically works out. I'm OK with a quick fix but it has to be better than this. 544675 9 jamesr 2012-01-28 12:30:58 -0800 We could make TextureManager managed the weak pointers explicitly and not attempt to clear ManagedTextures when nulling the LTH. Then if a layer leaves one LTH we can leave the ManagedTextures alive. If the LTH goes away before the layer, then ~TextureManager nulls out the ManagedTexture's m_manager pointers and the ManagedTexture is effectively dead. If the layer reenters the same tree then its ManagedTexture is still valid. The one tricky case is if the layer enters a different LTH all of its ManagedTextures that pointed to the previous LTH's TextureManager have to be dropped and regenerated with the new TextureManager. Canvas2DLayerChromium's m_frontTexture will have this problem. I think this is solvable in setLTH() by comparing the ManagedTexture's TextureManager pointer with the new LTH's contentsTextureManager and resetting if they differ. 546181 10 124764 alokp 2012-01-31 09:56:32 -0800 Created attachment 124764 proposed patch This patch caches the last valid LTH and clears the resources only when the layer is moved into another valid LTH. One problem that still needs to be solved is what happens when a layer is deleted after the LTH. James suggested this - "If the LTH goes away before the layer, then ~TextureManager nulls out the ManagedTexture's m_manager pointers and the ManagedTexture is effectively dead." But looking at ManagedTexture implementation, this does not seem feasible without major refactoring. ManagedTexture assumes that m_textureManager is valid in quite a few places. Am I missing something obvious? Vangelis suggested adding the orphaned layers to a dummy branch in LTH. This will fix the issue of releasing the layers as soon as LTH is deleted, but if ref-count the layers in the dummy branch, the layers themselves will not get deleted when they are detached from the tree. 546184 11 webkit.review.bot 2012-01-31 09:57:55 -0800 Attachment 124764 did not pass style-queue: Failed to run "['Tools/Scripts/update-webkit']" exit_code: 9 Updating OpenSource First, rewinding head to replay your work on top of it... Applying: Fix compilation errors on build-webkit --debug --no-workers on mac. Using index info to reconstruct a base tree... Falling back to patching base and 3-way merge... Auto-merging LayoutTests/ChangeLog CONFLICT (content): Merge conflict in LayoutTests/ChangeLog Auto-merging LayoutTests/platform/qt/Skipped CONFLICT (content): Merge conflict in LayoutTests/platform/qt/Skipped Auto-merging Source/WebCore/ChangeLog CONFLICT (content): Merge conflict in Source/WebCore/ChangeLog Failed to merge in the changes. Patch failed at 0001 Fix compilation errors on build-webkit --debug --no-workers on mac. When you have resolved this problem run "git rebase --continue". If you would prefer to skip this patch, instead run "git rebase --skip". To restore the original branch and stop rebasing run "git rebase --abort". rebase refs/remotes/origin/master: command returned error: 1 Died at Tools/Scripts/update-webkit line 164. If any of these errors are false positives, please file a bug against check-webkit-style. 546232 12 124764 jamesr 2012-01-31 10:57:35 -0800 Comment on attachment 124764 proposed patch I'm afraid this doesn't work either, pointer identity != object identity in C++. Consider: Layer removed from LTH A LTH A destroyed new LTH B allocated at the same addresses as LTH A layer added to LTH B pointer comparison passes, but all other state on the layer is still bogus! This also doesn't address the problems I pointed out earlier with leaving the LTH pointer set while the layer is out of the tree. 546235 13 jamesr 2012-01-31 10:59:03 -0800 (In reply to comment #10) > Created an attachment (id=124764) [details] > proposed patch > > This patch caches the last valid LTH and clears the resources only when the layer is moved into another valid LTH. One problem that still needs to be solved is what happens when a layer is deleted after the LTH. > > James suggested this - "If the LTH goes away before the layer, then ~TextureManager nulls out the ManagedTexture's m_manager pointers and the ManagedTexture is effectively dead." But looking at ManagedTexture implementation, this does not seem feasible without major refactoring. ManagedTexture assumes that m_textureManager is valid in quite a few places. Am I missing something obvious? > It's just adding some null checks and ASSERT()s. In particular isValid() and reserve() have to return false when the manager is null, most other functions should just ASSERT(). Did you even try this? 546253 14 alokp 2012-01-31 11:06:41 -0800 (In reply to comment #13) > (In reply to comment #10) > > Created an attachment (id=124764) [details] [details] > > proposed patch > > > > This patch caches the last valid LTH and clears the resources only when the layer is moved into another valid LTH. One problem that still needs to be solved is what happens when a layer is deleted after the LTH. > > > > James suggested this - "If the LTH goes away before the layer, then ~TextureManager nulls out the ManagedTexture's m_manager pointers and the ManagedTexture is effectively dead." But looking at ManagedTexture implementation, this does not seem feasible without major refactoring. ManagedTexture assumes that m_textureManager is valid in quite a few places. Am I missing something obvious? > > > > It's just adding some null checks and ASSERT()s. In particular isValid() and reserve() have to return false when the manager is null, most other functions should just ASSERT(). Did you even try this? I did not try it. It looked hairy. Most importantly I did not see any reference to ManagedTexture from TextureManager, which only holds texture tokens and ids. Do you know if there is a way to map the texture ids/tokens to ManagedTexture? 546260 15 jamesr 2012-01-31 11:09:24 -0800 That's what I was suggesting you add. 547434 16 alokp 2012-02-01 15:30:04 -0800 (In reply to comment #9) > We could make TextureManager managed the weak pointers explicitly and not attempt to clear ManagedTextures when nulling the LTH. Then if a layer leaves one LTH we can leave the ManagedTextures alive. If the LTH goes away before the layer, then ~TextureManager nulls out the ManagedTexture's m_manager pointers and the ManagedTexture is effectively dead. If the layer reenters the same tree then its ManagedTexture is still valid. This reasonable and easy to implement. In fact I have it working locally. > The one tricky case is if the layer enters a different LTH all of its ManagedTextures that pointed to the previous LTH's TextureManager have to be dropped and regenerated with the new TextureManager. Canvas2DLayerChromium's m_frontTexture will have this problem. I think this is solvable in setLTH() by comparing the ManagedTexture's TextureManager pointer with the new LTH's contentsTextureManager and resetting if they differ. This is really tricky to handle in TiledLayerChromium::setLayerTreeHost(). To avoid resetting all ManagedTextures held in tiles, we need to make sure that: 1. TextureManager is the same. This is simple - just iterate through the tile textures and compare TextureManager pointers. 2. The dirty-rect stored in the layer (tiles) is still valid. Is it? If not we would need to invalidate all tiles which defeats the whole purpose. 3. TiledLayerChromium::m_textureUpdater can be reused. The tiles hold a weak reference to TiledLayerChromium::m_textureUpdater via UpdatableTile->m_texture->m_textureUpdater. As soon as m_textureUpdater is recreated, all tiles need to deleted because they will be holding garbage. This is turning out to be more complicated than I anticipated. I wonder if making setChildren() smarter would be better. 548203 17 125201 alokp 2012-02-02 15:39:47 -0800 Created attachment 125201 proposed patch This is another approach that just collects all layers being orphaned during layout and releases them at the end of layout. 548209 18 webkit.review.bot 2012-02-02 15:44:02 -0800 Attachment 125201 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:177: The parameter name "layer" adds no information, so it should be removed. [readability/parameter_name] [5] Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:178: The parameter name "layer" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 2 in 6 files If any of these errors are false positives, please file a bug against check-webkit-style. 548237 19 jamesr 2012-02-02 16:26:39 -0800 (In reply to comment #16) > > The one tricky case is if the layer enters a different LTH all of its ManagedTextures that pointed to the previous LTH's TextureManager have to be dropped and regenerated with the new TextureManager. Canvas2DLayerChromium's m_frontTexture will have this problem. I think this is solvable in setLTH() by comparing the ManagedTexture's TextureManager pointer with the new LTH's contentsTextureManager and resetting if they differ. > > This is really tricky to handle in TiledLayerChromium::setLayerTreeHost(). To avoid resetting all ManagedTextures held in tiles, we need to make sure that: > 1. TextureManager is the same. This is simple - just iterate through the tile textures and compare TextureManager pointers. > 2. The dirty-rect stored in the layer (tiles) is still valid. Is it? If not we would need to invalidate all tiles which defeats the whole purpose. ManagedTextures don't have dirty rects. There is no case in which you need to worry about the dirty rects. If the TextureManager is different, then request a new token from the new TextureManager and stick it in the ManagedTexture. Then the next time we go to paint the layer will see that isValid() is false on that tile and grow the dirty rect as appropriate, but you don't need to add any new logic for that. > 3. TiledLayerChromium::m_textureUpdater can be reused. The tiles hold a weak reference to TiledLayerChromium::m_textureUpdater via UpdatableTile->m_texture->m_textureUpdater. As soon as m_textureUpdater is recreated, all tiles need to deleted because they will be holding garbage. Sure, just do that if you need to. > > This is turning out to be more complicated than I anticipated. I wonder if making setChildren() smarter would be better. That only solves one type of mutations. I think you think this is more complicated than it really is. 548239 20 125201 jamesr 2012-02-02 16:29:43 -0800 Comment on attachment 125201 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=125201&action=review This again won't work. Layout can happen at nearly any time, not just when called by WebViewImpl, since javascript can force layout to happen inline. > Source/WebCore/ChangeLog:8 > + Do not release layer resources during Layout. bizarre capitalization of a random Word here. > Source/WebCore/ChangeLog:9 > + Collect all render layers being orphaned and release them at the end of Layout. same Here > Source/WebKit/chromium/src/WebViewImpl.cpp:1183 > // setFrameRect may have the side-effect of causing existing page > // layout to be invalidated, so layout needs to be called last. > + if (m_layerTreeHost) > + m_layerTreeHost->beginLayout(); there are many other ways to enter layout beside this one. Set a breakpoint in GraphicsLayerChromium::setChildren() and see. I don't think this approach is scalable. 548241 21 jamesr 2012-02-02 16:30:43 -0800 Making ManagedTextures robust to TextureManager deletion would be useful for https://bugs.webkit.org/show_bug.cgi?id=77655 as well, could you upload that part to that bug if you have it working already, Alok? I guess I'll just have to write the rest of the patch myself. 548421 22 alokp 2012-02-02 21:22:04 -0800 (In reply to comment #21) > Making ManagedTextures robust to TextureManager deletion would be useful for https://bugs.webkit.org/show_bug.cgi?id=77655 as well, could you upload that part to that bug if you have it working already, Alok? I guess I'll just have to write the rest of the patch myself. I have uploaded the patch for TextureManager. 548435 23 alokp 2012-02-02 21:35:57 -0800 (In reply to comment #19) > (In reply to comment #16) > > > The one tricky case is if the layer enters a different LTH all of its ManagedTextures that pointed to the previous LTH's TextureManager have to be dropped and regenerated with the new TextureManager. Canvas2DLayerChromium's m_frontTexture will have this problem. I think this is solvable in setLTH() by comparing the ManagedTexture's TextureManager pointer with the new LTH's contentsTextureManager and resetting if they differ. > > > > This is really tricky to handle in TiledLayerChromium::setLayerTreeHost(). To avoid resetting all ManagedTextures held in tiles, we need to make sure that: > > 1. TextureManager is the same. This is simple - just iterate through the tile textures and compare TextureManager pointers. > > 2. The dirty-rect stored in the layer (tiles) is still valid. Is it? If not we would need to invalidate all tiles which defeats the whole purpose. > > ManagedTextures don't have dirty rects. There is no case in which you need to worry about the dirty rects. If the TextureManager is different, then request a new token from the new TextureManager and stick it in the ManagedTexture. Then the next time we go to paint the layer will see that isValid() is false on that tile and grow the dirty rect as appropriate, but you don't need to add any new logic for that. I was concerned about UpdatableTile::m_dirtyRect which is set inside TiledLayerChromium::invalidateRect(). If a layer moves within the same tree or to another tree, are those dirty rects still valid? Currently we invalidate the whole layer. > > > 3. TiledLayerChromium::m_textureUpdater can be reused. The tiles hold a weak reference to TiledLayerChromium::m_textureUpdater via UpdatableTile->m_texture->m_textureUpdater. As soon as m_textureUpdater is recreated, all tiles need to deleted because they will be holding garbage. > > Sure, just do that if you need to. Deleting all tiles is equivalent to call cleanupResources(), so you really want to reuse m_textureUpdater. This can be done but would require caching and comparing all parameters (CCLayerTreeHost::m_settings and LayerRendererCapabilities) that determine the type of LayerTextureUpdater. I can give it a try. I got discouraged because it started looking super ugly. > > > > This is turning out to be more complicated than I anticipated. I wonder if making setChildren() smarter would be better. > > That only solves one type of mutations. You are right. Thats why I was aiming for a more general solution. 549259 24 125452 jamesr 2012-02-03 17:15:53 -0800 Created attachment 125452 Patch 549288 25 jamesr 2012-02-03 17:47:54 -0800 With this patch I don't see any extra texture uploads on jsgamebench canvas demo, other than the FPS counter div which is changing every frame. 549702 26 125452 alokp 2012-02-05 20:52:28 -0800 Comment on attachment 125452 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125452&action=review > Source/WebCore/platform/graphics/chromium/Canvas2DLayerChromium.cpp:124 > + if (m_useDoubleBuffering && host) Is there a reason for moving the check for m_useDouldeBuffering here? > Source/WebCore/platform/graphics/chromium/LayerChromium.cpp:-109 > - // If we're changing hosts then we need to free up any resources Now that we are not releasing resources with setLayerTreeHost(0), we should do that at least in the destructor of layers. > Source/WebCore/platform/graphics/chromium/ManagedTexture.h:49 > + void setTextureManager(TextureManager*); Is there a difference between clearManager() and setTextureManager(0)? > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:264 > +void TiledLayerChromium::setLayerTreeHost(CCLayerTreeHost* host) I still see one problem here that I mentioned previously. If the host changes, the subclasses may need to update the texture-updater, because the type of texture-updater depends on host settings and layer-renderer-capabilities. Also this is based on the assumption that when a layer moves from one host to another, the dirty-rect remains valid. I am not sure if we can make that assumption, but if we do, a comment shoudl be added here to that effect. > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:267 > + if (host) { you do not want to do this if (host == layerTreeHost()) 549704 27 125452 jamesr 2012-02-05 21:12:18 -0800 Comment on attachment 125452 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125452&action=review >> Source/WebCore/platform/graphics/chromium/Canvas2DLayerChromium.cpp:124 >> + if (m_useDoubleBuffering && host) > > Is there a reason for moving the check for m_useDouldeBuffering here? It's shorter, where would you put it? >> Source/WebCore/platform/graphics/chromium/LayerChromium.cpp:-109 >> - // If we're changing hosts then we need to free up any resources > > Now that we are not releasing resources with setLayerTreeHost(0), we should do that at least in the destructor of layers. cleanupResources() just clears out member variables, which the destructor does anyway >> Source/WebCore/platform/graphics/chromium/ManagedTexture.h:49 >> + void setTextureManager(TextureManager*); > > Is there a difference between clearManager() and setTextureManager(0)? Yes, setTextureManager calls unregisterTexture on the previous owner. That's not necessary if the manager is going away >> Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:264 >> +void TiledLayerChromium::setLayerTreeHost(CCLayerTreeHost* host) > > I still see one problem here that I mentioned previously. If the host changes, the subclasses may need to update the texture-updater, because the type of texture-updater depends on host settings and layer-renderer-capabilities. Also this is based on the assumption that when a layer moves from one host to another, the dirty-rect remains valid. I am not sure if we can make that assumption, but if we do, a comment shoudl be added here to that effect. No, that's wrong. Tiled layers don't move between hosts and the dirty rect would be orthogonal even if they could. >> Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:267 >> + if (host) { > > you do not want to do this if (host == layerTreeHost()) it doesn't change behavior at all since setTextureManager() to the same value is a no-op, but we don't have to iterate if the host is the same as the old one. will add an early-out here before landing 550058 28 125452 alokp 2012-02-06 09:27:36 -0800 Comment on attachment 125452 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125452&action=review >>> Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:264 >>> +void TiledLayerChromium::setLayerTreeHost(CCLayerTreeHost* host) >> >> I still see one problem here that I mentioned previously. If the host changes, the subclasses may need to update the texture-updater, because the type of texture-updater depends on host settings and layer-renderer-capabilities. Also this is based on the assumption that when a layer moves from one host to another, the dirty-rect remains valid. I am not sure if we can make that assumption, but if we do, a comment shoudl be added here to that effect. > > No, that's wrong. Tiled layers don't move between hosts and the dirty rect would be orthogonal even if they could. Sorry I do not understand. Both - ImageLayerChromium and ContentLayerChromium use LTH to create a particular type of texture-updater. If LTH is changed shouldn't texture-updater be recreated/updated as well? http://trac.webkit.org/browser/trunk/Source/WebCore/platform/graphics/chromium/ImageLayerChromium.cpp#L174 http://trac.webkit.org/browser/trunk/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.cpp#L126 550104 29 jamesr 2012-02-06 10:58:25 -0800 The LTH isn't changed for Image or Content layers. 550119 30 alokp 2012-02-06 11:14:01 -0800 (In reply to comment #29) > The LTH isn't changed for Image or Content layers. Ah. I was working under a different assumption given your earlier comment: https://bugs.webkit.org/show_bug.cgi?id=77135#c9 LGTM then. It would be nice to enforce this assumption via an ASSERT though. 550154 31 jamesr 2012-02-06 11:48:41 -0800 (In reply to comment #30) > (In reply to comment #29) > > The LTH isn't changed for Image or Content layers. > > Ah. I was working under a different assumption given your earlier comment: > https://bugs.webkit.org/show_bug.cgi?id=77135#c9 > > LGTM then. It would be nice to enforce this assumption via an ASSERT though. Sorry for the confusion - in general layers can change LTH, but in the particular case of Image and Content this doesn't happen. 550435 32 125733 jamesr 2012-02-06 17:06:07 -0800 Created attachment 125733 Patch 550445 33 jamesr 2012-02-06 17:13:46 -0800 Updating to get EWS runs since the dependent patch has landed and this applies cleanly to ToT. 550465 34 125733 vangelis 2012-02-06 17:38:34 -0800 Comment on attachment 125733 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125733&action=review Somewhat tangentially related to this CL but can we also remove ImageLayerChromium::createTexture() . I don't think it's being used anywhere (I was trying to see if there are any other ManagedTextures that would require notification when the LTH changes and found that method). > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:66 > + if (manager == m_textureManager) Doesn't this suffer from the same pointer equality issue you mentioned in a previous review? If there's a new LTH that happens to create a TextureManager at the same address as the old one, then things will go out of whack. The sequence would be: Layer->setLTH(LTH1) : managed texture's manager is LTH1->m_contentsManager Layer->setLTH(0) : managed texture's manager is still LTH1->m_contentsManager Destroy LTH1 Create LTH2 . It just so happens that LTH2->m_contentsManager == LTH1->m_contentsManager Layer->setLTH(LTH2) : managed texture won't know that it really moved to a new manager. 550478 35 jamesr 2012-02-06 17:46:30 -0800 (In reply to comment #34) > (From update of attachment 125733 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=125733&action=review > > Somewhat tangentially related to this CL but can we also remove ImageLayerChromium::createTexture() . I don't think it's being used anywhere (I was trying to see if there are any other ManagedTextures that would require notification when the LTH changes and found that method). > > > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:66 > > + if (manager == m_textureManager) > > Doesn't this suffer from the same pointer equality issue you mentioned in a previous review? If there's a new LTH that happens to create a TextureManager at the same address as the old one, then things will go out of whack. The sequence would be: > > Layer->setLTH(LTH1) : managed texture's manager is LTH1->m_contentsManager > Layer->setLTH(0) : managed texture's manager is still LTH1->m_contentsManager > Destroy LTH1 This step will also destroy LTH1->m_contentsTextureManager, and ~TextureManager will call clearManager() on every ManagedTexture referring to the TextureManager setting their m_textureManager pointer to 0 > Create LTH2 . It just so happens that LTH2->m_contentsManager == LTH1->m_contentsManager > Layer->setLTH(LTH2) : managed texture won't know that it really moved to a new manager. This is fine since ManagedTexture will compare the new TextureManager pointer to 0 and see that it's different. 550482 36 vangelis 2012-02-06 17:48:39 -0800 (In reply to comment #35) > (In reply to comment #34) > > (From update of attachment 125733 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=125733&action=review > > > > Somewhat tangentially related to this CL but can we also remove ImageLayerChromium::createTexture() . I don't think it's being used anywhere (I was trying to see if there are any other ManagedTextures that would require notification when the LTH changes and found that method). > > > > > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:66 > > > + if (manager == m_textureManager) > > > > Doesn't this suffer from the same pointer equality issue you mentioned in a previous review? If there's a new LTH that happens to create a TextureManager at the same address as the old one, then things will go out of whack. The sequence would be: > > > > Layer->setLTH(LTH1) : managed texture's manager is LTH1->m_contentsManager > > Layer->setLTH(0) : managed texture's manager is still LTH1->m_contentsManager > > Destroy LTH1 > > This step will also destroy LTH1->m_contentsTextureManager, and ~TextureManager will call clearManager() on every ManagedTexture referring to the TextureManager setting their m_textureManager pointer to 0 > > > Create LTH2 . It just so happens that LTH2->m_contentsManager == LTH1->m_contentsManager > > Layer->setLTH(LTH2) : managed texture won't know that it really moved to a new manager. > > This is fine since ManagedTexture will compare the new TextureManager pointer to 0 and see that it's different. Ah, of course.. You're right. Nevermind! 550502 37 125733 kbr 2012-02-06 18:17:13 -0800 Comment on attachment 125733 Patch Nice. rs=me 550510 38 jamesr 2012-02-06 18:24:52 -0800 Committed r106891: <http://trac.webkit.org/changeset/106891> 124196 2012-01-26 15:35:56 -0800 2012-01-31 09:56:32 -0800 proposed patch 77135.patch text/plain 2187 alokp SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDEwNjA1NCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDEyLTAxLTI2ICBBbG9rIFBy aXlhZGFyc2hpICA8YWxva3BAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gY2Fu dmFzIGRlbW8gaXMgc2xvdyBkdWUgdG8gdW5uZWNlc3NhcnkgcmVzb3VyY2UgY2xlYW51cHMKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTM1CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRGVsYXkgcmVsZWFz aW5nIGxheWVyIHJlc291cmNlcyB1bnRpbCB0aGUgbGF5ZXIgaXMgZWl0aGVyIGRlc3Ryb3llZAor ICAgICAgICBvciBtb3ZlZCB0byBhIGRpZmZlcmVudCBMYXllclRyZWVIb3N0LgorCisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpMYXllckNocm9taXVtOjp+TGF5ZXJDaHJvbWl1bSk6CisgICAgICAgIChXZWJD b3JlOjpMYXllckNocm9taXVtOjpzZXRQYXJlbnQpOgorCiAyMDEyLTAxLTI2ICBBbG9rIFByaXlh ZGFyc2hpICA8YWxva3BAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFtjaHJvbWl1bV0gUmVtb3Zl IGRlYWQgYW5kIHVubmVjZXNzYXJ5IGNvZGUgcmVsYXRlZCB0byBMYXllckNocm9taXVtOjpjbGVh bnVwUmVzb3VyY2VzCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9MYXllckNocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmNwcAkocmV2aXNpb24gMTA2MDUy KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJv bWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTg2LDYgKzg2LDkgQEAgTGF5ZXJDaHJvbWl1bTo6 fkxheWVyQ2hyb21pdW0oKQogICAgIC8vIHdheSBmb3IgdXMgdG8gYmUgZGVzdHJveWVkIHdoaWxl IHdlIHN0aWxsIGhhdmUgYSBwYXJlbnQuCiAgICAgQVNTRVJUKCFwYXJlbnQoKSk7CiAKKyAgICAv LyBEZXRhY2ggZnJvbSBDQ0xheWVyVHJlZUhvc3QgYW5kIGNsZWFudXAgYXNzb2NpYXRlZCByZXNv dXJjZXMuCisgICAgc2V0TGF5ZXJUcmVlSG9zdCgwKTsKKwogICAgIC8vIFJlbW92ZSB0aGUgcGFy ZW50IHJlZmVyZW5jZSBmcm9tIGFsbCBjaGlsZHJlbi4KICAgICByZW1vdmVBbGxDaGlsZHJlbigp OwogfQpAQCAtMTMwLDcgKzEzMywxNCBAQCB2b2lkIExheWVyQ2hyb21pdW06OnNldFBhcmVudChM YXllckNocm9tCiB7CiAgICAgQVNTRVJUKCFsYXllciB8fCAhbGF5ZXItPmhhc0FuY2VzdG9yKHRo aXMpKTsKICAgICBtX3BhcmVudCA9IGxheWVyOwotICAgIHNldExheWVyVHJlZUhvc3QobV9wYXJl bnQgPyBtX3BhcmVudC0+bGF5ZXJUcmVlSG9zdCgpIDogMCk7CisKKyAgICAvLyBEZXRhY2ggZnJv bSBvciBhdHRhY2ggdG8gQ0NMYXllclRyZWVIb3N0IG9ubHkgd2hlbiBhIG5ldyBDQ0xheWVyVHJl ZUhvc3QKKyAgICAvLyBpcyBwcm92aWRlZC4gSWYgdGhpcyBsYXllciBpcyBkZXRhY2hlZCBmcm9t IGEgdHJlZSBhbmQgbmV2ZXIgYXR0YWNoZWQKKyAgICAvLyB0byBhIG5ldyBvbmUsIHRoZSByZXNv dXJjZXMgd2lsbCBiZSByZWxlYXNlZCBpbiB0aGUgZGVzdHJ1Y3Rvci4KKyAgICAvLyBUaGlzIGlz IHRvIGF2b2lkIHJlbGVhc2luZyByZXNvdXJjZXMgaW4gY2FzZXMgd2hlbiBhIGxheWVyIGlzIGp1 c3QgYmVpbmcKKyAgICAvLyBtb3ZlZCB3aXRoaW4gdGhlIHNhbWUgdHJlZSBob3N0LgorICAgIGlm IChtX3BhcmVudCkKKyAgICAgICAgc2V0TGF5ZXJUcmVlSG9zdChtX3BhcmVudC0+bGF5ZXJUcmVl SG9zdCgpKTsKIH0KIAogYm9vbCBMYXllckNocm9taXVtOjpoYXNBbmNlc3RvcihMYXllckNocm9t aXVtKiBhbmNlc3RvcikgY29uc3QK 124764 2012-01-31 09:56:32 -0800 2012-02-02 15:39:47 -0800 proposed patch 77135.patch text/plain 8091 alokp SW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJE TGF5ZXJDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcAkocmV2aXNpb24gMTA2 MDUyKQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFz MkRMYXllckNocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE2LDEyICsxMTYsMTAgQEAg dm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OnBhaW50Q29udGVudAogICAgIG1fY29udGV4dC0+ Zmx1c2goKTsKIH0KIAotdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OnNldExheWVyVHJlZUhv c3QoQ0NMYXllclRyZWVIb3N0KiBob3N0KQordm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OmVu dGVyZWRMYXllclRyZWVIb3N0KENDTGF5ZXJUcmVlSG9zdCogaG9zdCkKIHsKLSAgICBpZiAobGF5 ZXJUcmVlSG9zdCgpICE9IGhvc3QpCi0gICAgICAgIHNldFRleHR1cmVNYW5hZ2VyKGhvc3QgPyBo b3N0LT5jb250ZW50c1RleHR1cmVNYW5hZ2VyKCkgOiAwKTsKLQotICAgIENhbnZhc0xheWVyQ2hy b21pdW06OnNldExheWVyVHJlZUhvc3QoaG9zdCk7CisgICAgQVNTRVJUKGhvc3QpOworICAgIHNl dFRleHR1cmVNYW5hZ2VyKGhvc3QtPmNvbnRlbnRzVGV4dHVyZU1hbmFnZXIoKSk7CiB9CiAKIHZv aWQgQ2FudmFzMkRMYXllckNocm9taXVtOjpzZXRUZXh0dXJlTWFuYWdlcihUZXh0dXJlTWFuYWdl ciogdGV4dHVyZU1hbmFnZXIpCkBAIC0xNjksNiArMTY3LDggQEAgdm9pZCBDYW52YXMyRExheWVy Q2hyb21pdW06OmNsZWFudXBSZXNvdQogewogICAgIGlmIChtX3VzZURvdWJsZUJ1ZmZlcmluZykK ICAgICAgICAgbV9mcm9udFRleHR1cmUuY2xlYXIoKTsKKworICAgIENhbnZhc0xheWVyQ2hyb21p dW06OmNsZWFudXBSZXNvdXJjZXMoKTsKIH0KIAogfQpJbmRleDogU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRM YXllckNocm9taXVtLmgJKHJldmlzaW9uIDEwNjA1MikKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJDaHJvbWl1bS5oCSh3b3JraW5nIGNv cHkpCkBAIC01NCwxNSArNTQsMTYgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBkcmF3c0Nv bnRlbnQoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgcGFpbnRDb250ZW50c0lmRGlydHkoKTsK IAotICAgIHZpcnR1YWwgdm9pZCBzZXRMYXllclRyZWVIb3N0KENDTGF5ZXJUcmVlSG9zdCopOwog ICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4 dDNEKiwgQ0NUZXh0dXJlVXBkYXRlciYpOwogICAgIHZpcnR1YWwgdm9pZCBwdXNoUHJvcGVydGll c1RvKENDTGF5ZXJJbXBsKik7CiAgICAgdmlydHVhbCB2b2lkIHVucmVzZXJ2ZUNvbnRlbnRzVGV4 dHVyZSgpOwotICAgIHZpcnR1YWwgdm9pZCBjbGVhbnVwUmVzb3VyY2VzKCk7CiAKIHByaXZhdGU6 CiAgICAgQ2FudmFzMkRMYXllckNocm9taXVtKEdyYXBoaWNzQ29udGV4dDNEKiwgY29uc3QgSW50 U2l6ZSYpOwogCisgICAgdmlydHVhbCB2b2lkIGNsZWFudXBSZXNvdXJjZXMoKTsKKyAgICB2aXJ0 dWFsIHZvaWQgZW50ZXJlZExheWVyVHJlZUhvc3QoQ0NMYXllclRyZWVIb3N0Kik7CisKICAgICAv LyBWaXNpYmxlIGZvciB0ZXN0aW5nIHNvIHdlIGNhbiBieXBhc3Mgc2V0TGF5ZXJUcmVlSG9zdC4K ICAgICBmcmllbmQgY2xhc3MgQ2FudmFzMkRMYXllckNocm9taXVtVGVzdDsKICAgICB2b2lkIHNl dFRleHR1cmVNYW5hZ2VyKFRleHR1cmVNYW5hZ2VyKik7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVt LmNwcAkocmV2aXNpb24gMTA2MDUyKQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU4LDYgKzU4 LDcgQEAgTGF5ZXJDaHJvbWl1bTo6TGF5ZXJDaHJvbWl1bSgpCiAgICAgOiBtX25lZWRzRGlzcGxh eShmYWxzZSkKICAgICAsIG1fbGF5ZXJJZChzX25leHRMYXllcklkKyspCiAgICAgLCBtX3BhcmVu dCgwKQorICAgICwgbV9sYXN0VmFsaWRMYXllclRyZWVIb3N0KDApCiAgICAgLCBtX3Njcm9sbGFi bGUoZmFsc2UpCiAgICAgLCBtX2FuY2hvclBvaW50KDAuNSwgMC41KQogICAgICwgbV9iYWNrZ3Jv dW5kQ29sb3IoMCwgMCwgMCwgMCkKQEAgLTg2LDYgKzg3LDggQEAgTGF5ZXJDaHJvbWl1bTo6fkxh eWVyQ2hyb21pdW0oKQogICAgIC8vIHdheSBmb3IgdXMgdG8gYmUgZGVzdHJveWVkIHdoaWxlIHdl IHN0aWxsIGhhdmUgYSBwYXJlbnQuCiAgICAgQVNTRVJUKCFwYXJlbnQoKSk7CiAKKyAgICBjbGVh bnVwUmVzb3VyY2VzKCk7CisKICAgICAvLyBSZW1vdmUgdGhlIHBhcmVudCByZWZlcmVuY2UgZnJv bSBhbGwgY2hpbGRyZW4uCiAgICAgcmVtb3ZlQWxsQ2hpbGRyZW4oKTsKIH0KQEAgLTEwNiwxMCAr MTA5LDE1IEBAIHZvaWQgTGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdChDQ0wKIAogICAg IC8vIElmIHdlJ3JlIGNoYW5naW5nIGhvc3RzIHRoZW4gd2UgbmVlZCB0byBmcmVlIHVwIGFueSBy ZXNvdXJjZXMKICAgICAvLyBhbGxvY2F0ZWQgYnkgdGhlIG9sZCBob3N0LgotICAgIGlmIChtX2xh eWVyVHJlZUhvc3QpCi0gICAgICAgIGNsZWFudXBSZXNvdXJjZXMoKTsKLQorICAgIC8vIE5vdGUg dGhhdCB3ZSBvbmx5IGZyZWUgcmVzb3VyY2VzIHdoZW4gdGhpcyBsYXllcnMgZW50ZXJzIGEgbm9u LW51bGwKKyAgICAvLyBob3N0IGRpZmZlcmVudCBmcm9tIHRoZSBsYXN0IG5vbi1udWxsIGhvc3Qu IFRoaXMgaXMgdG8gYXZvaWQgdW5uZWNlc3NhcnkKKyAgICAvLyByZXNvdXJjZSBjbGVhbnVwcyB3 aGVuIG1lcmVseSBtb3ZpbmcgYSBsYXllciB3aXRoaW4gaW4gdGhlIHNhbWUgdHJlZS4KICAgICBt X2xheWVyVHJlZUhvc3QgPSBob3N0OworICAgIGlmIChob3N0ICYmIChob3N0ICE9IG1fbGFzdFZh bGlkTGF5ZXJUcmVlSG9zdCkpIHsKKyAgICAgICAgY2xlYW51cFJlc291cmNlcygpOworICAgICAg ICBlbnRlcmVkTGF5ZXJUcmVlSG9zdChob3N0KTsKKyAgICAgICAgbV9sYXN0VmFsaWRMYXllclRy ZWVIb3N0ID0gaG9zdDsKKyAgICB9CiAKICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fY2hp bGRyZW4uc2l6ZSgpOyArK2kpCiAgICAgICAgIG1fY2hpbGRyZW5baV0tPnNldExheWVyVHJlZUhv c3QoaG9zdCk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllckNocm9taXVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oCShyZXZpc2lvbiAxMDYwNTIpCisrKyBT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgJ KHdvcmtpbmcgY29weSkKQEAgLTE0NCw3ICsxNDQsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2 b2lkIHNldElzTm9uQ29tcG9zaXRlZENvbnRlbnQoYm9vbCk7CiAgICAgYm9vbCBpc05vbkNvbXBv c2l0ZWRDb250ZW50KCkgY29uc3QgeyByZXR1cm4gbV9pc05vbkNvbXBvc2l0ZWRDb250ZW50OyB9 CiAKLSAgICB2aXJ0dWFsIHZvaWQgc2V0TGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3QqKTsK KyAgICB2b2lkIHNldExheWVyVHJlZUhvc3QoQ0NMYXllclRyZWVIb3N0Kik7CiAKICAgICB2b2lk IHNldElzRHJhd2FibGUoYm9vbCk7CiAKQEAgLTIwNSw2ICsyMDUsOSBAQCBwcm90ZWN0ZWQ6CiAg ICAgLy8gaG9sZCBjb250ZXh0LWRlcGVuZGVudCByZXNvdXJjZXMgc3VjaCBhcyB0ZXh0dXJlcy4K ICAgICB2aXJ0dWFsIHZvaWQgY2xlYW51cFJlc291cmNlcygpOwogCisgICAgLy8gQ2FsbGVkIHdo ZW4gdGhpcyBsYXllciBlbnRlcnMgYSBuZXcgTFRILgorICAgIHZpcnR1YWwgdm9pZCBlbnRlcmVk TGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3QqKSB7IH0KKwogICAgIHZvaWQgc2V0TmVlZHND b21taXQoKTsKIAogICAgIC8vIFRoaXMgZmxhZyBpcyBzZXQgd2hlbiBsYXllciBuZWVkIHJlcGFp bnRpbmcvdXBkYXRpbmcuCkBAIC0yNDMsNiArMjQ2LDcgQEAgcHJpdmF0ZToKICAgICBMYXllckNo cm9taXVtKiBtX3BhcmVudDsKIAogICAgIFJlZlB0cjxDQ0xheWVyVHJlZUhvc3Q+IG1fbGF5ZXJU cmVlSG9zdDsKKyAgICBDQ0xheWVyVHJlZUhvc3QqIG1fbGFzdFZhbGlkTGF5ZXJUcmVlSG9zdDsK IAogICAgIC8vIExheWVyIHByb3BlcnRpZXMuCiAgICAgSW50U2l6ZSBtX2JvdW5kczsKSW5kZXg6 IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2Vy LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9UZXh0dXJlTWFuYWdlci5jcHAJKHJldmlzaW9uIDEwNjA1MikKKysrIFNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMTAzLDYgKzEwMywxMCBAQCBUZXh0dXJlTWFuYWdlcjo6VGV4dHVyZU1hbmFn ZXIoc2l6ZV90IG1hCiB7CiB9CiAKK1RleHR1cmVNYW5hZ2VyOjp+VGV4dHVyZU1hbmFnZXIoKQor eworfQorCiB2b2lkIFRleHR1cmVNYW5hZ2VyOjpzZXRNYXhNZW1vcnlMaW1pdEJ5dGVzKHNpemVf dCBtZW1vcnlMaW1pdEJ5dGVzKQogewogICAgIHJlZHVjZU1lbW9yeVRvTGltaXQobWVtb3J5TGlt aXRCeXRlcyk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9UZXh0dXJlTWFuYWdlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmgJKHJldmlzaW9uIDEwNjA1MikKKysr IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2Vy LmgJKHdvcmtpbmcgY29weSkKQEAgLTU0LDYgKzU0LDggQEAgcHVibGljOgogICAgICAgICByZXR1 cm4gYWRvcHRQdHIobmV3IFRleHR1cmVNYW5hZ2VyKG1heE1lbW9yeUxpbWl0Qnl0ZXMsIHByZWZl cnJlZE1lbW9yeUxpbWl0Qnl0ZXMsIG1heFRleHR1cmVTaXplKSk7CiAgICAgfQogCisgICAgflRl eHR1cmVNYW5hZ2VyKCk7CisKICAgICAvLyBBYnNvbHV0ZSBtYXhpbXVtIGxpbWl0IGZvciB0ZXh0 dXJlIGFsbG9jYXRpb25zIGZvciB0aGlzIGluc3RhbmNlLgogICAgIHN0YXRpYyBzaXplX3QgaGln aExpbWl0Qnl0ZXMoY29uc3QgSW50U2l6ZSYgdmlld3BvcnRTaXplKTsKICAgICAvLyBQcmVmZXJy ZWQgdGV4dHVyZSBzaXplIGxpbWl0IGdpdmVuIHRoZSB2aWV3cG9ydCBzaXplLgpJbmRleDogU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVt LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCShyZXZpc2lvbiAxMDYwNTIpCisrKyBTb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC05MywxMSArOTMsMTEgQEAgUGFzc1JlZlB0cjxDQ0xheWVySW1w bD4gVGlsZWRMYXllckNocm9taQogCiB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6Y2xlYW51cFJl c291cmNlcygpCiB7Ci0gICAgTGF5ZXJDaHJvbWl1bTo6Y2xlYW51cFJlc291cmNlcygpOwotCi0g ICAgbV90aWxlci0+cmVzZXQoKTsKICAgICBtX3BhaW50UmVjdCA9IEludFJlY3QoKTsKICAgICBt X3JlcXVlc3RlZFVwZGF0ZVRpbGVzUmVjdCA9IEludFJlY3QoKTsKKyAgICBtX3RpbGVyLT5yZXNl dCgpOworCisgICAgTGF5ZXJDaHJvbWl1bTo6Y2xlYW51cFJlc291cmNlcygpOwogfQogCiB2b2lk IFRpbGVkTGF5ZXJDaHJvbWl1bTo6dXBkYXRlVGlsZVNpemVBbmRUaWxpbmdPcHRpb24oKQpAQCAt MTczLDE2ICsxNzMsOSBAQCBJbnRTaXplIFRpbGVkTGF5ZXJDaHJvbWl1bTo6Y29udGVudEJvdW5k CiAgICAgcmV0dXJuIEludFNpemUobHJvdW5kZihib3VuZHMoKS53aWR0aCgpICogY29udGVudHNT Y2FsZSgpKSwgbHJvdW5kZihib3VuZHMoKS5oZWlnaHQoKSAqIGNvbnRlbnRzU2NhbGUoKSkpOwog fQogCi12b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJl ZUhvc3QqIGhvc3QpCit2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6ZW50ZXJlZExheWVyVHJlZUhv c3QoQ0NMYXllclRyZWVIb3N0KiBob3N0KQogewotICAgIGlmIChob3N0ID09IGxheWVyVHJlZUhv c3QoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgTGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVl SG9zdChob3N0KTsKLQotICAgIGlmICghaG9zdCkKLSAgICAgICAgcmV0dXJuOwotCisgICAgQVNT RVJUKGhvc3QpOwogICAgIGNyZWF0ZVRleHR1cmVVcGRhdGVyKGhvc3QpOwogICAgIHNldFRleHR1 cmVGb3JtYXQoaG9zdC0+bGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpLmJlc3RUZXh0dXJlRm9y bWF0KTsKICAgICBtX3NhbXBsZWRUZXhlbEZvcm1hdCA9IHRleHR1cmVVcGRhdGVyKCktPnNhbXBs ZWRUZXhlbEZvcm1hdChtX3RleHR1cmVGb3JtYXQpOwpJbmRleDogU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNo cm9taXVtLmgJKHJldmlzaW9uIDEwNjA1MikKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oCSh3b3JraW5nIGNvcHkpCkBAIC02 NSw2ICs2NSw4IEBAIHByb3RlY3RlZDoKICAgICBUaWxlZExheWVyQ2hyb21pdW0oKTsKIAogICAg IHZpcnR1YWwgdm9pZCBjbGVhbnVwUmVzb3VyY2VzKCk7CisgICAgdmlydHVhbCB2b2lkIGVudGVy ZWRMYXllclRyZWVIb3N0KENDTGF5ZXJUcmVlSG9zdCopOworCiAgICAgdm9pZCB1cGRhdGVUaWxl U2l6ZUFuZFRpbGluZ09wdGlvbigpOwogICAgIHZvaWQgdXBkYXRlQm91bmRzKCk7CiAKQEAgLTk3 LDggKzk5LDYgQEAgcHJvdGVjdGVkOgogcHJpdmF0ZToKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8 Q0NMYXllckltcGw+IGNyZWF0ZUNDTGF5ZXJJbXBsKCk7CiAKLSAgICB2aXJ0dWFsIHZvaWQgc2V0 TGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3QqKTsKLQogICAgIHZvaWQgY3JlYXRlVGlsZXJJ Zk5lZWRlZCgpOwogICAgIHZvaWQgc2V0VGlsaW5nT3B0aW9uKFRpbGluZ09wdGlvbik7CiAK 125201 2012-02-02 15:39:47 -0800 2012-02-03 17:14:56 -0800 proposed patch 77135.patch text/plain 9025 alokp SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDEwNjU5NykKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDMxIEBACisyMDEyLTAyLTAyICBBbG9rIFBy aXlhZGFyc2hpICA8YWxva3BAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gY2Fu dmFzIGRlbW8gaXMgc2xvdyBkdWUgdG8gdW5uZWNlc3NhcnkgcmVzb3VyY2UgY2xlYW51cHMKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTM1CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRG8gbm90IHJlbGVh c2UgbGF5ZXIgcmVzb3VyY2VzIGR1cmluZyBMYXlvdXQuCisgICAgICAgIENvbGxlY3QgYWxsIHJl bmRlciBsYXllcnMgYmVpbmcgb3JwaGFuZWQgYW5kIHJlbGVhc2UgdGhlbSBhdCB0aGUgZW5kIG9m IExheW91dC4KKyAgICAgICAgVGhpcyBwcmV2ZW50cyB1bm5lY2Vzc2FyaWx5IHJlbGVhc2luZyBy ZXNvdXJjZXMgZm9yIGxheWVycyB0aGF0IGFyZSBqdXN0IGJlaW5nIG1vdmVkIHdpdGhpbiB0aGUg c2FtZSB0cmVlLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJD aHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpMYXllckNocm9taXVtOjpzZXRQYXJlbnQp OgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJDaHJvbWl1bTo6c2V0TWFza0xheWVyKToKKyAgICAg ICAgKFdlYkNvcmU6OkxheWVyQ2hyb21pdW06OnNldFJlcGxpY2FMYXllcik6CisgICAgICAgICog cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6Q0NMYXllclRyZWVIb3N0KToKKyAgICAgICAg KFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6fkNDTGF5ZXJUcmVlSG9zdCk6CisgICAgICAgIChX ZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmJlZ2luTGF5b3V0KToKKyAgICAgICAgKFdlYkNvcmUp OgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0OjpsYXlvdXRDb21wbGV0ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmxheWVyRGlkRW50ZXJUcmVlKToKKyAg ICAgICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6bGF5ZXJXaWxsTGVhdmVUcmVlKToKKyAg ICAgICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6ZGVsZXRlVGV4dHVyZUFmdGVyQ29tbWl0 KToKKyAgICAgICAgKFdlYkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6cmVsZWFzZU9ycGhhbkxheWVy cyk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVI b3N0Lmg6CisgICAgICAgIChDQ0xheWVyVHJlZUhvc3QpOgorCiAyMDEyLTAyLTAyICBDaHJpcyBN YXJyaW4gIDxjbWFycmluQGFwcGxlLmNvbT4KIAogICAgICAgICBUdXJuIG9uIENTUyBGaWx0ZXJz IG9uIFdpbmRvd3MKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uY3BwCShyZXZpc2lvbiAxMDY0MzQp CisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9t aXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTMxLDggKzEzMSwxNiBAQCB2b2lkIExheWVyQ2hy b21pdW06OnNldE5lZWRzQ29tbWl0KCkKIHZvaWQgTGF5ZXJDaHJvbWl1bTo6c2V0UGFyZW50KExh eWVyQ2hyb21pdW0qIGxheWVyKQogewogICAgIEFTU0VSVCghbGF5ZXIgfHwgIWxheWVyLT5oYXNB bmNlc3Rvcih0aGlzKSk7CisKKyAgICBDQ0xheWVyVHJlZUhvc3QqIG9sZEhvc3QgPSBtX2xheWVy VHJlZUhvc3QuZ2V0KCk7CisgICAgQ0NMYXllclRyZWVIb3N0KiBuZXdIb3N0ID0gbGF5ZXIgPyBs YXllci0+bGF5ZXJUcmVlSG9zdCgpIDogMDsKKyAgICBpZiAob2xkSG9zdCAmJiAob2xkSG9zdCAh PSBuZXdIb3N0KSkKKyAgICAgICAgb2xkSG9zdC0+bGF5ZXJXaWxsTGVhdmVUcmVlKHRoaXMpOwor CiAgICAgbV9wYXJlbnQgPSBsYXllcjsKLSAgICBzZXRMYXllclRyZWVIb3N0KG1fcGFyZW50ID8g bV9wYXJlbnQtPmxheWVyVHJlZUhvc3QoKSA6IDApOworCisgICAgaWYgKG5ld0hvc3QgJiYgKG5l d0hvc3QgIT0gb2xkSG9zdCkpCisgICAgICAgIG5ld0hvc3QtPmxheWVyRGlkRW50ZXJUcmVlKHRo aXMpOwogfQogCiBib29sIExheWVyQ2hyb21pdW06Omhhc0FuY2VzdG9yKExheWVyQ2hyb21pdW0q IGFuY2VzdG9yKSBjb25zdApAQCAtMjk0LDExICszMDIsMTEgQEAgdm9pZCBMYXllckNocm9taXVt OjpzZXRNYXNrTGF5ZXIoTGF5ZXJDaAogewogICAgIGlmIChtX21hc2tMYXllciA9PSBtYXNrTGF5 ZXIpCiAgICAgICAgIHJldHVybjsKLSAgICBpZiAobV9tYXNrTGF5ZXIpCi0gICAgICAgIG1fbWFz a0xheWVyLT5zZXRMYXllclRyZWVIb3N0KDApOworICAgIGlmIChtX21hc2tMYXllciAmJiBtX2xh eWVyVHJlZUhvc3QpCisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+bGF5ZXJXaWxsTGVhdmVUcmVl KG1fbWFza0xheWVyLmdldCgpKTsKICAgICBtX21hc2tMYXllciA9IG1hc2tMYXllcjsKLSAgICBp ZiAobV9tYXNrTGF5ZXIpCi0gICAgICAgIG1fbWFza0xheWVyLT5zZXRMYXllclRyZWVIb3N0KG1f bGF5ZXJUcmVlSG9zdC5nZXQoKSk7CisgICAgaWYgKG1fbWFza0xheWVyICYmIG1fbGF5ZXJUcmVl SG9zdCkKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5sYXllckRpZEVudGVyVHJlZShtX21hc2tM YXllci5nZXQoKSk7CiAgICAgc2V0TmVlZHNDb21taXQoKTsKIH0KIApAQCAtMzA2LDExICszMTQs MTEgQEAgdm9pZCBMYXllckNocm9taXVtOjpzZXRSZXBsaWNhTGF5ZXIoTGF5ZQogewogICAgIGlm IChtX3JlcGxpY2FMYXllciA9PSBsYXllcikKICAgICAgICAgcmV0dXJuOwotICAgIGlmIChtX3Jl cGxpY2FMYXllcikKLSAgICAgICAgbV9yZXBsaWNhTGF5ZXItPnNldExheWVyVHJlZUhvc3QoMCk7 CisgICAgaWYgKG1fcmVwbGljYUxheWVyICYmIG1fbGF5ZXJUcmVlSG9zdCkKKyAgICAgICAgbV9s YXllclRyZWVIb3N0LT5sYXllcldpbGxMZWF2ZVRyZWUobV9yZXBsaWNhTGF5ZXIuZ2V0KCkpOwog ICAgIG1fcmVwbGljYUxheWVyID0gbGF5ZXI7Ci0gICAgaWYgKG1fcmVwbGljYUxheWVyKQotICAg ICAgICBtX3JlcGxpY2FMYXllci0+c2V0TGF5ZXJUcmVlSG9zdChtX2xheWVyVHJlZUhvc3QuZ2V0 KCkpOworICAgIGlmIChtX3JlcGxpY2FMYXllciAmJiBtX2xheWVyVHJlZUhvc3QpCisgICAgICAg IG1fbGF5ZXJUcmVlSG9zdC0+bGF5ZXJEaWRFbnRlclRyZWUobV9yZXBsaWNhTGF5ZXIuZ2V0KCkp OwogICAgIHNldE5lZWRzQ29tbWl0KCk7CiB9CiAKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRy ZWVIb3N0LmNwcAkocmV2aXNpb24gMTA2NDM0KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAkod29ya2luZyBjb3B5KQpA QCAtNjEsNiArNjEsNyBAQCBQYXNzUmVmUHRyPENDTGF5ZXJUcmVlSG9zdD4gQ0NMYXllclRyZWVI CiBDQ0xheWVyVHJlZUhvc3Q6OkNDTGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3RDbGllbnQq IGNsaWVudCwgY29uc3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MpCiAgICAgOiBtX2NvbXBvc2l0b3JJ ZGVudGlmaWVyKC0xKQogICAgICwgbV9hbmltYXRpbmcoZmFsc2UpCisgICAgLCBtX2luTGF5b3V0 KGZhbHNlKQogICAgICwgbV9jbGllbnQoY2xpZW50KQogICAgICwgbV9mcmFtZU51bWJlcigwKQog ICAgICwgbV9zZXR0aW5ncyhzZXR0aW5ncykKQEAgLTExMyw2ICsxMTQsNyBAQCBDQ0xheWVyVHJl ZUhvc3Q6On5DQ0xheWVyVHJlZUhvc3QoKQogICAgIG1fcHJveHktPnN0b3AoKTsKICAgICBtX3By b3h5LmNsZWFyKCk7CiAgICAgY2xlYXJQZW5kaW5nVXBkYXRlKCk7CisgICAgcmVsZWFzZU9ycGhh bkxheWVycygpOwogICAgIG51bUxheWVyVHJlZUluc3RhbmNlcy0tOwogfQogCkBAIC0xNzQsNiAr MTc2LDE3IEBAIHZvaWQgQ0NMYXllclRyZWVIb3N0Ojpjb21taXRDb21wbGV0ZSgpCiAgICAgbV9j b250ZW50c1RleHR1cmVNYW5hZ2VyLT51bnByb3RlY3RBbGxUZXh0dXJlcygpOwogfQogCit2b2lk IENDTGF5ZXJUcmVlSG9zdDo6YmVnaW5MYXlvdXQoKQoreworICAgIG1faW5MYXlvdXQgPSB0cnVl OworfQorCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6bGF5b3V0Q29tcGxldGUoKQoreworICAgIHJl bGVhc2VPcnBoYW5MYXllcnMoKTsKKyAgICBtX2luTGF5b3V0ID0gZmFsc2U7Cit9CisKIFBhc3NS ZWZQdHI8R3JhcGhpY3NDb250ZXh0M0Q+IENDTGF5ZXJUcmVlSG9zdDo6Y3JlYXRlTGF5ZXJUcmVl SG9zdENvbnRleHQzRCgpCiB7CiAgICAgcmV0dXJuIG1fY2xpZW50LT5jcmVhdGVMYXllclRyZWVI b3N0Q29udGV4dDNEKCk7CkBAIC0yNDksNiArMjYyLDI0IEBAIHZvaWQgQ0NMYXllclRyZWVIb3N0 OjpzZXRSb290TGF5ZXIoUGFzc1IKICAgICBzZXROZWVkc0NvbW1pdCgpOwogfQogCit2b2lkIEND TGF5ZXJUcmVlSG9zdDo6bGF5ZXJEaWRFbnRlclRyZWUoTGF5ZXJDaHJvbWl1bSogbGF5ZXIpCit7 CisgICAgQVNTRVJUKGxheWVyKTsKKyAgICBsYXllci0+c2V0TGF5ZXJUcmVlSG9zdCh0aGlzKTsK K30KKwordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmxheWVyV2lsbExlYXZlVHJlZShMYXllckNocm9t aXVtKiBsYXllcikKK3sKKyAgICBBU1NFUlQobGF5ZXIpOworICAgIC8vIER1cmluZyBsYXlvdXQg aXQgaXMgY29tbW9uIHRvIG1vdmUgbGF5ZXJzIHdpdGhpbiB0aGUgc2FtZSB0cmVlLgorICAgIC8v IERvIG5vdCByZWxlYXNlIHRoZSBvcnBoYW5lZCBsYXllcnMgdW50aWwgbGF5b3V0IGhhcyBjb21w bGV0ZWQuCisgICAgLy8gUmVsZWFzaW5nIGEgbGF5ZXIgYWxzbyByZWxlYXNlcyBhbGwgdGV4dHVy ZSByZXNvdXJjZXMuCisgICAgaWYgKG1faW5MYXlvdXQpCisgICAgICAgIG1fb3JwaGFuTGF5ZXJz LmFwcGVuZChsYXllcik7CisgICAgZWxzZQorICAgICAgICBsYXllci0+c2V0TGF5ZXJUcmVlSG9z dCgwKTsKK30KKwogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnNldFZpZXdwb3J0U2l6ZShjb25zdCBJ bnRTaXplJiB2aWV3cG9ydFNpemUpCiB7CiAgICAgaWYgKHZpZXdwb3J0U2l6ZSA9PSBtX3ZpZXdw b3J0U2l6ZSkKQEAgLTU5Myw0ICs2MjQsMTcgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0 ZVRleHR1cmVBZnRlcgogICAgIG1fZGVsZXRlVGV4dHVyZUFmdGVyQ29tbWl0TGlzdC5hcHBlbmQo dGV4dHVyZSk7CiB9CiAKK3ZvaWQgQ0NMYXllclRyZWVIb3N0OjpyZWxlYXNlT3JwaGFuTGF5ZXJz KCkKK3sKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1fb3JwaGFuTGF5ZXJzLnNpemUoKTsg KytpKSB7CisgICAgICAgIExheWVyQ2hyb21pdW0qIGxheWVyID0gbV9vcnBoYW5MYXllcnNbaV0u Z2V0KCk7CisgICAgICAgIC8vIENoZWNrIGlmIHRoZSBsYXllciBpcyBzdGlsbCBhbiBvcnBoYW4u CisgICAgICAgIC8vIExheWVycyBtYXkgZ2V0IHBhcmVudGVkIGFnYWluIGR1cmluZyBsYXlvdXQu CisgICAgICAgIGlmIChsYXllci0+cGFyZW50KCkgfHwgKGxheWVyID09IHJvb3RMYXllcigpKSkK KyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICBsYXllci0+c2V0TGF5ZXJUcmVlSG9zdCgw KTsKKyAgICB9CisgICAgbV9vcnBoYW5MYXllcnMuY2xlYXIoKTsKK30KKwogfQpJbmRleDogU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0 LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NMYXllclRyZWVIb3N0LmgJKHJldmlzaW9uIDEwNjQzNCkKKysrIFNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCSh3b3Jr aW5nIGNvcHkpCkBAIC0xMzgsNiArMTM4LDEwIEBAIHB1YmxpYzoKICAgICB2b2lkIGRpZENvbXBs ZXRlU3dhcEJ1ZmZlcnMoKSB7IG1fY2xpZW50LT5kaWRDb21wbGV0ZVN3YXBCdWZmZXJzKCk7IH0K ICAgICB2b2lkIGRlbGV0ZUNvbnRlbnRzVGV4dHVyZXNPbkltcGxUaHJlYWQoVGV4dHVyZUFsbG9j YXRvciopOwogCisgICAgLy8gTm90aWZpY2F0aW9uIHRoYXQgbGF5b3V0IGhhcyBzdGFydGVkL2Nv bXBsZXRlZC4KKyAgICB2b2lkIGJlZ2luTGF5b3V0KCk7CisgICAgdm9pZCBsYXlvdXRDb21wbGV0 ZSgpOworCiAgICAgQ0NMYXllclRyZWVIb3N0Q2xpZW50KiBjbGllbnQoKSB7IHJldHVybiBtX2Ns aWVudDsgfQogCiAgICAgaW50IGNvbXBvc2l0b3JJZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4g bV9jb21wb3NpdG9ySWRlbnRpZmllcjsgfQpAQCAtMTcwLDYgKzE3NCw5IEBAIHB1YmxpYzoKICAg ICBjb25zdCBMYXllckNocm9taXVtKiByb290TGF5ZXIoKSBjb25zdCB7IHJldHVybiBtX3Jvb3RM YXllci5nZXQoKTsgfQogICAgIHZvaWQgc2V0Um9vdExheWVyKFBhc3NSZWZQdHI8TGF5ZXJDaHJv bWl1bT4pOwogCisgICAgdm9pZCBsYXllckRpZEVudGVyVHJlZShMYXllckNocm9taXVtKiBsYXll cik7CisgICAgdm9pZCBsYXllcldpbGxMZWF2ZVRyZWUoTGF5ZXJDaHJvbWl1bSogbGF5ZXIpOwor CiAgICAgY29uc3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MoKSBjb25zdCB7IHJldHVybiBtX3NldHRp bmdzOyB9CiAKICAgICB2b2lkIHNldFZpZXdwb3J0U2l6ZShjb25zdCBJbnRTaXplJik7CkBAIC0y MTQsMTAgKzIyMSwxMiBAQCBwcml2YXRlOgogICAgIC8vIFByZS1yZXNlcnZlIHRleHR1cmVzIGZv ciBhbnkgbGF5ZXIgbWFya2VkICJhbHdheXMgcmVzZXJ2ZSB0ZXh0dXJlcyIKICAgICB2b2lkIHJl c2VydmVUZXh0dXJlcygpOwogICAgIHZvaWQgY2xlYXJQZW5kaW5nVXBkYXRlKCk7CisgICAgdm9p ZCByZWxlYXNlT3JwaGFuTGF5ZXJzKCk7CiAKICAgICBpbnQgbV9jb21wb3NpdG9ySWRlbnRpZmll cjsKIAogICAgIGJvb2wgbV9hbmltYXRpbmc7CisgICAgYm9vbCBtX2luTGF5b3V0OwogCiAgICAg Q0NMYXllclRyZWVIb3N0Q2xpZW50KiBtX2NsaWVudDsKIApAQCAtMjQzLDYgKzI1Miw3IEBAIHBy aXZhdGU6CiAgICAgYm9vbCBtX3RyaWdnZXJJZGxlUGFpbnRzOwogCiAgICAgVGV4dHVyZUxpc3Qg bV9kZWxldGVUZXh0dXJlQWZ0ZXJDb21taXRMaXN0OworICAgIExheWVyTGlzdCBtX29ycGhhbkxh eWVyczsKIH07CiAKIH0KSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiAx MDY1OTcpCisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDEzIEBACisyMDEyLTAyLTAyICBBbG9rIFByaXlhZGFyc2hpICA8YWxva3BA Y2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gY2FudmFzIGRlbW8gaXMgc2xvdyBk dWUgdG8gdW5uZWNlc3NhcnkgcmVzb3VyY2UgY2xlYW51cHMKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTM1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAgICAg ICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6bGF5b3V0KToKKwogMjAxMi0wMi0wMiAgVG9tbXkgV2lk ZW5mbHljaHQgIDx0b21teXdAZ29vZ2xlLmNvbT4KIAogICAgICAgICBbY2hyb21pdW1dIE1lZGlh U3RyZWFtIEFQSTogQWRkaW5nIHRoZSBlbWJlZGRpbmcgY29kZSBmb3IgTWVkaWFTdHJlYW1DZW50 ZXIKSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAJKHJl dmlzaW9uIDEwNjQzNCkKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBs LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE3OSw4ICsxMTc5LDEzIEBAIHZvaWQgV2ViVmlld0lt cGw6OmxheW91dCgpCiAKICAgICAgICAgLy8gc2V0RnJhbWVSZWN0IG1heSBoYXZlIHRoZSBzaWRl LWVmZmVjdCBvZiBjYXVzaW5nIGV4aXN0aW5nIHBhZ2UKICAgICAgICAgLy8gbGF5b3V0IHRvIGJl IGludmFsaWRhdGVkLCBzbyBsYXlvdXQgbmVlZHMgdG8gYmUgY2FsbGVkIGxhc3QuCisgICAgICAg IGlmIChtX2xheWVyVHJlZUhvc3QpCisgICAgICAgICAgICBtX2xheWVyVHJlZUhvc3QtPmJlZ2lu TGF5b3V0KCk7CiAKICAgICAgICAgd2ViZnJhbWUtPmxheW91dCgpOworCisgICAgICAgIGlmICht X2xheWVyVHJlZUhvc3QpCisgICAgICAgICAgICBtX2xheWVyVHJlZUhvc3QtPmxheW91dENvbXBs ZXRlKCk7CiAgICAgfQogfQogCg== 125452 2012-02-03 17:15:53 -0800 2012-02-06 17:06:03 -0800 Patch bug-77135-20120203171552.patch text/plain 17179 jamesr U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NzAwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzdiYzViYWQ5ZDNhNGQ2 N2M4OGQ1MmNhMDQzZGVhZjEzZGVlYzczZC4uNjAyMDZlYjllZTRjMzBiNzE1ZjFmY2QyZWZiOGNk YjQwMDE1NGUwOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDQ0IEBACiAyMDEyLTAyLTAzICBKYW1l cyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAKKyAgICAgICAgW2Nocm9taXVtXSBj YW52YXMgZGVtbyBpcyBzbG93IGR1ZSB0byB1bm5lY2Vzc2FyeSByZXNvdXJjZSBjbGVhbnVwcwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzcxMzUKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIGRlZmVy cyBkcm9wcGluZyBhIE1hbmFnZWRUZXh0dXJlIHVudGlsIGl0IGlzIGV2aWN0ZWQgYnkgdGhlIG1h bmFnZXIsIHRoZSBsYXllciBpcyBkZXN0cm95ZWQsIHRoZQorICAgICAgICBUZXh0dXJlTWFuYWdl ciBpcyBkZXN0cm95ZWQsIG9yIHRoZSBsYXllciBpcyBhZGRlZCB0byBhIENDTGF5ZXJUcmVlSG9z dCB0aGF0IGhhcyBhIGRpZmZlcmVudCB0ZXh0dXJlIG1hbmFnZXIuIEluCisgICAgICAgIHBhcnRp Y3VsYXIsIHJlbW92aW5nIGEgbGF5ZXIgZnJvbSBhIENDTGF5ZXJUcmVlSG9zdCBhbmQgdGhlbiBh ZGRpbmcgaXQgYmFjayB0byB0aGUgc2FtZSBob3N0IGRvZXMgbm90IGRyb3AgYW55CisgICAgICAg IE1hbmFnZWRUZXh0dXJlcyB1bmxlc3MgdGhlIG1hbmFnZXIgaGFzIHRvIGV2aWN0IGl0IGZvciBv dGhlciByZWFzb25zLiBUaGlzIHByb3ZpZGVzIGEgYmlnIHNwZWVkdXAgb24gc2l0ZXMgdGhhdAor ICAgICAgICByZWJ1aWxkIHRoZSBjb21wb3NpdGluZyB0cmVlIGZyZXF1ZW50bHkuCisKKyAgICAg ICAgTmV3IHVuaXQgdGVzdCBhZGRlZCBmb3IgTWFuYWdlZFRleHR1cmUgLyBUZXh0dXJlTWFuYWdl ciBpbnRlcmFjdGlvbi4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDYW52YXMyRExheWVy Q2hyb21pdW06OnNldExheWVyVHJlZUhvc3QpOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzMkRM YXllckNocm9taXVtOjpzZXRUZXh0dXJlTWFuYWdlcik6CisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmg6CisgICAgICAgIChDYW52YXMy RExheWVyQ2hyb21pdW0pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xh eWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJDaHJvbWl1bTo6c2V0TGF5 ZXJUcmVlSG9zdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJD aHJvbWl1bS5oOgorICAgICAgICAoTGF5ZXJDaHJvbWl1bSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 TWFuYWdlZFRleHR1cmU6OnNldFRleHR1cmVNYW5hZ2VyKToKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6TWFuYWdlZFRleHR1cmU6OnN0ZWFsKToKKyAgICAgICAgKFdlYkNv cmU6Ok1hbmFnZWRUZXh0dXJlOjpjbGVhcik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTWFuYWdlZFRleHR1cmUuaDoKKyAgICAgICAgKE1hbmFnZWRUZXh0dXJlKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9SZW5kZXJTdXJmYWNlQ2hyb21pdW0u aDoKKyAgICAgICAgKFJlbmRlclN1cmZhY2VDaHJvbWl1bSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdCk6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBk YXRlVGlsZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5 ZXJDaHJvbWl1bS5oOgorCisyMDEyLTAyLTAzICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJv bWl1bS5vcmc+CisKICAgICAgICAgU3VwcG9ydCBkZXRhY2hpbmcgVGV4dHVyZU1hbmFnZXIgZnJv bSBNYW5hZ2VkVGV4dHVyZQogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9Nzc2NTUKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAwYzUzN2Q1YjVk NDExZWE2MDhhMTEwOTBiZjNmNWUwMGNhNTQ1NWI0Li4yMjUyNTcwMjcwM2I2OGEyZDcyZWM0NDNk YmY4YmU0ZmVmYWJjMGYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDE3 IEBACiAyMDEyLTAyLTAzICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAK KyAgICAgICAgW2Nocm9taXVtXSBjYW52YXMgZGVtbyBpcyBzbG93IGR1ZSB0byB1bm5lY2Vzc2Fy eSByZXNvdXJjZSBjbGVhbnVwcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NzcxMzUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIHRlc3RzL0NhbnZhczJETGF5ZXJDaHJvbWl1bVRlc3QuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6Q2FudmFzMkRMYXllckNocm9taXVtVGVzdDo6ZnVsbExpZmVjeWNsZVRlc3Qp OgorICAgICAgICAqIHRlc3RzL1RleHR1cmVNYW5hZ2VyVGVzdC5jcHA6CisgICAgICAgICogdGVz dHMvVGlsZWRMYXllckNocm9taXVtVGVzdC5jcHA6CisKKzIwMTItMDItMDMgIEphbWVzIFJvYmlu c29uICA8amFtZXNyQGNocm9taXVtLm9yZz4KKwogICAgICAgICBbY2hyb21pdW1dIFN1cHBvcnQg ZGV0YWNoaW5nIFRleHR1cmVNYW5hZ2VyIGZyb20gTWFuYWdlZFRleHR1cmUKICAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3NjU1CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJD aHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9D YW52YXMyRExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDE2NjZiNjE4ZTExYjJmZWIxMzZkMDc1YmZl MjI3OTI4ZTBkMzNlY2MuLjE0ZmUzNWE1ODA1ZjZmZDA3ZjMzNzQzNGVmNDU5NWY0Nzk1NDc3NjAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcApAQCAtMTE5LDE4ICsxMTks MTggQEAgdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OnBhaW50Q29udGVudHNJZkRpcnR5KGNv bnN0IFJlZ2lvbiYgLyogb2NjbHVkZWRTY3JlZW4KIAogdm9pZCBDYW52YXMyRExheWVyQ2hyb21p dW06OnNldExheWVyVHJlZUhvc3QoQ0NMYXllclRyZWVIb3N0KiBob3N0KQogewotICAgIGlmIChs YXllclRyZWVIb3N0KCkgIT0gaG9zdCkKLSAgICAgICAgc2V0VGV4dHVyZU1hbmFnZXIoaG9zdCA/ IGhvc3QtPmNvbnRlbnRzVGV4dHVyZU1hbmFnZXIoKSA6IDApOwotCiAgICAgQ2FudmFzTGF5ZXJD aHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdChob3N0KTsKKworICAgIGlmIChtX3VzZURvdWJsZUJ1 ZmZlcmluZyAmJiBob3N0KQorICAgICAgICBzZXRUZXh0dXJlTWFuYWdlcihob3N0LT5jb250ZW50 c1RleHR1cmVNYW5hZ2VyKCkpOwogfQogCiB2b2lkIENhbnZhczJETGF5ZXJDaHJvbWl1bTo6c2V0 VGV4dHVyZU1hbmFnZXIoVGV4dHVyZU1hbmFnZXIqIHRleHR1cmVNYW5hZ2VyKQogewotICAgIGlm ICh0ZXh0dXJlTWFuYWdlciAmJiBtX3VzZURvdWJsZUJ1ZmZlcmluZykKLSAgICAgICAgbV9mcm9u dFRleHR1cmUgPSBNYW5hZ2VkVGV4dHVyZTo6Y3JlYXRlKHRleHR1cmVNYW5hZ2VyKTsKKyAgICBp ZiAobV9mcm9udFRleHR1cmUpCisgICAgICAgIG1fZnJvbnRUZXh0dXJlLT5zZXRUZXh0dXJlTWFu YWdlcih0ZXh0dXJlTWFuYWdlcik7CiAgICAgZWxzZQotICAgICAgICBtX2Zyb250VGV4dHVyZS5j bGVhcigpOworICAgICAgICBtX2Zyb250VGV4dHVyZSA9IE1hbmFnZWRUZXh0dXJlOjpjcmVhdGUo dGV4dHVyZU1hbmFnZXIpOwogfQogCiB2b2lkIENhbnZhczJETGF5ZXJDaHJvbWl1bTo6dXBkYXRl Q29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgQ0NUZXh0dXJl VXBkYXRlciYgdXBkYXRlcikKQEAgLTE2NiwxMiArMTY2LDYgQEAgdm9pZCBDYW52YXMyRExheWVy Q2hyb21pdW06OnVucmVzZXJ2ZUNvbnRlbnRzVGV4dHVyZSgpCiAgICAgICAgIG1fZnJvbnRUZXh0 dXJlLT51bnJlc2VydmUoKTsKIH0KIAotdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OmNsZWFu dXBSZXNvdXJjZXMoKQotewotICAgIGlmIChtX3VzZURvdWJsZUJ1ZmZlcmluZykKLSAgICAgICAg bV9mcm9udFRleHR1cmUuY2xlYXIoKTsKLX0KLQogfQogCiAjZW5kaWYgLy8gVVNFKEFDQ0VMRVJB VEVEX0NPTVBPU0lUSU5HKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uaAppbmRleCA4 NzcyMjRmNDFlYTFiNTVjZTllMDIwYTA4ZjJlODQxNDIzNzY4ZDRmLi4xMWExYTk1MzkwY2Q4ZTlh ZGE4ZmM4NGMxYjk5Yjc0YTBiMzU2OGNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21p dW0uaApAQCAtNjEsMTQgKzYxLDEyIEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgdXBkYXRl Q29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCosIENDVGV4dHVyZVVwZGF0ZXIm KTsKICAgICB2aXJ0dWFsIHZvaWQgcHVzaFByb3BlcnRpZXNUbyhDQ0xheWVySW1wbCopOwogICAg IHZpcnR1YWwgdm9pZCB1bnJlc2VydmVDb250ZW50c1RleHR1cmUoKTsKLSAgICB2aXJ0dWFsIHZv aWQgY2xlYW51cFJlc291cmNlcygpOwogCiAgICAgdm9pZCBzZXRDYW52YXMoU2tDYW52YXMqKTsK IAogcHJpdmF0ZToKICAgICBDYW52YXMyRExheWVyQ2hyb21pdW0oR3JhcGhpY3NDb250ZXh0M0Qq LCBjb25zdCBJbnRTaXplJik7CiAKLSAgICAvLyBWaXNpYmxlIGZvciB0ZXN0aW5nIHNvIHdlIGNh biBieXBhc3Mgc2V0TGF5ZXJUcmVlSG9zdC4KICAgICBmcmllbmQgY2xhc3MgQ2FudmFzMkRMYXll ckNocm9taXVtVGVzdDsKICAgICB2b2lkIHNldFRleHR1cmVNYW5hZ2VyKFRleHR1cmVNYW5hZ2Vy Kik7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggYjJmNzAxNDFiNDdhNWQ0N2I0NDAyOTM4 MGQzOGNiM2RjM2M1YjMyOC4uOGQwZmUwM2I2MTNiMjQ4MTcwZThmMzYyMDBkMTQwYmUwOTFmNDQ4 MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTkyLDEwICs5Miw2IEBAIExheWVyQ2hyb21p dW06On5MYXllckNocm9taXVtKCkKICAgICByZW1vdmVBbGxDaGlsZHJlbigpOwogfQogCi12b2lk IExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJjZXMoKQotewotfQotCiB2b2lkIExheWVyQ2hy b21pdW06OnNldElzTm9uQ29tcG9zaXRlZENvbnRlbnQoYm9vbCBpc05vbkNvbXBvc2l0ZWRDb250 ZW50KQogewogICAgIG1faXNOb25Db21wb3NpdGVkQ29udGVudCA9IGlzTm9uQ29tcG9zaXRlZENv bnRlbnQ7CkBAIC0xMDYsMTEgKzEwMiw2IEBAIHZvaWQgTGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJU cmVlSG9zdChDQ0xheWVyVHJlZUhvc3QqIGhvc3QpCiAgICAgaWYgKG1fbGF5ZXJUcmVlSG9zdCA9 PSBob3N0KQogICAgICAgICByZXR1cm47CiAKLSAgICAvLyBJZiB3ZSdyZSBjaGFuZ2luZyBob3N0 cyB0aGVuIHdlIG5lZWQgdG8gZnJlZSB1cCBhbnkgcmVzb3VyY2VzCi0gICAgLy8gYWxsb2NhdGVk IGJ5IHRoZSBvbGQgaG9zdC4KLSAgICBpZiAobV9sYXllclRyZWVIb3N0KQotICAgICAgICBjbGVh bnVwUmVzb3VyY2VzKCk7Ci0KICAgICBtX2xheWVyVHJlZUhvc3QgPSBob3N0OwogCiAgICAgZm9y IChzaXplX3QgaSA9IDA7IGkgPCBtX2NoaWxkcmVuLnNpemUoKTsgKytpKQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5o IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1 bS5oCmluZGV4IDc2NGY3MzAxNTViNTQ1MzdjZGE0YzczODFiM2ZkM2JjYjc5NjA2NGQuLmEwNzU4 MTMxZmJmZTIzNDY5MGIyNzMzYWVjNmJhMmY4YTE0ZDBjYTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgK QEAgLTIxNCwxMSArMjE0LDYgQEAgcHVibGljOgogcHJvdGVjdGVkOgogICAgIExheWVyQ2hyb21p dW0oKTsKIAotICAgIC8vIFRoaXMgaXMgY2FsbGVkIHRvIGNsZWFuIHVwIHJlc291cmNlcyBiZWlu ZyBoZWxkIGluIHRoZSBzYW1lIGNvbnRleHQgYXMKLSAgICAvLyBsYXllclJlbmRlcmVyQ29udGV4 dCgpLiBTdWJjbGFzc2VzIHNob3VsZCBvdmVycmlkZSB0aGlzIG1ldGhvZCBpZiB0aGV5Ci0gICAg Ly8gaG9sZCBjb250ZXh0LWRlcGVuZGVudCByZXNvdXJjZXMgc3VjaCBhcyB0ZXh0dXJlcy4KLSAg ICB2aXJ0dWFsIHZvaWQgY2xlYW51cFJlc291cmNlcygpOwotCiAgICAgYm9vbCBpc1BhaW50ZWRB eGlzQWxpZ25lZEluU2NyZWVuKCkgY29uc3Q7CiAKICAgICB2b2lkIHNldE5lZWRzQ29tbWl0KCk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9N YW5hZ2VkVGV4dHVyZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAKaW5kZXggNTQ4YjkzMWUyYjA3ZGRjOTQ2YWJhNDI4ZjA3 ZWIzODM2NjM1ZTBjYS4uYjI5ZGIwZWQ5ZTI4ZGM2ZDBlZjNmNzkwYTQ1NWIxZDJiMWYxMDA4OSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFu YWdlZFRleHR1cmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL01hbmFnZWRUZXh0dXJlLmNwcApAQCAtNjEsNiArNjEsMTkgQEAgTWFuYWdlZFRleHR1 cmU6On5NYW5hZ2VkVGV4dHVyZSgpCiAgICAgICAgIG1fdGV4dHVyZU1hbmFnZXItPnJlbGVhc2VU b2tlbihtX3Rva2VuKTsKIH0KIAordm9pZCBNYW5hZ2VkVGV4dHVyZTo6c2V0VGV4dHVyZU1hbmFn ZXIoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIpCit7CisgICAgaWYgKG1hbmFnZXIgPT0gbV90ZXh0 dXJlTWFuYWdlcikKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKG1fdGV4dHVyZU1hbmFnZXIp CisgICAgICAgIG1fdGV4dHVyZU1hbmFnZXItPnVucmVnaXN0ZXJUZXh0dXJlKHRoaXMpOworICAg IG1fdGV4dHVyZU1hbmFnZXIgPSBtYW5hZ2VyOworICAgIGNsZWFyKCk7CisgICAgaWYgKG1fdGV4 dHVyZU1hbmFnZXIpCisgICAgICAgIG1fdGV4dHVyZU1hbmFnZXItPnJlZ2lzdGVyVGV4dHVyZSh0 aGlzKTsKK30KKwogYm9vbCBNYW5hZ2VkVGV4dHVyZTo6aXNWYWxpZChjb25zdCBJbnRTaXplJiBz aXplLCB1bnNpZ25lZCBmb3JtYXQpCiB7CiAgICAgcmV0dXJuIG1fdG9rZW4gJiYgc2l6ZSA9PSBt X3NpemUgJiYgZm9ybWF0ID09IG1fZm9ybWF0ICYmIG1fdGV4dHVyZU1hbmFnZXIgJiYgbV90ZXh0 dXJlTWFuYWdlci0+aGFzVGV4dHVyZShtX3Rva2VuKTsKQEAgLTExOSwxNCArMTMyLDE4IEBAIHZv aWQgTWFuYWdlZFRleHR1cmU6OmZyYW1lYnVmZmVyVGV4dHVyZTJEKEdyYXBoaWNzQ29udGV4dDNE KiBjb250ZXh0LCBUZXh0dXJlQWxsCiBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBNYW5hZ2Vk VGV4dHVyZTo6c3RlYWwoKQogewogICAgIE93blB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSA9 IGFkb3B0UHRyKG5ldyBNYW5hZ2VkVGV4dHVyZShtX3RleHR1cmVNYW5hZ2VyLCBtX3Rva2VuLCBt X3NpemUsIG1fZm9ybWF0LCBtX3RleHR1cmVJZCkpOworICAgIGNsZWFyKCk7CisgICAgcmV0dXJu IHRleHR1cmUucmVsZWFzZSgpOworfQorCit2b2lkIE1hbmFnZWRUZXh0dXJlOjpjbGVhcigpCit7 CiAgICAgbV90b2tlbiA9IDA7CiAgICAgbV9zaXplID0gSW50U2l6ZSgpOwogICAgIG1fZm9ybWF0 ID0gMDsKICAgICBtX3RleHR1cmVJZCA9IDA7Ci0gICAgcmV0dXJuIHRleHR1cmUucmVsZWFzZSgp OwogfQogCi0KIH0KIAogI2VuZGlmIC8vIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFn ZWRUZXh0dXJlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9N YW5hZ2VkVGV4dHVyZS5oCmluZGV4IDk4OGRmNzcwYjM1MjBhOTM4Y2Y3ZGExMDc2OGRkZTQ5OTg5 NTEyZmIuLmVkNGQ0NTBlOTY5Y2UwYWI1NDdhOWFjNTEzOGQ0YzA5M2Q4MzlkNjIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0 dXJlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFu YWdlZFRleHR1cmUuaApAQCAtNDYsNiArNDYsNyBAQCBwdWJsaWM6CiAgICAgfQogICAgIH5NYW5h Z2VkVGV4dHVyZSgpOwogCisgICAgdm9pZCBzZXRUZXh0dXJlTWFuYWdlcihUZXh0dXJlTWFuYWdl ciopOwogICAgIHZvaWQgY2xlYXJNYW5hZ2VyKCkgeyBtX3RleHR1cmVNYW5hZ2VyID0gMDsgfQog CiAgICAgYm9vbCBpc1ZhbGlkKGNvbnN0IEludFNpemUmLCB1bnNpZ25lZCBmb3JtYXQpOwpAQCAt NzIsNiArNzMsOCBAQCBwcml2YXRlOgogICAgIGV4cGxpY2l0IE1hbmFnZWRUZXh0dXJlKFRleHR1 cmVNYW5hZ2VyKik7CiAgICAgTWFuYWdlZFRleHR1cmUoVGV4dHVyZU1hbmFnZXIqLCBUZXh0dXJl VG9rZW4sIEludFNpemUsIHVuc2lnbmVkIGZvcm1hdCwgdW5zaWduZWQgdGV4dHVyZUlkKTsKIAor ICAgIHZvaWQgY2xlYXIoKTsKKwogICAgIFRleHR1cmVNYW5hZ2VyKiBtX3RleHR1cmVNYW5hZ2Vy OwogICAgIFRleHR1cmVUb2tlbiBtX3Rva2VuOwogICAgIEludFNpemUgbV9zaXplOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vUmVuZGVyU3Vy ZmFjZUNocm9taXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9SZW5kZXJTdXJmYWNlQ2hyb21pdW0uaAppbmRleCBiZjQ5ODhjMjUzNzljZTIzYTQwMTJhODE0 NmRiNWE4NjJkMDM5ZjIwLi4zYzZmMTY0OWE1ZDI3ZTg3OGMzZTA3N2M0MjdmNDliNjc5OWQzNTk2 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9S ZW5kZXJTdXJmYWNlQ2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9SZW5kZXJTdXJmYWNlQ2hyb21pdW0uaApAQCAtNTEsNyArNTEsNiBAQCBw dWJsaWM6CiAKICAgICBib29sIHByZXBhcmVDb250ZW50c1RleHR1cmUoKTsKICAgICB2b2lkIHJl bGVhc2VDb250ZW50c1RleHR1cmUoKTsKLSAgICB2b2lkIGNsZWFudXBSZXNvdXJjZXMoKTsKICAg ICB2b2lkIGRyYXcoY29uc3QgSW50UmVjdCYgdGFyZ2V0U3VyZmFjZVJlY3QpOwogCiAgICAgLy8g UmV0dXJucyB0aGUgcmVjdCB0aGF0IGVuY2xvc2VzIHRoZSBSZW5kZXJTdXJmYWNlIGluY2x1ZGlu ZyBhbnkgcmVmbGVjdGlvbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDRm NmIyMzZjYjI0MmNhZDMwY2E4MDNiMmNkNGEwYzJjYmQxYWU5ZDguLmY5ZTRiMTFhZWYxZDlmYzdh ZmI3ZTQzY2MzZDNlY2IzZjM5OTBhMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNw cApAQCAtOTIsMTUgKzkyLDYgQEAgUGFzc1JlZlB0cjxDQ0xheWVySW1wbD4gVGlsZWRMYXllckNo cm9taXVtOjpjcmVhdGVDQ0xheWVySW1wbCgpCiAgICAgcmV0dXJuIENDVGlsZWRMYXllckltcGw6 OmNyZWF0ZShpZCgpKTsKIH0KIAotdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNv dXJjZXMoKQotewotICAgIExheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJjZXMoKTsKLQotICAg IG1fdGlsZXItPnJlc2V0KCk7Ci0gICAgbV9wYWludFJlY3QgPSBJbnRSZWN0KCk7Ci0gICAgbV9y ZXF1ZXN0ZWRVcGRhdGVUaWxlc1JlY3QgPSBJbnRSZWN0KCk7Ci19Ci0KIHZvaWQgVGlsZWRMYXll ckNocm9taXVtOjp1cGRhdGVUaWxlU2l6ZUFuZFRpbGluZ09wdGlvbigpCiB7CiAgICAgY29uc3Qg SW50U2l6ZSB0aWxlU2l6ZShtaW4oZGVmYXVsdFRpbGVTaXplLCBjb250ZW50Qm91bmRzKCkud2lk dGgoKSksIG1pbihkZWZhdWx0VGlsZVNpemUsIGNvbnRlbnRCb3VuZHMoKS5oZWlnaHQoKSkpOwpA QCAtMjcwLDYgKzI2MSwxNyBAQCBUZXh0dXJlTWFuYWdlciogVGlsZWRMYXllckNocm9taXVtOjp0 ZXh0dXJlTWFuYWdlcigpIGNvbnN0CiAgICAgcmV0dXJuIGxheWVyVHJlZUhvc3QoKS0+Y29udGVu dHNUZXh0dXJlTWFuYWdlcigpOwogfQogCit2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6c2V0TGF5 ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3QqIGhvc3QpCit7CisgICAgTGF5ZXJDaHJvbWl1bTo6 c2V0TGF5ZXJUcmVlSG9zdChob3N0KTsKKyAgICBpZiAoaG9zdCkgeworICAgICAgICBmb3IgKEND TGF5ZXJUaWxpbmdEYXRhOjpUaWxlTWFwOjpjb25zdF9pdGVyYXRvciBpdGVyID0gbV90aWxlci0+ dGlsZXMoKS5iZWdpbigpOyBpdGVyICE9IG1fdGlsZXItPnRpbGVzKCkuZW5kKCk7ICsraXRlcikg eworICAgICAgICAgICAgVXBkYXRhYmxlVGlsZSogdGlsZSA9IHN0YXRpY19jYXN0PFVwZGF0YWJs ZVRpbGUqPihpdGVyLT5zZWNvbmQuZ2V0KCkpOworICAgICAgICAgICAgdGlsZS0+bWFuYWdlZFRl eHR1cmUoKS0+c2V0VGV4dHVyZU1hbmFnZXIoaG9zdC0+Y29udGVudHNUZXh0dXJlTWFuYWdlcigp KTsKKyAgICAgICAgfQorICAgIH0KK30KKwogVXBkYXRhYmxlVGlsZSogVGlsZWRMYXllckNocm9t aXVtOjp0aWxlQXQoaW50IGksIGludCBqKSBjb25zdAogewogICAgIHJldHVybiBzdGF0aWNfY2Fz dDxVcGRhdGFibGVUaWxlKj4obV90aWxlci0+dGlsZUF0KGksIGopKTsKQEAgLTM4NCw3ICszODYs OSBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlVGlsZXMoYm9vbCBp ZGxlLCBpbnQgbGVmdCwgaW50IHRvcCwgaW50CiAgICAgICAgICAgICAgICAgICAgIC8vIGxheWVy IHNvIHRoYXQgY2hlY2tlcmJvYXJkZWQgdGlsZXMgd2lsbCBzdGlsbCBkcmF3LgogICAgICAgICAg ICAgICAgICAgICBpZiAoIWJhY2tncm91bmRDb3ZlcnNWaWV3cG9ydCgpKQogICAgICAgICAgICAg ICAgICAgICAgICAgbV9za2lwc0RyYXcgPSB0cnVlOwotICAgICAgICAgICAgICAgICAgICBjbGVh bnVwUmVzb3VyY2VzKCk7CisgICAgICAgICAgICAgICAgICAgIG1fdGlsZXItPnJlc2V0KCk7Cisg ICAgICAgICAgICAgICAgICAgIG1fcGFpbnRSZWN0ID0gSW50UmVjdCgpOworICAgICAgICAgICAg ICAgICAgICBtX3JlcXVlc3RlZFVwZGF0ZVRpbGVzUmVjdCA9IEludFJlY3QoKTsKICAgICAgICAg ICAgICAgICB9CiAgICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICAgfQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXll ckNocm9taXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U aWxlZExheWVyQ2hyb21pdW0uaAppbmRleCAyOWZlY2ZlNGNiZjk1OTA3MDA4OWVkY2JlYTVhNDRj MzhmODBkNDRjLi40NjE5MmZlNWQyNTZlNmUyN2VmYTFmNmFmOTBhNzhkNmRmODIwOTg0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExh eWVyQ2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9UaWxlZExheWVyQ2hyb21pdW0uaApAQCAtNTgsNiArNTgsOCBAQCBwdWJsaWM6CiAKICAg ICB2aXJ0dWFsIHZvaWQgc2V0SXNOb25Db21wb3NpdGVkQ29udGVudChib29sKTsKIAorICAgIHZp cnR1YWwgdm9pZCBzZXRMYXllclRyZWVIb3N0KENDTGF5ZXJUcmVlSG9zdCopOworCiAgICAgLy8g UmVzZXJ2ZXMgYWxsIGV4aXN0aW5nIGFuZCB2YWxpZCB0aWxlIHRleHR1cmVzIHRvIHByb3RlY3Qg dGhlbSBmcm9tIGJlaW5nCiAgICAgLy8gcmVjeWNsZWQgYnkgdGhlIHRleHR1cmUgbWFuYWdlci4K ICAgICB2b2lkIHByb3RlY3RUaWxlVGV4dHVyZXMoY29uc3QgSW50UmVjdCYgbGF5ZXJSZWN0KTsK QEAgLTY5LDcgKzcxLDYgQEAgcHVibGljOgogcHJvdGVjdGVkOgogICAgIFRpbGVkTGF5ZXJDaHJv bWl1bSgpOwogCi0gICAgdmlydHVhbCB2b2lkIGNsZWFudXBSZXNvdXJjZXMoKTsKICAgICB2b2lk IHVwZGF0ZVRpbGVTaXplQW5kVGlsaW5nT3B0aW9uKCk7CiAgICAgdm9pZCB1cGRhdGVCb3VuZHMo KTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DYW52YXMyRExh eWVyQ2hyb21pdW1UZXN0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ2FudmFz MkRMYXllckNocm9taXVtVGVzdC5jcHAKaW5kZXggMWRmMjdjMDExMTliMjY1N2U4MmUyYTA3OTdi MWMwMWI1MGQzMDVlYi4uNGIzZGQyN2QzMWQ4ODIxMDRjNzBjZmZmNTAyNGZiODA0NDdlYTE0MSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DYW52YXMyRExheWVyQ2hy b21pdW1UZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NhbnZhczJE TGF5ZXJDaHJvbWl1bVRlc3QuY3BwCkBAIC03NSwxMiArNzUsNiBAQCBuYW1lc3BhY2UgV2ViQ29y ZSB7CiAKIGNsYXNzIENhbnZhczJETGF5ZXJDaHJvbWl1bVRlc3QgOiBwdWJsaWMgVGVzdCB7CiBw cm90ZWN0ZWQ6Ci0gICAgLy8gVGhpcyBpbmRpcmVjdGlvbiBpcyBuZWVkZWQgYmVjYXVzZSBpbmRp dmlkdWFsIHRlc3RzIGFyZW4ndCBmcmllbmRzIG9mIENhbnZhczJETGF5ZXJDaHJvbWl1bS4KLSAg ICB2b2lkIHNldFRleHR1cmVNYW5hZ2VyKENhbnZhczJETGF5ZXJDaHJvbWl1bSogbGF5ZXIsIFRl eHR1cmVNYW5hZ2VyKiBtYW5hZ2VyKQotICAgIHsKLSAgICAgICAgbGF5ZXItPnNldFRleHR1cmVN YW5hZ2VyKG1hbmFnZXIpOwotICAgIH0KLQogICAgIHZvaWQgZnVsbExpZmVjeWNsZVRlc3QoYm9v bCB0aHJlYWRlZCkKICAgICB7CiAgICAgICAgIEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVz IGF0dHJzOwpAQCAtMTMzLDcgKzEyNyw3IEBAIHByb3RlY3RlZDoKIAogICAgICAgICBSZWZQdHI8 Q2FudmFzMkRMYXllckNocm9taXVtPiBjYW52YXMgPSBDYW52YXMyRExheWVyQ2hyb21pdW06OmNy ZWF0ZShtYWluQ29udGV4dC5nZXQoKSwgc2l6ZSk7CiAgICAgICAgIGNhbnZhcy0+c2V0SXNEcmF3 YWJsZSh0cnVlKTsKLSAgICAgICAgc2V0VGV4dHVyZU1hbmFnZXIoY2FudmFzLmdldCgpLCB0ZXh0 dXJlTWFuYWdlci5nZXQoKSk7CisgICAgICAgIGNhbnZhcy0+c2V0VGV4dHVyZU1hbmFnZXIodGV4 dHVyZU1hbmFnZXIuZ2V0KCkpOwogICAgICAgICBjYW52YXMtPnNldEJvdW5kcyhJbnRTaXplKDYw MCwgMzAwKSk7CiAgICAgICAgIGNhbnZhcy0+c2V0VGV4dHVyZUlkKGJhY2tUZXh0dXJlSWQpOwog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1RleHR1cmVNYW5hZ2Vy VGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1RleHR1cmVNYW5hZ2VyVGVz dC5jcHAKaW5kZXggNDFmMTBlZDkwOGI4ZGYxNjAxODI1YmJjZDE5YWRkNmNhMTgwZGMzZS4uZGZj ZmY2M2U1MDdmNDA2ZjA4ZGYyNTAzNDc2ZWM0YzhlZWI1MGUyOSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS90ZXN0cy9UZXh0dXJlTWFuYWdlclRlc3QuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvVGV4dHVyZU1hbmFnZXJUZXN0LmNwcApAQCAtMjY0LDQg KzI2NCwzMCBAQCBURVNUX0YoVGV4dHVyZU1hbmFnZXJUZXN0LCB0ZXh0dXJlTWFuYWdlckRlc3Ry b3llZEJlZm9yZU1hbmFnZWRUZXh0dXJlKQogICAgIEVYUEVDVF9GQUxTRShtYW5hZ2VkVGV4dHVy ZS0+cmVzZXJ2ZShzaXplLCBmb3JtYXQpKTsKIH0KIAorVEVTVF9GKFRleHR1cmVNYW5hZ2VyVGVz dCwgdGV4dHVyZU1vdmVkVG9OZXdNYW5hZ2VyKQoreworICAgIE93blB0cjxUZXh0dXJlTWFuYWdl cj4gdGV4dHVyZU1hbmFnZXJPbmUgPSBjcmVhdGVUZXh0dXJlTWFuYWdlcigxLCAxKTsKKyAgICBP d25QdHI8VGV4dHVyZU1hbmFnZXI+IHRleHR1cmVNYW5hZ2VyVHdvID0gY3JlYXRlVGV4dHVyZU1h bmFnZXIoMSwgMSk7CisgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBtYW5hZ2VkVGV4dHVyZSA9 IE1hbmFnZWRUZXh0dXJlOjpjcmVhdGUodGV4dHVyZU1hbmFnZXJPbmUuZ2V0KCkpOworCisgICAg SW50U2l6ZSBzaXplKDUwLCA1MCk7CisgICAgdW5zaWduZWQgZm9ybWF0ID0gR3JhcGhpY3NDb250 ZXh0M0Q6OlJHQkE7CisKKyAgICAvLyBUZXh0dXJlIGlzIGluaXRpYWxseSBpbnZhbGlkLCBidXQg d2Ugc2hvdWxkIGJlIGFibGUgdG8gcmVzZXJ2ZS4KKyAgICBFWFBFQ1RfRkFMU0UobWFuYWdlZFRl eHR1cmUtPmlzVmFsaWQoc2l6ZSwgZm9ybWF0KSk7CisgICAgRVhQRUNUX1RSVUUobWFuYWdlZFRl eHR1cmUtPnJlc2VydmUoc2l6ZSwgZm9ybWF0KSk7CisgICAgRVhQRUNUX1RSVUUobWFuYWdlZFRl eHR1cmUtPmlzVmFsaWQoc2l6ZSwgZm9ybWF0KSk7CisKKyAgICAvLyBTZXR0aW5nIHRvIHRoZSBz YW1lIG1hbmFnZXIgc2hvdWxkIGJlIGEgbm8tb3AuCisgICAgbWFuYWdlZFRleHR1cmUtPnNldFRl eHR1cmVNYW5hZ2VyKHRleHR1cmVNYW5hZ2VyT25lLmdldCgpKTsKKyAgICBFWFBFQ1RfVFJVRSht YW5hZ2VkVGV4dHVyZS0+aXNWYWxpZChzaXplLCBmb3JtYXQpKTsKKworICAgIC8vIFNldHRpbmcg dG8gYSBkaWZmZXJlbnQgbWFuYWdlciBzaG91bGQgaW52YWxpZGF0ZSB0aGUgdGV4dHVyZS4KKyAg ICBtYW5hZ2VkVGV4dHVyZS0+c2V0VGV4dHVyZU1hbmFnZXIodGV4dHVyZU1hbmFnZXJUd28uZ2V0 KCkpOworCisgICAgRVhQRUNUX0ZBTFNFKG1hbmFnZWRUZXh0dXJlLT5pc1ZhbGlkKHNpemUsIGZv cm1hdCkpOyAKKyAgICBFWFBFQ1RfVFJVRShtYW5hZ2VkVGV4dHVyZS0+cmVzZXJ2ZShzaXplLCBm b3JtYXQpKTsKKyAgICBFWFBFQ1RfVFJVRShtYW5hZ2VkVGV4dHVyZS0+aXNWYWxpZChzaXplLCBm b3JtYXQpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vdGVzdHMvVGlsZWRMYXllckNocm9taXVtVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL1RpbGVkTGF5ZXJDaHJvbWl1bVRlc3QuY3BwCmluZGV4IDBjNTUwOTAw NjJjMGY2ZmFkNjAzY2Y0NGEwMTEzZWFmYzE5MGI3YWIuLmFjY2QzNDFlZmRlODA1NTc1YzQxMjU3 MDZiNGVlMTk2NWQyY2VkNzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVz dHMvVGlsZWRMYXllckNocm9taXVtVGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS90ZXN0cy9UaWxlZExheWVyQ2hyb21pdW1UZXN0LmNwcApAQCAtNDU5LDYgKzQ1OSw3IEBAIFRF U1QoVGlsZWRMYXllckNocm9taXVtVGVzdCwgc2tpcHNEcmF3R2V0c1Jlc2V0KQogICAgIEVYUEVD VF9GQUxTRShjaGlsZExheWVyLT5za2lwc0RyYXcoKSk7CiAKICAgICBjY0xheWVyVHJlZUhvc3Qt PmNvbW1pdENvbXBsZXRlKCk7CisgICAgdGV4dHVyZU1hbmFnZXItPnVucHJvdGVjdEFsbFRleHR1 cmVzKCk7IC8vIENDTGF5ZXJUcmVlSG9zdDo6Y29tbWl0Q29tcGxldGUoKSBub3JtYWxseSBkb2Vz IHRoaXMsIGJ1dCBzaW5jZSB3ZSdyZSBtb2NraW5nIG91dCB0aGUgbWFuYWdlciB3ZSBoYXZlIHRv IGRvIGl0LgogCiAgICAgLy8gUmVtb3ZlIHRoZSBjaGlsZCBsYXllci4KICAgICByb290TGF5ZXIt PnJlbW92ZUFsbENoaWxkcmVuKCk7Cg== 125733 2012-02-06 17:06:07 -0800 2012-02-06 18:17:13 -0800 Patch bug-77135-20120206170605.patch text/plain 17266 jamesr U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2ODcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODUwMDRlNDBlMWQ0MGY5 NTVmYTYwNmUyMTVmMTkyYTQ4NjFlZjQxMS4uYTExYTAyN2UxMTU4ODg2YTc1YWMzMTdhMDMzOThl MWFkNDc5OWFkNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDQ0IEBACiAyMDEyLTAyLTA2ICBKYW1l cyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAKKyAgICAgICAgW2Nocm9taXVtXSBj YW52YXMgZGVtbyBpcyBzbG93IGR1ZSB0byB1bm5lY2Vzc2FyeSByZXNvdXJjZSBjbGVhbnVwcwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzcxMzUKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGlzIGRlZmVy cyBkcm9wcGluZyBhIE1hbmFnZWRUZXh0dXJlIHVudGlsIGl0IGlzIGV2aWN0ZWQgYnkgdGhlIG1h bmFnZXIsIHRoZSBsYXllciBpcyBkZXN0cm95ZWQsIHRoZQorICAgICAgICBUZXh0dXJlTWFuYWdl ciBpcyBkZXN0cm95ZWQsIG9yIHRoZSBsYXllciBpcyBhZGRlZCB0byBhIENDTGF5ZXJUcmVlSG9z dCB0aGF0IGhhcyBhIGRpZmZlcmVudCB0ZXh0dXJlIG1hbmFnZXIuIEluCisgICAgICAgIHBhcnRp Y3VsYXIsIHJlbW92aW5nIGEgbGF5ZXIgZnJvbSBhIENDTGF5ZXJUcmVlSG9zdCBhbmQgdGhlbiBh ZGRpbmcgaXQgYmFjayB0byB0aGUgc2FtZSBob3N0IGRvZXMgbm90IGRyb3AgYW55CisgICAgICAg IE1hbmFnZWRUZXh0dXJlcyB1bmxlc3MgdGhlIG1hbmFnZXIgaGFzIHRvIGV2aWN0IGl0IGZvciBv dGhlciByZWFzb25zLiBUaGlzIHByb3ZpZGVzIGEgYmlnIHNwZWVkdXAgb24gc2l0ZXMgdGhhdAor ICAgICAgICByZWJ1aWxkIHRoZSBjb21wb3NpdGluZyB0cmVlIGZyZXF1ZW50bHkuCisKKyAgICAg ICAgTmV3IHVuaXQgdGVzdCBhZGRlZCBmb3IgTWFuYWdlZFRleHR1cmUgLyBUZXh0dXJlTWFuYWdl ciBpbnRlcmFjdGlvbi4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDYW52YXMyRExheWVy Q2hyb21pdW06OnNldExheWVyVHJlZUhvc3QpOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzMkRM YXllckNocm9taXVtOjpzZXRUZXh0dXJlTWFuYWdlcik6CisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmg6CisgICAgICAgIChDYW52YXMy RExheWVyQ2hyb21pdW0pOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xh eWVyQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6TGF5ZXJDaHJvbWl1bTo6c2V0TGF5 ZXJUcmVlSG9zdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJD aHJvbWl1bS5oOgorICAgICAgICAoTGF5ZXJDaHJvbWl1bSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 TWFuYWdlZFRleHR1cmU6OnNldFRleHR1cmVNYW5hZ2VyKToKKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6TWFuYWdlZFRleHR1cmU6OnN0ZWFsKToKKyAgICAgICAgKFdlYkNv cmU6Ok1hbmFnZWRUZXh0dXJlOjpjbGVhcik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTWFuYWdlZFRleHR1cmUuaDoKKyAgICAgICAgKE1hbmFnZWRUZXh0dXJlKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9SZW5kZXJTdXJmYWNlQ2hyb21pdW0u aDoKKyAgICAgICAgKFJlbmRlclN1cmZhY2VDaHJvbWl1bSk6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdCk6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBk YXRlVGlsZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5 ZXJDaHJvbWl1bS5oOgorCisyMDEyLTAyLTA2ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJv bWl1bS5vcmc+CisKICAgICAgICAgW2Nocm9taXVtXSBEcm9wIHRpbGVzIGNvbXBsZXRlbHkgb3V0 c2lkZSBvZiBsYXllciBib3VuZHMgd2hlbiByZXNpemluZyB0byBhIHNtYWxsZXIgc2l6ZQogICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzc5MTAKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCBjZDZiZjU2NDhjMDI5YjlhOTMwOTI2MGIyNzc3OGYy NDRjMmVhNzk5Li5iOWVlMmEyNzQzOGQzYjU0NzgzMGVjMjJjZmRmMWY4ZjQ3MmM4ZTI4IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDE3IEBACiAyMDEyLTAyLTA2ICBKYW1l cyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAKKyAgICAgICAgW2Nocm9taXVtXSBj YW52YXMgZGVtbyBpcyBzbG93IGR1ZSB0byB1bm5lY2Vzc2FyeSByZXNvdXJjZSBjbGVhbnVwcwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzcxMzUKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHRlc3RzL0Nh bnZhczJETGF5ZXJDaHJvbWl1bVRlc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2FudmFzMkRM YXllckNocm9taXVtVGVzdDo6ZnVsbExpZmVjeWNsZVRlc3QpOgorICAgICAgICAqIHRlc3RzL1Rl eHR1cmVNYW5hZ2VyVGVzdC5jcHA6CisgICAgICAgICogdGVzdHMvVGlsZWRMYXllckNocm9taXVt VGVzdC5jcHA6CisKKzIwMTItMDItMDYgIEphbWVzIFJvYmluc29uICA8amFtZXNyQGNocm9taXVt Lm9yZz4KKwogICAgICAgICBbY2hyb21pdW1dIERyb3AgdGlsZXMgY29tcGxldGVseSBvdXRzaWRl IG9mIGxheWVyIGJvdW5kcyB3aGVuIHJlc2l6aW5nIHRvIGEgc21hbGxlciBzaXplCiAgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzkxMAogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExh eWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcAppbmRleCAxNjY2YjYxOGUxMWIyZmViMTM2ZDA3 NWJmZTIyNzkyOGUwZDMzZWNjLi4xNGZlMzVhNTgwNWY2ZmQwN2YzMzc0MzRlZjQ1OTVmNDc5NTQ3 NzYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTExOSwxOCAr MTE5LDE4IEBAIHZvaWQgQ2FudmFzMkRMYXllckNocm9taXVtOjpwYWludENvbnRlbnRzSWZEaXJ0 eShjb25zdCBSZWdpb24mIC8qIG9jY2x1ZGVkU2NyZWVuCiAKIHZvaWQgQ2FudmFzMkRMYXllckNo cm9taXVtOjpzZXRMYXllclRyZWVIb3N0KENDTGF5ZXJUcmVlSG9zdCogaG9zdCkKIHsKLSAgICBp ZiAobGF5ZXJUcmVlSG9zdCgpICE9IGhvc3QpCi0gICAgICAgIHNldFRleHR1cmVNYW5hZ2VyKGhv c3QgPyBob3N0LT5jb250ZW50c1RleHR1cmVNYW5hZ2VyKCkgOiAwKTsKLQogICAgIENhbnZhc0xh eWVyQ2hyb21pdW06OnNldExheWVyVHJlZUhvc3QoaG9zdCk7CisKKyAgICBpZiAobV91c2VEb3Vi bGVCdWZmZXJpbmcgJiYgaG9zdCkKKyAgICAgICAgc2V0VGV4dHVyZU1hbmFnZXIoaG9zdC0+Y29u dGVudHNUZXh0dXJlTWFuYWdlcigpKTsKIH0KIAogdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06 OnNldFRleHR1cmVNYW5hZ2VyKFRleHR1cmVNYW5hZ2VyKiB0ZXh0dXJlTWFuYWdlcikKIHsKLSAg ICBpZiAodGV4dHVyZU1hbmFnZXIgJiYgbV91c2VEb3VibGVCdWZmZXJpbmcpCi0gICAgICAgIG1f ZnJvbnRUZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZSh0ZXh0dXJlTWFuYWdlcik7Cisg ICAgaWYgKG1fZnJvbnRUZXh0dXJlKQorICAgICAgICBtX2Zyb250VGV4dHVyZS0+c2V0VGV4dHVy ZU1hbmFnZXIodGV4dHVyZU1hbmFnZXIpOwogICAgIGVsc2UKLSAgICAgICAgbV9mcm9udFRleHR1 cmUuY2xlYXIoKTsKKyAgICAgICAgbV9mcm9udFRleHR1cmUgPSBNYW5hZ2VkVGV4dHVyZTo6Y3Jl YXRlKHRleHR1cmVNYW5hZ2VyKTsKIH0KIAogdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OnVw ZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIENDVGV4 dHVyZVVwZGF0ZXImIHVwZGF0ZXIpCkBAIC0xNjYsMTIgKzE2Niw2IEBAIHZvaWQgQ2FudmFzMkRM YXllckNocm9taXVtOjp1bnJlc2VydmVDb250ZW50c1RleHR1cmUoKQogICAgICAgICBtX2Zyb250 VGV4dHVyZS0+dW5yZXNlcnZlKCk7CiB9CiAKLXZvaWQgQ2FudmFzMkRMYXllckNocm9taXVtOjpj bGVhbnVwUmVzb3VyY2VzKCkKLXsKLSAgICBpZiAobV91c2VEb3VibGVCdWZmZXJpbmcpCi0gICAg ICAgIG1fZnJvbnRUZXh0dXJlLmNsZWFyKCk7Ci19Ci0KIH0KIAogI2VuZGlmIC8vIFVTRShBQ0NF TEVSQVRFRF9DT01QT1NJVElORykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJETGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmgKaW5k ZXggODc3MjI0ZjQxZWExYjU1Y2U5ZTAyMGEwOGYyZTg0MTQyMzc2OGQ0Zi4uMTFhMWE5NTM5MGNk OGU5YWRhOGZjODRjMWI5OWI3NGEwYjM1NjhjYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNo cm9taXVtLmgKQEAgLTYxLDE0ICs2MSwxMiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHVw ZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3NDb250ZXh0M0QqLCBDQ1RleHR1cmVVcGRh dGVyJik7CiAgICAgdmlydHVhbCB2b2lkIHB1c2hQcm9wZXJ0aWVzVG8oQ0NMYXllckltcGwqKTsK ICAgICB2aXJ0dWFsIHZvaWQgdW5yZXNlcnZlQ29udGVudHNUZXh0dXJlKCk7Ci0gICAgdmlydHVh bCB2b2lkIGNsZWFudXBSZXNvdXJjZXMoKTsKIAogICAgIHZvaWQgc2V0Q2FudmFzKFNrQ2FudmFz Kik7CiAKIHByaXZhdGU6CiAgICAgQ2FudmFzMkRMYXllckNocm9taXVtKEdyYXBoaWNzQ29udGV4 dDNEKiwgY29uc3QgSW50U2l6ZSYpOwogCi0gICAgLy8gVmlzaWJsZSBmb3IgdGVzdGluZyBzbyB3 ZSBjYW4gYnlwYXNzIHNldExheWVyVHJlZUhvc3QuCiAgICAgZnJpZW5kIGNsYXNzIENhbnZhczJE TGF5ZXJDaHJvbWl1bVRlc3Q7CiAgICAgdm9pZCBzZXRUZXh0dXJlTWFuYWdlcihUZXh0dXJlTWFu YWdlciopOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9MYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uY3BwCmluZGV4IGIyZjcwMTQxYjQ3YTVkNDdiNDQw MjkzODBkMzhjYjNkYzNjNWIzMjguLjhkMGZlMDNiNjEzYjI0ODE3MGU4ZjM2MjAwZDE0MGJlMDkx ZjQ0ODMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL0xheWVyQ2hyb21pdW0uY3BwCkBAIC05MiwxMCArOTIsNiBAQCBMYXllckNo cm9taXVtOjp+TGF5ZXJDaHJvbWl1bSgpCiAgICAgcmVtb3ZlQWxsQ2hpbGRyZW4oKTsKIH0KIAot dm9pZCBMYXllckNocm9taXVtOjpjbGVhbnVwUmVzb3VyY2VzKCkKLXsKLX0KLQogdm9pZCBMYXll ckNocm9taXVtOjpzZXRJc05vbkNvbXBvc2l0ZWRDb250ZW50KGJvb2wgaXNOb25Db21wb3NpdGVk Q29udGVudCkKIHsKICAgICBtX2lzTm9uQ29tcG9zaXRlZENvbnRlbnQgPSBpc05vbkNvbXBvc2l0 ZWRDb250ZW50OwpAQCAtMTA2LDExICsxMDIsNiBAQCB2b2lkIExheWVyQ2hyb21pdW06OnNldExh eWVyVHJlZUhvc3QoQ0NMYXllclRyZWVIb3N0KiBob3N0KQogICAgIGlmIChtX2xheWVyVHJlZUhv c3QgPT0gaG9zdCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgLy8gSWYgd2UncmUgY2hhbmdpbmcg aG9zdHMgdGhlbiB3ZSBuZWVkIHRvIGZyZWUgdXAgYW55IHJlc291cmNlcwotICAgIC8vIGFsbG9j YXRlZCBieSB0aGUgb2xkIGhvc3QuCi0gICAgaWYgKG1fbGF5ZXJUcmVlSG9zdCkKLSAgICAgICAg Y2xlYW51cFJlc291cmNlcygpOwotCiAgICAgbV9sYXllclRyZWVIb3N0ID0gaG9zdDsKIAogICAg IGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9jaGlsZHJlbi5zaXplKCk7ICsraSkKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21p dW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hy b21pdW0uaAppbmRleCA3NjRmNzMwMTU1YjU0NTM3Y2RhNGM3MzgxYjNmZDNiY2I3OTYwNjRkLi5h MDc1ODEzMWZiZmUyMzQ2OTBiMjczM2FlYzZiYTJmOGExNGQwY2E3IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1 bS5oCkBAIC0yMTQsMTEgKzIxNCw2IEBAIHB1YmxpYzoKIHByb3RlY3RlZDoKICAgICBMYXllckNo cm9taXVtKCk7CiAKLSAgICAvLyBUaGlzIGlzIGNhbGxlZCB0byBjbGVhbiB1cCByZXNvdXJjZXMg YmVpbmcgaGVsZCBpbiB0aGUgc2FtZSBjb250ZXh0IGFzCi0gICAgLy8gbGF5ZXJSZW5kZXJlckNv bnRleHQoKS4gU3ViY2xhc3NlcyBzaG91bGQgb3ZlcnJpZGUgdGhpcyBtZXRob2QgaWYgdGhleQot ICAgIC8vIGhvbGQgY29udGV4dC1kZXBlbmRlbnQgcmVzb3VyY2VzIHN1Y2ggYXMgdGV4dHVyZXMu Ci0gICAgdmlydHVhbCB2b2lkIGNsZWFudXBSZXNvdXJjZXMoKTsKLQogICAgIGJvb2wgaXNQYWlu dGVkQXhpc0FsaWduZWRJblNjcmVlbigpIGNvbnN0OwogCiAgICAgdm9pZCBzZXROZWVkc0NvbW1p dCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTWFuYWdlZFRleHR1cmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwCmluZGV4IDU0OGI5MzFlMmIwN2RkYzk0NmFiYTQy OGYwN2ViMzgzNjYzNWUwY2EuLmIyOWRiMGVkOWUyOGRjNmQwZWYzZjc5MGE0NTViMWQyYjFmMTAw ODkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L01hbmFnZWRUZXh0dXJlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAKQEAgLTYxLDYgKzYxLDE5IEBAIE1hbmFnZWRU ZXh0dXJlOjp+TWFuYWdlZFRleHR1cmUoKQogICAgICAgICBtX3RleHR1cmVNYW5hZ2VyLT5yZWxl YXNlVG9rZW4obV90b2tlbik7CiB9CiAKK3ZvaWQgTWFuYWdlZFRleHR1cmU6OnNldFRleHR1cmVN YW5hZ2VyKFRleHR1cmVNYW5hZ2VyKiBtYW5hZ2VyKQoreworICAgIGlmIChtYW5hZ2VyID09IG1f dGV4dHVyZU1hbmFnZXIpCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChtX3RleHR1cmVNYW5h Z2VyKQorICAgICAgICBtX3RleHR1cmVNYW5hZ2VyLT51bnJlZ2lzdGVyVGV4dHVyZSh0aGlzKTsK KyAgICBtX3RleHR1cmVNYW5hZ2VyID0gbWFuYWdlcjsKKyAgICBjbGVhcigpOworICAgIGlmICht X3RleHR1cmVNYW5hZ2VyKQorICAgICAgICBtX3RleHR1cmVNYW5hZ2VyLT5yZWdpc3RlclRleHR1 cmUodGhpcyk7Cit9CisKIGJvb2wgTWFuYWdlZFRleHR1cmU6OmlzVmFsaWQoY29uc3QgSW50U2l6 ZSYgc2l6ZSwgdW5zaWduZWQgZm9ybWF0KQogewogICAgIHJldHVybiBtX3Rva2VuICYmIHNpemUg PT0gbV9zaXplICYmIGZvcm1hdCA9PSBtX2Zvcm1hdCAmJiBtX3RleHR1cmVNYW5hZ2VyICYmIG1f dGV4dHVyZU1hbmFnZXItPmhhc1RleHR1cmUobV90b2tlbik7CkBAIC0xMTksMTQgKzEzMiwxOCBA QCB2b2lkIE1hbmFnZWRUZXh0dXJlOjpmcmFtZWJ1ZmZlclRleHR1cmUyRChHcmFwaGljc0NvbnRl eHQzRCogY29udGV4dCwgVGV4dHVyZUFsbAogUGFzc093blB0cjxNYW5hZ2VkVGV4dHVyZT4gTWFu YWdlZFRleHR1cmU6OnN0ZWFsKCkKIHsKICAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1 cmUgPSBhZG9wdFB0cihuZXcgTWFuYWdlZFRleHR1cmUobV90ZXh0dXJlTWFuYWdlciwgbV90b2tl biwgbV9zaXplLCBtX2Zvcm1hdCwgbV90ZXh0dXJlSWQpKTsKKyAgICBjbGVhcigpOworICAgIHJl dHVybiB0ZXh0dXJlLnJlbGVhc2UoKTsKK30KKwordm9pZCBNYW5hZ2VkVGV4dHVyZTo6Y2xlYXIo KQorewogICAgIG1fdG9rZW4gPSAwOwogICAgIG1fc2l6ZSA9IEludFNpemUoKTsKICAgICBtX2Zv cm1hdCA9IDA7CiAgICAgbV90ZXh0dXJlSWQgPSAwOwotICAgIHJldHVybiB0ZXh0dXJlLnJlbGVh c2UoKTsKIH0KIAotCiB9CiAKICNlbmRpZiAvLyBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9N YW5hZ2VkVGV4dHVyZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTWFuYWdlZFRleHR1cmUuaAppbmRleCA5ODhkZjc3MGIzNTIwYTkzOGNmN2RhMTA3NjhkZGU0 OTk4OTUxMmZiLi5lZDRkNDUwZTk2OWNlMGFiNTQ3YTlhYzUxMzhkNGMwOTNkODM5ZDYyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2Vk VGV4dHVyZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L01hbmFnZWRUZXh0dXJlLmgKQEAgLTQ2LDYgKzQ2LDcgQEAgcHVibGljOgogICAgIH0KICAgICB+ TWFuYWdlZFRleHR1cmUoKTsKIAorICAgIHZvaWQgc2V0VGV4dHVyZU1hbmFnZXIoVGV4dHVyZU1h bmFnZXIqKTsKICAgICB2b2lkIGNsZWFyTWFuYWdlcigpIHsgbV90ZXh0dXJlTWFuYWdlciA9IDA7 IH0KIAogICAgIGJvb2wgaXNWYWxpZChjb25zdCBJbnRTaXplJiwgdW5zaWduZWQgZm9ybWF0KTsK QEAgLTcyLDYgKzczLDggQEAgcHJpdmF0ZToKICAgICBleHBsaWNpdCBNYW5hZ2VkVGV4dHVyZShU ZXh0dXJlTWFuYWdlciopOwogICAgIE1hbmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiwgVGV4 dHVyZVRva2VuLCBJbnRTaXplLCB1bnNpZ25lZCBmb3JtYXQsIHVuc2lnbmVkIHRleHR1cmVJZCk7 CiAKKyAgICB2b2lkIGNsZWFyKCk7CisKICAgICBUZXh0dXJlTWFuYWdlciogbV90ZXh0dXJlTWFu YWdlcjsKICAgICBUZXh0dXJlVG9rZW4gbV90b2tlbjsKICAgICBJbnRTaXplIG1fc2l6ZTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1JlbmRl clN1cmZhY2VDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vUmVuZGVyU3VyZmFjZUNocm9taXVtLmgKaW5kZXggYmY0OTg4YzI1Mzc5Y2UyM2E0MDEy YTgxNDZkYjVhODYyZDAzOWYyMC4uM2M2ZjE2NDlhNWQyN2U4NzhjM2UwNzdjNDI3ZjQ5YjY3OTlk MzU5NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vUmVuZGVyU3VyZmFjZUNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vUmVuZGVyU3VyZmFjZUNocm9taXVtLmgKQEAgLTUxLDcgKzUxLDYg QEAgcHVibGljOgogCiAgICAgYm9vbCBwcmVwYXJlQ29udGVudHNUZXh0dXJlKCk7CiAgICAgdm9p ZCByZWxlYXNlQ29udGVudHNUZXh0dXJlKCk7Ci0gICAgdm9pZCBjbGVhbnVwUmVzb3VyY2VzKCk7 CiAgICAgdm9pZCBkcmF3KGNvbnN0IEludFJlY3QmIHRhcmdldFN1cmZhY2VSZWN0KTsKIAogICAg IC8vIFJldHVybnMgdGhlIHJlY3QgdGhhdCBlbmNsb3NlcyB0aGUgUmVuZGVyU3VyZmFjZSBpbmNs dWRpbmcgYW55IHJlZmxlY3Rpb24uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRl eCAyMzY3NzYzOThmNjhkY2RlYzcyNTI5NTNhZTAyODVkY2RlMmNlNTMzLi5jOTFkZDVkZmI0MmU1 MGYwNTkzY2JhMWMzMjc3N2VjNTkyOTE2ZDgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1 bS5jcHAKQEAgLTkyLDE1ICs5Miw2IEBAIFBhc3NSZWZQdHI8Q0NMYXllckltcGw+IFRpbGVkTGF5 ZXJDaHJvbWl1bTo6Y3JlYXRlQ0NMYXllckltcGwoKQogICAgIHJldHVybiBDQ1RpbGVkTGF5ZXJJ bXBsOjpjcmVhdGUoaWQoKSk7CiB9CiAKLXZvaWQgVGlsZWRMYXllckNocm9taXVtOjpjbGVhbnVw UmVzb3VyY2VzKCkKLXsKLSAgICBMYXllckNocm9taXVtOjpjbGVhbnVwUmVzb3VyY2VzKCk7Ci0K LSAgICBtX3RpbGVyLT5yZXNldCgpOwotICAgIG1fcGFpbnRSZWN0ID0gSW50UmVjdCgpOwotICAg IG1fcmVxdWVzdGVkVXBkYXRlVGlsZXNSZWN0ID0gSW50UmVjdCgpOwotfQotCiB2b2lkIFRpbGVk TGF5ZXJDaHJvbWl1bTo6dXBkYXRlVGlsZVNpemVBbmRUaWxpbmdPcHRpb24oKQogewogICAgIGNv bnN0IEludFNpemUgdGlsZVNpemUobWluKGRlZmF1bHRUaWxlU2l6ZSwgY29udGVudEJvdW5kcygp LndpZHRoKCkpLCBtaW4oZGVmYXVsdFRpbGVTaXplLCBjb250ZW50Qm91bmRzKCkuaGVpZ2h0KCkp KTsKQEAgLTI3NSw2ICsyNjYsMTcgQEAgVGV4dHVyZU1hbmFnZXIqIFRpbGVkTGF5ZXJDaHJvbWl1 bTo6dGV4dHVyZU1hbmFnZXIoKSBjb25zdAogICAgIHJldHVybiBsYXllclRyZWVIb3N0KCktPmNv bnRlbnRzVGV4dHVyZU1hbmFnZXIoKTsKIH0KIAordm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnNl dExheWVyVHJlZUhvc3QoQ0NMYXllclRyZWVIb3N0KiBob3N0KQoreworICAgIGlmIChob3N0ICYm IGhvc3QgIT0gbGF5ZXJUcmVlSG9zdCgpKSB7CisgICAgICAgIGZvciAoQ0NMYXllclRpbGluZ0Rh dGE6OlRpbGVNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ZXIgPSBtX3RpbGVyLT50aWxlcygpLmJlZ2lu KCk7IGl0ZXIgIT0gbV90aWxlci0+dGlsZXMoKS5lbmQoKTsgKytpdGVyKSB7CisgICAgICAgICAg ICBVcGRhdGFibGVUaWxlKiB0aWxlID0gc3RhdGljX2Nhc3Q8VXBkYXRhYmxlVGlsZSo+KGl0ZXIt PnNlY29uZC5nZXQoKSk7CisgICAgICAgICAgICB0aWxlLT5tYW5hZ2VkVGV4dHVyZSgpLT5zZXRU ZXh0dXJlTWFuYWdlcihob3N0LT5jb250ZW50c1RleHR1cmVNYW5hZ2VyKCkpOworICAgICAgICB9 CisgICAgfQorICAgIExheWVyQ2hyb21pdW06OnNldExheWVyVHJlZUhvc3QoaG9zdCk7Cit9CisK IFVwZGF0YWJsZVRpbGUqIFRpbGVkTGF5ZXJDaHJvbWl1bTo6dGlsZUF0KGludCBpLCBpbnQgaikg Y29uc3QKIHsKICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8VXBkYXRhYmxlVGlsZSo+KG1fdGlsZXIt PnRpbGVBdChpLCBqKSk7CkBAIC0zODUsNyArMzg3LDkgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21p dW06OnByZXBhcmVUb1VwZGF0ZVRpbGVzKGJvb2wgaWRsZSwgaW50IGxlZnQsIGludCB0b3AsIGlu dAogICAgICAgICAgICAgICAgICAgICAvLyBsYXllciBzbyB0aGF0IGNoZWNrZXJib2FyZGVkIHRp bGVzIHdpbGwgc3RpbGwgZHJhdy4KICAgICAgICAgICAgICAgICAgICAgaWYgKCFiYWNrZ3JvdW5k Q292ZXJzVmlld3BvcnQoKSkKICAgICAgICAgICAgICAgICAgICAgICAgIG1fc2tpcHNEcmF3ID0g dHJ1ZTsKLSAgICAgICAgICAgICAgICAgICAgY2xlYW51cFJlc291cmNlcygpOworICAgICAgICAg ICAgICAgICAgICBtX3RpbGVyLT5yZXNldCgpOworICAgICAgICAgICAgICAgICAgICBtX3BhaW50 UmVjdCA9IEludFJlY3QoKTsKKyAgICAgICAgICAgICAgICAgICAgbV9yZXF1ZXN0ZWRVcGRhdGVU aWxlc1JlY3QgPSBJbnRSZWN0KCk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAg IHJldHVybjsKICAgICAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKaW5kZXgg MjlmZWNmZTRjYmY5NTkwNzAwODllZGNiZWE1YTQ0YzM4ZjgwZDQ0Yy4uNDYxOTJmZTVkMjU2ZTZl MjdlZmExZjZhZjkwYTc4ZDZkZjgyMDk4NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmgK QEAgLTU4LDYgKzU4LDggQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldElzTm9uQ29t cG9zaXRlZENvbnRlbnQoYm9vbCk7CiAKKyAgICB2aXJ0dWFsIHZvaWQgc2V0TGF5ZXJUcmVlSG9z dChDQ0xheWVyVHJlZUhvc3QqKTsKKwogICAgIC8vIFJlc2VydmVzIGFsbCBleGlzdGluZyBhbmQg dmFsaWQgdGlsZSB0ZXh0dXJlcyB0byBwcm90ZWN0IHRoZW0gZnJvbSBiZWluZwogICAgIC8vIHJl Y3ljbGVkIGJ5IHRoZSB0ZXh0dXJlIG1hbmFnZXIuCiAgICAgdm9pZCBwcm90ZWN0VGlsZVRleHR1 cmVzKGNvbnN0IEludFJlY3QmIGxheWVyUmVjdCk7CkBAIC02OSw3ICs3MSw2IEBAIHB1YmxpYzoK IHByb3RlY3RlZDoKICAgICBUaWxlZExheWVyQ2hyb21pdW0oKTsKIAotICAgIHZpcnR1YWwgdm9p ZCBjbGVhbnVwUmVzb3VyY2VzKCk7CiAgICAgdm9pZCB1cGRhdGVUaWxlU2l6ZUFuZFRpbGluZ09w dGlvbigpOwogICAgIHZvaWQgdXBkYXRlQm91bmRzKCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vdGVzdHMvQ2FudmFzMkRMYXllckNocm9taXVtVGVzdC5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NhbnZhczJETGF5ZXJDaHJvbWl1bVRlc3QuY3BwCmlu ZGV4IDFkZjI3YzAxMTE5YjI2NTdlODJlMmEwNzk3YjFjMDFiNTBkMzA1ZWIuLjRiM2RkMjdkMzFk ODgyMTA0YzcwY2ZmZjUwMjRmYjgwNDQ3ZWExNDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vdGVzdHMvQ2FudmFzMkRMYXllckNocm9taXVtVGVzdC5jcHAKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DYW52YXMyRExheWVyQ2hyb21pdW1UZXN0LmNwcApAQCAt NzUsMTIgKzc1LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBDYW52YXMyRExheWVy Q2hyb21pdW1UZXN0IDogcHVibGljIFRlc3QgewogcHJvdGVjdGVkOgotICAgIC8vIFRoaXMgaW5k aXJlY3Rpb24gaXMgbmVlZGVkIGJlY2F1c2UgaW5kaXZpZHVhbCB0ZXN0cyBhcmVuJ3QgZnJpZW5k cyBvZiBDYW52YXMyRExheWVyQ2hyb21pdW0uCi0gICAgdm9pZCBzZXRUZXh0dXJlTWFuYWdlcihD YW52YXMyRExheWVyQ2hyb21pdW0qIGxheWVyLCBUZXh0dXJlTWFuYWdlciogbWFuYWdlcikKLSAg ICB7Ci0gICAgICAgIGxheWVyLT5zZXRUZXh0dXJlTWFuYWdlcihtYW5hZ2VyKTsKLSAgICB9Ci0K ICAgICB2b2lkIGZ1bGxMaWZlY3ljbGVUZXN0KGJvb2wgdGhyZWFkZWQpCiAgICAgewogICAgICAg ICBHcmFwaGljc0NvbnRleHQzRDo6QXR0cmlidXRlcyBhdHRyczsKQEAgLTEzMyw3ICsxMjcsNyBA QCBwcm90ZWN0ZWQ6CiAKICAgICAgICAgUmVmUHRyPENhbnZhczJETGF5ZXJDaHJvbWl1bT4gY2Fu dmFzID0gQ2FudmFzMkRMYXllckNocm9taXVtOjpjcmVhdGUobWFpbkNvbnRleHQuZ2V0KCksIHNp emUpOwogICAgICAgICBjYW52YXMtPnNldElzRHJhd2FibGUodHJ1ZSk7Ci0gICAgICAgIHNldFRl eHR1cmVNYW5hZ2VyKGNhbnZhcy5nZXQoKSwgdGV4dHVyZU1hbmFnZXIuZ2V0KCkpOworICAgICAg ICBjYW52YXMtPnNldFRleHR1cmVNYW5hZ2VyKHRleHR1cmVNYW5hZ2VyLmdldCgpKTsKICAgICAg ICAgY2FudmFzLT5zZXRCb3VuZHMoSW50U2l6ZSg2MDAsIDMwMCkpOwogICAgICAgICBjYW52YXMt PnNldFRleHR1cmVJZChiYWNrVGV4dHVyZUlkKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS90ZXN0cy9UZXh0dXJlTWFuYWdlclRlc3QuY3BwIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS90ZXN0cy9UZXh0dXJlTWFuYWdlclRlc3QuY3BwCmluZGV4IDQxZjEwZWQ5MDhiOGRm MTYwMTgyNWJiY2QxOWFkZDZjYTE4MGRjM2UuLmRhNGFhMDMyNjFkZmExMmZmMzYwM2U1ZWUwYTBk Y2UwYTM3MmE1OTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvVGV4 dHVyZU1hbmFnZXJUZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1Rl eHR1cmVNYW5hZ2VyVGVzdC5jcHAKQEAgLTI2NCw0ICsyNjQsMzAgQEAgVEVTVF9GKFRleHR1cmVN YW5hZ2VyVGVzdCwgdGV4dHVyZU1hbmFnZXJEZXN0cm95ZWRCZWZvcmVNYW5hZ2VkVGV4dHVyZSkK ICAgICBFWFBFQ1RfRkFMU0UobWFuYWdlZFRleHR1cmUtPnJlc2VydmUoc2l6ZSwgZm9ybWF0KSk7 CiB9CiAKK1RFU1RfRihUZXh0dXJlTWFuYWdlclRlc3QsIHRleHR1cmVNb3ZlZFRvTmV3TWFuYWdl cikKK3sKKyAgICBPd25QdHI8VGV4dHVyZU1hbmFnZXI+IHRleHR1cmVNYW5hZ2VyT25lID0gY3Jl YXRlVGV4dHVyZU1hbmFnZXIoMSwgMSk7CisgICAgT3duUHRyPFRleHR1cmVNYW5hZ2VyPiB0ZXh0 dXJlTWFuYWdlclR3byA9IGNyZWF0ZVRleHR1cmVNYW5hZ2VyKDEsIDEpOworICAgIE93blB0cjxN YW5hZ2VkVGV4dHVyZT4gbWFuYWdlZFRleHR1cmUgPSBNYW5hZ2VkVGV4dHVyZTo6Y3JlYXRlKHRl eHR1cmVNYW5hZ2VyT25lLmdldCgpKTsKKworICAgIEludFNpemUgc2l6ZSg1MCwgNTApOworICAg IHVuc2lnbmVkIGZvcm1hdCA9IEdyYXBoaWNzQ29udGV4dDNEOjpSR0JBOworCisgICAgLy8gVGV4 dHVyZSBpcyBpbml0aWFsbHkgaW52YWxpZCwgYnV0IHdlIHNob3VsZCBiZSBhYmxlIHRvIHJlc2Vy dmUuCisgICAgRVhQRUNUX0ZBTFNFKG1hbmFnZWRUZXh0dXJlLT5pc1ZhbGlkKHNpemUsIGZvcm1h dCkpOworICAgIEVYUEVDVF9UUlVFKG1hbmFnZWRUZXh0dXJlLT5yZXNlcnZlKHNpemUsIGZvcm1h dCkpOworICAgIEVYUEVDVF9UUlVFKG1hbmFnZWRUZXh0dXJlLT5pc1ZhbGlkKHNpemUsIGZvcm1h dCkpOworCisgICAgLy8gU2V0dGluZyB0byB0aGUgc2FtZSBtYW5hZ2VyIHNob3VsZCBiZSBhIG5v LW9wLgorICAgIG1hbmFnZWRUZXh0dXJlLT5zZXRUZXh0dXJlTWFuYWdlcih0ZXh0dXJlTWFuYWdl ck9uZS5nZXQoKSk7CisgICAgRVhQRUNUX1RSVUUobWFuYWdlZFRleHR1cmUtPmlzVmFsaWQoc2l6 ZSwgZm9ybWF0KSk7CisKKyAgICAvLyBTZXR0aW5nIHRvIGEgZGlmZmVyZW50IG1hbmFnZXIgc2hv dWxkIGludmFsaWRhdGUgdGhlIHRleHR1cmUuCisgICAgbWFuYWdlZFRleHR1cmUtPnNldFRleHR1 cmVNYW5hZ2VyKHRleHR1cmVNYW5hZ2VyVHdvLmdldCgpKTsKKworICAgIEVYUEVDVF9GQUxTRSht YW5hZ2VkVGV4dHVyZS0+aXNWYWxpZChzaXplLCBmb3JtYXQpKTsKKyAgICBFWFBFQ1RfVFJVRSht YW5hZ2VkVGV4dHVyZS0+cmVzZXJ2ZShzaXplLCBmb3JtYXQpKTsKKyAgICBFWFBFQ1RfVFJVRSht YW5hZ2VkVGV4dHVyZS0+aXNWYWxpZChzaXplLCBmb3JtYXQpKTsKK30KKwogfSAvLyBuYW1lc3Bh Y2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvVGlsZWRMYXllckNo cm9taXVtVGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1RpbGVkTGF5ZXJD aHJvbWl1bVRlc3QuY3BwCmluZGV4IDFjMDc1ZmJiYmJhZDk3MzUzZWQ2NjBiZTM1MTNiOTE1YTc2 ZTJiM2IuLjYwNjlmZDE4MTM4OGJiNTQ2OWQ5YjYxM2Y4Yzc1M2Q2YTViZmI4OTkgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvVGlsZWRMYXllckNocm9taXVtVGVzdC5j cHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9UaWxlZExheWVyQ2hyb21pdW1U ZXN0LmNwcApAQCAtNDU5LDYgKzQ1OSw3IEBAIFRFU1QoVGlsZWRMYXllckNocm9taXVtVGVzdCwg c2tpcHNEcmF3R2V0c1Jlc2V0KQogICAgIEVYUEVDVF9GQUxTRShjaGlsZExheWVyLT5za2lwc0Ry YXcoKSk7CiAKICAgICBjY0xheWVyVHJlZUhvc3QtPmNvbW1pdENvbXBsZXRlKCk7CisgICAgdGV4 dHVyZU1hbmFnZXItPnVucHJvdGVjdEFsbFRleHR1cmVzKCk7IC8vIENDTGF5ZXJUcmVlSG9zdDo6 Y29tbWl0Q29tcGxldGUoKSBub3JtYWxseSBkb2VzIHRoaXMsIGJ1dCBzaW5jZSB3ZSdyZSBtb2Nr aW5nIG91dCB0aGUgbWFuYWdlciB3ZSBoYXZlIHRvIGRvIGl0LgogCiAgICAgLy8gUmVtb3ZlIHRo ZSBjaGlsZCBsYXllci4KICAgICByb290TGF5ZXItPnJlbW92ZUFsbENoaWxkcmVuKCk7Cg==