126022 2013-12-19 15:44:55 -0800 [CoordinatedGraphics][WK2] Scale factor and scroll position is not being restored properly in a back/forward load 2014-09-22 04:43:36 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 126243 131831 136999 1 thiago.lacerda gyuyoung.kim beidson benjamin bunhere cmarcelo commit-queue gyuyoung.kim gyuyoung.kim japhet kling luiz noam ossy rakuco sergio simon.fraser thorton webkit-ews zeno oldest_to_newest 961591 0 thiago.lacerda 2013-12-19 15:44:55 -0800 When user is navigating back/forward to a page that has been scrolled and/or scaled, that page must be shown with its last scroll position and scale factor. Also, when a user was using the WKView API to set the scale factor (WKViewSetContentScaleFactor) this scale was not being forwarded to WebCore. Then, when going back/forward to a page HistoryController was not knowing about its real scale factor. A WebKitAPI test is being added to validate this behaviour. 961602 1 219697 thiago.lacerda 2013-12-19 16:02:36 -0800 Created attachment 219697 Patch 961605 2 thiago.lacerda 2013-12-19 16:06:32 -0800 *** Bug 119063 has been marked as a duplicate of this bug. *** 961842 3 219697 noam 2013-12-20 05:47:06 -0800 Comment on attachment 219697 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=219697&action=review > Source/WebCore/ChangeLog:17 > + * loader/HistoryController.cpp: > + (WebCore::HistoryController::restoreScrollPositionAndViewState): Explain what you're actually doing to rectify this. > Source/WebKit2/ChangeLog:13 > + When user is navigating back/forward to a page that has been scrolled and/or scaled, that page must be shown > + with its last scroll position and scale factor. > + Also, when a user was using the WKView API to set the scale factor (WKViewSetContentScaleFactor) this scale was > + not being forwarded to WebCore. Then, when going back/forward to a page HistoryController was not knowing about > + its real scale factor. > + A WebKitAPI test is being added to validate this behaviour. This is a description of the bug. Also describe the solution otherwise the code is hard to follow. > Source/WebCore/loader/HistoryController.cpp:159 > + double currentScaleFactor = m_currentItem->pageScaleFactor(); > + IntPoint currentScrollPoint = m_currentItem->scrollPoint(); > +#if PLATFORM(EFL) || PLATFORM(NIX) > + double previousScaleFactor = m_previousItem ? m_previousItem->pageScaleFactor() : currentScaleFactor; > + IntPoint previousScrollPoint = m_previousItem ? m_previousItem->scrollPoint() : currentScrollPoint; > + > + if (previousScaleFactor != currentScaleFactor || previousScrollPoint != currentScrollPoint) { > +#else > if (!view->wasScrolledByUser()) { > - if (page && m_frame.isMainFrame() && m_currentItem->pageScaleFactor()) > - page->setPageScaleFactor(m_currentItem->pageScaleFactor(), m_currentItem->scrollPoint()); > +#endif // PLATFORM(EFL) || PLATFORM(NIX) > + if (page && m_frame.isMainFrame() && currentScaleFactor) > + page->setPageScaleFactor(currentScaleFactor, currentScrollPoint); > else > - view->setScrollPosition(m_currentItem->scrollPoint()); > + view->setScrollPosition(currentScrollPoint); > } > } This snippet is a bit spaghettified... I would rather try to figure out how ports where this already works (Mac?) do this, and try to consolidate rather than have port #ifdefs in WebCore. > Source/WebKit2/UIProcess/PageClient.h:127 > +#if PLATFORM(EFL) || PLATFORM(NIX) > + virtual void didChangePageScaleFactor(double scaleFactor) = 0; > +#endif I think this can be an empty implementation rather than some #ifdefed thing. > Source/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:1147 > +#if PLATFORM(EFL) || PLATFORM(NIX) > + if (m_frame == m_frame->page()->mainWebFrame()) > + m_frame->page()->send(Messages::WebPageProxy::PageDidRequestScroll(m_frame->coreFrame()->loader().history().currentItem()->scrollPoint())); > +#endif How is this done in Mac? If it's not, maybe it's better to make this into a Settings flag rather than an #ifdef block. 962062 4 thiago.lacerda 2013-12-20 14:38:12 -0800 (In reply to comment #3) > (From update of attachment 219697 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=219697&action=review > > > Source/WebCore/ChangeLog:17 > > + * loader/HistoryController.cpp: > > + (WebCore::HistoryController::restoreScrollPositionAndViewState): > > Explain what you're actually doing to rectify this. OK > > > Source/WebKit2/ChangeLog:13 > > + When user is navigating back/forward to a page that has been scrolled and/or scaled, that page must be shown > > + with its last scroll position and scale factor. > > + Also, when a user was using the WKView API to set the scale factor (WKViewSetContentScaleFactor) this scale was > > + not being forwarded to WebCore. Then, when going back/forward to a page HistoryController was not knowing about > > + its real scale factor. > > + A WebKitAPI test is being added to validate this behaviour. > > This is a description of the bug. Also describe the solution otherwise the code is hard to follow. OK > > > Source/WebCore/loader/HistoryController.cpp:159 > > + double currentScaleFactor = m_currentItem->pageScaleFactor(); > > + IntPoint currentScrollPoint = m_currentItem->scrollPoint(); > > +#if PLATFORM(EFL) || PLATFORM(NIX) > > + double previousScaleFactor = m_previousItem ? m_previousItem->pageScaleFactor() : currentScaleFactor; > > + IntPoint previousScrollPoint = m_previousItem ? m_previousItem->scrollPoint() : currentScrollPoint; > > + > > + if (previousScaleFactor != currentScaleFactor || previousScrollPoint != currentScrollPoint) { > > +#else > > if (!view->wasScrolledByUser()) { > > - if (page && m_frame.isMainFrame() && m_currentItem->pageScaleFactor()) > > - page->setPageScaleFactor(m_currentItem->pageScaleFactor(), m_currentItem->scrollPoint()); > > +#endif // PLATFORM(EFL) || PLATFORM(NIX) > > + if (page && m_frame.isMainFrame() && currentScaleFactor) > > + page->setPageScaleFactor(currentScaleFactor, currentScrollPoint); > > else > > - view->setScrollPosition(m_currentItem->scrollPoint()); > > + view->setScrollPosition(currentScrollPoint); > > } > > } > > This snippet is a bit spaghettified... I would rather try to figure out how ports where this already works (Mac?) do this, and try to consolidate rather than have port #ifdefs in WebCore. I could only reproduce this on ports using CoordinatedGraphics, with TILED_BACKING_STORE and fixed layout enabled. Then a very specific code path occurs, where FrameView::setWasScrolledByUser is set between Frame::reset and HistoryController::restoreViewStateAndScrollPosition, which makes the zoom and the scrollPosition to do not be restored (since they will not enter in the condition if (!view->wasScrolledByUser()). I will remove the #if code to a separated method. > > > Source/WebKit2/UIProcess/PageClient.h:127 > > +#if PLATFORM(EFL) || PLATFORM(NIX) > > + virtual void didChangePageScaleFactor(double scaleFactor) = 0; > > +#endif > > I think this can be an empty implementation rather than some #ifdefed thing. OK > > > Source/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:1147 > > +#if PLATFORM(EFL) || PLATFORM(NIX) > > + if (m_frame == m_frame->page()->mainWebFrame()) > > + m_frame->page()->send(Messages::WebPageProxy::PageDidRequestScroll(m_frame->coreFrame()->loader().history().currentItem()->scrollPoint())); > > +#endif > > How is this done in Mac? > If it's not, maybe it's better to make this into a Settings flag rather than an #ifdef block. I figured out that this will not be needed 962065 5 219798 thiago.lacerda 2013-12-20 15:03:53 -0800 Created attachment 219798 Patch 962077 6 219798 benjamin 2013-12-20 15:31:40 -0800 Comment on attachment 219798 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=219798&action=review r- due to platform #ifdefs in HistoryController. > Source/WebKit2/ChangeLog:3 > + scalebackhistory ? > Source/WebCore/loader/HistoryController.cpp:162 > +#if PLATFORM(EFL) || PLATFORM(NIX) > + double previousScaleFactor = m_previousItem ? m_previousItem->pageScaleFactor() : m_currentItem->pageScaleFactor(); > + IntPoint previousScrollPoint = m_previousItem ? m_previousItem->scrollPoint() : m_currentItem->scrollPoint(); > + return previousScaleFactor != m_currentItem->pageScaleFactor() || previousScrollPoint != m_currentItem->scrollPoint(); > +#else > + return !view->wasScrolledByUser(); > +#endif This #ifdef is not okay. Why can't the code be made common exactly? The changelog has a little explanation but not enough to determine what is correct. > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:88 > + if (isSuspended()) > + return; This is odd. An explanation in the changelog would be welcome. > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:106 > + m_contentScaleFactor = scaleFactor; This is a bad idea. The view presents the information of WebPageProxy. The information about contentScaleFactor already exists on WebPageProxy, I don't think you should duplicate it. 962372 7 thiago.lacerda 2013-12-22 14:42:31 -0800 (In reply to comment #6) > (From update of attachment 219798 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=219798&action=review > > r- due to platform #ifdefs in HistoryController. > > > Source/WebKit2/ChangeLog:3 > > + scalebackhistory > > ? > > > Source/WebCore/loader/HistoryController.cpp:162 > > +#if PLATFORM(EFL) || PLATFORM(NIX) > > + double previousScaleFactor = m_previousItem ? m_previousItem->pageScaleFactor() : m_currentItem->pageScaleFactor(); > > + IntPoint previousScrollPoint = m_previousItem ? m_previousItem->scrollPoint() : m_currentItem->scrollPoint(); > > + return previousScaleFactor != m_currentItem->pageScaleFactor() || previousScrollPoint != m_currentItem->scrollPoint(); > > +#else > > + return !view->wasScrolledByUser(); > > +#endif > > This #ifdef is not okay. Why can't the code be made common exactly? > > The changelog has a little explanation but not enough to determine what is correct. > > > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:88 > > + if (isSuspended()) > > + return; > > This is odd. An explanation in the changelog would be welcome. > > > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:106 > > + m_contentScaleFactor = scaleFactor; > > This is a bad idea. The view presents the information of WebPageProxy. The information about contentScaleFactor already exists on WebPageProxy, I don't think you should duplicate it. I completely agree with you. This is legacy code, so I just kept it as is. But having two "scale factors" (one in the WebView and another in the WebPageProxy) really annoys me. I would be more than happy to make a patch to unify those (WebView always getting this info from WebPageProxy). What do you think? 987091 8 gyuyoung.kim 2014-03-04 20:06:50 -0800 Thiago de Barros Lacerda, any update ? EFL port has same problem when using fixed layout. So, if you can't follow up this patch, can I finish this patch ? 987476 9 thiago.lacerda 2014-03-05 18:30:42 -0800 (In reply to comment #8) > Thiago de Barros Lacerda, any update ? > > EFL port has same problem when using fixed layout. So, if you can't follow up this patch, can I finish this patch ? Hi Gyuyoung, I have forgotten this bug. I will update the patch and let you know. Thanks 987487 10 gyuyoung.kim 2014-03-05 19:01:49 -0800 (In reply to comment #9) > (In reply to comment #8) > > Thiago de Barros Lacerda, any update ? > > > > EFL port has same problem when using fixed layout. So, if you can't follow up this patch, can I finish this patch ? > > Hi Gyuyoung, I have forgotten this bug. I will update the patch and let you know. > Thanks Nice, thank you. 988058 11 226091 gyuyoung.kim 2014-03-07 00:20:32 -0800 Created attachment 226091 Work-in-progress 988059 12 gyuyoung.kim 2014-03-07 00:22:36 -0800 (In reply to comment #11) > Created an attachment (id=226091) [details] > Work-in-progress Thiago said he doesn't have time to finish this bug. So, let me finish this patch. Thanks. Next patch is going to be uploaded. 990867 13 226822 gyuyoung.kim 2014-03-15 09:08:18 -0700 Created attachment 226822 Patch 990868 14 webkit-ews 2014-03-15 09:10:40 -0700 Attachment 226822 did not pass style-queue: Total errors found: 0 in 0 files If any of these errors are false positives, please file a bug against check-webkit-style. 990876 15 226822 ossy 2014-03-15 10:39:51 -0700 Comment on attachment 226822 Patch it's not a patch 990908 16 226827 gyuyoung.kim 2014-03-15 18:15:18 -0700 Created attachment 226827 Patch 990916 17 gyuyoung.kim 2014-03-15 19:20:35 -0700 (In reply to comment #15) > (From update of attachment 226822 [details]) > it's not a patch Oops, something was weird. I upload patch again. 991150 18 gyuyoung.kim 2014-03-17 01:32:35 -0700 Benjamin, Noam, could you take a look latest patch ? 991200 19 226827 thiago.lacerda 2014-03-17 07:19:06 -0700 Comment on attachment 226827 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=226827&action=review The problem on EFL port seems to be on the PageViewportController, it is setting the scale to 1 every time the page is loaded in didRenderFrame method > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:104 > + I think we don't need this callback, due to http://trac.webkit.org/changeset/162382. updateViewportSize() call can be moved to WebView::setContentScaleFactor. 991241 20 226827 gyuyoung.kim 2014-03-17 09:24:06 -0700 Comment on attachment 226827 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=226827&action=review > The problem on EFL port seems to be on the PageViewportController, it is setting the scale to 1 every time the page is loaded in didRenderFrame method This problem is not fixed by this patch yet. Let me check it soon. >> Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:104 >> + > > I think we don't need this callback, due to http://trac.webkit.org/changeset/162382. > updateViewportSize() call can be moved to WebView::setContentScaleFactor. > I think we don't need this callback, due to http://trac.webkit.org/changeset/162382. Looks like that. r162382 already updates m_pageScaleFactor with new scale factor. I will remove it. 992112 21 227183 gyuyoung.kim 2014-03-19 08:14:26 -0700 Created attachment 227183 Patch 992116 22 gyuyoung.kim 2014-03-19 08:35:07 -0700 (In reply to comment #19) > (From update of attachment 226827 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=226827&action=review > > The problem on EFL port seems to be on the PageViewportController, it is setting the scale to 1 every time the page is loaded in didRenderFrame method It looks it is a problem that didRenderFrame() resets existing pageScaleFactor which is not updated. It is really problem when we backward to previous page. The didRenderFrame() overwrites a pageScaleFactor of current scale factor though HistoryController::restoreScrollPositionAndViewState() restores the scale factor of previous page. So, the reset function calls are removed in latest patch. Please let me know if we need to keep those calls. > > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:104 > > + > > I think we don't need this callback, due to http://trac.webkit.org/changeset/162382. > updateViewportSize() call can be moved to WebView::setContentScaleFactor. didChangePageScaleFactor() is needed to set an updated pageScaleFactor if we remove the function calls to set an outdated pageScaleFactor. 992177 23 thiago.lacerda 2014-03-19 10:52:00 -0700 (In reply to comment #22) > (In reply to comment #19) > > (From update of attachment 226827 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=226827&action=review > > > > The problem on EFL port seems to be on the PageViewportController, it is setting the scale to 1 every time the page is loaded in didRenderFrame method > > It looks it is a problem that didRenderFrame() resets existing pageScaleFactor which is not updated. It is really problem when we backward to previous page. The didRenderFrame() overwrites a pageScaleFactor of current scale factor though HistoryController::restoreScrollPositionAndViewState() restores the scale factor of previous page. So, the reset function calls are removed in latest patch. Please let me know if we need to keep those calls. I think there is no problem, only EFL uses PageViewportController :) > > > > > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:104 > > > + > > > > I think we don't need this callback, due to http://trac.webkit.org/changeset/162382. > > updateViewportSize() call can be moved to WebView::setContentScaleFactor. > > didChangePageScaleFactor() is needed to set an updated pageScaleFactor if we remove the function calls to set an outdated pageScaleFactor. There is no need for that, since there is no more duplicated scaleFactor in both WebPageProxy and WebView, like in the past. WebView always get the updated scaleFactor because it retrieves directly from WebPageProxy (see WebView::contentScaleFactor). So, didChangeScaleFactor does nothing 992431 24 227269 gyuyoung.kim 2014-03-20 00:49:19 -0700 Created attachment 227269 Patch 992432 25 gyuyoung.kim 2014-03-20 00:54:18 -0700 (In reply to comment #23) > > > > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:104 > > > > + > > > > > > I think we don't need this callback, due to http://trac.webkit.org/changeset/162382. > > > updateViewportSize() call can be moved to WebView::setContentScaleFactor. > > > > didChangePageScaleFactor() is needed to set an updated pageScaleFactor if we remove the function calls to set an outdated pageScaleFactor. > > There is no need for that, since there is no more duplicated scaleFactor in both WebPageProxy and WebView, like in the past. WebView always get the updated scaleFactor because it retrieves directly from WebPageProxy (see WebView::contentScaleFactor). So, didChangeScaleFactor does nothing I see. I verified we don't need to add didChangeScaleFactor(). However, there is another problem. scroll position is not restored in backward load. According to my investigation, Page::setPageScaleFactor() has not updated scroll position when delegatesScrolling() is enabled. So, WK2 can't know previous scroll position in backward page load. Page::setPageScaleFactor(float scale, const IntPoint& origin) { if (!view->delegatesScrolling()) view->setScrollPosition(origin); } I would call "view->setScrollPosition(origin)" regardless of delegatesScrolling() in order to let WK2 know new scroll position. When I do that, is there any issue ? 992737 26 thiago.lacerda 2014-03-20 14:41:29 -0700 (In reply to comment #25) > (In reply to comment #23) > > > > > > Source/WebKit2/UIProcess/CoordinatedGraphics/WebView.cpp:104 > > > > > + > > > > > > > > I think we don't need this callback, due to http://trac.webkit.org/changeset/162382. > > > > updateViewportSize() call can be moved to WebView::setContentScaleFactor. > > > > > > didChangePageScaleFactor() is needed to set an updated pageScaleFactor if we remove the function calls to set an outdated pageScaleFactor. > > > > There is no need for that, since there is no more duplicated scaleFactor in both WebPageProxy and WebView, like in the past. WebView always get the updated scaleFactor because it retrieves directly from WebPageProxy (see WebView::contentScaleFactor). So, didChangeScaleFactor does nothing > > I see. I verified we don't need to add didChangeScaleFactor(). However, there is another problem. scroll position is not restored in backward load. According to my investigation, Page::setPageScaleFactor() has not updated scroll position when delegatesScrolling() is enabled. So, WK2 can't know previous scroll position in backward page load. > > Page::setPageScaleFactor(float scale, const IntPoint& origin) { > if (!view->delegatesScrolling()) > view->setScrollPosition(origin); > } > > I would call "view->setScrollPosition(origin)" regardless of delegatesScrolling() in order to let WK2 know new scroll position. When I do that, is there any issue ? Huum... I don't know, better ask benjaminp, he did this patch. I remember that I faced that problem in Nix as well, what I did that fixed the problem was to change this part of code: #if USE(TILED_BACKING_STORE) if (m_frame->coreFrame()->view()) fixedVisibleContentRect = m_frame->coreFrame()->view()->fixedVisibleContentRect(); #endif to something like this: #if USE(TILED_BACKING_STORE) #if PLATFORM(NIX) fixedVisibleContentRect = IntRect(); #else if (m_frame->coreFrame()->view()) fixedVisibleContentRect = m_frame->coreFrame()->view()->fixedVisibleContentRect(); #endif #endif Thus, view->wasScrolledByUser (in HistoryController) was never set and the scroll position is restored properly. See if that works. 992903 27 gyuyoung.kim 2014-03-20 22:07:30 -0700 (In reply to comment #26) > > Thus, view->wasScrolledByUser (in HistoryController) was never set and the scroll position is restored properly. > See if that works. Currently, m_wasScrolledByUser() is set as false by FrameView::reset() before calling HistoryController::restoreScrollPositionAndViewState(). if (!view->wasScrolledByUser()) { if (page && m_frame.isMainFrame() && m_currentItem->pageScaleFactor()) page->setPageScaleFactor(m_currentItem->pageScaleFactor(), m_currentItem->scrollPoint()); else view->setScrollPosition(m_currentItem->scrollPoint()); Thus, though page->setPageScaleFactor(m_currentItem->pageScaleFactor(), m_currentItem->scrollPoint()) is called, Page::setPageScaleFactor() can't pass the updated scrollPoint() value to WK2 side. That's why I wanna remove "if (!view->delegatesScrolling())" condition in the Page::setPageScaleFactor(). 993594 28 gyuyoung.kim 2014-03-22 17:33:28 -0700 (In reply to comment #27) > (In reply to comment #26) > > > > Thus, view->wasScrolledByUser (in HistoryController) was never set and the scroll position is restored properly. > > See if that works. > > Currently, m_wasScrolledByUser() is set as false by FrameView::reset() before calling HistoryController::restoreScrollPositionAndViewState(). > > if (!view->wasScrolledByUser()) { > if (page && m_frame.isMainFrame() && m_currentItem->pageScaleFactor()) > page->setPageScaleFactor(m_currentItem->pageScaleFactor(), m_currentItem->scrollPoint()); > else > view->setScrollPosition(m_currentItem->scrollPoint()); > > Thus, though page->setPageScaleFactor(m_currentItem->pageScaleFactor(), m_currentItem->scrollPoint()) is called, Page::setPageScaleFactor() can't pass the updated scrollPoint() value to WK2 side. That's why I wanna remove "if (!view->delegatesScrolling())" condition in the Page::setPageScaleFactor(). Benjamin, what do you think about above comments ? 995790 29 227269 gyuyoung.kim 2014-03-31 01:08:27 -0700 Comment on attachment 227269 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=227269&action=review > Source/WebCore/page/Page.cpp:-702 > - if (!view->delegatesScrolling()) Tim, could you check if this change may influence on mac and iOS ports ? 999077 30 gyuyoung.kim 2014-04-08 22:46:29 -0700 (In reply to comment #29) > (From update of attachment 227269 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=227269&action=review > > > Source/WebCore/page/Page.cpp:-702 > > - if (!view->delegatesScrolling()) > > Tim, could you check if this change may influence on mac and iOS ports ? Horton, any comment about my question ? 999078 31 gyuyoung.kim 2014-04-08 22:47:33 -0700 (In reply to comment #29) > (From update of attachment 227269 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=227269&action=review > > > Source/WebCore/page/Page.cpp:-702 > > - if (!view->delegatesScrolling()) > > Tim, could you check if this change may influence on mac and iOS ports ? Horton, any comment about my question ? 1003205 32 227269 simon.fraser 2014-04-22 23:25:09 -0700 Comment on attachment 227269 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=227269&action=review > Source/WebCore/page/Page.cpp:702 > + view->setScrollPosition(origin); Did you look at the history of this code? I'm pretty sure we added the if (!view->delegatesScrolling()) test to fix iOS. 1003223 33 227269 gyuyoung.kim 2014-04-23 01:25:20 -0700 Comment on attachment 227269 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=227269&action=review >> Source/WebCore/page/Page.cpp:702 >> + view->setScrollPosition(origin); > > Did you look at the history of this code? I'm pretty sure we added the if (!view->delegatesScrolling()) test to fix iOS. Simon, if so, let me try to find other way to fix this problem for EFL port. I'm going to update my opinion. Thanks. 1004031 34 230159 gyuyoung.kim 2014-04-25 03:19:10 -0700 Created attachment 230159 Patch 1004033 35 230159 gyuyoung.kim 2014-04-25 03:28:09 -0700 Comment on attachment 230159 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=230159&action=review > Source/WebCore/page/Page.cpp:718 > if (!view->delegatesScrolling()) Simon, if we don't call view->setScrollPosition(origin), we can't pass previous scroll position to WK2 side. Below view->setScrollPosition(origin) calls ScrollView::setScrollPosition(scrollPoint) eventually. Then, it calls WebChromeClient::delegatedScrollRequested() in WK2. Then, WK2 UIProcess can handle updated scroll position and scale. However, r165652 and r165913 have prohibited to call it. It looks WK2 ports(which use tiled backing store) need to call "view->setScrollPosition(origin)" in order to pass stored scroll position to WK2 implementation. void ScrollView::setScrollPosition(const IntPoint& scrollPoint) { ... #if USE(TILED_BACKING_STORE) if (delegatesScrolling()) { hostWindow()->delegatedScrollRequested(scrollPoint); return; } #endif ... } #if USE(TILED_BACKING_STORE) void WebChromeClient::delegatedScrollRequested(const IntPoint& scrollOffset) { m_page->pageDidRequestScroll(scrollOffset); } #endif 1004361 36 benjamin 2014-04-26 17:54:39 -0700 (In reply to comment #35) > (From update of attachment 230159 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=230159&action=review > > > Source/WebCore/page/Page.cpp:718 > > if (!view->delegatesScrolling()) > > Simon, if we don't call view->setScrollPosition(origin), we can't pass previous scroll position to WK2 side. > > Below view->setScrollPosition(origin) calls ScrollView::setScrollPosition(scrollPoint) eventually. Then, it calls WebChromeClient::delegatedScrollRequested() in WK2. Then, WK2 UIProcess can handle updated scroll position and scale. However, r165652 and r165913 have prohibited to call it. It looks WK2 ports(which use tiled backing store) need to call "view->setScrollPosition(origin)" in order to pass stored scroll position to WK2 implementation. There is a general conflict about how the scroll position is set when using delegateScrolling. With delegateScrolling, there are two sources that can set the scroll position: the UI side or the engine side. There are races between the two, there is a need for differentiating the source, and we need a way to solve conflicts. There is such things in WebKit today. I do agree with Simon that changing the scroll position when changing the scale factor on page does not seem to make much sense with delegate scrolling. I agree there is a bug here. I disagree the #ifdef USE(TILED_BACKING_STORE) of this patch is a solution. I think we may need to split the paths between scrolling requested from the WebKit layers against scrolling requested from the WebCore layer. Scrolling from the WebKit layer is imperative. Scrolling from the WebCore layer needs to go through conflicts resolution. I don't have the code in front of me to find a solution, but I can have a look next week. 1004455 37 230159 gyuyoung.kim 2014-04-27 18:12:04 -0700 Comment on attachment 230159 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=230159&action=review >>> Source/WebCore/page/Page.cpp:718 >>> if (!view->delegatesScrolling()) >> >> Simon, if we don't call view->setScrollPosition(origin), we can't pass previous scroll position to WK2 side. >> >> Below view->setScrollPosition(origin) calls ScrollView::setScrollPosition(scrollPoint) eventually. Then, it calls WebChromeClient::delegatedScrollRequested() in WK2. Then, WK2 UIProcess can handle updated scroll position and scale. However, r165652 and r165913 have prohibited to call it. It looks WK2 ports(which use tiled backing store) need to call "view->setScrollPosition(origin)" in order to pass stored scroll position to WK2 implementation. >> >> >> void ScrollView::setScrollPosition(const IntPoint& scrollPoint) { >> ... >> #if USE(TILED_BACKING_STORE) >> if (delegatesScrolling()) { >> hostWindow()->delegatedScrollRequested(scrollPoint); >> return; >> } >> #endif >> ... >> } >> >> #if USE(TILED_BACKING_STORE) >> void WebChromeClient::delegatedScrollRequested(const IntPoint& scrollOffset) >> { >> m_page->pageDidRequestScroll(scrollOffset); >> } >> #endif > > There is a general conflict about how the scroll position is set when using delegateScrolling. With delegateScrolling, there are two sources that can set the scroll position: the UI side or the engine side. > > There are races between the two, there is a need for differentiating the source, and we need a way to solve conflicts. There is such things in WebKit today. > > I do agree with Simon that changing the scroll position when changing the scale factor on page does not seem to make much sense with delegate scrolling. > > I agree there is a bug here. I disagree the #ifdef USE(TILED_BACKING_STORE) of this patch is a solution. > > I think we may need to split the paths between scrolling requested from the WebKit layers against scrolling requested from the WebCore layer. Scrolling from the WebKit layer is imperative. Scrolling from the WebCore layer needs to go through conflicts resolution. > > I don't have the code in front of me to find a solution, but I can have a look next week. Benjamin, will you upload your patch to this bug or file a new bug ? Anyway, I agree to use #if USE(TILED_BACKING_STORE) is not good solution. Please let me know your way to me. Thanks. 1005365 38 230477 gyuyoung.kim 2014-04-30 07:04:49 -0700 Created attachment 230477 Patch 1005366 39 230477 gyuyoung.kim 2014-04-30 07:11:42 -0700 Comment on attachment 230477 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=230477&action=review > Source/WebCore/page/Page.cpp:755 > + view->hostWindow()->delegatedScrollRequested(origin); >> I think we may need to split the paths between scrolling requested from the WebKit layers against scrolling requested from the WebCore layer. Benjamin, I'm not sure if this is one of the paths you think though, can't we split the path like this ? I think we don't need to call the delegatedScrollRequested() in ScrollView::setScrollPosition(). If we call it here, we may make a path to split between scrolling requests from Webkit layer, isn't it ? 1007461 40 230477 benjamin 2014-05-07 15:55:53 -0700 Comment on attachment 230477 Patch We should really get rid of TILED_BACKING_STORE. OS X and iOS also have tiled backing store, TILED_BACKING_STORE is mostly duplicated code at this point. A quick grep for TILED_BACKING_STORE shows it is actually duplicating a lot of features that have been upstreamed when iOS was upstreamed. In some cases, the code behind TILED_BACKING_STORE looks very suspicious. Now is not the right time though. I have serious doubt this is patch correct. For example, the call to Page::setPageScaleFactor() could come from WebPage::scalePage(), in which case calling back into scroll requested does not make any sense. I don't want to block you on this regression forever, the impact not any worse than the other TILED_BACKING_STORE stuff -> r+ for now. 1007484 41 gyuyoung.kim 2014-05-07 18:10:31 -0700 (In reply to comment #40) > (From update of attachment 230477 [details]) > We should really get rid of TILED_BACKING_STORE. > OS X and iOS also have tiled backing store, TILED_BACKING_STORE is mostly duplicated code at this point. > > A quick grep for TILED_BACKING_STORE shows it is actually duplicating a lot of features that have been upstreamed when iOS was upstreamed. In some cases, the code behind TILED_BACKING_STORE looks very suspicious. > Now is not the right time though. I also think we need to do refactoring for the TILED_BACKING_STORE align with iOS or mac port's implementation. I'm going to talk with my co-worker how to refactor the tiled backing store. > I have serious doubt this is patch correct. For example, the call to Page::setPageScaleFactor() could come from WebPage::scalePage(), in which case calling back into scroll requested does not make any sense. > I don't want to block you on this regression forever, the impact not any worse than the other TILED_BACKING_STORE stuff -> r+ for now. Thank you for helping to my development. When we modify it, let me try to consider your concern together. 1007493 42 230477 commit-queue 2014-05-07 18:42:46 -0700 Comment on attachment 230477 Patch Clearing flags on attachment: 230477 Committed r168458: <http://trac.webkit.org/changeset/168458> 1007494 43 commit-queue 2014-05-07 18:42:57 -0700 All reviewed patches have been landed. Closing bug. 219697 2013-12-19 16:02:36 -0800 2013-12-20 15:03:32 -0800 Patch bug-126022-20131219210235.patch text/plain 19933 thiago.lacerda U3VidmVyc2lvbiBSZXZpc2lvbjogMTYwODY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDI4NTBkNGQxZTdhNWRj MjQwZjk0MGU4YjY5NjkyNzA1ZTBhMWU0Yi4uOGFkMDE3ZDU3ZTM1NzllMDk2NTJlNGNiOTI0ZmI0 ZDI2OTlhYWM4NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEzLTEyLTE5ICBUaGlh Z28gZGUgQmFycm9zIExhY2VyZGEgIDx0aGlhZ28ubGFjZXJkYUBvcGVuYm9zc2Eub3JnPgorCisg ICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNzXVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xs IHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2Fy ZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MjYwMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBX aGVuIHVzZXIgaXMgbmF2aWdhdGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdlIHRoYXQgaGFzIGJl ZW4gc2Nyb2xsZWQgYW5kL29yIHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUgc2hvd24KKyAgICAg ICAgd2l0aCBpdHMgbGFzdCBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZhY3Rvci4KKyAgICAg ICAgQWxzbywgd2hlbiBhIHVzZXIgd2FzIHVzaW5nIHRoZSBXS1ZpZXcgQVBJIHRvIHNldCB0aGUg c2NhbGUgZmFjdG9yIChXS1ZpZXdTZXRDb250ZW50U2NhbGVGYWN0b3IpIHRoaXMgc2NhbGUgd2Fz CisgICAgICAgIG5vdCBiZWluZyBmb3J3YXJkZWQgdG8gV2ViQ29yZS4gVGhlbiwgd2hlbiBnb2lu ZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdlIEhpc3RvcnlDb250cm9sbGVyIHdhcyBub3Qga25vd2lu ZyBhYm91dAorICAgICAgICBpdHMgcmVhbCBzY2FsZSBmYWN0b3IuCisKKyAgICAgICAgV2ViS2l0 QVBJIHRlc3QgYWRkZWQuCisKKyAgICAgICAgKiBsb2FkZXIvSGlzdG9yeUNvbnRyb2xsZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SGlzdG9yeUNvbnRyb2xsZXI6OnJlc3RvcmVTY3JvbGxQb3Np dGlvbkFuZFZpZXdTdGF0ZSk6CisKIDIwMTMtMTItMTkgIEFuZHJlYXMgS2xpbmcgIDxha2xpbmdA YXBwbGUuY29tPgogCiAgICAgICAgIFVzZSBDYXNjYWRlZFByb3BlcnRpZXMgZm9yIHBhZ2UgYW5k IGtleWZyYW1lIHN0eWxlIHJlc29sdXRpb24gYXMgd2VsbC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA2OTc3NjUz OGU3NTk3ZjViYmViNDc1MmQ1ODNjNTM4YTQxYzUyNzA4Li5iN2VjMDBhOTliNTAzMzNlZWQ1Yjgw NTRkMzYyMDcyZjU0ZTZlNGRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cK KysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTMtMTIt MTkgIFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSAgPHRoaWFnby5sYWNlcmRhQG9wZW5ib3NzYS5v cmc+CisKKyAgICAgICAgW0Nvb3JkaW5hdGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUgZmFjdG9yIGFu ZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5IGluIGEgYmFj ay9mb3J3YXJkIGxvYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTEyNjAyMgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFdoZW4gdXNlciBpcyBuYXZpZ2F0aW5nIGJhY2svZm9yd2FyZCB0byBhIHBhZ2UgdGhh dCBoYXMgYmVlbiBzY3JvbGxlZCBhbmQvb3Igc2NhbGVkLCB0aGF0IHBhZ2UgbXVzdCBiZSBzaG93 bgorICAgICAgICB3aXRoIGl0cyBsYXN0IHNjcm9sbCBwb3NpdGlvbiBhbmQgc2NhbGUgZmFjdG9y LgorICAgICAgICBBbHNvLCB3aGVuIGEgdXNlciB3YXMgdXNpbmcgdGhlIFdLVmlldyBBUEkgdG8g c2V0IHRoZSBzY2FsZSBmYWN0b3IgKFdLVmlld1NldENvbnRlbnRTY2FsZUZhY3RvcikgdGhpcyBz Y2FsZSB3YXMKKyAgICAgICAgbm90IGJlaW5nIGZvcndhcmRlZCB0byBXZWJDb3JlLiBUaGVuLCB3 aGVuIGdvaW5nIGJhY2svZm9yd2FyZCB0byBhIHBhZ2UgSGlzdG9yeUNvbnRyb2xsZXIgd2FzIG5v dCBrbm93aW5nIGFib3V0CisgICAgICAgIGl0cyByZWFsIHNjYWxlIGZhY3Rvci4KKyAgICAgICAg QSBXZWJLaXRBUEkgdGVzdCBpcyBiZWluZyBhZGRlZCB0byB2YWxpZGF0ZSB0aGlzIGJlaGF2aW91 ci4KKworICAgICAgICAqIFVJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuY3Bw OgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpzZXRDb250ZW50U2NhbGVGYWN0b3IpOgorICAg ICAgICAoV2ViS2l0OjpXZWJWaWV3OjpkaWRDaGFuZ2VQYWdlU2NhbGVGYWN0b3IpOgorICAgICAg ICAoV2ViS2l0OjpXZWJWaWV3OjpkaWRDb21taXRMb2FkRm9yTWFpbkZyYW1lKToKKyAgICAgICAg KiBVSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3Lmg6CisgICAgICAgIChXZWJL aXQ6OldlYlZpZXc6OmlzU3VzcGVuZGVkKToKKyAgICAgICAgKiBVSVByb2Nlc3MvUGFnZUNsaWVu dC5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAoV2Vi S2l0OjpXZWJQYWdlUHJveHk6OnBhZ2VTY2FsZUZhY3RvckRpZENoYW5nZSk6CisgICAgICAgICog V2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJGcmFtZUxvYWRlckNsaWVudC5jcHA6CisgICAg ICAgIChXZWJLaXQ6OldlYkZyYW1lTG9hZGVyQ2xpZW50OjpyZXN0b3JlVmlld1N0YXRlKToKKwog MjAxMy0xMi0xOSAgQWxleGV5IFByb3NrdXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAg ICBSRUdSRVNTSU9OIChyMTYwNTE1KTogRnJlcXVlbnQgYXNzZXJ0aW9uIGZhaWx1cmVzIG9uIHBy aW50aW5nL3ByaW50LWNsb3NlLWNyYXNoLmh0bWwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvSGlz dG9yeUNvbnRyb2xsZXIuY3BwCmluZGV4IGViYzExODJjZjhhMGEyYjc0MTZlYTg0YmZjZTliNTJh MTljMjcyMzMuLjk3YmFmYTVkYzlhMGU3NWI0NDVhZTdlZmMwYjliYzhlM2RmZjIyNWYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvbG9hZGVyL0hpc3RvcnlDb250cm9sbGVyLmNwcApAQCAtMTQxLDExICsx NDEsMjAgQEAgdm9pZCBIaXN0b3J5Q29udHJvbGxlcjo6cmVzdG9yZVNjcm9sbFBvc2l0aW9uQW5k Vmlld1N0YXRlKCkKICAgICAgICAgICAgICAgICBzY3JvbGxpbmdDb29yZGluYXRvci0+ZnJhbWVW aWV3Um9vdExheWVyRGlkQ2hhbmdlKHZpZXcpOwogICAgICAgICB9CiAKKyAgICAgICAgZG91Ymxl IGN1cnJlbnRTY2FsZUZhY3RvciA9IG1fY3VycmVudEl0ZW0tPnBhZ2VTY2FsZUZhY3RvcigpOwor ICAgICAgICBJbnRQb2ludCBjdXJyZW50U2Nyb2xsUG9pbnQgPSBtX2N1cnJlbnRJdGVtLT5zY3Jv bGxQb2ludCgpOworI2lmIFBMQVRGT1JNKEVGTCkgfHwgUExBVEZPUk0oTklYKQorICAgICAgICBk b3VibGUgcHJldmlvdXNTY2FsZUZhY3RvciA9IG1fcHJldmlvdXNJdGVtID8gbV9wcmV2aW91c0l0 ZW0tPnBhZ2VTY2FsZUZhY3RvcigpIDogY3VycmVudFNjYWxlRmFjdG9yOworICAgICAgICBJbnRQ b2ludCBwcmV2aW91c1Njcm9sbFBvaW50ID0gbV9wcmV2aW91c0l0ZW0gPyBtX3ByZXZpb3VzSXRl bS0+c2Nyb2xsUG9pbnQoKSA6IGN1cnJlbnRTY3JvbGxQb2ludDsKKworICAgICAgICBpZiAocHJl dmlvdXNTY2FsZUZhY3RvciAhPSBjdXJyZW50U2NhbGVGYWN0b3IgfHwgcHJldmlvdXNTY3JvbGxQ b2ludCAhPSBjdXJyZW50U2Nyb2xsUG9pbnQpIHsKKyNlbHNlCiAgICAgICAgIGlmICghdmlldy0+ d2FzU2Nyb2xsZWRCeVVzZXIoKSkgewotICAgICAgICAgICAgaWYgKHBhZ2UgJiYgbV9mcmFtZS5p c01haW5GcmFtZSgpICYmIG1fY3VycmVudEl0ZW0tPnBhZ2VTY2FsZUZhY3RvcigpKQotICAgICAg ICAgICAgICAgIHBhZ2UtPnNldFBhZ2VTY2FsZUZhY3RvcihtX2N1cnJlbnRJdGVtLT5wYWdlU2Nh bGVGYWN0b3IoKSwgbV9jdXJyZW50SXRlbS0+c2Nyb2xsUG9pbnQoKSk7CisjZW5kaWYgLy8gUExB VEZPUk0oRUZMKSB8fCBQTEFURk9STShOSVgpCisgICAgICAgICAgICBpZiAocGFnZSAmJiBtX2Zy YW1lLmlzTWFpbkZyYW1lKCkgJiYgY3VycmVudFNjYWxlRmFjdG9yKQorICAgICAgICAgICAgICAg IHBhZ2UtPnNldFBhZ2VTY2FsZUZhY3RvcihjdXJyZW50U2NhbGVGYWN0b3IsIGN1cnJlbnRTY3Jv bGxQb2ludCk7CiAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAgdmlldy0+c2V0U2Ny b2xsUG9zaXRpb24obV9jdXJyZW50SXRlbS0+c2Nyb2xsUG9pbnQoKSk7CisgICAgICAgICAgICAg ICAgdmlldy0+c2V0U2Nyb2xsUG9zaXRpb24oY3VycmVudFNjcm9sbFBvaW50KTsKICAgICAgICAg fQogICAgIH0KICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nv b3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv Q29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcAppbmRleCAxMDBmYTM5YmUzNGNhM2VkOGVj NDEwNDQ0NTQ3ODgzZjA1NjA1YmU4Li5iYzgwYjlmNzViMDAzMjIwYmE0NTJlN2Y5OWFjM2IwNmQz MjE4MzJkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRH cmFwaGljcy9XZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRp bmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcApAQCAtNzcsNiArNzcsMjAgQEAgdm9pZCBXZWJWaWV3 Ojppbml0aWFsaXplKCkKICAgICBzZXRBY3RpdmUodHJ1ZSk7CiB9CiAKK3ZvaWQgV2ViVmlldzo6 c2V0Q29udGVudFNjYWxlRmFjdG9yKGZsb2F0IHNjYWxlRmFjdG9yKQoreworICAgIGlmIChtX2Nv bnRlbnRTY2FsZUZhY3RvciA9PSBzY2FsZUZhY3RvcikKKyAgICAgICAgcmV0dXJuOworCisgICAg bV9jb250ZW50U2NhbGVGYWN0b3IgPSBzY2FsZUZhY3RvcjsKKworICAgIGlmIChpc1N1c3BlbmRl ZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBwYWdlKCktPnNjYWxlUGFnZShzY2FsZUZhY3Rv ciwgcm91bmRlZEludFBvaW50KGNvbnRlbnRQb3NpdGlvbigpKSk7CisgICAgdXBkYXRlVmlld3Bv cnRTaXplKCk7Cit9CisKIHZvaWQgV2ViVmlldzo6c2V0QWN0aXZlKGJvb2wgYWN0aXZlKQogewog ICAgIENvb3JkaW5hdGVkR3JhcGhpY3NTY2VuZSogc2NlbmUgPSBjb29yZGluYXRlZEdyYXBoaWNz U2NlbmUoKTsKQEAgLTg3LDYgKzEwMSwxMiBAQCB2b2lkIFdlYlZpZXc6OnNldEFjdGl2ZShib29s IGFjdGl2ZSkKICAgICBtX3BhZ2UtPnZpZXdTdGF0ZURpZENoYW5nZShWaWV3U3RhdGU6OldpbmRv d0lzQWN0aXZlKTsKIH0KIAordm9pZCBXZWJWaWV3OjpkaWRDaGFuZ2VQYWdlU2NhbGVGYWN0b3Io ZG91YmxlIHNjYWxlRmFjdG9yKQoreworICAgIG1fY29udGVudFNjYWxlRmFjdG9yID0gc2NhbGVG YWN0b3I7CisgICAgdXBkYXRlVmlld3BvcnRTaXplKCk7Cit9CisKIHZvaWQgV2ViVmlldzo6c2V0 U2l6ZShjb25zdCBXZWJDb3JlOjpJbnRTaXplJiBzaXplKQogewogICAgIGlmIChtX3NpemUgPT0g c2l6ZSkKQEAgLTM3NCw2ICszOTQsOCBAQCB2b2lkIFdlYlZpZXc6OnRvb2xUaXBDaGFuZ2VkKGNv bnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYgbmV3VG9vbFRpcCkKIAogdm9pZCBXZWJWaWV3Ojpk aWRDb21taXRMb2FkRm9yTWFpbkZyYW1lKCkKIHsKKyAgICBtX2NvbnRlbnRTY2FsZUZhY3RvciA9 IDE7CisgICAgc2V0Q29udGVudFBvc2l0aW9uKFdlYkNvcmU6OkZsb2F0UG9pbnQoKSk7CiAgICAg bV9jb250ZW50c1NpemUgPSBJbnRTaXplKCk7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuaCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuaAppbmRleCA3YzM0NGU5 ZDU4YTI5ZDk5MDBkMmZlYjFhMTc3YjI1ZGFlMTEyYzcxLi40YmQxZTFkOTEzODIxZjE0ZmNmNjVk ZjhlOGQzMmZkN2U4ODE3NWQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv Q29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5oCkBAIC03MCw3ICs3MCw3IEBAIHB1Ymxp YzoKICAgICBib29sIGlzVmlzaWJsZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmlzaWJsZTsgfQogICAg IHZvaWQgc2V0VmlzaWJsZShib29sKTsKIAotICAgIHZvaWQgc2V0Q29udGVudFNjYWxlRmFjdG9y KGZsb2F0IHNjYWxlRmFjdG9yKSB7IG1fY29udGVudFNjYWxlRmFjdG9yID0gc2NhbGVGYWN0b3I7 IH0KKyAgICB2b2lkIHNldENvbnRlbnRTY2FsZUZhY3RvcihmbG9hdCk7CiAgICAgZmxvYXQgY29u dGVudFNjYWxlRmFjdG9yKCkgY29uc3QgeyByZXR1cm4gbV9jb250ZW50U2NhbGVGYWN0b3I7IH0K IAogICAgIHZvaWQgc2V0Q29udGVudFBvc2l0aW9uKGNvbnN0IFdlYkNvcmU6OkZsb2F0UG9pbnQm IHBvc2l0aW9uKSB7IG1fY29udGVudFBvc2l0aW9uID0gcG9zaXRpb247IH0KQEAgLTk2LDYgKzk2 LDggQEAgcHVibGljOgogICAgIHZvaWQgc2V0U2hvd3NBc1NvdXJjZShib29sKTsKICAgICBib29s IHNob3dzQXNTb3VyY2UoKSBjb25zdDsKIAorICAgIGJvb2wgaXNTdXNwZW5kZWQoKSB7IHJldHVy biBwYWdlKCktPmFyZUFjdGl2ZURPTU9iamVjdHNBbmRBbmltYXRpb25zU3VzcGVuZGVkKCk7IH0K KwogI2lmIEVOQUJMRShGVUxMU0NSRUVOX0FQSSkKICAgICBib29sIHJlcXVlc3RFeGl0RnVsbFNj cmVlbigpOwogI2VuZGlmCkBAIC0xNTMsNiArMTU1LDggQEAgcHJvdGVjdGVkOgogCiAgICAgdmly dHVhbCB2b2lkIGRpZENvbW1pdExvYWRGb3JNYWluRnJhbWUoKSBPVkVSUklERTsKIAorICAgIHZp cnR1YWwgdm9pZCBkaWRDaGFuZ2VQYWdlU2NhbGVGYWN0b3IoZG91YmxlKSBPVkVSUklERTsKKwog ICAgIHZpcnR1YWwgdm9pZCBwYWdlRGlkUmVxdWVzdFNjcm9sbChjb25zdCBXZWJDb3JlOjpJbnRQ b2ludCYpIE9WRVJSSURFOwogICAgIHZpcnR1YWwgdm9pZCBkaWRSZW5kZXJGcmFtZShjb25zdCBX ZWJDb3JlOjpJbnRTaXplJiBjb250ZW50c1NpemUsIGNvbnN0IFdlYkNvcmU6OkludFJlY3QmIGNv dmVyZWRSZWN0KSBPVkVSUklERTsKICAgICB2aXJ0dWFsIHZvaWQgcGFnZVRyYW5zaXRpb25WaWV3 cG9ydFJlYWR5KCkgT1ZFUlJJREU7CkBAIC0yMDUsNyArMjA5LDYgQEAgcHJvdGVjdGVkOgogICAg IHZpcnR1YWwgdm9pZCBiZWdhbkV4aXRGdWxsU2NyZWVuKGNvbnN0IFdlYkNvcmU6OkludFJlY3Qm LCBjb25zdCBXZWJDb3JlOjpJbnRSZWN0JikgT1ZFUlJJREUgeyB9CiAjZW5kaWYKIAotcHJvdGVj dGVkOgogICAgIFdlYlZpZXdDbGllbnQgbV9jbGllbnQ7CiAgICAgUmVmUHRyPFdlYlBhZ2VQcm94 eT4gbV9wYWdlOwogICAgIERlZmF1bHRVbmRvQ29udHJvbGxlciBtX3VuZG9Db250cm9sbGVyOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmgKaW5kZXggZjVlYTBlYzkwY2QyZWJkMzAx MDQ1M2U2ZGMyNmYwYzVmOTQyODBiYy4uN2E0MTBhZGM5NjEwNTU5YzdkYmZlZTBkM2E3NGFiOWQw ZWYzYzc1YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQu aAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGFnZUNsaWVudC5oCkBAIC0xMjIsNiAr MTIyLDEwIEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCB0b29sVGlwQ2hhbmdlZChjb25z dCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmKSA9IDA7CiAKKyNpZiBQTEFURk9STShFRkwpIHx8IFBM QVRGT1JNKE5JWCkKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlUGFnZVNjYWxlRmFjdG9yKGRv dWJsZSBzY2FsZUZhY3RvcikgPSAwOworI2VuZGlmCisKICAgICB2aXJ0dWFsIGJvb2wgZGVjaWRl UG9saWN5Rm9yR2VvbG9jYXRpb25QZXJtaXNzaW9uUmVxdWVzdChXZWJGcmFtZVByb3h5JiwgV2Vi U2VjdXJpdHlPcmlnaW4mLCBHZW9sb2NhdGlvblBlcm1pc3Npb25SZXF1ZXN0UHJveHkmKQogICAg IHsKICAgICAgICAgcmV0dXJuIGZhbHNlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcAppbmRleCBlOTEzMzRlZjVjMzJjNzQxOWJjMTkyNzVkYTUzZTI4MjkxN2M3MTZh Li43MDQ2NmU5YTJiNWVhMGVlZjIyNzRmZjBmOTQ4YTQxNTI2OGQzZGU3IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAtMTgxOCw2ICsxODE4LDkgQEAgdm9p ZCBXZWJQYWdlUHJveHk6OnNldEdhcEJldHdlZW5QYWdlcyhkb3VibGUgZ2FwKQogdm9pZCBXZWJQ YWdlUHJveHk6OnBhZ2VTY2FsZUZhY3RvckRpZENoYW5nZShkb3VibGUgc2NhbGVGYWN0b3IpCiB7 CiAgICAgbV9wYWdlU2NhbGVGYWN0b3IgPSBzY2FsZUZhY3RvcjsKKyNpZiBQTEFURk9STShFRkwp IHx8IFBMQVRGT1JNKE5JWCkKKyAgICBtX3BhZ2VDbGllbnQuZGlkQ2hhbmdlUGFnZVNjYWxlRmFj dG9yKG1fcGFnZVNjYWxlRmFjdG9yKTsKKyNlbmRpZgogfQogCiB2b2lkIFdlYlBhZ2VQcm94eTo6 cGFnZVpvb21GYWN0b3JEaWRDaGFuZ2UoZG91YmxlIHpvb21GYWN0b3IpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYkZyYW1lTG9hZGVyQ2xp ZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJh bWVMb2FkZXJDbGllbnQuY3BwCmluZGV4IDhiZTg3ODc5NjMxYWRiM2QxZWRkMmRjMDBmODI2NzVi Y2QxZGQzODYuLjZjNzc0NDM3NjA5ZmIxOTM1MjgxYjAzNjY2ZWVmMGM0ZmJhYTU3MGMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViRnJhbWVM b2FkZXJDbGllbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1 cHBvcnQvV2ViRnJhbWVMb2FkZXJDbGllbnQuY3BwCkBAIC0xMTQxLDYgKzExNDEsMTEgQEAgdm9p ZCBXZWJGcmFtZUxvYWRlckNsaWVudDo6cmVzdG9yZVZpZXdTdGF0ZSgpCiAgICAgaWYgKHNjYWxl RmFjdG9yKQogICAgICAgICBtX2ZyYW1lLT5wYWdlKCktPnNlbmQoTWVzc2FnZXM6OldlYlBhZ2VQ cm94eTo6UGFnZVNjYWxlRmFjdG9yRGlkQ2hhbmdlKHNjYWxlRmFjdG9yKSk7CiAKKyNpZiBQTEFU Rk9STShFRkwpIHx8IFBMQVRGT1JNKE5JWCkKKyAgICBpZiAobV9mcmFtZSA9PSBtX2ZyYW1lLT5w YWdlKCktPm1haW5XZWJGcmFtZSgpKQorICAgICAgICBtX2ZyYW1lLT5wYWdlKCktPnNlbmQoTWVz c2FnZXM6OldlYlBhZ2VQcm94eTo6UGFnZURpZFJlcXVlc3RTY3JvbGwobV9mcmFtZS0+Y29yZUZy YW1lKCktPmxvYWRlcigpLmhpc3RvcnkoKS5jdXJyZW50SXRlbSgpLT5zY3JvbGxQb2ludCgpKSk7 CisjZW5kaWYKKwogICAgIC8vIEZJWE1FOiBUaGlzIHNob3VsZCBub3QgYmUgbmVjZXNzYXJ5LiBX ZWJDb3JlIHNob3VsZCBiZSBjb3JyZWN0bHkgaW52YWxpZGF0aW5nCiAgICAgLy8gdGhlIHZpZXcg b24gcmVzdG9yZXMgZnJvbSB0aGUgYmFjay9mb3J3YXJkIGNhY2hlLgogICAgIGlmIChtX2ZyYW1l ID09IG1fZnJhbWUtPnBhZ2UoKS0+bWFpbldlYkZyYW1lKCkpCmRpZmYgLS1naXQgYS9Ub29scy9D aGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggOGUxODA0YzJiMjBiZWI2YWQ4MjY1Yzdi ZDM1NDUyODA4MWJmZjAzZS4uYWRlMTBiOWQ3ZTA2N2Q1YWIxZThhNTdhZmVjZTU3YWFlOTE1Y2Qw YyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAt MSwzICsxLDI0IEBACisyMDEzLTEyLTE5ICBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEgIDx0aGlh Z28ubGFjZXJkYUBvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNz XVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0 b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2FyZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjYwMjIKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXaGVuIHVzZXIgaXMgbmF2aWdhdGluZyBiYWNr L2ZvcndhcmQgdG8gYSBwYWdlIHRoYXQgaGFzIGJlZW4gc2Nyb2xsZWQgYW5kL29yIHNjYWxlZCwg dGhhdCBwYWdlIG11c3QgYmUgc2hvd24KKyAgICAgICAgd2l0aCBpdHMgbGFzdCBzY3JvbGwgcG9z aXRpb24gYW5kIHNjYWxlIGZhY3Rvci4KKyAgICAgICAgQWxzbywgd2hlbiBhIHVzZXIgd2FzIHVz aW5nIHRoZSBXS1ZpZXcgQVBJIHRvIHNldCB0aGUgc2NhbGUgZmFjdG9yIChXS1ZpZXdTZXRDb250 ZW50U2NhbGVGYWN0b3IpIHRoaXMgc2NhbGUgd2FzCisgICAgICAgIG5vdCBiZWluZyBmb3J3YXJk ZWQgdG8gV2ViQ29yZS4gVGhlbiwgd2hlbiBnb2luZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdlIEhp c3RvcnlDb250cm9sbGVyIHdhcyBub3Qga25vd2luZyBhYm91dAorICAgICAgICBpdHMgcmVhbCBz Y2FsZSBmYWN0b3IuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtl OgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBo aWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwOiBBZGRlZC4KKyAg ICAgICAgKFRlc3RXZWJLaXRBUEk6OmRpZEZpbmlzaExvYWRGb3JGcmFtZSk6CisgICAgICAgIChU ZXN0V2ViS2l0QVBJOjpkaWRDaGFuZ2VDb250ZW50c1Bvc2l0aW9uKToKKyAgICAgICAgKFRlc3RX ZWJLaXRBUEk6OlRFU1QpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9D b29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBU ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2Fy ZDIuaHRtbDogQWRkZWQuCisKIDIwMTMtMTItMTkgIE15bGVzIEMuIE1heGZpZWxkICA8bW1heGZp ZWxkQGFwcGxlLmNvbT4KIAogICAgICAgICBjaGVjay13ZWJraXQtc3R5bGUgbWFya3MgcnZhbHVl IHJlZmVyZW5jZXMgYXMgdmlvbGF0aW9ucwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21h a2UKaW5kZXggN2ZmYzZjZjkwMDY3ZjIxMWQwMzljNGQ4Y2RjNDIxNDQ5ODlkYTNkYS4uZDIzYTUw MjA1OWJiYTRmNGE2OTBlZmRiMmY3NjNiZTIwNGQ0NzQ1ZSAxMDA2NDQKLS0tIGEvVG9vbHMvVGVz dFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Bs YXRmb3JtRWZsLmNtYWtlCkBAIC0xMDQsNiArMTA0LDcgQEAgc2V0KHRlc3Rfd2Via2l0Ml9hcGlf QklOQVJJRVMKICAgICBXaWxsTG9hZAogICAgIFdpbGxTZW5kU3VibWl0RXZlbnQKICAgICBDb29y ZGluYXRlZEdyYXBoaWNzL1dLVmlld0lzQWN0aXZlU2V0SXNBY3RpdmUKKyAgICBDb29yZGluYXRl ZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQKICAgICBDb29y ZGluYXRlZEdyYXBoaWNzL1dLVmlld1VzZXJWaWV3cG9ydFRvQ29udGVudHMKICAgICBlZmwvV0tW aWV3Q2xpZW50V2ViUHJvY2Vzc0NhbGxiYWNrcwogKQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpv b21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tG b3J3YXJkLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iM2VkY2Q5M2ExMjg2OWQxZDEwMTc2ODFkMzk4OGNkOWE1 ZTI2M2VhCi0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9y d2FyZC5jcHAKQEAgLTAsMCArMSwxODQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTItMjAx MyBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERF UlMgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUIEhPTERF UlMgT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJQbGF0Zm9ybVV0aWxpdGllcy5oIgor I2luY2x1ZGUgPFdlYktpdDIvV0tDb250ZXh0Lmg+CisjaW5jbHVkZSA8V2ViS2l0Mi9XS0dlb21l dHJ5Lmg+CisjaW5jbHVkZSA8V2ViS2l0Mi9XS1JldGFpblB0ci5oPgorI2luY2x1ZGUgIlRlc3Qu aCIKKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCitzdGF0aWMgYm9vbCBmaW5pc2hlZExv YWQgPSBmYWxzZTsKK3N0YXRpYyBib29sIHNjcm9sbCA9IGZhbHNlOworCitzdGF0aWMgdm9pZCBk aWRGaW5pc2hMb2FkRm9yRnJhbWUoV0tQYWdlUmVmLCBXS0ZyYW1lUmVmLCBXS1R5cGVSZWYsIGNv bnN0IHZvaWQqKQoreworICAgIGZpbmlzaGVkTG9hZCA9IHRydWU7Cit9CisKK3N0YXRpYyB2b2lk IGRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb24oV0tWaWV3UmVmLCBXS1BvaW50IHAsIGNvbnN0IHZv aWQqKQoreworICAgIHNjcm9sbCA9IHRydWU7Cit9CisKK1RFU1QoV2ViS2l0MiwgQmFja0Zvcndh cmQpCit7CisgICAgY29uc3QgV0tTaXplIHNpemUgPSBXS1NpemVNYWtlKDgwMCwgNjAwKTsKKwor ICAgIFdLUmV0YWluUHRyPFdLQ29udGV4dFJlZj4gY29udGV4dCA9IGFkb3B0V0soV0tDb250ZXh0 Q3JlYXRlKCkpOworICAgIFdLUmV0YWluUHRyPFdLVmlld1JlZj4gdmlldyhBZG9wdFdLLCBXS1Zp ZXdDcmVhdGUoY29udGV4dC5nZXQoKSwgMCkpOworCisgICAgV0tWaWV3SW5pdGlhbGl6ZSh2aWV3 LmdldCgpKTsKKyAgICBXS1ZpZXdTZXRTaXplKHZpZXcuZ2V0KCksIHNpemUpOworCisgICAgV0tQ YWdlUmVmIHBhZ2VSZWYgPSBXS1ZpZXdHZXRQYWdlKHZpZXcuZ2V0KCkpOworICAgIEFTU0VSVF9U UlVFKHBhZ2VSZWYpOworCisgICAgV0tQYWdlTG9hZGVyQ2xpZW50VjMgbG9hZGVyQ2xpZW50Owor ICAgIG1lbXNldCgmbG9hZGVyQ2xpZW50LCAwLCBzaXplb2YobG9hZGVyQ2xpZW50KSk7CisgICAg bG9hZGVyQ2xpZW50LmJhc2UudmVyc2lvbiA9IDM7CisgICAgbG9hZGVyQ2xpZW50LmRpZEZpbmlz aExvYWRGb3JGcmFtZSA9IGRpZEZpbmlzaExvYWRGb3JGcmFtZTsKKyAgICBXS1BhZ2VTZXRQYWdl TG9hZGVyQ2xpZW50KHBhZ2VSZWYsICZsb2FkZXJDbGllbnQuYmFzZSk7CisKKyAgICBXS1ZpZXdD bGllbnRWMCB2aWV3Q2xpZW50OworICAgIG1lbXNldCgmdmlld0NsaWVudCwgMCwgc2l6ZW9mKHZp ZXdDbGllbnQpKTsKKyAgICB2aWV3Q2xpZW50LmJhc2UudmVyc2lvbiA9IDA7CisgICAgdmlld0Ns aWVudC5kaWRDaGFuZ2VDb250ZW50c1Bvc2l0aW9uID0gZGlkQ2hhbmdlQ29udGVudHNQb3NpdGlv bjsKKyAgICBXS1ZpZXdTZXRWaWV3Q2xpZW50KHZpZXcuZ2V0KCksICZ2aWV3Q2xpZW50LmJhc2Up OworCisgICAgV0tSZXRhaW5QdHI8V0tVUkxSZWY+IHVybCA9IGFkb3B0V0soVXRpbDo6Y3JlYXRl VVJMRm9yUmVzb3VyY2UoIkNvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQxIiwgImh0bWwi KSk7CisgICAgV0tQYWdlTG9hZFVSTChwYWdlUmVmLCB1cmwuZ2V0KCkpOworICAgIFV0aWw6OnJ1 bigmZmluaXNoZWRMb2FkKTsKKworICAgIGZsb2F0IG5ld1NjYWxlID0gMi4wOworICAgIFdLUG9p bnQgcG9pbnQgPSBXS1BvaW50TWFrZSgxMCwgMzUwKTsKKyAgICBXS1ZpZXdTZXRDb250ZW50UG9z aXRpb24odmlldy5nZXQoKSwgcG9pbnQpOworICAgIFdLVmlld1NldENvbnRlbnRTY2FsZUZhY3Rv cih2aWV3LmdldCgpLCBuZXdTY2FsZSk7CisgICAgZmxvYXQgc2NhbGUgPSBXS1ZpZXdHZXRDb250 ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgV0tQb2ludCBjb250ZW50UG9zaXRpb24g PSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKG5l d1NjYWxlLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlvbi54 KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueSwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAgZmlu aXNoZWRMb2FkID0gZmFsc2U7CisgICAgdXJsID0gYWRvcHRXSyhVdGlsOjpjcmVhdGVVUkxGb3JS ZXNvdXJjZSgiQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDIiLCAiaHRtbCIpKTsKKyAg ICBXS1BhZ2VMb2FkVVJMKHBhZ2VSZWYsIHVybC5nZXQoKSk7CisgICAgVXRpbDo6cnVuKCZmaW5p c2hlZExvYWQpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmll dy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9u KHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKDAs IGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoMCwgY29udGVudFBvc2l0aW9uLnkp OworCisgICAgV0tQYWdlR29CYWNrKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAg IGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAg ICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2Fs ZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250 ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKG5ld1NjYWxlLCBzY2FsZSk7 CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1Rf RVEocG9pbnQueSwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQYWdlR29Gb3J3YXJkKHBh Z2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOwor ICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisK KyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAg ICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7 CisgICAgRVhQRUNUX0VRKDEsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEoMCwgY29udGVudFBvc2l0 aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1Bh Z2VHb0JhY2socGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2Fk ID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigm c2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcu Z2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2 aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEobmV3U2NhbGUsIHNjYWxlKTsKKyAgICBFWFBFQ1Rf RVEocG9pbnQueCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUShwb2ludC55LCBj b250ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1BhZ2VHb0ZvcndhcmQocGFnZVJlZik7CisgICAg c2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVu KCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0g V0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3Np dGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1Rf RVEoMSwgc2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueCk7CisgICAg RVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFnZUdvQmFjayhwYWdl UmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAg ICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisg ICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAg Y29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOwor ICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9FUShwb2ludC54LCBj b250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNvbnRlbnRQb3NpdGlv bi55KTsKKworICAgIFdLUGFnZUdvRm9yd2FyZChwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxz ZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9h ZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250 ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3 R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBzY2FsZSk7 CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoMCwg Y29udGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQYWdlR29CYWNrKHBhZ2VSZWYpOworICAgIHNj cm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigm ZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdL Vmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRp b24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VR KG5ld1NjYWxlLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlv bi54KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueSwgY29udGVudFBvc2l0aW9uLnkpOworfQorCit9 IC8vIFRlc3RXZWJLaXRBUEkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQx Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYWE5YWM4ZWMyOGVlNGVhMDMyMzU3ZmM2NGU0OWZmMDJiMTJhYmQ4 OAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9D b29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sCkBAIC0wLDAgKzEsMyBAQAorPGJv ZHkgc3R5bGU9IndpZHRoOjEwMCU7IGhlaWdodDoxMDAlIj4KKyAgICA8ZGl2IHN0eWxlPSJwb3Np dGlvbjogYWJzb2x1dGU7IHRvcDogMDsgbGVmdDogMDsgd2lkdGg6IDkwMHB4OyBoZWlnaHQ6IDEy MDBweDsiPjwvZGl2PgorPC9ib2R5PgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyLmh0bWwgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9y d2FyZDIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zODA2YjlkMzJlYzRkZTM5ODYxZjJmNzcyYTIxOTIxOGVl YTljNjc1Ci0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyLmh0bWwKQEAgLTAsMCArMSBAQAor PGJvZHkgc3R5bGU9IndpZHRoOjEwMCU7IGhlaWdodDoxMDAlIi8+Cg== 219798 2013-12-20 15:03:53 -0800 2014-03-07 00:20:25 -0800 Patch bug-126022-20131220200351.patch text/plain 21171 thiago.lacerda U3VidmVyc2lvbiBSZXZpc2lvbjogMTYwOTI4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzk3ODUxZmNjNDg3N2Uz NTQxMGI5OWI3MTE0MTY2ZWU2ZGIwMWY3MS4uZTJiYTg3MGJiNWUyMjI4YjcwOWExYTQ4NWQ1Y2Q3 NGVhOWZlNDBjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEzLTEyLTIwICBUaGlh Z28gZGUgQmFycm9zIExhY2VyZGEgIDx0aGlhZ28ubGFjZXJkYUBvcGVuYm9zc2Eub3JnPgorCisg ICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNzXVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xs IHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2Fy ZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MjYwMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBX aGVuIHVzZXIgaXMgbmF2aWdhdGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdlIHRoYXQgaGFzIGJl ZW4gc2Nyb2xsZWQgYW5kL29yIHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUgc2hvd24KKyAgICAg ICAgd2l0aCBpdHMgbGFzdCBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZhY3Rvci4KKyAgICAg ICAgSG93ZXZlciwgd2hlbiBmaXhlZCBsYXlvdXQgd2FzIGVuYWJsZWQgd2l0aCBDb29yZGluYXRl ZEdyYXBoaWNzIGFuZCBUSUxFRF9CQUNLSU5HX1NUT1JFLAorICAgICAgICBGcmFtZVZpZXc6OnNl dFZpZXdXYXNTY3JvbGxlZEJ5VXNlciB3YXMgYmVpbmcgY2FsbGVkIGJldHdlZW4gRnJhbWVWaWV3 OjpyZXNldCBhbmQKKyAgICAgICAgSGlzdG9yeUNvbnRyb2xsZXI6OnJlc3RvcmVTY3JvbGxQb3Np dGlvbkFuZFZpZXdTdGF0ZSwgY2F1c2luZyB0aGUgdGhlIFdlYkNvcmU6OlBhZ2UgdG8gZG8gbm90 IGdldCBpdHMgc2NhbGUKKyAgICAgICAgZmFjdG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gdG8gYmUg cmVzdG9yZWQuCisgICAgICAgIE5vd2FkYXlzIHRoZSBvbmx5IHBvcnRzIHRoYXQgdXNlIENvb3Jk aW5hdGVkR3JhcGhpY3MgYW5kIFRJTEVEX0JBQ0tJTkdfU1RPUkUgYXJlIEVGTCBhbmQgTml4Lgor CisgICAgICAgIEFsc28sIHdoZW4gYSB1c2VyIHdhcyB1c2luZyB0aGUgV0tWaWV3IEFQSSB0byBz ZXQgdGhlIHNjYWxlIGZhY3RvciAoV0tWaWV3U2V0Q29udGVudFNjYWxlRmFjdG9yKSB0aGlzIHNj YWxlIHdhcworICAgICAgICBub3QgYmVpbmcgZm9yd2FyZGVkIHRvIFdlYkNvcmUuCisgICAgICAg IFRoZW4sIHdoZW4gZ29pbmcgYmFjay9mb3J3YXJkIHRvIGEgcGFnZSBIaXN0b3J5Q29udHJvbGxl ciB3YXMgbm90IGtub3dpbmcgYWJvdXQgaXRzIHJlYWwgc2NhbGUgZmFjdG9yLgorCisgICAgICAg IEEgV2ViS2l0QVBJIHRlc3QgaXMgYmVpbmcgYWRkZWQgdG8gdmFsaWRhdGUgdGhpcyBiZWhhdmlv dXIuCisKKyAgICAgICAgKiBsb2FkZXIvSGlzdG9yeUNvbnRyb2xsZXIuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SGlzdG9yeUNvbnRyb2xsZXI6OnJlc3RvcmVTY3JvbGxQb3NpdGlvbkFuZFZpZXdT dGF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpIaXN0b3J5Q29udHJvbGxlcjo6c2hvdWxkUmVzdG9y ZVBhZ2VTY2FsZUZhY3RvckFuZFNjcm9sbFBvc2l0aW9uKTogTWV0aG9kIGFkZGVkIHRvIGRlY2lk ZSB3aGV0aGVyCisgICAgICAgIEhpc3RvcnlDb250cm9sbGVyIHNob3VsZCB0cnkgdG8gcmVzdG9y ZSB0aGUgcGFnZSBzY2FsZSBmYWN0b3IgYW5kIHNjcm9sbCBwb3NpdGlvbiwgYmFzZWQgb24gdGhl IHBsYXRmb3JtLgorICAgICAgICAqIGxvYWRlci9IaXN0b3J5Q29udHJvbGxlci5oOgorCiAyMDEz LTEyLTIwICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAg TW92ZSBzY2hlZHVsZVNldE5lZWRzU3R5bGVSZWNhbGMgdG8gSFRNTEZyYW1lT3duZXJFbGVtZW50 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cKaW5kZXggOGViNTJiOTNjYjFjZmFhZmJlNjNmMjM1MTczZmViN2FkMjYwMzEzZi4u ZTM1ODIwODIyMjRiYzM2MmI2ODM2N2QzOWQ1ODlkZmM4NmE0ZDkwYSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAt MSwzICsxLDM3IEBACisyMDEzLTEyLTIwICBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEgIDx0aGlh Z28ubGFjZXJkYUBvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIHNjYWxlYmFja2hpc3RvcnkKKwor ICAgICAgICBbQ29vcmRpbmF0ZWRHcmFwaGljc11bV0syXSBTY2FsZSBmYWN0b3IgYW5kIHNjcm9s bCBwb3NpdGlvbiBpcyBub3QgYmVpbmcgcmVzdG9yZWQgcHJvcGVybHkgaW4gYSBiYWNrL2Zvcndh cmQgbG9hZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MTI2MDIyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg V2hlbiB1c2VyIGlzIG5hdmlnYXRpbmcgYmFjay9mb3J3YXJkIHRvIGEgcGFnZSB0aGF0IGhhcyBi ZWVuIHNjcm9sbGVkIGFuZC9vciBzY2FsZWQsIHRoYXQgcGFnZSBtdXN0IGJlIHNob3duCisgICAg ICAgIHdpdGggaXRzIGxhc3Qgc2Nyb2xsIHBvc2l0aW9uIGFuZCBzY2FsZSBmYWN0b3IuCisgICAg ICAgIEhvd2V2ZXIsIHdoZW4gZml4ZWQgbGF5b3V0IHdhcyBlbmFibGVkIHdpdGggQ29vcmRpbmF0 ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19TVE9SRSwKKyAgICAgICAgRnJhbWVWaWV3Ojpz ZXRWaWV3V2FzU2Nyb2xsZWRCeVVzZXIgd2FzIGJlaW5nIGNhbGxlZCBiZXR3ZWVuIEZyYW1lVmll dzo6cmVzZXQgYW5kCisgICAgICAgIEhpc3RvcnlDb250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9z aXRpb25BbmRWaWV3U3RhdGUsIGNhdXNpbmcgdGhlIHRoZSBXZWJDb3JlOjpQYWdlIHRvIGRvIG5v dCBnZXQgaXRzIHNjYWxlCisgICAgICAgIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIHRvIGJl IHJlc3RvcmVkLgorICAgICAgICBOb3dhZGF5cyB0aGUgb25seSBwb3J0cyB0aGF0IHVzZSBDb29y ZGluYXRlZEdyYXBoaWNzIGFuZCBUSUxFRF9CQUNLSU5HX1NUT1JFIGFyZSBFRkwgYW5kIE5peC4K KworICAgICAgICBBbHNvLCB3aGVuIGEgdXNlciB3YXMgdXNpbmcgdGhlIFdLVmlldyBBUEkgdG8g c2V0IHRoZSBzY2FsZSBmYWN0b3IgKFdLVmlld1NldENvbnRlbnRTY2FsZUZhY3RvcikgdGhpcyBz Y2FsZSB3YXMKKyAgICAgICAgbm90IGJlaW5nIGZvcndhcmRlZCB0byBXZWJDb3JlLgorICAgICAg ICBUaGVuLCB3aGVuIGdvaW5nIGJhY2svZm9yd2FyZCB0byBhIHBhZ2UgSGlzdG9yeUNvbnRyb2xs ZXIgd2FzIG5vdCBrbm93aW5nIGFib3V0IGl0cyByZWFsIHNjYWxlIGZhY3Rvci4KKworICAgICAg ICBBIFdlYktpdEFQSSB0ZXN0IGlzIGJlaW5nIGFkZGVkIHRvIHZhbGlkYXRlIHRoaXMgYmVoYXZp b3VyLgorCisgICAgICAgICogVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OnNldENvbnRlbnRTY2FsZUZhY3Rvcik6Cisg ICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OmRpZENoYW5nZVBhZ2VTY2FsZUZhY3Rvcik6CisgICAg ICAgIChXZWJLaXQ6OldlYlZpZXc6OmRpZENvbW1pdExvYWRGb3JNYWluRnJhbWUpOgorICAgICAg ICAqIFVJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuaDoKKyAgICAgICAgKFdl YktpdDo6V2ViVmlldzo6aXNTdXNwZW5kZWQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9QYWdlQ2xp ZW50Lmg6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VDbGllbnQ6OmRpZENoYW5nZVBhZ2VTY2FsZUZh Y3Rvcik6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlBhZ2VQcm94eTo6cGFnZVNjYWxlRmFjdG9yRGlkQ2hhbmdlKToKKwogMjAxMy0x Mi0yMCAgVGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KIAogICAgICAgICBX ZWJLaXQyIFZpZXcgR2VzdHVyZXM6IEltcGxlbWVudCBzbWFydE1hZ25pZnlXaXRoRXZlbnQ6IGFu ZCBtYWtlIGl0IHdvcmsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9IaXN0b3J5 Q29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvSGlzdG9yeUNvbnRyb2xsZXIu Y3BwCmluZGV4IGViYzExODJjZjhhMGEyYjc0MTZlYTg0YmZjZTliNTJhMTljMjcyMzMuLjA5YTZh NDQ1MGQzMjk4MDA5ZTI5Njk1MThkZGRiNDNjODczZDJhNzggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv bG9hZGVyL0hpc3RvcnlDb250cm9sbGVyLmNwcApAQCAtMTQxLDcgKzE0MSw3IEBAIHZvaWQgSGlz dG9yeUNvbnRyb2xsZXI6OnJlc3RvcmVTY3JvbGxQb3NpdGlvbkFuZFZpZXdTdGF0ZSgpCiAgICAg ICAgICAgICAgICAgc2Nyb2xsaW5nQ29vcmRpbmF0b3ItPmZyYW1lVmlld1Jvb3RMYXllckRpZENo YW5nZSh2aWV3KTsKICAgICAgICAgfQogCi0gICAgICAgIGlmICghdmlldy0+d2FzU2Nyb2xsZWRC eVVzZXIoKSkgeworICAgICAgICBpZiAoc2hvdWxkUmVzdG9yZVBhZ2VTY2FsZUZhY3RvckFuZFNj cm9sbFBvc2l0aW9uKHZpZXcpKSB7CiAgICAgICAgICAgICBpZiAocGFnZSAmJiBtX2ZyYW1lLmlz TWFpbkZyYW1lKCkgJiYgbV9jdXJyZW50SXRlbS0+cGFnZVNjYWxlRmFjdG9yKCkpCiAgICAgICAg ICAgICAgICAgcGFnZS0+c2V0UGFnZVNjYWxlRmFjdG9yKG1fY3VycmVudEl0ZW0tPnBhZ2VTY2Fs ZUZhY3RvcigpLCBtX2N1cnJlbnRJdGVtLT5zY3JvbGxQb2ludCgpKTsKICAgICAgICAgICAgIGVs c2UKQEAgLTE1MSw2ICsxNTEsMTcgQEAgdm9pZCBIaXN0b3J5Q29udHJvbGxlcjo6cmVzdG9yZVNj cm9sbFBvc2l0aW9uQW5kVmlld1N0YXRlKCkKICNlbmRpZgogfQogCitib29sIEhpc3RvcnlDb250 cm9sbGVyOjpzaG91bGRSZXN0b3JlUGFnZVNjYWxlRmFjdG9yQW5kU2Nyb2xsUG9zaXRpb24oRnJh bWVWaWV3KiB2aWV3KQoreworI2lmIFBMQVRGT1JNKEVGTCkgfHwgUExBVEZPUk0oTklYKQorICAg IGRvdWJsZSBwcmV2aW91c1NjYWxlRmFjdG9yID0gbV9wcmV2aW91c0l0ZW0gPyBtX3ByZXZpb3Vz SXRlbS0+cGFnZVNjYWxlRmFjdG9yKCkgOiBtX2N1cnJlbnRJdGVtLT5wYWdlU2NhbGVGYWN0b3Io KTsKKyAgICBJbnRQb2ludCBwcmV2aW91c1Njcm9sbFBvaW50ID0gbV9wcmV2aW91c0l0ZW0gPyBt X3ByZXZpb3VzSXRlbS0+c2Nyb2xsUG9pbnQoKSA6IG1fY3VycmVudEl0ZW0tPnNjcm9sbFBvaW50 KCk7CisgICAgcmV0dXJuIHByZXZpb3VzU2NhbGVGYWN0b3IgIT0gbV9jdXJyZW50SXRlbS0+cGFn ZVNjYWxlRmFjdG9yKCkgfHwgcHJldmlvdXNTY3JvbGxQb2ludCAhPSBtX2N1cnJlbnRJdGVtLT5z Y3JvbGxQb2ludCgpOworI2Vsc2UKKyAgICByZXR1cm4gIXZpZXctPndhc1Njcm9sbGVkQnlVc2Vy KCk7CisjZW5kaWYKK30KKwogdm9pZCBIaXN0b3J5Q29udHJvbGxlcjo6dXBkYXRlQmFja0Zvcndh cmRMaXN0Rm9yRnJhZ21lbnRTY3JvbGwoKQogewogICAgIHVwZGF0ZUJhY2tGb3J3YXJkTGlzdENs aXBwZWRBdFRhcmdldChmYWxzZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIv SGlzdG9yeUNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJv bGxlci5oCmluZGV4IDVkNmMwMWNiNjExYmQ5YmJkNWQ0ZTU3YTQ1NmZiYTk2N2JhY2I3NjYuLjZk ZjI5N2YzOTgxZTYzNjI5ZmVjYWViYjdhNGRjNmIwMmNjNGEwYWEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2xvYWRlci9IaXN0b3J5Q29udHJvbGxlci5oCkBAIC0zOSw2ICszOSw3IEBACiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKIGNsYXNzIEZyYW1lOworY2xhc3MgRnJhbWVWaWV3OwogY2xhc3MgSGlzdG9y eUl0ZW07CiBjbGFzcyBTZXJpYWxpemVkU2NyaXB0VmFsdWU7CiBjbGFzcyBTdHJpbmdXaXRoRGly ZWN0aW9uOwpAQCAtMTA4LDYgKzEwOSw4IEBAIHByaXZhdGU6CiAgICAgdm9pZCB1cGRhdGVCYWNr Rm9yd2FyZExpc3RDbGlwcGVkQXRUYXJnZXQoYm9vbCBkb0NsaXApOwogICAgIHZvaWQgdXBkYXRl Q3VycmVudEl0ZW0oKTsKIAorICAgIGJvb2wgc2hvdWxkUmVzdG9yZVBhZ2VTY2FsZUZhY3RvckFu ZFNjcm9sbFBvc2l0aW9uKEZyYW1lVmlldyopOworCiAgICAgRnJhbWUmIG1fZnJhbWU7CiAKICAg ICBSZWZQdHI8SGlzdG9yeUl0ZW0+IG1fY3VycmVudEl0ZW07CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuY3BwCmluZGV4 IDEwMGZhMzliZTM0Y2EzZWQ4ZWM0MTA0NDQ1NDc4ODNmMDU2MDViZTguLmJjODBiOWY3NWIwMDMy MjBiYTQ1MmU3Zjk5YWMzYjA2ZDMyMTgzMmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuY3BwCkBAIC03Nyw2ICs3 NywyMCBAQCB2b2lkIFdlYlZpZXc6OmluaXRpYWxpemUoKQogICAgIHNldEFjdGl2ZSh0cnVlKTsK IH0KIAordm9pZCBXZWJWaWV3OjpzZXRDb250ZW50U2NhbGVGYWN0b3IoZmxvYXQgc2NhbGVGYWN0 b3IpCit7CisgICAgaWYgKG1fY29udGVudFNjYWxlRmFjdG9yID09IHNjYWxlRmFjdG9yKQorICAg ICAgICByZXR1cm47CisKKyAgICBtX2NvbnRlbnRTY2FsZUZhY3RvciA9IHNjYWxlRmFjdG9yOwor CisgICAgaWYgKGlzU3VzcGVuZGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIHBhZ2UoKS0+ c2NhbGVQYWdlKHNjYWxlRmFjdG9yLCByb3VuZGVkSW50UG9pbnQoY29udGVudFBvc2l0aW9uKCkp KTsKKyAgICB1cGRhdGVWaWV3cG9ydFNpemUoKTsKK30KKwogdm9pZCBXZWJWaWV3OjpzZXRBY3Rp dmUoYm9vbCBhY3RpdmUpCiB7CiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljc1NjZW5lKiBzY2VuZSA9 IGNvb3JkaW5hdGVkR3JhcGhpY3NTY2VuZSgpOwpAQCAtODcsNiArMTAxLDEyIEBAIHZvaWQgV2Vi Vmlldzo6c2V0QWN0aXZlKGJvb2wgYWN0aXZlKQogICAgIG1fcGFnZS0+dmlld1N0YXRlRGlkQ2hh bmdlKFZpZXdTdGF0ZTo6V2luZG93SXNBY3RpdmUpOwogfQogCit2b2lkIFdlYlZpZXc6OmRpZENo YW5nZVBhZ2VTY2FsZUZhY3Rvcihkb3VibGUgc2NhbGVGYWN0b3IpCit7CisgICAgbV9jb250ZW50 U2NhbGVGYWN0b3IgPSBzY2FsZUZhY3RvcjsKKyAgICB1cGRhdGVWaWV3cG9ydFNpemUoKTsKK30K Kwogdm9pZCBXZWJWaWV3OjpzZXRTaXplKGNvbnN0IFdlYkNvcmU6OkludFNpemUmIHNpemUpCiB7 CiAgICAgaWYgKG1fc2l6ZSA9PSBzaXplKQpAQCAtMzc0LDYgKzM5NCw4IEBAIHZvaWQgV2ViVmll dzo6dG9vbFRpcENoYW5nZWQoY29uc3QgU3RyaW5nJiwgY29uc3QgU3RyaW5nJiBuZXdUb29sVGlw KQogCiB2b2lkIFdlYlZpZXc6OmRpZENvbW1pdExvYWRGb3JNYWluRnJhbWUoKQogeworICAgIG1f Y29udGVudFNjYWxlRmFjdG9yID0gMTsKKyAgICBzZXRDb250ZW50UG9zaXRpb24oV2ViQ29yZTo6 RmxvYXRQb2ludCgpKTsKICAgICBtX2NvbnRlbnRzU2l6ZSA9IEludFNpemUoKTsKIH0KIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2Vi Vmlldy5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2Vi Vmlldy5oCmluZGV4IDdjMzQ0ZTlkNThhMjlkOTkwMGQyZmViMWExNzdiMjVkYWUxMTJjNzEuLjRi ZDFlMWQ5MTM4MjFmMTRmY2Y2NWRmOGU4ZDMyZmQ3ZTg4MTc1ZDQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuaAorKysgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmgKQEAg LTcwLDcgKzcwLDcgQEAgcHVibGljOgogICAgIGJvb2wgaXNWaXNpYmxlKCkgY29uc3QgeyByZXR1 cm4gbV92aXNpYmxlOyB9CiAgICAgdm9pZCBzZXRWaXNpYmxlKGJvb2wpOwogCi0gICAgdm9pZCBz ZXRDb250ZW50U2NhbGVGYWN0b3IoZmxvYXQgc2NhbGVGYWN0b3IpIHsgbV9jb250ZW50U2NhbGVG YWN0b3IgPSBzY2FsZUZhY3RvcjsgfQorICAgIHZvaWQgc2V0Q29udGVudFNjYWxlRmFjdG9yKGZs b2F0KTsKICAgICBmbG9hdCBjb250ZW50U2NhbGVGYWN0b3IoKSBjb25zdCB7IHJldHVybiBtX2Nv bnRlbnRTY2FsZUZhY3RvcjsgfQogCiAgICAgdm9pZCBzZXRDb250ZW50UG9zaXRpb24oY29uc3Qg V2ViQ29yZTo6RmxvYXRQb2ludCYgcG9zaXRpb24pIHsgbV9jb250ZW50UG9zaXRpb24gPSBwb3Np dGlvbjsgfQpAQCAtOTYsNiArOTYsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBzZXRTaG93c0FzU291 cmNlKGJvb2wpOwogICAgIGJvb2wgc2hvd3NBc1NvdXJjZSgpIGNvbnN0OwogCisgICAgYm9vbCBp c1N1c3BlbmRlZCgpIHsgcmV0dXJuIHBhZ2UoKS0+YXJlQWN0aXZlRE9NT2JqZWN0c0FuZEFuaW1h dGlvbnNTdXNwZW5kZWQoKTsgfQorCiAjaWYgRU5BQkxFKEZVTExTQ1JFRU5fQVBJKQogICAgIGJv b2wgcmVxdWVzdEV4aXRGdWxsU2NyZWVuKCk7CiAjZW5kaWYKQEAgLTE1Myw2ICsxNTUsOCBAQCBw cm90ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tbWl0TG9hZEZvck1haW5GcmFtZSgp IE9WRVJSSURFOwogCisgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVBhZ2VTY2FsZUZhY3Rvcihk b3VibGUpIE9WRVJSSURFOworCiAgICAgdmlydHVhbCB2b2lkIHBhZ2VEaWRSZXF1ZXN0U2Nyb2xs KGNvbnN0IFdlYkNvcmU6OkludFBvaW50JikgT1ZFUlJJREU7CiAgICAgdmlydHVhbCB2b2lkIGRp ZFJlbmRlckZyYW1lKGNvbnN0IFdlYkNvcmU6OkludFNpemUmIGNvbnRlbnRzU2l6ZSwgY29uc3Qg V2ViQ29yZTo6SW50UmVjdCYgY292ZXJlZFJlY3QpIE9WRVJSSURFOwogICAgIHZpcnR1YWwgdm9p ZCBwYWdlVHJhbnNpdGlvblZpZXdwb3J0UmVhZHkoKSBPVkVSUklERTsKQEAgLTIwNSw3ICsyMDks NiBAQCBwcm90ZWN0ZWQ6CiAgICAgdmlydHVhbCB2b2lkIGJlZ2FuRXhpdEZ1bGxTY3JlZW4oY29u c3QgV2ViQ29yZTo6SW50UmVjdCYsIGNvbnN0IFdlYkNvcmU6OkludFJlY3QmKSBPVkVSUklERSB7 IH0KICNlbmRpZgogCi1wcm90ZWN0ZWQ6CiAgICAgV2ViVmlld0NsaWVudCBtX2NsaWVudDsKICAg ICBSZWZQdHI8V2ViUGFnZVByb3h5PiBtX3BhZ2U7CiAgICAgRGVmYXVsdFVuZG9Db250cm9sbGVy IG1fdW5kb0NvbnRyb2xsZXI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv UGFnZUNsaWVudC5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAppbmRl eCBmNWVhMGVjOTBjZDJlYmQzMDEwNDUzZTZkYzI2ZjBjNWY5NDI4MGJjLi42YjhkYmUzMzQ3NWI4 MjVkODFhZDVlZDgxNzEzMWE2ZWNhM2E2MDNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvUGFnZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9QYWdl Q2xpZW50LmgKQEAgLTEyMiw2ICsxMjIsOCBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQg dG9vbFRpcENoYW5nZWQoY29uc3QgU3RyaW5nJiwgY29uc3QgU3RyaW5nJikgPSAwOwogCisgICAg dmlydHVhbCB2b2lkIGRpZENoYW5nZVBhZ2VTY2FsZUZhY3Rvcihkb3VibGUpIHsgfQorCiAgICAg dmlydHVhbCBib29sIGRlY2lkZVBvbGljeUZvckdlb2xvY2F0aW9uUGVybWlzc2lvblJlcXVlc3Qo V2ViRnJhbWVQcm94eSYsIFdlYlNlY3VyaXR5T3JpZ2luJiwgR2VvbG9jYXRpb25QZXJtaXNzaW9u UmVxdWVzdFByb3h5JikKICAgICB7CiAgICAgICAgIHJldHVybiBmYWxzZTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKaW5kZXggZTkxMzM0ZWY1YzMyYzc0MTliYzE5 Mjc1ZGE1M2UyODI5MTdjNzE2YS4uNTcxM2I2ODg0MGQzOGQ5N2Q3ODFmM2JjZDM5NGUzZGQ3YWMy YmFmZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5j cHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKQEAgLTE4 MTgsNiArMTgxOCw3IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpzZXRHYXBCZXR3ZWVuUGFnZXMoZG91 YmxlIGdhcCkKIHZvaWQgV2ViUGFnZVByb3h5OjpwYWdlU2NhbGVGYWN0b3JEaWRDaGFuZ2UoZG91 YmxlIHNjYWxlRmFjdG9yKQogewogICAgIG1fcGFnZVNjYWxlRmFjdG9yID0gc2NhbGVGYWN0b3I7 CisgICAgbV9wYWdlQ2xpZW50LmRpZENoYW5nZVBhZ2VTY2FsZUZhY3RvcihtX3BhZ2VTY2FsZUZh Y3Rvcik7CiB9CiAKIHZvaWQgV2ViUGFnZVByb3h5OjpwYWdlWm9vbUZhY3RvckRpZENoYW5nZShk b3VibGUgem9vbUZhY3RvcikKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0No YW5nZUxvZwppbmRleCA5NWU3MWEyYzAyNzdiNTU4MTk4NDM5YmRhZTdlN2RlODg1MmFmMGY5Li4w YTg3NDQxZGYzOGQ4MzdiZDcyY2Q3ZWY4ZGQ0MWRhMmE3MGVjMTBmIDEwMDY0NAotLS0gYS9Ub29s cy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTMt MTItMjAgIFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSAgPHRoaWFnby5sYWNlcmRhQG9wZW5ib3Nz YS5vcmc+CisKKyAgICAgICAgc2NhbGViYWNraGlzdG9yeQorCisgICAgICAgIFtDb29yZGluYXRl ZEdyYXBoaWNzXVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIGlzIG5vdCBi ZWluZyByZXN0b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2FyZCBsb2FkCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjYwMjIKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXaGVuIHVzZXIgaXMgbmF2aWdh dGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdlIHRoYXQgaGFzIGJlZW4gc2Nyb2xsZWQgYW5kL29y IHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUgc2hvd24KKyAgICAgICAgd2l0aCBpdHMgbGFzdCBz Y3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZhY3Rvci4KKyAgICAgICAgSG93ZXZlciwgd2hlbiBm aXhlZCBsYXlvdXQgd2FzIGVuYWJsZWQgd2l0aCBDb29yZGluYXRlZEdyYXBoaWNzIGFuZCBUSUxF RF9CQUNLSU5HX1NUT1JFLAorICAgICAgICBGcmFtZVZpZXc6OnNldFZpZXdXYXNTY3JvbGxlZEJ5 VXNlciB3YXMgYmVpbmcgY2FsbGVkIGJldHdlZW4gRnJhbWVWaWV3OjpyZXNldCBhbmQKKyAgICAg ICAgSGlzdG9yeUNvbnRyb2xsZXI6OnJlc3RvcmVTY3JvbGxQb3NpdGlvbkFuZFZpZXdTdGF0ZSwg Y2F1c2luZyB0aGUgdGhlIFdlYkNvcmU6OlBhZ2UgdG8gZG8gbm90IGdldCBpdHMgc2NhbGUKKyAg ICAgICAgZmFjdG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gdG8gYmUgcmVzdG9yZWQuCisgICAgICAg IE5vd2FkYXlzIHRoZSBvbmx5IHBvcnRzIHRoYXQgdXNlIENvb3JkaW5hdGVkR3JhcGhpY3MgYW5k IFRJTEVEX0JBQ0tJTkdfU1RPUkUgYXJlIEVGTCBhbmQgTml4LgorCisgICAgICAgIEFsc28sIHdo ZW4gYSB1c2VyIHdhcyB1c2luZyB0aGUgV0tWaWV3IEFQSSB0byBzZXQgdGhlIHNjYWxlIGZhY3Rv ciAoV0tWaWV3U2V0Q29udGVudFNjYWxlRmFjdG9yKSB0aGlzIHNjYWxlIHdhcworICAgICAgICBu b3QgYmVpbmcgZm9yd2FyZGVkIHRvIFdlYkNvcmUuCisgICAgICAgIFRoZW4sIHdoZW4gZ29pbmcg YmFjay9mb3J3YXJkIHRvIGEgcGFnZSBIaXN0b3J5Q29udHJvbGxlciB3YXMgbm90IGtub3dpbmcg YWJvdXQgaXRzIHJlYWwgc2NhbGUgZmFjdG9yLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9Q bGF0Zm9ybUVmbC5jbWFrZToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIv Q29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tGb3J3YXJk LmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpkaWRGaW5pc2hMb2FkRm9yRnJh bWUpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6ZGlkQ2hhbmdlQ29udGVudHNQb3NpdGlvbik6 CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDEuaHRtbDogQWRk ZWQuCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3Jh cGhpY3MvYmFja2ZvcndhcmQyLmh0bWw6IEFkZGVkLgorCiAyMDEzLTEyLTIwICBNeWxlcyBDLiBN YXhmaWVsZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CiAKICAgICAgICAgTXlsZXMgQy4gTWF4Zmll bGQgaXMgYSBjb21taXR0ZXIgbm93CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Bs YXRmb3JtRWZsLmNtYWtlIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQpp bmRleCA3ZmZjNmNmOTAwNjdmMjExZDAzOWM0ZDhjZGM0MjE0NDk4OWRhM2RhLi5kMjNhNTAyMDU5 YmJhNGY0YTY5MGVmZGIyZjc2M2JlMjA0ZDQ3NDVlIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2Vi S2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZv cm1FZmwuY21ha2UKQEAgLTEwNCw2ICsxMDQsNyBAQCBzZXQodGVzdF93ZWJraXQyX2FwaV9CSU5B UklFUwogICAgIFdpbGxMb2FkCiAgICAgV2lsbFNlbmRTdWJtaXRFdmVudAogICAgIENvb3JkaW5h dGVkR3JhcGhpY3MvV0tWaWV3SXNBY3RpdmVTZXRJc0FjdGl2ZQorICAgIENvb3JkaW5hdGVkR3Jh cGhpY3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9yd2FyZAogICAgIENvb3JkaW5h dGVkR3JhcGhpY3MvV0tWaWV3VXNlclZpZXdwb3J0VG9Db250ZW50cwogICAgIGVmbC9XS1ZpZXdD bGllbnRXZWJQcm9jZXNzQ2FsbGJhY2tzCiApCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFu ZFNjcm9sbEJhY2tGb3J3YXJkLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0Zvcndh cmQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjc5NWQ0YTYwNWFjODBjMjA4MjlmN2UwYTQzY2QyZWFkZTY2MjI3 ZTAKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIv Q29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tGb3J3YXJk LmNwcApAQCAtMCwwICsxLDE4NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMi0yMDEzIE5v a2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKS4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBg YEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQgSE9MREVSUyBP UgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp bmNsdWRlICJjb25maWcuaCIKKworI2luY2x1ZGUgIlBsYXRmb3JtVXRpbGl0aWVzLmgiCisjaW5j bHVkZSA8V2ViS2l0Mi9XS0NvbnRleHQuaD4KKyNpbmNsdWRlIDxXZWJLaXQyL1dLR2VvbWV0cnku aD4KKyNpbmNsdWRlIDxXZWJLaXQyL1dLUmV0YWluUHRyLmg+CisjaW5jbHVkZSAiVGVzdC5oIgor CituYW1lc3BhY2UgVGVzdFdlYktpdEFQSSB7CisKK3N0YXRpYyBib29sIGZpbmlzaGVkTG9hZCA9 IGZhbHNlOworc3RhdGljIGJvb2wgc2Nyb2xsID0gZmFsc2U7CisKK3N0YXRpYyB2b2lkIGRpZEZp bmlzaExvYWRGb3JGcmFtZShXS1BhZ2VSZWYsIFdLRnJhbWVSZWYsIFdLVHlwZVJlZiwgY29uc3Qg dm9pZCopCit7CisgICAgZmluaXNoZWRMb2FkID0gdHJ1ZTsKK30KKworc3RhdGljIHZvaWQgZGlk Q2hhbmdlQ29udGVudHNQb3NpdGlvbihXS1ZpZXdSZWYsIFdLUG9pbnQgcCwgY29uc3Qgdm9pZCop Cit7CisgICAgc2Nyb2xsID0gdHJ1ZTsKK30KKworVEVTVChXZWJLaXQyLCBCYWNrRm9yd2FyZCkK K3sKKyAgICBjb25zdCBXS1NpemUgc2l6ZSA9IFdLU2l6ZU1ha2UoODAwLCA2MDApOworCisgICAg V0tSZXRhaW5QdHI8V0tDb250ZXh0UmVmPiBjb250ZXh0ID0gYWRvcHRXSyhXS0NvbnRleHRDcmVh dGUoKSk7CisgICAgV0tSZXRhaW5QdHI8V0tWaWV3UmVmPiB2aWV3KEFkb3B0V0ssIFdLVmlld0Ny ZWF0ZShjb250ZXh0LmdldCgpLCAwKSk7CisKKyAgICBXS1ZpZXdJbml0aWFsaXplKHZpZXcuZ2V0 KCkpOworICAgIFdLVmlld1NldFNpemUodmlldy5nZXQoKSwgc2l6ZSk7CisKKyAgICBXS1BhZ2VS ZWYgcGFnZVJlZiA9IFdLVmlld0dldFBhZ2Uodmlldy5nZXQoKSk7CisgICAgV0tQYWdlU2V0VXNl Rml4ZWRMYXlvdXQocGFnZVJlZiwgdHJ1ZSk7CisgICAgQVNTRVJUX1RSVUUocGFnZVJlZik7CisK KyAgICBXS1BhZ2VMb2FkZXJDbGllbnRWMyBsb2FkZXJDbGllbnQ7CisgICAgbWVtc2V0KCZsb2Fk ZXJDbGllbnQsIDAsIHNpemVvZihsb2FkZXJDbGllbnQpKTsKKyAgICBsb2FkZXJDbGllbnQuYmFz ZS52ZXJzaW9uID0gMzsKKyAgICBsb2FkZXJDbGllbnQuZGlkRmluaXNoTG9hZEZvckZyYW1lID0g ZGlkRmluaXNoTG9hZEZvckZyYW1lOworICAgIFdLUGFnZVNldFBhZ2VMb2FkZXJDbGllbnQocGFn ZVJlZiwgJmxvYWRlckNsaWVudC5iYXNlKTsKKworICAgIFdLVmlld0NsaWVudFYwIHZpZXdDbGll bnQ7CisgICAgbWVtc2V0KCZ2aWV3Q2xpZW50LCAwLCBzaXplb2Yodmlld0NsaWVudCkpOworICAg IHZpZXdDbGllbnQuYmFzZS52ZXJzaW9uID0gMDsKKyAgICB2aWV3Q2xpZW50LmRpZENoYW5nZUNv bnRlbnRzUG9zaXRpb24gPSBkaWRDaGFuZ2VDb250ZW50c1Bvc2l0aW9uOworICAgIFdLVmlld1Nl dFZpZXdDbGllbnQodmlldy5nZXQoKSwgJnZpZXdDbGllbnQuYmFzZSk7CisKKyAgICBXS1JldGFp blB0cjxXS1VSTFJlZj4gdXJsID0gYWRvcHRXSyhVdGlsOjpjcmVhdGVVUkxGb3JSZXNvdXJjZSgi Q29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDEiLCAiaHRtbCIpKTsKKyAgICBXS1BhZ2VM b2FkVVJMKHBhZ2VSZWYsIHVybC5nZXQoKSk7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQp OworCisgICAgZmxvYXQgbmV3U2NhbGUgPSAyLjA7CisgICAgV0tQb2ludCBwb2ludCA9IFdLUG9p bnRNYWtlKDEwLCAzNTApOworICAgIFdLVmlld1NldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgp LCBwb2ludCk7CisgICAgV0tWaWV3U2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCksIG5l d1NjYWxlKTsKKyAgICBmbG9hdCBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2 aWV3LmdldCgpKTsKKyAgICBXS1BvaW50IGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRl bnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEobmV3U2NhbGUsIHNjYWxlKTsK KyAgICBFWFBFQ1RfRVEocG9pbnQueCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9F UShwb2ludC55LCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxz ZTsKKyAgICB1cmwgPSBhZG9wdFdLKFV0aWw6OmNyZWF0ZVVSTEZvclJlc291cmNlKCJDb29yZGlu YXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMiIsICJodG1sIikpOworICAgIFdLUGFnZUxvYWRVUkwo cGFnZVJlZiwgdXJsLmdldCgpKTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisKKyAg ICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBj b250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7Cisg ICAgRVhQRUNUX0VRKDEsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEoMCwgY29udGVudFBvc2l0aW9u LngpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1BhZ2VH b0JhY2socGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2FkID0g ZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigmc2Ny b2xsKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0 KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3 LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEobmV3U2NhbGUsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEo cG9pbnQueCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUShwb2ludC55LCBjb250 ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1BhZ2VHb0ZvcndhcmQocGFnZVJlZik7CisgICAgc2Ny b2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZm aW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tW aWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlv biA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEo MSwgc2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQ RUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFnZUdvQmFjayhwYWdlUmVm KTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBV dGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAg c2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29u dGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAg IEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9FUShwb2ludC54LCBjb250 ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNvbnRlbnRQb3NpdGlvbi55 KTsKKworICAgIFdLUGFnZUdvRm9yd2FyZChwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsK KyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7 CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50 U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0 Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBzY2FsZSk7Cisg ICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoMCwgY29u dGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQYWdlR29CYWNrKHBhZ2VSZWYpOworICAgIHNjcm9s bCA9IGZhbHNlOworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmlu aXNoZWRMb2FkKTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmll d0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24g PSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKG5l d1NjYWxlLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlvbi54 KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueSwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQ YWdlR29Gb3J3YXJkKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVk TG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpy dW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2 aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRp b24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKDEsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEo MCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24u eSk7CisKKyAgICBXS1BhZ2VHb0JhY2socGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7Cisg ICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOwor ICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNj YWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENv bnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEobmV3U2NhbGUsIHNjYWxl KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVD VF9FUShwb2ludC55LCBjb250ZW50UG9zaXRpb24ueSk7Cit9CisKK30gLy8gVGVzdFdlYktpdEFQ SQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5h dGVkR3JhcGhpY3MvYmFja2ZvcndhcmQxLmh0bWwgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDEuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5hYTlhYzhlYzI4ZWU0ZWEwMzIzNTdmYzY0ZTQ5ZmYwMmIxMmFiZDg4Ci0tLSAvZGV2L251bGwK KysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhp Y3MvYmFja2ZvcndhcmQxLmh0bWwKQEAgLTAsMCArMSwzIEBACis8Ym9keSBzdHlsZT0id2lkdGg6 MTAwJTsgaGVpZ2h0OjEwMCUiPgorICAgIDxkaXYgc3R5bGU9InBvc2l0aW9uOiBhYnNvbHV0ZTsg dG9wOiAwOyBsZWZ0OiAwOyB3aWR0aDogOTAwcHg7IGhlaWdodDogMTIwMHB4OyI+PC9kaXY+Cis8 L2JvZHk+CmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29v cmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDIuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMi5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjM4MDZiOWQzMmVjNGRlMzk4NjFmMmY3NzJhMjE5MjE4ZWVhOWM2NzUKLS0tIC9kZXYv bnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRH cmFwaGljcy9iYWNrZm9yd2FyZDIuaHRtbApAQCAtMCwwICsxIEBACis8Ym9keSBzdHlsZT0id2lk dGg6MTAwJTsgaGVpZ2h0OjEwMCUiLz4K 226091 2014-03-07 00:20:32 -0800 2014-03-15 09:08:18 -0700 Work-in-progress bug-126022-20140307172031.patch text/plain 17411 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTY1MjUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOTkxOTNkNDZjZjZiZmI1 ZjcyNjYxMDk0MTZhNThhY2RjNDcwYWY5Zi4uZGNiYjRlNGIwNmVlNmIzMDE0Zjc3M2RkZTc5OWYz NzI0Mzk0MzhlYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMyIEBACisyMDE0LTAzLTA2ICBUaGlh Z28gZGUgQmFycm9zIExhY2VyZGEgIDx0aGlhZ28ubGFjZXJkYUBvcGVuYm9zc2Eub3JnPgorCisg ICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNzXVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xs IHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2Fy ZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MjYwMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBP cmlnaW5hbCBhdXRob3IgOiBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEsIGFuZCBmaW5pc2hlZCBi eSBHeXV5b3VuZyBLaW0uCisKKyAgICAgICAgV2hlbiB1c2VyIGlzIG5hdmlnYXRpbmcgYmFjay9m b3J3YXJkIHRvIGEgcGFnZSB0aGF0IGhhcyBiZWVuIHNjcm9sbGVkIGFuZC9vciBzY2FsZWQsIHRo YXQgcGFnZSBtdXN0IGJlIHNob3duCisgICAgICAgIHdpdGggaXRzIGxhc3Qgc2Nyb2xsIHBvc2l0 aW9uIGFuZCBzY2FsZSBmYWN0b3IuCisgICAgICAgIEhvd2V2ZXIsIHdoZW4gZml4ZWQgbGF5b3V0 IHdhcyBlbmFibGVkIHdpdGggQ29vcmRpbmF0ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19T VE9SRSwKKyAgICAgICAgRnJhbWVWaWV3OjpzZXRWaWV3V2FzU2Nyb2xsZWRCeVVzZXIgd2FzIGJl aW5nIGNhbGxlZCBiZXR3ZWVuIEZyYW1lVmlldzo6cmVzZXQgYW5kCisgICAgICAgIEhpc3RvcnlD b250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUsIGNhdXNpbmcgdGhl IHRoZSBXZWJDb3JlOjpQYWdlIHRvIGRvIG5vdCBnZXQgaXRzIHNjYWxlCisgICAgICAgIGZhY3Rv ciBhbmQgc2Nyb2xsIHBvc2l0aW9uIHRvIGJlIHJlc3RvcmVkLgorICAgICAgICBOb3dhZGF5cyB0 aGUgb25seSBwb3J0cyB0aGF0IHVzZSBDb29yZGluYXRlZEdyYXBoaWNzIGFuZCBUSUxFRF9CQUNL SU5HX1NUT1JFIGFyZSBFRkwgYW5kIE5peC4KKworICAgICAgICBBbHNvLCB3aGVuIGEgdXNlciB3 YXMgdXNpbmcgdGhlIFdLVmlldyBBUEkgdG8gc2V0IHRoZSBzY2FsZSBmYWN0b3IgKFdLVmlld1Nl dENvbnRlbnRTY2FsZUZhY3RvcikgdGhpcyBzY2FsZSB3YXMKKyAgICAgICAgbm90IGJlaW5nIGZv cndhcmRlZCB0byBXZWJDb3JlLgorICAgICAgICBUaGVuLCB3aGVuIGdvaW5nIGJhY2svZm9yd2Fy ZCB0byBhIHBhZ2UgSGlzdG9yeUNvbnRyb2xsZXIgd2FzIG5vdCBrbm93aW5nIGFib3V0IGl0cyBy ZWFsIHNjYWxlIGZhY3Rvci4KKworICAgICAgICBBIFdlYktpdEFQSSB0ZXN0IGlzIGJlaW5nIGFk ZGVkIHRvIHZhbGlkYXRlIHRoaXMgYmVoYXZpb3VyLgorCisgICAgICAgICogbG9hZGVyL0hpc3Rv cnlDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okhpc3RvcnlDb250cm9sbGVyOjpy ZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUpOgorICAgICAgICAoV2ViQ29yZTo6SGlz dG9yeUNvbnRyb2xsZXI6OnNob3VsZFJlc3RvcmVQYWdlU2NhbGVGYWN0b3JBbmRTY3JvbGxQb3Np dGlvbik6IE1ldGhvZCBhZGRlZCB0byBkZWNpZGUgd2hldGhlcgorICAgICAgICBIaXN0b3J5Q29u dHJvbGxlciBzaG91bGQgdHJ5IHRvIHJlc3RvcmUgdGhlIHBhZ2Ugc2NhbGUgZmFjdG9yIGFuZCBz Y3JvbGwgcG9zaXRpb24sIGJhc2VkIG9uIHRoZSBwbGF0Zm9ybS4KKyAgICAgICAgKiBsb2FkZXIv SGlzdG9yeUNvbnRyb2xsZXIuaDoKKwogMjAxNC0wMy0wNiAgQW5kcmVhcyBLbGluZyAgPGFrbGlu Z0BhcHBsZS5jb20+CiAKICAgICAgICAgV2ViQ29yZVJlc291cmNlSGFuZGxlQXNPcGVyYXRpb25R dWV1ZURlbGVnYXRlIG92ZXItcmV0YWlucyBOU1VSTFJlcXVlc3QuCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYzQ2 YjBjZDc5MDJjNjk4MjgxMGRmMDc5ZTI2MDUzOWM5MGU3NTc0NS4uMDEzMjg2Zjg5NDViZWY1OTcy NDMxYzc2YmViMjRkNWJmNTBhNzJlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE0 LTAzLTA2ICBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEgIDx0aGlhZ28ubGFjZXJkYUBvcGVuYm9z c2Eub3JnPgorCisgICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNzXVtXSzJdIFNjYWxlIGZhY3Rv ciBhbmQgc2Nyb2xsIHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0b3JlZCBwcm9wZXJseSBpbiBh IGJhY2svZm9yd2FyZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xMjYwMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBPcmlnaW5hbCBhdXRob3IgOiBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEsIGFu ZCBmaW5pc2hlZCBieSBHeXV5b3VuZyBLaW0uCisKKyAgICAgICAgV2hlbiB1c2VyIGlzIG5hdmln YXRpbmcgYmFjay9mb3J3YXJkIHRvIGEgcGFnZSB0aGF0IGhhcyBiZWVuIHNjcm9sbGVkIGFuZC9v ciBzY2FsZWQsIHRoYXQgcGFnZSBtdXN0IGJlIHNob3duCisgICAgICAgIHdpdGggaXRzIGxhc3Qg c2Nyb2xsIHBvc2l0aW9uIGFuZCBzY2FsZSBmYWN0b3IuCisgICAgICAgIEhvd2V2ZXIsIHdoZW4g Zml4ZWQgbGF5b3V0IHdhcyBlbmFibGVkIHdpdGggQ29vcmRpbmF0ZWRHcmFwaGljcyBhbmQgVElM RURfQkFDS0lOR19TVE9SRSwKKyAgICAgICAgRnJhbWVWaWV3OjpzZXRWaWV3V2FzU2Nyb2xsZWRC eVVzZXIgd2FzIGJlaW5nIGNhbGxlZCBiZXR3ZWVuIEZyYW1lVmlldzo6cmVzZXQgYW5kCisgICAg ICAgIEhpc3RvcnlDb250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUs IGNhdXNpbmcgdGhlIHRoZSBXZWJDb3JlOjpQYWdlIHRvIGRvIG5vdCBnZXQgaXRzIHNjYWxlCisg ICAgICAgIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIHRvIGJlIHJlc3RvcmVkLgorICAgICAg ICBOb3dhZGF5cyB0aGUgb25seSBwb3J0cyB0aGF0IHVzZSBDb29yZGluYXRlZEdyYXBoaWNzIGFu ZCBUSUxFRF9CQUNLSU5HX1NUT1JFIGFyZSBFRkwgYW5kIE5peC4KKworICAgICAgICBBbHNvLCB3 aGVuIGEgdXNlciB3YXMgdXNpbmcgdGhlIFdLVmlldyBBUEkgdG8gc2V0IHRoZSBzY2FsZSBmYWN0 b3IgKFdLVmlld1NldENvbnRlbnRTY2FsZUZhY3RvcikgdGhpcyBzY2FsZSB3YXMKKyAgICAgICAg bm90IGJlaW5nIGZvcndhcmRlZCB0byBXZWJDb3JlLgorICAgICAgICBUaGVuLCB3aGVuIGdvaW5n IGJhY2svZm9yd2FyZCB0byBhIHBhZ2UgSGlzdG9yeUNvbnRyb2xsZXIgd2FzIG5vdCBrbm93aW5n IGFib3V0IGl0cyByZWFsIHNjYWxlIGZhY3Rvci4KKworICAgICAgICBBIFdlYktpdEFQSSB0ZXN0 IGlzIGJlaW5nIGFkZGVkIHRvIHZhbGlkYXRlIHRoaXMgYmVoYXZpb3VyLgorCisgICAgICAgICog VUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5jcHA6CisgICAgICAgIChXZWJL aXQ6OldlYlZpZXc6OnNldENvbnRlbnRTY2FsZUZhY3Rvcik6CisgICAgICAgIChXZWJLaXQ6Oldl YlZpZXc6OmRpZENoYW5nZVBhZ2VTY2FsZUZhY3Rvcik6CisgICAgICAgIChXZWJLaXQ6OldlYlZp ZXc6OmRpZENvbW1pdExvYWRGb3JNYWluRnJhbWUpOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db29y ZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlldzo6aXNT dXNwZW5kZWQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9QYWdlQ2xpZW50Lmg6CisgICAgICAgIChX ZWJLaXQ6OlBhZ2VDbGllbnQ6OmRpZENoYW5nZVBhZ2VTY2FsZUZhY3Rvcik6CisgICAgICAgICog VUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94 eTo6cGFnZVNjYWxlRmFjdG9yRGlkQ2hhbmdlKToKKwogMjAxNC0wMy0wNiAgQWxleGV5IFByb3Nr dXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAgICBbTWFjXSBBbGxvdyBjb20uYXBwbGUu R1NTQ3JlZCBpbiBXZWJLaXQgc2FuZGJveCBwcm9maWxlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5jcHAgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcAppbmRleCA2 NzFkN2MwODg5ZTc4YWZhNjI1MGQyNmJiMzFiZTk5ZWRhYzJhNDEyLi45YjIxZDI3MzZjNDkzOGI1 MDZhOGE1NTAzNWEyNmE4ZDNlNjQ3ODk0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcApAQCAtODUsNiArODUs MTcgQEAgdm9pZCBXZWJWaWV3OjpzZXRDb250ZW50U2NhbGVGYWN0b3IoZmxvYXQgc2NhbGVGYWN0 b3IpCiAgICAgdXBkYXRlVmlld3BvcnRTaXplKCk7CiB9CiAKK3ZvaWQgV2ViVmlldzo6c2V0Q29u dGVudFNjYWxlRmFjdG9yKGZsb2F0IHNjYWxlRmFjdG9yKQoreworICAgIGlmIChtX2NvbnRlbnRT Y2FsZUZhY3RvciA9PSBzY2FsZUZhY3RvcikKKyAgICAgICAgcmV0dXJuOworCisgICAgbV9jb250 ZW50U2NhbGVGYWN0b3IgPSBzY2FsZUZhY3RvcjsKKworICAgIHBhZ2UoKS0+c2NhbGVQYWdlKHNj YWxlRmFjdG9yLCByb3VuZGVkSW50UG9pbnQoY29udGVudFBvc2l0aW9uKCkpKTsKKyAgICB1cGRh dGVWaWV3cG9ydFNpemUoKTsKK30KKwogdm9pZCBXZWJWaWV3OjpzZXRBY3RpdmUoYm9vbCBhY3Rp dmUpCiB7CiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljc1NjZW5lKiBzY2VuZSA9IGNvb3JkaW5hdGVk R3JhcGhpY3NTY2VuZSgpOwpAQCAtOTUsNiArMTA2LDExIEBAIHZvaWQgV2ViVmlldzo6c2V0QWN0 aXZlKGJvb2wgYWN0aXZlKQogICAgIG1fcGFnZS0+dmlld1N0YXRlRGlkQ2hhbmdlKFZpZXdTdGF0 ZTo6V2luZG93SXNBY3RpdmUpOwogfQogCit2b2lkIFdlYlZpZXc6OmRpZENoYW5nZVBhZ2VTY2Fs ZUZhY3Rvcihkb3VibGUgc2NhbGVGYWN0b3IpCit7CisgICAgdXBkYXRlVmlld3BvcnRTaXplKCk7 Cit9CisKIHZvaWQgV2ViVmlldzo6c2V0U2l6ZShjb25zdCBXZWJDb3JlOjpJbnRTaXplJiBzaXpl KQogewogICAgIGlmIChtX3NpemUgPT0gc2l6ZSkKQEAgLTM2NCw2ICszODAsOCBAQCB2b2lkIFdl YlZpZXc6OnRvb2xUaXBDaGFuZ2VkKGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYgbmV3VG9v bFRpcCkKIAogdm9pZCBXZWJWaWV3OjpkaWRDb21taXRMb2FkRm9yTWFpbkZyYW1lKCkKIHsKKyAg ICBtX2NvbnRlbnRTY2FsZUZhY3RvciA9IDE7CisgICAgc2V0Q29udGVudFBvc2l0aW9uKFdlYkNv cmU6OkZsb2F0UG9pbnQoKSk7CiAgICAgbV9jb250ZW50c1NpemUgPSBJbnRTaXplKCk7CiB9CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmggYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGFnZUNsaWVudC5oCmluZGV4IGI5NGQ5MGFhZmFkNTI0NDFj NGY0ODBmOWQ4NzVjNzY3OWY2MWE5YWQuLjExNzg5ODI1NWM0ZjA2ZDEzMmNkODBmYTZmY2JhODgy MWNjYmI1N2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9QYWdlQ2xpZW50 LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaApAQCAtMTI2LDYg KzEyNiw4IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9pZCB0b29sVGlwQ2hhbmdlZChjb25z dCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmKSA9IDA7CiAKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hh bmdlUGFnZVNjYWxlRmFjdG9yKGRvdWJsZSkgeyB9CisKICAgICB2aXJ0dWFsIGJvb2wgZGVjaWRl UG9saWN5Rm9yR2VvbG9jYXRpb25QZXJtaXNzaW9uUmVxdWVzdChXZWJGcmFtZVByb3h5JiwgV2Vi U2VjdXJpdHlPcmlnaW4mLCBHZW9sb2NhdGlvblBlcm1pc3Npb25SZXF1ZXN0UHJveHkmKQogICAg IHsKICAgICAgICAgcmV0dXJuIGZhbHNlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFn ZVByb3h5LmNwcAppbmRleCA0YTdlYWQ5NDNiNzg0YTkzMDQwZDUyNDA3ZmY2MDdhODM5MDM0ZWJm Li42ZGI4OTEzOGJlNDNlNDIwMWRhZGM1ZDEyYjFlZWU2MmVkZGU1NGFlIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcApAQCAtMTg1OCw2ICsxODU4LDcgQEAgdm9p ZCBXZWJQYWdlUHJveHk6OnNldEdhcEJldHdlZW5QYWdlcyhkb3VibGUgZ2FwKQogdm9pZCBXZWJQ YWdlUHJveHk6OnBhZ2VTY2FsZUZhY3RvckRpZENoYW5nZShkb3VibGUgc2NhbGVGYWN0b3IpCiB7 CiAgICAgbV9wYWdlU2NhbGVGYWN0b3IgPSBzY2FsZUZhY3RvcjsKKyAgICBtX3BhZ2VDbGllbnQu ZGlkQ2hhbmdlUGFnZVNjYWxlRmFjdG9yKG1fcGFnZVNjYWxlRmFjdG9yKTsKIH0KIAogdm9pZCBX ZWJQYWdlUHJveHk6OnBhZ2Vab29tRmFjdG9yRGlkQ2hhbmdlKGRvdWJsZSB6b29tRmFjdG9yKQpk aWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDA4NjQ2 YTRmZTZkMGM1MzRiZDZmMzFhYjhjZWM5ZDYxNWYyMDY3YmEuLmNlNmFjOGYxMmFkNTBlYzY5N2I3 MWY1NmY3MWVmNmNiOGZiMmI4NzkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9U b29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAxNC0wMy0wNiAgVGhpYWdvIGRlIEJh cnJvcyBMYWNlcmRhICA8dGhpYWdvLmxhY2VyZGFAb3BlbmJvc3NhLm9yZz4KKworICAgICAgICBb Q29vcmRpbmF0ZWRHcmFwaGljc11bV0syXSBTY2FsZSBmYWN0b3IgYW5kIHNjcm9sbCBwb3NpdGlv biBpcyBub3QgYmVpbmcgcmVzdG9yZWQgcHJvcGVybHkgaW4gYSBiYWNrL2ZvcndhcmQgbG9hZAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTI2MDIyCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgT3JpZ2luYWwg YXV0aG9yIDogVGhpYWdvIGRlIEJhcnJvcyBMYWNlcmRhLCBhbmQgZmluaXNoZWQgYnkgR3l1eW91 bmcgS2ltLgorCisgICAgICAgIFdoZW4gdXNlciBpcyBuYXZpZ2F0aW5nIGJhY2svZm9yd2FyZCB0 byBhIHBhZ2UgdGhhdCBoYXMgYmVlbiBzY3JvbGxlZCBhbmQvb3Igc2NhbGVkLCB0aGF0IHBhZ2Ug bXVzdCBiZSBzaG93bgorICAgICAgICB3aXRoIGl0cyBsYXN0IHNjcm9sbCBwb3NpdGlvbiBhbmQg c2NhbGUgZmFjdG9yLgorICAgICAgICBIb3dldmVyLCB3aGVuIGZpeGVkIGxheW91dCB3YXMgZW5h YmxlZCB3aXRoIENvb3JkaW5hdGVkR3JhcGhpY3MgYW5kIFRJTEVEX0JBQ0tJTkdfU1RPUkUsCisg ICAgICAgIEZyYW1lVmlldzo6c2V0Vmlld1dhc1Njcm9sbGVkQnlVc2VyIHdhcyBiZWluZyBjYWxs ZWQgYmV0d2VlbiBGcmFtZVZpZXc6OnJlc2V0IGFuZAorICAgICAgICBIaXN0b3J5Q29udHJvbGxl cjo6cmVzdG9yZVNjcm9sbFBvc2l0aW9uQW5kVmlld1N0YXRlLCBjYXVzaW5nIHRoZSB0aGUgV2Vi Q29yZTo6UGFnZSB0byBkbyBub3QgZ2V0IGl0cyBzY2FsZQorICAgICAgICBmYWN0b3IgYW5kIHNj cm9sbCBwb3NpdGlvbiB0byBiZSByZXN0b3JlZC4KKyAgICAgICAgTm93YWRheXMgdGhlIG9ubHkg cG9ydHMgdGhhdCB1c2UgQ29vcmRpbmF0ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19TVE9S RSBhcmUgRUZMIGFuZCBOaXguCisKKyAgICAgICAgQWxzbywgd2hlbiBhIHVzZXIgd2FzIHVzaW5n IHRoZSBXS1ZpZXcgQVBJIHRvIHNldCB0aGUgc2NhbGUgZmFjdG9yIChXS1ZpZXdTZXRDb250ZW50 U2NhbGVGYWN0b3IpIHRoaXMgc2NhbGUgd2FzCisgICAgICAgIG5vdCBiZWluZyBmb3J3YXJkZWQg dG8gV2ViQ29yZS4KKyAgICAgICAgVGhlbiwgd2hlbiBnb2luZyBiYWNrL2ZvcndhcmQgdG8gYSBw YWdlIEhpc3RvcnlDb250cm9sbGVyIHdhcyBub3Qga25vd2luZyBhYm91dCBpdHMgcmVhbCBzY2Fs ZSBmYWN0b3IuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlOgor ICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNz L1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwOiBBZGRlZC4KKyAgICAg ICAgKFRlc3RXZWJLaXRBUEk6OmRpZEZpbmlzaExvYWRGb3JGcmFtZSk6CisgICAgICAgIChUZXN0 V2ViS2l0QVBJOjpkaWRDaGFuZ2VDb250ZW50c1Bvc2l0aW9uKToKKyAgICAgICAgKFRlc3RXZWJL aXRBUEk6OlRFU1QpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29y ZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBUZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDIu aHRtbDogQWRkZWQuCisKIDIwMTQtMDMtMDYgIEZpbGlwIFBpemxvICA8ZnBpemxvQGFwcGxlLmNv bT4KIAogICAgICAgICBJZiB0aGUgRlRMIGlzIGJ1aWxkLXRpbWUgZW5hYmxlZCB0aGVuIGl0IHNo b3VsZCBiZSBydW4tdGltZSBlbmFibGVkLgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21h a2UKaW5kZXggODE1M2Y3ZjU2OWUxNjJkYzFkZjlmNzEwNjcxYWEzOWNlNzA4YmEwOS4uZjI4M2Zm OTIwN2JjYWU5OWViNjAzNzU4YjlkYTVhYjdjNWY0ZDVhMyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVz dFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Bs YXRmb3JtRWZsLmNtYWtlCkBAIC05OCw2ICs5OCw3IEBAIHNldCh0ZXN0X3dlYmtpdDJfYXBpX0JJ TkFSSUVTCiAgICAgV2lsbExvYWQKICAgICBXaWxsU2VuZFN1Ym1pdEV2ZW50CiAgICAgQ29vcmRp bmF0ZWRHcmFwaGljcy9XS1ZpZXdJc0FjdGl2ZVNldElzQWN0aXZlCisgICAgQ29vcmRpbmF0ZWRH cmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tGb3J3YXJkCiAgICAgQ29vcmRp bmF0ZWRHcmFwaGljcy9XS1ZpZXdVc2VyVmlld3BvcnRUb0NvbnRlbnRzCiAgICAgZWZsL1dLVmll d0NsaWVudFdlYlByb2Nlc3NDYWxsYmFja3MKICkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29t QW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9y d2FyZC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uNzk1ZDRhNjA1YWM4MGMyMDgyOWY3ZTBhNDNjZDJlYWRlNjYy MjdlMAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0Zvcndh cmQuY3BwCkBAIC0wLDAgKzEsMTg1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyLTIwMTMg Tm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJT IGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVCBIT0xERVJT IE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z IFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I2luY2x1ZGUgImNvbmZpZy5oIgorCisjaW5jbHVkZSAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNp bmNsdWRlIDxXZWJLaXQyL1dLQ29udGV4dC5oPgorI2luY2x1ZGUgPFdlYktpdDIvV0tHZW9tZXRy eS5oPgorI2luY2x1ZGUgPFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KKyNpbmNsdWRlICJUZXN0Lmgi CisKK25hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKKworc3RhdGljIGJvb2wgZmluaXNoZWRMb2Fk ID0gZmFsc2U7CitzdGF0aWMgYm9vbCBzY3JvbGwgPSBmYWxzZTsKKworc3RhdGljIHZvaWQgZGlk RmluaXNoTG9hZEZvckZyYW1lKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBlUmVmLCBjb25z dCB2b2lkKikKK3sKKyAgICBmaW5pc2hlZExvYWQgPSB0cnVlOworfQorCitzdGF0aWMgdm9pZCBk aWRDaGFuZ2VDb250ZW50c1Bvc2l0aW9uKFdLVmlld1JlZiwgV0tQb2ludCBwLCBjb25zdCB2b2lk KikKK3sKKyAgICBzY3JvbGwgPSB0cnVlOworfQorCitURVNUKFdlYktpdDIsIEJhY2tGb3J3YXJk KQoreworICAgIGNvbnN0IFdLU2l6ZSBzaXplID0gV0tTaXplTWFrZSg4MDAsIDYwMCk7CisKKyAg ICBXS1JldGFpblB0cjxXS0NvbnRleHRSZWY+IGNvbnRleHQgPSBhZG9wdFdLKFdLQ29udGV4dENy ZWF0ZSgpKTsKKyAgICBXS1JldGFpblB0cjxXS1ZpZXdSZWY+IHZpZXcoQWRvcHRXSywgV0tWaWV3 Q3JlYXRlKGNvbnRleHQuZ2V0KCksIDApKTsKKworICAgIFdLVmlld0luaXRpYWxpemUodmlldy5n ZXQoKSk7CisgICAgV0tWaWV3U2V0U2l6ZSh2aWV3LmdldCgpLCBzaXplKTsKKworICAgIFdLUGFn ZVJlZiBwYWdlUmVmID0gV0tWaWV3R2V0UGFnZSh2aWV3LmdldCgpKTsKKyAgICBXS1BhZ2VTZXRV c2VGaXhlZExheW91dChwYWdlUmVmLCB0cnVlKTsKKyAgICBBU1NFUlRfVFJVRShwYWdlUmVmKTsK KworICAgIFdLUGFnZUxvYWRlckNsaWVudFYzIGxvYWRlckNsaWVudDsKKyAgICBtZW1zZXQoJmxv YWRlckNsaWVudCwgMCwgc2l6ZW9mKGxvYWRlckNsaWVudCkpOworICAgIGxvYWRlckNsaWVudC5i YXNlLnZlcnNpb24gPSAzOworICAgIGxvYWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJhbWUg PSBkaWRGaW5pc2hMb2FkRm9yRnJhbWU7CisgICAgV0tQYWdlU2V0UGFnZUxvYWRlckNsaWVudChw YWdlUmVmLCAmbG9hZGVyQ2xpZW50LmJhc2UpOworCisgICAgV0tWaWV3Q2xpZW50VjAgdmlld0Ns aWVudDsKKyAgICBtZW1zZXQoJnZpZXdDbGllbnQsIDAsIHNpemVvZih2aWV3Q2xpZW50KSk7Cisg ICAgdmlld0NsaWVudC5iYXNlLnZlcnNpb24gPSAwOworICAgIHZpZXdDbGllbnQuZGlkQ2hhbmdl Q29udGVudHNQb3NpdGlvbiA9IGRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb247CisgICAgV0tWaWV3 U2V0Vmlld0NsaWVudCh2aWV3LmdldCgpLCAmdmlld0NsaWVudC5iYXNlKTsKKworICAgIFdLUmV0 YWluUHRyPFdLVVJMUmVmPiB1cmwgPSBhZG9wdFdLKFV0aWw6OmNyZWF0ZVVSTEZvclJlc291cmNl KCJDb29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMSIsICJodG1sIikpOworICAgIFdLUGFn ZUxvYWRVUkwocGFnZVJlZiwgdXJsLmdldCgpKTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9h ZCk7CisKKyAgICBmbG9hdCBuZXdTY2FsZSA9IDIuMDsKKyAgICBXS1BvaW50IHBvaW50ID0gV0tQ b2ludE1ha2UoMTAsIDM1MCk7CisgICAgV0tWaWV3U2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0 KCksIHBvaW50KTsKKyAgICBXS1ZpZXdTZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSwg bmV3U2NhbGUpOworICAgIGZsb2F0IHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9y KHZpZXcuZ2V0KCkpOworICAgIFdLUG9pbnQgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29u dGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUp OworICAgIEVYUEVDVF9FUShwb2ludC54LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNU X0VRKHBvaW50LnksIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIGZpbmlzaGVkTG9hZCA9IGZh bHNlOworICAgIHVybCA9IGFkb3B0V0soVXRpbDo6Y3JlYXRlVVJMRm9yUmVzb3VyY2UoIkNvb3Jk aW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyIiwgImh0bWwiKSk7CisgICAgV0tQYWdlTG9hZFVS TChwYWdlUmVmLCB1cmwuZ2V0KCkpOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKwor ICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAg IGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsK KyAgICBFWFBFQ1RfRVEoMSwgc2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRp b24ueCk7CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFn ZUdvQmFjayhwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQg PSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZz Y3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5n ZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZp ZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9F UShwb2ludC54LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNv bnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFnZUdvRm9yd2FyZChwYWdlUmVmKTsKKyAgICBz Y3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4o JmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBX S1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0 aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9F USgxLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBF WFBFQ1RfRVEoMCwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQYWdlR29CYWNrKHBhZ2VS ZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAg IFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAg ICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBj b250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7Cisg ICAgRVhQRUNUX0VRKG5ld1NjYWxlLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNv bnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueSwgY29udGVudFBvc2l0aW9u LnkpOworCisgICAgV0tQYWdlR29Gb3J3YXJkKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNl OworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2Fk KTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRl bnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdH ZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKDEsIHNjYWxlKTsK KyAgICBFWFBFQ1RfRVEoMCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBj b250ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1BhZ2VHb0JhY2socGFnZVJlZik7CisgICAgc2Ny b2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZm aW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tW aWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlv biA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEo bmV3U2NhbGUsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueCwgY29udGVudFBvc2l0aW9u LngpOworICAgIEVYUEVDVF9FUShwb2ludC55LCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAgICBX S1BhZ2VHb0ZvcndhcmQocGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNo ZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6 OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9y KHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3Np dGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEoMSwgc2NhbGUpOworICAgIEVYUEVDVF9F USgwLCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlv bi55KTsKKworICAgIFdLUGFnZUdvQmFjayhwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsK KyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7 CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50 U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0 Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2Nh bGUpOworICAgIEVYUEVDVF9FUShwb2ludC54LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQ RUNUX0VRKHBvaW50LnksIGNvbnRlbnRQb3NpdGlvbi55KTsKK30KKworfSAvLyBUZXN0V2ViS2l0 QVBJCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRp bmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDEuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmFhOWFjOGVjMjhlZTRlYTAzMjM1N2ZjNjRlNDlmZjAyYjEyYWJkODgKLS0tIC9kZXYvbnVs bAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFw aGljcy9iYWNrZm9yd2FyZDEuaHRtbApAQCAtMCwwICsxLDMgQEAKKzxib2R5IHN0eWxlPSJ3aWR0 aDoxMDAlOyBoZWlnaHQ6MTAwJSI+CisgICAgPGRpdiBzdHlsZT0icG9zaXRpb246IGFic29sdXRl OyB0b3A6IDA7IGxlZnQ6IDA7IHdpZHRoOiA5MDBweDsgaGVpZ2h0OiAxMjAwcHg7Ij48L2Rpdj4K KzwvYm9keT4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9D b29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMi5odG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uMzgwNmI5ZDMyZWM0ZGUzOTg2MWYyZjc3MmEyMTkyMThlZWE5YzY3NQotLS0gL2Rl di9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRl ZEdyYXBoaWNzL2JhY2tmb3J3YXJkMi5odG1sCkBAIC0wLDAgKzEgQEAKKzxib2R5IHN0eWxlPSJ3 aWR0aDoxMDAlOyBoZWlnaHQ6MTAwJSIvPgo= 226822 2014-03-15 09:08:18 -0700 2014-03-15 10:39:51 -0700 Patch scroll.html text/plain 3677 gyuyoung.kim PGh0bWw+Cjxib2R5PgoKPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxi cj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0i Li9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUu aHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9u IERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4K PGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9B bWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRt bCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERl PC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEg aHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6 b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+ QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9h Pjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJl Zj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24u ZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1h em9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxi cj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0i Li9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUu aHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9u IERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4K PGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9B bWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRt bCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERl PC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEg aHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6 b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+ QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9h Pjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJl Zj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24u ZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1h em9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxi cj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0i Li9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUu aHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9u IERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4K PGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9B bWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRt bCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERl PC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEg aHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6 b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+ QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9h Pjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJl Zj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24u ZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1h em9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxi cj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0i Li9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUu aHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9u IERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4K PGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9B bWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRt bCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERl PC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEg aHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6 b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+ QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9h Pjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJl Zj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24u ZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1h em9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxi cj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0i Li9BbWF6b24uZGUuaHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUu aHRtbCI+QW1hem9uIERlPC9hPjxicj4KPGEgaHJlZj0iLi9BbWF6b24uZGUuaHRtbCI+QW1hem9u IERlPC9hPjxicj4KCjwvYm9keT4KPC9odG1sPgo= 226827 2014-03-15 18:15:18 -0700 2014-03-19 08:14:12 -0700 Patch bug-126022-20140316101455.patch text/plain 15745 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTY1NjgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggYTY4OTczNDM1ZTVhN2Uw OTBlYzhkMzM5NDIyOTg1YzIxMzRmMTMyNS4uZWMxNzBjYzI3M2UxZmVhNmE3ZTMwYmQ3MThhNzI3 NjM4ZTcwNmNlOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDE0LTAzLTE1ICBUaGlh Z28gZGUgQmFycm9zIExhY2VyZGEgIDx0aGlhZ28ubGFjZXJkYUBvcGVuYm9zc2Eub3JnPgorCisg ICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNzXVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xs IHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2Fy ZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MjYwMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBP cmlnaW5hbCBhdXRob3IgOiBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEsIGFuZCBmaW5pc2hlZCBi eSBHeXV5b3VuZyBLaW0uCisKKyAgICAgICAgV2hlbiB1c2VyIGlzIG5hdmlnYXRpbmcgYmFjay9m b3J3YXJkIHRvIGEgcGFnZSB0aGF0IGhhcyBiZWVuIHNjcm9sbGVkIGFuZC9vciBzY2FsZWQsIHRo YXQgcGFnZSBtdXN0IGJlIHNob3duCisgICAgICAgIHdpdGggaXRzIGxhc3Qgc2Nyb2xsIHBvc2l0 aW9uIGFuZCBzY2FsZSBmYWN0b3IuCisgICAgICAgIEhvd2V2ZXIsIHdoZW4gZml4ZWQgbGF5b3V0 IHdhcyBlbmFibGVkIHdpdGggQ29vcmRpbmF0ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19T VE9SRSwKKyAgICAgICAgRnJhbWVWaWV3OjpzZXRWaWV3V2FzU2Nyb2xsZWRCeVVzZXIgd2FzIGJl aW5nIGNhbGxlZCBiZXR3ZWVuIEZyYW1lVmlldzo6cmVzZXQgYW5kCisgICAgICAgIEhpc3RvcnlD b250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUsIGNhdXNpbmcgdGhl IHRoZSBXZWJDb3JlOjpQYWdlIHRvIGRvIG5vdCBnZXQgaXRzIHNjYWxlCisgICAgICAgIGZhY3Rv ciBhbmQgc2Nyb2xsIHBvc2l0aW9uIHRvIGJlIHJlc3RvcmVkLgorICAgICAgICBOb3dhZGF5cyB0 aGUgb25seSBwb3J0IHRoYXQgdXNlIENvb3JkaW5hdGVkR3JhcGhpY3MgYW5kIFRJTEVEX0JBQ0tJ TkdfU1RPUkUgaXMgRUZMIHBvcnQoVW5mb3J0dW5hdGVseSwgbml4CisgICAgICAgIHBvcnQgd2Fz IGRyb3BwZWQuKS4KKworICAgICAgICBBbHNvLCB3aGVuIGEgdXNlciB3YXMgdXNpbmcgdGhlIFdL VmlldyBBUEkgdG8gc2V0IHRoZSBzY2FsZSBmYWN0b3IgKFdLVmlld1NldENvbnRlbnRTY2FsZUZh Y3RvcikgdGhpcyBzY2FsZSB3YXMKKyAgICAgICAgbm90IGJlaW5nIGZvcndhcmRlZCB0byBXZWJD b3JlLgorICAgICAgICBUaGVuLCB3aGVuIGdvaW5nIGJhY2svZm9yd2FyZCB0byBhIHBhZ2UgSGlz dG9yeUNvbnRyb2xsZXIgd2FzIG5vdCBrbm93aW5nIGFib3V0IGl0cyByZWFsIHNjYWxlIGZhY3Rv ci4KKworICAgICAgICBBIFdlYktpdEFQSSB0ZXN0IGlzIGJlaW5nIGFkZGVkIHRvIHZhbGlkYXRl IHRoaXMgYmVoYXZpb3VyLgorCisgICAgICAgICogVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhp Y3MvV2ViVmlldy5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OmRpZENoYW5nZVBhZ2VT Y2FsZUZhY3Rvcik6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OmRpZENvbW1pdExvYWRGb3JN YWluRnJhbWUpOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZp ZXcuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvUGFnZUNsaWVudC5oOgorICAgICAgICAoV2ViS2l0 OjpQYWdlQ2xpZW50OjpkaWRDaGFuZ2VQYWdlU2NhbGVGYWN0b3IpOgorICAgICAgICAqIFVJUHJv Y2Vzcy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnBh Z2VTY2FsZUZhY3RvckRpZENoYW5nZSk6CisKIDIwMTQtMDMtMTQgIEFsZXhleSBQcm9za3VyeWFr b3YgIDxhcEBhcHBsZS5jb20+CiAKICAgICAgICAgW01hY10gU3luYyBleHRlbmRlZCBhdHRyaWJ1 dGUgcmVsYXRlZCBydWxlcyB3aXRoIEFwcFNhbmRib3ggcHJvZmlsZQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5jcHAgYi9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcApp bmRleCBhYjI3ZjQ5OGU3MGY0NjcyZGQ4ODYyNGUzMGU5YWIwMmE2YjI1YWE3Li5mNTA5YTRkYTk4 MGE1ZmNmMjlhMjYxMzI4N2I3ZWZhYjI4ODlkODQyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcApAQCAtOTUs NiArOTUsMTMgQEAgdm9pZCBXZWJWaWV3OjpzZXRBY3RpdmUoYm9vbCBhY3RpdmUpCiAgICAgbV9w YWdlLT52aWV3U3RhdGVEaWRDaGFuZ2UoVmlld1N0YXRlOjpXaW5kb3dJc0FjdGl2ZSk7CiB9CiAK K3ZvaWQgV2ViVmlldzo6ZGlkQ2hhbmdlUGFnZVNjYWxlRmFjdG9yKGRvdWJsZSBzY2FsZUZhY3Rv cikKK3sKKyAgICAvLyBGSVhNRTogSG93IHRvIGhhbmRsZSBzY2FsZUZhY3RvciA/CisgICAgVU5V U0VEX1BBUkFNKHNjYWxlRmFjdG9yKTsKKyAgICB1cGRhdGVWaWV3cG9ydFNpemUoKTsKK30KKwog dm9pZCBXZWJWaWV3OjpzZXRTaXplKGNvbnN0IFdlYkNvcmU6OkludFNpemUmIHNpemUpCiB7CiAg ICAgaWYgKG1fc2l6ZSA9PSBzaXplKQpAQCAtMzY0LDYgKzM3MSw3IEBAIHZvaWQgV2ViVmlldzo6 dG9vbFRpcENoYW5nZWQoY29uc3QgU3RyaW5nJiwgY29uc3QgU3RyaW5nJiBuZXdUb29sVGlwKQog CiB2b2lkIFdlYlZpZXc6OmRpZENvbW1pdExvYWRGb3JNYWluRnJhbWUoY29uc3QgU3RyaW5nJiwg Ym9vbCkKIHsKKyAgICBzZXRDb250ZW50UG9zaXRpb24oV2ViQ29yZTo6RmxvYXRQb2ludCgpKTsK ICAgICBtX2NvbnRlbnRzU2l6ZSA9IEludFNpemUoKTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5oIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5oCmluZGV4IGM0 NDE5NzQxZDQ3ODRhNGVmMDVhMzFiYWJhYzAzM2Q1NDkyNWE1MjIuLjRkZTY1MWU3ZjY2MmRjOGEz OGY2OTk4OWNiM2M3YmJkMmJjZDJjNzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmgKQEAgLTE0OSw2ICsxNDksOCBA QCBwcm90ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tbWl0TG9hZEZvck1haW5GcmFt ZShjb25zdCBTdHJpbmcmIG1pbWVUeXBlLCBib29sIHVzZUN1c3RvbUNvbnRlbnRQcm92aWRlcikg b3ZlcnJpZGU7CiAKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlUGFnZVNjYWxlRmFjdG9yKGRv dWJsZSkgb3ZlcnJpZGU7CisKICAgICB2aXJ0dWFsIHZvaWQgcGFnZURpZFJlcXVlc3RTY3JvbGwo Y29uc3QgV2ViQ29yZTo6SW50UG9pbnQmKSBvdmVycmlkZTsKICAgICB2aXJ0dWFsIHZvaWQgZGlk UmVuZGVyRnJhbWUoY29uc3QgV2ViQ29yZTo6SW50U2l6ZSYgY29udGVudHNTaXplLCBjb25zdCBX ZWJDb3JlOjpJbnRSZWN0JiBjb3ZlcmVkUmVjdCkgb3ZlcnJpZGU7CiAgICAgdmlydHVhbCB2b2lk IHBhZ2VUcmFuc2l0aW9uVmlld3BvcnRSZWFkeSgpIG92ZXJyaWRlOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9QYWdlQ2xpZW50LmgKaW5kZXggOWZmYmMzMTQ4MTFlNjY3OWRhMTJhYzNiZmJhM2M3ZGYy YWU0NTI3YS4uNWRiMDA0MzUwZTI1N2MyYzIyY2Y2NjY3YzViN2Q5ZWRhN2VhNDFlOCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAorKysgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvUGFnZUNsaWVudC5oCkBAIC0xMjYsNiArMTI2LDggQEAgcHVibGlj OgogCiAgICAgdmlydHVhbCB2b2lkIHRvb2xUaXBDaGFuZ2VkKGNvbnN0IFN0cmluZyYsIGNvbnN0 IFN0cmluZyYpID0gMDsKIAorICAgIHZpcnR1YWwgdm9pZCBkaWRDaGFuZ2VQYWdlU2NhbGVGYWN0 b3IoZG91YmxlKSB7IH0KKwogICAgIHZpcnR1YWwgYm9vbCBkZWNpZGVQb2xpY3lGb3JHZW9sb2Nh dGlvblBlcm1pc3Npb25SZXF1ZXN0KFdlYkZyYW1lUHJveHkmLCBXZWJTZWN1cml0eU9yaWdpbiYs IEdlb2xvY2F0aW9uUGVybWlzc2lvblJlcXVlc3RQcm94eSYpCiAgICAgewogICAgICAgICByZXR1 cm4gZmFsc2U7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCmluZGV4 IGE3NmJhZDAxMzg5NzVkZWFhYmE2MjJlYTkxOTU1MTYwMTk3NWY2M2EuLjZmZWM5MzkwNTFmZDQw MDA1ZjcwZmVkYTgyNzZmODQ0MDM1YTE5N2QgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9X ZWJQYWdlUHJveHkuY3BwCkBAIC0xODU5LDYgKzE4NTksNyBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6 c2V0R2FwQmV0d2VlblBhZ2VzKGRvdWJsZSBnYXApCiB2b2lkIFdlYlBhZ2VQcm94eTo6cGFnZVNj YWxlRmFjdG9yRGlkQ2hhbmdlKGRvdWJsZSBzY2FsZUZhY3RvcikKIHsKICAgICBtX3BhZ2VTY2Fs ZUZhY3RvciA9IHNjYWxlRmFjdG9yOworICAgIG1fcGFnZUNsaWVudC5kaWRDaGFuZ2VQYWdlU2Nh bGVGYWN0b3IobV9wYWdlU2NhbGVGYWN0b3IpOwogfQogCiB2b2lkIFdlYlBhZ2VQcm94eTo6cGFn ZVpvb21GYWN0b3JEaWRDaGFuZ2UoZG91YmxlIHpvb21GYWN0b3IpCmRpZmYgLS1naXQgYS9Ub29s cy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNzVjYjYzOTVjMjI1OTcwY2M4YTU1 Y2NiNTY5YmVhYTM3OTFiYmNhOS4uYTc4NzI2YWEyYzI4YzQ5ODhhMGE3ODkwNjFkOWNjMmY5ZTc0 YmQ4ZSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpA QCAtMSwzICsxLDM1IEBACisyMDE0LTAzLTE1ICBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEgIDx0 aGlhZ28ubGFjZXJkYUBvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIFtDb29yZGluYXRlZEdyYXBo aWNzXVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIGlzIG5vdCBiZWluZyBy ZXN0b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2FyZCBsb2FkCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjYwMjIKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBPcmlnaW5hbCBhdXRob3IgOiBUaGlhZ28g ZGUgQmFycm9zIExhY2VyZGEsIGFuZCBmaW5pc2hlZCBieSBHeXV5b3VuZyBLaW0uCisKKyAgICAg ICAgV2hlbiB1c2VyIGlzIG5hdmlnYXRpbmcgYmFjay9mb3J3YXJkIHRvIGEgcGFnZSB0aGF0IGhh cyBiZWVuIHNjcm9sbGVkIGFuZC9vciBzY2FsZWQsIHRoYXQgcGFnZSBtdXN0IGJlIHNob3duCisg ICAgICAgIHdpdGggaXRzIGxhc3Qgc2Nyb2xsIHBvc2l0aW9uIGFuZCBzY2FsZSBmYWN0b3IuCisg ICAgICAgIEhvd2V2ZXIsIHdoZW4gZml4ZWQgbGF5b3V0IHdhcyBlbmFibGVkIHdpdGggQ29vcmRp bmF0ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19TVE9SRSwKKyAgICAgICAgRnJhbWVWaWV3 OjpzZXRWaWV3V2FzU2Nyb2xsZWRCeVVzZXIgd2FzIGJlaW5nIGNhbGxlZCBiZXR3ZWVuIEZyYW1l Vmlldzo6cmVzZXQgYW5kCisgICAgICAgIEhpc3RvcnlDb250cm9sbGVyOjpyZXN0b3JlU2Nyb2xs UG9zaXRpb25BbmRWaWV3U3RhdGUsIGNhdXNpbmcgdGhlIHRoZSBXZWJDb3JlOjpQYWdlIHRvIGRv IG5vdCBnZXQgaXRzIHNjYWxlCisgICAgICAgIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIHRv IGJlIHJlc3RvcmVkLgorICAgICAgICBOb3dhZGF5cyB0aGUgb25seSBwb3J0IHRoYXQgdXNlIENv b3JkaW5hdGVkR3JhcGhpY3MgYW5kIFRJTEVEX0JBQ0tJTkdfU1RPUkUgaXMgRUZMIHBvcnQoVW5m b3J0dW5hdGVseSwgbml4CisgICAgICAgIHBvcnQgd2FzIGRyb3BwZWQuKS4KKworICAgICAgICBB bHNvLCB3aGVuIGEgdXNlciB3YXMgdXNpbmcgdGhlIFdLVmlldyBBUEkgdG8gc2V0IHRoZSBzY2Fs ZSBmYWN0b3IgKFdLVmlld1NldENvbnRlbnRTY2FsZUZhY3RvcikgdGhpcyBzY2FsZSB3YXMKKyAg ICAgICAgbm90IGJlaW5nIGZvcndhcmRlZCB0byBXZWJDb3JlLgorICAgICAgICBUaGVuLCB3aGVu IGdvaW5nIGJhY2svZm9yd2FyZCB0byBhIHBhZ2UgSGlzdG9yeUNvbnRyb2xsZXIgd2FzIG5vdCBr bm93aW5nIGFib3V0IGl0cyByZWFsIHNjYWxlIGZhY3Rvci4KKworICAgICAgICBBIFdlYktpdEFQ SSB0ZXN0IGlzIGJlaW5nIGFkZGVkIHRvIHZhbGlkYXRlIHRoaXMgYmVoYXZpb3VyLgorCisgICAg ICAgICogVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZToKKyAgICAgICAgKiBUZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9v bUFuZFNjcm9sbEJhY2tGb3J3YXJkLmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJ OjpkaWRGaW5pc2hMb2FkRm9yRnJhbWUpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6ZGlkQ2hh bmdlQ29udGVudHNQb3NpdGlvbik6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKyAg ICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9i YWNrZm9yd2FyZDEuaHRtbDogQWRkZWQuCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyLmh0bWw6IEFkZGVkLgorCiAy MDE0LTAzLTE0ICBNYWNpZWogU3RhY2hvd2lhayAgPG1qc0BhcHBsZS5jb20+CiAKICAgICAgICAg UmVwbGFjZSAiQXBwbGUgQ29tcHV0ZXIsIEluYy4iIHdpdGggIkFwcGxlIEluYy4iIGluIGNvcHly aWdodCBoZWFkZXJzCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZs LmNtYWtlIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQppbmRleCA4MTUz ZjdmNTY5ZTE2MmRjMWRmOWY3MTA2NzFhYTM5Y2U3MDhiYTA5Li5mMjgzZmY5MjA3YmNhZTk5ZWI2 MDM3NThiOWRhNWFiN2M1ZjRkNWEzIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Bs YXRmb3JtRWZsLmNtYWtlCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21h a2UKQEAgLTk4LDYgKzk4LDcgQEAgc2V0KHRlc3Rfd2Via2l0Ml9hcGlfQklOQVJJRVMKICAgICBX aWxsTG9hZAogICAgIFdpbGxTZW5kU3VibWl0RXZlbnQKICAgICBDb29yZGluYXRlZEdyYXBoaWNz L1dLVmlld0lzQWN0aXZlU2V0SXNBY3RpdmUKKyAgICBDb29yZGluYXRlZEdyYXBoaWNzL1dLVmll d1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQKICAgICBDb29yZGluYXRlZEdyYXBoaWNz L1dLVmlld1VzZXJWaWV3cG9ydFRvQ29udGVudHMKICAgICBlZmwvV0tWaWV3Q2xpZW50V2ViUHJv Y2Vzc0NhbGxiYWNrcwogKQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNr Rm9yd2FyZC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0 ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tGb3J3YXJkLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi43OTVkNGE2MDVhYzgwYzIwODI5ZjdlMGE0M2NkMmVhZGU2NjIyN2UwCi0tLSAvZGV2 L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVk R3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHAKQEAgLTAs MCArMSwxODUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTItMjAxMyBOb2tpYSBDb3Jwb3Jh dGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgYGBBUyBJUycnIEFO RCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuICBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUIEhPTERFUlMgT1IKKyAqIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisKKyNpbmNsdWRlICJQbGF0Zm9ybVV0aWxpdGllcy5oIgorI2luY2x1ZGUgPFdlYktp dDIvV0tDb250ZXh0Lmg+CisjaW5jbHVkZSA8V2ViS2l0Mi9XS0dlb21ldHJ5Lmg+CisjaW5jbHVk ZSA8V2ViS2l0Mi9XS1JldGFpblB0ci5oPgorI2luY2x1ZGUgIlRlc3QuaCIKKworbmFtZXNwYWNl IFRlc3RXZWJLaXRBUEkgeworCitzdGF0aWMgYm9vbCBmaW5pc2hlZExvYWQgPSBmYWxzZTsKK3N0 YXRpYyBib29sIHNjcm9sbCA9IGZhbHNlOworCitzdGF0aWMgdm9pZCBkaWRGaW5pc2hMb2FkRm9y RnJhbWUoV0tQYWdlUmVmLCBXS0ZyYW1lUmVmLCBXS1R5cGVSZWYsIGNvbnN0IHZvaWQqKQorewor ICAgIGZpbmlzaGVkTG9hZCA9IHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIGRpZENoYW5nZUNvbnRl bnRzUG9zaXRpb24oV0tWaWV3UmVmLCBXS1BvaW50IHAsIGNvbnN0IHZvaWQqKQoreworICAgIHNj cm9sbCA9IHRydWU7Cit9CisKK1RFU1QoV2ViS2l0MiwgQmFja0ZvcndhcmQpCit7CisgICAgY29u c3QgV0tTaXplIHNpemUgPSBXS1NpemVNYWtlKDgwMCwgNjAwKTsKKworICAgIFdLUmV0YWluUHRy PFdLQ29udGV4dFJlZj4gY29udGV4dCA9IGFkb3B0V0soV0tDb250ZXh0Q3JlYXRlKCkpOworICAg IFdLUmV0YWluUHRyPFdLVmlld1JlZj4gdmlldyhBZG9wdFdLLCBXS1ZpZXdDcmVhdGUoY29udGV4 dC5nZXQoKSwgMCkpOworCisgICAgV0tWaWV3SW5pdGlhbGl6ZSh2aWV3LmdldCgpKTsKKyAgICBX S1ZpZXdTZXRTaXplKHZpZXcuZ2V0KCksIHNpemUpOworCisgICAgV0tQYWdlUmVmIHBhZ2VSZWYg PSBXS1ZpZXdHZXRQYWdlKHZpZXcuZ2V0KCkpOworICAgIFdLUGFnZVNldFVzZUZpeGVkTGF5b3V0 KHBhZ2VSZWYsIHRydWUpOworICAgIEFTU0VSVF9UUlVFKHBhZ2VSZWYpOworCisgICAgV0tQYWdl TG9hZGVyQ2xpZW50VjMgbG9hZGVyQ2xpZW50OworICAgIG1lbXNldCgmbG9hZGVyQ2xpZW50LCAw LCBzaXplb2YobG9hZGVyQ2xpZW50KSk7CisgICAgbG9hZGVyQ2xpZW50LmJhc2UudmVyc2lvbiA9 IDM7CisgICAgbG9hZGVyQ2xpZW50LmRpZEZpbmlzaExvYWRGb3JGcmFtZSA9IGRpZEZpbmlzaExv YWRGb3JGcmFtZTsKKyAgICBXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KHBhZ2VSZWYsICZsb2Fk ZXJDbGllbnQuYmFzZSk7CisKKyAgICBXS1ZpZXdDbGllbnRWMCB2aWV3Q2xpZW50OworICAgIG1l bXNldCgmdmlld0NsaWVudCwgMCwgc2l6ZW9mKHZpZXdDbGllbnQpKTsKKyAgICB2aWV3Q2xpZW50 LmJhc2UudmVyc2lvbiA9IDA7CisgICAgdmlld0NsaWVudC5kaWRDaGFuZ2VDb250ZW50c1Bvc2l0 aW9uID0gZGlkQ2hhbmdlQ29udGVudHNQb3NpdGlvbjsKKyAgICBXS1ZpZXdTZXRWaWV3Q2xpZW50 KHZpZXcuZ2V0KCksICZ2aWV3Q2xpZW50LmJhc2UpOworCisgICAgV0tSZXRhaW5QdHI8V0tVUkxS ZWY+IHVybCA9IGFkb3B0V0soVXRpbDo6Y3JlYXRlVVJMRm9yUmVzb3VyY2UoIkNvb3JkaW5hdGVk R3JhcGhpY3MvYmFja2ZvcndhcmQxIiwgImh0bWwiKSk7CisgICAgV0tQYWdlTG9hZFVSTChwYWdl UmVmLCB1cmwuZ2V0KCkpOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKworICAgIGZs b2F0IG5ld1NjYWxlID0gMi4wOworICAgIFdLUG9pbnQgcG9pbnQgPSBXS1BvaW50TWFrZSgxMCwg MzUwKTsKKyAgICBXS1ZpZXdTZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSwgcG9pbnQpOwor ICAgIFdLVmlld1NldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpLCBuZXdTY2FsZSk7Cisg ICAgZmxvYXQgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7 CisgICAgV0tQb2ludCBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24o dmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKG5ld1NjYWxlLCBzY2FsZSk7CisgICAgRVhQRUNU X0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueSwg Y29udGVudFBvc2l0aW9uLnkpOworCisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgdXJs ID0gYWRvcHRXSyhVdGlsOjpjcmVhdGVVUkxGb3JSZXNvdXJjZSgiQ29vcmRpbmF0ZWRHcmFwaGlj cy9iYWNrZm9yd2FyZDIiLCAiaHRtbCIpKTsKKyAgICBXS1BhZ2VMb2FkVVJMKHBhZ2VSZWYsIHVy bC5nZXQoKSk7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworCisgICAgc2NhbGUgPSBX S1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0 aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9F USgxLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBF WFBFQ1RfRVEoMCwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQYWdlR29CYWNrKHBhZ2VS ZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAg IFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAg ICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBj b250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7Cisg ICAgRVhQRUNUX0VRKG5ld1NjYWxlLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNv bnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueSwgY29udGVudFBvc2l0aW9u LnkpOworCisgICAgV0tQYWdlR29Gb3J3YXJkKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNl OworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2Fk KTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRl bnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdH ZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKDEsIHNjYWxlKTsK KyAgICBFWFBFQ1RfRVEoMCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBj b250ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1BhZ2VHb0JhY2socGFnZVJlZik7CisgICAgc2Ny b2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZm aW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tW aWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlv biA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEo bmV3U2NhbGUsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueCwgY29udGVudFBvc2l0aW9u LngpOworICAgIEVYUEVDVF9FUShwb2ludC55LCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAgICBX S1BhZ2VHb0ZvcndhcmQocGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNo ZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6 OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9y KHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3Np dGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEoMSwgc2NhbGUpOworICAgIEVYUEVDVF9F USgwLCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlv bi55KTsKKworICAgIFdLUGFnZUdvQmFjayhwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsK KyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7 CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50 U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0 Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2Nh bGUpOworICAgIEVYUEVDVF9FUShwb2ludC54LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQ RUNUX0VRKHBvaW50LnksIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFnZUdvRm9yd2Fy ZChwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxz ZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwp OworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7 CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0 KCkpOworICAgIEVYUEVDVF9FUSgxLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQ b3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoMCwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAg V0tQYWdlR29CYWNrKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVk TG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpy dW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2 aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRp b24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKG5ld1NjYWxlLCBzY2FsZSk7CisgICAgRVhQ RUNUX0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQu eSwgY29udGVudFBvc2l0aW9uLnkpOworfQorCit9IC8vIFRlc3RXZWJLaXRBUEkKZGlmZiAtLWdp dCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNz L2JhY2tmb3J3YXJkMS5odG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nv b3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQxLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWE5YWM4ZWMy OGVlNGVhMDMyMzU3ZmM2NGU0OWZmMDJiMTJhYmQ4OAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3 YXJkMS5odG1sCkBAIC0wLDAgKzEsMyBAQAorPGJvZHkgc3R5bGU9IndpZHRoOjEwMCU7IGhlaWdo dDoxMDAlIj4KKyAgICA8ZGl2IHN0eWxlPSJwb3NpdGlvbjogYWJzb2x1dGU7IHRvcDogMDsgbGVm dDogMDsgd2lkdGg6IDkwMHB4OyBoZWlnaHQ6IDEyMDBweDsiPjwvZGl2PgorPC9ib2R5PgpkaWZm IC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3Jh cGhpY3MvYmFja2ZvcndhcmQyLmh0bWwgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktp dDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDIuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zODA2 YjlkMzJlYzRkZTM5ODYxZjJmNzcyYTIxOTIxOGVlYTljNjc1Ci0tLSAvZGV2L251bGwKKysrIGIv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFj a2ZvcndhcmQyLmh0bWwKQEAgLTAsMCArMSBAQAorPGJvZHkgc3R5bGU9IndpZHRoOjEwMCU7IGhl aWdodDoxMDAlIi8+Cg== 227183 2014-03-19 08:14:26 -0700 2014-03-20 00:49:06 -0700 Patch bug-126022-20140320001403.patch text/plain 17045 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTY1ODkwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggNTQ4NzZhODBiMDZlMTdj NmYxYTBhNDQyNDkyNGI4ZWQ4MGQwM2I0OC4uMTc2YWFkNTdhN2YxOWRkZjY3Y2JjYTBhY2Q4MGVl YzEwMjVmOWZhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDE0LTAzLTE5ICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CisKKyAgICAgICAgW0Nvb3JkaW5h dGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUgZmFjdG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90 IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5IGluIGEgYmFjay9mb3J3YXJkIGxvYWQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyNjAyMgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsIGF1dGhvciA6 IFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSwgYW5kIGZpbmlzaGVkIGJ5IEd5dXlvdW5nIEtpbS4K KworICAgICAgICBXaGVuIHVzZXIgaXMgbmF2aWdhdGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdl IHRoYXQgaGFzIGJlZW4gc2Nyb2xsZWQgYW5kL29yIHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUg c2hvd24KKyAgICAgICAgd2l0aCBpdHMgbGFzdCBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZh Y3Rvci4KKyAgICAgICAgSG93ZXZlciwgd2hlbiBmaXhlZCBsYXlvdXQgd2FzIGVuYWJsZWQgd2l0 aCBDb29yZGluYXRlZEdyYXBoaWNzIGFuZCBUSUxFRF9CQUNLSU5HX1NUT1JFLAorICAgICAgICBG cmFtZVZpZXc6OnNldFZpZXdXYXNTY3JvbGxlZEJ5VXNlciB3YXMgYmVpbmcgY2FsbGVkIGJldHdl ZW4gRnJhbWVWaWV3OjpyZXNldCBhbmQKKyAgICAgICAgSGlzdG9yeUNvbnRyb2xsZXI6OnJlc3Rv cmVTY3JvbGxQb3NpdGlvbkFuZFZpZXdTdGF0ZSwgY2F1c2luZyB0aGUgdGhlIFdlYkNvcmU6OlBh Z2UgdG8gZG8gbm90IGdldCBpdHMgc2NhbGUKKyAgICAgICAgZmFjdG9yIGFuZCBzY3JvbGwgcG9z aXRpb24gdG8gYmUgcmVzdG9yZWQuCisgICAgICAgIE5vd2FkYXlzIHRoZSBvbmx5IHBvcnQgdGhh dCB1c2UgQ29vcmRpbmF0ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19TVE9SRSBpcyBFRkwg cG9ydChVbmZvcnR1bmF0ZWx5LCBuaXgKKyAgICAgICAgcG9ydCB3YXMgZHJvcHBlZC4pLgorCisg ICAgICAgIEFsc28sIHdoZW4gYSB1c2VyIHdhcyB1c2luZyB0aGUgV0tWaWV3IEFQSSB0byBzZXQg dGhlIHNjYWxlIGZhY3RvciAoV0tWaWV3U2V0Q29udGVudFNjYWxlRmFjdG9yKSB0aGlzIHNjYWxl IHdhcworICAgICAgICBub3QgYmVpbmcgZm9yd2FyZGVkIHRvIFdlYkNvcmUuCisgICAgICAgIFRo ZW4sIHdoZW4gZ29pbmcgYmFjay9mb3J3YXJkIHRvIGEgcGFnZSBIaXN0b3J5Q29udHJvbGxlciB3 YXMgbm90IGtub3dpbmcgYWJvdXQgaXRzIHJlYWwgc2NhbGUgZmFjdG9yLgorCisgICAgICAgIEEg V2ViS2l0QVBJIHRlc3QgaXMgYmVpbmcgYWRkZWQgdG8gdmFsaWRhdGUgdGhpcyBiZWhhdmlvdXIu CisKKyAgICAgICAgKiBVSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9QYWdlVmlld3BvcnRD b250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdlYktpdDo6UGFnZVZpZXdwb3J0Q29udHJvbGxlcjo6 ZGlkUmVuZGVyRnJhbWUpOgorICAgICAgICAqIFVJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNz L1dlYlZpZXcuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpkaWRDaGFuZ2VQYWdlU2Nh bGVGYWN0b3IpOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3OjpkaWRDb21taXRMb2FkRm9yTWFp bkZyYW1lKToKKyAgICAgICAgKiBVSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3 Lmg6CisgICAgICAgICogVUlQcm9jZXNzL1BhZ2VDbGllbnQuaDoKKyAgICAgICAgKFdlYktpdDo6 UGFnZUNsaWVudDo6ZGlkQ2hhbmdlUGFnZVNjYWxlRmFjdG9yKToKKyAgICAgICAgKiBVSVByb2Nl c3MvV2ViUGFnZVByb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpwYWdl U2NhbGVGYWN0b3JEaWRDaGFuZ2UpOgorCiAyMDE0LTAzLTE4ICBUaW0gSG9ydG9uICA8dGltb3Ro eV9ob3J0b25AYXBwbGUuY29tPgogCiAgICAgICAgIFtpT1NdW1dlYktpdDJdIFByb3ZpZGUgZ2Vu ZXJpYyBzb2Z0d2FyZS1zbmFwc2hvdHRpbmcgQVBJCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9QYWdlVmlld3BvcnRDb250cm9sbGVyLmNw cCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1BhZ2VWaWV3 cG9ydENvbnRyb2xsZXIuY3BwCmluZGV4IDdiNGI5NDUyMjJkMzE3M2FiODNiNDgzZDJhMzg2ZDUy ZTc4N2Y3ZjYuLmU2ZGYwNDEwMDA3NTIzYThhMDY0YjVmYTgxMzA0ZjMyMjkxOWJlN2IgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1BhZ2VW aWV3cG9ydENvbnRyb2xsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29y ZGluYXRlZEdyYXBoaWNzL1BhZ2VWaWV3cG9ydENvbnRyb2xsZXIuY3BwCkBAIC0xODcsMTUgKzE4 NywxMSBAQCB2b2lkIFBhZ2VWaWV3cG9ydENvbnRyb2xsZXI6OmRpZFJlbmRlckZyYW1lKGNvbnN0 IEludFNpemUmIGNvbnRlbnRzU2l6ZSwgY29uc3QgSQogCiAgICAgaWYgKG1fcGVuZGluZ1NjYWxl Q2hhbmdlKSB7CiAgICAgICAgIG1fcGVuZGluZ1NjYWxlQ2hhbmdlID0gZmFsc2U7Ci0gICAgICAg IG1fY2xpZW50LT5zZXRQYWdlU2NhbGVGYWN0b3IobV9wYWdlU2NhbGVGYWN0b3IpOwotCiAgICAg ICAgIC8vIFRoZSBzY2FsZSBjaGFuZ2VkLCB3ZSBoYXZlIHRvIHJlLXBpeGVsIGFsaWduLgogICAg ICAgICBtX3BlbmRpbmdQb3NpdGlvbkNoYW5nZSA9IHRydWU7CiAgICAgICAgIEZsb2F0UG9pbnQg Y3VycmVudERpc2NyZXRlUG9zID0gcm91bmRlZEludFBvaW50KG1fY29udGVudHNQb3NpdGlvbik7 CiAgICAgICAgIEZsb2F0UG9pbnQgcGl4ZWxBbGlnbmVkUG9zID0gcGl4ZWxBbGlnbmVkRmxvYXRQ b2ludChjdXJyZW50RGlzY3JldGVQb3MpOwogICAgICAgICBtX2NvbnRlbnRzUG9zaXRpb24gPSBi b3VuZENvbnRlbnRzUG9zaXRpb24ocGl4ZWxBbGlnbmVkUG9zKTsKLQotICAgICAgICBtX3dlYlBh Z2VQcm94eS0+c2NhbGVQYWdlKG1fcGFnZVNjYWxlRmFjdG9yLCByb3VuZGVkSW50UG9pbnQobV9j b250ZW50c1Bvc2l0aW9uKSk7CiAgICAgfQogCiAgICAgLy8gVGhlcmUgbWlnaHQgYmUgcmVuZGVy ZWQgZnJhbWVzIG5vdCBjb3ZlcmluZyBvdXIgcmVxdWVzdGVkIHBvc2l0aW9uIHlldCwgd2FpdCBm b3IgaXQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRH cmFwaGljcy9XZWJWaWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRl ZEdyYXBoaWNzL1dlYlZpZXcuY3BwCmluZGV4IGFiMjdmNDk4ZTcwZjQ2NzJkZDg4NjI0ZTMwZTlh YjAyYTZiMjVhYTcuLmY1MDlhNGRhOTgwYTVmY2YyOWEyNjEzMjg3YjdlZmFiMjg4OWQ4NDIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dl YlZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBo aWNzL1dlYlZpZXcuY3BwCkBAIC05NSw2ICs5NSwxMyBAQCB2b2lkIFdlYlZpZXc6OnNldEFjdGl2 ZShib29sIGFjdGl2ZSkKICAgICBtX3BhZ2UtPnZpZXdTdGF0ZURpZENoYW5nZShWaWV3U3RhdGU6 OldpbmRvd0lzQWN0aXZlKTsKIH0KIAordm9pZCBXZWJWaWV3OjpkaWRDaGFuZ2VQYWdlU2NhbGVG YWN0b3IoZG91YmxlIHNjYWxlRmFjdG9yKQoreworICAgIC8vIEZJWE1FOiBIb3cgdG8gaGFuZGxl IHNjYWxlRmFjdG9yID8KKyAgICBVTlVTRURfUEFSQU0oc2NhbGVGYWN0b3IpOworICAgIHVwZGF0 ZVZpZXdwb3J0U2l6ZSgpOworfQorCiB2b2lkIFdlYlZpZXc6OnNldFNpemUoY29uc3QgV2ViQ29y ZTo6SW50U2l6ZSYgc2l6ZSkKIHsKICAgICBpZiAobV9zaXplID09IHNpemUpCkBAIC0zNjQsNiAr MzcxLDcgQEAgdm9pZCBXZWJWaWV3Ojp0b29sVGlwQ2hhbmdlZChjb25zdCBTdHJpbmcmLCBjb25z dCBTdHJpbmcmIG5ld1Rvb2xUaXApCiAKIHZvaWQgV2ViVmlldzo6ZGlkQ29tbWl0TG9hZEZvck1h aW5GcmFtZShjb25zdCBTdHJpbmcmLCBib29sKQogeworICAgIHNldENvbnRlbnRQb3NpdGlvbihX ZWJDb3JlOjpGbG9hdFBvaW50KCkpOwogICAgIG1fY29udGVudHNTaXplID0gSW50U2l6ZSgpOwog fQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFw aGljcy9XZWJWaWV3LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFw aGljcy9XZWJWaWV3LmgKaW5kZXggYzQ0MTk3NDFkNDc4NGE0ZWYwNWEzMWJhYmFjMDMzZDU0OTI1 YTUyMi4uNGRlNjUxZTdmNjYyZGM4YTM4ZjY5OTg5Y2IzYzdiYmQyYmNkMmM3OSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5o CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZp ZXcuaApAQCAtMTQ5LDYgKzE0OSw4IEBAIHByb3RlY3RlZDoKIAogICAgIHZpcnR1YWwgdm9pZCBk aWRDb21taXRMb2FkRm9yTWFpbkZyYW1lKGNvbnN0IFN0cmluZyYgbWltZVR5cGUsIGJvb2wgdXNl Q3VzdG9tQ29udGVudFByb3ZpZGVyKSBvdmVycmlkZTsKIAorICAgIHZpcnR1YWwgdm9pZCBkaWRD aGFuZ2VQYWdlU2NhbGVGYWN0b3IoZG91YmxlKSBvdmVycmlkZTsKKwogICAgIHZpcnR1YWwgdm9p ZCBwYWdlRGlkUmVxdWVzdFNjcm9sbChjb25zdCBXZWJDb3JlOjpJbnRQb2ludCYpIG92ZXJyaWRl OwogICAgIHZpcnR1YWwgdm9pZCBkaWRSZW5kZXJGcmFtZShjb25zdCBXZWJDb3JlOjpJbnRTaXpl JiBjb250ZW50c1NpemUsIGNvbnN0IFdlYkNvcmU6OkludFJlY3QmIGNvdmVyZWRSZWN0KSBvdmVy cmlkZTsKICAgICB2aXJ0dWFsIHZvaWQgcGFnZVRyYW5zaXRpb25WaWV3cG9ydFJlYWR5KCkgb3Zl cnJpZGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGFnZUNsaWVudC5o IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAppbmRleCA5ZmZiYzMxNDgx MWU2Njc5ZGExMmFjM2JmYmEzYzdkZjJhZTQ1MjdhLi41ZGIwMDQzNTBlMjU3YzJjMjJjZjY2Njdj NWI3ZDllZGE3ZWE0MWU4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGFn ZUNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmgKQEAg LTEyNiw2ICsxMjYsOCBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgdG9vbFRpcENoYW5n ZWQoY29uc3QgU3RyaW5nJiwgY29uc3QgU3RyaW5nJikgPSAwOwogCisgICAgdmlydHVhbCB2b2lk IGRpZENoYW5nZVBhZ2VTY2FsZUZhY3Rvcihkb3VibGUpIHsgfQorCiAgICAgdmlydHVhbCBib29s IGRlY2lkZVBvbGljeUZvckdlb2xvY2F0aW9uUGVybWlzc2lvblJlcXVlc3QoV2ViRnJhbWVQcm94 eSYsIFdlYlNlY3VyaXR5T3JpZ2luJiwgR2VvbG9jYXRpb25QZXJtaXNzaW9uUmVxdWVzdFByb3h5 JikKICAgICB7CiAgICAgICAgIHJldHVybiBmYWxzZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L1dlYlBhZ2VQcm94eS5jcHAKaW5kZXggYjQzMTgzMjkwYzMzMzc2ZjdmOGZhNDRlYWNhMWI4Yjgw MWU5MjYwNS4uNWNmZmJmYTkwMjdhYmMyOWZiYmM0NGMyMTlkNWVjZmJjMDdiMzU0YSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKQEAgLTE4NzUsNiArMTg3NSw3 IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpzZXRHYXBCZXR3ZWVuUGFnZXMoZG91YmxlIGdhcCkKIHZv aWQgV2ViUGFnZVByb3h5OjpwYWdlU2NhbGVGYWN0b3JEaWRDaGFuZ2UoZG91YmxlIHNjYWxlRmFj dG9yKQogewogICAgIG1fcGFnZVNjYWxlRmFjdG9yID0gc2NhbGVGYWN0b3I7CisgICAgbV9wYWdl Q2xpZW50LmRpZENoYW5nZVBhZ2VTY2FsZUZhY3RvcihtX3BhZ2VTY2FsZUZhY3Rvcik7CiB9CiAK IHZvaWQgV2ViUGFnZVByb3h5OjpwYWdlWm9vbUZhY3RvckRpZENoYW5nZShkb3VibGUgem9vbUZh Y3RvcikKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCBjOTBmYTMyMjEzNzJmZTcwYmU4MmI4MGRjZDg2NDY0NGFkZGJhYmE2Li5jMDZhNDNkMzIzMmQ1 YjQ4YTA0N2UwNzA1YTQ2Mzk5NGRmNTZiYWU0IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cK KysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTQtMDMtMTkgIEd5dXlv dW5nIEtpbSAgPGd5dXlvdW5nLmtpbUBzYW1zdW5nLmNvbT4KKworICAgICAgICBbQ29vcmRpbmF0 ZWRHcmFwaGljc11bV0syXSBTY2FsZSBmYWN0b3IgYW5kIHNjcm9sbCBwb3NpdGlvbiBpcyBub3Qg YmVpbmcgcmVzdG9yZWQgcHJvcGVybHkgaW4gYSBiYWNrL2ZvcndhcmQgbG9hZAorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTI2MDIyCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgT3JpZ2luYWwgYXV0aG9yIDog VGhpYWdvIGRlIEJhcnJvcyBMYWNlcmRhLCBhbmQgZmluaXNoZWQgYnkgR3l1eW91bmcgS2ltLgor CisgICAgICAgIFdoZW4gdXNlciBpcyBuYXZpZ2F0aW5nIGJhY2svZm9yd2FyZCB0byBhIHBhZ2Ug dGhhdCBoYXMgYmVlbiBzY3JvbGxlZCBhbmQvb3Igc2NhbGVkLCB0aGF0IHBhZ2UgbXVzdCBiZSBz aG93bgorICAgICAgICB3aXRoIGl0cyBsYXN0IHNjcm9sbCBwb3NpdGlvbiBhbmQgc2NhbGUgZmFj dG9yLgorICAgICAgICBIb3dldmVyLCB3aGVuIGZpeGVkIGxheW91dCB3YXMgZW5hYmxlZCB3aXRo IENvb3JkaW5hdGVkR3JhcGhpY3MgYW5kIFRJTEVEX0JBQ0tJTkdfU1RPUkUsCisgICAgICAgIEZy YW1lVmlldzo6c2V0Vmlld1dhc1Njcm9sbGVkQnlVc2VyIHdhcyBiZWluZyBjYWxsZWQgYmV0d2Vl biBGcmFtZVZpZXc6OnJlc2V0IGFuZAorICAgICAgICBIaXN0b3J5Q29udHJvbGxlcjo6cmVzdG9y ZVNjcm9sbFBvc2l0aW9uQW5kVmlld1N0YXRlLCBjYXVzaW5nIHRoZSB0aGUgV2ViQ29yZTo6UGFn ZSB0byBkbyBub3QgZ2V0IGl0cyBzY2FsZQorICAgICAgICBmYWN0b3IgYW5kIHNjcm9sbCBwb3Np dGlvbiB0byBiZSByZXN0b3JlZC4KKyAgICAgICAgTm93YWRheXMgdGhlIG9ubHkgcG9ydCB0aGF0 IHVzZSBDb29yZGluYXRlZEdyYXBoaWNzIGFuZCBUSUxFRF9CQUNLSU5HX1NUT1JFIGlzIEVGTCBw b3J0KFVuZm9ydHVuYXRlbHksIG5peAorICAgICAgICBwb3J0IHdhcyBkcm9wcGVkLikuCisKKyAg ICAgICAgQWxzbywgd2hlbiBhIHVzZXIgd2FzIHVzaW5nIHRoZSBXS1ZpZXcgQVBJIHRvIHNldCB0 aGUgc2NhbGUgZmFjdG9yIChXS1ZpZXdTZXRDb250ZW50U2NhbGVGYWN0b3IpIHRoaXMgc2NhbGUg d2FzCisgICAgICAgIG5vdCBiZWluZyBmb3J3YXJkZWQgdG8gV2ViQ29yZS4KKyAgICAgICAgVGhl biwgd2hlbiBnb2luZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdlIEhpc3RvcnlDb250cm9sbGVyIHdh cyBub3Qga25vd2luZyBhYm91dCBpdHMgcmVhbCBzY2FsZSBmYWN0b3IuCisKKyAgICAgICAgQSBX ZWJLaXRBUEkgdGVzdCBpcyBiZWluZyBhZGRlZCB0byB2YWxpZGF0ZSB0aGlzIGJlaGF2aW91ci4K KworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21ha2U6CisgICAgICAgICog VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV0tWaWV3UmVz dG9yZVpvb21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHA6IEFkZGVkLgorICAgICAgICAoVGVzdFdl YktpdEFQSTo6ZGlkRmluaXNoTG9hZEZvckZyYW1lKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OmRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb24pOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVT VCk6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3Jh cGhpY3MvYmFja2ZvcndhcmQxLmh0bWw6IEFkZGVkLgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkv VGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMi5odG1sOiBBZGRl ZC4KKwogMjAxNC0wMy0xOCAgU2FtdWVsIFdoaXRlICA8c2FtdWVsX3doaXRlQGFwcGxlLmNvbT4K IAogICAgICAgICBBWDogTm90IGFibGUgdG8gdXNlIGFycm93IGtleXMgdG8gcmVhZCB0ZXh0IHdp dGggVm9pY2VPdmVyIGJlZm9yZSBzZWxlY3Rpb24gaXMgc2V0IHNvbWVwbGFjZSAoYW55cGxhY2Up LgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggODE1M2Y3ZjU2OWUxNjJk YzFkZjlmNzEwNjcxYWEzOWNlNzA4YmEwOS4uZjI4M2ZmOTIwN2JjYWU5OWViNjAzNzU4YjlkYTVh YjdjNWY0ZDVhMyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5j bWFrZQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC05OCw2 ICs5OCw3IEBAIHNldCh0ZXN0X3dlYmtpdDJfYXBpX0JJTkFSSUVTCiAgICAgV2lsbExvYWQKICAg ICBXaWxsU2VuZFN1Ym1pdEV2ZW50CiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdJc0Fj dGl2ZVNldElzQWN0aXZlCisgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9v bUFuZFNjcm9sbEJhY2tGb3J3YXJkCiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdVc2Vy Vmlld3BvcnRUb0NvbnRlbnRzCiAgICAgZWZsL1dLVmlld0NsaWVudFdlYlByb2Nlc3NDYWxsYmFj a3MKICkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29y ZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQuY3Bw IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3Mv V0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHAKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNzk1 ZDRhNjA1YWM4MGMyMDgyOWY3ZTBhNDNjZDJlYWRlNjYyMjdlMAotLS0gL2Rldi9udWxsCisrKyBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dL Vmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwCkBAIC0wLDAgKzEsMTg1IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyLTIwMTMgTm9raWEgQ29ycG9yYXRpb24gYW5kL29y IGl0cyBzdWJzaWRpYXJ5KC1pZXMpLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisg KiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVCBIT0xERVJTIE9SCisgKiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAq IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisj aW5jbHVkZSAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNpbmNsdWRlIDxXZWJLaXQyL1dLQ29udGV4 dC5oPgorI2luY2x1ZGUgPFdlYktpdDIvV0tHZW9tZXRyeS5oPgorI2luY2x1ZGUgPFdlYktpdDIv V0tSZXRhaW5QdHIuaD4KKyNpbmNsdWRlICJUZXN0LmgiCisKK25hbWVzcGFjZSBUZXN0V2ViS2l0 QVBJIHsKKworc3RhdGljIGJvb2wgZmluaXNoZWRMb2FkID0gZmFsc2U7CitzdGF0aWMgYm9vbCBz Y3JvbGwgPSBmYWxzZTsKKworc3RhdGljIHZvaWQgZGlkRmluaXNoTG9hZEZvckZyYW1lKFdLUGFn ZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBlUmVmLCBjb25zdCB2b2lkKikKK3sKKyAgICBmaW5pc2hl ZExvYWQgPSB0cnVlOworfQorCitzdGF0aWMgdm9pZCBkaWRDaGFuZ2VDb250ZW50c1Bvc2l0aW9u KFdLVmlld1JlZiwgV0tQb2ludCBwLCBjb25zdCB2b2lkKikKK3sKKyAgICBzY3JvbGwgPSB0cnVl OworfQorCitURVNUKFdlYktpdDIsIEJhY2tGb3J3YXJkKQoreworICAgIGNvbnN0IFdLU2l6ZSBz aXplID0gV0tTaXplTWFrZSg4MDAsIDYwMCk7CisKKyAgICBXS1JldGFpblB0cjxXS0NvbnRleHRS ZWY+IGNvbnRleHQgPSBhZG9wdFdLKFdLQ29udGV4dENyZWF0ZSgpKTsKKyAgICBXS1JldGFpblB0 cjxXS1ZpZXdSZWY+IHZpZXcoQWRvcHRXSywgV0tWaWV3Q3JlYXRlKGNvbnRleHQuZ2V0KCksIDAp KTsKKworICAgIFdLVmlld0luaXRpYWxpemUodmlldy5nZXQoKSk7CisgICAgV0tWaWV3U2V0U2l6 ZSh2aWV3LmdldCgpLCBzaXplKTsKKworICAgIFdLUGFnZVJlZiBwYWdlUmVmID0gV0tWaWV3R2V0 UGFnZSh2aWV3LmdldCgpKTsKKyAgICBXS1BhZ2VTZXRVc2VGaXhlZExheW91dChwYWdlUmVmLCB0 cnVlKTsKKyAgICBBU1NFUlRfVFJVRShwYWdlUmVmKTsKKworICAgIFdLUGFnZUxvYWRlckNsaWVu dFYzIGxvYWRlckNsaWVudDsKKyAgICBtZW1zZXQoJmxvYWRlckNsaWVudCwgMCwgc2l6ZW9mKGxv YWRlckNsaWVudCkpOworICAgIGxvYWRlckNsaWVudC5iYXNlLnZlcnNpb24gPSAzOworICAgIGxv YWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJhbWUgPSBkaWRGaW5pc2hMb2FkRm9yRnJhbWU7 CisgICAgV0tQYWdlU2V0UGFnZUxvYWRlckNsaWVudChwYWdlUmVmLCAmbG9hZGVyQ2xpZW50LmJh c2UpOworCisgICAgV0tWaWV3Q2xpZW50VjAgdmlld0NsaWVudDsKKyAgICBtZW1zZXQoJnZpZXdD bGllbnQsIDAsIHNpemVvZih2aWV3Q2xpZW50KSk7CisgICAgdmlld0NsaWVudC5iYXNlLnZlcnNp b24gPSAwOworICAgIHZpZXdDbGllbnQuZGlkQ2hhbmdlQ29udGVudHNQb3NpdGlvbiA9IGRpZENo YW5nZUNvbnRlbnRzUG9zaXRpb247CisgICAgV0tWaWV3U2V0Vmlld0NsaWVudCh2aWV3LmdldCgp LCAmdmlld0NsaWVudC5iYXNlKTsKKworICAgIFdLUmV0YWluUHRyPFdLVVJMUmVmPiB1cmwgPSBh ZG9wdFdLKFV0aWw6OmNyZWF0ZVVSTEZvclJlc291cmNlKCJDb29yZGluYXRlZEdyYXBoaWNzL2Jh Y2tmb3J3YXJkMSIsICJodG1sIikpOworICAgIFdLUGFnZUxvYWRVUkwocGFnZVJlZiwgdXJsLmdl dCgpKTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisKKyAgICBmbG9hdCBuZXdTY2Fs ZSA9IDIuMDsKKyAgICBXS1BvaW50IHBvaW50ID0gV0tQb2ludE1ha2UoMTAsIDM1MCk7CisgICAg V0tWaWV3U2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCksIHBvaW50KTsKKyAgICBXS1ZpZXdT ZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSwgbmV3U2NhbGUpOworICAgIGZsb2F0IHNj YWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIFdLUG9p bnQgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkp OworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9FUShwb2ludC54 LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNvbnRlbnRQb3Np dGlvbi55KTsKKworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIHVybCA9IGFkb3B0V0so VXRpbDo6Y3JlYXRlVVJMRm9yUmVzb3VyY2UoIkNvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2Zvcndh cmQyIiwgImh0bWwiKSk7CisgICAgV0tQYWdlTG9hZFVSTChwYWdlUmVmLCB1cmwuZ2V0KCkpOwor ICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29u dGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmll d0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEoMSwgc2NhbGUp OworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKDAs IGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFnZUdvQmFjayhwYWdlUmVmKTsKKyAgICBz Y3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4o JmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBX S1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0 aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9F UShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9FUShwb2ludC54LCBjb250ZW50UG9zaXRp b24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAg IFdLUGFnZUdvRm9yd2FyZChwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5p c2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRp bDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0 b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBv c2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBzY2FsZSk7CisgICAgRVhQRUNU X0VRKDAsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoMCwgY29udGVudFBvc2l0 aW9uLnkpOworCisgICAgV0tQYWdlR29CYWNrKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNl OworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2Fk KTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRl bnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdH ZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKG5ld1NjYWxlLCBz Y2FsZSk7CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBF WFBFQ1RfRVEocG9pbnQueSwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQYWdlR29Gb3J3 YXJkKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVkTG9hZCA9IGZh bHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpydW4oJnNjcm9s bCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgp KTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5n ZXQoKSk7CisgICAgRVhQRUNUX0VRKDEsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEoMCwgY29udGVu dFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAg ICBXS1BhZ2VHb0JhY2socGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNo ZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6 OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9y KHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3Np dGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEobmV3U2NhbGUsIHNjYWxlKTsKKyAgICBF WFBFQ1RfRVEocG9pbnQueCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUShwb2lu dC55LCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1BhZ2VHb0ZvcndhcmQocGFnZVJlZik7 CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRp bDo6cnVuKCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKworICAgIHNj YWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRl bnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBF WFBFQ1RfRVEoMSwgc2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueCk7 CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFnZUdvQmFj ayhwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxz ZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwp OworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7 CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0 KCkpOworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9FUShwb2lu dC54LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNvbnRlbnRQ b3NpdGlvbi55KTsKK30KKworfSAvLyBUZXN0V2ViS2l0QVBJCmRpZmYgLS1naXQgYS9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2Fy ZDEuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdy YXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmFhOWFjOGVjMjhlZTRlYTAzMjM1 N2ZjNjRlNDlmZjAyYjEyYWJkODgKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDEuaHRtbApA QCAtMCwwICsxLDMgQEAKKzxib2R5IHN0eWxlPSJ3aWR0aDoxMDAlOyBoZWlnaHQ6MTAwJSI+Cisg ICAgPGRpdiBzdHlsZT0icG9zaXRpb246IGFic29sdXRlOyB0b3A6IDA7IGxlZnQ6IDA7IHdpZHRo OiA5MDBweDsgaGVpZ2h0OiAxMjAwcHg7Ij48L2Rpdj4KKzwvYm9keT4KZGlmZiAtLWdpdCBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tm b3J3YXJkMi5odG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5h dGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMzgwNmI5ZDMyZWM0ZGUz OTg2MWYyZjc3MmEyMTkyMThlZWE5YzY3NQotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMi5o dG1sCkBAIC0wLDAgKzEgQEAKKzxib2R5IHN0eWxlPSJ3aWR0aDoxMDAlOyBoZWlnaHQ6MTAwJSIv Pgo= 227269 2014-03-20 00:49:19 -0700 2014-04-25 03:18:56 -0700 Patch bug-126022-20140320164856.patch text/plain 17396 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTY1OTQ2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYjM1ZTIzYmY1YzczYWUy MTZiMjgyZGQ1NDRlNzc5N2IwZDYyMTU0MC4uZGQ2Mzk1YzhhMzhlZmM3NGM4YjBkMDIzNTgyMTQw YjA1MTUzZTVmZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMzIEBACisyMDE0LTAzLTIwICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CisKKyAgICAgICAgW0Nvb3JkaW5h dGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUgZmFjdG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90 IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5IGluIGEgYmFjay9mb3J3YXJkIGxvYWQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyNjAyMgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsIGF1dGhvciA6 IFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSwgYW5kIGZpbmlzaGVkIGJ5IEd5dXlvdW5nIEtpbS4K KworICAgICAgICBXaGVuIHVzZXIgaXMgbmF2aWdhdGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdl IHRoYXQgaGFzIGJlZW4gc2Nyb2xsZWQgYW5kL29yIHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUg c2hvd24KKyAgICAgICAgd2l0aCBpdHMgbGFzdCBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZh Y3Rvci4KKyAgICAgICAgSG93ZXZlciwgd2hlbiBmaXhlZCBsYXlvdXQgd2FzIGVuYWJsZWQgd2l0 aCBDb29yZGluYXRlZEdyYXBoaWNzIGFuZCBUSUxFRF9CQUNLSU5HX1NUT1JFLAorICAgICAgICBG cmFtZVZpZXc6OnNldFZpZXdXYXNTY3JvbGxlZEJ5VXNlciB3YXMgYmVpbmcgY2FsbGVkIGJldHdl ZW4gRnJhbWVWaWV3OjpyZXNldCBhbmQKKyAgICAgICAgSGlzdG9yeUNvbnRyb2xsZXI6OnJlc3Rv cmVTY3JvbGxQb3NpdGlvbkFuZFZpZXdTdGF0ZSwgY2F1c2luZyB0aGUgdGhlIFdlYkNvcmU6OlBh Z2UgdG8gZG8gbm90IGdldCBpdHMgc2NhbGUKKyAgICAgICAgZmFjdG9yIGFuZCBzY3JvbGwgcG9z aXRpb24gdG8gYmUgcmVzdG9yZWQuCisgICAgICAgIE5vd2FkYXlzIHRoZSBvbmx5IHBvcnQgdGhh dCB1c2UgQ29vcmRpbmF0ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19TVE9SRSBpcyBFRkwg cG9ydChVbmZvcnR1bmF0ZWx5LCBuaXgKKyAgICAgICAgcG9ydCB3YXMgZHJvcHBlZC4pLgorCisg ICAgICAgIEFsc28sIHdoZW4gYSB1c2VyIHdhcyB1c2luZyB0aGUgV0tWaWV3IEFQSSB0byBzZXQg dGhlIHNjYWxlIGZhY3RvciAoV0tWaWV3U2V0Q29udGVudFNjYWxlRmFjdG9yKSB0aGlzIHNjYWxl IHdhcworICAgICAgICBub3QgYmVpbmcgZm9yd2FyZGVkIHRvIFdlYkNvcmUuCisgICAgICAgIFRo ZW4sIHdoZW4gZ29pbmcgYmFjay9mb3J3YXJkIHRvIGEgcGFnZSBIaXN0b3J5Q29udHJvbGxlciB3 YXMgbm90IGtub3dpbmcgYWJvdXQgaXRzIHJlYWwgc2NhbGUgZmFjdG9yLgorCisgICAgICAgIEEg V2ViS2l0QVBJIHRlc3QgaXMgYmVpbmcgYWRkZWQgdG8gdmFsaWRhdGUgdGhpcyBiZWhhdmlvdXIu CisKKyAgICAgICAgKiBwYWdlL1BhZ2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6c2V0 UGFnZVNjYWxlRmFjdG9yKToKKyAgICAgICAgCisgICAgICAgICAgICBXaGVuIGRlbGVnYXRlc1Nj cm9sbGluZyBpc24ndCBlbmFibGVkLCBXZSBhbHNvIG5lZWQgdG8gdXBkYXRlIHNjcm9sbCBwb3Np dGlvbiBiZWNhdXNlIHRoZSB1cGRhdGVkIHNjcm9sbCBwb3NpdGlvbgorICAgICAgICAgICAgYWxz byBuZWVkcyB0byBiZSBwYXNzZWQgdG8gV0syIGluIGJhY2svZm9yd2FyZCBsb2FkLgorCiAyMDE0 LTAzLTE5ICBQcmF0aWsgU29sYW5raSAgPHBzb2xhbmtpQGFwcGxlLmNvbT4KIAogICAgICAgICBb aU9TXSBHZXQgY29kZSB0byBjb21waWxlIG9uIG9sZGVyIGlPUyB2ZXJzaW9ucwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmlu ZGV4IDc2YTQ4MjdiYzdlNjYwOWZlMzE2YzhiNmYyZDQ1ODUxN2I1N2YxOTUuLmIyYmY2NTlhYjBk NWIyNDJiOTJhYzcyZDY2MjI5ZWMzZGUzYmY5NjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBA QAorMjAxNC0wMy0yMCAgR3l1eW91bmcgS2ltICA8Z3l1eW91bmcua2ltQHNhbXN1bmcuY29tPgor CisgICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNzXVtXSzJdIFNjYWxlIGZhY3RvciBhbmQgc2Ny b2xsIHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0b3JlZCBwcm9wZXJseSBpbiBhIGJhY2svZm9y d2FyZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xMjYwMjIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBPcmlnaW5hbCBhdXRob3IgOiBUaGlhZ28gZGUgQmFycm9zIExhY2VyZGEsIGFuZCBmaW5pc2hl ZCBieSBHeXV5b3VuZyBLaW0uCisKKyAgICAgICAgV2hlbiB1c2VyIGlzIG5hdmlnYXRpbmcgYmFj ay9mb3J3YXJkIHRvIGEgcGFnZSB0aGF0IGhhcyBiZWVuIHNjcm9sbGVkIGFuZC9vciBzY2FsZWQs IHRoYXQgcGFnZSBtdXN0IGJlIHNob3duCisgICAgICAgIHdpdGggaXRzIGxhc3Qgc2Nyb2xsIHBv c2l0aW9uIGFuZCBzY2FsZSBmYWN0b3IuCisgICAgICAgIEhvd2V2ZXIsIHdoZW4gZml4ZWQgbGF5 b3V0IHdhcyBlbmFibGVkIHdpdGggQ29vcmRpbmF0ZWRHcmFwaGljcyBhbmQgVElMRURfQkFDS0lO R19TVE9SRSwKKyAgICAgICAgRnJhbWVWaWV3OjpzZXRWaWV3V2FzU2Nyb2xsZWRCeVVzZXIgd2Fz IGJlaW5nIGNhbGxlZCBiZXR3ZWVuIEZyYW1lVmlldzo6cmVzZXQgYW5kCisgICAgICAgIEhpc3Rv cnlDb250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRpb25BbmRWaWV3U3RhdGUsIGNhdXNpbmcg dGhlIHRoZSBXZWJDb3JlOjpQYWdlIHRvIGRvIG5vdCBnZXQgaXRzIHNjYWxlCisgICAgICAgIGZh Y3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIHRvIGJlIHJlc3RvcmVkLgorICAgICAgICBOb3dhZGF5 cyB0aGUgb25seSBwb3J0IHRoYXQgdXNlIENvb3JkaW5hdGVkR3JhcGhpY3MgYW5kIFRJTEVEX0JB Q0tJTkdfU1RPUkUgaXMgRUZMIHBvcnQoVW5mb3J0dW5hdGVseSwgbml4CisgICAgICAgIHBvcnQg d2FzIGRyb3BwZWQuKS4KKworICAgICAgICBBbHNvLCB3aGVuIGEgdXNlciB3YXMgdXNpbmcgdGhl IFdLVmlldyBBUEkgdG8gc2V0IHRoZSBzY2FsZSBmYWN0b3IgKFdLVmlld1NldENvbnRlbnRTY2Fs ZUZhY3RvcikgdGhpcyBzY2FsZSB3YXMKKyAgICAgICAgbm90IGJlaW5nIGZvcndhcmRlZCB0byBX ZWJDb3JlLgorICAgICAgICBUaGVuLCB3aGVuIGdvaW5nIGJhY2svZm9yd2FyZCB0byBhIHBhZ2Ug SGlzdG9yeUNvbnRyb2xsZXIgd2FzIG5vdCBrbm93aW5nIGFib3V0IGl0cyByZWFsIHNjYWxlIGZh Y3Rvci4KKworICAgICAgICBBIFdlYktpdEFQSSB0ZXN0IGlzIGJlaW5nIGFkZGVkIHRvIHZhbGlk YXRlIHRoaXMgYmVoYXZpb3VyLgorCisgICAgICAgICogVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3Jh cGhpY3MvUGFnZVZpZXdwb3J0Q29udHJvbGxlci5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VW aWV3cG9ydENvbnRyb2xsZXI6OmRpZFJlbmRlckZyYW1lKToKKyAgICAgICAgKiBVSVByb2Nlc3Mv Q29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmll dzo6ZGlkQ29tbWl0TG9hZEZvck1haW5GcmFtZSk6CisKIDIwMTQtMDMtMTkgIFRpbSBIb3J0b24g IDx0aW1vdGh5X2hvcnRvbkBhcHBsZS5jb20+CiAKICAgICAgICAgQWRkcmVzcyBsYXRlIHJldmll dyBjb21tZW50IGFuZCBzdHlsZSBuaXQgYWZ0ZXIgcjE2NTkzNC4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCmlu ZGV4IDNmYTliMWM1ZTJmNGUxM2EwNDVmZGU5MmVmNGRhZjMzYWZiMjkwZDMuLmRiOTQwZTI3MjAx ODczZmIxMjliMjQyZjY1MWRmZmMzYzZiMjU1YzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcApAQCAtNjk5 LDggKzY5OSw3IEBAIHZvaWQgUGFnZTo6c2V0UGFnZVNjYWxlRmFjdG9yKGZsb2F0IHNjYWxlLCBj b25zdCBJbnRQb2ludCYgb3JpZ2luKQogICAgICAgICAgICAgaWYgKCFtX3NldHRpbmdzLT5kZWxl Z2F0ZXNQYWdlU2NhbGluZygpKQogICAgICAgICAgICAgICAgIGRvY3VtZW50LT51cGRhdGVMYXlv dXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKTsKIAotICAgICAgICAgICAgaWYgKCF2aWV3LT5k ZWxlZ2F0ZXNTY3JvbGxpbmcoKSkKLSAgICAgICAgICAgICAgICB2aWV3LT5zZXRTY3JvbGxQb3Np dGlvbihvcmlnaW4pOworICAgICAgICAgICAgdmlldy0+c2V0U2Nyb2xsUG9zaXRpb24ob3JpZ2lu KTsKICAgICAgICAgfQogICAgICAgICByZXR1cm47CiAgICAgfQpAQCAtNzI2LDggKzcyNSw3IEBA IHZvaWQgUGFnZTo6c2V0UGFnZVNjYWxlRmFjdG9yKGZsb2F0IHNjYWxlLCBjb25zdCBJbnRQb2lu dCYgb3JpZ2luKQogICAgICAgICBpZiAoIW1fc2V0dGluZ3MtPmRlbGVnYXRlc1BhZ2VTY2FsaW5n KCkgJiYgZG9jdW1lbnQtPnJlbmRlclZpZXcoKSAmJiBkb2N1bWVudC0+cmVuZGVyVmlldygpLT5u ZWVkc0xheW91dCgpICYmIHZpZXctPmRpZEZpcnN0TGF5b3V0KCkpCiAgICAgICAgICAgICB2aWV3 LT5sYXlvdXQoKTsKICAgICAgICAgCi0gICAgICAgIGlmICghdmlldy0+ZGVsZWdhdGVzU2Nyb2xs aW5nKCkpCi0gICAgICAgICAgICB2aWV3LT5zZXRTY3JvbGxQb3NpdGlvbihvcmlnaW4pOworICAg ICAgICB2aWV3LT5zZXRTY3JvbGxQb3NpdGlvbihvcmlnaW4pOwogICAgIH0KIH0KIApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvUGFnZVZp ZXdwb3J0Q29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0 ZWRHcmFwaGljcy9QYWdlVmlld3BvcnRDb250cm9sbGVyLmNwcAppbmRleCA3YjRiOTQ1MjIyZDMx NzNhYjgzYjQ4M2QyYTM4NmQ1MmU3ODdmN2Y2Li5lNmRmMDQxMDAwNzUyM2E4YTA2NGI1ZmE4MTMw NGYzMjI5MTliZTdiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRp bmF0ZWRHcmFwaGljcy9QYWdlVmlld3BvcnRDb250cm9sbGVyLmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9QYWdlVmlld3BvcnRDb250cm9sbGVy LmNwcApAQCAtMTg3LDE1ICsxODcsMTEgQEAgdm9pZCBQYWdlVmlld3BvcnRDb250cm9sbGVyOjpk aWRSZW5kZXJGcmFtZShjb25zdCBJbnRTaXplJiBjb250ZW50c1NpemUsIGNvbnN0IEkKIAogICAg IGlmIChtX3BlbmRpbmdTY2FsZUNoYW5nZSkgewogICAgICAgICBtX3BlbmRpbmdTY2FsZUNoYW5n ZSA9IGZhbHNlOwotICAgICAgICBtX2NsaWVudC0+c2V0UGFnZVNjYWxlRmFjdG9yKG1fcGFnZVNj YWxlRmFjdG9yKTsKLQogICAgICAgICAvLyBUaGUgc2NhbGUgY2hhbmdlZCwgd2UgaGF2ZSB0byBy ZS1waXhlbCBhbGlnbi4KICAgICAgICAgbV9wZW5kaW5nUG9zaXRpb25DaGFuZ2UgPSB0cnVlOwog ICAgICAgICBGbG9hdFBvaW50IGN1cnJlbnREaXNjcmV0ZVBvcyA9IHJvdW5kZWRJbnRQb2ludCht X2NvbnRlbnRzUG9zaXRpb24pOwogICAgICAgICBGbG9hdFBvaW50IHBpeGVsQWxpZ25lZFBvcyA9 IHBpeGVsQWxpZ25lZEZsb2F0UG9pbnQoY3VycmVudERpc2NyZXRlUG9zKTsKICAgICAgICAgbV9j b250ZW50c1Bvc2l0aW9uID0gYm91bmRDb250ZW50c1Bvc2l0aW9uKHBpeGVsQWxpZ25lZFBvcyk7 Ci0KLSAgICAgICAgbV93ZWJQYWdlUHJveHktPnNjYWxlUGFnZShtX3BhZ2VTY2FsZUZhY3Rvciwg cm91bmRlZEludFBvaW50KG1fY29udGVudHNQb3NpdGlvbikpOwogICAgIH0KIAogICAgIC8vIFRo ZXJlIG1pZ2h0IGJlIHJlbmRlcmVkIGZyYW1lcyBub3QgY292ZXJpbmcgb3VyIHJlcXVlc3RlZCBw b3NpdGlvbiB5ZXQsIHdhaXQgZm9yIGl0LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV2ViVmlldy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcAppbmRleCBhYjI3ZjQ5OGU3 MGY0NjcyZGQ4ODYyNGUzMGU5YWIwMmE2YjI1YWE3Li4xOTg1ZjhjODA4MWJkYWJlYmU2YzA1MDY3 OGU0NmNmMGNiYjAzZjNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29v cmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvQ29vcmRpbmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcApAQCAtMzY0LDYgKzM2NCw3IEBAIHZv aWQgV2ViVmlldzo6dG9vbFRpcENoYW5nZWQoY29uc3QgU3RyaW5nJiwgY29uc3QgU3RyaW5nJiBu ZXdUb29sVGlwKQogCiB2b2lkIFdlYlZpZXc6OmRpZENvbW1pdExvYWRGb3JNYWluRnJhbWUoY29u c3QgU3RyaW5nJiwgYm9vbCkKIHsKKyAgICBzZXRDb250ZW50UG9zaXRpb24oV2ViQ29yZTo6Rmxv YXRQb2ludCgpKTsKICAgICBtX2NvbnRlbnRzU2l6ZSA9IEludFNpemUoKTsKIH0KIApkaWZmIC0t Z2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDFhMWM3YmJiMjEw MTRkNWIxZWViOThlYzZmMzViM2ZlOWQ1M2VjNjIuLjVjZTc4OWZlMTY2Y2FjNzgxZGMzMTFhMmMx Mjg1ODY1ZjdmZDgxY2EgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxNC0wMy0yMCAgR3l1eW91bmcgS2ltICA8Z3l1 eW91bmcua2ltQHNhbXN1bmcuY29tPgorCisgICAgICAgIFtDb29yZGluYXRlZEdyYXBoaWNzXVtX SzJdIFNjYWxlIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIGlzIG5vdCBiZWluZyByZXN0b3Jl ZCBwcm9wZXJseSBpbiBhIGJhY2svZm9yd2FyZCBsb2FkCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMjYwMjIKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBPcmlnaW5hbCBhdXRob3IgOiBUaGlhZ28gZGUgQmFy cm9zIExhY2VyZGEsIGFuZCBmaW5pc2hlZCBieSBHeXV5b3VuZyBLaW0uCisKKyAgICAgICAgV2hl biB1c2VyIGlzIG5hdmlnYXRpbmcgYmFjay9mb3J3YXJkIHRvIGEgcGFnZSB0aGF0IGhhcyBiZWVu IHNjcm9sbGVkIGFuZC9vciBzY2FsZWQsIHRoYXQgcGFnZSBtdXN0IGJlIHNob3duCisgICAgICAg IHdpdGggaXRzIGxhc3Qgc2Nyb2xsIHBvc2l0aW9uIGFuZCBzY2FsZSBmYWN0b3IuCisgICAgICAg IEhvd2V2ZXIsIHdoZW4gZml4ZWQgbGF5b3V0IHdhcyBlbmFibGVkIHdpdGggQ29vcmRpbmF0ZWRH cmFwaGljcyBhbmQgVElMRURfQkFDS0lOR19TVE9SRSwKKyAgICAgICAgRnJhbWVWaWV3OjpzZXRW aWV3V2FzU2Nyb2xsZWRCeVVzZXIgd2FzIGJlaW5nIGNhbGxlZCBiZXR3ZWVuIEZyYW1lVmlldzo6 cmVzZXQgYW5kCisgICAgICAgIEhpc3RvcnlDb250cm9sbGVyOjpyZXN0b3JlU2Nyb2xsUG9zaXRp b25BbmRWaWV3U3RhdGUsIGNhdXNpbmcgdGhlIHRoZSBXZWJDb3JlOjpQYWdlIHRvIGRvIG5vdCBn ZXQgaXRzIHNjYWxlCisgICAgICAgIGZhY3RvciBhbmQgc2Nyb2xsIHBvc2l0aW9uIHRvIGJlIHJl c3RvcmVkLgorICAgICAgICBOb3dhZGF5cyB0aGUgb25seSBwb3J0IHRoYXQgdXNlIENvb3JkaW5h dGVkR3JhcGhpY3MgYW5kIFRJTEVEX0JBQ0tJTkdfU1RPUkUgaXMgRUZMIHBvcnQoVW5mb3J0dW5h dGVseSwgbml4CisgICAgICAgIHBvcnQgd2FzIGRyb3BwZWQuKS4KKworICAgICAgICBBbHNvLCB3 aGVuIGEgdXNlciB3YXMgdXNpbmcgdGhlIFdLVmlldyBBUEkgdG8gc2V0IHRoZSBzY2FsZSBmYWN0 b3IgKFdLVmlld1NldENvbnRlbnRTY2FsZUZhY3RvcikgdGhpcyBzY2FsZSB3YXMKKyAgICAgICAg bm90IGJlaW5nIGZvcndhcmRlZCB0byBXZWJDb3JlLgorICAgICAgICBUaGVuLCB3aGVuIGdvaW5n IGJhY2svZm9yd2FyZCB0byBhIHBhZ2UgSGlzdG9yeUNvbnRyb2xsZXIgd2FzIG5vdCBrbm93aW5n IGFib3V0IGl0cyByZWFsIHNjYWxlIGZhY3Rvci4KKworICAgICAgICBBIFdlYktpdEFQSSB0ZXN0 IGlzIGJlaW5nIGFkZGVkIHRvIHZhbGlkYXRlIHRoaXMgYmVoYXZpb3VyLgorCisgICAgICAgICog VGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNj cm9sbEJhY2tGb3J3YXJkLmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpkaWRG aW5pc2hMb2FkRm9yRnJhbWUpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6ZGlkQ2hhbmdlQ29u dGVudHNQb3NpdGlvbik6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKyAgICAgICAg KiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9y d2FyZDEuaHRtbDogQWRkZWQuCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy L0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyLmh0bWw6IEFkZGVkLgorCiAyMDE0LTAz LTE5ICBTaW1vbiBGcmFzZXIgIDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIEV4 cG9zZSB0ZXh0IGFuZCBwYWdlIHpvb20gaW4gV0syIFNQSSwgYW5kIGhvb2sgdGhlbSB1cCBpbiBN aW5pQnJvd3NlcgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5j bWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggODE1M2Y3 ZjU2OWUxNjJkYzFkZjlmNzEwNjcxYWEzOWNlNzA4YmEwOS4uZjI4M2ZmOTIwN2JjYWU5OWViNjAz NzU4YjlkYTVhYjdjNWY0ZDVhMyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0 Zm9ybUVmbC5jbWFrZQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtl CkBAIC05OCw2ICs5OCw3IEBAIHNldCh0ZXN0X3dlYmtpdDJfYXBpX0JJTkFSSUVTCiAgICAgV2ls bExvYWQKICAgICBXaWxsU2VuZFN1Ym1pdEV2ZW50CiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9X S1ZpZXdJc0FjdGl2ZVNldElzQWN0aXZlCisgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdS ZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tGb3J3YXJkCiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9X S1ZpZXdVc2VyVmlld3BvcnRUb0NvbnRlbnRzCiAgICAgZWZsL1dLVmlld0NsaWVudFdlYlByb2Nl c3NDYWxsYmFja3MKICkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0Zv cndhcmQuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVk R3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHAKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uNzk1ZDRhNjA1YWM4MGMyMDgyOWY3ZTBhNDNjZDJlYWRlNjYyMjdlMAotLS0gL2Rldi9u dWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdy YXBoaWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwCkBAIC0wLDAg KzEsMTg1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyLTIwMTMgTm9raWEgQ29ycG9yYXRp b24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIGBgQVMgSVMnJyBBTkQg QU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiAgSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVCBIT0xERVJTIE9SCisgKiBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BF Q0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZp Zy5oIgorCisjaW5jbHVkZSAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNpbmNsdWRlIDxXZWJLaXQy L1dLQ29udGV4dC5oPgorI2luY2x1ZGUgPFdlYktpdDIvV0tHZW9tZXRyeS5oPgorI2luY2x1ZGUg PFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KKyNpbmNsdWRlICJUZXN0LmgiCisKK25hbWVzcGFjZSBU ZXN0V2ViS2l0QVBJIHsKKworc3RhdGljIGJvb2wgZmluaXNoZWRMb2FkID0gZmFsc2U7CitzdGF0 aWMgYm9vbCBzY3JvbGwgPSBmYWxzZTsKKworc3RhdGljIHZvaWQgZGlkRmluaXNoTG9hZEZvckZy YW1lKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBlUmVmLCBjb25zdCB2b2lkKikKK3sKKyAg ICBmaW5pc2hlZExvYWQgPSB0cnVlOworfQorCitzdGF0aWMgdm9pZCBkaWRDaGFuZ2VDb250ZW50 c1Bvc2l0aW9uKFdLVmlld1JlZiwgV0tQb2ludCBwLCBjb25zdCB2b2lkKikKK3sKKyAgICBzY3Jv bGwgPSB0cnVlOworfQorCitURVNUKFdlYktpdDIsIEJhY2tGb3J3YXJkKQoreworICAgIGNvbnN0 IFdLU2l6ZSBzaXplID0gV0tTaXplTWFrZSg4MDAsIDYwMCk7CisKKyAgICBXS1JldGFpblB0cjxX S0NvbnRleHRSZWY+IGNvbnRleHQgPSBhZG9wdFdLKFdLQ29udGV4dENyZWF0ZSgpKTsKKyAgICBX S1JldGFpblB0cjxXS1ZpZXdSZWY+IHZpZXcoQWRvcHRXSywgV0tWaWV3Q3JlYXRlKGNvbnRleHQu Z2V0KCksIDApKTsKKworICAgIFdLVmlld0luaXRpYWxpemUodmlldy5nZXQoKSk7CisgICAgV0tW aWV3U2V0U2l6ZSh2aWV3LmdldCgpLCBzaXplKTsKKworICAgIFdLUGFnZVJlZiBwYWdlUmVmID0g V0tWaWV3R2V0UGFnZSh2aWV3LmdldCgpKTsKKyAgICBXS1BhZ2VTZXRVc2VGaXhlZExheW91dChw YWdlUmVmLCB0cnVlKTsKKyAgICBBU1NFUlRfVFJVRShwYWdlUmVmKTsKKworICAgIFdLUGFnZUxv YWRlckNsaWVudFYzIGxvYWRlckNsaWVudDsKKyAgICBtZW1zZXQoJmxvYWRlckNsaWVudCwgMCwg c2l6ZW9mKGxvYWRlckNsaWVudCkpOworICAgIGxvYWRlckNsaWVudC5iYXNlLnZlcnNpb24gPSAz OworICAgIGxvYWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJhbWUgPSBkaWRGaW5pc2hMb2Fk Rm9yRnJhbWU7CisgICAgV0tQYWdlU2V0UGFnZUxvYWRlckNsaWVudChwYWdlUmVmLCAmbG9hZGVy Q2xpZW50LmJhc2UpOworCisgICAgV0tWaWV3Q2xpZW50VjAgdmlld0NsaWVudDsKKyAgICBtZW1z ZXQoJnZpZXdDbGllbnQsIDAsIHNpemVvZih2aWV3Q2xpZW50KSk7CisgICAgdmlld0NsaWVudC5i YXNlLnZlcnNpb24gPSAwOworICAgIHZpZXdDbGllbnQuZGlkQ2hhbmdlQ29udGVudHNQb3NpdGlv biA9IGRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb247CisgICAgV0tWaWV3U2V0Vmlld0NsaWVudCh2 aWV3LmdldCgpLCAmdmlld0NsaWVudC5iYXNlKTsKKworICAgIFdLUmV0YWluUHRyPFdLVVJMUmVm PiB1cmwgPSBhZG9wdFdLKFV0aWw6OmNyZWF0ZVVSTEZvclJlc291cmNlKCJDb29yZGluYXRlZEdy YXBoaWNzL2JhY2tmb3J3YXJkMSIsICJodG1sIikpOworICAgIFdLUGFnZUxvYWRVUkwocGFnZVJl ZiwgdXJsLmdldCgpKTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisKKyAgICBmbG9h dCBuZXdTY2FsZSA9IDIuMDsKKyAgICBXS1BvaW50IHBvaW50ID0gV0tQb2ludE1ha2UoMTAsIDM1 MCk7CisgICAgV0tWaWV3U2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCksIHBvaW50KTsKKyAg ICBXS1ZpZXdTZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSwgbmV3U2NhbGUpOworICAg IGZsb2F0IHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOwor ICAgIFdLUG9pbnQgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZp ZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9F UShwb2ludC54LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNv bnRlbnRQb3NpdGlvbi55KTsKKworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIHVybCA9 IGFkb3B0V0soVXRpbDo6Y3JlYXRlVVJMRm9yUmVzb3VyY2UoIkNvb3JkaW5hdGVkR3JhcGhpY3Mv YmFja2ZvcndhcmQyIiwgImh0bWwiKSk7CisgICAgV0tQYWdlTG9hZFVSTChwYWdlUmVmLCB1cmwu Z2V0KCkpOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKworICAgIHNjYWxlID0gV0tW aWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlv biA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEo MSwgc2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQ RUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdLUGFnZUdvQmFjayhwYWdlUmVm KTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBV dGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAg c2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29u dGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAg IEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVDVF9FUShwb2ludC54LCBjb250 ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50LnksIGNvbnRlbnRQb3NpdGlvbi55 KTsKKworICAgIFdLUGFnZUdvRm9yd2FyZChwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsK KyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7 CisgICAgVXRpbDo6cnVuKCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50 U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0 Q29udGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBzY2FsZSk7Cisg ICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoMCwgY29u dGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQYWdlR29CYWNrKHBhZ2VSZWYpOworICAgIHNjcm9s bCA9IGZhbHNlOworICAgIGZpbmlzaGVkTG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmlu aXNoZWRMb2FkKTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmll d0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24g PSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKG5l d1NjYWxlLCBzY2FsZSk7CisgICAgRVhQRUNUX0VRKHBvaW50LngsIGNvbnRlbnRQb3NpdGlvbi54 KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueSwgY29udGVudFBvc2l0aW9uLnkpOworCisgICAgV0tQ YWdlR29Gb3J3YXJkKHBhZ2VSZWYpOworICAgIHNjcm9sbCA9IGZhbHNlOworICAgIGZpbmlzaGVk TG9hZCA9IGZhbHNlOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBVdGlsOjpy dW4oJnNjcm9sbCk7CisKKyAgICBzY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2 aWV3LmdldCgpKTsKKyAgICBjb250ZW50UG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRp b24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKDEsIHNjYWxlKTsKKyAgICBFWFBFQ1RfRVEo MCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9zaXRpb24u eSk7CisKKyAgICBXS1BhZ2VHb0JhY2socGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7Cisg ICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOwor ICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNj YWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENv bnRlbnRQb3NpdGlvbih2aWV3LmdldCgpKTsKKyAgICBFWFBFQ1RfRVEobmV3U2NhbGUsIHNjYWxl KTsKKyAgICBFWFBFQ1RfRVEocG9pbnQueCwgY29udGVudFBvc2l0aW9uLngpOworICAgIEVYUEVD VF9FUShwb2ludC55LCBjb250ZW50UG9zaXRpb24ueSk7CisKKyAgICBXS1BhZ2VHb0ZvcndhcmQo cGFnZVJlZik7CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7 CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsK KworICAgIHNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOwor ICAgIGNvbnRlbnRQb3NpdGlvbiA9IFdLVmlld0dldENvbnRlbnRQb3NpdGlvbih2aWV3LmdldCgp KTsKKyAgICBFWFBFQ1RfRVEoMSwgc2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjb250ZW50UG9z aXRpb24ueCk7CisgICAgRVhQRUNUX0VRKDAsIGNvbnRlbnRQb3NpdGlvbi55KTsKKworICAgIFdL UGFnZUdvQmFjayhwYWdlUmVmKTsKKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExv YWQgPSBmYWxzZTsKKyAgICBVdGlsOjpydW4oJmZpbmlzaGVkTG9hZCk7CisgICAgVXRpbDo6cnVu KCZzY3JvbGwpOworCisgICAgc2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmll dy5nZXQoKSk7CisgICAgY29udGVudFBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9u KHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUShuZXdTY2FsZSwgc2NhbGUpOworICAgIEVYUEVD VF9FUShwb2ludC54LCBjb250ZW50UG9zaXRpb24ueCk7CisgICAgRVhQRUNUX0VRKHBvaW50Lnks IGNvbnRlbnRQb3NpdGlvbi55KTsKK30KKworfSAvLyBUZXN0V2ViS2l0QVBJCmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9i YWNrZm9yd2FyZDEuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29y ZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmFhOWFjOGVjMjhl ZTRlYTAzMjM1N2ZjNjRlNDlmZjAyYjEyYWJkODgKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2Fy ZDEuaHRtbApAQCAtMCwwICsxLDMgQEAKKzxib2R5IHN0eWxlPSJ3aWR0aDoxMDAlOyBoZWlnaHQ6 MTAwJSI+CisgICAgPGRpdiBzdHlsZT0icG9zaXRpb246IGFic29sdXRlOyB0b3A6IDA7IGxlZnQ6 IDA7IHdpZHRoOiA5MDBweDsgaGVpZ2h0OiAxMjAwcHg7Ij48L2Rpdj4KKzwvYm9keT4KZGlmZiAt LWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBo aWNzL2JhY2tmb3J3YXJkMi5odG1sIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy L0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQyLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMzgwNmI5 ZDMyZWM0ZGUzOTg2MWYyZjc3MmEyMTkyMThlZWE5YzY3NQotLS0gL2Rldi9udWxsCisrKyBiL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tm b3J3YXJkMi5odG1sCkBAIC0wLDAgKzEgQEAKKzxib2R5IHN0eWxlPSJ3aWR0aDoxMDAlOyBoZWln aHQ6MTAwJSIvPgo= 230159 2014-04-25 03:19:10 -0700 2014-04-30 07:04:30 -0700 Patch bug-126022-20140425191847.patch text/plain 12834 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTY3NzQyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWY0MDZlODJmMWEyOTMx MjAyYzU2NjMyYjhmNTZiMjRkNWRkZTIzYi4uNzc3MjJiYzZiZGNmODRmNjFmNDg4OWEyNzdjYTNi NDgwM2FhYWMyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDE0LTA0LTI0ICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CisKKyAgICAgICAgW0Nvb3JkaW5h dGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUgZmFjdG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90 IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5IGluIGEgYmFjay9mb3J3YXJkIGxvYWQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyNjAyMgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsIGF1dGhvciA6 IFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSwgYW5kIGZpbmlzaGVkIGJ5IEd5dXlvdW5nIEtpbS4K KworICAgICAgICBXaGVuIHVzZXIgaXMgbmF2aWdhdGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdl IHRoYXQgaGFzIGJlZW4gc2Nyb2xsZWQgYW5kL29yIHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUg c2hvd24KKyAgICAgICAgd2l0aCBpdHMgbGFzdCBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZh Y3Rvci4gSG93ZXZlciwgd2hlbiBmaXhlZCBsYXlvdXQgd2FzIGVuYWJsZWQgd2l0aCBDb29yZGlu YXRlZEdyYXBoaWNzCisgICAgICAgIGFuZCBUSUxFRF9CQUNLSU5HX1NUT1JFLCBQYWdlOjpzZXRQ YWdlU2NhbGVGYWN0b3IoKSBkb2Vzbid0IHNlbmQgcHJldmlvdXMgc2Nyb2xsIHBvc2l0aW9uIHNp bmNlIHIxNjU2NTIgYW5kIHIxNjU5MTMuCisKKyAgICAgICAgVGhpcyBwYXRjaCBhbGxvd3MgdGhl IFBhZ2U6OnNldFBhZ2VTY2FsZUZhY3RvcigpIHNlbmQgc3RvcmVkIHBvc2l0aW9uIHRvIFdLMiBp bXBsZW1lbnRhdGlvbi4KKworICAgICAgICAqIHBhZ2UvUGFnZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpQYWdlOjpzZXRQYWdlU2NhbGVGYWN0b3IpOiBUSUxFRF9CQUNLSU5HX1NUT1JFIGlzIGVu YWJsZWQsIHdlIHBhc3MgbmV3IHNjcm9sbCBwb3NpdGlvbiB0byBXSzIgdGhvdWdoCisgICAgICAg IGRlbGVnYXRlU2Nyb2xsaW5nIGlzIGRpc2FibGVkLgorCiAyMDE0LTA0LTIzICBBbmRyZWFzIEts aW5nICA8YWtsaW5nQGFwcGxlLmNvbT4KIAogICAgICAgICBDYW52YXMgY2FjaGUgb2YgY2xlYW4g VVJMcyBjYW4gZ3JvdyB3aXRob3V0IGJvdW5kcy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCAzY2FmNTYzODQwNjUw ZWVmMzVjNDQxMjEyNTg1ZDI4MjQyZjAyYmQ3Li5lMGVlMzJhMmYxYjZlYzhiMTZiNGU4NzdjMDY1 OTEzM2ZmYjEwOGQ1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIv U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTQtMDQtMjQgIEd5 dXlvdW5nIEtpbSAgPGd5dXlvdW5nLmtpbUBzYW1zdW5nLmNvbT4KKworICAgICAgICBbQ29vcmRp bmF0ZWRHcmFwaGljc11bV0syXSBTY2FsZSBmYWN0b3IgYW5kIHNjcm9sbCBwb3NpdGlvbiBpcyBu b3QgYmVpbmcgcmVzdG9yZWQgcHJvcGVybHkgaW4gYSBiYWNrL2ZvcndhcmQgbG9hZAorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTI2MDIyCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgT3JpZ2luYWwgYXV0aG9y IDogVGhpYWdvIGRlIEJhcnJvcyBMYWNlcmRhLCBhbmQgZmluaXNoZWQgYnkgR3l1eW91bmcgS2lt LgorCisgICAgICAgIFdoZW4gdXNlciBpcyBuYXZpZ2F0aW5nIGJhY2svZm9yd2FyZCB0byBhIHBh Z2UgdGhhdCBoYXMgYmVlbiBzY3JvbGxlZCBhbmQvb3Igc2NhbGVkLCB0aGF0IHBhZ2UgbXVzdCBi ZSBzaG93bgorICAgICAgICB3aXRoIGl0cyBsYXN0IHNjcm9sbCBwb3NpdGlvbiBhbmQgc2NhbGUg ZmFjdG9yLiBIb3dldmVyLCB3aGVuIGZpeGVkIGxheW91dCB3YXMgZW5hYmxlZCB3aXRoIENvb3Jk aW5hdGVkR3JhcGhpY3MKKyAgICAgICAgYW5kIFRJTEVEX0JBQ0tJTkdfU1RPUkUsIFBhZ2U6OnNl dFBhZ2VTY2FsZUZhY3RvcigpIGRvZXNuJ3Qgc2VuZCBwcmV2aW91cyBzY3JvbGwgcG9zaXRpb24g c2luY2UgcjE2NTY1MiBhbmQgcjE2NTkxMy4KKworICAgICAgICBUaGlzIHBhdGNoIGFsbG93cyB0 aGUgUGFnZTo6c2V0UGFnZVNjYWxlRmFjdG9yKCkgc2VuZCBzdG9yZWQgcG9zaXRpb24gdG8gV0sy IGltcGxlbWVudGF0aW9uLgorCisgICAgICAgICogVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhp Y3MvV2ViVmlldy5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXc6OmRpZENvbW1pdExvYWRG b3JNYWluRnJhbWUpOgorCiAyMDE0LTA0LTIzICBBbmRyZWFzIEtsaW5nICA8YWtsaW5nQGFwcGxl LmNvbT4KIAogICAgICAgICBSZW1vdmUgdW51c2VkIFdLUGFnZVNldE1lbW9yeUNhY2hlQ2xpZW50 Q2FsbHNFbmFibGVkIEFQSS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCmluZGV4IGM5MzVjMGI0NDU3NzI0ZWYy ZDQxOTJhMjU2OTlhYTg3YzQ1NmUyMjUuLjkxOWY3MmY1Mzk3ZjY2ZTJkZGFmNjA4ZjVlMzU4OGIy ZTU3YzJmODkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcApAQCAtNzE0LDcgKzcxNCw5IEBAIHZvaWQgUGFn ZTo6c2V0UGFnZVNjYWxlRmFjdG9yKGZsb2F0IHNjYWxlLCBjb25zdCBJbnRQb2ludCYgb3JpZ2lu KQogICAgICAgICAgICAgaWYgKCFtX3NldHRpbmdzLT5kZWxlZ2F0ZXNQYWdlU2NhbGluZygpKQog ICAgICAgICAgICAgICAgIGRvY3VtZW50LT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVz aGVldHMoKTsKIAorI2lmICFVU0UoVElMRURfQkFDS0lOR19TVE9SRSkKICAgICAgICAgICAgIGlm ICghdmlldy0+ZGVsZWdhdGVzU2Nyb2xsaW5nKCkpCisjZW5kaWYKICAgICAgICAgICAgICAgICB2 aWV3LT5zZXRTY3JvbGxQb3NpdGlvbihvcmlnaW4pOwogICAgICAgICB9CiAgICAgICAgIHJldHVy bjsKQEAgLTc0MCw4ICs3NDIsOSBAQCB2b2lkIFBhZ2U6OnNldFBhZ2VTY2FsZUZhY3RvcihmbG9h dCBzY2FsZSwgY29uc3QgSW50UG9pbnQmIG9yaWdpbikKICAgICBpZiAodmlldyAmJiB2aWV3LT5z Y3JvbGxQb3NpdGlvbigpICE9IG9yaWdpbikgewogICAgICAgICBpZiAoIW1fc2V0dGluZ3MtPmRl bGVnYXRlc1BhZ2VTY2FsaW5nKCkgJiYgZG9jdW1lbnQtPnJlbmRlclZpZXcoKSAmJiBkb2N1bWVu dC0+cmVuZGVyVmlldygpLT5uZWVkc0xheW91dCgpICYmIHZpZXctPmRpZEZpcnN0TGF5b3V0KCkp CiAgICAgICAgICAgICB2aWV3LT5sYXlvdXQoKTsKLSAgICAgICAgCisjaWYgIVVTRShUSUxFRF9C QUNLSU5HX1NUT1JFKSAgICAgICAgCiAgICAgICAgIGlmICghdmlldy0+ZGVsZWdhdGVzU2Nyb2xs aW5nKCkpCisjZW5kaWYKICAgICAgICAgICAgIHZpZXctPnNldFNjcm9sbFBvc2l0aW9uKG9yaWdp bik7CiAgICAgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRp bmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29y ZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuY3BwCmluZGV4IDYxNDRhYmEyNGM3MTc4YzQ4N2JhMDBh NmYwYWYxZDIxZjE4NWI5NTQuLmQyM2U0OTZmYjU5NWY5NzhlZDc3YjNkZjdkMDgyYWFkNDNkYjRj NTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBo aWNzL1dlYlZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRl ZEdyYXBoaWNzL1dlYlZpZXcuY3BwCkBAIC0zNzIsNiArMzcyLDcgQEAgdm9pZCBXZWJWaWV3Ojp0 b29sVGlwQ2hhbmdlZChjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIG5ld1Rvb2xUaXApCiAK IHZvaWQgV2ViVmlldzo6ZGlkQ29tbWl0TG9hZEZvck1haW5GcmFtZShjb25zdCBTdHJpbmcmLCBi b29sKQogeworICAgIHNldENvbnRlbnRQb3NpdGlvbihXZWJDb3JlOjpGbG9hdFBvaW50KCkpOwog ICAgIG1fY29udGVudHNTaXplID0gSW50U2l6ZSgpOwogfQogCmRpZmYgLS1naXQgYS9Ub29scy9D aGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYzI3YmI1YmQ5MTA5Nzk3OThiZjgwMTU5 YzQ4NjdmMTQ2ZDRiNjkxMi4uOWFjZjFmNDA1ODA4YzBjMmQ2MjkxMDNhY2VhYzc0MDUzNjNhNjkz YyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAt MSwzICsxLDIyIEBACisyMDE0LTA0LTI0ICBHeXV5b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ft c3VuZy5jb20+CisKKyAgICAgICAgW0Nvb3JkaW5hdGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUgZmFj dG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5IGlu IGEgYmFjay9mb3J3YXJkIGxvYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTEyNjAyMgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIE9yaWdpbmFsIGF1dGhvciA6IFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSwg YW5kIGZpbmlzaGVkIGJ5IEd5dXlvdW5nIEtpbS4KKworICAgICAgICBBZGRlZCBhbiB1bml0IHRl c3QgY2FzZSB0byBjaGVjayBpZiBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGFyZSByZXN0b3Jl ZCBwcm9wZXJseS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21ha2U6 CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhp Y3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHA6IEFkZGVkLgorICAg ICAgICAoVGVzdFdlYktpdEFQSTo6ZGlkRmluaXNoTG9hZEZvckZyYW1lKToKKyAgICAgICAgKFRl c3RXZWJLaXRBUEk6OmRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb24pOgorICAgICAgICAoVGVzdFdl YktpdEFQSTo6VEVTVCk6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nv b3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQxLmh0bWw6IEFkZGVkLgorICAgICAgICAqIFRl c3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJk Mi5odG1sOiBBZGRlZC4KKwogMjAxNC0wNC0yMyAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FA YXBwbGUuY29tPgogCiAgICAgICAgIFRyeSB0byBmaXggaU9TIGJ1aWxkLgpkaWZmIC0tZ2l0IGEv VG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggODE1M2Y3ZjU2OWUxNjJkYzFkZjlmNzEwNjcxYWEz OWNlNzA4YmEwOS4uZjI4M2ZmOTIwN2JjYWU5OWViNjAzNzU4YjlkYTVhYjdjNWY0ZDVhMyAxMDA2 NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQorKysgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC05OCw2ICs5OCw3IEBAIHNldCh0 ZXN0X3dlYmtpdDJfYXBpX0JJTkFSSUVTCiAgICAgV2lsbExvYWQKICAgICBXaWxsU2VuZFN1Ym1p dEV2ZW50CiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdJc0FjdGl2ZVNldElzQWN0aXZl CisgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tG b3J3YXJkCiAgICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdVc2VyVmlld3BvcnRUb0NvbnRl bnRzCiAgICAgZWZsL1dLVmlld0NsaWVudFdlYlByb2Nlc3NDYWxsYmFja3MKICkKZGlmZiAtLWdp dCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNz L1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwIGIvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpv b21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZjIwOGFkN2RkYTg4Yzc3YjY2 NDMyMzMwYTQ1NDQ5YTljNmRmNGFjMwotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29t QW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwCkBAIC0wLDAgKzEsMTI5IEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDEyLTIwMTMgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5 KC1pZXMpLgorICogQ29weXJpZ2h0IChDKSAyMDExIFNhbXN1bmcgRWxlY3Ryb25pY3MuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF CisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBT SEFMTCBUSEUgQ09QWVJJR0hUIEhPTERFUlMgT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRl ICJld2tfdmlld19wcml2YXRlLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNp bmNsdWRlICJQbGF0Zm9ybVdlYlZpZXcuaCIKKyNpbmNsdWRlIDxXZWJLaXQyL1dLQ29udGV4dC5o PgorI2luY2x1ZGUgPFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KKyNpbmNsdWRlICJUZXN0LmgiCisK K25hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKKworc3RhdGljIGJvb2wgZmluaXNoZWRMb2FkID0g ZmFsc2U7CitzdGF0aWMgYm9vbCBzY3JvbGwgPSBmYWxzZTsKKworc3RhdGljIHZvaWQgZGlkRmlu aXNoTG9hZEZvckZyYW1lKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBlUmVmLCBjb25zdCB2 b2lkKikKK3sKKyAgICBmaW5pc2hlZExvYWQgPSB0cnVlOworfQorCitzdGF0aWMgdm9pZCBkaWRD aGFuZ2VDb250ZW50c1Bvc2l0aW9uKFdLVmlld1JlZiwgV0tQb2ludCBwLCBjb25zdCB2b2lkKikK K3sKKyAgICBzY3JvbGwgPSB0cnVlOworfQorCitURVNUKFdlYktpdDIsIFdLVmlld1Jlc3RvcmVa b29tQW5kU2Nyb2xsQmFja0ZvcndhcmQpCit7CisgICAgV0tSZXRhaW5QdHI8V0tDb250ZXh0UmVm PiBjb250ZXh0KEFkb3B0V0ssIFdLQ29udGV4dENyZWF0ZSgpKTsKKyAgICBQbGF0Zm9ybVdlYlZp ZXcgd2ViVmlldyhjb250ZXh0LmdldCgpKTsKKyAgICBXS1JldGFpblB0cjxXS1ZpZXdSZWY+IHZp ZXcgPSBFV0tWaWV3R2V0V0tWaWV3KHdlYlZpZXcucGxhdGZvcm1WaWV3KCkpOworCisgICAgV0tQ YWdlU2V0VXNlRml4ZWRMYXlvdXQod2ViVmlldy5wYWdlKCksIHRydWUpOworCisgICAgV0tQYWdl TG9hZGVyQ2xpZW50VjAgbG9hZGVyQ2xpZW50OworICAgIG1lbXNldCgmbG9hZGVyQ2xpZW50LCAw LCBzaXplb2YobG9hZGVyQ2xpZW50KSk7CisgICAgbG9hZGVyQ2xpZW50LmJhc2UudmVyc2lvbiA9 IDA7CisgICAgbG9hZGVyQ2xpZW50LmRpZEZpbmlzaExvYWRGb3JGcmFtZSA9IGRpZEZpbmlzaExv YWRGb3JGcmFtZTsKKyAgICBXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KHdlYlZpZXcucGFnZSgp LCAmbG9hZGVyQ2xpZW50LmJhc2UpOworCisgICAgV0tWaWV3Q2xpZW50VjAgdmlld0NsaWVudDsK KyAgICBtZW1zZXQoJnZpZXdDbGllbnQsIDAsIHNpemVvZih2aWV3Q2xpZW50KSk7CisgICAgdmll d0NsaWVudC5iYXNlLnZlcnNpb24gPSAwOworICAgIHZpZXdDbGllbnQuZGlkQ2hhbmdlQ29udGVu dHNQb3NpdGlvbiA9IGRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb247CisgICAgV0tWaWV3U2V0Vmll d0NsaWVudCh2aWV3LmdldCgpLCAmdmlld0NsaWVudC5iYXNlKTsKKworICAgIC8vIExvYWQgZmly c3QgcGFnZS4KKyAgICBXS1JldGFpblB0cjxXS1VSTFJlZj4gdXJsKEFkb3B0V0ssIFV0aWw6OmNy ZWF0ZVVSTEZvclJlc291cmNlKCJDb29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMSIsICJo dG1sIikpOworICAgIFdLUGFnZUxvYWRVUkwod2ViVmlldy5wYWdlKCksIHVybC5nZXQoKSk7Cisg ICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworCisgICAgLy8gQ2hhbmdlIHNjYWxlIGFuZCBw b3NpdGlvbiBvbiBmaXJzdCBwYWdlLgorICAgIGZsb2F0IGZpcnN0UGFnZVNjYWxlID0gMi4wOwor ICAgIFdLUG9pbnQgZmlyc3RQYWdlU2Nyb2xsUG9zaXRpb24gPSBXS1BvaW50TWFrZSgxMCwgMzUw KTsgLy8gU2Nyb2xsIHBvc2l0aW9uIG9mIGZpcnN0IHBhZ2UuCisgICAgV0tWaWV3U2V0Q29udGVu dFBvc2l0aW9uKHZpZXcuZ2V0KCksIGZpcnN0UGFnZVNjcm9sbFBvc2l0aW9uKTsKKyAgICBXS1Zp ZXdTZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSwgZmlyc3RQYWdlU2NhbGUpOworICAg IGZsb2F0IGN1cnJlbnRQYWdlU2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmll dy5nZXQoKSk7CisgICAgV0tQb2ludCBjdXJyZW50UGFnZVBvc2l0aW9uID0gV0tWaWV3R2V0Q29u dGVudFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKyAgICBF WFBFQ1RfRVEoZmlyc3RQYWdlU2NhbGUsIGN1cnJlbnRQYWdlU2NhbGUpOworICAgIEVYUEVDVF9F UShmaXJzdFBhZ2VTY3JvbGxQb3NpdGlvbi54LCBjdXJyZW50UGFnZVBvc2l0aW9uLngpOworICAg IEVYUEVDVF9FUShmaXJzdFBhZ2VTY3JvbGxQb3NpdGlvbi55LCBjdXJyZW50UGFnZVBvc2l0aW9u LnkpOworCisgICAgLy8gTG9hZCBzZWNvbmQgcGFnZS4KKyAgICBmaW5pc2hlZExvYWQgPSBmYWxz ZTsKKyAgICB1cmwgPSBhZG9wdFdLKFV0aWw6OmNyZWF0ZVVSTEZvclJlc291cmNlKCJDb29yZGlu YXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMiIsICJodG1sIikpOworICAgIFdLUGFnZUxvYWRVUkwo d2ViVmlldy5wYWdlKCksIHVybC5nZXQoKSk7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQp OworCisgICAgLy8gQ2hlY2sgaWYgc2Vjb25kIHBhZ2Ugc2NhbGUgYW5kIHBvc2l0aW9uIGlzIGNv cnJlY3QuCisgICAgY3VycmVudFBhZ2VTY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rv cih2aWV3LmdldCgpKTsKKyAgICBjdXJyZW50UGFnZVBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVu dFBvc2l0aW9uKHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBjdXJyZW50UGFnZVNjYWxl KTsKKyAgICBFWFBFQ1RfRVEoMCwgY3VycmVudFBhZ2VQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1Rf RVEoMCwgY3VycmVudFBhZ2VQb3NpdGlvbi55KTsKKworICAgIC8vIEdvIGJhY2sgZmlyc3QgcGFn ZS4KKyAgICBzY3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBX S1BhZ2VHb0JhY2sod2ViVmlldy5wYWdlKCkpOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2Fk KTsKKyAgICBVdGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICAvLyBDaGVjayBpZiBzY3JvbGwgcG9z aXRpb24gYW5kIHNjYWxlIG9mIGZpcnN0IHBhZ2UgYXJlIHJlc3RvcmVkIGNvcnJlY3RseS4KKyAg ICBjdXJyZW50UGFnZVNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0 KCkpOworICAgIGN1cnJlbnRQYWdlUG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24o dmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VRKGZpcnN0UGFnZVNjYWxlLCBjdXJyZW50UGFnZVNj YWxlKTsKKyAgICBFWFBFQ1RfRVEoZmlyc3RQYWdlU2Nyb2xsUG9zaXRpb24ueCwgY3VycmVudFBh Z2VQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoZmlyc3RQYWdlU2Nyb2xsUG9zaXRpb24ueSwg Y3VycmVudFBhZ2VQb3NpdGlvbi55KTsKKworICAgIC8vIEdvIHRvIHNlY29uZCBwYWdlIGFnYWlu LgorICAgIFdLUGFnZUdvRm9yd2FyZCh3ZWJWaWV3LnBhZ2UoKSk7CisgICAgc2Nyb2xsID0gZmFs c2U7CisgICAgZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExv YWQpOworCisgICAgLy8gQ2hlY2sgaWYgdGhlIHNjcm9sbCBwb3NpdGlvbiBhbmQgc2NhbGUgb2Yg c2Vjb25kIHBhZ2UgYXJlIHJlc3RvcmVkIGNvcnJlY3RseS4KKyAgICBjdXJyZW50UGFnZVNjYWxl ID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGN1cnJlbnRQ YWdlUG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAg RVhQRUNUX0VRKDEsIGN1cnJlbnRQYWdlU2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjdXJyZW50 UGFnZVBvc2l0aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBjdXJyZW50UGFnZVBvc2l0aW9uLnkp OworfQorCit9IC8vIFRlc3RXZWJLaXRBUEkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sIGIv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFj a2ZvcndhcmQxLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOThjMWMxMDdjZjYyOWE2YjQ3NTUwM2Y3N2JlMjUw MGNjZDFmNGE3ZQotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sCkBAIC0wLDAgKzEs NSBAQAorPGh0bWw+Cis8Ym9keSBzdHlsZT0id2lkdGg6MTAwJTsgaGVpZ2h0OjEwMCUiPgorICAg IDxkaXYgc3R5bGU9InBvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiAwOyBsZWZ0OiAwOyB3aWR0aDog OTAwcHg7IGhlaWdodDogMTIwMHB4OyI+PC9kaXY+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1n aXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGlj cy9iYWNrZm9yd2FyZDIuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9D b29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM4MDZiOWQz MmVjNGRlMzk4NjFmMmY3NzJhMjE5MjE4ZWVhOWM2NzUKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9y d2FyZDIuaHRtbApAQCAtMCwwICsxIEBACis8Ym9keSBzdHlsZT0id2lkdGg6MTAwJTsgaGVpZ2h0 OjEwMCUiLz4K 230477 2014-04-30 07:04:49 -0700 2014-05-07 18:42:46 -0700 Patch bug-126022-20140430230425.patch text/plain 13737 gyuyoung.kim U3VidmVyc2lvbiBSZXZpc2lvbjogMTY3OTkzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzJiZDA1OWFlYTZlNDRi NTc4OGUzMjFmNGJiOTQwZTY2ODNjZjdjZC4uYWY3NThiZTc3YTcxYTdhMzFmZGE2YjE2YWRkZjMy NTg5NGI4Mjk0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDE0LTA0LTMwICBHeXV5 b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ftc3VuZy5jb20+CisKKyAgICAgICAgW0Nvb3JkaW5h dGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUgZmFjdG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90 IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5IGluIGEgYmFjay9mb3J3YXJkIGxvYWQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEyNjAyMgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsIGF1dGhvciA6 IFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSwgYW5kIGZpbmlzaGVkIGJ5IEd5dXlvdW5nIEtpbS4K KworICAgICAgICBXaGVuIHVzZXIgaXMgbmF2aWdhdGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdl IHRoYXQgaGFzIGJlZW4gc2Nyb2xsZWQgYW5kL29yIHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUg c2hvd24KKyAgICAgICAgd2l0aCBpdHMgbGFzdCBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZh Y3Rvci4gSG93ZXZlciwgd2hlbiBmaXhlZCBsYXlvdXQgd2FzIGVuYWJsZWQgd2l0aCBDb29yZGlu YXRlZEdyYXBoaWNzCisgICAgICAgIGFuZCBUSUxFRF9CQUNLSU5HX1NUT1JFLCBQYWdlOjpzZXRQ YWdlU2NhbGVGYWN0b3IoKSBkb2Vzbid0IHNlbmQgcHJldmlvdXMgc2Nyb2xsIHBvc2l0aW9uIHNp bmNlIHIxNjU2NTIgYW5kIHIxNjU5MTMuCisKKyAgICAgICAgVGhpcyBwYXRjaCBhbGxvd3MgdGhl IFBhZ2U6OnNldFBhZ2VTY2FsZUZhY3RvcigpIHNlbmQgc3RvcmVkIHBvc2l0aW9uIHRvIFdLMiBp bXBsZW1lbnRhdGlvbiBieSBjYWxsaW5nIGRlbGVnYXRlZFNjcm9sbFJlcXVlc3RlZCgpCisgICAg ICAgIGRpcmVjdGx5IHdoZW4gZGVsZWdhdGVzU2Nyb2xsaW5nKCkgaXMgb24uCisKKyAgICAgICAg KiBwYWdlL1BhZ2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6c2V0UGFnZVNjYWxlRmFj dG9yKTogVElMRURfQkFDS0lOR19TVE9SRSBhbmQgZGVsZWdhdGVTY3JvbGxpbmcgYXJlIGVuYWJs ZWQsIHdlIHBhc3MgbmV3IHNjcm9sbCBwb3NpdGlvbiB0byBXSzIgdGhvdWdoCisgICAgICAgIGRl bGVnYXRlU2Nyb2xsaW5nIGlzIGRpc2FibGVkLgorICAgICAgICAqIHBsYXRmb3JtL1Njcm9sbFZp ZXcuY3BwOiBkZWxlZ2F0ZWRTY3JvbGxSZXF1ZXN0ZWQoKSBjYWxsIGlzIG1vdmVkIGZyb20gU2Ny b2xsVmlldzo6c2V0U2Nyb2xsUG9zaXRpb24oKSB0byBQYWdlOjpzZXRQYWdlU2NhbGVGYWN0b3Io KS4KKyAgICAgICAgKFdlYkNvcmU6OlNjcm9sbFZpZXc6OnNldFNjcm9sbFBvc2l0aW9uKTogCisK IDIwMTQtMDQtMzAgIE1hbnVlbCBSZWdvIENhc2Fzbm92YXMgIDxyZWdvQGlnYWxpYS5jb20+CiAK ICAgICAgICAgW0NTUyBHcmlkIExheW91dF0gRW5hYmxlIHJ1bnRpbWUgZmVhdHVyZSBieSBkZWZh dWx0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKaW5kZXggN2Q1YjAzNDY5ZWI2Yjc1YjE2ODFlMjFhMGFhYjYxOWE0Nzg5MWI4 Ny4uMDVjYjA1MmFlNDJhNDA4MTUzMDE4ZWQzMjgzMzNkZjRkYTZjZDIwZSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpA QCAtMSwzICsxLDIxIEBACisyMDE0LTA0LTMwICBHeXV5b3VuZyBLaW0gIDxneXV5b3VuZy5raW1A c2Ftc3VuZy5jb20+CisKKyAgICAgICAgW0Nvb3JkaW5hdGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUg ZmFjdG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5 IGluIGEgYmFjay9mb3J3YXJkIGxvYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTEyNjAyMgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIE9yaWdpbmFsIGF1dGhvciA6IFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJk YSwgYW5kIGZpbmlzaGVkIGJ5IEd5dXlvdW5nIEtpbS4KKworICAgICAgICBXaGVuIHVzZXIgaXMg bmF2aWdhdGluZyBiYWNrL2ZvcndhcmQgdG8gYSBwYWdlIHRoYXQgaGFzIGJlZW4gc2Nyb2xsZWQg YW5kL29yIHNjYWxlZCwgdGhhdCBwYWdlIG11c3QgYmUgc2hvd24KKyAgICAgICAgd2l0aCBpdHMg bGFzdCBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGZhY3Rvci4gSG93ZXZlciwgd2hlbiBmaXhl ZCBsYXlvdXQgd2FzIGVuYWJsZWQgd2l0aCBDb29yZGluYXRlZEdyYXBoaWNzCisgICAgICAgIGFu ZCBUSUxFRF9CQUNLSU5HX1NUT1JFLCBQYWdlOjpzZXRQYWdlU2NhbGVGYWN0b3IoKSBkb2Vzbid0 IHNlbmQgcHJldmlvdXMgc2Nyb2xsIHBvc2l0aW9uIHNpbmNlIHIxNjU2NTIgYW5kIHIxNjU5MTMu CisKKyAgICAgICAgVGhpcyBwYXRjaCBhbGxvd3MgdGhlIFBhZ2U6OnNldFBhZ2VTY2FsZUZhY3Rv cigpIHNlbmQgc3RvcmVkIHBvc2l0aW9uIHRvIFdLMiBpbXBsZW1lbnRhdGlvbi4KKworICAgICAg ICAqIFVJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJWaWV3OjpkaWRDb21taXRMb2FkRm9yTWFpbkZyYW1lKToKKwogMjAxNC0wNC0z MCAgTWFudWVsIFJlZ28gQ2FzYXNub3ZhcyAgPHJlZ29AaWdhbGlhLmNvbT4KIAogICAgICAgICBb Q1NTIEdyaWQgTGF5b3V0XSBFbmFibGUgcnVudGltZSBmZWF0dXJlIGJ5IGRlZmF1bHQKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdl L1BhZ2UuY3BwCmluZGV4IDVhZGZjMTRmNTk0MjJiZTI0Y2MyMDg0NWZhZGJlZDk1ZTdlZWFiYjUu LmY1ZmJmYjU3YjFiYjBkODJhNjYwYjE0NGE5NmEwYjEyODc3OTM1NjcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdl LmNwcApAQCAtNzE5LDYgKzcxOSwxMCBAQCB2b2lkIFBhZ2U6OnNldFBhZ2VTY2FsZUZhY3Rvcihm bG9hdCBzY2FsZSwgY29uc3QgSW50UG9pbnQmIG9yaWdpbikKIAogICAgICAgICAgICAgaWYgKCF2 aWV3LT5kZWxlZ2F0ZXNTY3JvbGxpbmcoKSkKICAgICAgICAgICAgICAgICB2aWV3LT5zZXRTY3Jv bGxQb3NpdGlvbihvcmlnaW4pOworI2lmIFVTRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorICAgICAg ICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHZpZXctPmhvc3RXaW5kb3coKS0+ZGVsZWdhdGVk U2Nyb2xsUmVxdWVzdGVkKG9yaWdpbik7CisjZW5kaWYKICAgICAgICAgfQogICAgICAgICByZXR1 cm47CiAgICAgfQpAQCAtNzQ2LDYgKzc1MCwxMCBAQCB2b2lkIFBhZ2U6OnNldFBhZ2VTY2FsZUZh Y3RvcihmbG9hdCBzY2FsZSwgY29uc3QgSW50UG9pbnQmIG9yaWdpbikKICAgICAgICAgCiAgICAg ICAgIGlmICghdmlldy0+ZGVsZWdhdGVzU2Nyb2xsaW5nKCkpCiAgICAgICAgICAgICB2aWV3LT5z ZXRTY3JvbGxQb3NpdGlvbihvcmlnaW4pOworI2lmIFVTRShUSUxFRF9CQUNLSU5HX1NUT1JFKQor ICAgICAgICBlbHNlCisgICAgICAgICAgICB2aWV3LT5ob3N0V2luZG93KCktPmRlbGVnYXRlZFNj cm9sbFJlcXVlc3RlZChvcmlnaW4pOworI2VuZGlmCiAgICAgfQogCiAjaWYgRU5BQkxFKE1FRElB X0NPTlRST0xTX1NDUklQVCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Nj cm9sbFZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Nyb2xsVmlldy5jcHAKaW5k ZXggYzAyMmQxMjk2ZGNmMDQwYzU4NTQ1YTg1NjIwMWVlMmMxMDk4NmY3Ny4uYjM2OGQyYmViNTAy MWY5ZmM5Y2M5NzdlZmE5NjJlYWQ1Yzc2Nzg2MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vU2Nyb2xsVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vU2Ny b2xsVmlldy5jcHAKQEAgLTQ5NywxMyArNDk3LDYgQEAgdm9pZCBTY3JvbGxWaWV3OjpzZXRTY3Jv bGxQb3NpdGlvbihjb25zdCBJbnRQb2ludCYgc2Nyb2xsUG9pbnQpCiAgICAgICAgIHJldHVybjsK ICAgICB9CiAKLSNpZiBVU0UoVElMRURfQkFDS0lOR19TVE9SRSkKLSAgICBpZiAoZGVsZWdhdGVz U2Nyb2xsaW5nKCkpIHsKLSAgICAgICAgaG9zdFdpbmRvdygpLT5kZWxlZ2F0ZWRTY3JvbGxSZXF1 ZXN0ZWQoc2Nyb2xsUG9pbnQpOwotICAgICAgICByZXR1cm47Ci0gICAgfQotI2VuZGlmCi0KICAg ICBJbnRQb2ludCBuZXdTY3JvbGxQb3NpdGlvbiA9IGFkanVzdFNjcm9sbFBvc2l0aW9uV2l0aGlu UmFuZ2Uoc2Nyb2xsUG9pbnQpOwogCiAgICAgaWYgKG5ld1Njcm9sbFBvc2l0aW9uID09IHNjcm9s bFBvc2l0aW9uKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQ29vcmRp bmF0ZWRHcmFwaGljcy9XZWJWaWV3LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29y ZGluYXRlZEdyYXBoaWNzL1dlYlZpZXcuY3BwCmluZGV4IDYxNDRhYmEyNGM3MTc4YzQ4N2JhMDBh NmYwYWYxZDIxZjE4NWI5NTQuLmQyM2U0OTZmYjU5NWY5NzhlZDc3YjNkZjdkMDgyYWFkNDNkYjRj NTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRlZEdyYXBo aWNzL1dlYlZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9Db29yZGluYXRl ZEdyYXBoaWNzL1dlYlZpZXcuY3BwCkBAIC0zNzIsNiArMzcyLDcgQEAgdm9pZCBXZWJWaWV3Ojp0 b29sVGlwQ2hhbmdlZChjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIG5ld1Rvb2xUaXApCiAK IHZvaWQgV2ViVmlldzo6ZGlkQ29tbWl0TG9hZEZvck1haW5GcmFtZShjb25zdCBTdHJpbmcmLCBi b29sKQogeworICAgIHNldENvbnRlbnRQb3NpdGlvbihXZWJDb3JlOjpGbG9hdFBvaW50KCkpOwog ICAgIG1fY29udGVudHNTaXplID0gSW50U2l6ZSgpOwogfQogCmRpZmYgLS1naXQgYS9Ub29scy9D aGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZjA2YzczOWJlYTg5ZTY2N2EwYWRiYmY0 ZTY0MmIwMThkZDNhNmM4Zi4uZmRjNDEzYzQxOTUwZTM2Mjg0ZmUzMmU2Y2VjZmYyZDY1MGUwNmMz MiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAt MSwzICsxLDIyIEBACisyMDE0LTA0LTMwICBHeXV5b3VuZyBLaW0gIDxneXV5b3VuZy5raW1Ac2Ft c3VuZy5jb20+CisKKyAgICAgICAgW0Nvb3JkaW5hdGVkR3JhcGhpY3NdW1dLMl0gU2NhbGUgZmFj dG9yIGFuZCBzY3JvbGwgcG9zaXRpb24gaXMgbm90IGJlaW5nIHJlc3RvcmVkIHByb3Blcmx5IGlu IGEgYmFjay9mb3J3YXJkIGxvYWQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTEyNjAyMgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIE9yaWdpbmFsIGF1dGhvciA6IFRoaWFnbyBkZSBCYXJyb3MgTGFjZXJkYSwg YW5kIGZpbmlzaGVkIGJ5IEd5dXlvdW5nIEtpbS4KKworICAgICAgICBBZGRlZCBhbiB1bml0IHRl c3QgY2FzZSB0byBjaGVjayBpZiBzY3JvbGwgcG9zaXRpb24gYW5kIHNjYWxlIGFyZSByZXN0b3Jl ZCBwcm9wZXJseS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21ha2U6 CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhp Y3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3JvbGxCYWNrRm9yd2FyZC5jcHA6IEFkZGVkLgorICAg ICAgICAoVGVzdFdlYktpdEFQSTo6ZGlkRmluaXNoTG9hZEZvckZyYW1lKToKKyAgICAgICAgKFRl c3RXZWJLaXRBUEk6OmRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb24pOgorICAgICAgICAoVGVzdFdl YktpdEFQSTo6VEVTVCk6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nv b3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQxLmh0bWw6IEFkZGVkLgorICAgICAgICAqIFRl c3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJk Mi5odG1sOiBBZGRlZC4KKwogMjAxNC0wNC0yOSAgU3RlcGhhbmllIExld2lzICA8c2xld2lzQGFw cGxlLmNvbT4KIAogICAgICAgICA8cmRhcjovL3Byb2JsZW0vMTY3NjU3NjU+IFVzZSBKU09OOjpQ UCBpbiBwZXJsIHNjcmlwdHMgaW5zdGVhZCBvZiBKU09OLgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVz dFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZv cm1FZmwuY21ha2UKaW5kZXggODE1M2Y3ZjU2OWUxNjJkYzFkZjlmNzEwNjcxYWEzOWNlNzA4YmEw OS4uZjI4M2ZmOTIwN2JjYWU5OWViNjAzNzU4YjlkYTVhYjdjNWY0ZDVhMyAxMDA2NDQKLS0tIGEv VG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQorKysgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC05OCw2ICs5OCw3IEBAIHNldCh0ZXN0X3dlYmtp dDJfYXBpX0JJTkFSSUVTCiAgICAgV2lsbExvYWQKICAgICBXaWxsU2VuZFN1Ym1pdEV2ZW50CiAg ICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdJc0FjdGl2ZVNldElzQWN0aXZlCisgICAgQ29v cmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdSZXN0b3JlWm9vbUFuZFNjcm9sbEJhY2tGb3J3YXJkCiAg ICAgQ29vcmRpbmF0ZWRHcmFwaGljcy9XS1ZpZXdVc2VyVmlld3BvcnRUb0NvbnRlbnRzCiAgICAg ZWZsL1dLVmlld0NsaWVudFdlYlByb2Nlc3NDYWxsYmFja3MKICkKZGlmZiAtLWdpdCBhL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jl c3RvcmVab29tQW5kU2Nyb2xsQmFja0ZvcndhcmQuY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvV0tWaWV3UmVzdG9yZVpvb21BbmRTY3Jv bGxCYWNrRm9yd2FyZC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZjIwOGFkN2RkYTg4Yzc3YjY2NDMyMzMwYTQ1 NDQ5YTljNmRmNGFjMwotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL1dLVmlld1Jlc3RvcmVab29tQW5kU2Nyb2xs QmFja0ZvcndhcmQuY3BwCkBAIC0wLDAgKzEsMTI5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEyLTIwMTMgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpLgor ICogQ29weXJpZ2h0IChDKSAyMDExIFNhbXN1bmcgRWxlY3Ryb25pY3MuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUg Q09QWVJJR0hUIEhPTERFUlMgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBUSEUg Q09QWVJJR0hUIEhPTERFUlMgT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICog UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us IERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpbmNsdWRlICJld2tfdmll d19wcml2YXRlLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNpbmNsdWRlICJQ bGF0Zm9ybVdlYlZpZXcuaCIKKyNpbmNsdWRlIDxXZWJLaXQyL1dLQ29udGV4dC5oPgorI2luY2x1 ZGUgPFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KKyNpbmNsdWRlICJUZXN0LmgiCisKK25hbWVzcGFj ZSBUZXN0V2ViS2l0QVBJIHsKKworc3RhdGljIGJvb2wgZmluaXNoZWRMb2FkID0gZmFsc2U7Citz dGF0aWMgYm9vbCBzY3JvbGwgPSBmYWxzZTsKKworc3RhdGljIHZvaWQgZGlkRmluaXNoTG9hZEZv ckZyYW1lKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBlUmVmLCBjb25zdCB2b2lkKikKK3sK KyAgICBmaW5pc2hlZExvYWQgPSB0cnVlOworfQorCitzdGF0aWMgdm9pZCBkaWRDaGFuZ2VDb250 ZW50c1Bvc2l0aW9uKFdLVmlld1JlZiwgV0tQb2ludCBwLCBjb25zdCB2b2lkKikKK3sKKyAgICBz Y3JvbGwgPSB0cnVlOworfQorCitURVNUKFdlYktpdDIsIFdLVmlld1Jlc3RvcmVab29tQW5kU2Ny b2xsQmFja0ZvcndhcmQpCit7CisgICAgV0tSZXRhaW5QdHI8V0tDb250ZXh0UmVmPiBjb250ZXh0 KEFkb3B0V0ssIFdLQ29udGV4dENyZWF0ZSgpKTsKKyAgICBQbGF0Zm9ybVdlYlZpZXcgd2ViVmll dyhjb250ZXh0LmdldCgpKTsKKyAgICBXS1JldGFpblB0cjxXS1ZpZXdSZWY+IHZpZXcgPSBFV0tW aWV3R2V0V0tWaWV3KHdlYlZpZXcucGxhdGZvcm1WaWV3KCkpOworCisgICAgV0tQYWdlU2V0VXNl Rml4ZWRMYXlvdXQod2ViVmlldy5wYWdlKCksIHRydWUpOworCisgICAgV0tQYWdlTG9hZGVyQ2xp ZW50VjAgbG9hZGVyQ2xpZW50OworICAgIG1lbXNldCgmbG9hZGVyQ2xpZW50LCAwLCBzaXplb2Yo bG9hZGVyQ2xpZW50KSk7CisgICAgbG9hZGVyQ2xpZW50LmJhc2UudmVyc2lvbiA9IDA7CisgICAg bG9hZGVyQ2xpZW50LmRpZEZpbmlzaExvYWRGb3JGcmFtZSA9IGRpZEZpbmlzaExvYWRGb3JGcmFt ZTsKKyAgICBXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KHdlYlZpZXcucGFnZSgpLCAmbG9hZGVy Q2xpZW50LmJhc2UpOworCisgICAgV0tWaWV3Q2xpZW50VjAgdmlld0NsaWVudDsKKyAgICBtZW1z ZXQoJnZpZXdDbGllbnQsIDAsIHNpemVvZih2aWV3Q2xpZW50KSk7CisgICAgdmlld0NsaWVudC5i YXNlLnZlcnNpb24gPSAwOworICAgIHZpZXdDbGllbnQuZGlkQ2hhbmdlQ29udGVudHNQb3NpdGlv biA9IGRpZENoYW5nZUNvbnRlbnRzUG9zaXRpb247CisgICAgV0tWaWV3U2V0Vmlld0NsaWVudCh2 aWV3LmdldCgpLCAmdmlld0NsaWVudC5iYXNlKTsKKworICAgIC8vIExvYWQgZmlyc3QgcGFnZS4K KyAgICBXS1JldGFpblB0cjxXS1VSTFJlZj4gdXJsKEFkb3B0V0ssIFV0aWw6OmNyZWF0ZVVSTEZv clJlc291cmNlKCJDb29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMSIsICJodG1sIikpOwor ICAgIFdLUGFnZUxvYWRVUkwod2ViVmlldy5wYWdlKCksIHVybC5nZXQoKSk7CisgICAgVXRpbDo6 cnVuKCZmaW5pc2hlZExvYWQpOworCisgICAgLy8gQ2hhbmdlIHNjYWxlIGFuZCBwb3NpdGlvbiBv biBmaXJzdCBwYWdlLgorICAgIGZsb2F0IGZpcnN0UGFnZVNjYWxlID0gMi4wOworICAgIFdLUG9p bnQgZmlyc3RQYWdlU2Nyb2xsUG9zaXRpb24gPSBXS1BvaW50TWFrZSgxMCwgMzUwKTsgLy8gU2Ny b2xsIHBvc2l0aW9uIG9mIGZpcnN0IHBhZ2UuCisgICAgV0tWaWV3U2V0Q29udGVudFBvc2l0aW9u KHZpZXcuZ2V0KCksIGZpcnN0UGFnZVNjcm9sbFBvc2l0aW9uKTsKKyAgICBXS1ZpZXdTZXRDb250 ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSwgZmlyc3RQYWdlU2NhbGUpOworICAgIGZsb2F0IGN1 cnJlbnRQYWdlU2NhbGUgPSBXS1ZpZXdHZXRDb250ZW50U2NhbGVGYWN0b3Iodmlldy5nZXQoKSk7 CisgICAgV0tQb2ludCBjdXJyZW50UGFnZVBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0 aW9uKHZpZXcuZ2V0KCkpOworICAgIFV0aWw6OnJ1bigmc2Nyb2xsKTsKKyAgICBFWFBFQ1RfRVEo Zmlyc3RQYWdlU2NhbGUsIGN1cnJlbnRQYWdlU2NhbGUpOworICAgIEVYUEVDVF9FUShmaXJzdFBh Z2VTY3JvbGxQb3NpdGlvbi54LCBjdXJyZW50UGFnZVBvc2l0aW9uLngpOworICAgIEVYUEVDVF9F UShmaXJzdFBhZ2VTY3JvbGxQb3NpdGlvbi55LCBjdXJyZW50UGFnZVBvc2l0aW9uLnkpOworCisg ICAgLy8gTG9hZCBzZWNvbmQgcGFnZS4KKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICB1 cmwgPSBhZG9wdFdLKFV0aWw6OmNyZWF0ZVVSTEZvclJlc291cmNlKCJDb29yZGluYXRlZEdyYXBo aWNzL2JhY2tmb3J3YXJkMiIsICJodG1sIikpOworICAgIFdLUGFnZUxvYWRVUkwod2ViVmlldy5w YWdlKCksIHVybC5nZXQoKSk7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworCisgICAg Ly8gQ2hlY2sgaWYgc2Vjb25kIHBhZ2Ugc2NhbGUgYW5kIHBvc2l0aW9uIGlzIGNvcnJlY3QuCisg ICAgY3VycmVudFBhZ2VTY2FsZSA9IFdLVmlld0dldENvbnRlbnRTY2FsZUZhY3Rvcih2aWV3Lmdl dCgpKTsKKyAgICBjdXJyZW50UGFnZVBvc2l0aW9uID0gV0tWaWV3R2V0Q29udGVudFBvc2l0aW9u KHZpZXcuZ2V0KCkpOworICAgIEVYUEVDVF9FUSgxLCBjdXJyZW50UGFnZVNjYWxlKTsKKyAgICBF WFBFQ1RfRVEoMCwgY3VycmVudFBhZ2VQb3NpdGlvbi54KTsKKyAgICBFWFBFQ1RfRVEoMCwgY3Vy cmVudFBhZ2VQb3NpdGlvbi55KTsKKworICAgIC8vIEdvIGJhY2sgZmlyc3QgcGFnZS4KKyAgICBz Y3JvbGwgPSBmYWxzZTsKKyAgICBmaW5pc2hlZExvYWQgPSBmYWxzZTsKKyAgICBXS1BhZ2VHb0Jh Y2sod2ViVmlldy5wYWdlKCkpOworICAgIFV0aWw6OnJ1bigmZmluaXNoZWRMb2FkKTsKKyAgICBV dGlsOjpydW4oJnNjcm9sbCk7CisKKyAgICAvLyBDaGVjayBpZiBzY3JvbGwgcG9zaXRpb24gYW5k IHNjYWxlIG9mIGZpcnN0IHBhZ2UgYXJlIHJlc3RvcmVkIGNvcnJlY3RseS4KKyAgICBjdXJyZW50 UGFnZVNjYWxlID0gV0tWaWV3R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAg IGN1cnJlbnRQYWdlUG9zaXRpb24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQo KSk7CisgICAgRVhQRUNUX0VRKGZpcnN0UGFnZVNjYWxlLCBjdXJyZW50UGFnZVNjYWxlKTsKKyAg ICBFWFBFQ1RfRVEoZmlyc3RQYWdlU2Nyb2xsUG9zaXRpb24ueCwgY3VycmVudFBhZ2VQb3NpdGlv bi54KTsKKyAgICBFWFBFQ1RfRVEoZmlyc3RQYWdlU2Nyb2xsUG9zaXRpb24ueSwgY3VycmVudFBh Z2VQb3NpdGlvbi55KTsKKworICAgIC8vIEdvIHRvIHNlY29uZCBwYWdlIGFnYWluLgorICAgIFdL UGFnZUdvRm9yd2FyZCh3ZWJWaWV3LnBhZ2UoKSk7CisgICAgc2Nyb2xsID0gZmFsc2U7CisgICAg ZmluaXNoZWRMb2FkID0gZmFsc2U7CisgICAgVXRpbDo6cnVuKCZmaW5pc2hlZExvYWQpOworCisg ICAgLy8gQ2hlY2sgaWYgdGhlIHNjcm9sbCBwb3NpdGlvbiBhbmQgc2NhbGUgb2Ygc2Vjb25kIHBh Z2UgYXJlIHJlc3RvcmVkIGNvcnJlY3RseS4KKyAgICBjdXJyZW50UGFnZVNjYWxlID0gV0tWaWV3 R2V0Q29udGVudFNjYWxlRmFjdG9yKHZpZXcuZ2V0KCkpOworICAgIGN1cnJlbnRQYWdlUG9zaXRp b24gPSBXS1ZpZXdHZXRDb250ZW50UG9zaXRpb24odmlldy5nZXQoKSk7CisgICAgRVhQRUNUX0VR KDEsIGN1cnJlbnRQYWdlU2NhbGUpOworICAgIEVYUEVDVF9FUSgwLCBjdXJyZW50UGFnZVBvc2l0 aW9uLngpOworICAgIEVYUEVDVF9FUSgwLCBjdXJyZW50UGFnZVBvc2l0aW9uLnkpOworfQorCit9 IC8vIFRlc3RXZWJLaXRBUEkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mi9Db29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0Nvb3JkaW5hdGVkR3JhcGhpY3MvYmFja2ZvcndhcmQx Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uOThjMWMxMDdjZjYyOWE2YjQ3NTUwM2Y3N2JlMjUwMGNjZDFmNGE3 ZQotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9D b29yZGluYXRlZEdyYXBoaWNzL2JhY2tmb3J3YXJkMS5odG1sCkBAIC0wLDAgKzEsNSBAQAorPGh0 bWw+Cis8Ym9keSBzdHlsZT0id2lkdGg6MTAwJTsgaGVpZ2h0OjEwMCUiPgorICAgIDxkaXYgc3R5 bGU9InBvc2l0aW9uOiBhYnNvbHV0ZTsgdG9wOiAwOyBsZWZ0OiAwOyB3aWR0aDogOTAwcHg7IGhl aWdodDogMTIwMHB4OyI+PC9kaXY+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Ub29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9y d2FyZDIuaHRtbCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Db29yZGluYXRl ZEdyYXBoaWNzL2JhY2tmb3J3YXJkMi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM4MDZiOWQzMmVjNGRlMzk4 NjFmMmY3NzJhMjE5MjE4ZWVhOWM2NzUKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdDIvQ29vcmRpbmF0ZWRHcmFwaGljcy9iYWNrZm9yd2FyZDIuaHRt bApAQCAtMCwwICsxIEBACis8Ym9keSBzdHlsZT0id2lkdGg6MTAwJTsgaGVpZ2h0OjEwMCUiLz4K