110743 2013-02-25 03:31:09 -0800 [WK2] WebPageProxy loadURL() won't work when called just after terminateProcess() 2013-04-21 18:47:50 -0700 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 109980 0 savagobr benjamin andersca ap benjamin cgarcia gyuyoung.kim hausmann jesus rafael.lobo rakuco sergio webkit.review.bot zan oldest_to_newest 840840 0 savagobr 2013-02-25 03:31:09 -0800 Issue #109980 has a unit test that demonstrate this scenario. loadURL() tests for the state of WebProcess to decide if there is a need to re-spawn it (in cases where a crash happened). The issue is that the check depends in a variable that will not be updated when terminateProcess() has executed, thus, loading a page will fail. What would be expected is: terminateProcess() --> loadURL() --> reattachtoWebProcess() But what really is happening: terminateProcess() --> loadURL() --> processDidCrash() This is due to the fact that the complete WebProcess's resources teardown happens in processDidCrash(). Ideally, all cleanup should be done at terminateProcess(). 842261 1 savagobr 2013-02-26 12:27:23 -0800 An update on this issue: I started by moving most of the code in WebPageProxy processDidCrash() to a private function named processTeardown(). It is used by both processDidCrash() and at terminateProcess(). The basic idea here is that when terminateProcess() was called, it should do the cleanup and processDidCrash() should *not* execute in a later step. Further investigation revealed that WebProcessProxy will call WebPageProxy::processDidCrash() when the connection to WebProcess is closed. So it seems that is required to know at WebProcessProxy the 2 cases: a) When WebPageProxy::terminateProcess() has executed: because in this case, we will do the process cleanup just after calling ChildProcesProxy::terminate() and WebPageProxy::processDidCrash() should *not* be executed, otherwise cleanup would be done twice. and b) When the process crashed by external factors: in this case no process cleanup has being done so far and *there is* the need to execute WebPageProxy::processDidCrash(). There is an added complication I've observed. Some ports (e.g. EFL) after being notified by WebPageProxy::processDidCrash() that the process has exited, will call WebPageProxy::loadURL(). This happens exactly in the middle of WebProcess associated resources tear down. I think it makes sense to notify the port of WebProcess unavailability only in cases of real crash, not in the case of explicit termination (i.e. when WebPageProxy::terminateProcess() was called). Finally, it would be safer to notify the port of WebProcess crash only *after* cleaning up the associated resources (so that if the port calls WebPageProxy::loadURL() or reload(), we wouldn't be in the an undefined state). 842571 2 benjamin 2013-02-26 18:01:48 -0800 It looks like we need terminateProcess() to: 1) Ensure any future message from the WebProcess will be discarded. 2) Kill the Process 3) Reset to a clean state. 4) Maybe call processDidCrash, or maybe schedule its call, I am not sure. When terminateProcess() finishes, any command on the PageProxy should be valid. 842572 3 andersca 2013-02-26 18:08:50 -0800 (In reply to comment #2) > It looks like we need terminateProcess() to: > 4) Maybe call processDidCrash, or maybe schedule its call, I am not sure. We shouldn’t call processDidCrash - if the client explicitly asked for the process to be terminated, we shouldn’t consider it to be a crash. 844714 4 190867 savagobr 2013-02-28 19:03:17 -0800 Created attachment 190867 Makes WebPageProxy cleanup at terminateProcess() step 844726 5 savagobr 2013-02-28 19:26:57 -0800 An explanation on this patch... first, the good: it does the resources cleanup associated with a client call to process termination and implements a way for WebProcessProxy to know if it is a crash or if it is an explicit termination, thus notifying the client when needed. The bad: it won't make the tests on #109980 to succeed because when when the WebPageProxy::reattachToWebProcess() is executed, WebProcessProxy *hasn't* completed its own cleanup. 845572 6 190867 rafael.lobo 2013-03-01 15:52:28 -0800 Comment on attachment 190867 Makes WebPageProxy cleanup at terminateProcess() step View in context: https://bugs.webkit.org/attachment.cgi?id=190867&action=review > Source/WebKit2/UIProcess/WebProcessProxy.cpp:404 > + m_isTerminated = false; if !m_isTerminated, then m_isTerminated is already false. 870595 7 196821 savagobr 2013-04-07 19:57:37 -0700 Created attachment 196821 Do all cleanup on terminate (both WebPageProxy and WebProcessProxy). 870596 8 savagobr 2013-04-07 20:02:16 -0700 The good: does all cleanup (including WebProcessProxy) so that WebPageProxy::reattachToWebProcess() will work (and so loadURL()). It will break the other unit tests that simulate crashes calling WebPageProxy::terminateProcess(), since we no longer notify the client of a 'crash' (since it really is not a crash, but was requested by the user). Question: what to do with the other unit tests that depend on execution of a crash handler? 870719 9 196846 savagobr 2013-04-08 05:46:27 -0700 Created attachment 196846 With new test (load, crash, load) WebProcess termination now is done using a new function 'userRequestedTerminate' that performs complete shutdown of WebProcessProxy before returning. This ensures that at time reattachToWebProcess() is executed, WebProcessProxy is in a sane state. Next, cleanup of WebPageProxy is done at terminateProcess(), using a new function named 'processTeardown()', that is shared with processDidCrash(). Finally, client is not notified of process crash, since it was terminated per client's request. This changes makes the new test succeed, but will cause a regression in all tests that depend on a callback to be executed at process termination. 870811 10 196846 ap 2013-04-08 09:38:38 -0700 Comment on attachment 196846 With new test (load, crash, load) View in context: https://bugs.webkit.org/attachment.cgi?id=196846&action=review > will cause a regression in all tests that depend on a callback to be executed at process termination. What are these other tests? We clearly need to do something about them, can't just make them fail. > Tools/TestWebKitAPI/Tests/WebKit2/LoadPageOnCrash.cpp:59 > + void crashWebProcess() > + { > + WKPageTerminate(webView.page()); > + } Unsure why you called this function crashWebProcess. It doesn't make it crash, does it? 870862 11 savagobr 2013-04-08 10:43:18 -0700 Alexey Thanks for commenting. Answering the questions: a) What are the tests? All that use WKPageTerminate API, which are 3 tests (MouseMoveAfterCrash, ReloadPageAfterCrash, ResizeWindowAfterCrash). I think they can work *if* we execute the code in the crash callback within the scope of primary test function. b) why 'crashWebProcess': it terminates WebProcess thus simulating a crash (the other 3 tests follow a similar nomenclature). If you wish, I can change the function name. 871131 12 196945 savagobr 2013-04-08 13:09:17 -0700 Created attachment 196945 Fixed failing unit test Fixed failing unit test. 871200 13 196945 benjamin 2013-04-08 15:09:38 -0700 Comment on attachment 196945 Fixed failing unit test View in context: https://bugs.webkit.org/attachment.cgi?id=196945&action=review > Source/WebKit2/ChangeLog:14 > + WebPageProxy should do its resources clean up as soon as executing the call to terminate. > + > + Its state will be undefined if depending on the execution of processDidCrash(), thus this > + patch moves the cleanup code to a shared private function that is used for both the cases > + i.e. user termination and real crash. WebProcess shutdown is done using a new method that > + ensures that all cleanup was done before returning. Finally, for user requested termination, > + clients are no longer notified of crash. I think the changelog should be clearer. You are fixing a very specific issue. You first state what was the bug, then explain why it happened, then you put the text explaining how you fixed the problem. > Source/WebKit2/UIProcess/WebPageProxy.cpp:1571 > + m_process->userRequestedTerminate(); > + processTeardown(); Why are those called in this order? You should first clean up the state, then invoke any callback. > Source/WebKit2/UIProcess/WebPageProxy.cpp:3803 > + if (!m_isValid) > + return; When does that happen? 1) terminateProcess() 2) processTeardown() 3) processDidCrash() ? Because I would think you cannot get processDidCrash() after processTeardown() (because of m_process->removeMessageReceiver). Can this be tested? > Source/WebKit2/UIProcess/WebPageProxy.cpp:3810 > + // After removing the message receivers and cleaning up resources, we > + // notify the client/port that a crash happened. This ensures > + // that we are in a defined state and calls to loadURL() or reload() > + // should work. I don't think this comment is necessary. > Source/WebKit2/UIProcess/WebPageProxy.h:604 > + void processTeardown(); This should be private. > Source/WebKit2/UIProcess/WebProcessProxy.h:119 > + void userRequestedTerminate(); > + The name should not have "user", as it is a callback for any programmatic termination. Not only the one triggered by the user. Why not terminateProcess()? 871201 14 benjamin 2013-04-08 15:10:30 -0700 Please ping me when you have an update. Let's iterate quickly on this until fixed. 871977 15 savagobr 2013-04-09 11:22:39 -0700 Benjamin Thanks for reviewing this patch. I will try to address the comments bellow. > I think the changelog should be clearer. You are fixing a very specific >issue. You first state what was the bug, then explain why it happened, then >you put the text explaining how you fixed the problem. > Concerning the CL... agreed. The fix is one thing (i.e. load fails after call to terminate) and the points of failure are 2: a) Cleaning up of WebPageProxy b) Reattach executing *before* complete WebProcessProxy cleanup. I will upload a new version of this patch with a hopefully better explanation in the CL. > > Source/WebKit2/UIProcess/WebPageProxy.cpp:1571 > > + m_process->userRequestedTerminate(); > > + processTeardown(); > > Why are those called in this order? > Executing WebProcess termination must be done *before* any cleanup of WebPageProxy. If you think about it, in normal crashes, this is exactly what has happened already. This ensures that reattach/respawn of WebProcess will succeed, since when we return to WebPageProxy, WebProcessProxy is in a well defined state (and not in the middle of its own cleanup). > > When does that happen? > 1) terminateProcess() > 2) processTeardown() > 3) processDidCrash() The previous behavior was to execute processDidCrash(), called from WebProcessProxy. With this patch, using the new member function 'userRequestedTerminate', WebProcessProxy will *not* callback any method into WebPageProxy. This includes processDidCrash(). So, the execution flow for user requested termination was: WebPageProxy................ WebProcessProxy terminateProcess() ---------> processTerminate() processDidCrash() <---------- DidClose() *Now* the execution flow for this case is: WebPageProxy................ WebProcessProxy terminateProcess() ---------> userRequestedTerminate() //kill everything processTearDown() For normal crashes (i.e. not user requested termination), the execution flow hasn't changed. WebProcessProxy will call processDidCrash() into WebPageProxy which will then notify the client/port of the crash. Another thing that this patch changes is the ordering of steps for normal crashes. Before it was: notify the client/port of a crash and next try to do the cleanup. Now it is: first do the cleanup, next notify the client/port of a crash. This helps to ensure that WebPageProxy is in a defined state if someone calls its member functions (e.g. loadURL()). In those cases, since the cleanup hasn't executed yet, the test for WebProcess state would fail (and reattach is never executed). > > > Source/WebKit2/UIProcess/WebPageProxy.cpp:3810 > > + // After removing the message receivers and cleaning up resources, we > > + // notify the client/port that a crash happened. This ensures > > + // that we are in a defined state and calls to loadURL() or reload() > > + // should work. > > I don't think this comment is necessary. > Ack. > > Source/WebKit2/UIProcess/WebPageProxy.h:604 > > + void processTeardown(); > > This should be private. > Agreed. > > Source/WebKit2/UIProcess/WebProcessProxy.h:119 > > + void userRequestedTerminate(); > > + > > The name should not have "user", as it is a callback for any programmatic termination. Not only the one triggered by the user. > Isn't this executed when the user/client code call WKPageTerminate()? 873980 16 197640 savagobr 2013-04-11 10:46:17 -0700 Created attachment 197640 Addressing reviewers comments: CL, member function naming, using private access, etc. Tested on Qt/Linux, waiting to finish compile on Mac to run unit tests before asking for cq. 874211 17 197640 benjamin 2013-04-11 15:13:14 -0700 Comment on attachment 197640 Addressing reviewers comments: CL, member function naming, using private access, etc. View in context: https://bugs.webkit.org/attachment.cgi?id=197640&action=review > Source/WebKit2/ChangeLog:17 > + closing connections. Otherwise, WebPageProxy can even be able to > + detect that WebProcess is no longer running, but a call to respawn > + the process will fail. "Otherwise, WebPageProxy can even be able to detect that WebProcess [...]" > Source/WebKit2/ChangeLog:19 > + To fix this issues, this patch moves the cleanup code to a shared private function "this issue" or "these issues". > Tools/TestWebKitAPI/Tests/WebKit2/LoadPageOnCrash.cpp:83 > + EXPECT_TRUE(testHelper->firstSuccessfulLoad); This can never be false. 874214 18 197640 andersca 2013-04-11 15:15:57 -0700 Comment on attachment 197640 Addressing reviewers comments: CL, member function naming, using private access, etc. View in context: https://bugs.webkit.org/attachment.cgi?id=197640&action=review > Source/WebKit2/UIProcess/WebPageProxy.cpp:3810 > +void WebPageProxy::processTeardown() This function name is ambiguous; it sounds like it will process the teardown. 874329 19 savagobr 2013-04-11 19:09:18 -0700 Heads up on test results: Adenilsons-Mac-mini:Webkit adenilsoncavalcanti$ egrep -n Crash ../vanilla.txt | grep After 292: Test: MouseMoveAfterCrash -> Passed 302: Test: ReloadPageAfterCrash -> Passed 303: Test: ResizeWindowAfterCrash -> Passed Adenilsons-Mac-mini:Webkit adenilsoncavalcanti$ egrep -n Crash ../patched.txt | grep After 293: Test: LoadPageAfterCrash -> Passed 294: Test: MouseMoveAfterCrash -> Passed 304: Test: ReloadPageAfterCrash -> Passed 305: Test: ResizeWindowAfterCrash -> Passed All other API tests are ok too. 874346 20 197640 benjamin 2013-04-11 21:32:25 -0700 Comment on attachment 197640 Addressing reviewers comments: CL, member function naming, using private access, etc. View in context: https://bugs.webkit.org/attachment.cgi?id=197640&action=review >> Source/WebKit2/UIProcess/WebPageProxy.cpp:3810 >> +void WebPageProxy::processTeardown() > > This function name is ambiguous; it sounds like it will process the teardown. processTeardown-> resetStateAfterProcessExit? Anders, any suggestion? > Source/WebKit2/UIProcess/WebPageProxy.cpp:3899 > - > if (!m_isValid) { Can m_isValid be true at all at this point? 874954 21 197886 benjamin 2013-04-12 14:21:43 -0700 Created attachment 197886 Patch 875039 22 benjamin 2013-04-12 16:32:24 -0700 Landed: https://trac.webkit.org/r148312 878684 23 rafael.lobo 2013-04-19 17:22:56 -0700 (In reply to comment #22) > Landed: https://trac.webkit.org/r148312 So now ReloadPageAfterCrash is useless. The "didCrash" callback is never called and the test is now simply tests if the page reloads. In fact, if you simply comment "WKPageTerminate" from that test, it will also pass. 878694 24 benjamin 2013-04-19 18:12:28 -0700 (In reply to comment #23) > (In reply to comment #22) > > Landed: https://trac.webkit.org/r148312 > > So now ReloadPageAfterCrash is useless. The "didCrash" callback is never called and the test is now simply tests if the page reloads. In fact, if you simply comment "WKPageTerminate" from that test, it will also pass. Yep. I suggested to Adenilson to make a injected bundle to crash the WebProcess. That way we can start making process-crash tests again. 878714 25 rafael.lobo 2013-04-19 20:44:08 -0700 How are we going to test WKPageTerminate if we never get a callback such as "didTerminate"? What if instead of having "processDidCrash" callback we had a single "processDidTerminate" or something like that with a boolean argument confirming if it was a crash or not? Given that the user of this API can figure out by himself if it has crashed by purpose or not checking whether he has used WKPageTerminate I think we don't even need that argument at all: he could just ignore "processDidTerminate" if he is indeed expecting the page to terminate or act as a "processDidCrash" otherwise at user level without changing the behavior we had before. 878715 26 benjamin 2013-04-19 20:49:22 -0700 (In reply to comment #25) > How are we going to test WKPageTerminate if we never get a callback such as "didTerminate"? What if instead of having "processDidCrash" callback we had a single "processDidTerminate" or something like that with a boolean argument confirming if it was a crash or not? Given that the user of this API can figure out by himself if it has crashed by purpose or not checking whether he has used WKPageTerminate I think we don't even need that argument at all: he could just ignore "processDidTerminate" if he is indeed expecting the page to terminate or act as a "processDidCrash" otherwise at user level without changing the behavior we had before. It is not clear to me how that would help WKPageTerminate. What kind of tests do you have in mind. A callback processDidTerminate does not really fit into the API. 878889 27 jesus 2013-04-21 11:45:29 -0700 (In reply to comment #26) > (In reply to comment #25) > > How are we going to test WKPageTerminate if we never get a callback such as "didTerminate"? What if instead of having "processDidCrash" callback we had a single "processDidTerminate" or something like that with a boolean argument confirming if it was a crash or not? Given that the user of this API can figure out by himself if it has crashed by purpose or not checking whether he has used WKPageTerminate I think we don't even need that argument at all: he could just ignore "processDidTerminate" if he is indeed expecting the page to terminate or act as a "processDidCrash" otherwise at user level without changing the behavior we had before. > > It is not clear to me how that would help WKPageTerminate. What kind of tests do you have in mind. > > A callback processDidTerminate does not really fit into the API. I agree with Benjamin here. Plus, from an API perspective, both options look a bit messy. A boolean that will ending up as a state representation, or a few assumptions around using or ignoring callbacks. If what we want in the end is only a way to test a page-crashed-and-reload-something-else flow, the Injected Bundle path looks cleaner. 878919 28 rafael.lobo 2013-04-21 16:36:02 -0700 (In reply to comment #27) > (In reply to comment #26) > > (In reply to comment #25) > > > How are we going to test WKPageTerminate if we never get a callback such as "didTerminate"? What if instead of having "processDidCrash" callback we had a single "processDidTerminate" or something like that with a boolean argument confirming if it was a crash or not? Given that the user of this API can figure out by himself if it has crashed by purpose or not checking whether he has used WKPageTerminate I think we don't even need that argument at all: he could just ignore "processDidTerminate" if he is indeed expecting the page to terminate or act as a "processDidCrash" otherwise at user level without changing the behavior we had before. > > > > It is not clear to me how that would help WKPageTerminate. What kind of tests do you have in mind. > > > > A callback processDidTerminate does not really fit into the API. > > > I agree with Benjamin here. Plus, from an API perspective, both options look a bit messy. A boolean that will ending up as a state representation, or a few assumptions around using or ignoring callbacks. > > If what we want in the end is only a way to test a page-crashed-and-reload-something-else flow, the Injected Bundle path looks cleaner. It's not only about whether we have a crash or not, but how can we test WKPageTerminate. The callback looks like a straight-forward solution. It's still not clear to me how WKPageTerminate can be tested today... or maybe we just don't want to test it. 878936 29 benjamin 2013-04-21 18:47:49 -0700 (In reply to comment #28) > It's not only about whether we have a crash or not, but how can we test WKPageTerminate. The callback looks like a straight-forward solution. It's still not clear to me how WKPageTerminate can be tested today... or maybe we just don't want to test it. Seriously I have trouble following you. To make thing easier, what kind of tests do you envision if we had a callback? 878937 30 benjamin 2013-04-21 18:47:50 -0700 (In reply to comment #28) > It's not only about whether we have a crash or not, but how can we test WKPageTerminate. The callback looks like a straight-forward solution. It's still not clear to me how WKPageTerminate can be tested today... or maybe we just don't want to test it. Seriously I have trouble following you. To make thing easier, what kind of tests do you envision if we had a callback? 190867 2013-02-28 19:03:17 -0800 2013-04-08 05:46:27 -0700 Makes WebPageProxy cleanup at terminateProcess() step 0001-First-step-for-solving-the-issue-of-loadURL-failing.patch text/plain 6122 savagobr RnJvbSBkNTQ0NjhhY2NlZDI3NjgxYmUxNjlmN2E1MWUwOTk4NGIwZTI2OWFkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBZGVuaWxzb24gQ2F2YWxjYW50aSA8Y2F2YWxjYW50aWlAZ21h aWwuY29tPgpEYXRlOiBUaHUsIDI4IEZlYiAyMDEzIDIyOjU1OjE2IC0wNDAwClN1YmplY3Q6IFtQ QVRDSF0gRmlyc3Qgc3RlcCBmb3Igc29sdmluZyB0aGUgaXNzdWUgb2YgbG9hZFVSTCgpIGZhaWxp bmcgYWZ0ZXIKIHByb2Nlc3MgdGVybWluYXRpb24uCgpTaWduZWQtb2ZmLWJ5OiBBZGVuaWxzb24g Q2F2YWxjYW50aSA8Y2F2YWxjYW50aWlAZ21haWwuY29tPgotLS0KIFNvdXJjZS9XZWJLaXQyL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgIHwgICAyOSArKysrKysrKysrKysrKysrKysrKysr KysrKwogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgICAgfCAgIDIy ICsrKysrKysrKysrKysrLS0tLS0KIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJv eHkuaCAgICAgIHwgICAgMSArCiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1By b3h5LmNwcCB8ICAgMTUgKysrKysrKysrKystLQogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dl YlByb2Nlc3NQcm94eS5oICAgfCAgICA0ICsrKysKIDUgZmlsZXMgY2hhbmdlZCwgNjQgaW5zZXJ0 aW9ucygrKSwgNyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggM2RmY2RiNi4uMDEyZTJlYiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQy L0NoYW5nZUxvZwpAQCAtMSwzICsxLDMyIEBACisyMDEzLTAyLTI4ICBBZGVuaWxzb24gQ2F2YWxj YW50aSAgPGNhdmFsY2FudGlpQGdtYWlsLmNvbT4KKworICAgICAgICBbV0syXSBXZWJQYWdlUHJv eHkgbG9hZFVSTCgpIHdvbid0IHdvcmsgd2hlbiBjYWxsZWQganVzdCBhZnRlciB0ZXJtaW5hdGVQ cm9jZXNzKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTExMDc0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFdlYlBhZ2VQcm94eSBzaG91bGQgZG8gaXRzIHJlc291cmNlcyBjbGVhbiB1cCBhcyBzb29uIGFz IGV4ZWN1dGluZyB0aGUgY2FsbCB0byB0ZXJtaW5hdGUuCisKKyAgICAgICAgSXRzIHN0YXRlIHdp bGwgYmUgdW5kZWZpbmVkIGlmIGRlcGVuZGluZyBvbiB0aGUgZXhlY3V0aW9uIG9mIHByb2Nlc3NE aWRDcmFzaCgpLCB0aHVzIHRoaXMKKyAgICAgICAgcGF0Y2ggbW92ZXMgdGhlIGNsZWFudXAgY29k ZSB0byBhIHNoYXJlZCBwcml2YXRlIGZ1bmN0aW9uIHRoYXQgaXMgdXNlZCBmb3IgYm90aCB0aGUg Y2FzZXMKKyAgICAgICAgaS5lLiB1c2VyIHRlcm1pbmF0aW9uIGFuZCByZWFsIGNyYXNoLiBGaW5h bGx5LCBpZiB0aGUgdXNlciBoYXMgcmVxdWVzdGVkIHRoZSB0ZXJtaW5hdGlvbiBvZgorICAgICAg ICBXZWJQcm9jZXNzLCBpdCBpcyBzYWZlIHRvIGFzc3VtZSB0aGF0IHRoZSBjbGllbnQgY29kZSBz aG91bGQgbm90IGJlIG5vdGlmaWVkIG9mIGEgY3Jhc2guCisKKyAgICAgICAgKiBVSVByb2Nlc3Mv V2ViUGFnZVByb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojp0ZXJtaW5h dGVQcm9jZXNzKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojpwcm9jZXNzRGlkQ3Jh c2gpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojpw cm9jZXNzVGVhcmRvd24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaDoKKyAg ICAgICAgKFdlYlBhZ2VQcm94eSk6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94 eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQcm94eTo6V2ViUHJvY2Vzc1Byb3h5 KToKKyAgICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzc1Byb3h5OjpkaWRDbG9zZSk6CisgICAgICAg IChXZWJLaXQ6OldlYlByb2Nlc3NQcm94eTo6dXNlclJlcXVlc3RlZFRlcm1pbmF0ZSk6CisgICAg ICAgIChXZWJLaXQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaDoKKyAg ICAgICAgKFdlYlByb2Nlc3NQcm94eSk6CisKIDIwMTMtMDItMjcgIENzYWJhIE9zenRyb2dvbsOh YyAgPG9zc3lAd2Via2l0Lm9yZz4KIAogICAgICAgICBbV0syXSBPbmUgbW9yZSB1bnJldmlld2Vk IGJ1aWxkZml4IGZvciBFRkwsIEdUSyBhbmQgUXQgYWZ0ZXIgcjE0NDIxOC4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKaW5kZXggYjgwMWQ1NS4uYjdkZDA3YSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAKQEAgLTE0ODIsNyArMTQ4 Miw4IEBAIHZvaWQgV2ViUGFnZVByb3h5Ojp0ZXJtaW5hdGVQcm9jZXNzKCkKICAgICBpZiAoIW1f aXNWYWxpZCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgbV9wcm9jZXNzLT50ZXJtaW5hdGUoKTsK KyAgICBwcm9jZXNzVGVhcmRvd24oKTsKKyAgICBtX3Byb2Nlc3MtPnVzZXJSZXF1ZXN0ZWRUZXJt aW5hdGUoKTsKIH0KIAogI2lmICFVU0UoQ0YpIHx8IGRlZmluZWQoQlVJTERJTkdfUVRfXykKQEAg LTM2ODUsOCArMzY4NiwyMiBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6cHJvY2Vzc0RpZEJlY29tZVJl c3BvbnNpdmUoKQogCiB2b2lkIFdlYlBhZ2VQcm94eTo6cHJvY2Vzc0RpZENyYXNoKCkKIHsKLSAg ICBBU1NFUlQobV9wYWdlQ2xpZW50KTsKKyAgICBpZiAoIW1faXNWYWxpZCkKKyAgICAgICAgcmV0 dXJuOworCisgICAgcHJvY2Vzc1RlYXJkb3duKCk7CiAKKyAgICAvLyBBZnRlciByZW1vdmluZyB0 aGUgbWVzc2FnZSByZWNlaXZlcnMgYW5kIGNsZWFuaW5nIHVwIHJlc291cmNlcywgd2UKKyAgICAv LyBub3RpZnkgdGhlIGNsaWVudC9wb3J0IHRoYXQgYSBjcmFzaCBoYXBwZW5lZC4gVGhpcyBlbnN1 cmVzCisgICAgLy8gdGhhdCB3ZSBhcmUgaW4gYSBkZWZpbmVkIHN0YXRlIGFuZCBjYWxscyB0byBs b2FkVVJMKCkgb3IgcmVsb2FkKCkKKyAgICAvLyBzaG91bGQgd29yay4KKyAgICBtX3BhZ2VDbGll bnQtPnByb2Nlc3NEaWRDcmFzaCgpOworICAgIG1fbG9hZGVyQ2xpZW50LnByb2Nlc3NEaWRDcmFz aCh0aGlzKTsKK30KKwordm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NUZWFyZG93bigpCit7Cisg ICAgQVNTRVJUKG1fcGFnZUNsaWVudCk7CiAgICAgbV9wcm9jZXNzLT5yZW1vdmVNZXNzYWdlUmVj ZWl2ZXIoTWVzc2FnZXM6OldlYlBhZ2VQcm94eTo6bWVzc2FnZVJlY2VpdmVyTmFtZSgpLCBtX3Bh Z2VJRCk7CiAKICAgICBtX2lzVmFsaWQgPSBmYWxzZTsKQEAgLTM3NzMsOSArMzc4OCw2IEBAIHZv aWQgV2ViUGFnZVByb3h5Ojpwcm9jZXNzRGlkQ3Jhc2goKQogCiAgICAgbV9wZW5kaW5nTGVhcm5P cklnbm9yZVdvcmRNZXNzYWdlQ291bnQgPSAwOwogCi0gICAgbV9wYWdlQ2xpZW50LT5wcm9jZXNz RGlkQ3Jhc2goKTsKLSAgICBtX2xvYWRlckNsaWVudC5wcm9jZXNzRGlkQ3Jhc2godGhpcyk7Ci0K ICAgICBpZiAoIW1faXNWYWxpZCkgewogICAgICAgICAvLyBJZiB0aGUgY2FsbCBvdXQgdG8gdGhl IGxvYWRlciBjbGllbnQgZGlkbid0IGNhdXNlIHRoZSB3ZWIgcHJvY2VzcyB0byBiZSByZWxhdW5j aGVkLCAKICAgICAgICAgLy8gd2UnbGwgY2FsbCBzZXROZWVkc0Rpc3BsYXkgb24gdGhlIHZpZXcg c28gdGhhdCB3ZSB3b24ndCBoYXZlIHRoZSBvbGQgY29udGVudHMgc2hvd2luZy4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAppbmRleCBmMGVjN2RiLi5lNDBlMGM5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKKysrIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCkBAIC01OTksNiArNTk5LDcgQEAg cHVibGljOgogICAgIHZvaWQgaW50ZXJhY3Rpb25PY2N1cnJlZFdoaWxlUHJvY2Vzc1VucmVzcG9u c2l2ZSgpOwogICAgIHZvaWQgcHJvY2Vzc0RpZEJlY29tZVJlc3BvbnNpdmUoKTsKICAgICB2b2lk IHByb2Nlc3NEaWRDcmFzaCgpOworICAgIHZvaWQgcHJvY2Vzc1RlYXJkb3duKCk7CiAKICNpZiBV U0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCiAgICAgdmlydHVhbCB2b2lkIGVudGVyQWNjZWxl cmF0ZWRDb21wb3NpdGluZ01vZGUoY29uc3QgTGF5ZXJUcmVlQ29udGV4dCYpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcAppbmRleCA2ZmVhM2E1Li43MTBj ODlkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5 LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcApA QCAtOTcsNiArOTcsNyBAQCBXZWJQcm9jZXNzUHJveHk6OldlYlByb2Nlc3NQcm94eShQYXNzUmVm UHRyPFdlYkNvbnRleHQ+IGNvbnRleHQpCiAjaWYgUExBVEZPUk0oTUFDKQogICAgICwgbV9wcm9j ZXNzU3VwcHJlc3Npb25FbmFibGVkKGZhbHNlKQogI2VuZGlmCisgICAgLCBtX2lzVGVybWluYXRl ZChmYWxzZSkKIHsKICAgICBjb25uZWN0KCk7CiB9CkBAIC0zOTYsOCArMzk3LDEyIEBAIHZvaWQg V2ViUHJvY2Vzc1Byb3h5OjpkaWRDbG9zZShDb3JlSVBDOjpDb25uZWN0aW9uKikKIAogICAgIGRp c2Nvbm5lY3QoKTsKIAotICAgIGZvciAoc2l6ZV90IGkgPSAwLCBzaXplID0gcGFnZXMuc2l6ZSgp OyBpIDwgc2l6ZTsgKytpKQotICAgICAgICBwYWdlc1tpXS0+cHJvY2Vzc0RpZENyYXNoKCk7Cisg ICAgaWYgKCFtX2lzVGVybWluYXRlZCkgeworICAgICAgICBmb3IgKHNpemVfdCBpID0gMCwgc2l6 ZSA9IHBhZ2VzLnNpemUoKTsgaSA8IHNpemU7ICsraSkKKyAgICAgICAgICAgIHBhZ2VzW2ldLT5w cm9jZXNzRGlkQ3Jhc2goKTsKKworICAgICAgICBtX2lzVGVybWluYXRlZCA9IGZhbHNlOworICAg IH0KIAogfQogCkBAIC02MTgsNCArNjIzLDEwIEBAIHZvaWQgV2ViUHJvY2Vzc1Byb3h5OjpwYWdl UHJlZmVyZW5jZXNDaGFuZ2VkKFdlYktpdDo6V2ViUGFnZVByb3h5ICpwYWdlKQogI2VuZGlmCiB9 CiAKK3ZvaWQgV2ViUHJvY2Vzc1Byb3h5Ojp1c2VyUmVxdWVzdGVkVGVybWluYXRlKCkKK3sKKyAg ICBtX2lzVGVybWluYXRlZCA9IHRydWU7CisgICAgQ2hpbGRQcm9jZXNzUHJveHk6OnRlcm1pbmF0 ZSgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9XZWJQcm9jZXNzUHJveHkuaAppbmRleCBkMzM1Y2UxLi5mYjA3Y2JiIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmgKKysrIGIvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCkBAIC0xMTUsNiArMTE1LDggQEAgcHVi bGljOgogICAgIHZvaWQgdXBkYXRlUHJvY2Vzc1N1cHByZXNzaW9uU3RhdGUoKTsKICNlbmRpZgog CisgICAgdm9pZCB1c2VyUmVxdWVzdGVkVGVybWluYXRlKCk7CisKIHByaXZhdGU6CiAgICAgZXhw bGljaXQgV2ViUHJvY2Vzc1Byb3h5KFBhc3NSZWZQdHI8V2ViQ29udGV4dD4pOwogCkBAIC0xOTgs NiArMjAwLDggQEAgcHJpdmF0ZToKICAgICBIYXNoU2V0PHVpbnQ2NF90PiBtX3Byb2Nlc3NTdXBw cmVzc2libGVQYWdlczsKICAgICBib29sIG1fcHJvY2Vzc1N1cHByZXNzaW9uRW5hYmxlZDsKICNl bmRpZgorCisgICAgYm9vbCBtX2lzVGVybWluYXRlZDsKIH07CiAgICAgCiB9IC8vIG5hbWVzcGFj ZSBXZWJLaXQKLS0gCjEuNy4xMC40Cgo= 196821 2013-04-07 19:57:37 -0700 2013-04-08 05:46:27 -0700 Do all cleanup on terminate (both WebPageProxy and WebProcessProxy). 0001-Newly-added-function-userRequestedTerminate-will-per.patch text/plain 5367 savagobr RnJvbSBkOWFlMTE5OTNlMmU0Yzg3OTMzZTlhMzVmYWUyZjBhODc4YzM1OTVkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBZGVuaWxzb24gQ2F2YWxjYW50aSA8Y2F2YWxjYW50aWlAZ21h aWwuY29tPgpEYXRlOiBTdW4sIDcgQXByIDIwMTMgMTE6MTY6NTkgLTA0MDAKU3ViamVjdDogW1BB VENIXSBOZXdseSBhZGRlZCBmdW5jdGlvbiAndXNlclJlcXVlc3RlZFRlcm1pbmF0ZScgd2lsbCBw ZXJmb3JtCiBjb21wbGV0ZSBzaHV0ZG93biBvZiBXZWJQcm9jZXNzUHJveHkgYmVmb3JlIHJldHVy bmluZy4KClRoaXMgZW5zdXJlcyB0aGF0IGF0IHRpbWUgcmVhdHRhY2hUb1dlYlByb2Nlc3MoKSBp cyBleGVjdXRlZCwKV2ViUHJvY2Vzc1Byb3h5IGlzIGluIGEgc2FuZSBzdGF0ZS4KClNpZ25lZC1v ZmYtYnk6IEFkZW5pbHNvbiBDYXZhbGNhbnRpIDxjYXZhbGNhbnRpaUBnbWFpbC5jb20+Ci0tLQog U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgfCAgIDI3ICsrKysr KysrKysrKysrKysrKysrKysrKysrCiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmNwcCAgICB8ICAgMjIgKysrKysrKysrKysrKysrKy0tLS0tCiBTb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmggICAgICB8ICAgIDEgKwogU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAgfCAgICA3ICsrKysrKysKIFNvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaCAgIHwgICAgMiArKwogNSBmaWxlcyBjaGFuZ2Vk LCA1NCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCBhNDc1MTM0 Li5iNThhZGVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTMtMDQtMDcgIEFkZW5p bHNvbiBDYXZhbGNhbnRpICA8Y2F2YWxjYW50aWlAZ21haWwuY29tPgorCisgICAgICAgIFtXSzJd IFdlYlBhZ2VQcm94eSBsb2FkVVJMKCkgd29uJ3Qgd29yayB3aGVuIGNhbGxlZCBqdXN0IGFmdGVy IHRlcm1pbmF0ZVByb2Nlc3MoKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTEwNzQzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgV2ViUGFnZVByb3h5IHNob3VsZCBkbyBpdHMgcmVzb3VyY2VzIGNsZWFuIHVw IGFzIHNvb24gYXMgZXhlY3V0aW5nIHRoZSBjYWxsIHRvIHRlcm1pbmF0ZS4KKworICAgICAgICBJ dHMgc3RhdGUgd2lsbCBiZSB1bmRlZmluZWQgaWYgZGVwZW5kaW5nIG9uIHRoZSBleGVjdXRpb24g b2YgcHJvY2Vzc0RpZENyYXNoKCksIHRodXMgdGhpcworICAgICAgICBwYXRjaCBtb3ZlcyB0aGUg Y2xlYW51cCBjb2RlIHRvIGEgc2hhcmVkIHByaXZhdGUgZnVuY3Rpb24gdGhhdCBpcyB1c2VkIGZv ciBib3RoIHRoZSBjYXNlcworICAgICAgICBpLmUuIHVzZXIgdGVybWluYXRpb24gYW5kIHJlYWwg Y3Jhc2guIFdlYlByb2Nlc3Mgc2h1dGRvd24gaXMgZG9uZSB1c2luZyBhIG5ldyBtZXRob2QgdGhh dAorICAgICAgICBlbnN1cmVzIHRoYXQgYWxsIGNsZWFudXAgd2FzIGRvbmUgYmVmb3JlIHJldHVy bmluZy4KKworICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJQYWdlUHJveHk6OnRlcm1pbmF0ZVByb2Nlc3MpOgorICAgICAgICAoV2ViS2l0 OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCk6CisgICAgICAgIChXZWJLaXQpOgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NUZWFyZG93bik6CisgICAgICAgICog VUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAoV2ViUGFnZVByb3h5KToKKyAgICAg ICAgKiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2Vi UHJvY2Vzc1Byb3h5Ojp1c2VyUmVxdWVzdGVkVGVybWluYXRlKToKKyAgICAgICAgKFdlYktpdCk6 CisgICAgICAgICogVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oOgorICAgICAgICAoV2ViUHJv Y2Vzc1Byb3h5KToKKwogMjAxMy0wNC0wNSAgRWQgQmFydG9zaCAgPGJhcnRvc2hAZ21haWwuY29t PgogCiAgICAgICAgIFtXSzJdIC0tbm8tdGlsZWQtYmFja2luZy1zdG9yZSBidWlsZCBmYWlscyBi ZWNhdXNlIEZsb2F0UG9pbnQgaXMgbm90IGRlY2xhcmVkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9XZWJQYWdlUHJveHkuY3BwCmluZGV4IDg1MTczNDAuLmY0OWRiYTkgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCkBAIC0xNTY3LDcgKzE1NjcsOCBAQCB2b2lk IFdlYlBhZ2VQcm94eTo6dGVybWluYXRlUHJvY2VzcygpCiAgICAgaWYgKCFtX2lzVmFsaWQpCiAg ICAgICAgIHJldHVybjsKIAotICAgIG1fcHJvY2Vzcy0+dGVybWluYXRlKCk7CisgICAgbV9wcm9j ZXNzLT51c2VyUmVxdWVzdGVkVGVybWluYXRlKCk7CisgICAgcHJvY2Vzc1RlYXJkb3duKCk7CiB9 CiAKICNpZiAhVVNFKENGKSB8fCBkZWZpbmVkKEJVSUxESU5HX1FUX18pCkBAIC0zNzk4LDggKzM3 OTksMjIgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRCZWNvbWVSZXNwb25zaXZlKCkK IAogdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCgpCiB7Ci0gICAgQVNTRVJUKG1f cGFnZUNsaWVudCk7CisgICAgaWYgKCFtX2lzVmFsaWQpCisgICAgICAgIHJldHVybjsKKworICAg IHByb2Nlc3NUZWFyZG93bigpOwogCisgICAgLy8gQWZ0ZXIgcmVtb3ZpbmcgdGhlIG1lc3NhZ2Ug cmVjZWl2ZXJzIGFuZCBjbGVhbmluZyB1cCByZXNvdXJjZXMsIHdlCisgICAgLy8gbm90aWZ5IHRo ZSBjbGllbnQvcG9ydCB0aGF0IGEgY3Jhc2ggaGFwcGVuZWQuIFRoaXMgZW5zdXJlcworICAgIC8v IHRoYXQgd2UgYXJlIGluIGEgZGVmaW5lZCBzdGF0ZSBhbmQgY2FsbHMgdG8gbG9hZFVSTCgpIG9y IHJlbG9hZCgpCisgICAgLy8gc2hvdWxkIHdvcmsuCisgICAgbV9wYWdlQ2xpZW50LT5wcm9jZXNz RGlkQ3Jhc2goKTsKKyAgICBtX2xvYWRlckNsaWVudC5wcm9jZXNzRGlkQ3Jhc2godGhpcyk7Cit9 CisKK3ZvaWQgV2ViUGFnZVByb3h5Ojpwcm9jZXNzVGVhcmRvd24oKQoreworICAgIEFTU0VSVCht X3BhZ2VDbGllbnQpOwogICAgIG1fcHJvY2Vzcy0+cmVtb3ZlTWVzc2FnZVJlY2VpdmVyKE1lc3Nh Z2VzOjpXZWJQYWdlUHJveHk6Om1lc3NhZ2VSZWNlaXZlck5hbWUoKSwgbV9wYWdlSUQpOwogCiAg ICAgbV9pc1ZhbGlkID0gZmFsc2U7CkBAIC0zODg2LDkgKzM5MDEsNiBAQCB2b2lkIFdlYlBhZ2VQ cm94eTo6cHJvY2Vzc0RpZENyYXNoKCkKIAogICAgIG1fcGVuZGluZ0xlYXJuT3JJZ25vcmVXb3Jk TWVzc2FnZUNvdW50ID0gMDsKIAotICAgIG1fcGFnZUNsaWVudC0+cHJvY2Vzc0RpZENyYXNoKCk7 Ci0gICAgbV9sb2FkZXJDbGllbnQucHJvY2Vzc0RpZENyYXNoKHRoaXMpOwotCiAgICAgaWYgKCFt X2lzVmFsaWQpIHsKICAgICAgICAgLy8gSWYgdGhlIGNhbGwgb3V0IHRvIHRoZSBsb2FkZXIgY2xp ZW50IGRpZG4ndCBjYXVzZSB0aGUgd2ViIHByb2Nlc3MgdG8gYmUgcmVsYXVuY2hlZCwgCiAgICAg ICAgIC8vIHdlJ2xsIGNhbGwgc2V0TmVlZHNEaXNwbGF5IG9uIHRoZSB2aWV3IHNvIHRoYXQgd2Ug d29uJ3QgaGF2ZSB0aGUgb2xkIGNvbnRlbnRzIHNob3dpbmcuCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvV2ViUGFnZVByb3h5LmgKaW5kZXggYzgwMGI5Yi4uNjY2MmY2NiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaApAQCAtNjAxLDYgKzYwMSw3IEBAIHB1YmxpYzoKICAg ICB2b2lkIGludGVyYWN0aW9uT2NjdXJyZWRXaGlsZVByb2Nlc3NVbnJlc3BvbnNpdmUoKTsKICAg ICB2b2lkIHByb2Nlc3NEaWRCZWNvbWVSZXNwb25zaXZlKCk7CiAgICAgdm9pZCBwcm9jZXNzRGlk Q3Jhc2goKTsKKyAgICB2b2lkIHByb2Nlc3NUZWFyZG93bigpOwogCiAjaWYgVVNFKEFDQ0VMRVJB VEVEX0NPTVBPU0lUSU5HKQogICAgIHZpcnR1YWwgdm9pZCBlbnRlckFjY2VsZXJhdGVkQ29tcG9z aXRpbmdNb2RlKGNvbnN0IExheWVyVHJlZUNvbnRleHQmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKaW5kZXggNmM2NDhkZC4uZDRmNTMwMCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKQEAgLTYyNiw0ICs2 MjYsMTEgQEAgdm9pZCBXZWJQcm9jZXNzUHJveHk6OnBhZ2VQcmVmZXJlbmNlc0NoYW5nZWQoV2Vi S2l0OjpXZWJQYWdlUHJveHkgKnBhZ2UpCiAjZW5kaWYKIH0KIAordm9pZCBXZWJQcm9jZXNzUHJv eHk6OnVzZXJSZXF1ZXN0ZWRUZXJtaW5hdGUoKQoreworICAgIENoaWxkUHJvY2Vzc1Byb3h5Ojp0 ZXJtaW5hdGUoKTsKKyAgICB3ZWJDb25uZWN0aW9uKCktPmRpZENsb3NlKCk7CisgICAgZGlzY29u bmVjdCgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9XZWJQcm9jZXNzUHJveHkuaAppbmRleCBkMzM1Y2UxLi5kMjAyZGIwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmgKKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCkBAIC0xMTUsNiArMTE1LDggQEAg cHVibGljOgogICAgIHZvaWQgdXBkYXRlUHJvY2Vzc1N1cHByZXNzaW9uU3RhdGUoKTsKICNlbmRp ZgogCisgICAgdm9pZCB1c2VyUmVxdWVzdGVkVGVybWluYXRlKCk7CisKIHByaXZhdGU6CiAgICAg ZXhwbGljaXQgV2ViUHJvY2Vzc1Byb3h5KFBhc3NSZWZQdHI8V2ViQ29udGV4dD4pOwogCi0tIAox LjcuMTAuNAoK 196846 2013-04-08 05:46:27 -0700 2013-04-08 13:09:17 -0700 With new test (load, crash, load) 0001-WebProcess-termination-now-is-done-using-a-new-funct.patch text/plain 17520 savagobr RnJvbSAxYzcwOTIzMDY1ODE4YzAwNTdiNjVjMmE0ZDYyMTdhMGNiYjc1ZWMzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBZGVuaWxzb24gQ2F2YWxjYW50aSA8Y2F2YWxjYW50aWlAZ21h aWwuY29tPgpEYXRlOiBTdW4sIDcgQXByIDIwMTMgMTE6MTY6NTkgLTA0MDAKU3ViamVjdDogW1BB VENIXSBXZWJQcm9jZXNzIHRlcm1pbmF0aW9uIG5vdyBpcyBkb25lIHVzaW5nIGEgbmV3IGZ1bmN0 aW9uCiAndXNlclJlcXVlc3RlZFRlcm1pbmF0ZScgdGhhdCBwZXJmb3JtcyBjb21wbGV0ZSBzaHV0 ZG93biBvZgogV2ViUHJvY2Vzc1Byb3h5IGJlZm9yZSByZXR1cm5pbmcuIFRoaXMgZW5zdXJlcyB0 aGF0IGF0IHRpbWUKIHJlYXR0YWNoVG9XZWJQcm9jZXNzKCkgaXMgZXhlY3V0ZWQsIFdlYlByb2Nl c3NQcm94eSBpcyBpbiBhCiBzYW5lIHN0YXRlLgoKTmV4dCwgY2xlYW51cCBvZiBXZWJQYWdlUHJv eHkgaXMgZG9uZSBhdCB0ZXJtaW5hdGVQcm9jZXNzKCksIHVzaW5nIGEgbmV3IGZ1bmN0aW9uIG5h bWVkICdwcm9jZXNzVGVhcmRvd24oKScsCnRoYXQgaXMgc2hhcmVkIHdpdGggcHJvY2Vzc0RpZENy YXNoKCkuIEZpbmFsbHksIGNsaWVudCBpcyBub3Qgbm90aWZpZWQgb2YgcHJvY2VzcyBjcmFzaCwg c2luY2UgaXQgd2FzCnRlcm1pbmF0ZWQgcGVyIGNsaWVudCdzIHJlcXVlc3QuCgpUaGlzIGNoYW5n ZXMgbWFrZXMgdGhlIG5ldyB0ZXN0IHN1Y2NlZWQsIGJ1dCB3aWxsIGNhdXNlIGEgcmVncmVzc2lv biBpbiBhbGwgdGVzdHMgdGhhdCBkZXBlbmQKb24gYSBjYWxsYmFjayB0byBiZSBleGVjdXRlZCBh dCBwcm9jZXNzIHRlcm1pbmF0aW9uLgoKU2lnbmVkLW9mZi1ieTogQWRlbmlsc29uIENhdmFsY2Fu dGkgPGNhdmFsY2FudGlpQGdtYWlsLmNvbT4KLS0tCiBTb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cg ICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjggKysrKysrCiBTb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcCAgICAgICAgICB8ICAgMjIgKysrKy0KIFNvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaCAgICAgICAgICAgIHwgICAgMSArCiBTb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcCAgICAgICB8ICAgIDcgKysK IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaCAgICAgICAgIHwgICAg MiArCiBUb29scy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgMjUgKysrKysKIFRvb2xzL1Rlc3RXZWJLaXRBUEkvR05VbWFrZWZpbGUuYW0gICAgICAgICAg ICAgICAgIHwgICAgMSArCiBUb29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlICAg ICAgICAgICAgICB8ICAgIDEgKwogLi4uL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiAgICAgICAgfCAgICA0ICsKIC4uLi9UZXN0cy9XZWJLaXQyL0xvYWRQYWdlT25DcmFz aC5jcHAgICAgICAgICAgICAgIHwgIDEwMiArKysrKysrKysrKysrKysrKysrKwogVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvICAgICAgfCAgICAxICsKIDExIGZp bGVzIGNoYW5nZWQsIDE4OSBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2FkUGFnZU9uQ3Jh c2guY3BwCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIvU291cmNlL1dl YktpdDIvQ2hhbmdlTG9nCmluZGV4IGE0NzUxMzQuLjliNDQxMDMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzMSBAQAorMjAxMy0wNC0wNyAgQWRlbmlsc29uIENhdmFsY2FudGkgIDxjYXZhbGNhbnRp aUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dLMl0gV2ViUGFnZVByb3h5IGxvYWRVUkwoKSB3b24n dCB3b3JrIHdoZW4gY2FsbGVkIGp1c3QgYWZ0ZXIgdGVybWluYXRlUHJvY2VzcygpCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTA3NDMKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZWJQYWdlUHJveHkgc2hv dWxkIGRvIGl0cyByZXNvdXJjZXMgY2xlYW4gdXAgYXMgc29vbiBhcyBleGVjdXRpbmcgdGhlIGNh bGwgdG8gdGVybWluYXRlLgorCisgICAgICAgIEl0cyBzdGF0ZSB3aWxsIGJlIHVuZGVmaW5lZCBp ZiBkZXBlbmRpbmcgb24gdGhlIGV4ZWN1dGlvbiBvZiBwcm9jZXNzRGlkQ3Jhc2goKSwgdGh1cyB0 aGlzCisgICAgICAgIHBhdGNoIG1vdmVzIHRoZSBjbGVhbnVwIGNvZGUgdG8gYSBzaGFyZWQgcHJp dmF0ZSBmdW5jdGlvbiB0aGF0IGlzIHVzZWQgZm9yIGJvdGggdGhlIGNhc2VzCisgICAgICAgIGku ZS4gdXNlciB0ZXJtaW5hdGlvbiBhbmQgcmVhbCBjcmFzaC4gV2ViUHJvY2VzcyBzaHV0ZG93biBp cyBkb25lIHVzaW5nIGEgbmV3IG1ldGhvZCB0aGF0CisgICAgICAgIGVuc3VyZXMgdGhhdCBhbGwg Y2xlYW51cCB3YXMgZG9uZSBiZWZvcmUgcmV0dXJuaW5nLiBGaW5hbGx5LCBmb3IgdXNlciByZXF1 ZXN0ZWQgdGVybWluYXRpb24sCisgICAgICAgIGNsaWVudHMgYXJlIG5vIGxvbmdlciBub3RpZmll ZCBvZiBjcmFzaC4KKworICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnRlcm1pbmF0ZVByb2Nlc3MpOgorICAgICAgICAo V2ViS2l0OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCk6CisgICAgICAgIChXZWJLaXQp OgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NUZWFyZG93bik6CisgICAg ICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAoV2ViUGFnZVByb3h5KToK KyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcDoKKyAgICAgICAgKFdlYktp dDo6V2ViUHJvY2Vzc1Byb3h5Ojp1c2VyUmVxdWVzdGVkVGVybWluYXRlKToKKyAgICAgICAgKFdl YktpdCk6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oOgorICAgICAgICAo V2ViUHJvY2Vzc1Byb3h5KToKKwogMjAxMy0wNC0wNSAgRWQgQmFydG9zaCAgPGJhcnRvc2hAZ21h aWwuY29tPgogCiAgICAgICAgIFtXSzJdIC0tbm8tdGlsZWQtYmFja2luZy1zdG9yZSBidWlsZCBm YWlscyBiZWNhdXNlIEZsb2F0UG9pbnQgaXMgbm90IGRlY2xhcmVkCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCmluZGV4IDg1MTczNDAuLmY0OWRiYTkgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCkBAIC0xNTY3LDcgKzE1NjcsOCBA QCB2b2lkIFdlYlBhZ2VQcm94eTo6dGVybWluYXRlUHJvY2VzcygpCiAgICAgaWYgKCFtX2lzVmFs aWQpCiAgICAgICAgIHJldHVybjsKIAotICAgIG1fcHJvY2Vzcy0+dGVybWluYXRlKCk7CisgICAg bV9wcm9jZXNzLT51c2VyUmVxdWVzdGVkVGVybWluYXRlKCk7CisgICAgcHJvY2Vzc1RlYXJkb3du KCk7CiB9CiAKICNpZiAhVVNFKENGKSB8fCBkZWZpbmVkKEJVSUxESU5HX1FUX18pCkBAIC0zNzk4 LDggKzM3OTksMjIgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRCZWNvbWVSZXNwb25z aXZlKCkKIAogdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCgpCiB7Ci0gICAgQVNT RVJUKG1fcGFnZUNsaWVudCk7CisgICAgaWYgKCFtX2lzVmFsaWQpCisgICAgICAgIHJldHVybjsK KworICAgIHByb2Nlc3NUZWFyZG93bigpOwogCisgICAgLy8gQWZ0ZXIgcmVtb3ZpbmcgdGhlIG1l c3NhZ2UgcmVjZWl2ZXJzIGFuZCBjbGVhbmluZyB1cCByZXNvdXJjZXMsIHdlCisgICAgLy8gbm90 aWZ5IHRoZSBjbGllbnQvcG9ydCB0aGF0IGEgY3Jhc2ggaGFwcGVuZWQuIFRoaXMgZW5zdXJlcwor ICAgIC8vIHRoYXQgd2UgYXJlIGluIGEgZGVmaW5lZCBzdGF0ZSBhbmQgY2FsbHMgdG8gbG9hZFVS TCgpIG9yIHJlbG9hZCgpCisgICAgLy8gc2hvdWxkIHdvcmsuCisgICAgbV9wYWdlQ2xpZW50LT5w cm9jZXNzRGlkQ3Jhc2goKTsKKyAgICBtX2xvYWRlckNsaWVudC5wcm9jZXNzRGlkQ3Jhc2godGhp cyk7Cit9CisKK3ZvaWQgV2ViUGFnZVByb3h5Ojpwcm9jZXNzVGVhcmRvd24oKQoreworICAgIEFT U0VSVChtX3BhZ2VDbGllbnQpOwogICAgIG1fcHJvY2Vzcy0+cmVtb3ZlTWVzc2FnZVJlY2VpdmVy KE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6Om1lc3NhZ2VSZWNlaXZlck5hbWUoKSwgbV9wYWdlSUQp OwogCiAgICAgbV9pc1ZhbGlkID0gZmFsc2U7CkBAIC0zODg2LDkgKzM5MDEsNiBAQCB2b2lkIFdl YlBhZ2VQcm94eTo6cHJvY2Vzc0RpZENyYXNoKCkKIAogICAgIG1fcGVuZGluZ0xlYXJuT3JJZ25v cmVXb3JkTWVzc2FnZUNvdW50ID0gMDsKIAotICAgIG1fcGFnZUNsaWVudC0+cHJvY2Vzc0RpZENy YXNoKCk7Ci0gICAgbV9sb2FkZXJDbGllbnQucHJvY2Vzc0RpZENyYXNoKHRoaXMpOwotCiAgICAg aWYgKCFtX2lzVmFsaWQpIHsKICAgICAgICAgLy8gSWYgdGhlIGNhbGwgb3V0IHRvIHRoZSBsb2Fk ZXIgY2xpZW50IGRpZG4ndCBjYXVzZSB0aGUgd2ViIHByb2Nlc3MgdG8gYmUgcmVsYXVuY2hlZCwg CiAgICAgICAgIC8vIHdlJ2xsIGNhbGwgc2V0TmVlZHNEaXNwbGF5IG9uIHRoZSB2aWV3IHNvIHRo YXQgd2Ugd29uJ3QgaGF2ZSB0aGUgb2xkIGNvbnRlbnRzIHNob3dpbmcuCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmggYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggYzgwMGI5Yi4uNjY2MmY2NiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaApAQCAtNjAxLDYgKzYwMSw3IEBAIHB1Ymxp YzoKICAgICB2b2lkIGludGVyYWN0aW9uT2NjdXJyZWRXaGlsZVByb2Nlc3NVbnJlc3BvbnNpdmUo KTsKICAgICB2b2lkIHByb2Nlc3NEaWRCZWNvbWVSZXNwb25zaXZlKCk7CiAgICAgdm9pZCBwcm9j ZXNzRGlkQ3Jhc2goKTsKKyAgICB2b2lkIHByb2Nlc3NUZWFyZG93bigpOwogCiAjaWYgVVNFKEFD Q0VMRVJBVEVEX0NPTVBPU0lUSU5HKQogICAgIHZpcnR1YWwgdm9pZCBlbnRlckFjY2VsZXJhdGVk Q29tcG9zaXRpbmdNb2RlKGNvbnN0IExheWVyVHJlZUNvbnRleHQmKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKaW5kZXggNmM2NDhkZC4uZDRmNTMwMCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKQEAgLTYy Niw0ICs2MjYsMTEgQEAgdm9pZCBXZWJQcm9jZXNzUHJveHk6OnBhZ2VQcmVmZXJlbmNlc0NoYW5n ZWQoV2ViS2l0OjpXZWJQYWdlUHJveHkgKnBhZ2UpCiAjZW5kaWYKIH0KIAordm9pZCBXZWJQcm9j ZXNzUHJveHk6OnVzZXJSZXF1ZXN0ZWRUZXJtaW5hdGUoKQoreworICAgIENoaWxkUHJvY2Vzc1By b3h5Ojp0ZXJtaW5hdGUoKTsKKyAgICB3ZWJDb25uZWN0aW9uKCktPmRpZENsb3NlKCk7CisgICAg ZGlzY29ubmVjdCgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaAppbmRleCBkMzM1Y2UxLi5kMjAyZGIwIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmgKKysrIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCkBAIC0xMTUsNiArMTE1 LDggQEAgcHVibGljOgogICAgIHZvaWQgdXBkYXRlUHJvY2Vzc1N1cHByZXNzaW9uU3RhdGUoKTsK ICNlbmRpZgogCisgICAgdm9pZCB1c2VyUmVxdWVzdGVkVGVybWluYXRlKCk7CisKIHByaXZhdGU6 CiAgICAgZXhwbGljaXQgV2ViUHJvY2Vzc1Byb3h5KFBhc3NSZWZQdHI8V2ViQ29udGV4dD4pOwog CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggODFi NjA1NS4uMDdmNGZmNiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0No YW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDEzLTA0LTA3ICBBZGVuaWxzb24gQ2F2YWxjYW50 aSAgPGNhdmFsY2FudGlpQGdtYWlsLmNvbT4KKworICAgICAgICBbV0syXSBXZWJQYWdlUHJveHkg bG9hZFVSTCgpIHdvbid0IHdvcmsgd2hlbiBjYWxsZWQganVzdCBhZnRlciB0ZXJtaW5hdGVQcm9j ZXNzKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEx MDc0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZGluZyBhIG5ldyB0ZXN0IGZpbGUgdG8gY2hlY2sgaWYgbG9hZGluZyBhIHBhZ2UganVzdCBhZnRl ciBXZWJQcm9jZXNzCisgICAgICAgIGhhcyBjcmFzaGVkIChvciB3YXMgdGVybWluYXRlZCkgd29y a3MuIFRoZSB0ZXN0IGV4ZWN1dGVzIHRoZQorICAgICAgICBmb2xsb3dpbmcgc3RlcHMgKExvYWQs IENyYXNoLCBMb2FkKSwgdGh1cyBzdHJlc3NpbmcgV2ViUHJvY2VzcworICAgICAgICByZWF0dGFj aCBhbmQgcHJvY2VzcyB0ZXJtaW5hdGlvbiBjb2RlIHBhdGguCisKKyAgICAgICAgKiBUZXN0V2Vi S2l0QVBJL0dOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxhdGZvcm1F ZmwuY21ha2U6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy L0xvYWRQYWdlT25DcmFzaC5jcHA6IEFkZGVkLgorICAgICAgICAoVGVzdFdlYktpdEFQSSk6Cisg ICAgICAgIChXZWJLaXQyQ3Jhc2hMb2FkZXIpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6V2Vi S2l0MkNyYXNoTG9hZGVyOjpXZWJLaXQyQ3Jhc2hMb2FkZXIpOgorICAgICAgICAoVGVzdFdlYktp dEFQSTo6V2ViS2l0MkNyYXNoTG9hZGVyOjpsb2FkVXJsKToKKyAgICAgICAgKFRlc3RXZWJLaXRB UEk6OldlYktpdDJDcmFzaExvYWRlcjo6Y3Jhc2hXZWJQcm9jZXNzKToKKyAgICAgICAgKFRlc3RX ZWJLaXRBUEk6OmRpZEZpbmlzaExvYWQpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6 CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvOgorCiAy MDEzLTA0LTA1ICBPamFuIFZhZmFpICA8b2phbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgTW92 ZSB0aGUgZmxha2luZXNzIGRhc2hib2FyZCB0byB0aGUgbmV3IGluc3RhbmNlIGF0IHdlYmtpdC10 ZXN0LXJlc3VsdHMuYXBwc3BvdC5jb20KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkv R05VbWFrZWZpbGUuYW0gYi9Ub29scy9UZXN0V2ViS2l0QVBJL0dOVW1ha2VmaWxlLmFtCmluZGV4 IDM0NGY2MGIuLjliMjBlMDMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvR05VbWFr ZWZpbGUuYW0KKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9HTlVtYWtlZmlsZS5hbQpAQCAtMTU1 LDYgKzE1NSw3IEBAIFByb2dyYW1zX1Rlc3RXZWJLaXRBUElfVGVzdFdlYktpdDJfU09VUkNFUyA9 IFwKIAlUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvSW5qZWN0ZWRCdW5kbGVJbml0 aWFsaXphdGlvblVzZXJEYXRhQ2FsbGJhY2tXaW5zLmNwcCBcCiAJVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XZWJLaXQyL0xvYWRBbHRlcm5hdGVIVE1MU3RyaW5nV2l0aE5vbkRpcmVjdG9yeVVS TC5jcHAgXAogCVRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2FkQ2FuY2VsZWRO b1NlcnZlclJlZGlyZWN0Q2FsbGJhY2suY3BwIFwKKwlUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dlYktpdDIvTG9hZFBhZ2VPbkNyYXNoLmNwcCBcCiAJVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0 cy9XZWJLaXQyL01vdXNlTW92ZUFmdGVyQ3Jhc2guY3BwIFwKIAlUb29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdDIvUmVsb2FkUGFnZUFmdGVyQ3Jhc2guY3BwIFwKIAlUb29scy9UZXN0V2Vi S2l0QVBJL1Rlc3RzL1dlYktpdDIvUmVzaXplV2luZG93QWZ0ZXJDcmFzaC5jcHAgXApkaWZmIC0t Z2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggYTcxNzU1OS4uM2JjNDRjMyAxMDA2NDQK LS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQorKysgYi9Ub29scy9U ZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC02OCw2ICs2OCw3IEBAIHNldCh0ZXN0 X3dlYmtpdDJfYXBpX0JJTkFSSUVTCiAgICAgSW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVz ZXJEYXRhQ2FsbGJhY2tXaW5zCiAgICAgTG9hZEFsdGVybmF0ZUhUTUxTdHJpbmdXaXRoTm9uRGly ZWN0b3J5VVJMCiAgICAgTG9hZENhbmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxiYWNrCisgICAg TG9hZFBhZ2VPbkNyYXNoCiAgICAgTW91c2VNb3ZlQWZ0ZXJDcmFzaAogICAgIFJlbG9hZFBhZ2VB ZnRlckNyYXNoCiAgICAgUmVzaXplV2luZG93QWZ0ZXJDcmFzaApkaWZmIC0tZ2l0IGEvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agppbmRleCA1ZjY2YjA5Li42NjA4NjhkIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Ub29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtOTEs NiArOTEsNyBAQAogCQk4MUI1MDE5MzE0MEYyMzIzMDBEOUVCNTggLyogU3RyaW5nQnVpbGRlci5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4MUI1MDE5 MjE0MEYyMzIzMDBEOUVCNTggLyogU3RyaW5nQnVpbGRlci5jcHAgKi87IH07CiAJCThBMkM3NTBF MTZDRUQ5NTUwMDI0RjM1MiAvKiBSZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBMkM3NTBEMTZDRUQ5NTUwMDI0 RjM1MiAvKiBSZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcCAqLzsgfTsKIAkJOEEzQUY5M0IxNkM5 RUQyNzAwRDI0OEMxIC8qIFJlbG9hZFBhZ2VBZnRlckNyYXNoLmNwcCBpbiBTb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBM0FGOTNBMTZDOUVEMjcwMEQyNDhDMSAv KiBSZWxvYWRQYWdlQWZ0ZXJDcmFzaC5jcHAgKi87IH07CisJCThBQTI4QzFBMTZEMkZBN0IwMDJG RjREQiAvKiBMb2FkUGFnZU9uQ3Jhc2guY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gOEFBMjhDMTkxNkQyRkE3QjAwMkZGNERCIC8qIExvYWRQYWdlT25D cmFzaC5jcHAgKi87IH07CiAJCTkzMEFENDAyMTUwNjk4RDAwMDY3OTcwRiAvKiBsb3RzLW9mLXRl eHQuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA5MzBBRDQwMTE1MDY5OEIzMDA2Nzk3MEYgLyogbG90cy1vZi10ZXh0Lmh0bWwgKi87IH07 CiAJCTkzMTg3Nzg5MTVFRUM1NzcwMEE5Q0NFMyAvKiBOZXdGaXJzdFZpc3VhbGx5Tm9uRW1wdHlM YXlvdXRGb3JJbWFnZXMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gOTNBRjRFQ0ExNTA2RjAzNTAwN0ZENTdFIC8qIE5ld0ZpcnN0VmlzdWFsbHlOb25F bXB0eUxheW91dEZvckltYWdlcy5jcHAgKi87IH07CiAJCTkzNjEwMDI5MTREQzk1QTcwMDYxMzc5 RCAvKiBsb3RzLW9mLWlmcmFtZXMuaHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzYxMDAyODE0REM5NTdCMDA2MTM3OUQgLyogbG90cy1v Zi1pZnJhbWVzLmh0bWwgKi87IH07CkBAIC0zNTksNiArMzYwLDcgQEAKIAkJODFCNTAxOTIxNDBG MjMyMzAwRDlFQjU4IC8qIFN0cmluZ0J1aWxkZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBuYW1lID0gU3RyaW5nQnVpbGRlci5jcHA7IHBhdGggPSBXVEYvU3RyaW5nQnVpbGRl ci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThBMkM3NTBEMTZDRUQ5NTUwMDI0 RjM1MiAvKiBSZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IFJlc2l6ZVdpbmRvd0FmdGVyQ3Jhc2guY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk4QTNBRjkzQTE2QzlFRDI3MDBEMjQ4QzEgLyogUmVsb2FkUGFnZUFm dGVyQ3Jhc2guY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVsb2Fk UGFnZUFmdGVyQ3Jhc2guY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4QUEyOEMx OTE2RDJGQTdCMDAyRkY0REIgLyogTG9hZFBhZ2VPbkNyYXNoLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IExvYWRQYWdlT25DcmFzaC5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCThERDc2RkExMDQ4NkFBNzYwMEQ5NkI1RSAvKiBUZXN0V2ViS2l0QVBJ ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGV4cGxpY2l0RmlsZVR5cGUgPSAiY29tcGls ZWQubWFjaC1vLmV4ZWN1dGFibGUiOyBpbmNsdWRlSW5JbmRleCA9IDA7IHBhdGggPSBUZXN0V2Vi S2l0QVBJOyBzb3VyY2VUcmVlID0gQlVJTFRfUFJPRFVDVFNfRElSOyB9OwogCQk5MzBBRDQwMTE1 MDY5OEIzMDA2Nzk3MEYgLyogbG90cy1vZi10ZXh0Lmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7 IHBhdGggPSAibG90cy1vZi10ZXh0Lmh0bWwiOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQk5MzYxMDAyODE0REM5NTdCMDA2MTM3OUQgLyogbG90cy1vZi1pZnJhbWVzLmh0bWwgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSB0ZXh0Lmh0bWw7IHBhdGggPSAibG90cy1vZi1pZnJhbWVzLmh0bWwiOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwpAQCAtNjYyLDYgKzY2NCw3IEBACiAJCQkJNTJDQjQ3NDAxNDQ4RkI5 MzAwODczOTk1IC8qIExvYWRBbHRlcm5hdGVIVE1MU3RyaW5nV2l0aE5vbkRpcmVjdG9yeVVSTC5j cHAgKi8sCiAJCQkJMzNEQzg5MTAxNDE5NTNBMzAwNzQ3RUY3IC8qIExvYWRDYW5jZWxlZE5vU2Vy dmVyUmVkaXJlY3RDYWxsYmFjay5jcHAgKi8sCiAJCQkJMzNEQzg5MTMxNDE5NTc5RjAwNzQ3RUY3 IC8qIExvYWRDYW5jZWxlZE5vU2VydmVyUmVkaXJlY3RDYWxsYmFja19CdW5kbGUuY3BwICovLAor CQkJCThBQTI4QzE5MTZEMkZBN0IwMDJGRjREQiAvKiBMb2FkUGFnZU9uQ3Jhc2guY3BwICovLAog CQkJCTMzQkU1QUY0MTM3QjVBNkMwMDcwNTgxMyAvKiBNb3VzZU1vdmVBZnRlckNyYXNoLmNwcCAq LywKIAkJCQkzM0JFNUFGODEzN0I1QUFFMDA3MDU4MTMgLyogTW91c2VNb3ZlQWZ0ZXJDcmFzaF9C dW5kbGUuY3BwICovLAogCQkJCTkzRjFEQjMwMTREQTIwNzYwMDI0QzM2MiAvKiBOZXdGaXJzdFZp c3VhbGx5Tm9uRW1wdHlMYXlvdXQuY3BwICovLApAQCAtMTA0MSw2ICsxMDQ0LDcgQEAKIAkJCQky NjMwMEIxODE2NzU1Q0Q5MDA2Njg4NkQgLyogTGlzdEhhc2hTZXQuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJNTJDQjQ3NDExNDQ4RkI5MzAwODczOTk1IC8qIExvYWRBbHRlcm5hdGVIVE1MU3RyaW5n V2l0aE5vbkRpcmVjdG9yeVVSTC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkzM0RDODkxMTE0MTk1 M0EzMDA3NDdFRjcgLyogTG9hZENhbmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxiYWNrLmNwcCBp biBTb3VyY2VzICovLAorCQkJCThBQTI4QzFBMTZEMkZBN0IwMDJGRjREQiAvKiBMb2FkUGFnZU9u Q3Jhc2guY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQjQwMzlGOUQxNUU2RDhCMzAwNzI1NUQ2IC8q IE1hdGhFeHRyYXMuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQ0Q1NDk3QjQxNTg1N0YwQzAwQjVC QzMwIC8qIE1lZGlhVGltZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlFMTIyMERBMDE1NUIyNTQ4 MDAxM0UyRkMgLyogTWVtb3J5Q2FjaGVEaXNhYmxlV2l0aGluUmVzb3VyY2VMb2FkRGVsZWdhdGUu bW0gaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mi9Mb2FkUGFnZU9uQ3Jhc2guY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9X ZWJLaXQyL0xvYWRQYWdlT25DcmFzaC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uNTYzMmQ1NAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mi9Mb2FkUGFnZU9uQ3Jhc2guY3BwCkBAIC0wLDAgKzEsMTAyIEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDEzIEFkZW5pbHNvbiBDYXZhbGNhbnRpIDxjYXZhbGNhbnRpaUBnbWFp bC5jb20+CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisg KiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAq IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJQbGF0Zm9y bVV0aWxpdGllcy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtV2ViVmlldy5oIgorI2luY2x1ZGUgIlRl c3QuaCIKKyNpbmNsdWRlIDxXZWJLaXQyL1dLUmV0YWluUHRyLmg+CisKK25hbWVzcGFjZSBUZXN0 V2ViS2l0QVBJIHsKKworc3RhdGljIHZvaWQgZGlkRmluaXNoTG9hZChXS1BhZ2VSZWYsIFdLRnJh bWVSZWYsIFdLVHlwZVJlZiwgY29uc3Qgdm9pZCopOworCitjbGFzcyBXZWJLaXQyQ3Jhc2hMb2Fk ZXIgeworcHVibGljOgorICAgIFdlYktpdDJDcmFzaExvYWRlcigpCisgICAgICAgIDogY29udGV4 dChBZG9wdFdLLCBXS0NvbnRleHRDcmVhdGUoKSkKKyAgICAgICAgLCB3ZWJWaWV3KGNvbnRleHQu Z2V0KCkpCisgICAgICAgICwgdXJsKGFkb3B0V0soV0tVUkxDcmVhdGVXaXRoVVRGOENTdHJpbmco ImFib3V0OmJsYW5rIikpKQorICAgICAgICAsIGZpcnN0U3VjY2Vzc2Z1bExvYWQoZmFsc2UpCisg ICAgICAgICwgc2Vjb25kU3VjY2Vzc2Z1bExvYWQoZmFsc2UpCisgICAgeworICAgICAgICBtZW1z ZXQoJmxvYWRlckNsaWVudCwgMCwgc2l6ZW9mKGxvYWRlckNsaWVudCkpOworICAgICAgICBsb2Fk ZXJDbGllbnQuY2xpZW50SW5mbyA9IHRoaXM7CisgICAgICAgIGxvYWRlckNsaWVudC5kaWRGaW5p c2hMb2FkRm9yRnJhbWUgPSBkaWRGaW5pc2hMb2FkOworICAgICAgICBXS1BhZ2VTZXRQYWdlTG9h ZGVyQ2xpZW50KHdlYlZpZXcucGFnZSgpLCAmbG9hZGVyQ2xpZW50KTsKKyAgICB9CisKKyAgICB2 b2lkIGxvYWRVcmwoKQorICAgIHsKKyAgICAgICAgV0tQYWdlTG9hZFVSTCh3ZWJWaWV3LnBhZ2Uo KSwgdXJsLmdldCgpKTsKKyAgICB9CisKKyAgICB2b2lkIGNyYXNoV2ViUHJvY2VzcygpCisgICAg eworICAgICAgICBXS1BhZ2VUZXJtaW5hdGUod2ViVmlldy5wYWdlKCkpOworICAgIH0KKworICAg IFdLUmV0YWluUHRyPFdLQ29udGV4dFJlZj4gY29udGV4dDsKKyAgICBXS1BhZ2VMb2FkZXJDbGll bnQgbG9hZGVyQ2xpZW50OworICAgIFBsYXRmb3JtV2ViVmlldyB3ZWJWaWV3OworICAgIFdLUmV0 YWluUHRyPFdLVVJMUmVmPiB1cmw7CisKKyAgICBib29sIGZpcnN0U3VjY2Vzc2Z1bExvYWQ7Cisg ICAgYm9vbCBzZWNvbmRTdWNjZXNzZnVsTG9hZDsKK307CisKKy8vIFRoaXMgaXMgc2hhcmVkIGZv ciBib3RoIHRlc3RzLCBzaW5jZSB3ZSBhcmUgZ29pbmcgdG8gaGF2ZSAyIGxvYWQgZXZlbnRzCisv LyBpbnRlcnR3aW5lZCBieSBhIGNyYXNoIChpLmUuIExvYWQgLT4gQ3Jhc2ggLT4gTG9hZCkuCit2 b2lkIGRpZEZpbmlzaExvYWQoV0tQYWdlUmVmIHBhZ2UsIFdLRnJhbWVSZWYgZnJhbWUsIFdLVHlw ZVJlZiB1c2VyRGF0YSwgY29uc3Qgdm9pZCogY2xpZW50SW5mbykKK3sKKyAgICBXZWJLaXQyQ3Jh c2hMb2FkZXIqIHRlc3RIZWxwZXIgPSBjb25zdF9jYXN0PFdlYktpdDJDcmFzaExvYWRlcio+KHN0 YXRpY19jYXN0PGNvbnN0IFdlYktpdDJDcmFzaExvYWRlcio+KGNsaWVudEluZm8pKTsKKworICAg IC8vIEZpcnN0IGxvYWQgd29ya2VkLCBsZXQncyBjcmFzaCBXZWJQcm9jZXNzLgorICAgIGlmICgh dGVzdEhlbHBlci0+Zmlyc3RTdWNjZXNzZnVsTG9hZCkgeworICAgICAgICB0ZXN0SGVscGVyLT5m aXJzdFN1Y2Nlc3NmdWxMb2FkID0gdHJ1ZTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAg IC8vIFNlY29uZCBsb2FkIHdvcmtlZCwgd2UgYXJlIGRvbmUuCisgICAgRVhQRUNUX1RSVUUodGVz dEhlbHBlci0+Zmlyc3RTdWNjZXNzZnVsTG9hZCk7CisgICAgaWYgKCF0ZXN0SGVscGVyLT5zZWNv bmRTdWNjZXNzZnVsTG9hZCkgeworICAgICAgICB0ZXN0SGVscGVyLT5zZWNvbmRTdWNjZXNzZnVs TG9hZCA9IHRydWU7CisgICAgICAgIHJldHVybjsKKyAgICB9Cit9CisKKy8vIFRoaXMgdGVzdCB3 aWxsIGxvYWQgYSBibGFuayBwYWdlIGFuZCBuZXh0IGtpbGwgV2ViUHJvY2VzcywgdGhlIGV4cGVj dGVkCisvLyByZXN1bHQgaXMgdGhhdCBhIGNhbGwgdG8gcGFnZSBsb2FkIHNob3VsZCBzcGF3biBh IG5ldyBXZWJQcm9jZXNzLgorVEVTVChXZWJLaXQyLCBMb2FkUGFnZUFmdGVyQ3Jhc2gpCit7Cisg ICAgV2ViS2l0MkNyYXNoTG9hZGVyIGhlbHBlcjsKKyAgICBoZWxwZXIubG9hZFVybCgpOworICAg IFV0aWw6OnJ1bigmaGVscGVyLmZpcnN0U3VjY2Vzc2Z1bExvYWQpOworICAgIGhlbHBlci5jcmFz aFdlYlByb2Nlc3MoKTsKKyAgICBoZWxwZXIubG9hZFVybCgpOworICAgIFV0aWw6OnJ1bigmaGVs cGVyLnNlY29uZFN1Y2Nlc3NmdWxMb2FkKTsKK30KKworfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktp dEFQSQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktp dDIucHJvIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvCmlu ZGV4IDk0NTJhNWEuLjFkMDYzNzkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mi9XZWJLaXQyLnBybworKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDIvV2ViS2l0Mi5wcm8KQEAgLTE5LDYgKzE5LDcgQEAgU09VUkNFUyArPSBcCiAgICAgSW5q ZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRhQ2FsbGJhY2tXaW5zLmNwcCBcCiAgICAg TG9hZEFsdGVybmF0ZUhUTUxTdHJpbmdXaXRoTm9uRGlyZWN0b3J5VVJMLmNwcCBcCiAgICAgTG9h ZENhbmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxiYWNrLmNwcCBcCisgICAgTG9hZFBhZ2VPbkNy YXNoLmNwcCBcCiAgICAgTW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHAgXAogICAgIFBhZ2VMb2FkQmFz aWMuY3BwIFwKICAgICBQYWdlTG9hZERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZUZvckZyYW1l LmNwcCBcCi0tIAoxLjcuMTAuNAoK 196945 2013-04-08 13:09:17 -0700 2013-04-11 10:46:17 -0700 Fixed failing unit test WKTerminateFix_ProxyProcessCleanup_Tests.patch text/plain 19353 savagobr RnJvbSA0YjA1NGUxMDcyYmM4Y2NjZGMwMzUxMjAxYzY0NmJiYWU2ZDIwMjI0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBZGVuaWxzb24gQ2F2YWxjYW50aSA8Y2F2YWxjYW50aWlAZ21h aWwuY29tPgpEYXRlOiBTdW4sIDcgQXByIDIwMTMgMTE6MTY6NTkgLTA0MDAKU3ViamVjdDogW1BB VENIXSBXZWJQcm9jZXNzIHRlcm1pbmF0aW9uIG5vdyBpcyBkb25lIHVzaW5nIGEgbmV3IGZ1bmN0 aW9uCiAndXNlclJlcXVlc3RlZFRlcm1pbmF0ZScgdGhhdCBwZXJmb3JtcyBjb21wbGV0ZSBzaHV0 ZG93biBvZgogV2ViUHJvY2Vzc1Byb3h5IGJlZm9yZSByZXR1cm5pbmcuIFRoaXMgZW5zdXJlcyB0 aGF0IGF0IHRpbWUKIHJlYXR0YWNoVG9XZWJQcm9jZXNzKCkgaXMgZXhlY3V0ZWQsIFdlYlByb2Nl c3NQcm94eSBpcyBpbiBhCiBzYW5lIHN0YXRlLgoKTmV4dCwgY2xlYW51cCBvZiBXZWJQYWdlUHJv eHkgaXMgZG9uZSBhdCB0ZXJtaW5hdGVQcm9jZXNzKCksIHVzaW5nIGEgbmV3IGZ1bmN0aW9uIG5h bWVkICdwcm9jZXNzVGVhcmRvd24oKScsCnRoYXQgaXMgc2hhcmVkIHdpdGggcHJvY2Vzc0RpZENy YXNoKCkuIEZpbmFsbHksIGNsaWVudCBpcyBub3Qgbm90aWZpZWQgb2YgcHJvY2VzcyBjcmFzaCwg c2luY2UgaXQgd2FzCnRlcm1pbmF0ZWQgcGVyIGNsaWVudCdzIHJlcXVlc3QuCgpUaGlzIGNoYW5n ZXMgbWFrZXMgdGhlIG5ldyB0ZXN0IHN1Y2NlZWQgYW5kIGluY2x1ZGUgdGhlIGNoYW5nZXMgcmVx dWlyZWQgdG8gZml4IGZhaWxpbmcgdGVzdC4KClNpZ25lZC1vZmYtYnk6IEFkZW5pbHNvbiBDYXZh bGNhbnRpIDxjYXZhbGNhbnRpaUBnbWFpbC5jb20+Ci0tLQogU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDI4ICsrKysrKwogU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgICAgICAgICAgfCAgIDIyICsrKystCiBTb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmggICAgICAgICAgICB8ICAgIDEgKwog U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAgICAgICAgfCAgICA3 ICsrCiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmggICAgICAgICB8 ICAgIDIgKwogVG9vbHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgIDI4ICsrKysrKwogVG9vbHMvVGVzdFdlYktpdEFQSS9HTlVtYWtlZmlsZS5hbSAgICAg ICAgICAgICAgICAgfCAgICAxICsKIFRvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21h a2UgICAgICAgICAgICAgIHwgICAgMSArCiAuLi4vVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qICAgICAgICB8ICAgIDQgKwogLi4uL1Rlc3RzL1dlYktpdDIvTG9hZFBhZ2VP bkNyYXNoLmNwcCAgICAgICAgICAgICAgfCAgMTAyICsrKysrKysrKysrKysrKysrKysrCiAuLi4v VGVzdHMvV2ViS2l0Mi9Nb3VzZU1vdmVBZnRlckNyYXNoLmNwcCAgICAgICAgICB8ICAgMTIgKy0t CiBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvV2ViS2l0Mi5wcm8gICAgICB8ICAg IDEgKwogMTIgZmlsZXMgY2hhbmdlZCwgMTk1IGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygt KQogY3JlYXRlIG1vZGUgMTAwNjQ0IFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9M b2FkUGFnZU9uQ3Jhc2guY3BwCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9n IGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IGE0NzUxMzQuLjliNDQxMDMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFu Z2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAxMy0wNC0wNyAgQWRlbmlsc29uIENhdmFsY2FudGkg IDxjYXZhbGNhbnRpaUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dLMl0gV2ViUGFnZVByb3h5IGxv YWRVUkwoKSB3b24ndCB3b3JrIHdoZW4gY2FsbGVkIGp1c3QgYWZ0ZXIgdGVybWluYXRlUHJvY2Vz cygpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTA3 NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZWJQ YWdlUHJveHkgc2hvdWxkIGRvIGl0cyByZXNvdXJjZXMgY2xlYW4gdXAgYXMgc29vbiBhcyBleGVj dXRpbmcgdGhlIGNhbGwgdG8gdGVybWluYXRlLgorCisgICAgICAgIEl0cyBzdGF0ZSB3aWxsIGJl IHVuZGVmaW5lZCBpZiBkZXBlbmRpbmcgb24gdGhlIGV4ZWN1dGlvbiBvZiBwcm9jZXNzRGlkQ3Jh c2goKSwgdGh1cyB0aGlzCisgICAgICAgIHBhdGNoIG1vdmVzIHRoZSBjbGVhbnVwIGNvZGUgdG8g YSBzaGFyZWQgcHJpdmF0ZSBmdW5jdGlvbiB0aGF0IGlzIHVzZWQgZm9yIGJvdGggdGhlIGNhc2Vz CisgICAgICAgIGkuZS4gdXNlciB0ZXJtaW5hdGlvbiBhbmQgcmVhbCBjcmFzaC4gV2ViUHJvY2Vz cyBzaHV0ZG93biBpcyBkb25lIHVzaW5nIGEgbmV3IG1ldGhvZCB0aGF0CisgICAgICAgIGVuc3Vy ZXMgdGhhdCBhbGwgY2xlYW51cCB3YXMgZG9uZSBiZWZvcmUgcmV0dXJuaW5nLiBGaW5hbGx5LCBm b3IgdXNlciByZXF1ZXN0ZWQgdGVybWluYXRpb24sCisgICAgICAgIGNsaWVudHMgYXJlIG5vIGxv bmdlciBub3RpZmllZCBvZiBjcmFzaC4KKworICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJv eHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnRlcm1pbmF0ZVByb2Nlc3Mp OgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCk6CisgICAg ICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NUZWFy ZG93bik6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAoV2Vi UGFnZVByb3h5KToKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmNwcDoKKyAg ICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzc1Byb3h5Ojp1c2VyUmVxdWVzdGVkVGVybWluYXRlKToK KyAgICAgICAgKFdlYktpdCk6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5o OgorICAgICAgICAoV2ViUHJvY2Vzc1Byb3h5KToKKwogMjAxMy0wNC0wNSAgRWQgQmFydG9zaCAg PGJhcnRvc2hAZ21haWwuY29tPgogCiAgICAgICAgIFtXSzJdIC0tbm8tdGlsZWQtYmFja2luZy1z dG9yZSBidWlsZCBmYWlscyBiZWNhdXNlIEZsb2F0UG9pbnQgaXMgbm90IGRlY2xhcmVkCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCmluZGV4IDg1MTczNDAuLmY0OWRi YTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCkBAIC0xNTY3 LDcgKzE1NjcsOCBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6dGVybWluYXRlUHJvY2VzcygpCiAgICAg aWYgKCFtX2lzVmFsaWQpCiAgICAgICAgIHJldHVybjsKIAotICAgIG1fcHJvY2Vzcy0+dGVybWlu YXRlKCk7CisgICAgbV9wcm9jZXNzLT51c2VyUmVxdWVzdGVkVGVybWluYXRlKCk7CisgICAgcHJv Y2Vzc1RlYXJkb3duKCk7CiB9CiAKICNpZiAhVVNFKENGKSB8fCBkZWZpbmVkKEJVSUxESU5HX1FU X18pCkBAIC0zNzk4LDggKzM3OTksMjIgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRC ZWNvbWVSZXNwb25zaXZlKCkKIAogdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCgp CiB7Ci0gICAgQVNTRVJUKG1fcGFnZUNsaWVudCk7CisgICAgaWYgKCFtX2lzVmFsaWQpCisgICAg ICAgIHJldHVybjsKKworICAgIHByb2Nlc3NUZWFyZG93bigpOwogCisgICAgLy8gQWZ0ZXIgcmVt b3ZpbmcgdGhlIG1lc3NhZ2UgcmVjZWl2ZXJzIGFuZCBjbGVhbmluZyB1cCByZXNvdXJjZXMsIHdl CisgICAgLy8gbm90aWZ5IHRoZSBjbGllbnQvcG9ydCB0aGF0IGEgY3Jhc2ggaGFwcGVuZWQuIFRo aXMgZW5zdXJlcworICAgIC8vIHRoYXQgd2UgYXJlIGluIGEgZGVmaW5lZCBzdGF0ZSBhbmQgY2Fs bHMgdG8gbG9hZFVSTCgpIG9yIHJlbG9hZCgpCisgICAgLy8gc2hvdWxkIHdvcmsuCisgICAgbV9w YWdlQ2xpZW50LT5wcm9jZXNzRGlkQ3Jhc2goKTsKKyAgICBtX2xvYWRlckNsaWVudC5wcm9jZXNz RGlkQ3Jhc2godGhpcyk7Cit9CisKK3ZvaWQgV2ViUGFnZVByb3h5Ojpwcm9jZXNzVGVhcmRvd24o KQoreworICAgIEFTU0VSVChtX3BhZ2VDbGllbnQpOwogICAgIG1fcHJvY2Vzcy0+cmVtb3ZlTWVz c2FnZVJlY2VpdmVyKE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6Om1lc3NhZ2VSZWNlaXZlck5hbWUo KSwgbV9wYWdlSUQpOwogCiAgICAgbV9pc1ZhbGlkID0gZmFsc2U7CkBAIC0zODg2LDkgKzM5MDEs NiBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6cHJvY2Vzc0RpZENyYXNoKCkKIAogICAgIG1fcGVuZGlu Z0xlYXJuT3JJZ25vcmVXb3JkTWVzc2FnZUNvdW50ID0gMDsKIAotICAgIG1fcGFnZUNsaWVudC0+ cHJvY2Vzc0RpZENyYXNoKCk7Ci0gICAgbV9sb2FkZXJDbGllbnQucHJvY2Vzc0RpZENyYXNoKHRo aXMpOwotCiAgICAgaWYgKCFtX2lzVmFsaWQpIHsKICAgICAgICAgLy8gSWYgdGhlIGNhbGwgb3V0 IHRvIHRoZSBsb2FkZXIgY2xpZW50IGRpZG4ndCBjYXVzZSB0aGUgd2ViIHByb2Nlc3MgdG8gYmUg cmVsYXVuY2hlZCwgCiAgICAgICAgIC8vIHdlJ2xsIGNhbGwgc2V0TmVlZHNEaXNwbGF5IG9uIHRo ZSB2aWV3IHNvIHRoYXQgd2Ugd29uJ3QgaGF2ZSB0aGUgb2xkIGNvbnRlbnRzIHNob3dpbmcuCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmggYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggYzgwMGI5Yi4uNjY2MmY2 NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCisr KyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaApAQCAtNjAxLDYgKzYw MSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGludGVyYWN0aW9uT2NjdXJyZWRXaGlsZVByb2Nlc3NV bnJlc3BvbnNpdmUoKTsKICAgICB2b2lkIHByb2Nlc3NEaWRCZWNvbWVSZXNwb25zaXZlKCk7CiAg ICAgdm9pZCBwcm9jZXNzRGlkQ3Jhc2goKTsKKyAgICB2b2lkIHByb2Nlc3NUZWFyZG93bigpOwog CiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQogICAgIHZpcnR1YWwgdm9pZCBlbnRl ckFjY2VsZXJhdGVkQ29tcG9zaXRpbmdNb2RlKGNvbnN0IExheWVyVHJlZUNvbnRleHQmKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKaW5kZXggNmM2NDhk ZC4uZDRmNTMwMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nl c3NQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94 eS5jcHAKQEAgLTYyNiw0ICs2MjYsMTEgQEAgdm9pZCBXZWJQcm9jZXNzUHJveHk6OnBhZ2VQcmVm ZXJlbmNlc0NoYW5nZWQoV2ViS2l0OjpXZWJQYWdlUHJveHkgKnBhZ2UpCiAjZW5kaWYKIH0KIAor dm9pZCBXZWJQcm9jZXNzUHJveHk6OnVzZXJSZXF1ZXN0ZWRUZXJtaW5hdGUoKQoreworICAgIENo aWxkUHJvY2Vzc1Byb3h5Ojp0ZXJtaW5hdGUoKTsKKyAgICB3ZWJDb25uZWN0aW9uKCktPmRpZENs b3NlKCk7CisgICAgZGlzY29ubmVjdCgpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaCBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaAppbmRleCBkMzM1Y2UxLi5k MjAyZGIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1By b3h5LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCkBA IC0xMTUsNiArMTE1LDggQEAgcHVibGljOgogICAgIHZvaWQgdXBkYXRlUHJvY2Vzc1N1cHByZXNz aW9uU3RhdGUoKTsKICNlbmRpZgogCisgICAgdm9pZCB1c2VyUmVxdWVzdGVkVGVybWluYXRlKCk7 CisKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgV2ViUHJvY2Vzc1Byb3h5KFBhc3NSZWZQdHI8V2Vi Q29udGV4dD4pOwogCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VM b2cKaW5kZXggODFiNjA1NS4uMmI3YmJiYiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisr KyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDEzLTA0LTA3ICBBZGVuaWxz b24gQ2F2YWxjYW50aSAgPGNhdmFsY2FudGlpQGdtYWlsLmNvbT4KKworICAgICAgICBbV0syXSBX ZWJQYWdlUHJveHkgbG9hZFVSTCgpIHdvbid0IHdvcmsgd2hlbiBjYWxsZWQganVzdCBhZnRlciB0 ZXJtaW5hdGVQcm9jZXNzKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTExMDc0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZGluZyBhIG5ldyB0ZXN0IGZpbGUgdG8gY2hlY2sgaWYgbG9hZGluZyBhIHBh Z2UganVzdCBhZnRlciBXZWJQcm9jZXNzCisgICAgICAgIGhhcyBjcmFzaGVkIChvciB3YXMgdGVy bWluYXRlZCkgd29ya3MuIFRoZSB0ZXN0IGV4ZWN1dGVzIHRoZQorICAgICAgICBmb2xsb3dpbmcg c3RlcHMgKExvYWQsIENyYXNoLCBMb2FkKSwgdGh1cyBzdHJlc3NpbmcgV2ViUHJvY2VzcworICAg ICAgICByZWF0dGFjaCBhbmQgcHJvY2VzcyB0ZXJtaW5hdGlvbiBjb2RlIHBhdGguCisKKyAgICAg ICAgKiBUZXN0V2ViS2l0QVBJL0dOVW1ha2VmaWxlLmFtOgorICAgICAgICAqIFRlc3RXZWJLaXRB UEkvUGxhdGZvcm1FZmwuY21ha2U6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0V2ViS2l0 QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogVGVzdFdlYktpdEFQSS9U ZXN0cy9XZWJLaXQyL01vdXNlTW92ZUFmdGVyQ3Jhc2guY3BwOgorICAgICAgICAoVGVzdFdlYktp dEFQSTo6c2V0UGFnZUxvYWRlckNsaWVudCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNU KToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTG9hZFBhZ2VPbkNyYXNo LmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJKToKKyAgICAgICAgKFdlYktpdDJD cmFzaExvYWRlcik6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpXZWJLaXQyQ3Jhc2hMb2FkZXI6 OldlYktpdDJDcmFzaExvYWRlcik6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpXZWJLaXQyQ3Jh c2hMb2FkZXI6OmxvYWRVcmwpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6V2ViS2l0MkNyYXNo TG9hZGVyOjpjcmFzaFdlYlByb2Nlc3MpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6ZGlkRmlu aXNoTG9hZCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKyAgICAgICAgKiBUZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvV2ViS2l0Mi5wcm86CisKIDIwMTMtMDQtMDUgIE9qYW4g VmFmYWkgIDxvamFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBNb3ZlIHRoZSBmbGFraW5lc3Mg ZGFzaGJvYXJkIHRvIHRoZSBuZXcgaW5zdGFuY2UgYXQgd2Via2l0LXRlc3QtcmVzdWx0cy5hcHBz cG90LmNvbQpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9HTlVtYWtlZmlsZS5hbSBi L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvR05VbWFrZWZpbGUuYW0KaW5kZXggMzQ0ZjYwYi4uOWIyMGUw MyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9HTlVtYWtlZmlsZS5hbQorKysgYi9U b29scy9UZXN0V2ViS2l0QVBJL0dOVW1ha2VmaWxlLmFtCkBAIC0xNTUsNiArMTU1LDcgQEAgUHJv Z3JhbXNfVGVzdFdlYktpdEFQSV9UZXN0V2ViS2l0Ml9TT1VSQ0VTID0gXAogCVRvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9JbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRh dGFDYWxsYmFja1dpbnMuY3BwIFwKIAlUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIv TG9hZEFsdGVybmF0ZUhUTUxTdHJpbmdXaXRoTm9uRGlyZWN0b3J5VVJMLmNwcCBcCiAJVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0xvYWRDYW5jZWxlZE5vU2VydmVyUmVkaXJlY3RD YWxsYmFjay5jcHAgXAorCVRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2FkUGFn ZU9uQ3Jhc2guY3BwIFwKIAlUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTW91c2VN b3ZlQWZ0ZXJDcmFzaC5jcHAgXAogCVRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9S ZWxvYWRQYWdlQWZ0ZXJDcmFzaC5jcHAgXAogCVRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0Mi9SZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcCBcCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0 V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9y bUVmbC5jbWFrZQppbmRleCBhNzE3NTU5Li4zYmM0NGMzIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0 V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxh dGZvcm1FZmwuY21ha2UKQEAgLTY4LDYgKzY4LDcgQEAgc2V0KHRlc3Rfd2Via2l0Ml9hcGlfQklO QVJJRVMKICAgICBJbmplY3RlZEJ1bmRsZUluaXRpYWxpemF0aW9uVXNlckRhdGFDYWxsYmFja1dp bnMKICAgICBMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZ1dpdGhOb25EaXJlY3RvcnlVUkwKICAgICBM b2FkQ2FuY2VsZWROb1NlcnZlclJlZGlyZWN0Q2FsbGJhY2sKKyAgICBMb2FkUGFnZU9uQ3Jhc2gK ICAgICBNb3VzZU1vdmVBZnRlckNyYXNoCiAgICAgUmVsb2FkUGFnZUFmdGVyQ3Jhc2gKICAgICBS ZXNpemVXaW5kb3dBZnRlckNyYXNoCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDVmNjZiMDku LjY2MDg2OGQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdFdl YktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC05MSw2ICs5MSw3IEBACiAJCTgx QjUwMTkzMTQwRjIzMjMwMEQ5RUI1OCAvKiBTdHJpbmdCdWlsZGVyLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDgxQjUwMTkyMTQwRjIzMjMwMEQ5RUI1 OCAvKiBTdHJpbmdCdWlsZGVyLmNwcCAqLzsgfTsKIAkJOEEyQzc1MEUxNkNFRDk1NTAwMjRGMzUy IC8qIFJlc2l6ZVdpbmRvd0FmdGVyQ3Jhc2guY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gOEEyQzc1MEQxNkNFRDk1NTAwMjRGMzUyIC8qIFJlc2l6ZVdp bmRvd0FmdGVyQ3Jhc2guY3BwICovOyB9OwogCQk4QTNBRjkzQjE2QzlFRDI3MDBEMjQ4QzEgLyog UmVsb2FkUGFnZUFmdGVyQ3Jhc2guY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gOEEzQUY5M0ExNkM5RUQyNzAwRDI0OEMxIC8qIFJlbG9hZFBhZ2VBZnRl ckNyYXNoLmNwcCAqLzsgfTsKKwkJOEFBMjhDMUExNkQyRkE3QjAwMkZGNERCIC8qIExvYWRQYWdl T25DcmFzaC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA4QUEyOEMxOTE2RDJGQTdCMDAyRkY0REIgLyogTG9hZFBhZ2VPbkNyYXNoLmNwcCAqLzsgfTsK IAkJOTMwQUQ0MDIxNTA2OThEMDAwNjc5NzBGIC8qIGxvdHMtb2YtdGV4dC5odG1sIGluIENvcHkg UmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzMEFENDAxMTUw Njk4QjMwMDY3OTcwRiAvKiBsb3RzLW9mLXRleHQuaHRtbCAqLzsgfTsKIAkJOTMxODc3ODkxNUVF QzU3NzAwQTlDQ0UzIC8qIE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZvckltYWdlcy5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5M0FGNEVD QTE1MDZGMDM1MDA3RkQ1N0UgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5b3V0Rm9ySW1h Z2VzLmNwcCAqLzsgfTsKIAkJOTM2MTAwMjkxNERDOTVBNzAwNjEzNzlEIC8qIGxvdHMtb2YtaWZy YW1lcy5odG1sIGluIENvcHkgUmVzb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDkzNjEwMDI4MTREQzk1N0IwMDYxMzc5RCAvKiBsb3RzLW9mLWlmcmFtZXMuaHRtbCAq LzsgfTsKQEAgLTM1OSw2ICszNjAsNyBAQAogCQk4MUI1MDE5MjE0MEYyMzIzMDBEOUVCNTggLyog U3RyaW5nQnVpbGRlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBT dHJpbmdCdWlsZGVyLmNwcDsgcGF0aCA9IFdURi9TdHJpbmdCdWlsZGVyLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOEEyQzc1MEQxNkNFRDk1NTAwMjRGMzUyIC8qIFJlc2l6ZVdp bmRvd0FmdGVyQ3Jhc2guY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g UmVzaXplV2luZG93QWZ0ZXJDcmFzaC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CThBM0FGOTNBMTZDOUVEMjcwMEQyNDhDMSAvKiBSZWxvYWRQYWdlQWZ0ZXJDcmFzaC5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZWxvYWRQYWdlQWZ0ZXJDcmFzaC5j cHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCThBQTI4QzE5MTZEMkZBN0IwMDJGRjRE QiAvKiBMb2FkUGFnZU9uQ3Jhc2guY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gTG9hZFBhZ2VPbkNyYXNoLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ OERENzZGQTEwNDg2QUE3NjAwRDk2QjVFIC8qIFRlc3RXZWJLaXRBUEkgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZXhwbGljaXRGaWxlVHlwZSA9ICJjb21waWxlZC5tYWNoLW8uZXhlY3V0 YWJsZSI7IGluY2x1ZGVJbkluZGV4ID0gMDsgcGF0aCA9IFRlc3RXZWJLaXRBUEk7IHNvdXJjZVRy ZWUgPSBCVUlMVF9QUk9EVUNUU19ESVI7IH07CiAJCTkzMEFENDAxMTUwNjk4QjMwMDY3OTcwRiAv KiBsb3RzLW9mLXRleHQuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsgcGF0aCA9ICJsb3RzLW9m LXRleHQuaHRtbCI7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzNjEwMDI4MTREQzk1 N0IwMDYxMzc5RCAvKiBsb3RzLW9mLWlmcmFtZXMuaHRtbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuaHRtbDsg cGF0aCA9ICJsb3RzLW9mLWlmcmFtZXMuaHRtbCI7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC02NjIsNiArNjY0LDcgQEAKIAkJCQk1MkNCNDc0MDE0NDhGQjkzMDA4NzM5OTUgLyogTG9h ZEFsdGVybmF0ZUhUTUxTdHJpbmdXaXRoTm9uRGlyZWN0b3J5VVJMLmNwcCAqLywKIAkJCQkzM0RD ODkxMDE0MTk1M0EzMDA3NDdFRjcgLyogTG9hZENhbmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxi YWNrLmNwcCAqLywKIAkJCQkzM0RDODkxMzE0MTk1NzlGMDA3NDdFRjcgLyogTG9hZENhbmNlbGVk Tm9TZXJ2ZXJSZWRpcmVjdENhbGxiYWNrX0J1bmRsZS5jcHAgKi8sCisJCQkJOEFBMjhDMTkxNkQy RkE3QjAwMkZGNERCIC8qIExvYWRQYWdlT25DcmFzaC5jcHAgKi8sCiAJCQkJMzNCRTVBRjQxMzdC NUE2QzAwNzA1ODEzIC8qIE1vdXNlTW92ZUFmdGVyQ3Jhc2guY3BwICovLAogCQkJCTMzQkU1QUY4 MTM3QjVBQUUwMDcwNTgxMyAvKiBNb3VzZU1vdmVBZnRlckNyYXNoX0J1bmRsZS5jcHAgKi8sCiAJ CQkJOTNGMURCMzAxNERBMjA3NjAwMjRDMzYyIC8qIE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxh eW91dC5jcHAgKi8sCkBAIC0xMDQxLDYgKzEwNDQsNyBAQAogCQkJCTI2MzAwQjE4MTY3NTVDRDkw MDY2ODg2RCAvKiBMaXN0SGFzaFNldC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk1MkNCNDc0MTE0 NDhGQjkzMDA4NzM5OTUgLyogTG9hZEFsdGVybmF0ZUhUTUxTdHJpbmdXaXRoTm9uRGlyZWN0b3J5 VVJMLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTMzREM4OTExMTQxOTUzQTMwMDc0N0VGNyAvKiBM b2FkQ2FuY2VsZWROb1NlcnZlclJlZGlyZWN0Q2FsbGJhY2suY3BwIGluIFNvdXJjZXMgKi8sCisJ CQkJOEFBMjhDMUExNkQyRkE3QjAwMkZGNERCIC8qIExvYWRQYWdlT25DcmFzaC5jcHAgaW4gU291 cmNlcyAqLywKIAkJCQlCNDAzOUY5RDE1RTZEOEIzMDA3MjU1RDYgLyogTWF0aEV4dHJhcy5jcHAg aW4gU291cmNlcyAqLywKIAkJCQlDRDU0OTdCNDE1ODU3RjBDMDBCNUJDMzAgLyogTWVkaWFUaW1l LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUUxMjIwREEwMTU1QjI1NDgwMDEzRTJGQyAvKiBNZW1v cnlDYWNoZURpc2FibGVXaXRoaW5SZXNvdXJjZUxvYWREZWxlZ2F0ZS5tbSBpbiBTb3VyY2VzICov LApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0xvYWRQYWdl T25DcmFzaC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTG9hZFBhZ2VP bkNyYXNoLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NjMyZDU0Ci0t LSAvZGV2L251bGwKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0xvYWRQ YWdlT25DcmFzaC5jcHAKQEAgLTAsMCArMSwxMDIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTMgQWRlbmlsc29uIENhdmFsY2FudGkgPGNhdmFsY2FudGlpQGdtYWlsLmNvbT4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBD T05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIK KyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4g T1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAq IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisg KiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtVXRpbGl0aWVzLmgiCisj aW5jbHVkZSAiUGxhdGZvcm1XZWJWaWV3LmgiCisjaW5jbHVkZSAiVGVzdC5oIgorI2luY2x1ZGUg PFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KKworbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgeworCitz dGF0aWMgdm9pZCBkaWRGaW5pc2hMb2FkKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBlUmVm LCBjb25zdCB2b2lkKik7CisKK2NsYXNzIFdlYktpdDJDcmFzaExvYWRlciB7CitwdWJsaWM6Cisg ICAgV2ViS2l0MkNyYXNoTG9hZGVyKCkKKyAgICAgICAgOiBjb250ZXh0KEFkb3B0V0ssIFdLQ29u dGV4dENyZWF0ZSgpKQorICAgICAgICAsIHdlYlZpZXcoY29udGV4dC5nZXQoKSkKKyAgICAgICAg LCB1cmwoYWRvcHRXSyhXS1VSTENyZWF0ZVdpdGhVVEY4Q1N0cmluZygiYWJvdXQ6YmxhbmsiKSkp CisgICAgICAgICwgZmlyc3RTdWNjZXNzZnVsTG9hZChmYWxzZSkKKyAgICAgICAgLCBzZWNvbmRT dWNjZXNzZnVsTG9hZChmYWxzZSkKKyAgICB7CisgICAgICAgIG1lbXNldCgmbG9hZGVyQ2xpZW50 LCAwLCBzaXplb2YobG9hZGVyQ2xpZW50KSk7CisgICAgICAgIGxvYWRlckNsaWVudC5jbGllbnRJ bmZvID0gdGhpczsKKyAgICAgICAgbG9hZGVyQ2xpZW50LmRpZEZpbmlzaExvYWRGb3JGcmFtZSA9 IGRpZEZpbmlzaExvYWQ7CisgICAgICAgIFdLUGFnZVNldFBhZ2VMb2FkZXJDbGllbnQod2ViVmll dy5wYWdlKCksICZsb2FkZXJDbGllbnQpOworICAgIH0KKworICAgIHZvaWQgbG9hZFVybCgpCisg ICAgeworICAgICAgICBXS1BhZ2VMb2FkVVJMKHdlYlZpZXcucGFnZSgpLCB1cmwuZ2V0KCkpOwor ICAgIH0KKworICAgIHZvaWQgY3Jhc2hXZWJQcm9jZXNzKCkKKyAgICB7CisgICAgICAgIFdLUGFn ZVRlcm1pbmF0ZSh3ZWJWaWV3LnBhZ2UoKSk7CisgICAgfQorCisgICAgV0tSZXRhaW5QdHI8V0tD b250ZXh0UmVmPiBjb250ZXh0OworICAgIFdLUGFnZUxvYWRlckNsaWVudCBsb2FkZXJDbGllbnQ7 CisgICAgUGxhdGZvcm1XZWJWaWV3IHdlYlZpZXc7CisgICAgV0tSZXRhaW5QdHI8V0tVUkxSZWY+ IHVybDsKKworICAgIGJvb2wgZmlyc3RTdWNjZXNzZnVsTG9hZDsKKyAgICBib29sIHNlY29uZFN1 Y2Nlc3NmdWxMb2FkOworfTsKKworLy8gVGhpcyBpcyBzaGFyZWQgZm9yIGJvdGggdGVzdHMsIHNp bmNlIHdlIGFyZSBnb2luZyB0byBoYXZlIDIgbG9hZCBldmVudHMKKy8vIGludGVydHdpbmVkIGJ5 IGEgY3Jhc2ggKGkuZS4gTG9hZCAtPiBDcmFzaCAtPiBMb2FkKS4KK3ZvaWQgZGlkRmluaXNoTG9h ZChXS1BhZ2VSZWYgcGFnZSwgV0tGcmFtZVJlZiBmcmFtZSwgV0tUeXBlUmVmIHVzZXJEYXRhLCBj b25zdCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIFdlYktpdDJDcmFzaExvYWRlciogdGVzdEhl bHBlciA9IGNvbnN0X2Nhc3Q8V2ViS2l0MkNyYXNoTG9hZGVyKj4oc3RhdGljX2Nhc3Q8Y29uc3Qg V2ViS2l0MkNyYXNoTG9hZGVyKj4oY2xpZW50SW5mbykpOworCisgICAgLy8gRmlyc3QgbG9hZCB3 b3JrZWQsIGxldCdzIGNyYXNoIFdlYlByb2Nlc3MuCisgICAgaWYgKCF0ZXN0SGVscGVyLT5maXJz dFN1Y2Nlc3NmdWxMb2FkKSB7CisgICAgICAgIHRlc3RIZWxwZXItPmZpcnN0U3VjY2Vzc2Z1bExv YWQgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgLy8gU2Vjb25kIGxvYWQg d29ya2VkLCB3ZSBhcmUgZG9uZS4KKyAgICBFWFBFQ1RfVFJVRSh0ZXN0SGVscGVyLT5maXJzdFN1 Y2Nlc3NmdWxMb2FkKTsKKyAgICBpZiAoIXRlc3RIZWxwZXItPnNlY29uZFN1Y2Nlc3NmdWxMb2Fk KSB7CisgICAgICAgIHRlc3RIZWxwZXItPnNlY29uZFN1Y2Nlc3NmdWxMb2FkID0gdHJ1ZTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KK30KKworLy8gVGhpcyB0ZXN0IHdpbGwgbG9hZCBhIGJsYW5r IHBhZ2UgYW5kIG5leHQga2lsbCBXZWJQcm9jZXNzLCB0aGUgZXhwZWN0ZWQKKy8vIHJlc3VsdCBp cyB0aGF0IGEgY2FsbCB0byBwYWdlIGxvYWQgc2hvdWxkIHNwYXduIGEgbmV3IFdlYlByb2Nlc3Mu CitURVNUKFdlYktpdDIsIExvYWRQYWdlQWZ0ZXJDcmFzaCkKK3sKKyAgICBXZWJLaXQyQ3Jhc2hM b2FkZXIgaGVscGVyOworICAgIGhlbHBlci5sb2FkVXJsKCk7CisgICAgVXRpbDo6cnVuKCZoZWxw ZXIuZmlyc3RTdWNjZXNzZnVsTG9hZCk7CisgICAgaGVscGVyLmNyYXNoV2ViUHJvY2VzcygpOwor ICAgIGhlbHBlci5sb2FkVXJsKCk7CisgICAgVXRpbDo6cnVuKCZoZWxwZXIuc2Vjb25kU3VjY2Vz c2Z1bExvYWQpOworfQorCit9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTW91c2VNb3ZlQWZ0ZXJDcmFzaC5j cHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTW91c2VNb3ZlQWZ0ZXJDcmFz aC5jcHAKaW5kZXggOWI0NzA1MS4uNGJmNTUyNyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyL01vdXNlTW92ZUFmdGVyQ3Jhc2guY3BwCisrKyBiL1Rvb2xzL1Rl c3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Nb3VzZU1vdmVBZnRlckNyYXNoLmNwcApAQCAtMzcs MTEgKzM3LDYgQEAgc3RhdGljIHZvaWQgZGlkRmluaXNoTG9hZEZvckZyYW1lKFdLUGFnZVJlZiwg V0tGcmFtZVJlZiwgV0tUeXBlUmVmLCBjb25zdCB2b2lkKikKICAgICBkaWRGaW5pc2hMb2FkID0g dHJ1ZTsKIH0KIAotc3RhdGljIHZvaWQgcHJvY2Vzc0RpZENyYXNoKFdLUGFnZVJlZiBwYWdlLCBj b25zdCB2b2lkKikKLXsKLSAgICBXS1BhZ2VSZWxvYWQocGFnZSk7Ci19Ci0KIHN0YXRpYyB2b2lk IHNldFBhZ2VMb2FkZXJDbGllbnQoV0tQYWdlUmVmIHBhZ2UpCiB7CiAgICAgV0tQYWdlTG9hZGVy Q2xpZW50IGxvYWRlckNsaWVudDsKQEAgLTQ5LDcgKzQ0LDYgQEAgc3RhdGljIHZvaWQgc2V0UGFn ZUxvYWRlckNsaWVudChXS1BhZ2VSZWYgcGFnZSkKICAgICBsb2FkZXJDbGllbnQudmVyc2lvbiA9 IDA7CiAgICAgbG9hZGVyQ2xpZW50LmNsaWVudEluZm8gPSAwOwogICAgIGxvYWRlckNsaWVudC5k aWRGaW5pc2hMb2FkRm9yRnJhbWUgPSBkaWRGaW5pc2hMb2FkRm9yRnJhbWU7Ci0gICAgbG9hZGVy Q2xpZW50LnByb2Nlc3NEaWRDcmFzaCA9IHByb2Nlc3NEaWRDcmFzaDsKIAogICAgIFdLUGFnZVNl dFBhZ2VMb2FkZXJDbGllbnQocGFnZSwgJmxvYWRlckNsaWVudCk7CiB9CkBAIC03OSwxMSArNzMs MTEgQEAgVEVTVChXZWJLaXQyLCBNb3VzZU1vdmVBZnRlckNyYXNoKQogICAgIHdlYlZpZXcuc2lt dWxhdGVNb3VzZU1vdmUoMTAsIDEwKTsKICAgICB3ZWJWaWV3LnNpbXVsYXRlTW91c2VNb3ZlKDIw LCAyMCk7CiAKLSAgICAvLyBBZnRlciBtb3ZpbmcgdGhlIG1vdXNlICh3aGlsZSB0aGUgd2ViIHBy b2Nlc3Mgd2FzIGh1bmcgb24gdGhlIFBhdXNlIG1lc3NhZ2UpLCBraWxsIHRoZSB3ZWIgcHJvY2Vz cy4gSXQgaXMgcmVzdGFydGVkIGluCi0gICAgLy8gcHJvY2Vzc0RpZENyYXNoIGJ5IHJlbG9hZGlu ZyB0aGUgcGFnZS4KKyAgICAvLyBBZnRlciBtb3ZpbmcgdGhlIG1vdXNlICh3aGlsZSB0aGUgd2Vi IHByb2Nlc3Mgd2FzIGh1bmcgb24gdGhlIFBhdXNlIG1lc3NhZ2UpLCBraWxsIHRoZSB3ZWIgcHJv Y2Vzcy4gSXQgaXMgcmVzdGFydGVkIGJ5IHJlbG9hZGluZyB0aGUgcGFnZS4KICAgICBXS1BhZ2VU ZXJtaW5hdGUod2ViVmlldy5wYWdlKCkpOworICAgIFdLUGFnZVJlbG9hZCh3ZWJWaWV3LnBhZ2Uo KSk7CiAKLSAgICAvLyBXYWl0IHVudGlsIHdlIGxvYWQgdGhlIHBhZ2UgYSBzZWNvbmQgdGltZSAo dmlhIHJlbG9hZGluZyB0aGUgcGFnZSBpbiBwcm9jZXNzRGlkQ3Jhc2gpLgorICAgIC8vIFdhaXQg dW50aWwgd2UgbG9hZCB0aGUgcGFnZSBhIHNlY29uZCB0aW1lLgogICAgIFV0aWw6OnJ1bigmZGlk RmluaXNoTG9hZCk7CiAKICAgICBFWFBFQ1RfSlNfRkFMU0Uod2ViVmlldy5wYWdlKCksICJkaWRN b3ZlTW91c2UoKSIpOwpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyL1dlYktpdDIucHJvIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktp dDIucHJvCmluZGV4IDk0NTJhNWEuLjFkMDYzNzkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV2ViS2l0Mi9XZWJLaXQyLnBybworKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdDIvV2ViS2l0Mi5wcm8KQEAgLTE5LDYgKzE5LDcgQEAgU09VUkNFUyArPSBc CiAgICAgSW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRhQ2FsbGJhY2tXaW5zLmNw cCBcCiAgICAgTG9hZEFsdGVybmF0ZUhUTUxTdHJpbmdXaXRoTm9uRGlyZWN0b3J5VVJMLmNwcCBc CiAgICAgTG9hZENhbmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxiYWNrLmNwcCBcCisgICAgTG9h ZFBhZ2VPbkNyYXNoLmNwcCBcCiAgICAgTW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHAgXAogICAgIFBh Z2VMb2FkQmFzaWMuY3BwIFwKICAgICBQYWdlTG9hZERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFn ZUZvckZyYW1lLmNwcCBcCi0tIAoxLjcuMTAuNAoK 197640 2013-04-11 10:46:17 -0700 2013-04-12 14:21:34 -0700 Addressing reviewers comments: CL, member function naming, using private access, etc. 0001-WebProcess-termination-now-is-done-using-a-new-funct.patch text/plain 19728 savagobr RnJvbSBlZmM2MzlhZTE1NjgzODYxMTgxZTc5OTkzYjBmYTQxYmU4Y2E5MTNjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBZGVuaWxzb24gQ2F2YWxjYW50aSA8Y2F2YWxjYW50aWlAZ21h aWwuY29tPgpEYXRlOiBTdW4sIDcgQXByIDIwMTMgMTE6MTY6NTkgLTA0MDAKU3ViamVjdDogW1BB VENIXSBXZWJQcm9jZXNzIHRlcm1pbmF0aW9uIG5vdyBpcyBkb25lIHVzaW5nIGEgbmV3IGZ1bmN0 aW9uCiAncmVxdWVzdFRlcm1pbmF0ZScgdGhhdCBwZXJmb3JtcyBjb21wbGV0ZSBzaHV0ZG93biBv ZgogV2ViUHJvY2Vzc1Byb3h5IGJlZm9yZSByZXR1cm5pbmcuIFRoaXMgZW5zdXJlcyB0aGF0IGF0 IHRpbWUKIHJlYXR0YWNoVG9XZWJQcm9jZXNzKCkgaXMgZXhlY3V0ZWQsIFdlYlByb2Nlc3NQcm94 eSBpcyBpbiBhCiBzYW5lIHN0YXRlLgoKTmV4dCwgY2xlYW51cCBvZiBXZWJQYWdlUHJveHkgaXMg ZG9uZSBhdCB0ZXJtaW5hdGVQcm9jZXNzKCksIHVzaW5nIGEgbmV3IGZ1bmN0aW9uIG5hbWVkICdw cm9jZXNzVGVhcmRvd24oKScsCnRoYXQgaXMgc2hhcmVkIHdpdGggcHJvY2Vzc0RpZENyYXNoKCku IEZpbmFsbHksIGNsaWVudCBpcyBub3Qgbm90aWZpZWQgb2YgcHJvY2VzcyBjcmFzaCwgc2luY2Ug aXQgd2FzCnRlcm1pbmF0ZWQgcGVyIGNsaWVudCdzIHJlcXVlc3QuCgpUaGlzIGNoYW5nZXMgbWFr ZXMgdGhlIG5ldyB0ZXN0IHN1Y2NlZWQgYW5kIGluY2x1ZGUgdGhlIGNoYW5nZXMgcmVxdWlyZWQg dG8gZml4IGZhaWxpbmcgdGVzdC4KClNpZ25lZC1vZmYtYnk6IEFkZW5pbHNvbiBDYXZhbGNhbnRp IDxjYXZhbGNhbnRpaUBnbWFpbC5jb20+Ci0tLQogU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nICAg ICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDM5ICsrKysrKysrCiBTb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcCAgICAgICAgICB8ICAgMTcgKysrLQogU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oICAgICAgICAgICAgfCAgICAyICsKIFNvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwICAgICAgIHwgICAgNyArKwog U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oICAgICAgICAgfCAgICAy ICsKIFRvb2xzL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg ICAyOCArKysrKysKIFRvb2xzL1Rlc3RXZWJLaXRBUEkvR05VbWFrZWZpbGUuYW0gICAgICAgICAg ICAgICAgIHwgICAgMSArCiBUb29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZsLmNtYWtlICAg ICAgICAgICAgICB8ICAgIDEgKwogLi4uL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvaiAgICAgICAgfCAgICA0ICsKIC4uLi9UZXN0cy9XZWJLaXQyL0xvYWRQYWdlT25DcmFz aC5jcHAgICAgICAgICAgICAgIHwgIDEwMiArKysrKysrKysrKysrKysrKysrKwogLi4uL1Rlc3Rz L1dlYktpdDIvTW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHAgICAgICAgICAgfCAgIDEyICstLQogVG9v bHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvICAgICAgfCAgICAxICsK IDEyIGZpbGVzIGNoYW5nZWQsIDIwMiBpbnNlcnRpb25zKCspLCAxNCBkZWxldGlvbnMoLSkKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTG9hZFBh Z2VPbkNyYXNoLmNwcAoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCBhNDc1MTM0Li5jYWE0MWU1IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsNDIgQEAKKzIwMTMtMDQtMDcgIEFkZW5pbHNvbiBDYXZhbGNhbnRpICA8Y2F2 YWxjYW50aWlAZ21haWwuY29tPgorCisgICAgICAgIFtXSzJdIFdlYlBhZ2VQcm94eSBsb2FkVVJM KCkgd29uJ3Qgd29yayB3aGVuIGNhbGxlZCBqdXN0IGFmdGVyIHRlcm1pbmF0ZVByb2Nlc3MoKQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEwNzQzCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQSBjYWxsIHRv IGxvYWRVUkwoKSBqdXN0IGFmdGVyIHRlcm1pbmF0aW5nIFdlYlByb2Nlc3Mgd2lsbCBmYWlsIHRo YW5rcyB0bworICAgICAgICBXZWJQYWdlUHJveHkgYmVpbmcgaW4gYW4gdW5kZWZpbmVkIHN0YXRl IHNpbmNlIGl0IGlzIGluIHRoZSBtaWRkbGUgb2YgaXRzIG93bgorICAgICAgICBjbGVhbnVwIGFm dGVyIHByb2Nlc3MgdGVybWluYXRpb24uCisKKyAgICAgICAgVG8gcHJvcGVybHkgZml4IHRoaXMs IG5vdCBvbmx5IFdlYlBhZ2VQcm94eSBjbGVhbnVwIHNob3VsZCBiZSBtYWRlCisgICAgICAgIGF0 IFdlYlByb2Nlc3MgdGVybWluYXRpb24gcmVxdWVzdCwgYnV0IGFsc28gV2ViUHJvY2Vzc1Byb3h5 IG5lZWRzCisgICAgICAgIHRvIG9ubHkgcmV0dXJuIHRvIGl0cyBjYWxsZXIgYWZ0ZXIgdGVybWlu YXRpbmcgdGhlIHByb2Nlc3MgYW5kCisgICAgICAgIGNsb3NpbmcgY29ubmVjdGlvbnMuIE90aGVy d2lzZSwgV2ViUGFnZVByb3h5IGNhbiBldmVuIGJlIGFibGUgdG8KKyAgICAgICAgZGV0ZWN0IHRo YXQgV2ViUHJvY2VzcyBpcyBubyBsb25nZXIgcnVubmluZywgYnV0IGEgY2FsbCB0byByZXNwYXdu CisgICAgICAgIHRoZSBwcm9jZXNzIHdpbGwgZmFpbC4KKworICAgICAgICBUbyBmaXggdGhpcyBp c3N1ZXMsIHRoaXMgcGF0Y2ggbW92ZXMgdGhlIGNsZWFudXAgY29kZSB0byBhIHNoYXJlZCBwcml2 YXRlIGZ1bmN0aW9uCisgICAgICAgIHRoYXQgaXMgdXNlZCBmb3IgYm90aCB0aGUgY2FzZXMgaS5l LiB1c2VyIHRlcm1pbmF0aW9uIGFuZCByZWFsIGNyYXNoLiBXZWJQcm9jZXNzCisgICAgICAgIHNo dXRkb3duIGlzIGRvbmUgdXNpbmcgYSBuZXcgbWV0aG9kIHRoYXQgZW5zdXJlcyB0aGF0IGFsbCBj bGVhbnVwIHdhcyBkb25lIGJlZm9yZQorICAgICAgICByZXR1cm5pbmcuCisKKyAgICAgICAgQSBs YXN0IGNoYW5nZSBpbnRyb2R1Y2VkIGluIHRoaXMgcGF0Y2ggaXMgdGhhdCBmb3IgdXNlciByZXF1 ZXN0ZWQgdGVybWluYXRpb24sCisgICAgICAgIGNsaWVudHMgYXJlIG5vIGxvbmdlciBub3RpZmll ZCBvZiBhIGNyYXNoIChzaW5jZSBpdCBpcyBub3QgYSBjcmFzaCkuCisKKyAgICAgICAgKiBVSVBy b2Nlc3MvV2ViUGFnZVByb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojp0 ZXJtaW5hdGVQcm9jZXNzKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojpwcm9jZXNz RGlkQ3Jhc2gpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVBy b3h5Ojpwcm9jZXNzVGVhcmRvd24pOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHku aDoKKyAgICAgICAgKFdlYlBhZ2VQcm94eSk6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlByb2Nl c3NQcm94eS5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQcm94eTo6dXNlclJlcXVl c3RlZFRlcm1pbmF0ZSk6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAqIFVJUHJvY2Vzcy9X ZWJQcm9jZXNzUHJveHkuaDoKKyAgICAgICAgKFdlYlByb2Nlc3NQcm94eSk6CisKIDIwMTMtMDQt MDUgIEVkIEJhcnRvc2ggIDxiYXJ0b3NoQGdtYWlsLmNvbT4KIAogICAgICAgICBbV0syXSAtLW5v LXRpbGVkLWJhY2tpbmctc3RvcmUgYnVpbGQgZmFpbHMgYmVjYXVzZSBGbG9hdFBvaW50IGlzIG5v dCBkZWNsYXJlZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAppbmRl eCA4NTE3MzQwLi5iMmEwNTk4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv V2ViUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmNwcApAQCAtMTU2Nyw3ICsxNTY3LDggQEAgdm9pZCBXZWJQYWdlUHJveHk6OnRlcm1pbmF0 ZVByb2Nlc3MoKQogICAgIGlmICghbV9pc1ZhbGlkKQogICAgICAgICByZXR1cm47CiAKLSAgICBt X3Byb2Nlc3MtPnRlcm1pbmF0ZSgpOworICAgIG1fcHJvY2Vzcy0+cmVxdWVzdFRlcm1pbmF0aW9u KCk7CisgICAgcHJvY2Vzc1RlYXJkb3duKCk7CiB9CiAKICNpZiAhVVNFKENGKSB8fCBkZWZpbmVk KEJVSUxESU5HX1FUX18pCkBAIC0zNzk4LDggKzM3OTksMTcgQEAgdm9pZCBXZWJQYWdlUHJveHk6 OnByb2Nlc3NEaWRCZWNvbWVSZXNwb25zaXZlKCkKIAogdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nl c3NEaWRDcmFzaCgpCiB7Ci0gICAgQVNTRVJUKG1fcGFnZUNsaWVudCk7CisgICAgQVNTRVJUKG1f aXNWYWxpZCk7CisKKyAgICBwcm9jZXNzVGVhcmRvd24oKTsKKworICAgIG1fcGFnZUNsaWVudC0+ cHJvY2Vzc0RpZENyYXNoKCk7CisgICAgbV9sb2FkZXJDbGllbnQucHJvY2Vzc0RpZENyYXNoKHRo aXMpOworfQogCit2b2lkIFdlYlBhZ2VQcm94eTo6cHJvY2Vzc1RlYXJkb3duKCkKK3sKKyAgICBB U1NFUlQobV9wYWdlQ2xpZW50KTsKICAgICBtX3Byb2Nlc3MtPnJlbW92ZU1lc3NhZ2VSZWNlaXZl cihNZXNzYWdlczo6V2ViUGFnZVByb3h5OjptZXNzYWdlUmVjZWl2ZXJOYW1lKCksIG1fcGFnZUlE KTsKIAogICAgIG1faXNWYWxpZCA9IGZhbHNlOwpAQCAtMzg4Niw5ICszODk2LDYgQEAgdm9pZCBX ZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCgpCiAKICAgICBtX3BlbmRpbmdMZWFybk9ySWdu b3JlV29yZE1lc3NhZ2VDb3VudCA9IDA7CiAKLSAgICBtX3BhZ2VDbGllbnQtPnByb2Nlc3NEaWRD cmFzaCgpOwotICAgIG1fbG9hZGVyQ2xpZW50LnByb2Nlc3NEaWRDcmFzaCh0aGlzKTsKLQogICAg IGlmICghbV9pc1ZhbGlkKSB7CiAgICAgICAgIC8vIElmIHRoZSBjYWxsIG91dCB0byB0aGUgbG9h ZGVyIGNsaWVudCBkaWRuJ3QgY2F1c2UgdGhlIHdlYiBwcm9jZXNzIHRvIGJlIHJlbGF1bmNoZWQs IAogICAgICAgICAvLyB3ZSdsbCBjYWxsIHNldE5lZWRzRGlzcGxheSBvbiB0aGUgdmlldyBzbyB0 aGF0IHdlIHdvbid0IGhhdmUgdGhlIG9sZCBjb250ZW50cyBzaG93aW5nLgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCmluZGV4IGM4MDBiOWIuLjIyMGEwNzIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAorKysgYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKQEAgLTc3Nyw2ICs3NzcsOCBAQCBwdWJs aWM6CiBwcml2YXRlOgogICAgIFdlYlBhZ2VQcm94eShQYWdlQ2xpZW50KiwgUGFzc1JlZlB0cjxX ZWJQcm9jZXNzUHJveHk+LCBXZWJQYWdlR3JvdXAqLCB1aW50NjRfdCBwYWdlSUQpOwogCisgICAg dm9pZCBwcm9jZXNzVGVhcmRvd24oKTsKKwogICAgIC8vIENvcmVJUEM6Ok1lc3NhZ2VSZWNlaXZl cgogICAgIHZpcnR1YWwgdm9pZCBkaWRSZWNlaXZlTWVzc2FnZShDb3JlSVBDOjpDb25uZWN0aW9u KiwgQ29yZUlQQzo6TWVzc2FnZURlY29kZXImKSBPVkVSUklERTsKICAgICB2aXJ0dWFsIHZvaWQg ZGlkUmVjZWl2ZVN5bmNNZXNzYWdlKENvcmVJUEM6OkNvbm5lY3Rpb24qLCBDb3JlSVBDOjpNZXNz YWdlRGVjb2RlciYsIE93blB0cjxDb3JlSVBDOjpNZXNzYWdlRW5jb2Rlcj4mKSBPVkVSUklERTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3Bw IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5jcHAKaW5kZXggNmM2 NDhkZC4uMGRjMTFkNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBy b2Nlc3NQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQ cm94eS5jcHAKQEAgLTYyNiw0ICs2MjYsMTEgQEAgdm9pZCBXZWJQcm9jZXNzUHJveHk6OnBhZ2VQ cmVmZXJlbmNlc0NoYW5nZWQoV2ViS2l0OjpXZWJQYWdlUHJveHkgKnBhZ2UpCiAjZW5kaWYKIH0K IAordm9pZCBXZWJQcm9jZXNzUHJveHk6OnJlcXVlc3RUZXJtaW5hdGlvbigpCit7CisgICAgQ2hp bGRQcm9jZXNzUHJveHk6OnRlcm1pbmF0ZSgpOworICAgIHdlYkNvbm5lY3Rpb24oKS0+ZGlkQ2xv c2UoKTsKKyAgICBkaXNjb25uZWN0KCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCmluZGV4IGQzMzVjZTEuLjY3 ZWY0Y2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJv eHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmgKQEAg LTExNSw2ICsxMTUsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCB1cGRhdGVQcm9jZXNzU3VwcHJlc3Np b25TdGF0ZSgpOwogI2VuZGlmCiAKKyAgICB2b2lkIHJlcXVlc3RUZXJtaW5hdGlvbigpOworCiBw cml2YXRlOgogICAgIGV4cGxpY2l0IFdlYlByb2Nlc3NQcm94eShQYXNzUmVmUHRyPFdlYkNvbnRl eHQ+KTsKIApkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmlu ZGV4IDgxYjYwNTUuLjJiN2JiYmIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9U b29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAxMy0wNC0wNyAgQWRlbmlsc29uIENh dmFsY2FudGkgIDxjYXZhbGNhbnRpaUBnbWFpbC5jb20+CisKKyAgICAgICAgW1dLMl0gV2ViUGFn ZVByb3h5IGxvYWRVUkwoKSB3b24ndCB3b3JrIHdoZW4gY2FsbGVkIGp1c3QgYWZ0ZXIgdGVybWlu YXRlUHJvY2VzcygpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xMTA3NDMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBBZGRpbmcgYSBuZXcgdGVzdCBmaWxlIHRvIGNoZWNrIGlmIGxvYWRpbmcgYSBwYWdlIGp1 c3QgYWZ0ZXIgV2ViUHJvY2VzcworICAgICAgICBoYXMgY3Jhc2hlZCAob3Igd2FzIHRlcm1pbmF0 ZWQpIHdvcmtzLiBUaGUgdGVzdCBleGVjdXRlcyB0aGUKKyAgICAgICAgZm9sbG93aW5nIHN0ZXBz IChMb2FkLCBDcmFzaCwgTG9hZCksIHRodXMgc3RyZXNzaW5nIFdlYlByb2Nlc3MKKyAgICAgICAg cmVhdHRhY2ggYW5kIHByb2Nlc3MgdGVybWluYXRpb24gY29kZSBwYXRoLgorCisgICAgICAgICog VGVzdFdlYktpdEFQSS9HTlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Bs YXRmb3JtRWZsLmNtYWtlOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdFdlYktpdEFQSS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mi9Nb3VzZU1vdmVBZnRlckNyYXNoLmNwcDoKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6 OnNldFBhZ2VMb2FkZXJDbGllbnQpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6Cisg ICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0xvYWRQYWdlT25DcmFzaC5jcHA6 IEFkZGVkLgorICAgICAgICAoVGVzdFdlYktpdEFQSSk6CisgICAgICAgIChXZWJLaXQyQ3Jhc2hM b2FkZXIpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6V2ViS2l0MkNyYXNoTG9hZGVyOjpXZWJL aXQyQ3Jhc2hMb2FkZXIpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6V2ViS2l0MkNyYXNoTG9h ZGVyOjpsb2FkVXJsKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OldlYktpdDJDcmFzaExvYWRl cjo6Y3Jhc2hXZWJQcm9jZXNzKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OmRpZEZpbmlzaExv YWQpOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisgICAgICAgICogVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvOgorCiAyMDEzLTA0LTA1ICBPamFuIFZhZmFp ICA8b2phbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgTW92ZSB0aGUgZmxha2luZXNzIGRhc2hi b2FyZCB0byB0aGUgbmV3IGluc3RhbmNlIGF0IHdlYmtpdC10ZXN0LXJlc3VsdHMuYXBwc3BvdC5j b20KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvR05VbWFrZWZpbGUuYW0gYi9Ub29s cy9UZXN0V2ViS2l0QVBJL0dOVW1ha2VmaWxlLmFtCmluZGV4IDM0NGY2MGIuLjliMjBlMDMgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvR05VbWFrZWZpbGUuYW0KKysrIGIvVG9vbHMv VGVzdFdlYktpdEFQSS9HTlVtYWtlZmlsZS5hbQpAQCAtMTU1LDYgKzE1NSw3IEBAIFByb2dyYW1z X1Rlc3RXZWJLaXRBUElfVGVzdFdlYktpdDJfU09VUkNFUyA9IFwKIAlUb29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDIvSW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRhQ2Fs bGJhY2tXaW5zLmNwcCBcCiAJVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0xvYWRB bHRlcm5hdGVIVE1MU3RyaW5nV2l0aE5vbkRpcmVjdG9yeVVSTC5jcHAgXAogCVRvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2FkQ2FuY2VsZWROb1NlcnZlclJlZGlyZWN0Q2FsbGJh Y2suY3BwIFwKKwlUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTG9hZFBhZ2VPbkNy YXNoLmNwcCBcCiAJVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL01vdXNlTW92ZUFm dGVyQ3Jhc2guY3BwIFwKIAlUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvUmVsb2Fk UGFnZUFmdGVyQ3Jhc2guY3BwIFwKIAlUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIv UmVzaXplV2luZG93QWZ0ZXJDcmFzaC5jcHAgXApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktp dEFQSS9QbGF0Zm9ybUVmbC5jbWFrZSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwu Y21ha2UKaW5kZXggYTcxNzU1OS4uM2JjNDRjMyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9QbGF0Zm9ybUVmbC5jbWFrZQorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3Jt RWZsLmNtYWtlCkBAIC02OCw2ICs2OCw3IEBAIHNldCh0ZXN0X3dlYmtpdDJfYXBpX0JJTkFSSUVT CiAgICAgSW5qZWN0ZWRCdW5kbGVJbml0aWFsaXphdGlvblVzZXJEYXRhQ2FsbGJhY2tXaW5zCiAg ICAgTG9hZEFsdGVybmF0ZUhUTUxTdHJpbmdXaXRoTm9uRGlyZWN0b3J5VVJMCiAgICAgTG9hZENh bmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxiYWNrCisgICAgTG9hZFBhZ2VPbkNyYXNoCiAgICAg TW91c2VNb3ZlQWZ0ZXJDcmFzaAogICAgIFJlbG9hZFBhZ2VBZnRlckNyYXNoCiAgICAgUmVzaXpl V2luZG93QWZ0ZXJDcmFzaApkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0V2Vi S2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RXZWJLaXRBUEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCA1ZjY2YjA5Li42NjA4 NjhkIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRB UEkueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtOTEsNiArOTEsNyBAQAogCQk4MUI1MDE5 MzE0MEYyMzIzMDBEOUVCNTggLyogU3RyaW5nQnVpbGRlci5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4MUI1MDE5MjE0MEYyMzIzMDBEOUVCNTggLyog U3RyaW5nQnVpbGRlci5jcHAgKi87IH07CiAJCThBMkM3NTBFMTZDRUQ5NTUwMDI0RjM1MiAvKiBS ZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDhBMkM3NTBEMTZDRUQ5NTUwMDI0RjM1MiAvKiBSZXNpemVXaW5kb3dB ZnRlckNyYXNoLmNwcCAqLzsgfTsKIAkJOEEzQUY5M0IxNkM5RUQyNzAwRDI0OEMxIC8qIFJlbG9h ZFBhZ2VBZnRlckNyYXNoLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDhBM0FGOTNBMTZDOUVEMjcwMEQyNDhDMSAvKiBSZWxvYWRQYWdlQWZ0ZXJDcmFz aC5jcHAgKi87IH07CisJCThBQTI4QzFBMTZEMkZBN0IwMDJGRjREQiAvKiBMb2FkUGFnZU9uQ3Jh c2guY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEFB MjhDMTkxNkQyRkE3QjAwMkZGNERCIC8qIExvYWRQYWdlT25DcmFzaC5jcHAgKi87IH07CiAJCTkz MEFENDAyMTUwNjk4RDAwMDY3OTcwRiAvKiBsb3RzLW9mLXRleHQuaHRtbCBpbiBDb3B5IFJlc291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzBBRDQwMTE1MDY5OEIz MDA2Nzk3MEYgLyogbG90cy1vZi10ZXh0Lmh0bWwgKi87IH07CiAJCTkzMTg3Nzg5MTVFRUM1Nzcw MEE5Q0NFMyAvKiBOZXdGaXJzdFZpc3VhbGx5Tm9uRW1wdHlMYXlvdXRGb3JJbWFnZXMuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTNBRjRFQ0ExNTA2 RjAzNTAwN0ZENTdFIC8qIE5ld0ZpcnN0VmlzdWFsbHlOb25FbXB0eUxheW91dEZvckltYWdlcy5j cHAgKi87IH07CiAJCTkzNjEwMDI5MTREQzk1QTcwMDYxMzc5RCAvKiBsb3RzLW9mLWlmcmFtZXMu aHRtbCBpbiBDb3B5IFJlc291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA5MzYxMDAyODE0REM5NTdCMDA2MTM3OUQgLyogbG90cy1vZi1pZnJhbWVzLmh0bWwgKi87IH07 CkBAIC0zNTksNiArMzYwLDcgQEAKIAkJODFCNTAxOTIxNDBGMjMyMzAwRDlFQjU4IC8qIFN0cmlu Z0J1aWxkZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBuYW1lID0gU3RyaW5n QnVpbGRlci5jcHA7IHBhdGggPSBXVEYvU3RyaW5nQnVpbGRlci5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCThBMkM3NTBEMTZDRUQ5NTUwMDI0RjM1MiAvKiBSZXNpemVXaW5kb3dB ZnRlckNyYXNoLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFJlc2l6 ZVdpbmRvd0FmdGVyQ3Jhc2guY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QTNB RjkzQTE2QzlFRDI3MDBEMjQ4QzEgLyogUmVsb2FkUGFnZUFmdGVyQ3Jhc2guY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVsb2FkUGFnZUFmdGVyQ3Jhc2guY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4QUEyOEMxOTE2RDJGQTdCMDAyRkY0REIgLyog TG9hZFBhZ2VPbkNyYXNoLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IExvYWRQYWdlT25DcmFzaC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThERDc2 RkExMDQ4NkFBNzYwMEQ5NkI1RSAvKiBUZXN0V2ViS2l0QVBJICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGV4cGxpY2l0RmlsZVR5cGUgPSAiY29tcGlsZWQubWFjaC1vLmV4ZWN1dGFibGUi OyBpbmNsdWRlSW5JbmRleCA9IDA7IHBhdGggPSBUZXN0V2ViS2l0QVBJOyBzb3VyY2VUcmVlID0g QlVJTFRfUFJPRFVDVFNfRElSOyB9OwogCQk5MzBBRDQwMTE1MDY5OEIzMDA2Nzk3MEYgLyogbG90 cy1vZi10ZXh0Lmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7IHBhdGggPSAibG90cy1vZi10ZXh0 Lmh0bWwiOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk5MzYxMDAyODE0REM5NTdCMDA2 MTM3OUQgLyogbG90cy1vZi1pZnJhbWVzLmh0bWwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0Lmh0bWw7IHBhdGgg PSAibG90cy1vZi1pZnJhbWVzLmh0bWwiOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAt NjYyLDYgKzY2NCw3IEBACiAJCQkJNTJDQjQ3NDAxNDQ4RkI5MzAwODczOTk1IC8qIExvYWRBbHRl cm5hdGVIVE1MU3RyaW5nV2l0aE5vbkRpcmVjdG9yeVVSTC5jcHAgKi8sCiAJCQkJMzNEQzg5MTAx NDE5NTNBMzAwNzQ3RUY3IC8qIExvYWRDYW5jZWxlZE5vU2VydmVyUmVkaXJlY3RDYWxsYmFjay5j cHAgKi8sCiAJCQkJMzNEQzg5MTMxNDE5NTc5RjAwNzQ3RUY3IC8qIExvYWRDYW5jZWxlZE5vU2Vy dmVyUmVkaXJlY3RDYWxsYmFja19CdW5kbGUuY3BwICovLAorCQkJCThBQTI4QzE5MTZEMkZBN0Iw MDJGRjREQiAvKiBMb2FkUGFnZU9uQ3Jhc2guY3BwICovLAogCQkJCTMzQkU1QUY0MTM3QjVBNkMw MDcwNTgxMyAvKiBNb3VzZU1vdmVBZnRlckNyYXNoLmNwcCAqLywKIAkJCQkzM0JFNUFGODEzN0I1 QUFFMDA3MDU4MTMgLyogTW91c2VNb3ZlQWZ0ZXJDcmFzaF9CdW5kbGUuY3BwICovLAogCQkJCTkz RjFEQjMwMTREQTIwNzYwMDI0QzM2MiAvKiBOZXdGaXJzdFZpc3VhbGx5Tm9uRW1wdHlMYXlvdXQu Y3BwICovLApAQCAtMTA0MSw2ICsxMDQ0LDcgQEAKIAkJCQkyNjMwMEIxODE2NzU1Q0Q5MDA2Njg4 NkQgLyogTGlzdEhhc2hTZXQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNTJDQjQ3NDExNDQ4RkI5 MzAwODczOTk1IC8qIExvYWRBbHRlcm5hdGVIVE1MU3RyaW5nV2l0aE5vbkRpcmVjdG9yeVVSTC5j cHAgaW4gU291cmNlcyAqLywKIAkJCQkzM0RDODkxMTE0MTk1M0EzMDA3NDdFRjcgLyogTG9hZENh bmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxiYWNrLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCThB QTI4QzFBMTZEMkZBN0IwMDJGRjREQiAvKiBMb2FkUGFnZU9uQ3Jhc2guY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJQjQwMzlGOUQxNUU2RDhCMzAwNzI1NUQ2IC8qIE1hdGhFeHRyYXMuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJQ0Q1NDk3QjQxNTg1N0YwQzAwQjVCQzMwIC8qIE1lZGlhVGltZS5jcHAg aW4gU291cmNlcyAqLywKIAkJCQlFMTIyMERBMDE1NUIyNTQ4MDAxM0UyRkMgLyogTWVtb3J5Q2Fj aGVEaXNhYmxlV2l0aGluUmVzb3VyY2VMb2FkRGVsZWdhdGUubW0gaW4gU291cmNlcyAqLywKZGlm ZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2FkUGFnZU9uQ3Jh c2guY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0xvYWRQYWdlT25DcmFz aC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjNkMTgzMAotLS0gL2Rl di9udWxsCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2FkUGFnZU9u Q3Jhc2guY3BwCkBAIC0wLDAgKzEsMTAyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEzIEFk ZW5pbHNvbiBDYXZhbGNhbnRpIDxjYXZhbGNhbnRpaUBnbWFpbC5jb20+CisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJ QlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElU UyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp bmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVV0aWxpdGllcy5oIgorI2luY2x1 ZGUgIlBsYXRmb3JtV2ViVmlldy5oIgorI2luY2x1ZGUgIlRlc3QuaCIKKyNpbmNsdWRlIDxXZWJL aXQyL1dLUmV0YWluUHRyLmg+CisKK25hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKKworc3RhdGlj IHZvaWQgZGlkRmluaXNoTG9hZChXS1BhZ2VSZWYsIFdLRnJhbWVSZWYsIFdLVHlwZVJlZiwgY29u c3Qgdm9pZCopOworCitjbGFzcyBXZWJLaXQyQ3Jhc2hMb2FkZXIgeworcHVibGljOgorICAgIFdl YktpdDJDcmFzaExvYWRlcigpCisgICAgICAgIDogY29udGV4dChBZG9wdFdLLCBXS0NvbnRleHRD cmVhdGUoKSkKKyAgICAgICAgLCB3ZWJWaWV3KGNvbnRleHQuZ2V0KCkpCisgICAgICAgICwgdXJs KGFkb3B0V0soV0tVUkxDcmVhdGVXaXRoVVRGOENTdHJpbmcoImFib3V0OmJsYW5rIikpKQorICAg ICAgICAsIGZpcnN0U3VjY2Vzc2Z1bExvYWQoZmFsc2UpCisgICAgICAgICwgc2Vjb25kU3VjY2Vz c2Z1bExvYWQoZmFsc2UpCisgICAgeworICAgICAgICBtZW1zZXQoJmxvYWRlckNsaWVudCwgMCwg c2l6ZW9mKGxvYWRlckNsaWVudCkpOworICAgICAgICBsb2FkZXJDbGllbnQuY2xpZW50SW5mbyA9 IHRoaXM7CisgICAgICAgIGxvYWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJhbWUgPSBkaWRG aW5pc2hMb2FkOworICAgICAgICBXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KHdlYlZpZXcucGFn ZSgpLCAmbG9hZGVyQ2xpZW50KTsKKyAgICB9CisKKyAgICB2b2lkIGxvYWRVcmwoKQorICAgIHsK KyAgICAgICAgV0tQYWdlTG9hZFVSTCh3ZWJWaWV3LnBhZ2UoKSwgdXJsLmdldCgpKTsKKyAgICB9 CisKKyAgICB2b2lkIHRlcm1pbmF0ZVdlYlByb2Nlc3MoKQorICAgIHsKKyAgICAgICAgV0tQYWdl VGVybWluYXRlKHdlYlZpZXcucGFnZSgpKTsKKyAgICB9CisKKyAgICBXS1JldGFpblB0cjxXS0Nv bnRleHRSZWY+IGNvbnRleHQ7CisgICAgV0tQYWdlTG9hZGVyQ2xpZW50IGxvYWRlckNsaWVudDsK KyAgICBQbGF0Zm9ybVdlYlZpZXcgd2ViVmlldzsKKyAgICBXS1JldGFpblB0cjxXS1VSTFJlZj4g dXJsOworCisgICAgYm9vbCBmaXJzdFN1Y2Nlc3NmdWxMb2FkOworICAgIGJvb2wgc2Vjb25kU3Vj Y2Vzc2Z1bExvYWQ7Cit9OworCisvLyBXZSBhcmUgZ29pbmcgdG8gaGF2ZSAyIGxvYWQgZXZlbnRz IGludGVydHdpbmVkIGJ5IGEgc2ltdWxhdGVkIGNyYXNoCisvLyAoaS5lLiBMb2FkIC0+IENyYXNo IC0+IExvYWQpLgordm9pZCBkaWRGaW5pc2hMb2FkKFdLUGFnZVJlZiBwYWdlLCBXS0ZyYW1lUmVm IGZyYW1lLCBXS1R5cGVSZWYgdXNlckRhdGEsIGNvbnN0IHZvaWQqIGNsaWVudEluZm8pCit7Cisg ICAgV2ViS2l0MkNyYXNoTG9hZGVyKiB0ZXN0SGVscGVyID0gY29uc3RfY2FzdDxXZWJLaXQyQ3Jh c2hMb2FkZXIqPihzdGF0aWNfY2FzdDxjb25zdCBXZWJLaXQyQ3Jhc2hMb2FkZXIqPihjbGllbnRJ bmZvKSk7CisKKyAgICAvLyBGaXJzdCBsb2FkIHdvcmtlZCwgbGV0J3MgY3Jhc2ggV2ViUHJvY2Vz cy4KKyAgICBpZiAoIXRlc3RIZWxwZXItPmZpcnN0U3VjY2Vzc2Z1bExvYWQpIHsKKyAgICAgICAg dGVzdEhlbHBlci0+Zmlyc3RTdWNjZXNzZnVsTG9hZCA9IHRydWU7CisgICAgICAgIHJldHVybjsK KyAgICB9CisKKyAgICAvLyBTZWNvbmQgbG9hZCB3b3JrZWQsIHdlIGFyZSBkb25lLgorICAgIEVY UEVDVF9UUlVFKHRlc3RIZWxwZXItPmZpcnN0U3VjY2Vzc2Z1bExvYWQpOworICAgIGlmICghdGVz dEhlbHBlci0+c2Vjb25kU3VjY2Vzc2Z1bExvYWQpIHsKKyAgICAgICAgdGVzdEhlbHBlci0+c2Vj b25kU3VjY2Vzc2Z1bExvYWQgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorfQorCisv LyBUaGlzIHRlc3Qgd2lsbCBsb2FkIGEgYmxhbmsgcGFnZSBhbmQgbmV4dCBraWxsIFdlYlByb2Nl c3MsIHRoZSBleHBlY3RlZAorLy8gcmVzdWx0IGlzIHRoYXQgYSBjYWxsIHRvIHBhZ2UgbG9hZCBz aG91bGQgc3Bhd24gYSBuZXcgV2ViUHJvY2Vzcy4KK1RFU1QoV2ViS2l0MiwgTG9hZFBhZ2VBZnRl ckNyYXNoKQoreworICAgIFdlYktpdDJDcmFzaExvYWRlciBoZWxwZXI7CisgICAgaGVscGVyLmxv YWRVcmwoKTsKKyAgICBVdGlsOjpydW4oJmhlbHBlci5maXJzdFN1Y2Nlc3NmdWxMb2FkKTsKKyAg ICBoZWxwZXIudGVybWluYXRlV2ViUHJvY2VzcygpOworICAgIGhlbHBlci5sb2FkVXJsKCk7Cisg ICAgVXRpbDo6cnVuKCZoZWxwZXIuc2Vjb25kU3VjY2Vzc2Z1bExvYWQpOworfQorCit9IC8vIG5h bWVzcGFjZSBUZXN0V2ViS2l0QVBJCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dlYktpdDIvTW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJ L1Rlc3RzL1dlYktpdDIvTW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHAKaW5kZXggOWI0NzA1MS4uNGJm NTUyNyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL01vdXNl TW92ZUFmdGVyQ3Jhc2guY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 Mi9Nb3VzZU1vdmVBZnRlckNyYXNoLmNwcApAQCAtMzcsMTEgKzM3LDYgQEAgc3RhdGljIHZvaWQg ZGlkRmluaXNoTG9hZEZvckZyYW1lKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tUeXBlUmVmLCBj b25zdCB2b2lkKikKICAgICBkaWRGaW5pc2hMb2FkID0gdHJ1ZTsKIH0KIAotc3RhdGljIHZvaWQg cHJvY2Vzc0RpZENyYXNoKFdLUGFnZVJlZiBwYWdlLCBjb25zdCB2b2lkKikKLXsKLSAgICBXS1Bh Z2VSZWxvYWQocGFnZSk7Ci19Ci0KIHN0YXRpYyB2b2lkIHNldFBhZ2VMb2FkZXJDbGllbnQoV0tQ YWdlUmVmIHBhZ2UpCiB7CiAgICAgV0tQYWdlTG9hZGVyQ2xpZW50IGxvYWRlckNsaWVudDsKQEAg LTQ5LDcgKzQ0LDYgQEAgc3RhdGljIHZvaWQgc2V0UGFnZUxvYWRlckNsaWVudChXS1BhZ2VSZWYg cGFnZSkKICAgICBsb2FkZXJDbGllbnQudmVyc2lvbiA9IDA7CiAgICAgbG9hZGVyQ2xpZW50LmNs aWVudEluZm8gPSAwOwogICAgIGxvYWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJhbWUgPSBk aWRGaW5pc2hMb2FkRm9yRnJhbWU7Ci0gICAgbG9hZGVyQ2xpZW50LnByb2Nlc3NEaWRDcmFzaCA9 IHByb2Nlc3NEaWRDcmFzaDsKIAogICAgIFdLUGFnZVNldFBhZ2VMb2FkZXJDbGllbnQocGFnZSwg JmxvYWRlckNsaWVudCk7CiB9CkBAIC03OSwxMSArNzMsMTEgQEAgVEVTVChXZWJLaXQyLCBNb3Vz ZU1vdmVBZnRlckNyYXNoKQogICAgIHdlYlZpZXcuc2ltdWxhdGVNb3VzZU1vdmUoMTAsIDEwKTsK ICAgICB3ZWJWaWV3LnNpbXVsYXRlTW91c2VNb3ZlKDIwLCAyMCk7CiAKLSAgICAvLyBBZnRlciBt b3ZpbmcgdGhlIG1vdXNlICh3aGlsZSB0aGUgd2ViIHByb2Nlc3Mgd2FzIGh1bmcgb24gdGhlIFBh dXNlIG1lc3NhZ2UpLCBraWxsIHRoZSB3ZWIgcHJvY2Vzcy4gSXQgaXMgcmVzdGFydGVkIGluCi0g ICAgLy8gcHJvY2Vzc0RpZENyYXNoIGJ5IHJlbG9hZGluZyB0aGUgcGFnZS4KKyAgICAvLyBBZnRl ciBtb3ZpbmcgdGhlIG1vdXNlICh3aGlsZSB0aGUgd2ViIHByb2Nlc3Mgd2FzIGh1bmcgb24gdGhl IFBhdXNlIG1lc3NhZ2UpLCBraWxsIHRoZSB3ZWIgcHJvY2Vzcy4gSXQgaXMgcmVzdGFydGVkIGJ5 IHJlbG9hZGluZyB0aGUgcGFnZS4KICAgICBXS1BhZ2VUZXJtaW5hdGUod2ViVmlldy5wYWdlKCkp OworICAgIFdLUGFnZVJlbG9hZCh3ZWJWaWV3LnBhZ2UoKSk7CiAKLSAgICAvLyBXYWl0IHVudGls IHdlIGxvYWQgdGhlIHBhZ2UgYSBzZWNvbmQgdGltZSAodmlhIHJlbG9hZGluZyB0aGUgcGFnZSBp biBwcm9jZXNzRGlkQ3Jhc2gpLgorICAgIC8vIFdhaXQgdW50aWwgd2UgbG9hZCB0aGUgcGFnZSBh IHNlY29uZCB0aW1lLgogICAgIFV0aWw6OnJ1bigmZGlkRmluaXNoTG9hZCk7CiAKICAgICBFWFBF Q1RfSlNfRkFMU0Uod2ViVmlldy5wYWdlKCksICJkaWRNb3ZlTW91c2UoKSIpOwpkaWZmIC0tZ2l0 IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvIGIvVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvCmluZGV4IDk0NTJhNWEuLjFk MDYzNzkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9XZWJL aXQyLnBybworKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvV2ViS2l0Mi5w cm8KQEAgLTE5LDYgKzE5LDcgQEAgU09VUkNFUyArPSBcCiAgICAgSW5qZWN0ZWRCdW5kbGVJbml0 aWFsaXphdGlvblVzZXJEYXRhQ2FsbGJhY2tXaW5zLmNwcCBcCiAgICAgTG9hZEFsdGVybmF0ZUhU TUxTdHJpbmdXaXRoTm9uRGlyZWN0b3J5VVJMLmNwcCBcCiAgICAgTG9hZENhbmNlbGVkTm9TZXJ2 ZXJSZWRpcmVjdENhbGxiYWNrLmNwcCBcCisgICAgTG9hZFBhZ2VPbkNyYXNoLmNwcCBcCiAgICAg TW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHAgXAogICAgIFBhZ2VMb2FkQmFzaWMuY3BwIFwKICAgICBQ YWdlTG9hZERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZUZvckZyYW1lLmNwcCBcCi0tIAoxLjcu MTAuNAoK 197886 2013-04-12 14:21:43 -0700 2013-04-12 14:23:03 -0700 Patch bug-110743-20130412142120.patch text/plain 19589 benjamin U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ4MzAyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZTg2ZDkxOWJiZmQ3NTY5 YTMyMWVlN2NhNTQ3NGQ4MWMwMDBkZGNlNC4uODQzYzI0MTNhZWQ1ZjM3YmFjODkzZjgwYzk5ZDRh ODEwM2RjYjJmNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQyIEBACisyMDEzLTA0LTA3ICBBZGVu aWxzb24gQ2F2YWxjYW50aSAgPGNhdmFsY2FudGlpQGdtYWlsLmNvbT4KKworICAgICAgICBbV0sy XSBXZWJQYWdlUHJveHkgbG9hZFVSTCgpIHdvbid0IHdvcmsgd2hlbiBjYWxsZWQganVzdCBhZnRl ciB0ZXJtaW5hdGVQcm9jZXNzKCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTExMDc0MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIEEgY2FsbCB0byBsb2FkVVJMKCkganVzdCBhZnRlciB0ZXJtaW5hdGluZyBX ZWJQcm9jZXNzIHdpbGwgZmFpbCB0aGFua3MgdG8KKyAgICAgICAgV2ViUGFnZVByb3h5IGJlaW5n IGluIGFuIHVuZGVmaW5lZCBzdGF0ZSBzaW5jZSBpdCBpcyBpbiB0aGUgbWlkZGxlIG9mIGl0cyBv d24KKyAgICAgICAgY2xlYW51cCBhZnRlciBwcm9jZXNzIHRlcm1pbmF0aW9uLgorCisgICAgICAg IFRvIHByb3Blcmx5IGZpeCB0aGlzLCBub3Qgb25seSBXZWJQYWdlUHJveHkgY2xlYW51cCBzaG91 bGQgYmUgbWFkZQorICAgICAgICBhdCBXZWJQcm9jZXNzIHRlcm1pbmF0aW9uIHJlcXVlc3QsIGJ1 dCBhbHNvIFdlYlByb2Nlc3NQcm94eSBuZWVkcworICAgICAgICB0byBvbmx5IHJldHVybiB0byBp dHMgY2FsbGVyIGFmdGVyIHRlcm1pbmF0aW5nIHRoZSBwcm9jZXNzIGFuZAorICAgICAgICBjbG9z aW5nIGNvbm5lY3Rpb25zLiBPdGhlcndpc2UsIFdlYlBhZ2VQcm94eSBjYW4gZXZlbiBiZSBhYmxl IHRvCisgICAgICAgIGRldGVjdCB0aGF0IFdlYlByb2Nlc3MgaXMgbm8gbG9uZ2VyIHJ1bm5pbmcs IGJ1dCBhIGNhbGwgdG8gcmVzcGF3bgorICAgICAgICB0aGUgcHJvY2VzcyB3aWxsIGZhaWwuCisK KyAgICAgICAgVG8gZml4IHRoZXNlIGlzc3VlcywgdGhpcyBwYXRjaCBtb3ZlcyB0aGUgY2xlYW51 cCBjb2RlIHRvIGEgc2hhcmVkIHByaXZhdGUgZnVuY3Rpb24KKyAgICAgICAgdGhhdCBpcyB1c2Vk IGZvciBib3RoIHRoZSBjYXNlcyBpLmUuIHVzZXIgdGVybWluYXRpb24gYW5kIHJlYWwgY3Jhc2gu IFdlYlByb2Nlc3MKKyAgICAgICAgc2h1dGRvd24gaXMgZG9uZSB1c2luZyBhIG5ldyBtZXRob2Qg dGhhdCBlbnN1cmVzIHRoYXQgYWxsIGNsZWFudXAgd2FzIGRvbmUgYmVmb3JlCisgICAgICAgIHJl dHVybmluZy4KKworICAgICAgICBBIGxhc3QgY2hhbmdlIGludHJvZHVjZWQgaW4gdGhpcyBwYXRj aCBpcyB0aGF0IGZvciB1c2VyIHJlcXVlc3RlZCB0ZXJtaW5hdGlvbiwKKyAgICAgICAgY2xpZW50 cyBhcmUgbm8gbG9uZ2VyIG5vdGlmaWVkIG9mIGEgY3Jhc2ggKHNpbmNlIGl0IGlzIG5vdCBhIGNy YXNoKS4KKworICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJQYWdlUHJveHk6OnRlcm1pbmF0ZVByb2Nlc3MpOgorICAgICAgICAoV2ViS2l0 OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCk6CisgICAgICAgIChXZWJLaXQpOgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnJlc2V0U3RhdGVBZnRlclByb2Nlc3NFeGl0KToK KyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lmg6CisgICAgICAgIChXZWJQYWdlUHJv eHkpOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJQcm9jZXNzUHJveHk6OnVzZXJSZXF1ZXN0ZWRUZXJtaW5hdGUpOgorICAgICAg ICAoV2ViS2l0KToKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5Lmg6CisgICAg ICAgIChXZWJQcm9jZXNzUHJveHkpOgorCiAyMDEzLTA0LTEyICBUaW0gSG9ydG9uICA8dGltb3Ro eV9ob3J0b25AYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT04gKHIxMzg4NTgpOiBHSUZz IGRvbid0IHN0YXJ0IHBsYXlpbmcgd2hlbiB0aGV5IGNvbWUgb3V0IG9mIGJhY2tncm91bmQgdGFi cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAppbmRleCA4NTE3MzQw NTViZTI0OWYyZTVkMDA5MjgzZWMwZDU1ZjZiNWNhMTE2Li4yNWJjZDljYWM3MmFmYWYzNTY2Y2Fi Y2NiODI1MjEyZTAxNjk3YWIxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv V2ViUGFnZVByb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmNwcApAQCAtMTU2Nyw3ICsxNTY3LDggQEAgdm9pZCBXZWJQYWdlUHJveHk6OnRlcm1pbmF0 ZVByb2Nlc3MoKQogICAgIGlmICghbV9pc1ZhbGlkKQogICAgICAgICByZXR1cm47CiAKLSAgICBt X3Byb2Nlc3MtPnRlcm1pbmF0ZSgpOworICAgIG1fcHJvY2Vzcy0+cmVxdWVzdFRlcm1pbmF0aW9u KCk7CisgICAgcmVzZXRTdGF0ZUFmdGVyUHJvY2Vzc0V4aXQoKTsKIH0KIAogI2lmICFVU0UoQ0Yp IHx8IGRlZmluZWQoQlVJTERJTkdfUVRfXykKQEAgLTM3OTgsOCArMzc5OSwxNyBAQCB2b2lkIFdl YlBhZ2VQcm94eTo6cHJvY2Vzc0RpZEJlY29tZVJlc3BvbnNpdmUoKQogCiB2b2lkIFdlYlBhZ2VQ cm94eTo6cHJvY2Vzc0RpZENyYXNoKCkKIHsKLSAgICBBU1NFUlQobV9wYWdlQ2xpZW50KTsKKyAg ICBBU1NFUlQobV9pc1ZhbGlkKTsKKworICAgIHJlc2V0U3RhdGVBZnRlclByb2Nlc3NFeGl0KCk7 CisKKyAgICBtX3BhZ2VDbGllbnQtPnByb2Nlc3NEaWRDcmFzaCgpOworICAgIG1fbG9hZGVyQ2xp ZW50LnByb2Nlc3NEaWRDcmFzaCh0aGlzKTsKK30KIAordm9pZCBXZWJQYWdlUHJveHk6OnJlc2V0 U3RhdGVBZnRlclByb2Nlc3NFeGl0KCkKK3sKKyAgICBBU1NFUlQobV9wYWdlQ2xpZW50KTsKICAg ICBtX3Byb2Nlc3MtPnJlbW92ZU1lc3NhZ2VSZWNlaXZlcihNZXNzYWdlczo6V2ViUGFnZVByb3h5 OjptZXNzYWdlUmVjZWl2ZXJOYW1lKCksIG1fcGFnZUlEKTsKIAogICAgIG1faXNWYWxpZCA9IGZh bHNlOwpAQCAtMzg4NiwxNiArMzg5NiwxMSBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6cHJvY2Vzc0Rp ZENyYXNoKCkKIAogICAgIG1fcGVuZGluZ0xlYXJuT3JJZ25vcmVXb3JkTWVzc2FnZUNvdW50ID0g MDsKIAotICAgIG1fcGFnZUNsaWVudC0+cHJvY2Vzc0RpZENyYXNoKCk7Ci0gICAgbV9sb2FkZXJD bGllbnQucHJvY2Vzc0RpZENyYXNoKHRoaXMpOwotCi0gICAgaWYgKCFtX2lzVmFsaWQpIHsKLSAg ICAgICAgLy8gSWYgdGhlIGNhbGwgb3V0IHRvIHRoZSBsb2FkZXIgY2xpZW50IGRpZG4ndCBjYXVz ZSB0aGUgd2ViIHByb2Nlc3MgdG8gYmUgcmVsYXVuY2hlZCwgCi0gICAgICAgIC8vIHdlJ2xsIGNh bGwgc2V0TmVlZHNEaXNwbGF5IG9uIHRoZSB2aWV3IHNvIHRoYXQgd2Ugd29uJ3QgaGF2ZSB0aGUg b2xkIGNvbnRlbnRzIHNob3dpbmcuCi0gICAgICAgIC8vIElmIHRoZSBjYWxsIGRpZCBjYXVzZSB0 aGUgd2ViIHByb2Nlc3MgdG8gYmUgcmVsYXVuY2hlZCwgd2UnbGwga2VlcCB0aGUgb2xkIHBhZ2Ug Y29udGVudHMgc2hvd2luZwotICAgICAgICAvLyB1bnRpbCB0aGUgbmV3IHdlYiBwcm9jZXNzIGhh cyBwYWludGVkIGl0cyBjb250ZW50cy4KLSAgICAgICAgc2V0Vmlld05lZWRzRGlzcGxheShJbnRS ZWN0KEludFBvaW50KCksIHZpZXdTaXplKCkpKTsKLSAgICB9CisgICAgLy8gSWYgdGhlIGNhbGwg b3V0IHRvIHRoZSBsb2FkZXIgY2xpZW50IGRpZG4ndCBjYXVzZSB0aGUgd2ViIHByb2Nlc3MgdG8g YmUgcmVsYXVuY2hlZCwKKyAgICAvLyB3ZSdsbCBjYWxsIHNldE5lZWRzRGlzcGxheSBvbiB0aGUg dmlldyBzbyB0aGF0IHdlIHdvbid0IGhhdmUgdGhlIG9sZCBjb250ZW50cyBzaG93aW5nLgorICAg IC8vIElmIHRoZSBjYWxsIGRpZCBjYXVzZSB0aGUgd2ViIHByb2Nlc3MgdG8gYmUgcmVsYXVuY2hl ZCwgd2UnbGwga2VlcCB0aGUgb2xkIHBhZ2UgY29udGVudHMgc2hvd2luZworICAgIC8vIHVudGls IHRoZSBuZXcgd2ViIHByb2Nlc3MgaGFzIHBhaW50ZWQgaXRzIGNvbnRlbnRzLgorICAgIHNldFZp ZXdOZWVkc0Rpc3BsYXkoSW50UmVjdChJbnRQb2ludCgpLCB2aWV3U2l6ZSgpKSk7CiAKICAgICAv LyBDYW4ndCBleHBlY3QgRGlkUmVjZWl2ZUV2ZW50IG5vdGlmaWNhdGlvbnMgZnJvbSBhIGNyYXNo ZWQgd2ViIHByb2Nlc3MuCiAgICAgbV9rZXlFdmVudFF1ZXVlLmNsZWFyKCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmggYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKaW5kZXggMmYwOTkyMTYzZjg3MDdjOTdjNmRmNTcx ODIwMGZmYjZjODQ0OTA0Yy4uMjIxNDU0OTAwNTE3MjI3MWNmN2ZhMjBkOTFkODNiNmIyYmExZDMy ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCisr KyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaApAQCAtNzc3LDYgKzc3 Nyw4IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgV2ViUGFnZVByb3h5KFBhZ2VDbGllbnQqLCBQ YXNzUmVmUHRyPFdlYlByb2Nlc3NQcm94eT4sIFdlYlBhZ2VHcm91cCosIHVpbnQ2NF90IHBhZ2VJ RCk7CiAKKyAgICB2b2lkIHJlc2V0U3RhdGVBZnRlclByb2Nlc3NFeGl0KCk7CisKICAgICAvLyBD b3JlSVBDOjpNZXNzYWdlUmVjZWl2ZXIKICAgICB2aXJ0dWFsIHZvaWQgZGlkUmVjZWl2ZU1lc3Nh Z2UoQ29yZUlQQzo6Q29ubmVjdGlvbiosIENvcmVJUEM6Ok1lc3NhZ2VEZWNvZGVyJikgT1ZFUlJJ REU7CiAgICAgdmlydHVhbCB2b2lkIGRpZFJlY2VpdmVTeW5jTWVzc2FnZShDb3JlSVBDOjpDb25u ZWN0aW9uKiwgQ29yZUlQQzo6TWVzc2FnZURlY29kZXImLCBPd25QdHI8Q29yZUlQQzo6TWVzc2Fn ZUVuY29kZXI+JikgT1ZFUlJJREU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvV2ViUHJvY2Vzc1Byb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9j ZXNzUHJveHkuY3BwCmluZGV4IDZjNjQ4ZGRkMGVkNWYzOWZkN2MwYzlhZDE4YjExZTc5ZDdiYjdm MmIuLjBkYzExZDc0YWM4YjU4NTE2MThlMjM5NGZiMzkyZGYxYzdmZTA1NWQgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuY3BwCkBAIC02MjYsNCArNjI2LDEx IEBAIHZvaWQgV2ViUHJvY2Vzc1Byb3h5OjpwYWdlUHJlZmVyZW5jZXNDaGFuZ2VkKFdlYktpdDo6 V2ViUGFnZVByb3h5ICpwYWdlKQogI2VuZGlmCiB9CiAKK3ZvaWQgV2ViUHJvY2Vzc1Byb3h5Ojpy ZXF1ZXN0VGVybWluYXRpb24oKQoreworICAgIENoaWxkUHJvY2Vzc1Byb3h5Ojp0ZXJtaW5hdGUo KTsKKyAgICB3ZWJDb25uZWN0aW9uKCktPmRpZENsb3NlKCk7CisgICAgZGlzY29ubmVjdCgpOwor fQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9XZWJQcm9jZXNzUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQ cm9jZXNzUHJveHkuaAppbmRleCBkMzM1Y2UxMjA0YjY4NDkyN2FjYjFhYzgwNjE3NTI4MDlkODEx ZGRjLi42N2VmNGNmYWJlNjg1ZmFlOTViMTRiYWE3NmZkOWUyMGEzMjM5Yjg5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Byb3h5LmgKKysrIGIvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQcm94eS5oCkBAIC0xMTUsNiArMTE1LDggQEAg cHVibGljOgogICAgIHZvaWQgdXBkYXRlUHJvY2Vzc1N1cHByZXNzaW9uU3RhdGUoKTsKICNlbmRp ZgogCisgICAgdm9pZCByZXF1ZXN0VGVybWluYXRpb24oKTsKKwogcHJpdmF0ZToKICAgICBleHBs aWNpdCBXZWJQcm9jZXNzUHJveHkoUGFzc1JlZlB0cjxXZWJDb250ZXh0Pik7CiAKZGlmZiAtLWdp dCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBmY2RhOGFhY2NjNjMy MWEwYTY5MmQ1YzdkMzM4OGY3MzU1YzkzOWZjLi5jODlhMTM4YmQ3OWIwZjRhMjQ0NmFkNGVhOTI0 ZDY3NzhkZDY4ZTViIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTMtMDQtMDcgIEFkZW5pbHNvbiBDYXZhbGNhbnRp ICA8Y2F2YWxjYW50aWlAZ21haWwuY29tPgorCisgICAgICAgIFtXSzJdIFdlYlBhZ2VQcm94eSBs b2FkVVJMKCkgd29uJ3Qgd29yayB3aGVuIGNhbGxlZCBqdXN0IGFmdGVyIHRlcm1pbmF0ZVByb2Nl c3MoKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEw NzQzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRk aW5nIGEgbmV3IHRlc3QgZmlsZSB0byBjaGVjayBpZiBsb2FkaW5nIGEgcGFnZSBqdXN0IGFmdGVy IFdlYlByb2Nlc3MKKyAgICAgICAgaGFzIGNyYXNoZWQgKG9yIHdhcyB0ZXJtaW5hdGVkKSB3b3Jr cy4gVGhlIHRlc3QgZXhlY3V0ZXMgdGhlCisgICAgICAgIGZvbGxvd2luZyBzdGVwcyAoTG9hZCwg Q3Jhc2gsIExvYWQpLCB0aHVzIHN0cmVzc2luZyBXZWJQcm9jZXNzCisgICAgICAgIHJlYXR0YWNo IGFuZCBwcm9jZXNzIHRlcm1pbmF0aW9uIGNvZGUgcGF0aC4KKworICAgICAgICAqIFRlc3RXZWJL aXRBUEkvR05VbWFrZWZpbGUuYW06CisgICAgICAgICogVGVzdFdlYktpdEFQSS9QbGF0Zm9ybUVm bC5jbWFrZToKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RXZWJLaXRBUEkueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIv TW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHA6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpzZXRQYWdl TG9hZGVyQ2xpZW50KToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorICAgICAgICAq IFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2FkUGFnZU9uQ3Jhc2guY3BwOiBBZGRlZC4K KyAgICAgICAgKFRlc3RXZWJLaXRBUEkpOgorICAgICAgICAoV2ViS2l0MkNyYXNoTG9hZGVyKToK KyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OldlYktpdDJDcmFzaExvYWRlcjo6V2ViS2l0MkNyYXNo TG9hZGVyKToKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OldlYktpdDJDcmFzaExvYWRlcjo6bG9h ZFVybCk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpXZWJLaXQyQ3Jhc2hMb2FkZXI6OmNyYXNo V2ViUHJvY2Vzcyk6CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpkaWRGaW5pc2hMb2FkKToKKyAg ICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mi9XZWJLaXQyLnBybzoKKwogMjAxMy0wNC0wOSAgUm9nZXIgRm9uZyAgPHJvZ2Vy X2ZvbmdAYXBwbGUuY29tPgogCiAgICAgICAgIFJlLWVuYWJsZSBXaW5FV1MgdGVzdHMuCmRpZmYg LS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL0dOVW1ha2VmaWxlLmFtIGIvVG9vbHMvVGVzdFdl YktpdEFQSS9HTlVtYWtlZmlsZS5hbQppbmRleCAzNDRmNjBiNDUyNTI5Y2E2ZjBmYmNlYmUyZjUw MTY4OTBkMmUzODk4Li45YjIwZTAzN2QwZjBlZmQ1NzQ5ZjA3Yjk0ZGJjMDQ2MzczOWNkOGZiIDEw MDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL0dOVW1ha2VmaWxlLmFtCisrKyBiL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvR05VbWFrZWZpbGUuYW0KQEAgLTE1NSw2ICsxNTUsNyBAQCBQcm9ncmFt c19UZXN0V2ViS2l0QVBJX1Rlc3RXZWJLaXQyX1NPVVJDRVMgPSBcCiAJVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyL0luamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YUNh bGxiYWNrV2lucy5jcHAgXAogCVRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Mb2Fk QWx0ZXJuYXRlSFRNTFN0cmluZ1dpdGhOb25EaXJlY3RvcnlVUkwuY3BwIFwKIAlUb29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTG9hZENhbmNlbGVkTm9TZXJ2ZXJSZWRpcmVjdENhbGxi YWNrLmNwcCBcCisJVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL0xvYWRQYWdlT25D cmFzaC5jcHAgXAogCVRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Nb3VzZU1vdmVB ZnRlckNyYXNoLmNwcCBcCiAJVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1JlbG9h ZFBhZ2VBZnRlckNyYXNoLmNwcCBcCiAJVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy L1Jlc2l6ZVdpbmRvd0FmdGVyQ3Jhc2guY3BwIFwKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvUGxhdGZvcm1FZmwuY21ha2UgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtRWZs LmNtYWtlCmluZGV4IDFiNGU5NjA2YTVjOGI2ODNkMTRmMjcxZTk0MjQzYWVhZGFjMzZjZGEuLmI0 OGIwMDQyYWZiZDIwMGQ4NDEzN2I0ZDg1ODMwMTlkMWRjOGNiMDcgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1FZmwuY21ha2UKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQ SS9QbGF0Zm9ybUVmbC5jbWFrZQpAQCAtNjgsNiArNjgsNyBAQCBzZXQodGVzdF93ZWJraXQyX2Fw aV9CSU5BUklFUwogICAgIEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25Vc2VyRGF0YUNhbGxi YWNrV2lucwogICAgIExvYWRBbHRlcm5hdGVIVE1MU3RyaW5nV2l0aE5vbkRpcmVjdG9yeVVSTAog ICAgIExvYWRDYW5jZWxlZE5vU2VydmVyUmVkaXJlY3RDYWxsYmFjaworICAgIExvYWRQYWdlT25D cmFzaAogICAgIE1vdXNlTW92ZUFmdGVyQ3Jhc2gKICAgICBSZWxvYWRQYWdlQWZ0ZXJDcmFzaAog ICAgIFJlc2l6ZVdpbmRvd0FmdGVyQ3Jhc2gKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdFdlYktpdEFQSS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNWY2 NmIwOTliOTc1NTZhNDNjN2JhOTE5ODBkNzYwNTJjM2Q4MDk3Ni4uNjYwODY4ZDQxNGU2MWFiNzI2 ZTMzYTUyMGVkYjlmNTY1MGQ1Nzg4NyAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0V2ViS2l0QVBJLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTkxLDYg KzkxLDcgQEAKIAkJODFCNTAxOTMxNDBGMjMyMzAwRDlFQjU4IC8qIFN0cmluZ0J1aWxkZXIuY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gODFCNTAxOTIx NDBGMjMyMzAwRDlFQjU4IC8qIFN0cmluZ0J1aWxkZXIuY3BwICovOyB9OwogCQk4QTJDNzUwRTE2 Q0VEOTU1MDAyNEYzNTIgLyogUmVzaXplV2luZG93QWZ0ZXJDcmFzaC5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTJDNzUwRDE2Q0VEOTU1MDAyNEYz NTIgLyogUmVzaXplV2luZG93QWZ0ZXJDcmFzaC5jcHAgKi87IH07CiAJCThBM0FGOTNCMTZDOUVE MjcwMEQyNDhDMSAvKiBSZWxvYWRQYWdlQWZ0ZXJDcmFzaC5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTNBRjkzQTE2QzlFRDI3MDBEMjQ4QzEgLyog UmVsb2FkUGFnZUFmdGVyQ3Jhc2guY3BwICovOyB9OworCQk4QUEyOEMxQTE2RDJGQTdCMDAyRkY0 REIgLyogTG9hZFBhZ2VPbkNyYXNoLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDhBQTI4QzE5MTZEMkZBN0IwMDJGRjREQiAvKiBMb2FkUGFnZU9uQ3Jh c2guY3BwICovOyB9OwogCQk5MzBBRDQwMjE1MDY5OEQwMDA2Nzk3MEYgLyogbG90cy1vZi10ZXh0 Lmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gOTMwQUQ0MDExNTA2OThCMzAwNjc5NzBGIC8qIGxvdHMtb2YtdGV4dC5odG1sICovOyB9Owog CQk5MzE4Nzc4OTE1RUVDNTc3MDBBOUNDRTMgLyogTmV3Rmlyc3RWaXN1YWxseU5vbkVtcHR5TGF5 b3V0Rm9ySW1hZ2VzLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDkzQUY0RUNBMTUwNkYwMzUwMDdGRDU3RSAvKiBOZXdGaXJzdFZpc3VhbGx5Tm9uRW1w dHlMYXlvdXRGb3JJbWFnZXMuY3BwICovOyB9OwogCQk5MzYxMDAyOTE0REM5NUE3MDA2MTM3OUQg LyogbG90cy1vZi1pZnJhbWVzLmh0bWwgaW4gQ29weSBSZXNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gOTM2MTAwMjgxNERDOTU3QjAwNjEzNzlEIC8qIGxvdHMtb2Yt aWZyYW1lcy5odG1sICovOyB9OwpAQCAtMzU5LDYgKzM2MCw3IEBACiAJCTgxQjUwMTkyMTQwRjIz MjMwMEQ5RUI1OCAvKiBTdHJpbmdCdWlsZGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgbmFtZSA9IFN0cmluZ0J1aWxkZXIuY3BwOyBwYXRoID0gV1RGL1N0cmluZ0J1aWxkZXIu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QTJDNzUwRDE2Q0VEOTU1MDAyNEYz NTIgLyogUmVzaXplV2luZG93QWZ0ZXJDcmFzaC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBSZXNpemVXaW5kb3dBZnRlckNyYXNoLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJOEEzQUY5M0ExNkM5RUQyNzAwRDI0OEMxIC8qIFJlbG9hZFBhZ2VBZnRl ckNyYXNoLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFJlbG9hZFBh Z2VBZnRlckNyYXNoLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOEFBMjhDMTkx NkQyRkE3QjAwMkZGNERCIC8qIExvYWRQYWdlT25DcmFzaC5jcHAgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBMb2FkUGFnZU9uQ3Jhc2guY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk4REQ3NkZBMTA0ODZBQTc2MDBEOTZCNUUgLyogVGVzdFdlYktpdEFQSSAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBleHBsaWNpdEZpbGVUeXBlID0gImNvbXBpbGVk Lm1hY2gtby5leGVjdXRhYmxlIjsgaW5jbHVkZUluSW5kZXggPSAwOyBwYXRoID0gVGVzdFdlYktp dEFQSTsgc291cmNlVHJlZSA9IEJVSUxUX1BST0RVQ1RTX0RJUjsgfTsKIAkJOTMwQUQ0MDExNTA2 OThCMzAwNjc5NzBGIC8qIGxvdHMtb2YtdGV4dC5odG1sICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5odG1sOyBw YXRoID0gImxvdHMtb2YtdGV4dC5odG1sIjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ OTM2MTAwMjgxNERDOTU3QjAwNjEzNzlEIC8qIGxvdHMtb2YtaWZyYW1lcy5odG1sICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gdGV4dC5odG1sOyBwYXRoID0gImxvdHMtb2YtaWZyYW1lcy5odG1sIjsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKQEAgLTY2Miw2ICs2NjQsNyBAQAogCQkJCTUyQ0I0NzQwMTQ0OEZCOTMw MDg3Mzk5NSAvKiBMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZ1dpdGhOb25EaXJlY3RvcnlVUkwuY3Bw ICovLAogCQkJCTMzREM4OTEwMTQxOTUzQTMwMDc0N0VGNyAvKiBMb2FkQ2FuY2VsZWROb1NlcnZl clJlZGlyZWN0Q2FsbGJhY2suY3BwICovLAogCQkJCTMzREM4OTEzMTQxOTU3OUYwMDc0N0VGNyAv KiBMb2FkQ2FuY2VsZWROb1NlcnZlclJlZGlyZWN0Q2FsbGJhY2tfQnVuZGxlLmNwcCAqLywKKwkJ CQk4QUEyOEMxOTE2RDJGQTdCMDAyRkY0REIgLyogTG9hZFBhZ2VPbkNyYXNoLmNwcCAqLywKIAkJ CQkzM0JFNUFGNDEzN0I1QTZDMDA3MDU4MTMgLyogTW91c2VNb3ZlQWZ0ZXJDcmFzaC5jcHAgKi8s CiAJCQkJMzNCRTVBRjgxMzdCNUFBRTAwNzA1ODEzIC8qIE1vdXNlTW92ZUFmdGVyQ3Jhc2hfQnVu ZGxlLmNwcCAqLywKIAkJCQk5M0YxREIzMDE0REEyMDc2MDAyNEMzNjIgLyogTmV3Rmlyc3RWaXN1 YWxseU5vbkVtcHR5TGF5b3V0LmNwcCAqLywKQEAgLTEwNDEsNiArMTA0NCw3IEBACiAJCQkJMjYz MDBCMTgxNjc1NUNEOTAwNjY4ODZEIC8qIExpc3RIYXNoU2V0LmNwcCBpbiBTb3VyY2VzICovLAog CQkJCTUyQ0I0NzQxMTQ0OEZCOTMwMDg3Mzk5NSAvKiBMb2FkQWx0ZXJuYXRlSFRNTFN0cmluZ1dp dGhOb25EaXJlY3RvcnlVUkwuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJMzNEQzg5MTExNDE5NTNB MzAwNzQ3RUY3IC8qIExvYWRDYW5jZWxlZE5vU2VydmVyUmVkaXJlY3RDYWxsYmFjay5jcHAgaW4g U291cmNlcyAqLywKKwkJCQk4QUEyOEMxQTE2RDJGQTdCMDAyRkY0REIgLyogTG9hZFBhZ2VPbkNy YXNoLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUI0MDM5RjlEMTVFNkQ4QjMwMDcyNTVENiAvKiBN YXRoRXh0cmFzLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUNENTQ5N0I0MTU4NTdGMEMwMEI1QkMz MCAvKiBNZWRpYVRpbWUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJRTEyMjBEQTAxNTVCMjU0ODAw MTNFMkZDIC8qIE1lbW9yeUNhY2hlRGlzYWJsZVdpdGhpblJlc291cmNlTG9hZERlbGVnYXRlLm1t IGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDIvTG9hZFBhZ2VPbkNyYXNoLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2Vi S2l0Mi9Mb2FkUGFnZU9uQ3Jhc2guY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmYzZDE4MzBkNjg4MDU0MzAxMTA2 ZTVkZjQyN2ViMzg1ZTVkYzAyM2MKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9UZXN0V2ViS2l0 QVBJL1Rlc3RzL1dlYktpdDIvTG9hZFBhZ2VPbkNyYXNoLmNwcApAQCAtMCwwICsxLDEwMiBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxMyBBZGVuaWxzb24gQ2F2YWxjYW50aSA8Y2F2YWxjYW50 aWlAZ21haWwuY29tPgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0 OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkg RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUg Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlks IE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9T UyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAi UGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVdlYlZpZXcuaCIKKyNpbmNs dWRlICJUZXN0LmgiCisjaW5jbHVkZSA8V2ViS2l0Mi9XS1JldGFpblB0ci5oPgorCituYW1lc3Bh Y2UgVGVzdFdlYktpdEFQSSB7CisKK3N0YXRpYyB2b2lkIGRpZEZpbmlzaExvYWQoV0tQYWdlUmVm LCBXS0ZyYW1lUmVmLCBXS1R5cGVSZWYsIGNvbnN0IHZvaWQqKTsKKworY2xhc3MgV2ViS2l0MkNy YXNoTG9hZGVyIHsKK3B1YmxpYzoKKyAgICBXZWJLaXQyQ3Jhc2hMb2FkZXIoKQorICAgICAgICA6 IGNvbnRleHQoQWRvcHRXSywgV0tDb250ZXh0Q3JlYXRlKCkpCisgICAgICAgICwgd2ViVmlldyhj b250ZXh0LmdldCgpKQorICAgICAgICAsIHVybChhZG9wdFdLKFdLVVJMQ3JlYXRlV2l0aFVURjhD U3RyaW5nKCJhYm91dDpibGFuayIpKSkKKyAgICAgICAgLCBmaXJzdFN1Y2Nlc3NmdWxMb2FkKGZh bHNlKQorICAgICAgICAsIHNlY29uZFN1Y2Nlc3NmdWxMb2FkKGZhbHNlKQorICAgIHsKKyAgICAg ICAgbWVtc2V0KCZsb2FkZXJDbGllbnQsIDAsIHNpemVvZihsb2FkZXJDbGllbnQpKTsKKyAgICAg ICAgbG9hZGVyQ2xpZW50LmNsaWVudEluZm8gPSB0aGlzOworICAgICAgICBsb2FkZXJDbGllbnQu ZGlkRmluaXNoTG9hZEZvckZyYW1lID0gZGlkRmluaXNoTG9hZDsKKyAgICAgICAgV0tQYWdlU2V0 UGFnZUxvYWRlckNsaWVudCh3ZWJWaWV3LnBhZ2UoKSwgJmxvYWRlckNsaWVudCk7CisgICAgfQor CisgICAgdm9pZCBsb2FkVXJsKCkKKyAgICB7CisgICAgICAgIFdLUGFnZUxvYWRVUkwod2ViVmll dy5wYWdlKCksIHVybC5nZXQoKSk7CisgICAgfQorCisgICAgdm9pZCB0ZXJtaW5hdGVXZWJQcm9j ZXNzKCkKKyAgICB7CisgICAgICAgIFdLUGFnZVRlcm1pbmF0ZSh3ZWJWaWV3LnBhZ2UoKSk7Cisg ICAgfQorCisgICAgV0tSZXRhaW5QdHI8V0tDb250ZXh0UmVmPiBjb250ZXh0OworICAgIFdLUGFn ZUxvYWRlckNsaWVudCBsb2FkZXJDbGllbnQ7CisgICAgUGxhdGZvcm1XZWJWaWV3IHdlYlZpZXc7 CisgICAgV0tSZXRhaW5QdHI8V0tVUkxSZWY+IHVybDsKKworICAgIGJvb2wgZmlyc3RTdWNjZXNz ZnVsTG9hZDsKKyAgICBib29sIHNlY29uZFN1Y2Nlc3NmdWxMb2FkOworfTsKKworLy8gV2UgYXJl IGdvaW5nIHRvIGhhdmUgMiBsb2FkIGV2ZW50cyBpbnRlcnR3aW5lZCBieSBhIHNpbXVsYXRlZCBj cmFzaAorLy8gKGkuZS4gTG9hZCAtPiBDcmFzaCAtPiBMb2FkKS4KK3ZvaWQgZGlkRmluaXNoTG9h ZChXS1BhZ2VSZWYgcGFnZSwgV0tGcmFtZVJlZiBmcmFtZSwgV0tUeXBlUmVmIHVzZXJEYXRhLCBj b25zdCB2b2lkKiBjbGllbnRJbmZvKQoreworICAgIFdlYktpdDJDcmFzaExvYWRlciogdGVzdEhl bHBlciA9IGNvbnN0X2Nhc3Q8V2ViS2l0MkNyYXNoTG9hZGVyKj4oc3RhdGljX2Nhc3Q8Y29uc3Qg V2ViS2l0MkNyYXNoTG9hZGVyKj4oY2xpZW50SW5mbykpOworCisgICAgLy8gRmlyc3QgbG9hZCB3 b3JrZWQsIGxldCdzIGNyYXNoIFdlYlByb2Nlc3MuCisgICAgaWYgKCF0ZXN0SGVscGVyLT5maXJz dFN1Y2Nlc3NmdWxMb2FkKSB7CisgICAgICAgIHRlc3RIZWxwZXItPmZpcnN0U3VjY2Vzc2Z1bExv YWQgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgLy8gU2Vjb25kIGxvYWQg d29ya2VkLCB3ZSBhcmUgZG9uZS4KKyAgICBFWFBFQ1RfVFJVRSh0ZXN0SGVscGVyLT5maXJzdFN1 Y2Nlc3NmdWxMb2FkKTsKKyAgICBpZiAoIXRlc3RIZWxwZXItPnNlY29uZFN1Y2Nlc3NmdWxMb2Fk KSB7CisgICAgICAgIHRlc3RIZWxwZXItPnNlY29uZFN1Y2Nlc3NmdWxMb2FkID0gdHJ1ZTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KK30KKworLy8gVGhpcyB0ZXN0IHdpbGwgbG9hZCBhIGJsYW5r IHBhZ2UgYW5kIG5leHQga2lsbCBXZWJQcm9jZXNzLCB0aGUgZXhwZWN0ZWQKKy8vIHJlc3VsdCBp cyB0aGF0IGEgY2FsbCB0byBwYWdlIGxvYWQgc2hvdWxkIHNwYXduIGEgbmV3IFdlYlByb2Nlc3Mu CitURVNUKFdlYktpdDIsIExvYWRQYWdlQWZ0ZXJDcmFzaCkKK3sKKyAgICBXZWJLaXQyQ3Jhc2hM b2FkZXIgaGVscGVyOworICAgIGhlbHBlci5sb2FkVXJsKCk7CisgICAgVXRpbDo6cnVuKCZoZWxw ZXIuZmlyc3RTdWNjZXNzZnVsTG9hZCk7CisgICAgaGVscGVyLnRlcm1pbmF0ZVdlYlByb2Nlc3Mo KTsKKyAgICBoZWxwZXIubG9hZFVybCgpOworICAgIFV0aWw6OnJ1bigmaGVscGVyLnNlY29uZFN1 Y2Nlc3NmdWxMb2FkKTsKK30KKworfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQpkaWZmIC0t Z2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL01vdXNlTW92ZUFmdGVyQ3Jh c2guY3BwIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL01vdXNlTW92ZUFmdGVy Q3Jhc2guY3BwCmluZGV4IDliNDcwNTE1MTI3MjUyYjA1OWE4OTVlZTY1NDFmMzJhYTZjMTBlN2Iu LjRiZjU1MjdmOTVhY2RmYTQxODNiYTk1MzBmNzk4ZjY4OWVlMmVlZGYgMTAwNjQ0Ci0tLSBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9Nb3VzZU1vdmVBZnRlckNyYXNoLmNwcAor KysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvTW91c2VNb3ZlQWZ0ZXJDcmFz aC5jcHAKQEAgLTM3LDExICszNyw2IEBAIHN0YXRpYyB2b2lkIGRpZEZpbmlzaExvYWRGb3JGcmFt ZShXS1BhZ2VSZWYsIFdLRnJhbWVSZWYsIFdLVHlwZVJlZiwgY29uc3Qgdm9pZCopCiAgICAgZGlk RmluaXNoTG9hZCA9IHRydWU7CiB9CiAKLXN0YXRpYyB2b2lkIHByb2Nlc3NEaWRDcmFzaChXS1Bh Z2VSZWYgcGFnZSwgY29uc3Qgdm9pZCopCi17Ci0gICAgV0tQYWdlUmVsb2FkKHBhZ2UpOwotfQot CiBzdGF0aWMgdm9pZCBzZXRQYWdlTG9hZGVyQ2xpZW50KFdLUGFnZVJlZiBwYWdlKQogewogICAg IFdLUGFnZUxvYWRlckNsaWVudCBsb2FkZXJDbGllbnQ7CkBAIC00OSw3ICs0NCw2IEBAIHN0YXRp YyB2b2lkIHNldFBhZ2VMb2FkZXJDbGllbnQoV0tQYWdlUmVmIHBhZ2UpCiAgICAgbG9hZGVyQ2xp ZW50LnZlcnNpb24gPSAwOwogICAgIGxvYWRlckNsaWVudC5jbGllbnRJbmZvID0gMDsKICAgICBs b2FkZXJDbGllbnQuZGlkRmluaXNoTG9hZEZvckZyYW1lID0gZGlkRmluaXNoTG9hZEZvckZyYW1l OwotICAgIGxvYWRlckNsaWVudC5wcm9jZXNzRGlkQ3Jhc2ggPSBwcm9jZXNzRGlkQ3Jhc2g7CiAK ICAgICBXS1BhZ2VTZXRQYWdlTG9hZGVyQ2xpZW50KHBhZ2UsICZsb2FkZXJDbGllbnQpOwogfQpA QCAtNzksMTEgKzczLDExIEBAIFRFU1QoV2ViS2l0MiwgTW91c2VNb3ZlQWZ0ZXJDcmFzaCkKICAg ICB3ZWJWaWV3LnNpbXVsYXRlTW91c2VNb3ZlKDEwLCAxMCk7CiAgICAgd2ViVmlldy5zaW11bGF0 ZU1vdXNlTW92ZSgyMCwgMjApOwogCi0gICAgLy8gQWZ0ZXIgbW92aW5nIHRoZSBtb3VzZSAod2hp bGUgdGhlIHdlYiBwcm9jZXNzIHdhcyBodW5nIG9uIHRoZSBQYXVzZSBtZXNzYWdlKSwga2lsbCB0 aGUgd2ViIHByb2Nlc3MuIEl0IGlzIHJlc3RhcnRlZCBpbgotICAgIC8vIHByb2Nlc3NEaWRDcmFz aCBieSByZWxvYWRpbmcgdGhlIHBhZ2UuCisgICAgLy8gQWZ0ZXIgbW92aW5nIHRoZSBtb3VzZSAo d2hpbGUgdGhlIHdlYiBwcm9jZXNzIHdhcyBodW5nIG9uIHRoZSBQYXVzZSBtZXNzYWdlKSwga2ls bCB0aGUgd2ViIHByb2Nlc3MuIEl0IGlzIHJlc3RhcnRlZCBieSByZWxvYWRpbmcgdGhlIHBhZ2Uu CiAgICAgV0tQYWdlVGVybWluYXRlKHdlYlZpZXcucGFnZSgpKTsKKyAgICBXS1BhZ2VSZWxvYWQo d2ViVmlldy5wYWdlKCkpOwogCi0gICAgLy8gV2FpdCB1bnRpbCB3ZSBsb2FkIHRoZSBwYWdlIGEg c2Vjb25kIHRpbWUgKHZpYSByZWxvYWRpbmcgdGhlIHBhZ2UgaW4gcHJvY2Vzc0RpZENyYXNoKS4K KyAgICAvLyBXYWl0IHVudGlsIHdlIGxvYWQgdGhlIHBhZ2UgYSBzZWNvbmQgdGltZS4KICAgICBV dGlsOjpydW4oJmRpZEZpbmlzaExvYWQpOwogCiAgICAgRVhQRUNUX0pTX0ZBTFNFKHdlYlZpZXcu cGFnZSgpLCAiZGlkTW92ZU1vdXNlKCkiKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRB UEkvVGVzdHMvV2ViS2l0Mi9XZWJLaXQyLnBybyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mi9XZWJLaXQyLnBybwppbmRleCA5NDUyYTVhZDgxMGIyZjBkODI1ZmMxOGY5OGFmMDU3 Zjg4MWE4Y2NmLi4xZDA2Mzc5Y2ZhZDliYmVmOWU4ZDg5YTVlMTQwOGU1N2IxMjFhYzdmIDEwMDY0 NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvV2ViS2l0Mi5wcm8KKysr IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1dlYktpdDIucHJvCkBAIC0xOSw2 ICsxOSw3IEBAIFNPVVJDRVMgKz0gXAogICAgIEluamVjdGVkQnVuZGxlSW5pdGlhbGl6YXRpb25V c2VyRGF0YUNhbGxiYWNrV2lucy5jcHAgXAogICAgIExvYWRBbHRlcm5hdGVIVE1MU3RyaW5nV2l0 aE5vbkRpcmVjdG9yeVVSTC5jcHAgXAogICAgIExvYWRDYW5jZWxlZE5vU2VydmVyUmVkaXJlY3RD YWxsYmFjay5jcHAgXAorICAgIExvYWRQYWdlT25DcmFzaC5jcHAgXAogICAgIE1vdXNlTW92ZUFm dGVyQ3Jhc2guY3BwIFwKICAgICBQYWdlTG9hZEJhc2ljLmNwcCBcCiAgICAgUGFnZUxvYWREaWRD aGFuZ2VMb2NhdGlvbldpdGhpblBhZ2VGb3JGcmFtZS5jcHAgXAo=