53361 2011-01-28 20:24:07 -0800 autorelease pools accumulate memory during automatic testing on Webkit2 2011-02-02 18:03:54 -0800 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) Mac OS X 10.6 RESOLVED FIXED InRadar P2 Normal --- 1 slewis webkit-unassigned andersca ap aroben ggaren slewis webkit-ews oldest_to_newest 341972 0 80539 slewis 2011-01-28 20:24:07 -0800 Created attachment 80539 patch <rdar://problem/8921729> REGRESSION: Membuster accumulates 1GB+ memory due to autorelease pools not being drained. Add observers to push and pop autorelease pools on entry and exit from the main CFRunLoop. This will prevent memory from accumulating. 341989 1 80539 ap 2011-01-28 22:16:15 -0800 Comment on attachment 80539 patch View in context: https://bugs.webkit.org/attachment.cgi?id=80539&action=review Looks good. I have many style nitpicks though, seems worth another quick review round. > Source/WebKit2/Platform/RunLoop.h:33 > #include <wtf/PassOwnPtr.h> PLease fix alphabetic sorting. > Source/WebKit2/Platform/RunLoop.h:143 > + RetainPtr<CFRunLoopObserverRef> m_CurrentRunLoopEnterObserverRef; > + RetainPtr<CFRunLoopObserverRef> m_CurrentRunLoopExitObserverRef; WebKit style is m_currentRunLoopEnter/ExitObserver (lower case first letter, and there is no need for "Ref" suffix. > Source/WebKit2/Platform/mac/RunLoopMac.mm:30 > +#define WRAP_RUN_LOOP_WITH_AUTORELEASE_POOLS_OBSERVER_ORDER 1000000 We prefer consts to macros. > Source/WebKit2/Platform/mac/RunLoopMac.mm:36 > + switch (activity) { > + case kCFRunLoopEntry: We don't indent case statements. > Source/WebKit2/Platform/mac/RunLoopMac.mm:43 > + const NSAutoreleasePool* pool = static_cast<const NSAutoreleasePool*>(CFArrayGetValueAtIndex(autoreleasePoolStack, count-1)); Please also use const_cast to remove the const. There should be a space around "-" in count-1. > Source/WebKit2/Platform/mac/RunLoopMac.mm:45 > + CFArrayRemoveValueAtIndex(autoreleasePoolStack, count-1); There should be a space around "-" in count-1. > Source/WebKit2/Platform/mac/RunLoopMac.mm:118 > +// Set up an Autorelease Pool on the main RunLoop > +// FIXME: remove when <rdar://problem/8929426> is fixed. > +void RunLoop::installAutoreleasePoolsOnCurrentRunLoop() Does this function work on the main, or on current run loop? Please bring comments and function name in sync. > Source/WebKit2/Platform/mac/RunLoopMac.mm:123 > + CFRunLoopObserverRef newRunLoopEnterObserverRef = 0; Please don't use local CF objects without RetainPtr. I think that here, you could just assign to m_currentRunLoopEnterObserver immediately. > Source/WebKit2/Platform/mac/RunLoopMac.mm:125 > + CFRunLoopObserverRef newRunLoopExitObserverRef = 0; Ditto. > Source/WebKit2/Platform/mac/RunLoopMac.mm:131 > + newRunLoopEnterObserverContext.info = CFArrayCreateMutable(kCFAllocatorSystemDefault /* Don't retain the autorelease pool tokens. */,0,0); > + newRunLoopEnterObserverContext.retain = CFRetain; // retain the array > + newRunLoopEnterObserverContext.release = CFRelease; // release the array when the context info goes away. > + newRunLoopEnterObserverContext.copyDescription = CFCopyDescription; Please don't align "=" signs or comments. There should be spaces in ",0,0". > Source/WebKit2/Platform/mac/RunLoopMac.mm:134 > + // Install a repeating observer to fire on exit of the current run loop with an very late ordering like kWrapRunLoopWithAutoreleasePoolObserverOrder. CFRunLoop gives lowest priority to those observers close to positive infinity. We don't put two spaces between sentences. > Source/WebKit2/Platform/mac/RunLoopMac.mm:138 > + newRunLoopExitObserverContext.version = 0; > + newRunLoopExitObserverContext.info = newRunLoopEnterObserverContext.info; > + newRunLoopExitObserverContext.retain = CFRetain; // retain the array > + newRunLoopExitObserverContext.release = CFRelease; // release the array when the context info goes away. Please don't align. > Source/WebKit2/Platform/mac/RunLoopMac.mm:142 > + CFRelease((CFMutableArrayRef)newRunLoopEnterObserverContext.info); // owned by the observer. (only one release is needed since Enter/Exit point to the same instance). One space before "//". Please fix grammar in the comment, too. I would have put newRunLoopEnterObserverContext.info into a local RetainPtr variable to avoid the need for explicit CFRelease. 341990 2 ap 2011-01-28 22:17:15 -0800 Dave, do you know why the style bot had no comments? 341991 3 webkit-ews 2011-01-28 22:19:23 -0800 Attachment 80539 did not build on qt: Build output: http://queues.webkit.org/results/7597447 342574 4 80539 aroben 2011-01-31 07:50:51 -0800 Comment on attachment 80539 patch View in context: https://bugs.webkit.org/attachment.cgi?id=80539&action=review > Source/WebKit2/Platform/mac/RunLoopMac.mm:61 > + installAutoreleasePoolsOnCurrentRunLoop(); I'm surprised that this is needed or helpful. RunLoop::run claims that -[NSRunLoop run] (and, presumably, +[NSApplication run]) will take care of setting up an autorelease pool. Is that not true? 342692 5 slewis 2011-01-31 11:15:58 -0800 AppKit creates Autorelease pools at the beginning and end of the user event loop. When testing Membuster, stress test, etc. there are no user events so the top pool isn't getting drained. 342933 6 80703 slewis 2011-01-31 17:31:26 -0800 Created attachment 80703 new patch 343004 7 80703 ap 2011-01-31 20:48:54 -0800 Comment on attachment 80703 new patch View in context: https://bugs.webkit.org/attachment.cgi?id=80703&action=review > AppKit creates Autorelease pools at the beginning and end of the user event loop. When testing Membuster, stress test, etc. there are no user events so the top pool isn't getting drained. Should we switch to CFRunLoop now that this more powerful mechanism is used? > Source/WebKit2/Platform/mac/RunLoopMac.mm:43 > + NSAutoreleasePool* pool = const_cast<NSAutoreleasePool*>(static_cast<const NSAutoreleasePool*>(CFArrayGetValueAtIndex(autoreleasePoolStack, count - 1))); Misplaced star - should be "NSAutoreleasePool *" in all three cases. > Source/WebKit2/Platform/mac/RunLoopMac.mm:45 > + CFArrayRemoveValueAtIndex(autoreleasePoolStack, count-1); There should be spaces around "-". > Source/WebKit2/Platform/mac/RunLoopMac.mm:124 > + RetainPtr<CFMutableArrayRef> autoreleasePoolStack = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, 0); // Use system Allocator to avoid retaining the autorelease pool tokens; I don't understand this comment. It's the last parameter (null callbacks) that avoids retaining array items, so what's the importance of using kCFAllocatorSystemDefault? Also, it's grammatically incorrect ("Allocator" and a semicolon at the end). > Source/WebKit2/Platform/mac/RunLoopMac.mm:126 > + // Install a repeating observer to fire on entry to the run current run loop with a early ordering like -wrapRunLoopWithAutoreleasePoolsOrder. CFRunLoop gives highest priority to those observers close to minus infinity. Please don't use two spaces between sentences. > Source/WebKit2/Platform/mac/RunLoopMac.mm:144 > + autoreleasePoolStack.clear(); // owned by the observer. No need for this line - it's the same as RetainPtr destruction. 343005 8 ap 2011-01-31 20:50:45 -0800 In fact, can't we fix this by simply calling NSApplicationLoad() some time early in WebProcessMain() (before NSApp is initialized)? That way, you can avoid adding custom code. 343258 9 80703 darin 2011-02-01 09:20:46 -0800 Comment on attachment 80703 new patch View in context: https://bugs.webkit.org/attachment.cgi?id=80703&action=review > Source/WebKit2/Platform/mac/RunLoopMac.mm:30 > +static const int wrapRunLoopWithAutoreleasePoolsPriority = 1000000; Alexey has pointed out to me many times that we can just use "const int" for such things, because these constants have internal linkage even if you don’t specify static. So now I point it out to you. The type of this constant should be CFIndex, not int. We need a comment here explaining why this is a good value to use for priority. > Source/WebKit2/Platform/mac/RunLoopMac.mm:50 > + default: > + break; Can you leave this out? What good does the default here do? > Source/WebKit2/Platform/mac/RunLoopMac.mm:121 > + if (!m_currentRunLoopEnterObserver) { We prefer early return to nesting the entire function inside an if. So this should just say: if (m_currentRunLoopEnterObserver) { ASSERT(m_currentRunLoopExitObserver); return; } And then the rest of the function should not be nested. >> Source/WebKit2/Platform/mac/RunLoopMac.mm:126 >> + // Install a repeating observer to fire on entry to the run current run loop with a early ordering like -wrapRunLoopWithAutoreleasePoolsOrder. CFRunLoop gives highest priority to those observers close to minus infinity. > > Please don't use two spaces between sentences. It would be clearer to have two priority constants, one for enter and one for exit, rather than using a single constant, sometimes with a minus sign. > Source/WebKit2/Platform/mac/RunLoopMac.mm:148 > +void RunLoop::uninstallAutoreleasePoolsOnCurrentRunLoop(void) No need for the (void) here. That’s a plain C idiom, and never needs to be used in C++. Just () works. > Source/WebKit2/Platform/mac/RunLoopMac.mm:153 > + if (m_currentRunLoopEnterObserver) > + m_currentRunLoopEnterObserver.clear(); > + if (m_currentRunLoopExitObserver) > + m_currentRunLoopExitObserver.clear(); The best style here would be: m_currentRunLoopEnterObserver = nullptr; m_currentRunLoopExitObserver = nullptr; There is no need to check for null before calling clear(), since it does so already, and assignment to nullptr is preferred over calls to clear(). This function is named “uninstall” but the code here simply releases the observers, and does not remove them from the run loop. I expect that won’t work correctly. I believe we need calls to CFRunLoopRemoveObserver here. 343335 10 levin 2011-02-01 10:40:01 -0800 (In reply to comment #2) > Dave, do you know why the style bot had no comments? It looks like the style checker doesn't check .mm or .m files. It looks has been true since before r53675 (Jan 2010) -- I stopped trying to backtrace further at that point. To get this to happen, one should modify Tools/Scripts/webkitpy/style/checker.py and perhaps expand _CPP_FILE_EXTENSIONS to have the extensions mm and m (or add a new variable for this). Before such a change is checked in, one should run the style checker on the checked in mm/m files and see how many false positives it gives. For checks that are wrong/gave false positives for Objective C, one could add "file_state.is_objective_c()" checks to disable the check in Tools/Scripts/webkitpy/style/checkers/cpp.py I'm willing to generously advise anyone who would like to take this on. 343812 11 80883 slewis 2011-02-01 20:49:27 -0800 Created attachment 80883 patch 343826 12 80883 ap 2011-02-01 21:20:56 -0800 Comment on attachment 80883 patch View in context: https://bugs.webkit.org/attachment.cgi?id=80883&action=review > Source/WebKit2/Platform/mac/RunLoopMac.mm:31 > +@interface NSApplication (PeekAtAppKitSecrets) Please rename the category to WebNSApplicationDetails. > Source/WebKit2/Platform/mac/RunLoopMac.mm:45 > RunLoop::RunLoop() > { > + // Installs autorelease pools on the current CFRunLoop which prevents memory from accumulating between user events. > + // FIXME: Remove when <rdar://problem/8929426> is fixed. > + [[NSApplication sharedApplication] _installAutoreleasePoolsOnCurrentThreadIfNecessary]; Do we want this on non-main run loops? What are the other WebKit2 run loops, in fact? 344064 13 ggaren 2011-02-02 11:03:23 -0800 > > + [[NSApplication sharedApplication] _installAutoreleasePoolsOnCurrentThreadIfNecessary]; > > Do we want this on non-main run loops? What are the other WebKit2 run loops, in fact? There's one run loop per thread. So, the question is, do we want this behavior for worker threads, and possibly database and icon database threads, too? I think we probably do, since those threads are even more likely to receive callbacks from other libraries without an explicit user event. 344078 14 ap 2011-02-02 11:21:32 -0800 We've intentionally left worker threads without global autorelease pools at all, as that helped catch running main thread only code that got accidentally executed in a worker thread. 344107 15 ggaren 2011-02-02 12:00:36 -0800 (In reply to comment #14) > We've intentionally left worker threads without global autorelease pools at all, as that helped catch running main thread only code that got accidentally executed in a worker thread. Seems like a very strange and roundabout way to detect a threading error. There's no guarantee that temporary autorelease pools won't defeat this roundabout assertion technique. And a "no autorelease pool in place" message is a very unclear way to say "you shouldn't have run this code on a non-main thread." If running main-thread-only code on worker threads has been a problem in the past, a more direct and reliable solution is to add ASSERT(isMainThread()) to common choke points. 344167 16 slewis 2011-02-02 13:17:46 -0800 I don't know about workers or databases, but Anders said I shouldn't limit this to the main thread because we want it to work when WebKit2 is running in threaded mode. 344186 17 ap 2011-02-02 13:30:44 -0800 > Seems like a very strange and roundabout way It's strange and roundabout, but it helped us detect real problems, see bug 40655. Do you have a better suggestion? We shouldn't be adding autorelease pools to threads that should never run any Objective C. But I'm not sure why we are discussing worker, database and icon database threads. These aren't using WebKit2 RunLoop code, as far as I know. What is using it, besides the vaporware threaded mode? Should this class be renamed to not look more general than it is, or should we be calling -_installAutoreleasePoolsOnCurrentThreadIfNecessary in some other code? 344300 18 ggaren 2011-02-02 15:12:41 -0800 > It's strange and roundabout, but it helped us detect real problems, see bug 40655. Do you have a better suggestion? Yes. Put a real ASSERT in a reasonable choke point. For bugs like 40655 (messaging a delegate on a non-main thread), a reasonable choke point is any place in WebKit1 matching the regexp .*Client::dispatch.*. Such an ASSERT already seems to exist for WebKit2: // We only allow sending sync messages from the client run loop. ASSERT(RunLoop::current() == m_clientRunLoop); > We shouldn't be adding autorelease pools to threads that should never run any Objective C. There is no such thing as a thread that should never run any Objective-C. But if you believe there is such a thing, you can try adding an ASSERT to WTF::String::operator NSString*, and/or HardAutorelease. For what it's worth, that ASSERT would have fired in the case of bug 40655. Personally, I think it is irrational to assume that just because an accident helped identify one bug, we should keep committing the same accident. That seems like a recipe for paralysis in software development. > But I'm not sure why we are discussing worker, database and icon database threads. These aren't using WebKit2 RunLoop code, as far as I know. What is using it, besides the vaporware threaded mode? Threaded mode is not vaporware. It exists today, and Anders asked Stephanie to keep it working. > Should this class be renamed to not look more general than it is, or should we be calling -_installAutoreleasePoolsOnCurrentThreadIfNecessary in some other code? If you want to rename RunLoop, please talk to Anders and Sam. Personally, I don't think it's a good idea to name a class after its current set of clients -- then you have to rename it every time it acquires a new client! Anyway, this is pretty far afield from the question at hand, which is, does this patch solve the problem of gigabytes of memory leaking in Safari? I think it does, so I'm inclined to say r+, with the caveat of the WebNSApplicationDetails rename you suggested. 344302 19 80883 ggaren 2011-02-02 15:15:40 -0800 Comment on attachment 80883 patch r=me, but please rename your category to WebNSApplicationDetails like Alexey suggested. 344408 20 ap 2011-02-02 16:47:02 -0800 We talked about this more, and the current thinking is that -_installAutoreleasePoolsOnCurrentThreadIfNecessary class should not be added to RunLoop, but to code that calls RunLoop. 344454 21 81014 slewis 2011-02-02 17:47:53 -0800 Created attachment 81014 patch moving code to WebProcessMain 344459 22 81014 ggaren 2011-02-02 17:54:36 -0800 Comment on attachment 81014 patch moving code to WebProcessMain r=me 344466 23 slewis 2011-02-02 18:03:54 -0800 Committed http://trac.webkit.org/projects/webkit/changeset/77452 80539 2011-01-28 20:24:07 -0800 2011-01-31 17:31:26 -0800 patch AutoreleasePatch.txt text/plain 7461 slewis SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDc2OTg5KQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDEtMjggIFN0ZXBoYW5p ZSBMZXdpcyAgPHNsZXdpc0BhcHBsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQWxleGV5 IFByb3NrdXJ5YWtvdi4KKworICAgICAgICA8cmRhcjovL3Byb2JsZW0vODkyMTcyOT4gUkVHUkVT U0lPTjogTWVtYnVzdGVyIGFjY3VtdWxhdGVzIDFHQisgbWVtb3J5IGR1ZSB0byBhdXRvcmVsZWFz ZSBwb29scyBub3QgYmVpbmcgZHJhaW5lZC4KKyAgICAgICAgQWRkIG9ic2VydmVycyB0byBwdXNo IGFuZCBwb3AgYXV0b3JlbGVhc2UgcG9vbHMgb24gZW50cnkgYW5kIGV4aXQgZnJvbSB0aGUgbWFp biBDRlJ1bkxvb3AuICAKKyAgICAgICAgVGhpcyB3aWxsIHByZXZlbnQgbWVtb3J5IGZyb20gYWNj dW11bGF0aW5nLgorCisgICAgICAgICogUGxhdGZvcm0vUnVuTG9vcC5oOgorICAgICAgICAqIFBs YXRmb3JtL21hYy9SdW5Mb29wTWFjLm1tOgorICAgICAgICAod3JhcFJ1bkxvb3BXaXRoQXV0b3Jl bGVhc2VQb29sSGFuZGxlcik6CisgICAgICAgIChSdW5Mb29wOjpSdW5Mb29wKToKKyAgICAgICAg KFJ1bkxvb3A6On5SdW5Mb29wKToKKyAgICAgICAgKFJ1bkxvb3A6Omluc3RhbGxBdXRvcmVsZWFz ZVBvb2xzT25NYWluUnVuTG9vcCk6CisgICAgICAgIChSdW5Mb29wOjp1bmluc3RhbGxBdXRvcmVs ZWFzZVBvb2xzT25NYWluUnVuTG9vcCk6CisKIDIwMTEtMDEtMjggIFN0ZXBoYW5pZSBMZXdpcyAg PHNsZXdpc0BhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgR2VvZmYgR2FyZW4uCklu ZGV4OiBTb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybS9SdW5Mb29wLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291 cmNlL1dlYktpdDIvUGxhdGZvcm0vUnVuTG9vcC5oCShyZXZpc2lvbiA3Njk4NikKKysrIFNvdXJj ZS9XZWJLaXQyL1BsYXRmb3JtL1J1bkxvb3AuaAkod29ya2luZyBjb3B5KQpAQCAtMjksNiArMjks NyBAQAogI2RlZmluZSBSdW5Mb29wX2gKIAogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5j bHVkZSA8d3RmL1JldGFpblB0ci5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CiAjaW5j bHVkZSA8d3RmL1RocmVhZFNwZWNpZmljLmg+CiAjaW5jbHVkZSA8d3RmL1RocmVhZGluZy5oPgpA QCAtMTM0LDggKzEzNSwxMiBAQCBwcml2YXRlOgogICAgIFRpbWVyTWFwIG1fYWN0aXZlVGltZXJz OwogI2VsaWYgUExBVEZPUk0oTUFDKQogICAgIHN0YXRpYyB2b2lkIHBlcmZvcm1Xb3JrKHZvaWQq KTsKKyAgICB2b2lkIGluc3RhbGxBdXRvcmVsZWFzZVBvb2xzT25DdXJyZW50UnVuTG9vcCgpOwor ICAgIHZvaWQgdW5pbnN0YWxsQXV0b3JlbGVhc2VQb29sc09uQ3VycmVudFJ1bkxvb3AoKTsKICAg ICBDRlJ1bkxvb3BSZWYgbV9ydW5Mb29wOwogICAgIENGUnVuTG9vcFNvdXJjZVJlZiBtX3J1bkxv b3BTb3VyY2U7CisgICAgUmV0YWluUHRyPENGUnVuTG9vcE9ic2VydmVyUmVmPiBtX0N1cnJlbnRS dW5Mb29wRW50ZXJPYnNlcnZlclJlZjsKKyAgICBSZXRhaW5QdHI8Q0ZSdW5Mb29wT2JzZXJ2ZXJS ZWY+IG1fQ3VycmVudFJ1bkxvb3BFeGl0T2JzZXJ2ZXJSZWY7CiAjZWxpZiBQTEFURk9STShRVCkK ICAgICB0eXBlZGVmIEhhc2hNYXA8aW50LCBUaW1lckJhc2UqPiBUaW1lck1hcDsKICAgICBUaW1l ck1hcCBtX2FjdGl2ZVRpbWVyczsKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1BsYXRmb3JtL21hYy9S dW5Mb29wTWFjLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1BsYXRmb3JtL21hYy9S dW5Mb29wTWFjLm1tCShyZXZpc2lvbiA3Njk4NikKKysrIFNvdXJjZS9XZWJLaXQyL1BsYXRmb3Jt L21hYy9SdW5Mb29wTWFjLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0yNyw2ICsyNywzMCBAQAogCiAj aW1wb3J0ICJXb3JrSXRlbS5oIgogCisjZGVmaW5lIFdSQVBfUlVOX0xPT1BfV0lUSF9BVVRPUkVM RUFTRV9QT09MU19PQlNFUlZFUl9PUkRFUiAxMDAwMDAwCisKK3N0YXRpYyB2b2lkIHdyYXBSdW5M b29wV2l0aEF1dG9yZWxlYXNlUG9vbEhhbmRsZXIoQ0ZSdW5Mb29wT2JzZXJ2ZXJSZWYgb2JzZXJ2 ZXIsIENGUnVuTG9vcEFjdGl2aXR5IGFjdGl2aXR5LCB2b2lkKiBjb250ZXh0RGF0YSkgCit7Cisg ICAgQ0ZNdXRhYmxlQXJyYXlSZWYgYXV0b3JlbGVhc2VQb29sU3RhY2sgPSBzdGF0aWNfY2FzdDxD Rk11dGFibGVBcnJheVJlZj4oY29udGV4dERhdGEpOworICAgIHN3aXRjaCAoYWN0aXZpdHkpIHsK KyAgICAgICAgY2FzZSBrQ0ZSdW5Mb29wRW50cnk6CisgICAgICAgICAgICBDRkFycmF5QXBwZW5k VmFsdWUoYXV0b3JlbGVhc2VQb29sU3RhY2ssIFtbTlNBdXRvcmVsZWFzZVBvb2wgYWxsb2NdIGlu aXRdKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIGtDRlJ1bkxvb3BFeGl0OiB7 CisgICAgICAgICAgICBDRkluZGV4IGNvdW50ID0gQ0ZBcnJheUdldENvdW50KGF1dG9yZWxlYXNl UG9vbFN0YWNrKTsKKyAgICAgICAgICAgIC8vIEl0IGlzIHBvc3NpYmxlIGZvciB0aGVyZSB0byBi ZSBubyBhdXRvcmVsZWFzZVBvb2wgb24gdGhlIHN0YWNrIGlmIHRoaXMgaGFuZGxlciB3YXMgaW5z dGFsbGVkIHdoaWxlIHdpdGhpbiBDRlJ1bkxvb3BSdW4sIGJlY2F1c2Ugd2UnbGwgZ2V0IGEga0NG UnVuTG9vcEV4aXQgYmVmb3JlIHRoZSBuZXh0IGtDRlJ1bkxvb3BFbnRyeS4gIAorICAgICAgICAg ICAgaWYgKGNvdW50ID4gMCkgeworICAgICAgICAgICAgICAgIGNvbnN0IE5TQXV0b3JlbGVhc2VQ b29sKiBwb29sID0gc3RhdGljX2Nhc3Q8Y29uc3QgTlNBdXRvcmVsZWFzZVBvb2wqPihDRkFycmF5 R2V0VmFsdWVBdEluZGV4KGF1dG9yZWxlYXNlUG9vbFN0YWNrLCBjb3VudC0xKSk7CisgICAgICAg ICAgICAgICAgW3Bvb2wgZHJhaW5dOworICAgICAgICAgICAgICAgIENGQXJyYXlSZW1vdmVWYWx1 ZUF0SW5kZXgoYXV0b3JlbGVhc2VQb29sU3RhY2ssIGNvdW50LTEpOworICAgICAgICAgICAgfQor ICAgICAgICB9CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAg ICAgIGJyZWFrOworICAgIH0KK30KKwogdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayh2b2lkKiBj b250ZXh0KQogewogICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihjb250ZXh0KS0+cGVyZm9ybVdv cmsoKTsKQEAgLTM0LDYgKzU4LDggQEAgdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayh2b2lkKiBj b250ZXh0KQogCiBSdW5Mb29wOjpSdW5Mb29wKCkKIHsKKyAgICBpbnN0YWxsQXV0b3JlbGVhc2VQ b29sc09uQ3VycmVudFJ1bkxvb3AoKTsKKyAgICAKICAgICBtX3J1bkxvb3AgPSBDRlJ1bkxvb3BH ZXRDdXJyZW50KCk7CiAKICAgICBDRlJ1bkxvb3BTb3VyY2VDb250ZXh0IGNvbnRleHQgPSB7IDAs IHRoaXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1Xb3JrIH07CkBAIC00Myw2ICs2OSw4 IEBAIFJ1bkxvb3A6OlJ1bkxvb3AoKQogCiBSdW5Mb29wOjp+UnVuTG9vcCgpCiB7CisgICAgdW5p bnN0YWxsQXV0b3JlbGVhc2VQb29sc09uQ3VycmVudFJ1bkxvb3AoKTsKKwogICAgIC8vIEZJWE1F OiBUZWFyIGRvd24gdGhlIHdvcmsgaXRlbSBxdWV1ZSBoZXJlLgogICAgIENGUnVuTG9vcFNvdXJj ZUludmFsaWRhdGUobV9ydW5Mb29wU291cmNlKTsKICAgICBDRlJlbGVhc2UobV9ydW5Mb29wU291 cmNlKTsKQEAgLTg1LDYgKzExMyw0NyBAQCB2b2lkIFJ1bkxvb3A6Ondha2VVcCgpCiAgICAgQ0ZS dW5Mb29wV2FrZVVwKG1fcnVuTG9vcCk7CiB9CiAKKy8vIFNldCB1cCBhbiBBdXRvcmVsZWFzZSBQ b29sIG9uIHRoZSBtYWluIFJ1bkxvb3AKKy8vIEZJWE1FOiByZW1vdmUgd2hlbiA8cmRhcjovL3By b2JsZW0vODkyOTQyNj4gaXMgZml4ZWQuCit2b2lkIFJ1bkxvb3A6Omluc3RhbGxBdXRvcmVsZWFz ZVBvb2xzT25DdXJyZW50UnVuTG9vcCgpCit7CisgICAgLy8gU2V0cyB1cCBvYnNlcnZlcnMgYXJv dW5kIHRoZSBjdXJyZW50IHJ1biBsb29wLiBUaGVzZSBvYnNlcnZlcnMgYWRkIGFuZCByZW1vdmUg YW4gYXV0b3JlbGVhc2UgcG9vbCBhcm91bmQgdGhlIHJ1biBsb29wIGZyb20gbm8gdW50aWwgaW5m aW5pdHkuLi4gIAorICAgIGlmICghbV9DdXJyZW50UnVuTG9vcEVudGVyT2JzZXJ2ZXJSZWYpIHsK KyAgICAgICAgQ0ZSdW5Mb29wT2JzZXJ2ZXJDb250ZXh0IG5ld1J1bkxvb3BFbnRlck9ic2VydmVy Q29udGV4dDsKKyAgICAgICAgQ0ZSdW5Mb29wT2JzZXJ2ZXJSZWYgbmV3UnVuTG9vcEVudGVyT2Jz ZXJ2ZXJSZWYgPSAwOworICAgICAgICBDRlJ1bkxvb3BPYnNlcnZlckNvbnRleHQgbmV3UnVuTG9v cEV4aXRPYnNlcnZlckNvbnRleHQ7CisgICAgICAgIENGUnVuTG9vcE9ic2VydmVyUmVmIG5ld1J1 bkxvb3BFeGl0T2JzZXJ2ZXJSZWYgPSAwOworICAgICAgICAvLyBJbnN0YWxsIGEgcmVwZWF0aW5n IG9ic2VydmVyIHRvIGZpcmUgb24gZW50cnkgdG8gdGhlIHJ1biBjdXJyZW50IHJ1biBsb29wIHdp dGggYSBlYXJseSBvcmRlcmluZyBsaWtlIC1rV3JhcFJ1bkxvb3BXaXRoQXV0b3JlbGVhc2VQb29s T2JzZXJ2ZXJPcmRlci4gIENGUnVuTG9vcCBnaXZlcyBoaWdoZXN0IHByaW9yaXR5IHRvIHRob3Nl IG9ic2VydmVycyBjbG9zZSB0byBtaW51cyBpbmZpbml0eS4KKyAgICAgICAgbmV3UnVuTG9vcEVu dGVyT2JzZXJ2ZXJDb250ZXh0LnZlcnNpb24gID0gMDsKKyAgICAgICAgbmV3UnVuTG9vcEVudGVy T2JzZXJ2ZXJDb250ZXh0LmluZm8gICAgID0gQ0ZBcnJheUNyZWF0ZU11dGFibGUoa0NGQWxsb2Nh dG9yU3lzdGVtRGVmYXVsdCAvKiBEb24ndCByZXRhaW4gdGhlIGF1dG9yZWxlYXNlIHBvb2wgdG9r ZW5zLiAqLywwLDApOworICAgICAgICBuZXdSdW5Mb29wRW50ZXJPYnNlcnZlckNvbnRleHQucmV0 YWluICAgPSBDRlJldGFpbjsgICAgICAgICAvLyByZXRhaW4gdGhlIGFycmF5CisgICAgICAgIG5l d1J1bkxvb3BFbnRlck9ic2VydmVyQ29udGV4dC5yZWxlYXNlICA9IENGUmVsZWFzZTsgICAgICAg IC8vIHJlbGVhc2UgdGhlIGFycmF5IHdoZW4gdGhlIGNvbnRleHQgaW5mbyBnb2VzIGF3YXkuCisg ICAgICAgIG5ld1J1bkxvb3BFbnRlck9ic2VydmVyQ29udGV4dC5jb3B5RGVzY3JpcHRpb24gPSBD RkNvcHlEZXNjcmlwdGlvbjsKKyAgICAgICAgbmV3UnVuTG9vcEVudGVyT2JzZXJ2ZXJSZWYgPSBD RlJ1bkxvb3BPYnNlcnZlckNyZWF0ZSgwLCBrQ0ZSdW5Mb29wRW50cnksIFlFUyAvKiByZXBlYXRz ICovLCAtV1JBUF9SVU5fTE9PUF9XSVRIX0FVVE9SRUxFQVNFX1BPT0xTX09CU0VSVkVSX09SREVS IC8qIG9yZGVyID09IHByaW9yaXR5ICovLCB3cmFwUnVuTG9vcFdpdGhBdXRvcmVsZWFzZVBvb2xI YW5kbGVyLCAmbmV3UnVuTG9vcEVudGVyT2JzZXJ2ZXJDb250ZXh0KTsKKyAgICAgICAgQ0ZSdW5M b29wQWRkT2JzZXJ2ZXIoQ0ZSdW5Mb29wR2V0Q3VycmVudCgpLCBuZXdSdW5Mb29wRW50ZXJPYnNl cnZlclJlZiwga0NGUnVuTG9vcENvbW1vbk1vZGVzKTsKKyAgICAgICAgLy8gSW5zdGFsbCBhIHJl cGVhdGluZyBvYnNlcnZlciB0byBmaXJlIG9uIGV4aXQgb2YgdGhlIGN1cnJlbnQgcnVuIGxvb3Ag d2l0aCBhbiB2ZXJ5IGxhdGUgb3JkZXJpbmcgbGlrZSBrV3JhcFJ1bkxvb3BXaXRoQXV0b3JlbGVh c2VQb29sT2JzZXJ2ZXJPcmRlci4gIENGUnVuTG9vcCBnaXZlcyBsb3dlc3QgcHJpb3JpdHkgdG8g dGhvc2Ugb2JzZXJ2ZXJzIGNsb3NlIHRvIHBvc2l0aXZlIGluZmluaXR5LgorICAgICAgICBuZXdS dW5Mb29wRXhpdE9ic2VydmVyQ29udGV4dC52ZXJzaW9uICA9IDA7CisgICAgICAgIG5ld1J1bkxv b3BFeGl0T2JzZXJ2ZXJDb250ZXh0LmluZm8gICAgID0gbmV3UnVuTG9vcEVudGVyT2JzZXJ2ZXJD b250ZXh0LmluZm87CisgICAgICAgIG5ld1J1bkxvb3BFeGl0T2JzZXJ2ZXJDb250ZXh0LnJldGFp biAgID0gQ0ZSZXRhaW47ICAgICAgICAgLy8gcmV0YWluIHRoZSBhcnJheQorICAgICAgICBuZXdS dW5Mb29wRXhpdE9ic2VydmVyQ29udGV4dC5yZWxlYXNlICA9IENGUmVsZWFzZTsgICAgICAgIC8v IHJlbGVhc2UgdGhlIGFycmF5IHdoZW4gdGhlIGNvbnRleHQgaW5mbyBnb2VzIGF3YXkuCisgICAg ICAgIG5ld1J1bkxvb3BFeGl0T2JzZXJ2ZXJDb250ZXh0LmNvcHlEZXNjcmlwdGlvbiA9IENGQ29w eURlc2NyaXB0aW9uOworICAgICAgICBuZXdSdW5Mb29wRXhpdE9ic2VydmVyUmVmID0gQ0ZSdW5M b29wT2JzZXJ2ZXJDcmVhdGUoMCwga0NGUnVuTG9vcEV4aXQsIFlFUyAvKiByZXBlYXRzICovLCBX UkFQX1JVTl9MT09QX1dJVEhfQVVUT1JFTEVBU0VfUE9PTFNfT0JTRVJWRVJfT1JERVIgLyogb3Jk ZXIgLSBwcmlvcml0eSAqLywgd3JhcFJ1bkxvb3BXaXRoQXV0b3JlbGVhc2VQb29sSGFuZGxlciwg Jm5ld1J1bkxvb3BFeGl0T2JzZXJ2ZXJDb250ZXh0KTsKKyAgICAgICAgQ0ZSdW5Mb29wQWRkT2Jz ZXJ2ZXIoQ0ZSdW5Mb29wR2V0Q3VycmVudCgpLCBuZXdSdW5Mb29wRXhpdE9ic2VydmVyUmVmLCBr Q0ZSdW5Mb29wQ29tbW9uTW9kZXMpOworICAgICAgICBDRlJlbGVhc2UoKENGTXV0YWJsZUFycmF5 UmVmKW5ld1J1bkxvb3BFbnRlck9ic2VydmVyQ29udGV4dC5pbmZvKTsgICAgICAgIC8vIG93bmVk IGJ5IHRoZSBvYnNlcnZlci4gKG9ubHkgb25lIHJlbGVhc2UgaXMgbmVlZGVkIHNpbmNlIEVudGVy L0V4aXQgcG9pbnQgdG8gdGhlIHNhbWUgaW5zdGFuY2UpLgorICAgICAgICAKKyAgICAgICAgbV9D dXJyZW50UnVuTG9vcEVudGVyT2JzZXJ2ZXJSZWYuYWRvcHRDRihuZXdSdW5Mb29wRW50ZXJPYnNl cnZlclJlZik7ICAKKyAgICAgICAgbV9DdXJyZW50UnVuTG9vcEV4aXRPYnNlcnZlclJlZi5hZG9w dENGKG5ld1J1bkxvb3BFeGl0T2JzZXJ2ZXJSZWYpOworICAgIH0KK30KKwordm9pZCBSdW5Mb29w Ojp1bmluc3RhbGxBdXRvcmVsZWFzZVBvb2xzT25DdXJyZW50UnVuTG9vcCh2b2lkKQoreworICAg IGlmIChtX0N1cnJlbnRSdW5Mb29wRW50ZXJPYnNlcnZlclJlZikKKyAgICAgICAgbV9DdXJyZW50 UnVuTG9vcEVudGVyT2JzZXJ2ZXJSZWYuY2xlYXIoKTsKKyAgICBpZiAobV9DdXJyZW50UnVuTG9v cEV4aXRPYnNlcnZlclJlZikKKyAgICAgICAgbV9DdXJyZW50UnVuTG9vcEV4aXRPYnNlcnZlclJl Zi5jbGVhcigpOworfQorCiAvLyBSdW5Mb29wOjpUaW1lcgogCiB2b2lkIFJ1bkxvb3A6OlRpbWVy QmFzZTo6dGltZXJGaXJlZChDRlJ1bkxvb3BUaW1lclJlZiwgdm9pZCogY29udGV4dCkK 80703 2011-01-31 17:31:26 -0800 2011-02-01 20:49:27 -0800 new patch AutoreleasePatch.txt text/plain 6925 slewis SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDc2OTg5KQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTEtMDEtMjggIFN0ZXBoYW5p ZSBMZXdpcyAgPHNsZXdpc0BhcHBsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ LgorCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84OTIxNzI5PiBSRUdSRVNTSU9OOiBNZW1idXN0 ZXIgYWNjdW11bGF0ZXMgMUdCKyBtZW1vcnkgZHVlIHRvIGF1dG9yZWxlYXNlIHBvb2xzIG5vdCBi ZWluZyBkcmFpbmVkLgorICAgICAgICBBZGQgb2JzZXJ2ZXJzIHRvIHB1c2ggYW5kIHBvcCBhdXRv cmVsZWFzZSBwb29scyBvbiBlbnRyeSBhbmQgZXhpdCBmcm9tIHRoZSBtYWluIENGUnVuTG9vcC4g IAorICAgICAgICBUaGlzIHdpbGwgcHJldmVudCBtZW1vcnkgZnJvbSBhY2N1bXVsYXRpbmcuCisK KyAgICAgICAgKiBQbGF0Zm9ybS9SdW5Mb29wLmg6CisgICAgICAgICogUGxhdGZvcm0vbWFjL1J1 bkxvb3BNYWMubW06CisgICAgICAgICh3cmFwUnVuTG9vcFdpdGhBdXRvcmVsZWFzZVBvb2xIYW5k bGVyKToKKyAgICAgICAgKFJ1bkxvb3A6OlJ1bkxvb3ApOgorICAgICAgICAoUnVuTG9vcDo6flJ1 bkxvb3ApOgorICAgICAgICAoUnVuTG9vcDo6aW5zdGFsbEF1dG9yZWxlYXNlUG9vbHNPbk1haW5S dW5Mb29wKToKKyAgICAgICAgKFJ1bkxvb3A6OnVuaW5zdGFsbEF1dG9yZWxlYXNlUG9vbHNPbk1h aW5SdW5Mb29wKToKKwogMjAxMS0wMS0yOCAgU3RlcGhhbmllIExld2lzICA8c2xld2lzQGFwcGxl LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBHZW9mZiBHYXJlbi4KSW5kZXg6IFNvdXJjZS9X ZWJLaXQyL1BsYXRmb3JtL1J1bkxvb3AuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9Q bGF0Zm9ybS9SdW5Mb29wLmgJKHJldmlzaW9uIDc2OTg2KQorKysgU291cmNlL1dlYktpdDIvUGxh dGZvcm0vUnVuTG9vcC5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMyw2ICszMywxMSBAQAogI2luY2x1 ZGUgPHd0Zi9UaHJlYWRTcGVjaWZpYy5oPgogI2luY2x1ZGUgPHd0Zi9UaHJlYWRpbmcuaD4KICNp bmNsdWRlIDx3dGYvVmVjdG9yLmg+CisKKyNpZiBQTEFURk9STShNQUMpCisjaW5jbHVkZSA8d3Rm L1JldGFpblB0ci5oPgorI2VuZGlmCisKICNpZiBQTEFURk9STShHVEspCiB0eXBlZGVmIHN0cnVj dCBfR1NvdXJjZSBHU291cmNlOwogdHlwZWRlZiBzdHJ1Y3QgX0dNYWluTG9vcCBHTWFpbkxvb3A7 CkBAIC0xMzQsOCArMTM5LDEyIEBAIHByaXZhdGU6CiAgICAgVGltZXJNYXAgbV9hY3RpdmVUaW1l cnM7CiAjZWxpZiBQTEFURk9STShNQUMpCiAgICAgc3RhdGljIHZvaWQgcGVyZm9ybVdvcmsodm9p ZCopOworICAgIHZvaWQgaW5zdGFsbEF1dG9yZWxlYXNlUG9vbHNPbkN1cnJlbnRSdW5Mb29wKCk7 CisgICAgdm9pZCB1bmluc3RhbGxBdXRvcmVsZWFzZVBvb2xzT25DdXJyZW50UnVuTG9vcCgpOwog ICAgIENGUnVuTG9vcFJlZiBtX3J1bkxvb3A7CiAgICAgQ0ZSdW5Mb29wU291cmNlUmVmIG1fcnVu TG9vcFNvdXJjZTsKKyAgICBSZXRhaW5QdHI8Q0ZSdW5Mb29wT2JzZXJ2ZXJSZWY+IG1fY3VycmVu dFJ1bkxvb3BFbnRlck9ic2VydmVyOworICAgIFJldGFpblB0cjxDRlJ1bkxvb3BPYnNlcnZlclJl Zj4gbV9jdXJyZW50UnVuTG9vcEV4aXRPYnNlcnZlcjsKICNlbGlmIFBMQVRGT1JNKFFUKQogICAg IHR5cGVkZWYgSGFzaE1hcDxpbnQsIFRpbWVyQmFzZSo+IFRpbWVyTWFwOwogICAgIFRpbWVyTWFw IG1fYWN0aXZlVGltZXJzOwpJbmRleDogU291cmNlL1dlYktpdDIvUGxhdGZvcm0vbWFjL1J1bkxv b3BNYWMubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvUGxhdGZvcm0vbWFjL1J1bkxv b3BNYWMubW0JKHJldmlzaW9uIDc2OTg2KQorKysgU291cmNlL1dlYktpdDIvUGxhdGZvcm0vbWFj L1J1bkxvb3BNYWMubW0JKHdvcmtpbmcgY29weSkKQEAgLTI3LDYgKzI3LDMwIEBACiAKICNpbXBv cnQgIldvcmtJdGVtLmgiCiAKK3N0YXRpYyBjb25zdCBpbnQgd3JhcFJ1bkxvb3BXaXRoQXV0b3Jl bGVhc2VQb29sc1ByaW9yaXR5ID0gMTAwMDAwMDsKKworc3RhdGljIHZvaWQgd3JhcFJ1bkxvb3BX aXRoQXV0b3JlbGVhc2VQb29sSGFuZGxlcihDRlJ1bkxvb3BPYnNlcnZlclJlZiBvYnNlcnZlciwg Q0ZSdW5Mb29wQWN0aXZpdHkgYWN0aXZpdHksIHZvaWQqIGNvbnRleHREYXRhKSAKK3sKKyAgICBD Rk11dGFibGVBcnJheVJlZiBhdXRvcmVsZWFzZVBvb2xTdGFjayA9IHN0YXRpY19jYXN0PENGTXV0 YWJsZUFycmF5UmVmPihjb250ZXh0RGF0YSk7CisgICAgc3dpdGNoIChhY3Rpdml0eSkgeworICAg IGNhc2Uga0NGUnVuTG9vcEVudHJ5OgorICAgICAgICBDRkFycmF5QXBwZW5kVmFsdWUoYXV0b3Jl bGVhc2VQb29sU3RhY2ssIFtbTlNBdXRvcmVsZWFzZVBvb2wgYWxsb2NdIGluaXRdKTsKKyAgICAg ICAgYnJlYWs7CisgICAgY2FzZSBrQ0ZSdW5Mb29wRXhpdDogeworICAgICAgICBDRkluZGV4IGNv dW50ID0gQ0ZBcnJheUdldENvdW50KGF1dG9yZWxlYXNlUG9vbFN0YWNrKTsKKyAgICAgICAgLy8g SXQgaXMgcG9zc2libGUgZm9yIHRoZXJlIHRvIGJlIG5vIGF1dG9yZWxlYXNlUG9vbCBvbiB0aGUg c3RhY2sgaWYgdGhpcyBoYW5kbGVyIHdhcyBpbnN0YWxsZWQgd2hpbGUgd2l0aGluIENGUnVuTG9v cFJ1biwgYmVjYXVzZSB3ZSdsbCBnZXQgYSBrQ0ZSdW5Mb29wRXhpdCBiZWZvcmUgdGhlIG5leHQg a0NGUnVuTG9vcEVudHJ5LiAgCisgICAgICAgIGlmIChjb3VudCA+IDApIHsKKyAgICAgICAgICAg IE5TQXV0b3JlbGVhc2VQb29sKiBwb29sID0gY29uc3RfY2FzdDxOU0F1dG9yZWxlYXNlUG9vbCo+ KHN0YXRpY19jYXN0PGNvbnN0IE5TQXV0b3JlbGVhc2VQb29sKj4oQ0ZBcnJheUdldFZhbHVlQXRJ bmRleChhdXRvcmVsZWFzZVBvb2xTdGFjaywgY291bnQgLSAxKSkpOworICAgICAgICAgICAgW3Bv b2wgZHJhaW5dOworICAgICAgICAgICAgQ0ZBcnJheVJlbW92ZVZhbHVlQXRJbmRleChhdXRvcmVs ZWFzZVBvb2xTdGFjaywgY291bnQtMSk7CisgICAgICAgIH0KKyAgICAgICAgYnJlYWs7CisgICAg fQorICAgIGRlZmF1bHQ6CisgICAgICAgIGJyZWFrOworICAgIH0KK30KKwogdm9pZCBSdW5Mb29w OjpwZXJmb3JtV29yayh2b2lkKiBjb250ZXh0KQogewogICAgIHN0YXRpY19jYXN0PFJ1bkxvb3Aq Pihjb250ZXh0KS0+cGVyZm9ybVdvcmsoKTsKQEAgLTM0LDYgKzU4LDggQEAgdm9pZCBSdW5Mb29w OjpwZXJmb3JtV29yayh2b2lkKiBjb250ZXh0KQogCiBSdW5Mb29wOjpSdW5Mb29wKCkKIHsKKyAg ICBpbnN0YWxsQXV0b3JlbGVhc2VQb29sc09uQ3VycmVudFJ1bkxvb3AoKTsKKyAgICAKICAgICBt X3J1bkxvb3AgPSBDRlJ1bkxvb3BHZXRDdXJyZW50KCk7CiAKICAgICBDRlJ1bkxvb3BTb3VyY2VD b250ZXh0IGNvbnRleHQgPSB7IDAsIHRoaXMsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIHBlcmZvcm1X b3JrIH07CkBAIC00Myw2ICs2OSw4IEBAIFJ1bkxvb3A6OlJ1bkxvb3AoKQogCiBSdW5Mb29wOjp+ UnVuTG9vcCgpCiB7CisgICAgdW5pbnN0YWxsQXV0b3JlbGVhc2VQb29sc09uQ3VycmVudFJ1bkxv b3AoKTsKKwogICAgIC8vIEZJWE1FOiBUZWFyIGRvd24gdGhlIHdvcmsgaXRlbSBxdWV1ZSBoZXJl LgogICAgIENGUnVuTG9vcFNvdXJjZUludmFsaWRhdGUobV9ydW5Mb29wU291cmNlKTsKICAgICBD RlJlbGVhc2UobV9ydW5Mb29wU291cmNlKTsKQEAgLTg1LDYgKzExMyw0NiBAQCB2b2lkIFJ1bkxv b3A6Ondha2VVcCgpCiAgICAgQ0ZSdW5Mb29wV2FrZVVwKG1fcnVuTG9vcCk7CiB9CiAKKy8vIFNl dCB1cCBhbiBBdXRvcmVsZWFzZSBQb29sIG9uIHRoZSBjdXJyZW50IFJ1bkxvb3AKKy8vIEZJWE1F OiByZW1vdmUgd2hlbiA8cmRhcjovL3Byb2JsZW0vODkyOTQyNj4gaXMgZml4ZWQuCit2b2lkIFJ1 bkxvb3A6Omluc3RhbGxBdXRvcmVsZWFzZVBvb2xzT25DdXJyZW50UnVuTG9vcCgpCit7CisgICAg Ly8gU2V0cyB1cCBvYnNlcnZlcnMgYXJvdW5kIHRoZSBjdXJyZW50IHJ1biBsb29wLiBUaGVzZSBv YnNlcnZlcnMgYWRkIGFuZCByZW1vdmUgYW4gYXV0b3JlbGVhc2UgcG9vbCBhcm91bmQgdGhlIHJ1 biBsb29wIGZyb20gbm8gdW50aWwgaW5maW5pdHkuLi4gIAorICAgIGlmICghbV9jdXJyZW50UnVu TG9vcEVudGVyT2JzZXJ2ZXIpIHsKKyAgICAgICAgQ0ZSdW5Mb29wT2JzZXJ2ZXJDb250ZXh0IG5l d1J1bkxvb3BFbnRlck9ic2VydmVyQ29udGV4dDsKKyAgICAgICAgQ0ZSdW5Mb29wT2JzZXJ2ZXJD b250ZXh0IG5ld1J1bkxvb3BFeGl0T2JzZXJ2ZXJDb250ZXh0OworICAgICAgICBSZXRhaW5QdHI8 Q0ZNdXRhYmxlQXJyYXlSZWY+IGF1dG9yZWxlYXNlUG9vbFN0YWNrID0gQ0ZBcnJheUNyZWF0ZU11 dGFibGUoa0NGQWxsb2NhdG9yU3lzdGVtRGVmYXVsdCwgMCwgMCk7IC8vIFVzZSBzeXN0ZW0gQWxs b2NhdG9yIHRvIGF2b2lkIHJldGFpbmluZyB0aGUgYXV0b3JlbGVhc2UgcG9vbCB0b2tlbnM7Cisg ICAgICAgIAorICAgICAgICAvLyBJbnN0YWxsIGEgcmVwZWF0aW5nIG9ic2VydmVyIHRvIGZpcmUg b24gZW50cnkgdG8gdGhlIHJ1biBjdXJyZW50IHJ1biBsb29wIHdpdGggYSBlYXJseSBvcmRlcmlu ZyBsaWtlIC13cmFwUnVuTG9vcFdpdGhBdXRvcmVsZWFzZVBvb2xzT3JkZXIuICBDRlJ1bkxvb3Ag Z2l2ZXMgaGlnaGVzdCBwcmlvcml0eSB0byB0aG9zZSBvYnNlcnZlcnMgY2xvc2UgdG8gbWludXMg aW5maW5pdHkuCisgICAgICAgIG5ld1J1bkxvb3BFbnRlck9ic2VydmVyQ29udGV4dC52ZXJzaW9u ID0gMDsKKyAgICAgICAgbmV3UnVuTG9vcEVudGVyT2JzZXJ2ZXJDb250ZXh0LmluZm8gPSBhdXRv cmVsZWFzZVBvb2xTdGFjay5nZXQoKTsKKyAgICAgICAgbmV3UnVuTG9vcEVudGVyT2JzZXJ2ZXJD b250ZXh0LnJldGFpbiA9IENGUmV0YWluOworICAgICAgICBuZXdSdW5Mb29wRW50ZXJPYnNlcnZl ckNvbnRleHQucmVsZWFzZSA9IENGUmVsZWFzZTsKKyAgICAgICAgbmV3UnVuTG9vcEVudGVyT2Jz ZXJ2ZXJDb250ZXh0LmNvcHlEZXNjcmlwdGlvbiA9IENGQ29weURlc2NyaXB0aW9uOworICAgICAg ICBtX2N1cnJlbnRSdW5Mb29wRW50ZXJPYnNlcnZlci5hZG9wdENGKENGUnVuTG9vcE9ic2VydmVy Q3JlYXRlKDAsIGtDRlJ1bkxvb3BFbnRyeSwgWUVTLCAtd3JhcFJ1bkxvb3BXaXRoQXV0b3JlbGVh c2VQb29sc1ByaW9yaXR5LCB3cmFwUnVuTG9vcFdpdGhBdXRvcmVsZWFzZVBvb2xIYW5kbGVyLCAm bmV3UnVuTG9vcEVudGVyT2JzZXJ2ZXJDb250ZXh0KSk7CisgICAgICAgIENGUnVuTG9vcEFkZE9i c2VydmVyKENGUnVuTG9vcEdldEN1cnJlbnQoKSwgbV9jdXJyZW50UnVuTG9vcEVudGVyT2JzZXJ2 ZXIuZ2V0KCksIGtDRlJ1bkxvb3BDb21tb25Nb2Rlcyk7CisgICAgICAgIAorICAgICAgICAvLyBJ bnN0YWxsIGEgcmVwZWF0aW5nIG9ic2VydmVyIHRvIGZpcmUgb24gZXhpdCBvZiB0aGUgY3VycmVu dCBydW4gbG9vcCB3aXRoIGFuIHZlcnkgbGF0ZSBvcmRlcmluZyBsaWtlIHdyYXBSdW5Mb29wV2l0 aEF1dG9yZWxlYXNlUG9vbHNPcmRlci4gQ0ZSdW5Mb29wIGdpdmVzIGxvd2VzdCBwcmlvcml0eSB0 byB0aG9zZSBvYnNlcnZlcnMgY2xvc2UgdG8gcG9zaXRpdmUgaW5maW5pdHkuCisgICAgICAgIG5l d1J1bkxvb3BFeGl0T2JzZXJ2ZXJDb250ZXh0LnZlcnNpb24gPSAwOworICAgICAgICBuZXdSdW5M b29wRXhpdE9ic2VydmVyQ29udGV4dC5pbmZvID0gYXV0b3JlbGVhc2VQb29sU3RhY2suZ2V0KCk7 CisgICAgICAgIG5ld1J1bkxvb3BFeGl0T2JzZXJ2ZXJDb250ZXh0LnJldGFpbiA9IENGUmV0YWlu OworICAgICAgICBuZXdSdW5Mb29wRXhpdE9ic2VydmVyQ29udGV4dC5yZWxlYXNlID0gQ0ZSZWxl YXNlOworICAgICAgICBuZXdSdW5Mb29wRXhpdE9ic2VydmVyQ29udGV4dC5jb3B5RGVzY3JpcHRp b24gPSBDRkNvcHlEZXNjcmlwdGlvbjsKKyAgICAgICAgbV9jdXJyZW50UnVuTG9vcEV4aXRPYnNl cnZlci5hZG9wdENGKENGUnVuTG9vcE9ic2VydmVyQ3JlYXRlKDAsIGtDRlJ1bkxvb3BFeGl0LCBZ RVMsIHdyYXBSdW5Mb29wV2l0aEF1dG9yZWxlYXNlUG9vbHNQcmlvcml0eSwgd3JhcFJ1bkxvb3BX aXRoQXV0b3JlbGVhc2VQb29sSGFuZGxlciwgJm5ld1J1bkxvb3BFeGl0T2JzZXJ2ZXJDb250ZXh0 KSk7CisgICAgICAgIENGUnVuTG9vcEFkZE9ic2VydmVyKENGUnVuTG9vcEdldEN1cnJlbnQoKSwg bV9jdXJyZW50UnVuTG9vcEV4aXRPYnNlcnZlci5nZXQoKSwga0NGUnVuTG9vcENvbW1vbk1vZGVz KTsKKyAgICAgICAgCisgICAgICAgIGF1dG9yZWxlYXNlUG9vbFN0YWNrLmNsZWFyKCk7IC8vIG93 bmVkIGJ5IHRoZSBvYnNlcnZlci4KKyAgICB9Cit9CisKK3ZvaWQgUnVuTG9vcDo6dW5pbnN0YWxs QXV0b3JlbGVhc2VQb29sc09uQ3VycmVudFJ1bkxvb3Aodm9pZCkKK3sKKyAgICBpZiAobV9jdXJy ZW50UnVuTG9vcEVudGVyT2JzZXJ2ZXIpCisgICAgICAgIG1fY3VycmVudFJ1bkxvb3BFbnRlck9i c2VydmVyLmNsZWFyKCk7CisgICAgaWYgKG1fY3VycmVudFJ1bkxvb3BFeGl0T2JzZXJ2ZXIpCisg ICAgICAgIG1fY3VycmVudFJ1bkxvb3BFeGl0T2JzZXJ2ZXIuY2xlYXIoKTsKK30KKwogLy8gUnVu TG9vcDo6VGltZXIKIAogdm9pZCBSdW5Mb29wOjpUaW1lckJhc2U6OnRpbWVyRmlyZWQoQ0ZSdW5M b29wVGltZXJSZWYsIHZvaWQqIGNvbnRleHQpCg== 80883 2011-02-01 20:49:27 -0800 2011-02-02 17:47:53 -0800 patch AutoreleasePatch2.txt text/plain 1814 slewis SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDc3MzU5KQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDItMDEgIFN0ZXBoYW5p ZSBMZXdpcyAgPHNsZXdpc0BhcHBsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTUzMzYxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84OTIxNzI5PiBSRUdSRVNTSU9OOiBN ZW1idXN0ZXIgYWNjdW11bGF0ZXMgMUdCKyBtZW1vcnkgZHVlIHRvIGF1dG9yZWxlYXNlIAorICAg ICAgICBwb29scyBub3QgYmVpbmcgZHJhaW5lZC4KKyAgICAgICAgQ2FsbCBpbnRvIEFwcEtpdCB0 byBhZGQgb2JzZXJ2ZXJzIHRoYXQgcHVzaCBhbmQgcG9wIGF1dG9yZWxlYXNlIHBvb2xzIG9uIGVu dHJ5IAorICAgICAgICBhbmQgZXhpdCBmcm9tIHRoZSBDRlJ1bkxvb3AuICBUaGlzIHdpbGwgcHJl dmVudCBtZW1vcnkgZnJvbSBhY2N1bXVsYXRpbmcuCisKKyAgICAgICAgKiBQbGF0Zm9ybS9tYWMv UnVuTG9vcE1hYy5tbToKKyAgICAgICAgKFJ1bkxvb3A6OlJ1bkxvb3ApOgorCiAyMDExLTAyLTAx ICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgRGFuIEJlcm5zdGVpbi4KSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1BsYXRmb3JtL21hYy9S dW5Mb29wTWFjLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1BsYXRmb3JtL21hYy9S dW5Mb29wTWFjLm1tCShyZXZpc2lvbiA3NzI3OSkKKysrIFNvdXJjZS9XZWJLaXQyL1BsYXRmb3Jt L21hYy9SdW5Mb29wTWFjLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0yOCw2ICsyOCwxMSBAQAogCiAj aW1wb3J0ICJXb3JrSXRlbS5oIgogCitAaW50ZXJmYWNlIE5TQXBwbGljYXRpb24gKFBlZWtBdEFw cEtpdFNlY3JldHMpCistKHZvaWQpX2luc3RhbGxBdXRvcmVsZWFzZVBvb2xzT25DdXJyZW50VGhy ZWFkSWZOZWNlc3Nhcnk7CitAZW5kCisKKwogdm9pZCBSdW5Mb29wOjpwZXJmb3JtV29yayh2b2lk KiBjb250ZXh0KQogewogICAgIHN0YXRpY19jYXN0PFJ1bkxvb3AqPihjb250ZXh0KS0+cGVyZm9y bVdvcmsoKTsKQEAgLTM1LDYgKzQwLDEwIEBAIHZvaWQgUnVuTG9vcDo6cGVyZm9ybVdvcmsodm9p ZCogY29udGV4dCkKIAogUnVuTG9vcDo6UnVuTG9vcCgpCiB7CisgICAgLy8gSW5zdGFsbHMgYXV0 b3JlbGVhc2UgcG9vbHMgb24gdGhlIGN1cnJlbnQgQ0ZSdW5Mb29wIHdoaWNoIHByZXZlbnRzIG1l bW9yeSBmcm9tIGFjY3VtdWxhdGluZyBiZXR3ZWVuIHVzZXIgZXZlbnRzLgorICAgIC8vIEZJWE1F OiBSZW1vdmUgd2hlbiA8cmRhcjovL3Byb2JsZW0vODkyOTQyNj4gaXMgZml4ZWQuCisgICAgW1tO U0FwcGxpY2F0aW9uIHNoYXJlZEFwcGxpY2F0aW9uXSBfaW5zdGFsbEF1dG9yZWxlYXNlUG9vbHNP bkN1cnJlbnRUaHJlYWRJZk5lY2Vzc2FyeV07CisgICAgCiAgICAgbV9ydW5Mb29wID0gQ0ZSdW5M b29wR2V0Q3VycmVudCgpOwogCiAgICAgQ0ZSdW5Mb29wU291cmNlQ29udGV4dCBjb250ZXh0ID0g eyAwLCB0aGlzLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCBwZXJmb3JtV29yayB9Owo= 81014 2011-02-02 17:47:53 -0800 2011-02-02 17:54:36 -0800 patch moving code to WebProcessMain AutoreleasePatch2.txt text/plain 1928 slewis SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDc3NDQ3KQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDItMDIgIFN0ZXBoYW5p ZSBMZXdpcyAgPHNsZXdpc0BhcHBsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTUzMzYxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84OTIxNzI5PiBSRUdSRVNTSU9OOiBN ZW1idXN0ZXIgYWNjdW11bGF0ZXMgMUdCKyBtZW1vcnkgZHVlIHRvIGF1dG9yZWxlYXNlIAorICAg ICAgICBwb29scyBub3QgYmVpbmcgZHJhaW5lZC4KKyAgICAgICAgQ2FsbCBpbnRvIEFwcEtpdCB0 byBhZGQgb2JzZXJ2ZXJzIHRoYXQgcHVzaCBhbmQgcG9wIGF1dG9yZWxlYXNlIHBvb2xzIG9uIGVu dHJ5IAorICAgICAgICBhbmQgZXhpdCBmcm9tIHRoZSBDRlJ1bkxvb3AuICBUaGlzIHdpbGwgcHJl dmVudCBtZW1vcnkgZnJvbSBhY2N1bXVsYXRpbmcuCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL21h Yy9XZWJQcm9jZXNzTWFpbk1hYy5tbToKKyAgICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzc01haW4p OgorCiAyMDExLTAyLTAyICBNYXJrIFJvd2UgIDxtcm93ZUBhcHBsZS5jb20+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQmV0aCBEYWtpbi4KSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3Mv bWFjL1dlYlByb2Nlc3NNYWluTWFjLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvbWFjL1dlYlByb2Nlc3NNYWluTWFjLm1tCShyZXZpc2lvbiA3NzI3OSkKKysrIFNv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvbWFjL1dlYlByb2Nlc3NNYWluTWFjLm1tCSh3b3JraW5n IGNvcHkpCkBAIC00Niw2ICs0NiwxMCBAQAogLy8gRklYTUU6IFdlIHNob3VsZCBiZSBkb2luZyB0 aGlzIGFub3RoZXIgd2F5LgogZXh0ZXJuICJDIiBrZXJuX3JldHVybl90IGJvb3RzdHJhcF9sb29r X3VwMihtYWNoX3BvcnRfdCwgY29uc3QgbmFtZV90LCBtYWNoX3BvcnRfdCosIHBpZF90LCB1aW50 NjRfdCk7CiAKK0BpbnRlcmZhY2UgTlNBcHBsaWNhdGlvbiAoV2ViTlNBcHBsaWNhdGlvbkRldGFp bHMpCistKHZvaWQpX2luc3RhbGxBdXRvcmVsZWFzZVBvb2xzT25DdXJyZW50VGhyZWFkSWZOZWNl c3Nhcnk7CitAZW5kCisKICNkZWZpbmUgU0hPV19DUkFTSF9SRVBPUlRFUiAxCiAKIHVzaW5nIG5h bWVzcGFjZSBXZWJDb3JlOwpAQCAtODksNiArOTMsMTAgQEAgaW50IFdlYlByb2Nlc3NNYWluKGNv bnN0IENvbW1hbmRMaW5lJiBjbwogICAgICAvLyBJbml0aWFsaXplIEFwcEtpdC4KICAgICBbTlNB cHBsaWNhdGlvbiBzaGFyZWRBcHBsaWNhdGlvbl07CiAKKyAgICAvLyBJbnN0YWxscyBhdXRvcmVs ZWFzZSBwb29scyBvbiB0aGUgY3VycmVudCBDRlJ1bkxvb3Agd2hpY2ggcHJldmVudHMgbWVtb3J5 IGZyb20gYWNjdW11bGF0aW5nIGJldHdlZW4gdXNlciBldmVudHMuCisgICAgLy8gRklYTUU6IFJl bW92ZSB3aGVuIDxyZGFyOi8vcHJvYmxlbS84OTI5NDI2PiBpcyBmaXhlZC4KKyAgICBbW05TQXBw bGljYXRpb24gc2hhcmVkQXBwbGljYXRpb25dIF9pbnN0YWxsQXV0b3JlbGVhc2VQb29sc09uQ3Vy cmVudFRocmVhZElmTmVjZXNzYXJ5XTsKKwogI2lmICFkZWZpbmVkKEJVSUxESU5HX09OX1NOT1df TEVPUEFSRCkKICAgICBXS0FYUmVnaXN0ZXJSZW1vdGVBcHAoKTsKICNlbmRpZgo=