48278 2010-10-25 16:45:38 -0700 Convert DumpRenderTree webarchive code to CoreFoundation 2010-10-27 08:43:49 -0700 1 1 1 Unclassified WebKit Web Inspector (Deprecated) 528+ (Nightly build) PC Windows XP RESOLVED FIXED P2 Normal --- 1 ddkilzer ddkilzer aestes aroben commit-queue zimmermann oldest_to_newest 299187 0 ddkilzer 2010-10-25 16:45:38 -0700 The current webarchive code in DumpRenderTree is written in Objective-C[++], which makes it impossible to share with the Windows port. Rewriting it to use CoreFoundation (CF) methods instead would make it cross-platform and reusable on Windows. Patches to be attached soon. 299194 1 71817 ddkilzer 2010-10-25 17:05:28 -0700 Created attachment 71817 Part 1: Extract call to -[WebHTMLRepresentation supportedNonImageMIMETypes] from WebArchiveDumpSupport.mm 299195 2 71818 ddkilzer 2010-10-25 17:06:18 -0700 Created attachment 71818 Part 2: Extract use of NSKeyedUnarchiver from WebArchiveDumpSupport.mm 299196 3 71819 ddkilzer 2010-10-25 17:06:54 -0700 Created attachment 71819 Part 3: Convert WebArchiveDumpSupport.mm from NS objects to CF types 299199 4 71820 ddkilzer 2010-10-25 17:07:56 -0700 Created attachment 71820 Part 4: Rename WebArchiveDumpSupport.mm to WebArchiveDumpSupport.cpp 299428 5 71819 aroben 2010-10-26 07:21:24 -0700 Comment on attachment 71819 Part 3: Convert WebArchiveDumpSupport.mm from NS objects to CF types View in context: https://bugs.webkit.org/attachment.cgi?id=71819&action=review > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.h:33 > +extern "C" { > +typedef struct _CFURLResponse* CFURLResponseRef; > +} I don't think extern "C" is needed for CF-style typedefs. At least, we don't normally use it for them. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.h:40 > -NSString *serializeWebArchiveToXML(WebArchive *webArchive); > +CFStringRef createXMLStringFromWebArchiveData(CFDataRef webArchiveData); > > #pragma mark - > #pragma mark Platform-specific methods > > -NSURLResponse *unarchiveNSURLResponseFromResponseData(NSData *responseData); > +CFURLResponseRef createCFURLResponseFromResponseData(CFDataRef responseData); Maybe these new functions should return RetainPtrs? > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:30 > +#import <JavaScriptCore/RetainPtr.h> Does <wtf/RetainPtr.h> not work in DRT? > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:48 > + if (CFStringCompare(mimeType, CFSTR("text/xml"), kCFCompareAnchored|kCFCompareCaseInsensitive) == kCFCompareEqualTo) I think you should mention the change to using a case-insensitive comparison in your ChangeLog. You also need spaces around the | operator. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:52 > + if (CFStringCompare(mimeType, CFSTR("application/x-javascript"), kCFCompareAnchored|kCFCompareCaseInsensitive) == kCFCompareEqualTo) Ditto. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:60 > + CFStringLowercase(mimeType, CFLocaleGetSystem()); > convertMIMEType(mimeType); Seems like you don't need to lowercase here, given that convertMIMEType is now case-insensitive. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:72 > + RetainPtr<CFStringRef> dataAsString(AdoptCF, CFStringCreateFromExternalRepresentation(NULL, data, stringEncoding)); Since this is C++ code, you should use 0 instead of NULL. (Though I think we may be moving toward always using kCFAllocatorDefault in this case.) > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:94 > - if ([fields objectForKey:@"Connection"]) > - [fields removeObjectForKey:@"Connection"]; > - if ([fields objectForKey:@"Keep-Alive"]) > - [fields removeObjectForKey:@"Keep-Alive"]; > + if (CFDictionaryContainsKey(fields, CFSTR("Connection"))) > + CFDictionaryRemoveValue(fields, CFSTR("Connection")); > + if (CFDictionaryContainsKey(fields, CFSTR("Keep-Alive"))) > + CFDictionaryRemoveValue(fields, CFSTR("Keep-Alive")); It's weird that we check for the presence of the keys before removing them. That shouldn't be necessary, right? > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:117 > + RetainPtr<CFMutableDictionaryRef> responseDictionary(AdoptCF, CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)); Same comment about NULL here (and elsewhere in this patch). > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:119 > - NSMutableString *urlString = [[[response URL] description] mutableCopy]; > - normalizeWebResourceURL(urlString); > - [responseDictionary setObject:urlString forKey:@"URL"]; > - [urlString release]; > + RetainPtr<CFMutableStringRef> urlString(AdoptCF, CFStringCreateMutableCopy(NULL, 0, CFURLGetString(CFURLResponseGetURL(response.get())))); What does -[NSURL description] return? Is that really the same as CFURLGetString? > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:132 > + SInt64 expectedContentLength = CFURLResponseGetExpectedContentLength(response.get()); > + RetainPtr<CFNumberRef> expectedContentLengthNumber(AdoptCF, CFNumberCreate(NULL, kCFNumberLongLongType, &expectedContentLength)); Seems like you should either be using "long long" or kCFNumberSInt64Type. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:142 > + CFIndex statusCode = CFHTTPMessageGetResponseStatusCode(httpMessage); > + RetainPtr<CFNumberRef> statusCodeNumber(AdoptCF, CFNumberCreate(NULL, kCFNumberLongType, &statusCode)); Seems like you should either be using "long" or kCFNumberCFIndexType. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:152 > + CFStringRef url1 = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)val1, CFSTR("WebResourceURL")); > + CFStringRef url2 = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)val2, CFSTR("WebResourceURL")); You could use static_cast here. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:166 > + return CFErrorCopyDescription(error); > + return CFSTR("An unknown error occurred converting data to property list."); Presumably you need to pass the result of CFSTR() through CFRetain before returning it to maintain the "create" semantics of this function. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:189 > + for (CFIndex i = 0; i < CFArrayGetCount(subresources); ++i) { It might be better to store the result of CFArrayGetCount in a local variable. > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:206 > + return CFErrorCopyDescription(error); > + return CFSTR("An unknown error occurred converting property list to data."); Same comment here about CFRetain. 299429 6 71820 aroben 2010-10-26 07:21:55 -0700 Comment on attachment 71820 Part 4: Rename WebArchiveDumpSupport.mm to WebArchiveDumpSupport.cpp View in context: https://bugs.webkit.org/attachment.cgi?id=71820&action=review > WebKitTools/ChangeLog:18 > + * DumpRenderTree/cf/WebArchiveDumpSupport.cpp: Renamed from DumpRenderTree/mac/WebArchiveDumpSupport.mm. > + (convertMIMEType): > + (convertWebResourceDataToString): > + (normalizeHTTPResponseHeaderFields): > + (normalizeWebResourceURL): > + (convertWebResourceResponseToDictionary): > + (compareResourceURLs): > + (createXMLStringFromWebArchiveData): I usually leave out function names when doing a file rename. 299976 7 ddkilzer 2010-10-26 21:41:36 -0700 (In reply to comment #5) > (From update of attachment 71819 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=71819&action=review > > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.h:33 > > +extern "C" { > > +typedef struct _CFURLResponse* CFURLResponseRef; > > +} > > I don't think extern "C" is needed for CF-style typedefs. At least, we don't normally use it for them. Will try removing it. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.h:40 > > -NSString *serializeWebArchiveToXML(WebArchive *webArchive); > > +CFStringRef createXMLStringFromWebArchiveData(CFDataRef webArchiveData); > > > > #pragma mark - > > #pragma mark Platform-specific methods > > > > -NSURLResponse *unarchiveNSURLResponseFromResponseData(NSData *responseData); > > +CFURLResponseRef createCFURLResponseFromResponseData(CFDataRef responseData); > > Maybe these new functions should return RetainPtrs? They currently follow the "create" rule for CoreFoundation memory management. I don't think PassRetainPtr<> exists. Won't returning a RetainPtr<> cause ref churn? (I realize it probably doesn't matter for DRT, but I would expect to use PassRetainPtr<> to pass an owning reference to a returning method.) > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:30 > > +#import <JavaScriptCore/RetainPtr.h> > > Does <wtf/RetainPtr.h> not work in DRT? Probably. I just got caught up in using the framework name in the #import statement. :) > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:48 > > + if (CFStringCompare(mimeType, CFSTR("text/xml"), kCFCompareAnchored|kCFCompareCaseInsensitive) == kCFCompareEqualTo) > > I think you should mention the change to using a case-insensitive comparison in your ChangeLog. You also need spaces around the | operator. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:52 > > + if (CFStringCompare(mimeType, CFSTR("application/x-javascript"), kCFCompareAnchored|kCFCompareCaseInsensitive) == kCFCompareEqualTo) > > Ditto. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:60 > > + CFStringLowercase(mimeType, CFLocaleGetSystem()); > > convertMIMEType(mimeType); > > Seems like you don't need to lowercase here, given that convertMIMEType is now case-insensitive. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:72 > > + RetainPtr<CFStringRef> dataAsString(AdoptCF, CFStringCreateFromExternalRepresentation(NULL, data, stringEncoding)); > > Since this is C++ code, you should use 0 instead of NULL. (Though I think we may be moving toward always using kCFAllocatorDefault in this case.) Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:94 > > - if ([fields objectForKey:@"Connection"]) > > - [fields removeObjectForKey:@"Connection"]; > > - if ([fields objectForKey:@"Keep-Alive"]) > > - [fields removeObjectForKey:@"Keep-Alive"]; > > + if (CFDictionaryContainsKey(fields, CFSTR("Connection"))) > > + CFDictionaryRemoveValue(fields, CFSTR("Connection")); > > + if (CFDictionaryContainsKey(fields, CFSTR("Keep-Alive"))) > > + CFDictionaryRemoveValue(fields, CFSTR("Keep-Alive")); > > It's weird that we check for the presence of the keys before removing them. That shouldn't be necessary, right? I was trying to prevent DRT from doing unnecessary work, but it may be more work to check first. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:117 > > + RetainPtr<CFMutableDictionaryRef> responseDictionary(AdoptCF, CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)); > > Same comment about NULL here (and elsewhere in this patch). Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:119 > > - NSMutableString *urlString = [[[response URL] description] mutableCopy]; > > - normalizeWebResourceURL(urlString); > > - [responseDictionary setObject:urlString forKey:@"URL"]; > > - [urlString release]; > > + RetainPtr<CFMutableStringRef> urlString(AdoptCF, CFStringCreateMutableCopy(NULL, 0, CFURLGetString(CFURLResponseGetURL(response.get())))); > > What does -[NSURL description] return? Is that really the same as CFURLGetString? -[NSURL description] returns an NSString of the URL. I probably should have used -absolueString instead. But CFURLGetString() returns an equivalent string. The webarchive tests continue to pass after this change. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:132 > > + SInt64 expectedContentLength = CFURLResponseGetExpectedContentLength(response.get()); > > + RetainPtr<CFNumberRef> expectedContentLengthNumber(AdoptCF, CFNumberCreate(NULL, kCFNumberLongLongType, &expectedContentLength)); > > Seems like you should either be using "long long" or kCFNumberSInt64Type. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:142 > > + CFIndex statusCode = CFHTTPMessageGetResponseStatusCode(httpMessage); > > + RetainPtr<CFNumberRef> statusCodeNumber(AdoptCF, CFNumberCreate(NULL, kCFNumberLongType, &statusCode)); > > Seems like you should either be using "long" or kCFNumberCFIndexType. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:152 > > + CFStringRef url1 = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)val1, CFSTR("WebResourceURL")); > > + CFStringRef url2 = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)val2, CFSTR("WebResourceURL")); > > You could use static_cast here. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:166 > > + return CFErrorCopyDescription(error); > > + return CFSTR("An unknown error occurred converting data to property list."); > > Presumably you need to pass the result of CFSTR() through CFRetain before returning it to maintain the "create" semantics of this function. I believe CFSTR("") in CF is like an @"" string in Cocoa. They are "constants" that never have a retain count of zero. I will add the CFRetain(). > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:189 > > + for (CFIndex i = 0; i < CFArrayGetCount(subresources); ++i) { > > It might be better to store the result of CFArrayGetCount in a local variable. Will fix. > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:206 > > + return CFErrorCopyDescription(error); > > + return CFSTR("An unknown error occurred converting property list to data."); > > Same comment here about CFRetain. Will fix. Thanks! 299977 8 ddkilzer 2010-10-26 21:42:03 -0700 (In reply to comment #6) > (From update of attachment 71820 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=71820&action=review > > > WebKitTools/ChangeLog:18 > > + * DumpRenderTree/cf/WebArchiveDumpSupport.cpp: Renamed from DumpRenderTree/mac/WebArchiveDumpSupport.mm. > > + (convertMIMEType): > > + (convertWebResourceDataToString): > > + (normalizeHTTPResponseHeaderFields): > > + (normalizeWebResourceURL): > > + (convertWebResourceResponseToDictionary): > > + (compareResourceURLs): > > + (createXMLStringFromWebArchiveData): > > I usually leave out function names when doing a file rename. Will fix. Thanks for the thorough review, Adam! 299989 9 ddkilzer 2010-10-26 22:05:58 -0700 (In reply to comment #5) > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:60 > > + CFStringLowercase(mimeType, CFLocaleGetSystem()); > > convertMIMEType(mimeType); > > Seems like you don't need to lowercase here, given that convertMIMEType is now case-insensitive. Later in the method I check if mimeType begins with "text/", so I do want CFStringLowercase() here. 299990 10 ddkilzer 2010-10-26 22:07:30 -0700 (In reply to comment #5) > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:72 > > + RetainPtr<CFStringRef> dataAsString(AdoptCF, CFStringCreateFromExternalRepresentation(NULL, data, stringEncoding)); > > Since this is C++ code, you should use 0 instead of NULL. (Though I think we may be moving toward always using kCFAllocatorDefault in this case.) BTW, why is that? Passing 0 or NULL gets you kCFAllocatorDefault regardless (per the documentation). 300004 11 ddkilzer 2010-10-26 22:30:38 -0700 Part 1: Committed r70611: <http://trac.webkit.org/changeset/70611> Part 2: Committed r70612: <http://trac.webkit.org/changeset/70612> Part 3: Committed r70613: <http://trac.webkit.org/changeset/70613> Part 4: Committed r70614: <http://trac.webkit.org/changeset/70614> 300068 12 zimmermann 2010-10-27 01:41:20 -0700 (In reply to comment #11) > Part 1: Committed r70611: <http://trac.webkit.org/changeset/70611> > Part 2: Committed r70612: <http://trac.webkit.org/changeset/70612> > Part 3: Committed r70613: <http://trac.webkit.org/changeset/70613> > Part 4: Committed r70614: <http://trac.webkit.org/changeset/70614> Hm, this broke Leopard. CFPropertyListCreateWithData is only "Available in Mac OS X v10.6 and later." 300077 13 71997 zimmermann 2010-10-27 02:20:51 -0700 Created attachment 71997 Fix Leopard build Verified this change works, by running run-webkit-tests webarchive on Leopard. 300078 14 71997 jorlow 2010-10-27 02:26:24 -0700 Comment on attachment 71997 Fix Leopard build build fix, so rubber stamp...would be nice if someone who knew this stuff better could look tho! 300079 15 71997 ddkilzer 2010-10-27 02:31:18 -0700 Comment on attachment 71997 Fix Leopard build View in context: https://bugs.webkit.org/attachment.cgi?id=71997&action=review Thanks for catching and fixing this, Nikolas! A couple nits below. r=me > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:159 > +#ifdef BUILDING_ON_LEOPARD Technically, this should be: #if defined(BUILDING_ON_TIGER) || defined(BUILDING_ON_LEOPARD) > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:161 > + CFReadStreamRef readStream = CFReadStreamCreateWithBytesNoCopy(kCFAllocatorDefault, CFDataGetBytePtr(webArchiveData), bytesCount, kCFAllocatorNull); Could use RetainPtr<> here: RetainPtr<CFReadStreamRef> readStream(AdoptCF, CFReadStreamCreateWithBytesNoCopy(...)); > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:162 > + CFReadStreamOpen(readStream); Then all references to readStream become readStream.get(). > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:165 > + CFRelease(readStream); This can be removed if RetainPtr<> is used. > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:209 > +#ifdef BUILDING_ON_LEOPARD Technically, this should be: #if defined(BUILDING_ON_TIGER) || defined(BUILDING_ON_LEOPARD) 300080 16 zimmermann 2010-10-27 02:38:49 -0700 (In reply to comment #15) > (From update of attachment 71997 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=71997&action=review > > Thanks for catching and fixing this, Nikolas! A couple nits below. r=me Thanks David for your prompt response, I thought you were asleep, and it was easy to fix, so I wanted to avoid a rollout :-) > > > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:159 > > +#ifdef BUILDING_ON_LEOPARD > > Technically, this should be: > > #if defined(BUILDING_ON_TIGER) || defined(BUILDING_ON_LEOPARD) Fixed. > > > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:161 > > + CFReadStreamRef readStream = CFReadStreamCreateWithBytesNoCopy(kCFAllocatorDefault, CFDataGetBytePtr(webArchiveData), bytesCount, kCFAllocatorNull); > > Could use RetainPtr<> here: > > RetainPtr<CFReadStreamRef> readStream(AdoptCF, CFReadStreamCreateWithBytesNoCopy(...)); Ah, that's the trick to avoid the manual release. > > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:162 > > + CFReadStreamOpen(readStream); > > Then all references to readStream become readStream.get(). Fixed. > > > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:165 > > + CFRelease(readStream); > > This can be removed if RetainPtr<> is used. Fixed. > > > WebKitTools/DumpRenderTree/cf/WebArchiveDumpSupport.cpp:209 > > +#ifdef BUILDING_ON_LEOPARD > > Technically, this should be: > > #if defined(BUILDING_ON_TIGER) || defined(BUILDING_ON_LEOPARD) Fixed, thanks for the review - landing soon! 300081 17 ddkilzer 2010-10-27 02:41:20 -0700 (In reply to comment #16) > (In reply to comment #15) > > (From update of attachment 71997 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=71997&action=review > > > > Thanks for catching and fixing this, Nikolas! A couple nits below. r=me > Thanks David for your prompt response, I thought you were asleep, and it was easy to fix, so I wanted to avoid a rollout :-) I was, but I sensed a disturbance in the Force. ;) 300082 18 zimmermann 2010-10-27 02:44:23 -0700 (In reply to comment #15) > (From update of attachment 71997 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=71997&action=review > > Thanks for catching and fixing this, Nikolas! A couple nits below. r=me I did another leaks run before landing, and I'm seeing leaks, not sure wheter they are also present on SnowLeopard using the other APIs. Going to post a log and wait for your comment. 300084 19 zimmermann 2010-10-27 02:50:54 -0700 (In reply to comment #18) > (In reply to comment #15) > > (From update of attachment 71997 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=71997&action=review > > > > Thanks for catching and fixing this, Nikolas! A couple nits below. r=me > > I did another leaks run before landing, and I'm seeing leaks, not sure wheter they are also present on SnowLeopard using the other APIs. Going to post a log and wait for your comment. Testing 26 test cases. webarchive ...................... webarchive/loading .... ? checking for leaks in DumpRenderTree + 1340 leaks (68576 bytes) were found, details in /tmp/layout-test-results/DumpRenderTree-leaks.txt Call stack: [thread 0xa0855720]: | 0x2 | start | main | dumpRenderTree(int, char const**) | __ZL20runTestingServerLoopv | __ZL7runTestRKSs | -[NSRunLoop(NSRunLoop) runMode:beforeDate:] | CFRunLoopRunInMode | CFRunLoopRunSpecific | MultiplexerSource::perform() | URLConnectionClient::processEvents() | URLConnectionClient::ClientConnectionEventQueue::processAllEventsAndConsumePayload(XConnectionEventInfo<XClientEvent, XClientEventParams>*, long) | URLConnectionClient::_clientDidFinishLoading(URLConnectionClient::ClientConnectionEventQueue*) | _NSURLConnectionDidFinishLoading | -[NSURLConnection(NSURLConnectionReallyInternal) sendDidFinishLoading] | -[WebCoreResourceHandleAsDelegate connectionDidFinishLoading:] | WebCore::ResourceLoader::didFinishLoading(WebCore::ResourceHandle*, double) | WebCore::MainResourceLoader::didFinishLoading(double) | WebCore::FrameLoader::finishedLoading() | WebCore::FrameLoader::checkLoadComplete() | WebCore::FrameLoader::recursiveCheckLoadComplete() | WebCore::FrameLoader::checkLoadCompleteForThisFrame() | WebFrameLoaderClient::dispatchDidFinishLoad() | CallFrameLoadDelegate(objc_object* (*)(objc_object*, objc_selector*, ...), WebView*, objc_selector*, objc_object*) | __ZL12CallDelegatePFP11objc_objectS0_P13objc_selectorzEP7WebViewS0_S2_S0_ | -[FrameLoadDelegate webView:didFinishLoadForFrame:] | -[FrameLoadDelegate webView:locationChangeDone:forDataSource:] | dump() | createXMLStringFromWebArchiveData(__CFData const*) | CFPropertyListCreateFromStream | _CFPropertyListCreateFromXMLData | __CFTryParseBinaryPlist | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | CFDataAppendBytes | CFDataReplaceBytes | __CFDataGrow | malloc_zone_realloc Leak: 0x90cc000 size=2048 string 'GIF89a4' Call stack: [thread 0xa0855720]: | 0x2 | start | main | dumpRenderTree(int, char const**) | __ZL20runTestingServerLoopv | __ZL7runTestRKSs | -[NSRunLoop(NSRunLoop) runMode:beforeDate:] | CFRunLoopRunInMode | CFRunLoopRunSpecific | __ZN7WebCoreL10timerFiredEP16__CFRunLoopTimerPv | WebCore::ThreadTimers::sharedTimerFired() | WebCore::ThreadTimers::sharedTimerFiredInternal() | WebCore::DOMTimer::fired() | WebCore::ScheduledAction::execute(WebCore::ScriptExecutionContext*) | WebCore::ScheduledAction::execute(WebCore::Document*) | WebCore::ScriptController::executeScriptInWorld(WebCore::DOMWrapperWorld*, WTF::String const&, bool, WebCore::ShouldAllowXSS) | WebCore::ScriptController::evaluateInWorld(WebCore::ScriptSourceCode const&, WebCore::DOMWrapperWorld*, WebCore::ShouldAllowXSS) | WebCore::JSMainThreadExecState::evaluate(JSC::ExecState*, JSC::ScopeChain&, JSC::SourceCode const&, JSC::JSValue) | JSC::evaluate(JSC::ExecState*, JSC::ScopeChain&, JSC::SourceCode const&, JSC::JSValue) | JSC::Interpreter::execute(JSC::ProgramExecutable*, JSC::ExecState*, JSC::ScopeChainNode*, JSC::JSObject*, JSC::JSValue*) | JSC::JITCode::execute(JSC::RegisterFile*, JSC::ExecState*, JSC::JSGlobalData*, JSC::JSValue*) | jscGeneratedNativeCode | cti_op_call_NotJSFunction | JSC::JSCallbackFunction::call(JSC::ExecState*) | __ZL18notifyDoneCallbackPK15OpaqueJSContextP13OpaqueJSValueS3_mPKPKS2_PS5_ | LayoutTestController::notifyDone() | dump() | createXMLStringFromWebArchiveData(__CFData const*) | CFPropertyListCreateFromStream | _CFPropertyListCreateFromXMLData | __CFTryParseBinaryPlist | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | CFDataAppendBytes | CFDataReplaceBytes | __CFDataGrow | malloc_zone_realloc It's always these two leaks. Does that ring a bell? I'm not familiar with CF at all unfortunately. 300087 20 71819 aroben 2010-10-27 02:58:57 -0700 Comment on attachment 71819 Part 3: Convert WebArchiveDumpSupport.mm from NS objects to CF types View in context: https://bugs.webkit.org/attachment.cgi?id=71819&action=review >>> WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.h:40 >>> +CFURLResponseRef createCFURLResponseFromResponseData(CFDataRef responseData); >> >> Maybe these new functions should return RetainPtrs? > > They currently follow the "create" rule for CoreFoundation memory management. > > I don't think PassRetainPtr<> exists. Won't returning a RetainPtr<> cause ref churn? (I realize it probably doesn't matter for DRT, but I would expect to use PassRetainPtr<> to pass an owning reference to a returning method.) Yeah, if we had PassRetainPtr that would be the best thing to use here. But, since we don't, RetainPtr is an OK alternative that we use in other places in WebKit like this. 300088 21 aroben 2010-10-27 02:59:38 -0700 (In reply to comment #10) > (In reply to comment #5) > > > WebKitTools/DumpRenderTree/mac/WebArchiveDumpSupport.mm:72 > > > + RetainPtr<CFStringRef> dataAsString(AdoptCF, CFStringCreateFromExternalRepresentation(NULL, data, stringEncoding)); > > > > Since this is C++ code, you should use 0 instead of NULL. (Though I think we may be moving toward always using kCFAllocatorDefault in this case.) > > BTW, why is that? Passing 0 or NULL gets you kCFAllocatorDefault regardless (per the documentation). I believe kCFAllocatorDefault is preferred because it is more explicit than passing 0, and thus hopefully clearer to readers. 300095 22 zimmermann 2010-10-27 03:13:48 -0700 (In reply to comment #19) > (In reply to comment #18) > > (In reply to comment #15) > > > (From update of attachment 71997 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=71997&action=review > > > > > > Thanks for catching and fixing this, Nikolas! A couple nits below. r=me > > > > I did another leaks run before landing, and I'm seeing leaks, not sure wheter they are also present on SnowLeopard using the other APIs. Going to post a log and wait for your comment. > > Testing 26 test cases. > webarchive ...................... > webarchive/loading .... > ? checking for leaks in DumpRenderTree > + 1340 leaks (68576 bytes) were found, details in /tmp/layout-test-results/DumpRenderTree-leaks.txt > > > Call stack: [thread 0xa0855720]: | 0x2 | start | main | dumpRenderTree(int, char const**) | __ZL20runTestingServerLoopv | __ZL7runTestRKSs | -[NSRunLoop(NSRunLoop) runMode:beforeDate:] | CFRunLoopRunInMode | CFRunLoopRunSpecific | MultiplexerSource::perform() | URLConnectionClient::processEvents() | URLConnectionClient::ClientConnectionEventQueue::processAllEventsAndConsumePayload(XConnectionEventInfo<XClientEvent, XClientEventParams>*, long) | URLConnectionClient::_clientDidFinishLoading(URLConnectionClient::ClientConnectionEventQueue*) | _NSURLConnectionDidFinishLoading | -[NSURLConnection(NSURLConnectionReallyInternal) sendDidFinishLoading] | -[WebCoreResourceHandleAsDelegate connectionDidFinishLoading:] | WebCore::ResourceLoader::didFinishLoading(WebCore::ResourceHandle*, double) | WebCore::MainResourceLoader::didFinishLoading(double) | WebCore::FrameLoader::finishedLoading() | WebCore::FrameLoader::checkLoadComplete() | WebCore::FrameLoader::recursiveCheckLoadComplete() | WebCore::FrameLoader::checkLoadCompleteForThisFrame() | WebFrameLoaderClient::dispatchDidFinishLoad() | CallFrameLoadDelegate(objc_object* (*)(objc_object*, objc_selector*, ...), WebView*, objc_selector*, objc_object*) | __ZL12CallDelegatePFP11objc_objectS0_P13objc_selectorzEP7WebViewS0_S2_S0_ | -[FrameLoadDelegate webView:didFinishLoadForFrame:] | -[FrameLoadDelegate webView:locationChangeDone:forDataSource:] | dump() | createXMLStringFromWebArchiveData(__CFData const*) | CFPropertyListCreateFromStream | _CFPropertyListCreateFromXMLData | __CFTryParseBinaryPlist | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | CFDataAppendBytes | CFDataReplaceBytes | __CFDataGrow | malloc_zone_realloc > Leak: 0x90cc000 size=2048 string 'GIF89a4' > Call stack: [thread 0xa0855720]: | 0x2 | start | main | dumpRenderTree(int, char const**) | __ZL20runTestingServerLoopv | __ZL7runTestRKSs | -[NSRunLoop(NSRunLoop) runMode:beforeDate:] | CFRunLoopRunInMode | CFRunLoopRunSpecific | __ZN7WebCoreL10timerFiredEP16__CFRunLoopTimerPv | WebCore::ThreadTimers::sharedTimerFired() | WebCore::ThreadTimers::sharedTimerFiredInternal() | WebCore::DOMTimer::fired() | WebCore::ScheduledAction::execute(WebCore::ScriptExecutionContext*) | WebCore::ScheduledAction::execute(WebCore::Document*) | WebCore::ScriptController::executeScriptInWorld(WebCore::DOMWrapperWorld*, WTF::String const&, bool, WebCore::ShouldAllowXSS) | WebCore::ScriptController::evaluateInWorld(WebCore::ScriptSourceCode const&, WebCore::DOMWrapperWorld*, WebCore::ShouldAllowXSS) | WebCore::JSMainThreadExecState::evaluate(JSC::ExecState*, JSC::ScopeChain&, JSC::SourceCode const&, JSC::JSValue) | JSC::evaluate(JSC::ExecState*, JSC::ScopeChain&, JSC::SourceCode const&, JSC::JSValue) | JSC::Interpreter::execute(JSC::ProgramExecutable*, JSC::ExecState*, JSC::ScopeChainNode*, JSC::JSObject*, JSC::JSValue*) | JSC::JITCode::execute(JSC::RegisterFile*, JSC::ExecState*, JSC::JSGlobalData*, JSC::JSValue*) | jscGeneratedNativeCode | cti_op_call_NotJSFunction | JSC::JSCallbackFunction::call(JSC::ExecState*) | __ZL18notifyDoneCallbackPK15OpaqueJSContextP13OpaqueJSValueS3_mPKPKS2_PS5_ | LayoutTestController::notifyDone() | dump() | createXMLStringFromWebArchiveData(__CFData const*) | CFPropertyListCreateFromStream | _CFPropertyListCreateFromXMLData | __CFTryParseBinaryPlist | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | CFDataAppendBytes | CFDataReplaceBytes | __CFDataGrow | malloc_zone_realloc > > It's always these two leaks. Does that ring a bell? I'm not familiar with CF at all unfortunately. Forgot to ask, shall I still land this patch? I think the leak is not my fault... 300096 23 zimmermann 2010-10-27 03:21:19 -0700 Hah, same leaks on Snow Leopard: http://build.webkit.org/results/SnowLeopard%20Intel%20Leaks/r70618%20(12096)/DumpRenderTree7-leaks.txt Going to land my patch, but it needs to be investigated. I think the CFValuesAppend is the problem, leaving this to Adam/David. 300097 24 zimmermann 2010-10-27 03:21:51 -0700 (In reply to comment #23) > Hah, same leaks on Snow Leopard: http://build.webkit.org/results/SnowLeopard%20Intel%20Leaks/r70618%20(12096)/DumpRenderTree7-leaks.txt > > Going to land my patch, but it needs to be investigated. > I think the CFValuesAppend is the problem, leaving this to Adam/David. Landed in r70629. Reopining bug, as the new code leaks. 300098 25 aroben 2010-10-27 03:23:42 -0700 (In reply to comment #19) > Call stack: [thread 0xa0855720]: | 0x2 | start | main | dumpRenderTree(int, char const**) | __ZL20runTestingServerLoopv | __ZL7runTestRKSs | -[NSRunLoop(NSRunLoop) runMode:beforeDate:] | CFRunLoopRunInMode | CFRunLoopRunSpecific | MultiplexerSource::perform() | URLConnectionClient::processEvents() | URLConnectionClient::ClientConnectionEventQueue::processAllEventsAndConsumePayload(XConnectionEventInfo<XClientEvent, XClientEventParams>*, long) | URLConnectionClient::_clientDidFinishLoading(URLConnectionClient::ClientConnectionEventQueue*) | _NSURLConnectionDidFinishLoading | -[NSURLConnection(NSURLConnectionReallyInternal) sendDidFinishLoading] | -[WebCoreResourceHandleAsDelegate connectionDidFinishLoading:] | WebCore::ResourceLoader::didFinishLoading(WebCore::ResourceHandle*, double) | WebCore::MainResourceLoader::didFinishLoading(double) | WebCore::FrameLoader::finishedLoading() | WebCore::FrameLoader::checkLoadComplete() | WebCore::FrameLoader::recursiveCheckLoadComplete() | WebCore::FrameLoader::checkLoadCompleteForThisFrame() | WebFrameLoaderClient::dispatchDidFinishLoad() | CallFrameLoadDelegate(objc_object* (*)(objc_object*, objc_selector*, ...), WebView*, objc_selector*, objc_object*) | __ZL12CallDelegatePFP11objc_objectS0_P13objc_selectorzEP7WebViewS0_S2_S0_ | -[FrameLoadDelegate webView:didFinishLoadForFrame:] | -[FrameLoadDelegate webView:locationChangeDone:forDataSource:] | dump() | createXMLStringFromWebArchiveData(__CFData const*) | CFPropertyListCreateFromStream | _CFPropertyListCreateFromXMLData | __CFTryParseBinaryPlist | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | __CFBinaryPlistCreateObject2 | CFDataAppendBytes | CFDataReplaceBytes | __CFDataGrow | malloc_zone_realloc Looks like we're leaking the whole property list. RetainPtr should fix this pretty easily. 300193 26 ddkilzer 2010-10-27 07:05:12 -0700 (In reply to comment #24) > (In reply to comment #23) > > Going to land my patch, but it needs to be investigated. > > I think the CFValuesAppend is the problem, leaving this to Adam/David. > > Landed in r70629. Reopining bug, as the new code leaks. Thanks! I'll look into the leak. (In reply to comment #25) > Looks like we're leaking the whole property list. RetainPtr should fix this pretty easily. Yikes. I wonder why I didn't use RetainPtr<> there?! Testing a patch now. 300205 27 72032 ddkilzer 2010-10-27 07:33:25 -0700 Created attachment 72032 Fix leak of CFMutableDictionaryRef in createXMLStringFromWebArchiveData() 300247 28 72032 commit-queue 2010-10-27 08:43:42 -0700 Comment on attachment 72032 Fix leak of CFMutableDictionaryRef in createXMLStringFromWebArchiveData() Clearing flags on attachment: 72032 Committed r70647: <http://trac.webkit.org/changeset/70647> 300248 29 commit-queue 2010-10-27 08:43:49 -0700 All reviewed patches have been landed. Closing bug. 71817 2010-10-25 17:05:28 -0700 2010-10-27 02:20:51 -0700 Part 1: Extract call to -[WebHTMLRepresentation supportedNonImageMIMETypes] from WebArchiveDumpSupport.mm bug-48278-20101025170527.patch text/plain 9318 ddkilzer ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA3M2JjOTdlNzE0YjliNzAyNmM0MTY1ZTk5MTUyNTA5ODQxNGNmMTE2Li40MTFmMzFl ZmI4MzQxM2ZjNmE3MTVkOWE3Y2FiODQ3Y2RhNWU4NWMzIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjcgQEAK KzIwMTAtMTAtMjUgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAg ICBFeHRyYWN0IGNhbGwgdG8gLVtXZWJIVE1MUmVwcmVzZW50YXRpb24gc3VwcG9ydGVkTm9uSW1h Z2VNSU1FVHlwZXNdIGZyb20gV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUGFydCAxIG9mIDQ6IDxodHRwOi8v d2Via2l0Lm9yZy9iLzQ4Mjc4PiBDb252ZXJ0IER1bXBSZW5kZXJUcmVlIHdlYmFyY2hpdmUgY29k ZSB0byBDb3JlRm91bmRhdGlvbgorCisgICAgICAgIFRoZSBjYWxsIHRvIC1bV2ViSFRNTFJlcHJl c2VudGF0aW9uIHN1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGVzXQorICAgICAgICBpcyBub3QgY3Jv c3MtcGxhdGZvcm0gYmV0d2VlbiBNYWMgYW5kIFdpbmRvd3MsIHNvIGV4dHJhY3QgaXQKKyAgICAg ICAgaW50byBhIHBsYXRmb3JtLXNwZWNpZmljIHNvdXJjZSBmaWxlLgorCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvRHVtcFJlbmRlclRyZWUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajogQWRk ZWQKKyAgICAgICAgV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tIHRvIHRoZSBwcm9qZWN0Lgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuaDoKKyAg ICAgICAgKHN1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGVzKTogQWRkZWQgZGVjbGFyYXRpb24uCisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5tbToKKyAg ICAgICAgKGNvbnZlcnRXZWJSZXNvdXJjZURhdGFUb1N0cmluZyk6IFJlcGxhY2VkIGNhbGwgdG8K KyAgICAgICAgLVtXZWJIVE1MUmVwcmVzZW50YXRpb24gc3VwcG9ydGVkTm9uSW1hZ2VNSU1FVHlw ZXNdIHdpdGgKKyAgICAgICAgc3VwcG9ydGVkTm9uSW1hZ2VNSU1FVHlwZXMoKS4KKyAgICAgICAg KiBEdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tOiBBZGRlZC4K KyAgICAgICAgKHN1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGVzKTogQWRkZWQuICBFeHRyYWN0ZWQg ZnJvbQorICAgICAgICBXZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0uCisKIDIwMTAtMTAtMjUgIEdh Ym9yIFJhcGNzYW55aSAgPHJnYWJvckBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgT2phbiBWYWZhaS4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0R1bXBSZW5kZXJUcmVlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmlu ZGV4IGY3ZDBmYTczNjA0M2Q5ZDRlYmUyZTEwMGUzY2NiNWEzNWZjYWI1MDcuLmMzZmYwNjI0MWY1 Y2MxNjI2YzkwYzFiNTM4MjA1MGE2Y2M5MzE4ZTkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL0R1bXBSZW5kZXJUcmVlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysr IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvRHVtcFJlbmRlclRyZWUueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvagpAQCAtNDgsNiArNDgsNyBAQAogCQkyOUNGQkEyRTEyMjczQTEwMDBCQzMw QzAgLyogQWNjZXNzaWJpbGl0eVRleHRNYXJrZXJNYWMubW0gaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSAyOUNGQkEyRDEyMjczQTEwMDBCQzMwQzAgLyogQWNj ZXNzaWJpbGl0eVRleHRNYXJrZXJNYWMubW0gKi87IH07CiAJCTM3MTNFREUyMTE1QkUxOTMwMDcw NTcyMCAvKiBDb2xvckJpdHMtQS5wbmcgaW4gQ29weSBGb250IEZpbGVzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDM3MTNFRERGMTE1QkUxNkYwMDcwNTcyMCAvKiBDb2xvckJp dHMtQS5wbmcgKi87IH07CiAJCTM3MTNFREUzMTE1QkUxOTMwMDcwNTcyMCAvKiBDb2xvckJpdHMu dHRmIGluIENvcHkgRm9udCBGaWxlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSAzNzEzRURFMDExNUJFMTZGMDA3MDU3MjAgLyogQ29sb3JCaXRzLnR0ZiAqLzsgfTsKKwkJNDQw NTkwNzExMjY4NDUzODAwQ0ZENDhEIC8qIFdlYkFyY2hpdmVEdW1wU3VwcG9ydE1hYy5tbSBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ0MDU5MDcwMTI2ODQ1 MzgwMENGRDQ4RCAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW0gKi87IH07CiAJCTQ0Mzc3 MzBFMTI1Q0JDMzYwMEFBRTAyQyAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0gaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NEE5OTc4MzBGQ0RFODY0MDA1 ODBGMTAgLyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tICovOyB9OwogCQk0NDM3NzMwRjEyNUNC QzREMDBBQUUwMkMgLyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0LmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA0NEE5OTc4MjBGQ0RFODY0MDA1ODBGMTAgLyog V2ViQXJjaGl2ZUR1bXBTdXBwb3J0LmggKi87IH07CiAJCTUxODVGNkIyMTA3MTRFMDcwMDdBQTM5 MyAvKiBIaXN0b3J5RGVsZWdhdGUubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA1MTg1RjY5RjEwNzE0QTU3MDA3QUEzOTMgLyogSGlzdG9yeURlbGVnYXRl Lm1tICovOyB9OwpAQCAtMjIzLDYgKzIyNCw3IEBACiAJCTM3NUYwOTc3MERBQzNDQjYwMEM4QjRF NSAvKiBXZWJLaXRXZWlnaHRXYXRjaGVyNzAwLnR0ZiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IGZpbGU7IG5hbWUgPSBXZWJLaXRXZWlnaHRXYXRjaGVy NzAwLnR0ZjsgcGF0aCA9IGZvbnRzL1dlYktpdFdlaWdodFdhdGNoZXI3MDAudHRmOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQkzNzVGMDk3ODBEQUMzQ0I2MDBDOEI0RTUgLyogV2ViS2l0 V2VpZ2h0V2F0Y2hlcjgwMC50dGYgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBmaWxlOyBuYW1lID0gV2ViS2l0V2VpZ2h0V2F0Y2hlcjgwMC50dGY7IHBh dGggPSBmb250cy9XZWJLaXRXZWlnaHRXYXRjaGVyODAwLnR0Zjsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJMzc1RjA5NzkwREFDM0NCNjAwQzhCNEU1IC8qIFdlYktpdFdlaWdodFdhdGNo ZXI5MDAudHRmICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBl ID0gZmlsZTsgbmFtZSA9IFdlYktpdFdlaWdodFdhdGNoZXI5MDAudHRmOyBwYXRoID0gZm9udHMv V2ViS2l0V2VpZ2h0V2F0Y2hlcjkwMC50dGY7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJ CTQ0MDU5MDcwMTI2ODQ1MzgwMENGRDQ4RCAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW0g Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IG5hbWUgPSBXZWJBcmNoaXZlRHVtcFN1 cHBvcnRNYWMubW07IHBhdGggPSBtYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0NEE5OTc4MjBGQ0RFODY0MDA1ODBGMTAgLyogV2Vi QXJjaGl2ZUR1bXBTdXBwb3J0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdl YkFyY2hpdmVEdW1wU3VwcG9ydC5oOyBwYXRoID0gbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk0NEE5OTc4MzBGQ0RFODY0MDA1ODBGMTAg LyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2Jq Y3BwOyBuYW1lID0gV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tOyBwYXRoID0gbWFjL1dlYkFyY2hp dmVEdW1wU3VwcG9ydC5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNTE4NUY2OUUx MDcxNEE1NzAwN0FBMzkzIC8qIEhpc3RvcnlEZWxlZ2F0ZS5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IG5hbWUgPSBIaXN0b3J5RGVsZWdhdGUuaDsgcGF0aCA9IG1hYy9IaXN0b3J5RGVsZWdh dGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTM2Niw2ICszNjgsNyBAQAogCQkJ CUE4RDc5Q0U5MEZDMjhCMkMwMDRBQzhGRSAvKiBEdW1wUmVuZGVyVHJlZUZpbGVEcmFnZ2luZ1Nv dXJjZS5tICovLAogCQkJCTQ0QTk5NzgyMEZDREU4NjQwMDU4MEYxMCAvKiBXZWJBcmNoaXZlRHVt cFN1cHBvcnQuaCAqLywKIAkJCQk0NEE5OTc4MzBGQ0RFODY0MDA1ODBGMTAgLyogV2ViQXJjaGl2 ZUR1bXBTdXBwb3J0Lm1tICovLAorCQkJCTQ0MDU5MDcwMTI2ODQ1MzgwMENGRDQ4RCAvKiBXZWJB cmNoaXZlRHVtcFN1cHBvcnRNYWMubW0gKi8sCiAJCQkJQkM5RDkwMjEwQzk3NDcyRDAwOTlBNEEz IC8qIFdvcmtRdWV1ZS5jcHAgKi8sCiAJCQkJQkM5RDkwMjIwQzk3NDcyRTAwOTlBNEEzIC8qIFdv cmtRdWV1ZS5oICovLAogCQkJCUJDOUQ5MDIzMEM5NzQ3MkUwMDk5QTRBMyAvKiBXb3JrUXVldWVJ dGVtLmggKi8sCkBAIC03ODMsNiArNzg2LDcgQEAKIAkJCQlCQ0ExOEI0OTBDOUIwMkM0MDAxMTQz NjkgLyogVGV4dElucHV0Q29udHJvbGxlci5tIGluIFNvdXJjZXMgKi8sCiAJCQkJQkNBMThCNkEw QzlCMDhDMjAwMTE0MzY5IC8qIFVJRGVsZWdhdGUubW0gaW4gU291cmNlcyAqLywKIAkJCQk0NDM3 NzMwRTEyNUNCQzM2MDBBQUUwMkMgLyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tIGluIFNvdXJj ZXMgKi8sCisJCQkJNDQwNTkwNzExMjY4NDUzODAwQ0ZENDhEIC8qIFdlYkFyY2hpdmVEdW1wU3Vw cG9ydE1hYy5tbSBpbiBTb3VyY2VzICovLAogCQkJCUJDOUQ5MDI0MEM5NzQ3MkUwMDk5QTRBMyAv KiBXb3JrUXVldWUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQkNBMThCMjYwQzlCMDE1QzAwMTE0 MzY5IC8qIFdvcmtRdWV1ZUl0ZW1NYWMubW0gaW4gU291cmNlcyAqLywKIAkJCQk1MTg1RjZCMjEw NzE0RTA3MDA3QUEzOTMgLyogSGlzdG9yeURlbGVnYXRlLm1tIGluIFNvdXJjZXMgKi8sCmRpZmYg LS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBw b3J0LmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBw b3J0LmgKaW5kZXggODY1NGRkNWUyZjViMmUxMTJkY2NiZDBlZjYwYzBmOTE2NmIyZjMxNy4uYWIw YjUzMDdhZmU0N2Q0NzQwOGVjMDA5ODIxZTY0N2VmYmI3ZmY2MiAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5oCisrKyBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuaApAQCAt MjYsOSArMjYsMTYgQEAKICNpZm5kZWYgV2ViQXJjaGl2ZUR1bXBTdXBwb3J0X2gKICNkZWZpbmUg V2ViQXJjaGl2ZUR1bXBTdXBwb3J0X2gKIAorI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVG b3VuZGF0aW9uLmg+CisKIEBjbGFzcyBOU1N0cmluZzsKIEBjbGFzcyBXZWJBcmNoaXZlOwogCiBO U1N0cmluZyAqc2VyaWFsaXplV2ViQXJjaGl2ZVRvWE1MKFdlYkFyY2hpdmUgKndlYkFyY2hpdmUp OwogCisjcHJhZ21hIG1hcmsgLQorI3ByYWdtYSBtYXJrIFBsYXRmb3JtLXNwZWNpZmljIG1ldGhv ZHMKKworQ0ZBcnJheVJlZiBzdXBwb3J0ZWROb25JbWFnZU1JTUVUeXBlcygpOworCiAjZW5kaWYg LyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0X2ggKi8KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0gYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tCmluZGV4IDZkOGUxN2Fh NDc5ZjBiMzU2MGYwY2ExOTUyMTliZjBjZGVlY2Q2MzEuLjg2MzJmZWNiZDBhNDI1MGFjZGZhMGI5 ZDRmOWNhOTQ5NTI0NTRiNzkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5tbQpAQCAtMjcsNyArMjcsNiBAQAogCiAj aW1wb3J0IDxGb3VuZGF0aW9uL0ZvdW5kYXRpb24uaD4KICNpbXBvcnQgPFdlYktpdC9XZWJBcmNo aXZlLmg+Ci0jaW1wb3J0IDxXZWJLaXQvV2ViSFRNTFJlcHJlc2VudGF0aW9uLmg+CiAKIHN0YXRp YyB2b2lkIGNvbnZlcnRNSU1FVHlwZShOU011dGFibGVTdHJpbmcgKm1pbWVUeXBlKQogewpAQCAt NDYsNyArNDUsNyBAQCBzdGF0aWMgdm9pZCBjb252ZXJ0V2ViUmVzb3VyY2VEYXRhVG9TdHJpbmco TlNNdXRhYmxlRGljdGlvbmFyeSAqcmVzb3VyY2UpCiAgICAgTlNNdXRhYmxlU3RyaW5nICptaW1l VHlwZSA9IFtyZXNvdXJjZSBvYmplY3RGb3JLZXk6QCJXZWJSZXNvdXJjZU1JTUVUeXBlIl07CiAg ICAgY29udmVydE1JTUVUeXBlKG1pbWVUeXBlKTsKIAotICAgIGlmIChbbWltZVR5cGUgaGFzUHJl Zml4OkAidGV4dC8iXSB8fCBbW1dlYkhUTUxSZXByZXNlbnRhdGlvbiBzdXBwb3J0ZWROb25JbWFn ZU1JTUVUeXBlc10gY29udGFpbnNPYmplY3Q6bWltZVR5cGVdKSB7CisgICAgaWYgKFttaW1lVHlw ZSBoYXNQcmVmaXg6QCJ0ZXh0LyJdIHx8IFsoTlNBcnJheSAqKXN1cHBvcnRlZE5vbkltYWdlTUlN RVR5cGVzKCkgY29udGFpbnNPYmplY3Q6bWltZVR5cGVdKSB7CiAgICAgICAgIE5TU3RyaW5nICp0 ZXh0RW5jb2RpbmdOYW1lID0gW3Jlc291cmNlIG9iamVjdEZvcktleTpAIldlYlJlc291cmNlVGV4 dEVuY29kaW5nTmFtZSJdOwogICAgICAgICBOU1N0cmluZ0VuY29kaW5nIHN0cmluZ0VuY29kaW5n OwogICAgICAgICBpZiAoW3RleHRFbmNvZGluZ05hbWUgbGVuZ3RoXSA+IDApCmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFj Lm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9y dE1hYy5tbQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5jMzk0OWU2YjVlNGYyYjg1Yzc5ZjhiYWMyNzNjMzdjNWYwM2Zk NjQ2Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1dl YkFyY2hpdmVEdW1wU3VwcG9ydE1hYy5tbQpAQCAtMCwwICsxLDMzIEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDEwIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuIAorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uIAorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElU UyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJ VFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwor ICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbXBv cnQgIldlYkFyY2hpdmVEdW1wU3VwcG9ydC5oIgorCisjaW1wb3J0IDxXZWJLaXQvV2ViSFRNTFJl cHJlc2VudGF0aW9uLmg+CisKK0NGQXJyYXlSZWYgc3VwcG9ydGVkTm9uSW1hZ2VNSU1FVHlwZXMo KQoreworICAgIHJldHVybiAoQ0ZBcnJheVJlZilbV2ViSFRNTFJlcHJlc2VudGF0aW9uIHN1cHBv cnRlZE5vbkltYWdlTUlNRVR5cGVzXTsKK30K 71818 2010-10-25 17:06:18 -0700 2010-10-27 02:20:51 -0700 Part 2: Extract use of NSKeyedUnarchiver from WebArchiveDumpSupport.mm bug-48278-20101025170617.patch text/plain 4807 ddkilzer ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA0MTFmMzFlZmI4MzQxM2ZjNmE3MTVkOWE3Y2FiODQ3Y2RhNWU4NWMzLi45MDIzMjk2 ZjU2MDU3ODg0N2I1ZGEwY2Y0ZTgxZWI3Yjg4OTg4OWY0IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMjggQEAK IDIwMTAtMTAtMjUgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KIAorICAgICAg ICBFeHRyYWN0IHVzZSBvZiBOU0tleWVkVW5hcmNoaXZlciBmcm9tIFdlYkFyY2hpdmVEdW1wU3Vw cG9ydC5tbQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFBhcnQgMiBvZiA0OiA8aHR0cDovL3dlYmtpdC5vcmcvYi80ODI3OD4gQ29udmVydCBEdW1wUmVu ZGVyVHJlZSB3ZWJhcmNoaXZlIGNvZGUgdG8gQ29yZUZvdW5kYXRpb24KKworICAgICAgICBUaGVy ZSBpcyBubyBlcXVpdmFsZW50IHRvIE5TS2V5ZWRVbmFyY2hpdmVyIGluIENvcmVGb3VuZGF0aW9u LAorICAgICAgICBzbyBleHRyYWN0IGl0IGludG8gYSBwbGF0Zm9ybS1zcGVjaWZpYyBzb3VyY2Ug ZmlsZS4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBv cnQuaDoKKyAgICAgICAgKHVuYXJjaGl2ZU5TVVJMUmVzcG9uc2VGcm9tUmVzcG9uc2VEYXRhKTog QWRkZWQgZGVjbGFyYXRpb24uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL1dlYkFyY2hp dmVEdW1wU3VwcG9ydC5tbToKKyAgICAgICAgKGNvbnZlcnRXZWJSZXNvdXJjZVJlc3BvbnNlVG9E aWN0aW9uYXJ5KTogRXh0cmFjdGVkIGNvZGUgdG8KKyAgICAgICAgdW5hcmNoaXZlTlNVUkxSZXNw b25zZUZyb21SZXNwb25zZURhdGEoKSBpbgorICAgICAgICBXZWJBcmNoaXZlRHVtcFN1cHBvcnRN YWMubW0uICBVcGRhdGVkIGxvZ2ljIHRvIHJldHVybiBlYXJseSBpZgorICAgICAgICBuaWwgaXMg cmV0dXJuZWQgZnJvbSB1bmFyY2hpdmVOU1VSTFJlc3BvbnNlRnJvbVJlc3BvbnNlRGF0YSgpLgor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW06 CisgICAgICAgICh1bmFyY2hpdmVOU1VSTFJlc3BvbnNlRnJvbVJlc3BvbnNlRGF0YSk6IEFkZGVk LiAgRXh0cmFjdGVkCisgICAgICAgIGNvZGUgZnJvbSBjb252ZXJ0V2ViUmVzb3VyY2VSZXNwb25z ZVRvRGljdGlvbmFyeSgpIGluCisgICAgICAgIFdlYkFyY2hpdmVEdW1wU3VwcG9ydC5tbS4KKwor MjAxMC0xMC0yNSAgRGF2aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBwbGUuY29tPgorCiAgICAgICAg IEV4dHJhY3QgY2FsbCB0byAtW1dlYkhUTUxSZXByZXNlbnRhdGlvbiBzdXBwb3J0ZWROb25JbWFn ZU1JTUVUeXBlc10gZnJvbSBXZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0KIAogICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuaAppbmRleCBhYjBiNTMwN2FmZTQ3ZDQ3 NDA4ZWMwMDk4MjFlNjQ3ZWZiYjdmZjYyLi42NmNkMzY5ZTQ0MGQyNThhM2U0ZDZkZDc4ZjA5ZDQx NGRiZjZkOWExIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2Vi QXJjaGl2ZUR1bXBTdXBwb3J0LmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFj L1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5oCkBAIC0yOCw3ICsyOCw5IEBACiAKICNpbmNsdWRlIDxD b3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgogCitAY2xhc3MgTlNEYXRhOwogQGNsYXNz IE5TU3RyaW5nOworQGNsYXNzIE5TVVJMUmVzcG9uc2U7CiBAY2xhc3MgV2ViQXJjaGl2ZTsKIAog TlNTdHJpbmcgKnNlcmlhbGl6ZVdlYkFyY2hpdmVUb1hNTChXZWJBcmNoaXZlICp3ZWJBcmNoaXZl KTsKQEAgLTM2LDYgKzM4LDcgQEAgTlNTdHJpbmcgKnNlcmlhbGl6ZVdlYkFyY2hpdmVUb1hNTChX ZWJBcmNoaXZlICp3ZWJBcmNoaXZlKTsKICNwcmFnbWEgbWFyayAtCiAjcHJhZ21hIG1hcmsgUGxh dGZvcm0tc3BlY2lmaWMgbWV0aG9kcwogCitOU1VSTFJlc3BvbnNlICp1bmFyY2hpdmVOU1VSTFJl c3BvbnNlRnJvbVJlc3BvbnNlRGF0YShOU0RhdGEgKnJlc3BvbnNlRGF0YSk7CiBDRkFycmF5UmVm IHN1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGVzKCk7CiAKICNlbmRpZiAvKiBXZWJBcmNoaXZlRHVt cFN1cHBvcnRfaCAqLwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFj L1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21h Yy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0KaW5kZXggODYzMmZlY2JkMGE0MjUwYWNkZmEwYjlk NGY5Y2E5NDk1MjQ1NGI3OS4uNGNkY2RlMjk4YTllMzI3MGYxMjczM2NhZGUxZDYzNTYyMWM0NDE2 MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1dlYkFyY2hpdmVE dW1wU3VwcG9ydC5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJj aGl2ZUR1bXBTdXBwb3J0Lm1tCkBAIC05MiwxNSArOTIsMTMgQEAgc3RhdGljIHZvaWQgbm9ybWFs aXplV2ViUmVzb3VyY2VVUkwoTlNNdXRhYmxlU3RyaW5nICp3ZWJSZXNvdXJjZVVSTCkKIAogc3Rh dGljIHZvaWQgY29udmVydFdlYlJlc291cmNlUmVzcG9uc2VUb0RpY3Rpb25hcnkoTlNNdXRhYmxl RGljdGlvbmFyeSAqcHJvcGVydHlMaXN0KQogewotICAgIE5TVVJMUmVzcG9uc2UgKnJlc3BvbnNl ID0gbmlsOwogICAgIE5TRGF0YSAqcmVzcG9uc2VEYXRhID0gW3Byb3BlcnR5TGlzdCBvYmplY3RG b3JLZXk6QCJXZWJSZXNvdXJjZVJlc3BvbnNlIl07IC8vIFdlYlJlc291cmNlUmVzcG9uc2VLZXkg aW4gV2ViUmVzb3VyY2UubQotICAgIGlmIChbcmVzcG9uc2VEYXRhIGlzS2luZE9mQ2xhc3M6W05T RGF0YSBjbGFzc11dKSB7Ci0gICAgICAgIC8vIERlY29kZSBOU1VSTFJlc3BvbnNlCi0gICAgICAg IE5TS2V5ZWRVbmFyY2hpdmVyICp1bmFyY2hpdmVyID0gW1tOU0tleWVkVW5hcmNoaXZlciBhbGxv Y10gaW5pdEZvclJlYWRpbmdXaXRoRGF0YTpyZXNwb25zZURhdGFdOwotICAgICAgICByZXNwb25z ZSA9IFt1bmFyY2hpdmVyIGRlY29kZU9iamVjdEZvcktleTpAIldlYlJlc291cmNlUmVzcG9uc2Ui XTsgLy8gV2ViUmVzb3VyY2VSZXNwb25zZUtleSBpbiBXZWJSZXNvdXJjZS5tCi0gICAgICAgIFt1 bmFyY2hpdmVyIGZpbmlzaERlY29kaW5nXTsKLSAgICAgICAgW3VuYXJjaGl2ZXIgcmVsZWFzZV07 Ci0gICAgfSAgICAgICAgCisgICAgaWYgKCFbcmVzcG9uc2VEYXRhIGlzS2luZE9mQ2xhc3M6W05T RGF0YSBjbGFzc11dKQorICAgICAgICByZXR1cm47CisKKyAgICBOU1VSTFJlc3BvbnNlICpyZXNw b25zZSA9IHVuYXJjaGl2ZU5TVVJMUmVzcG9uc2VGcm9tUmVzcG9uc2VEYXRhKHJlc3BvbnNlRGF0 YSk7CisgICAgaWYgKCFyZXNwb25zZSkKKyAgICAgICAgcmV0dXJuOwogCiAgICAgTlNNdXRhYmxl RGljdGlvbmFyeSAqcmVzcG9uc2VEaWN0aW9uYXJ5ID0gW1tOU011dGFibGVEaWN0aW9uYXJ5IGFs bG9jXSBpbml0XTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFj L1dlYkFyY2hpdmVEdW1wU3VwcG9ydE1hYy5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW0KaW5kZXggYzM5NDllNmI1ZTRmMmI4NWM3 OWY4YmFjMjczYzM3YzVmMDNmZDY0Ni4uNjBiMmU5NjUwZjMxMjQ1MTRkNjkwYmUwN2E0ZTM0NDhm NjdkMmJhZCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1dlYkFy Y2hpdmVEdW1wU3VwcG9ydE1hYy5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tCkBAIC0yNSw4ICsyNSwyMCBAQAogCiAjaW1w b3J0ICJXZWJBcmNoaXZlRHVtcFN1cHBvcnQuaCIKIAorI2ltcG9ydCA8Rm91bmRhdGlvbi9Gb3Vu ZGF0aW9uLmg+CisjaW1wb3J0IDxKYXZhU2NyaXB0Q29yZS9SZXRhaW5QdHIuaD4KICNpbXBvcnQg PFdlYktpdC9XZWJIVE1MUmVwcmVzZW50YXRpb24uaD4KIAorTlNVUkxSZXNwb25zZSAqdW5hcmNo aXZlTlNVUkxSZXNwb25zZUZyb21SZXNwb25zZURhdGEoTlNEYXRhICpyZXNwb25zZURhdGEpCit7 CisgICAgLy8gRGVjb2RlIE5TVVJMUmVzcG9uc2UKKyAgICBSZXRhaW5QdHI8TlNLZXllZFVuYXJj aGl2ZXI+IHVuYXJjaGl2ZXIoQWRvcHROUywgW1tOU0tleWVkVW5hcmNoaXZlciBhbGxvY10gaW5p dEZvclJlYWRpbmdXaXRoRGF0YTpyZXNwb25zZURhdGFdKTsKKyAgICBOU1VSTFJlc3BvbnNlICpy ZXNwb25zZSA9IFt1bmFyY2hpdmVyLmdldCgpIGRlY29kZU9iamVjdEZvcktleTpAIldlYlJlc291 cmNlUmVzcG9uc2UiXTsgLy8gV2ViUmVzb3VyY2VSZXNwb25zZUtleSBpbiBXZWJSZXNvdXJjZS5t CisgICAgW3VuYXJjaGl2ZXIuZ2V0KCkgZmluaXNoRGVjb2RpbmddOworCisgICAgcmV0dXJuIHJl c3BvbnNlOworfQorCiBDRkFycmF5UmVmIHN1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGVzKCkKIHsK ICAgICByZXR1cm4gKENGQXJyYXlSZWYpW1dlYkhUTUxSZXByZXNlbnRhdGlvbiBzdXBwb3J0ZWRO b25JbWFnZU1JTUVUeXBlc107Cg== 71819 2010-10-25 17:06:54 -0700 2010-10-27 02:58:57 -0700 Part 3: Convert WebArchiveDumpSupport.mm from NS objects to CF types bug-48278-20101025170653.patch text/plain 25674 ddkilzer ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA5MDIzMjk2ZjU2MDU3ODg0N2I1ZGEwY2Y0ZTgxZWI3Yjg4OTg4OWY0Li5iNDgzNDEw YzQ5ZDQ0YzgxMmUyYTQwYjFjNTg2MDliNWFlNTQ2Y2FiIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsNDIgQEAK IDIwMTAtMTAtMjUgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KIAorICAgICAg ICBDb252ZXJ0IFdlYkFyY2hpdmVEdW1wU3VwcG9ydC5tbSBmcm9tIE5TIG9iamVjdHMgdG8gQ0Yg dHlwZXMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBQ YXJ0IDMgb2YgNDogPGh0dHA6Ly93ZWJraXQub3JnL2IvNDgyNzg+IENvbnZlcnQgRHVtcFJlbmRl clRyZWUgd2ViYXJjaGl2ZSBjb2RlIHRvIENvcmVGb3VuZGF0aW9uCisKKyAgICAgICAgSW4gb3Jk ZXIgdG8gc2hhcmUgV2ViQXJjaGl2ZSBjb2RlIGJldHdlZW4gdGhlIE1hYyBhbmQgV2luZG93cwor ICAgICAgICBwb3J0cywgdGhlIGNvZGUgaW4gV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tIHdhcyBj b252ZXJ0ZWQgZnJvbQorICAgICAgICBDb2NvYSB0byBDKysgdXNpbmcgQ29yZUZvdW5kYXRpb24g KENGKSB0eXBlcy4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJl ZS5tbToKKyAgICAgICAgKGR1bXApOiBSZW5hbWVkIHNlcmlhbGl6ZVdlYkFyY2hpdmVUb1hNTCgp IHRvCisgICAgICAgIGNyZWF0ZVhNTFN0cmluZ0Zyb21XZWJBcmNoaXZlRGF0YSgpIGFuZCBhZGRl ZCBIYXJkQXV0b3JlbGVhc2UoKQorICAgICAgICB0byBwcmV2ZW50IGxlYWtzLgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuaDoKKyAgICAgICAgKGNy ZWF0ZVhNTFN0cmluZ0Zyb21XZWJBcmNoaXZlRGF0YSk6IFJlbmFtZWQgZnJvbQorICAgICAgICBz ZXJpYWxpemVXZWJBcmNoaXZlVG9YTUwoKS4gIENoYW5nZWQgdG8gdXNlIENGIHR5cGVzLgorICAg ICAgICAoY3JlYXRlQ0ZVUkxSZXNwb25zZUZyb21SZXNwb25zZURhdGEpOiBSZW5hbWVkIGZyb20K KyAgICAgICAgdW5hcmNoaXZlTlNVUkxSZXNwb25zZUZyb21SZXNwb25zZURhdGEoKS4gIENoYW5n ZWQgdG8gdXNlIENGCisgICAgICAgIHR5cGVzIGZvciBpdHMgcGFyYW1ldGVyIGFuZCByZXR1cm4g dHlwZS4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0 Lm1tOiBSZXBsYWNlZCB1c2Ugb2YKKyAgICAgICAgTlMgb2JqZWN0cyB3aXRoIENGIHR5cGVzLiAg SXQgd2lsbCBiZSByZW5hbWVkIHRvICouY3BwIGluIGEKKyAgICAgICAgZnV0dXJlIGNvbW1pdC4K KyAgICAgICAgKGNvbnZlcnRNSU1FVHlwZSk6CisgICAgICAgIChjb252ZXJ0V2ViUmVzb3VyY2VE YXRhVG9TdHJpbmcpOgorICAgICAgICAobm9ybWFsaXplSFRUUFJlc3BvbnNlSGVhZGVyRmllbGRz KToKKyAgICAgICAgKG5vcm1hbGl6ZVdlYlJlc291cmNlVVJMKToKKyAgICAgICAgKGNvbnZlcnRX ZWJSZXNvdXJjZVJlc3BvbnNlVG9EaWN0aW9uYXJ5KToKKyAgICAgICAgKGNvbXBhcmVSZXNvdXJj ZVVSTHMpOgorICAgICAgICAoY3JlYXRlWE1MU3RyaW5nRnJvbVdlYkFyY2hpdmVEYXRhKToKKyAg ICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tOgor ICAgICAgICAoY3JlYXRlQ0ZVUkxSZXNwb25zZUZyb21SZXNwb25zZURhdGEpOiBSZW5hbWVkIGZy b20KKyAgICAgICAgdW5hcmNoaXZlTlNVUkxSZXNwb25zZUZyb21SZXNwb25zZURhdGEoKS4gIENo YW5nZWQgdG8gdXNlIENGCisgICAgICAgIHR5cGVzIGZvciBpdHMgcGFyYW1ldGVyIGFuZCByZXR1 cm4gdHlwZS4KKworMjAxMC0xMC0yNSAgRGF2aWQgS2lsemVyICA8ZGRraWx6ZXJAYXBwbGUuY29t PgorCiAgICAgICAgIEV4dHJhY3QgdXNlIG9mIE5TS2V5ZWRVbmFyY2hpdmVyIGZyb20gV2ViQXJj aGl2ZUR1bXBTdXBwb3J0Lm1tCiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRy ZWUubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0K aW5kZXggNjg3NjVmNjE0NTFiODMxYWYzYTY4YzBlNmRhN2EyMmM5MzE1Y2E2Zi4uZWZkZjU0YTJh OTExMjI2YTdkODQwOWY1NmE0NWE5ODNmYmRiMzY5NyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQpAQCAtNTQsNiArNTQsNyBAQAogI2lt cG9ydCAiV29ya1F1ZXVlSXRlbS5oIgogI2ltcG9ydCA8Q2FyYm9uL0NhcmJvbi5oPgogI2ltcG9y dCA8Q29yZUZvdW5kYXRpb24vQ29yZUZvdW5kYXRpb24uaD4KKyNpbXBvcnQgPFdlYkNvcmUvRm91 bmRhdGlvbkV4dHJhcy5oPgogI2ltcG9ydCA8V2ViS2l0L0RPTUVsZW1lbnQuaD4KICNpbXBvcnQg PFdlYktpdC9ET01FeHRlbnNpb25zLmg+CiAjaW1wb3J0IDxXZWJLaXQvRE9NUmFuZ2UuaD4KQEAg LTkyMCwxMSArOTIxLDExIEBAIHZvaWQgZHVtcCgpCiAgICAgICAgICAgICByZXN1bHRNaW1lVHlw ZSA9IEAiYXBwbGljYXRpb24vcGRmIjsKICAgICAgICAgfSBlbHNlIGlmIChnTGF5b3V0VGVzdENv bnRyb2xsZXItPmR1bXBET01Bc1dlYkFyY2hpdmUoKSkgewogICAgICAgICAgICAgV2ViQXJjaGl2 ZSAqd2ViQXJjaGl2ZSA9IFtbbWFpbkZyYW1lIERPTURvY3VtZW50XSB3ZWJBcmNoaXZlXTsKLSAg ICAgICAgICAgIHJlc3VsdFN0cmluZyA9IHNlcmlhbGl6ZVdlYkFyY2hpdmVUb1hNTCh3ZWJBcmNo aXZlKTsKKyAgICAgICAgICAgIHJlc3VsdFN0cmluZyA9IEhhcmRBdXRvcmVsZWFzZShjcmVhdGVY TUxTdHJpbmdGcm9tV2ViQXJjaGl2ZURhdGEoKENGRGF0YVJlZilbd2ViQXJjaGl2ZSBkYXRhXSkp OwogICAgICAgICAgICAgcmVzdWx0TWltZVR5cGUgPSBAImFwcGxpY2F0aW9uL3gtd2ViYXJjaGl2 ZSI7CiAgICAgICAgIH0gZWxzZSBpZiAoZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1wU291cmNl QXNXZWJBcmNoaXZlKCkpIHsKICAgICAgICAgICAgIFdlYkFyY2hpdmUgKndlYkFyY2hpdmUgPSBb W21haW5GcmFtZSBkYXRhU291cmNlXSB3ZWJBcmNoaXZlXTsKLSAgICAgICAgICAgIHJlc3VsdFN0 cmluZyA9IHNlcmlhbGl6ZVdlYkFyY2hpdmVUb1hNTCh3ZWJBcmNoaXZlKTsKKyAgICAgICAgICAg IHJlc3VsdFN0cmluZyA9IEhhcmRBdXRvcmVsZWFzZShjcmVhdGVYTUxTdHJpbmdGcm9tV2ViQXJj aGl2ZURhdGEoKENGRGF0YVJlZilbd2ViQXJjaGl2ZSBkYXRhXSkpOwogICAgICAgICAgICAgcmVz dWx0TWltZVR5cGUgPSBAImFwcGxpY2F0aW9uL3gtd2ViYXJjaGl2ZSI7CiAgICAgICAgIH0gZWxz ZSB7CiAgICAgICAgICAgICBzaXplV2ViVmlld0ZvckN1cnJlbnRUZXN0KCk7CmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lmgg Yi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0LmgK aW5kZXggNjZjZDM2OWU0NDBkMjU4YTNlNGQ2ZGQ3OGYwOWQ0MTRkYmY2ZDlhMS4uMTQyODAxYzc4 NGJmYTc5NWE4M2IwOWUxZmEyOTkzMTQwMjI1Y2I5YiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5oCisrKyBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuaApAQCAtMjgsMTcg KzI4LDE2IEBACiAKICNpbmNsdWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgog Ci1AY2xhc3MgTlNEYXRhOwotQGNsYXNzIE5TU3RyaW5nOwotQGNsYXNzIE5TVVJMUmVzcG9uc2U7 Ci1AY2xhc3MgV2ViQXJjaGl2ZTsKK2V4dGVybiAiQyIgewordHlwZWRlZiBzdHJ1Y3QgX0NGVVJM UmVzcG9uc2UqIENGVVJMUmVzcG9uc2VSZWY7Cit9CiAKLU5TU3RyaW5nICpzZXJpYWxpemVXZWJB cmNoaXZlVG9YTUwoV2ViQXJjaGl2ZSAqd2ViQXJjaGl2ZSk7CitDRlN0cmluZ1JlZiBjcmVhdGVY TUxTdHJpbmdGcm9tV2ViQXJjaGl2ZURhdGEoQ0ZEYXRhUmVmIHdlYkFyY2hpdmVEYXRhKTsKIAog I3ByYWdtYSBtYXJrIC0KICNwcmFnbWEgbWFyayBQbGF0Zm9ybS1zcGVjaWZpYyBtZXRob2RzCiAK LU5TVVJMUmVzcG9uc2UgKnVuYXJjaGl2ZU5TVVJMUmVzcG9uc2VGcm9tUmVzcG9uc2VEYXRhKE5T RGF0YSAqcmVzcG9uc2VEYXRhKTsKK0NGVVJMUmVzcG9uc2VSZWYgY3JlYXRlQ0ZVUkxSZXNwb25z ZUZyb21SZXNwb25zZURhdGEoQ0ZEYXRhUmVmIHJlc3BvbnNlRGF0YSk7CiBDRkFycmF5UmVmIHN1 cHBvcnRlZE5vbkltYWdlTUlNRVR5cGVzKCk7CiAKICNlbmRpZiAvKiBXZWJBcmNoaXZlRHVtcFN1 cHBvcnRfaCAqLwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1dl YkFyY2hpdmVEdW1wU3VwcG9ydC5tbSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9X ZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0KaW5kZXggNGNkY2RlMjk4YTllMzI3MGYxMjczM2NhZGUx ZDYzNTYyMWM0NDE2My4uMTMyOTkwZjU2ZTQxMzVlNTAwYzM4OTk4MzU4ZDliOTk2Mzk4ZGE0MSAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1dlYkFyY2hpdmVEdW1w U3VwcG9ydC5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2 ZUR1bXBTdXBwb3J0Lm1tCkBAIC0yNSwxNzMgKzI1LDE5MiBAQAogCiAjaW1wb3J0ICJXZWJBcmNo aXZlRHVtcFN1cHBvcnQuaCIKIAotI2ltcG9ydCA8Rm91bmRhdGlvbi9Gb3VuZGF0aW9uLmg+Ci0j aW1wb3J0IDxXZWJLaXQvV2ViQXJjaGl2ZS5oPgorI2ltcG9ydCA8Q29yZUZvdW5kYXRpb24vQ29y ZUZvdW5kYXRpb24uaD4KKyNpbXBvcnQgPENGTmV0d29yay9DRk5ldHdvcmsuaD4KKyNpbXBvcnQg PEphdmFTY3JpcHRDb3JlL1JldGFpblB0ci5oPgogCi1zdGF0aWMgdm9pZCBjb252ZXJ0TUlNRVR5 cGUoTlNNdXRhYmxlU3RyaW5nICptaW1lVHlwZSkKK2V4dGVybiAiQyIgeworCitDRlVSTFJlZiBD RlVSTFJlc3BvbnNlR2V0VVJMKENGVVJMUmVzcG9uc2VSZWYgcmVzcG9uc2UpOworQ0ZTdHJpbmdS ZWYgQ0ZVUkxSZXNwb25zZUdldE1JTUVUeXBlKENGVVJMUmVzcG9uc2VSZWYgcmVzcG9uc2UpOwor Q0ZTdHJpbmdSZWYgQ0ZVUkxSZXNwb25zZUdldFRleHRFbmNvZGluZ05hbWUoQ0ZVUkxSZXNwb25z ZVJlZiByZXNwb25zZSk7CitTSW50NjQgQ0ZVUkxSZXNwb25zZUdldEV4cGVjdGVkQ29udGVudExl bmd0aChDRlVSTFJlc3BvbnNlUmVmIHJlc3BvbnNlKTsKK0NGSFRUUE1lc3NhZ2VSZWYgQ0ZVUkxS ZXNwb25zZUdldEhUVFBSZXNwb25zZShDRlVSTFJlc3BvbnNlUmVmIHJlc3BvbnNlKTsKKworQ0ZU eXBlSUQgQ0ZVUkxSZXNwb25zZUdldFR5cGVJRCh2b2lkKTsKKworfQorCitzdGF0aWMgdm9pZCBj b252ZXJ0TUlNRVR5cGUoQ0ZNdXRhYmxlU3RyaW5nUmVmIG1pbWVUeXBlKQogewogI2lmZGVmIEJV SUxESU5HX09OX0xFT1BBUkQKICAgICAvLyBXb3JrYXJvdW5kIGZvciA8cmRhcjovL3Byb2JsZW0v NTUzOTgyND4gb24gTGVvcGFyZAotICAgIGlmIChbbWltZVR5cGUgaXNFcXVhbFRvU3RyaW5nOkAi dGV4dC94bWwiXSkKLSAgICAgICAgW21pbWVUeXBlIHNldFN0cmluZzpAImFwcGxpY2F0aW9uL3ht bCJdOworICAgIGlmIChDRlN0cmluZ0NvbXBhcmUobWltZVR5cGUsIENGU1RSKCJ0ZXh0L3htbCIp LCBrQ0ZDb21wYXJlQW5jaG9yZWR8a0NGQ29tcGFyZUNhc2VJbnNlbnNpdGl2ZSkgPT0ga0NGQ29t cGFyZUVxdWFsVG8pCisgICAgICAgIENGU3RyaW5nUmVwbGFjZUFsbChtaW1lVHlwZSwgQ0ZTVFIo ImFwcGxpY2F0aW9uL3htbCIpKTsKICNlbmRpZgogICAgIC8vIFdvcmthcm91bmQgZm9yIDxyZGFy Oi8vcHJvYmxlbS82MjM0MzE4PiB3aXRoIERhc2hjb2RlIDIuMAotICAgIGlmIChbbWltZVR5cGUg aXNFcXVhbFRvU3RyaW5nOkAiYXBwbGljYXRpb24veC1qYXZhc2NyaXB0Il0pCi0gICAgICAgIFtt aW1lVHlwZSBzZXRTdHJpbmc6QCJ0ZXh0L2phdmFzY3JpcHQiXTsKKyAgICBpZiAoQ0ZTdHJpbmdD b21wYXJlKG1pbWVUeXBlLCBDRlNUUigiYXBwbGljYXRpb24veC1qYXZhc2NyaXB0IiksIGtDRkNv bXBhcmVBbmNob3JlZHxrQ0ZDb21wYXJlQ2FzZUluc2Vuc2l0aXZlKSA9PSBrQ0ZDb21wYXJlRXF1 YWxUbykKKyAgICAgICAgQ0ZTdHJpbmdSZXBsYWNlQWxsKG1pbWVUeXBlLCBDRlNUUigidGV4dC9q YXZhc2NyaXB0IikpOwogfQogCi1zdGF0aWMgdm9pZCBjb252ZXJ0V2ViUmVzb3VyY2VEYXRhVG9T dHJpbmcoTlNNdXRhYmxlRGljdGlvbmFyeSAqcmVzb3VyY2UpCitzdGF0aWMgdm9pZCBjb252ZXJ0 V2ViUmVzb3VyY2VEYXRhVG9TdHJpbmcoQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZiByZXNvdXJjZSkK IHsKLSAgICBOU011dGFibGVTdHJpbmcgKm1pbWVUeXBlID0gW3Jlc291cmNlIG9iamVjdEZvcktl eTpAIldlYlJlc291cmNlTUlNRVR5cGUiXTsKKyAgICBDRk11dGFibGVTdHJpbmdSZWYgbWltZVR5 cGUgPSAoQ0ZNdXRhYmxlU3RyaW5nUmVmKUNGRGljdGlvbmFyeUdldFZhbHVlKHJlc291cmNlLCBD RlNUUigiV2ViUmVzb3VyY2VNSU1FVHlwZSIpKTsKKyAgICBDRlN0cmluZ0xvd2VyY2FzZShtaW1l VHlwZSwgQ0ZMb2NhbGVHZXRTeXN0ZW0oKSk7CiAgICAgY29udmVydE1JTUVUeXBlKG1pbWVUeXBl KTsKIAotICAgIGlmIChbbWltZVR5cGUgaGFzUHJlZml4OkAidGV4dC8iXSB8fCBbKE5TQXJyYXkg KilzdXBwb3J0ZWROb25JbWFnZU1JTUVUeXBlcygpIGNvbnRhaW5zT2JqZWN0Om1pbWVUeXBlXSkg ewotICAgICAgICBOU1N0cmluZyAqdGV4dEVuY29kaW5nTmFtZSA9IFtyZXNvdXJjZSBvYmplY3RG b3JLZXk6QCJXZWJSZXNvdXJjZVRleHRFbmNvZGluZ05hbWUiXTsKLSAgICAgICAgTlNTdHJpbmdF bmNvZGluZyBzdHJpbmdFbmNvZGluZzsKLSAgICAgICAgaWYgKFt0ZXh0RW5jb2RpbmdOYW1lIGxl bmd0aF0gPiAwKQotICAgICAgICAgICAgc3RyaW5nRW5jb2RpbmcgPSBDRlN0cmluZ0NvbnZlcnRF bmNvZGluZ1RvTlNTdHJpbmdFbmNvZGluZyhDRlN0cmluZ0NvbnZlcnRJQU5BQ2hhclNldE5hbWVU b0VuY29kaW5nKChDRlN0cmluZ1JlZil0ZXh0RW5jb2RpbmdOYW1lKSk7CisgICAgQ0ZBcnJheVJl ZiBzdXBwb3J0ZWRNSU1FVHlwZXMgPSBzdXBwb3J0ZWROb25JbWFnZU1JTUVUeXBlcygpOworICAg IGlmIChDRlN0cmluZ0hhc1ByZWZpeChtaW1lVHlwZSwgQ0ZTVFIoInRleHQvIikpIHx8IENGQXJy YXlDb250YWluc1ZhbHVlKHN1cHBvcnRlZE1JTUVUeXBlcywgQ0ZSYW5nZU1ha2UoMCwgQ0ZBcnJh eUdldENvdW50KHN1cHBvcnRlZE1JTUVUeXBlcykpLCBtaW1lVHlwZSkpIHsKKyAgICAgICAgQ0ZT dHJpbmdSZWYgdGV4dEVuY29kaW5nTmFtZSA9IHN0YXRpY19jYXN0PENGU3RyaW5nUmVmPihDRkRp Y3Rpb25hcnlHZXRWYWx1ZShyZXNvdXJjZSwgQ0ZTVFIoIldlYlJlc291cmNlVGV4dEVuY29kaW5n TmFtZSIpKSk7CisgICAgICAgIENGU3RyaW5nRW5jb2Rpbmcgc3RyaW5nRW5jb2Rpbmc7CisgICAg ICAgIGlmICh0ZXh0RW5jb2RpbmdOYW1lICYmIENGU3RyaW5nR2V0TGVuZ3RoKHRleHRFbmNvZGlu Z05hbWUpKQorICAgICAgICAgICAgc3RyaW5nRW5jb2RpbmcgPSBDRlN0cmluZ0NvbnZlcnRJQU5B Q2hhclNldE5hbWVUb0VuY29kaW5nKHRleHRFbmNvZGluZ05hbWUpOwogICAgICAgICBlbHNlCi0g ICAgICAgICAgICBzdHJpbmdFbmNvZGluZyA9IE5TVVRGOFN0cmluZ0VuY29kaW5nOworICAgICAg ICAgICAgc3RyaW5nRW5jb2RpbmcgPSBrQ0ZTdHJpbmdFbmNvZGluZ1VURjg7CiAKLSAgICAgICAg TlNEYXRhICpkYXRhID0gW3Jlc291cmNlIG9iamVjdEZvcktleTpAIldlYlJlc291cmNlRGF0YSJd OwotICAgICAgICBOU1N0cmluZyAqZGF0YUFzU3RyaW5nID0gW1tOU1N0cmluZyBhbGxvY10gaW5p dFdpdGhEYXRhOmRhdGEgZW5jb2Rpbmc6c3RyaW5nRW5jb2RpbmddOworICAgICAgICBDRkRhdGFS ZWYgZGF0YSA9IHN0YXRpY19jYXN0PENGRGF0YVJlZj4oQ0ZEaWN0aW9uYXJ5R2V0VmFsdWUocmVz b3VyY2UsIENGU1RSKCJXZWJSZXNvdXJjZURhdGEiKSkpOworICAgICAgICBSZXRhaW5QdHI8Q0ZT dHJpbmdSZWY+IGRhdGFBc1N0cmluZyhBZG9wdENGLCBDRlN0cmluZ0NyZWF0ZUZyb21FeHRlcm5h bFJlcHJlc2VudGF0aW9uKE5VTEwsIGRhdGEsIHN0cmluZ0VuY29kaW5nKSk7CiAgICAgICAgIGlm IChkYXRhQXNTdHJpbmcpCi0gICAgICAgICAgICBbcmVzb3VyY2Ugc2V0T2JqZWN0OmRhdGFBc1N0 cmluZyBmb3JLZXk6QCJXZWJSZXNvdXJjZURhdGEiXTsKLSAgICAgICAgW2RhdGFBc1N0cmluZyBy ZWxlYXNlXTsKKyAgICAgICAgICAgIENGRGljdGlvbmFyeVNldFZhbHVlKHJlc291cmNlLCBDRlNU UigiV2ViUmVzb3VyY2VEYXRhIiksIGRhdGFBc1N0cmluZy5nZXQoKSk7CiAgICAgfQogfQogCi1z dGF0aWMgdm9pZCBub3JtYWxpemVIVFRQUmVzcG9uc2VIZWFkZXJGaWVsZHMoTlNNdXRhYmxlRGlj dGlvbmFyeSAqZmllbGRzKQorc3RhdGljIHZvaWQgbm9ybWFsaXplSFRUUFJlc3BvbnNlSGVhZGVy RmllbGRzKENGTXV0YWJsZURpY3Rpb25hcnlSZWYgZmllbGRzKQogewogICAgIC8vIE5vcm1hbGl6 ZSBoZWFkZXJzCi0gICAgaWYgKFtmaWVsZHMgb2JqZWN0Rm9yS2V5OkAiRGF0ZSJdKQotICAgICAg ICBbZmllbGRzIHNldE9iamVjdDpAIlN1biwgMTYgTm92IDIwMDggMTc6MDA6MDAgR01UIiBmb3JL ZXk6QCJEYXRlIl07Ci0gICAgaWYgKFtmaWVsZHMgb2JqZWN0Rm9yS2V5OkAiTGFzdC1Nb2RpZmll ZCJdKQotICAgICAgICBbZmllbGRzIHNldE9iamVjdDpAIlN1biwgMTYgTm92IDIwMDggMTY6NTU6 MDAgR01UIiBmb3JLZXk6QCJMYXN0LU1vZGlmaWVkIl07Ci0gICAgaWYgKFtmaWVsZHMgb2JqZWN0 Rm9yS2V5OkAiRXRhZyJdKQotICAgICAgICBbZmllbGRzIHNldE9iamVjdDpAIlwiMzAxOTI1LTIx LTQ1YzdkNzJkM2U3ODBcIiIgZm9yS2V5OkAiRXRhZyJdOwotICAgIGlmIChbZmllbGRzIG9iamVj dEZvcktleTpAIlNlcnZlciJdKQotICAgICAgICBbZmllbGRzIHNldE9iamVjdDpAIkFwYWNoZS8y LjIuOSAoVW5peCkgbW9kX3NzbC8yLjIuOSBPcGVuU1NMLzAuOS43bCBQSFAvNS4yLjYiIGZvcktl eTpAIlNlcnZlciJdOworICAgIGlmIChDRkRpY3Rpb25hcnlDb250YWluc0tleShmaWVsZHMsIENG U1RSKCJEYXRlIikpKQorICAgICAgICBDRkRpY3Rpb25hcnlTZXRWYWx1ZShmaWVsZHMsIENGU1RS KCJEYXRlIiksIENGU1RSKCJTdW4sIDE2IE5vdiAyMDA4IDE3OjAwOjAwIEdNVCIpKTsKKyAgICBp ZiAoQ0ZEaWN0aW9uYXJ5Q29udGFpbnNLZXkoZmllbGRzLCBDRlNUUigiTGFzdC1Nb2RpZmllZCIp KSkKKyAgICAgICAgQ0ZEaWN0aW9uYXJ5U2V0VmFsdWUoZmllbGRzLCBDRlNUUigiTGFzdC1Nb2Rp ZmllZCIpLCBDRlNUUigiU3VuLCAxNiBOb3YgMjAwOCAxNjo1NTowMCBHTVQiKSk7CisgICAgaWYg KENGRGljdGlvbmFyeUNvbnRhaW5zS2V5KGZpZWxkcywgQ0ZTVFIoIkV0YWciKSkpCisgICAgICAg IENGRGljdGlvbmFyeVNldFZhbHVlKGZpZWxkcywgQ0ZTVFIoIkV0YWciKSwgQ0ZTVFIoIlwiMzAx OTI1LTIxLTQ1YzdkNzJkM2U3ODBcIiIpKTsKKyAgICBpZiAoQ0ZEaWN0aW9uYXJ5Q29udGFpbnNL ZXkoZmllbGRzLCBDRlNUUigiU2VydmVyIikpKQorICAgICAgICBDRkRpY3Rpb25hcnlTZXRWYWx1 ZShmaWVsZHMsIENGU1RSKCJTZXJ2ZXIiKSwgQ0ZTVFIoIkFwYWNoZS8yLjIuOSAoVW5peCkgbW9k X3NzbC8yLjIuOSBPcGVuU1NMLzAuOS43bCBQSFAvNS4yLjYiKSk7CiAKICAgICAvLyBSZW1vdmUg aGVhZGVycwotICAgIGlmIChbZmllbGRzIG9iamVjdEZvcktleTpAIkNvbm5lY3Rpb24iXSkKLSAg ICAgICAgW2ZpZWxkcyByZW1vdmVPYmplY3RGb3JLZXk6QCJDb25uZWN0aW9uIl07Ci0gICAgaWYg KFtmaWVsZHMgb2JqZWN0Rm9yS2V5OkAiS2VlcC1BbGl2ZSJdKQotICAgICAgICBbZmllbGRzIHJl bW92ZU9iamVjdEZvcktleTpAIktlZXAtQWxpdmUiXTsKKyAgICBpZiAoQ0ZEaWN0aW9uYXJ5Q29u dGFpbnNLZXkoZmllbGRzLCBDRlNUUigiQ29ubmVjdGlvbiIpKSkKKyAgICAgICAgQ0ZEaWN0aW9u YXJ5UmVtb3ZlVmFsdWUoZmllbGRzLCBDRlNUUigiQ29ubmVjdGlvbiIpKTsKKyAgICBpZiAoQ0ZE aWN0aW9uYXJ5Q29udGFpbnNLZXkoZmllbGRzLCBDRlNUUigiS2VlcC1BbGl2ZSIpKSkKKyAgICAg ICAgQ0ZEaWN0aW9uYXJ5UmVtb3ZlVmFsdWUoZmllbGRzLCBDRlNUUigiS2VlcC1BbGl2ZSIpKTsK IH0KIAotc3RhdGljIHZvaWQgbm9ybWFsaXplV2ViUmVzb3VyY2VVUkwoTlNNdXRhYmxlU3RyaW5n ICp3ZWJSZXNvdXJjZVVSTCkKK3N0YXRpYyB2b2lkIG5vcm1hbGl6ZVdlYlJlc291cmNlVVJMKENG TXV0YWJsZVN0cmluZ1JlZiB3ZWJSZXNvdXJjZVVSTCkKIHsKLSAgICBzdGF0aWMgaW50IGZpbGVV cmxMZW5ndGggPSBbKE5TU3RyaW5nICopQCJmaWxlOi8vIiBsZW5ndGhdOwotICAgIE5TUmFuZ2Ug bGF5b3V0VGVzdHNXZWJBcmNoaXZlUGF0aFJhbmdlID0gW3dlYlJlc291cmNlVVJMIHJhbmdlT2ZT dHJpbmc6QCIvTGF5b3V0VGVzdHMvIiBvcHRpb25zOk5TQmFja3dhcmRzU2VhcmNoXTsKLSAgICBp ZiAobGF5b3V0VGVzdHNXZWJBcmNoaXZlUGF0aFJhbmdlLmxvY2F0aW9uID09IE5TTm90Rm91bmQp CisgICAgc3RhdGljIENGSW5kZXggZmlsZVVybExlbmd0aCA9IENGU3RyaW5nR2V0TGVuZ3RoKENG U1RSKCJmaWxlOi8vIikpOworICAgIENGUmFuZ2UgbGF5b3V0VGVzdHNXZWJBcmNoaXZlUGF0aFJh bmdlID0gQ0ZTdHJpbmdGaW5kKHdlYlJlc291cmNlVVJMLCBDRlNUUigiL0xheW91dFRlc3RzLyIp LCBrQ0ZDb21wYXJlQmFja3dhcmRzKTsKKyAgICBpZiAobGF5b3V0VGVzdHNXZWJBcmNoaXZlUGF0 aFJhbmdlLmxvY2F0aW9uID09IGtDRk5vdEZvdW5kKQogICAgICAgICByZXR1cm47Ci0gICAgTlNS YW5nZSBjdXJyZW50V29ya2luZ0RpcmVjdG9yeVJhbmdlID0gTlNNYWtlUmFuZ2UoZmlsZVVybExl bmd0aCwgbGF5b3V0VGVzdHNXZWJBcmNoaXZlUGF0aFJhbmdlLmxvY2F0aW9uIC0gZmlsZVVybExl bmd0aCk7Ci0gICAgW3dlYlJlc291cmNlVVJMIHJlcGxhY2VDaGFyYWN0ZXJzSW5SYW5nZTpjdXJy ZW50V29ya2luZ0RpcmVjdG9yeVJhbmdlIHdpdGhTdHJpbmc6QCIiXTsKKyAgICBDRlJhbmdlIGN1 cnJlbnRXb3JraW5nRGlyZWN0b3J5UmFuZ2UgPSBDRlJhbmdlTWFrZShmaWxlVXJsTGVuZ3RoLCBs YXlvdXRUZXN0c1dlYkFyY2hpdmVQYXRoUmFuZ2UubG9jYXRpb24gLSBmaWxlVXJsTGVuZ3RoKTsK KyAgICBDRlN0cmluZ1JlcGxhY2Uod2ViUmVzb3VyY2VVUkwsIGN1cnJlbnRXb3JraW5nRGlyZWN0 b3J5UmFuZ2UsIENGU1RSKCIiKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGNvbnZlcnRXZWJSZXNvdXJj ZVJlc3BvbnNlVG9EaWN0aW9uYXJ5KE5TTXV0YWJsZURpY3Rpb25hcnkgKnByb3BlcnR5TGlzdCkK K3N0YXRpYyB2b2lkIGNvbnZlcnRXZWJSZXNvdXJjZVJlc3BvbnNlVG9EaWN0aW9uYXJ5KENGTXV0 YWJsZURpY3Rpb25hcnlSZWYgcHJvcGVydHlMaXN0KQogewotICAgIE5TRGF0YSAqcmVzcG9uc2VE YXRhID0gW3Byb3BlcnR5TGlzdCBvYmplY3RGb3JLZXk6QCJXZWJSZXNvdXJjZVJlc3BvbnNlIl07 IC8vIFdlYlJlc291cmNlUmVzcG9uc2VLZXkgaW4gV2ViUmVzb3VyY2UubQotICAgIGlmICghW3Jl c3BvbnNlRGF0YSBpc0tpbmRPZkNsYXNzOltOU0RhdGEgY2xhc3NdXSkKKyAgICBDRkRhdGFSZWYg cmVzcG9uc2VEYXRhID0gc3RhdGljX2Nhc3Q8Q0ZEYXRhUmVmPihDRkRpY3Rpb25hcnlHZXRWYWx1 ZShwcm9wZXJ0eUxpc3QsIENGU1RSKCJXZWJSZXNvdXJjZVJlc3BvbnNlIikpKTsgLy8gV2ViUmVz b3VyY2VSZXNwb25zZUtleSBpbiBXZWJSZXNvdXJjZS5tCisgICAgaWYgKENGR2V0VHlwZUlEKHJl c3BvbnNlRGF0YSkgIT0gQ0ZEYXRhR2V0VHlwZUlEKCkpCiAgICAgICAgIHJldHVybjsKIAotICAg IE5TVVJMUmVzcG9uc2UgKnJlc3BvbnNlID0gdW5hcmNoaXZlTlNVUkxSZXNwb25zZUZyb21SZXNw b25zZURhdGEocmVzcG9uc2VEYXRhKTsKKyAgICBSZXRhaW5QdHI8Q0ZVUkxSZXNwb25zZVJlZj4g cmVzcG9uc2UoQWRvcHRDRiwgY3JlYXRlQ0ZVUkxSZXNwb25zZUZyb21SZXNwb25zZURhdGEocmVz cG9uc2VEYXRhKSk7CiAgICAgaWYgKCFyZXNwb25zZSkKICAgICAgICAgcmV0dXJuOwogCi0gICAg TlNNdXRhYmxlRGljdGlvbmFyeSAqcmVzcG9uc2VEaWN0aW9uYXJ5ID0gW1tOU011dGFibGVEaWN0 aW9uYXJ5IGFsbG9jXSBpbml0XTsKKyAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxlRGljdGlvbmFyeVJl Zj4gcmVzcG9uc2VEaWN0aW9uYXJ5KEFkb3B0Q0YsIENGRGljdGlvbmFyeUNyZWF0ZU11dGFibGUo TlVMTCwgMCwgJmtDRlR5cGVEaWN0aW9uYXJ5S2V5Q2FsbEJhY2tzLCAma0NGVHlwZURpY3Rpb25h cnlWYWx1ZUNhbGxCYWNrcykpOwogCi0gICAgTlNNdXRhYmxlU3RyaW5nICp1cmxTdHJpbmcgPSBb W1tyZXNwb25zZSBVUkxdIGRlc2NyaXB0aW9uXSBtdXRhYmxlQ29weV07Ci0gICAgbm9ybWFsaXpl V2ViUmVzb3VyY2VVUkwodXJsU3RyaW5nKTsKLSAgICBbcmVzcG9uc2VEaWN0aW9uYXJ5IHNldE9i amVjdDp1cmxTdHJpbmcgZm9yS2V5OkAiVVJMIl07Ci0gICAgW3VybFN0cmluZyByZWxlYXNlXTsK KyAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxlU3RyaW5nUmVmPiB1cmxTdHJpbmcoQWRvcHRDRiwgQ0ZT dHJpbmdDcmVhdGVNdXRhYmxlQ29weShOVUxMLCAwLCBDRlVSTEdldFN0cmluZyhDRlVSTFJlc3Bv bnNlR2V0VVJMKHJlc3BvbnNlLmdldCgpKSkpKTsKKyAgICBub3JtYWxpemVXZWJSZXNvdXJjZVVS TCh1cmxTdHJpbmcuZ2V0KCkpOworICAgIENGRGljdGlvbmFyeVNldFZhbHVlKHJlc3BvbnNlRGlj dGlvbmFyeS5nZXQoKSwgQ0ZTVFIoIlVSTCIpLCB1cmxTdHJpbmcuZ2V0KCkpOwogCi0gICAgTlNN dXRhYmxlU3RyaW5nICptaW1lVHlwZVN0cmluZyA9IFtbcmVzcG9uc2UgTUlNRVR5cGVdIG11dGFi bGVDb3B5XTsKLSAgICBjb252ZXJ0TUlNRVR5cGUobWltZVR5cGVTdHJpbmcpOwotICAgIFtyZXNw b25zZURpY3Rpb25hcnkgc2V0T2JqZWN0Om1pbWVUeXBlU3RyaW5nIGZvcktleTpAIk1JTUVUeXBl Il07Ci0gICAgW21pbWVUeXBlU3RyaW5nIHJlbGVhc2VdOworICAgIFJldGFpblB0cjxDRk11dGFi bGVTdHJpbmdSZWY+IG1pbWVUeXBlU3RyaW5nKEFkb3B0Q0YsIENGU3RyaW5nQ3JlYXRlTXV0YWJs ZUNvcHkoTlVMTCwgMCwgQ0ZVUkxSZXNwb25zZUdldE1JTUVUeXBlKHJlc3BvbnNlLmdldCgpKSkp OworICAgIGNvbnZlcnRNSU1FVHlwZShtaW1lVHlwZVN0cmluZy5nZXQoKSk7CisgICAgQ0ZEaWN0 aW9uYXJ5U2V0VmFsdWUocmVzcG9uc2VEaWN0aW9uYXJ5LmdldCgpLCBDRlNUUigiTUlNRVR5cGUi KSwgbWltZVR5cGVTdHJpbmcuZ2V0KCkpOwogCi0gICAgTlNTdHJpbmcgKnRleHRFbmNvZGluZ05h bWUgPSBbcmVzcG9uc2UgdGV4dEVuY29kaW5nTmFtZV07CisgICAgQ0ZTdHJpbmdSZWYgdGV4dEVu Y29kaW5nTmFtZSA9IENGVVJMUmVzcG9uc2VHZXRUZXh0RW5jb2RpbmdOYW1lKHJlc3BvbnNlLmdl dCgpKTsKICAgICBpZiAodGV4dEVuY29kaW5nTmFtZSkKLSAgICAgICAgW3Jlc3BvbnNlRGljdGlv bmFyeSBzZXRPYmplY3Q6dGV4dEVuY29kaW5nTmFtZSBmb3JLZXk6QCJ0ZXh0RW5jb2RpbmdOYW1l Il07Ci0gICAgW3Jlc3BvbnNlRGljdGlvbmFyeSBzZXRPYmplY3Q6W05TTnVtYmVyIG51bWJlcldp dGhMb25nTG9uZzpbcmVzcG9uc2UgZXhwZWN0ZWRDb250ZW50TGVuZ3RoXV0gZm9yS2V5OkAiZXhw ZWN0ZWRDb250ZW50TGVuZ3RoIl07CisgICAgICAgIENGRGljdGlvbmFyeVNldFZhbHVlKHJlc3Bv bnNlRGljdGlvbmFyeS5nZXQoKSwgQ0ZTVFIoInRleHRFbmNvZGluZ05hbWUiKSwgdGV4dEVuY29k aW5nTmFtZSk7CiAKLSAgICBpZiAoW3Jlc3BvbnNlIGlzS2luZE9mQ2xhc3M6W05TSFRUUFVSTFJl c3BvbnNlIGNsYXNzXV0pIHsKLSAgICAgICAgTlNIVFRQVVJMUmVzcG9uc2UgKmh0dHBSZXNwb25z ZSA9IChOU0hUVFBVUkxSZXNwb25zZSAqKXJlc3BvbnNlOworICAgIFNJbnQ2NCBleHBlY3RlZENv bnRlbnRMZW5ndGggPSBDRlVSTFJlc3BvbnNlR2V0RXhwZWN0ZWRDb250ZW50TGVuZ3RoKHJlc3Bv bnNlLmdldCgpKTsKKyAgICBSZXRhaW5QdHI8Q0ZOdW1iZXJSZWY+IGV4cGVjdGVkQ29udGVudExl bmd0aE51bWJlcihBZG9wdENGLCBDRk51bWJlckNyZWF0ZShOVUxMLCBrQ0ZOdW1iZXJMb25nTG9u Z1R5cGUsICZleHBlY3RlZENvbnRlbnRMZW5ndGgpKTsKKyAgICBDRkRpY3Rpb25hcnlTZXRWYWx1 ZShyZXNwb25zZURpY3Rpb25hcnkuZ2V0KCksIENGU1RSKCJleHBlY3RlZENvbnRlbnRMZW5ndGgi KSwgZXhwZWN0ZWRDb250ZW50TGVuZ3RoTnVtYmVyLmdldCgpKTsKIAotICAgICAgICBOU011dGFi bGVEaWN0aW9uYXJ5ICphbGxIZWFkZXJGaWVsZHMgPSBbW2h0dHBSZXNwb25zZSBhbGxIZWFkZXJG aWVsZHNdIG11dGFibGVDb3B5XTsKLSAgICAgICAgbm9ybWFsaXplSFRUUFJlc3BvbnNlSGVhZGVy RmllbGRzKGFsbEhlYWRlckZpZWxkcyk7Ci0gICAgICAgIFtyZXNwb25zZURpY3Rpb25hcnkgc2V0 T2JqZWN0OmFsbEhlYWRlckZpZWxkcyBmb3JLZXk6QCJhbGxIZWFkZXJGaWVsZHMiXTsKLSAgICAg ICAgW2FsbEhlYWRlckZpZWxkcyByZWxlYXNlXTsKKyAgICBpZiAoQ0ZIVFRQTWVzc2FnZVJlZiBo dHRwTWVzc2FnZSA9IENGVVJMUmVzcG9uc2VHZXRIVFRQUmVzcG9uc2UocmVzcG9uc2UuZ2V0KCkp KSB7CisgICAgICAgIFJldGFpblB0cjxDRkRpY3Rpb25hcnlSZWY+IGFsbEhlYWRlcnMoQWRvcHRD RiwgQ0ZIVFRQTWVzc2FnZUNvcHlBbGxIZWFkZXJGaWVsZHMoaHR0cE1lc3NhZ2UpKTsKKyAgICAg ICAgUmV0YWluUHRyPENGTXV0YWJsZURpY3Rpb25hcnlSZWY+IGFsbEhlYWRlckZpZWxkcyhBZG9w dENGLCBDRkRpY3Rpb25hcnlDcmVhdGVNdXRhYmxlQ29weShOVUxMLCAwLCBhbGxIZWFkZXJzLmdl dCgpKSk7CisgICAgICAgIG5vcm1hbGl6ZUhUVFBSZXNwb25zZUhlYWRlckZpZWxkcyhhbGxIZWFk ZXJGaWVsZHMuZ2V0KCkpOworICAgICAgICBDRkRpY3Rpb25hcnlTZXRWYWx1ZShyZXNwb25zZURp Y3Rpb25hcnkuZ2V0KCksIENGU1RSKCJhbGxIZWFkZXJGaWVsZHMiKSwgYWxsSGVhZGVyRmllbGRz LmdldCgpKTsKIAotICAgICAgICBbcmVzcG9uc2VEaWN0aW9uYXJ5IHNldE9iamVjdDpbTlNOdW1i ZXIgbnVtYmVyV2l0aEludDpbaHR0cFJlc3BvbnNlIHN0YXR1c0NvZGVdXSBmb3JLZXk6QCJzdGF0 dXNDb2RlIl07CisgICAgICAgIENGSW5kZXggc3RhdHVzQ29kZSA9IENGSFRUUE1lc3NhZ2VHZXRS ZXNwb25zZVN0YXR1c0NvZGUoaHR0cE1lc3NhZ2UpOworICAgICAgICBSZXRhaW5QdHI8Q0ZOdW1i ZXJSZWY+IHN0YXR1c0NvZGVOdW1iZXIoQWRvcHRDRiwgQ0ZOdW1iZXJDcmVhdGUoTlVMTCwga0NG TnVtYmVyTG9uZ1R5cGUsICZzdGF0dXNDb2RlKSk7CisgICAgICAgIENGRGljdGlvbmFyeVNldFZh bHVlKHJlc3BvbnNlRGljdGlvbmFyeS5nZXQoKSwgQ0ZTVFIoInN0YXR1c0NvZGUiKSwgc3RhdHVz Q29kZU51bWJlci5nZXQoKSk7CiAgICAgfQogCi0gICAgW3Byb3BlcnR5TGlzdCBzZXRPYmplY3Q6 cmVzcG9uc2VEaWN0aW9uYXJ5IGZvcktleTpAIldlYlJlc291cmNlUmVzcG9uc2UiXTsKLSAgICBb cmVzcG9uc2VEaWN0aW9uYXJ5IHJlbGVhc2VdOworICAgIENGRGljdGlvbmFyeVNldFZhbHVlKHBy b3BlcnR5TGlzdCwgQ0ZTVFIoIldlYlJlc291cmNlUmVzcG9uc2UiKSwgcmVzcG9uc2VEaWN0aW9u YXJ5LmdldCgpKTsKIH0KIAotc3RhdGljIE5TSW50ZWdlciBjb21wYXJlUmVzb3VyY2VVUkxzKGlk IHJlc291cmNlMSwgaWQgcmVzb3VyY2UyLCB2b2lkICpjb250ZXh0KQorc3RhdGljIENGQ29tcGFy aXNvblJlc3VsdCBjb21wYXJlUmVzb3VyY2VVUkxzKGNvbnN0IHZvaWQgKnZhbDEsIGNvbnN0IHZv aWQgKnZhbDIsIHZvaWQgKmNvbnRleHQpCiB7Ci0gICAgTlNTdHJpbmcgKnVybDEgPSBbcmVzb3Vy Y2UxIG9iamVjdEZvcktleTpAIldlYlJlc291cmNlVVJMIl07Ci0gICAgTlNTdHJpbmcgKnVybDIg PSBbcmVzb3VyY2UyIG9iamVjdEZvcktleTpAIldlYlJlc291cmNlVVJMIl07CisgICAgQ0ZTdHJp bmdSZWYgdXJsMSA9IChDRlN0cmluZ1JlZilDRkRpY3Rpb25hcnlHZXRWYWx1ZSgoQ0ZEaWN0aW9u YXJ5UmVmKXZhbDEsIENGU1RSKCJXZWJSZXNvdXJjZVVSTCIpKTsKKyAgICBDRlN0cmluZ1JlZiB1 cmwyID0gKENGU3RyaW5nUmVmKUNGRGljdGlvbmFyeUdldFZhbHVlKChDRkRpY3Rpb25hcnlSZWYp dmFsMiwgQ0ZTVFIoIldlYlJlc291cmNlVVJMIikpOwogIAotICAgIHJldHVybiBbdXJsMSBjb21w YXJlOnVybDJdOworICAgIHJldHVybiBDRlN0cmluZ0NvbXBhcmUodXJsMSwgdXJsMiwga0NGQ29t cGFyZUFuY2hvcmVkKTsKIH0KIAotTlNTdHJpbmcgKnNlcmlhbGl6ZVdlYkFyY2hpdmVUb1hNTChX ZWJBcmNoaXZlICp3ZWJBcmNoaXZlKQorQ0ZTdHJpbmdSZWYgY3JlYXRlWE1MU3RyaW5nRnJvbVdl YkFyY2hpdmVEYXRhKENGRGF0YVJlZiB3ZWJBcmNoaXZlRGF0YSkKIHsKLSAgICBOU1N0cmluZyAq ZXJyb3JTdHJpbmc7Ci0gICAgTlNNdXRhYmxlRGljdGlvbmFyeSAqcHJvcGVydHlMaXN0ID0gW05T UHJvcGVydHlMaXN0U2VyaWFsaXphdGlvbiBwcm9wZXJ0eUxpc3RGcm9tRGF0YTpbd2ViQXJjaGl2 ZSBkYXRhXQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIG11dGFiaWxpdHlPcHRpb246TlNQcm9wZXJ0eUxpc3RN dXRhYmxlQ29udGFpbmVyc0FuZExlYXZlcwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmb3Jt YXQ6TlVMTAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGVycm9yRGVzY3JpcHRpb246JmVycm9yU3RyaW5nXTsK LSAgICBpZiAoIXByb3BlcnR5TGlzdCkKLSAgICAgICAgcmV0dXJuIGVycm9yU3RyaW5nOwotCi0g ICAgTlNNdXRhYmxlQXJyYXkgKnJlc291cmNlcyA9IFtOU011dGFibGVBcnJheSBhcnJheVdpdGhD YXBhY2l0eToxXTsKLSAgICBbcmVzb3VyY2VzIGFkZE9iamVjdDpwcm9wZXJ0eUxpc3RdOwotCi0g ICAgd2hpbGUgKFtyZXNvdXJjZXMgY291bnRdKSB7Ci0gICAgICAgIE5TTXV0YWJsZURpY3Rpb25h cnkgKnJlc291cmNlUHJvcGVydHlMaXN0ID0gW3Jlc291cmNlcyBvYmplY3RBdEluZGV4OjBdOwot ICAgICAgICBbcmVzb3VyY2VzIHJlbW92ZU9iamVjdEF0SW5kZXg6MF07Ci0KLSAgICAgICAgTlNN dXRhYmxlRGljdGlvbmFyeSAqbWFpblJlc291cmNlID0gW3Jlc291cmNlUHJvcGVydHlMaXN0IG9i amVjdEZvcktleTpAIldlYk1haW5SZXNvdXJjZSJdOwotICAgICAgICBub3JtYWxpemVXZWJSZXNv dXJjZVVSTChbbWFpblJlc291cmNlIG9iamVjdEZvcktleTpAIldlYlJlc291cmNlVVJMIl0pOwor ICAgIENGRXJyb3JSZWYgZXJyb3IgPSBOVUxMOworICAgIENGUHJvcGVydHlMaXN0Rm9ybWF0IGZv cm1hdCA9IGtDRlByb3BlcnR5TGlzdEJpbmFyeUZvcm1hdF92MV8wOworICAgIENGTXV0YWJsZURp Y3Rpb25hcnlSZWYgcHJvcGVydHlMaXN0ID0gKENGTXV0YWJsZURpY3Rpb25hcnlSZWYpQ0ZQcm9w ZXJ0eUxpc3RDcmVhdGVXaXRoRGF0YShOVUxMLCB3ZWJBcmNoaXZlRGF0YSwga0NGUHJvcGVydHlM aXN0TXV0YWJsZUNvbnRhaW5lcnNBbmRMZWF2ZXMsICZmb3JtYXQsICZlcnJvcik7CisKKyAgICBp ZiAoIXByb3BlcnR5TGlzdCkgeworICAgICAgICBpZiAoZXJyb3IpCisgICAgICAgICAgICByZXR1 cm4gQ0ZFcnJvckNvcHlEZXNjcmlwdGlvbihlcnJvcik7CisgICAgICAgIHJldHVybiBDRlNUUigi QW4gdW5rbm93biBlcnJvciBvY2N1cnJlZCBjb252ZXJ0aW5nIGRhdGEgdG8gcHJvcGVydHkgbGlz dC4iKTsKKyAgICB9CisKKyAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxlQXJyYXlSZWY+IHJlc291cmNl cyhBZG9wdENGLCBDRkFycmF5Q3JlYXRlTXV0YWJsZShOVUxMLCAwLCAma0NGVHlwZUFycmF5Q2Fs bEJhY2tzKSk7CisgICAgQ0ZBcnJheUFwcGVuZFZhbHVlKHJlc291cmNlcy5nZXQoKSwgcHJvcGVy dHlMaXN0KTsKKworICAgIHdoaWxlIChDRkFycmF5R2V0Q291bnQocmVzb3VyY2VzLmdldCgpKSkg eworICAgICAgICBSZXRhaW5QdHI8Q0ZNdXRhYmxlRGljdGlvbmFyeVJlZj4gcmVzb3VyY2VQcm9w ZXJ0eUxpc3QgPSAoQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZilDRkFycmF5R2V0VmFsdWVBdEluZGV4 KHJlc291cmNlcy5nZXQoKSwgMCk7CisgICAgICAgIENGQXJyYXlSZW1vdmVWYWx1ZUF0SW5kZXgo cmVzb3VyY2VzLmdldCgpLCAwKTsKKworICAgICAgICBDRk11dGFibGVEaWN0aW9uYXJ5UmVmIG1h aW5SZXNvdXJjZSA9IChDRk11dGFibGVEaWN0aW9uYXJ5UmVmKUNGRGljdGlvbmFyeUdldFZhbHVl KHJlc291cmNlUHJvcGVydHlMaXN0LmdldCgpLCBDRlNUUigiV2ViTWFpblJlc291cmNlIikpOwor ICAgICAgICBub3JtYWxpemVXZWJSZXNvdXJjZVVSTCgoQ0ZNdXRhYmxlU3RyaW5nUmVmKUNGRGlj dGlvbmFyeUdldFZhbHVlKG1haW5SZXNvdXJjZSwgQ0ZTVFIoIldlYlJlc291cmNlVVJMIikpKTsK ICAgICAgICAgY29udmVydFdlYlJlc291cmNlRGF0YVRvU3RyaW5nKG1haW5SZXNvdXJjZSk7CiAK ICAgICAgICAgLy8gQWRkIHN1YmZyYW1lQXJjaGl2ZXMgdG8gbGlzdCBmb3IgcHJvY2Vzc2luZwot ICAgICAgICBOU011dGFibGVBcnJheSAqc3ViZnJhbWVBcmNoaXZlcyA9IFtyZXNvdXJjZVByb3Bl cnR5TGlzdCBvYmplY3RGb3JLZXk6QCJXZWJTdWJmcmFtZUFyY2hpdmVzIl07IC8vIFdlYlN1YmZy YW1lQXJjaGl2ZXNLZXkgaW4gV2ViQXJjaGl2ZS5tCisgICAgICAgIENGTXV0YWJsZUFycmF5UmVm IHN1YmZyYW1lQXJjaGl2ZXMgPSAoQ0ZNdXRhYmxlQXJyYXlSZWYpQ0ZEaWN0aW9uYXJ5R2V0VmFs dWUocmVzb3VyY2VQcm9wZXJ0eUxpc3QuZ2V0KCksIENGU1RSKCJXZWJTdWJmcmFtZUFyY2hpdmVz IikpOyAvLyBXZWJTdWJmcmFtZUFyY2hpdmVzS2V5IGluIFdlYkFyY2hpdmUubQogICAgICAgICBp ZiAoc3ViZnJhbWVBcmNoaXZlcykKLSAgICAgICAgICAgIFtyZXNvdXJjZXMgYWRkT2JqZWN0c0Zy b21BcnJheTpzdWJmcmFtZUFyY2hpdmVzXTsKKyAgICAgICAgICAgIENGQXJyYXlBcHBlbmRBcnJh eShyZXNvdXJjZXMuZ2V0KCksIHN1YmZyYW1lQXJjaGl2ZXMsIENGUmFuZ2VNYWtlKDAsIENGQXJy YXlHZXRDb3VudChzdWJmcmFtZUFyY2hpdmVzKSkpOwogCi0gICAgICAgIE5TTXV0YWJsZUFycmF5 ICpzdWJyZXNvdXJjZXMgPSBbcmVzb3VyY2VQcm9wZXJ0eUxpc3Qgb2JqZWN0Rm9yS2V5OkAiV2Vi U3VicmVzb3VyY2VzIl07IC8vIFdlYlN1YnJlc291cmNlc0tleSBpbiBXZWJBcmNoaXZlLm0KLSAg ICAgICAgTlNFbnVtZXJhdG9yICplbnVtZXJhdG9yID0gW3N1YnJlc291cmNlcyBvYmplY3RFbnVt ZXJhdG9yXTsKLSAgICAgICAgTlNNdXRhYmxlRGljdGlvbmFyeSAqc3VicmVzb3VyY2VQcm9wZXJ0 eUxpc3Q7Ci0gICAgICAgIHdoaWxlICgoc3VicmVzb3VyY2VQcm9wZXJ0eUxpc3QgPSBbZW51bWVy YXRvciBuZXh0T2JqZWN0XSkpIHsKLSAgICAgICAgICAgIG5vcm1hbGl6ZVdlYlJlc291cmNlVVJM KFtzdWJyZXNvdXJjZVByb3BlcnR5TGlzdCBvYmplY3RGb3JLZXk6QCJXZWJSZXNvdXJjZVVSTCJd KTsKKyAgICAgICAgQ0ZNdXRhYmxlQXJyYXlSZWYgc3VicmVzb3VyY2VzID0gKENGTXV0YWJsZUFy cmF5UmVmKUNGRGljdGlvbmFyeUdldFZhbHVlKHJlc291cmNlUHJvcGVydHlMaXN0LmdldCgpLCBD RlNUUigiV2ViU3VicmVzb3VyY2VzIikpOyAvLyBXZWJTdWJyZXNvdXJjZXNLZXkgaW4gV2ViQXJj aGl2ZS5tCisgICAgICAgIGlmICghc3VicmVzb3VyY2VzKQorICAgICAgICAgICAgY29udGludWU7 CisKKyAgICAgICAgZm9yIChDRkluZGV4IGkgPSAwOyBpIDwgQ0ZBcnJheUdldENvdW50KHN1YnJl c291cmNlcyk7ICsraSkgeworICAgICAgICAgICAgQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZiBzdWJy ZXNvdXJjZVByb3BlcnR5TGlzdCA9IChDRk11dGFibGVEaWN0aW9uYXJ5UmVmKUNGQXJyYXlHZXRW YWx1ZUF0SW5kZXgoc3VicmVzb3VyY2VzLCBpKTsKKyAgICAgICAgICAgIG5vcm1hbGl6ZVdlYlJl c291cmNlVVJMKChDRk11dGFibGVTdHJpbmdSZWYpQ0ZEaWN0aW9uYXJ5R2V0VmFsdWUoc3VicmVz b3VyY2VQcm9wZXJ0eUxpc3QsIENGU1RSKCJXZWJSZXNvdXJjZVVSTCIpKSk7CiAgICAgICAgICAg ICBjb252ZXJ0V2ViUmVzb3VyY2VSZXNwb25zZVRvRGljdGlvbmFyeShzdWJyZXNvdXJjZVByb3Bl cnR5TGlzdCk7CiAgICAgICAgICAgICBjb252ZXJ0V2ViUmVzb3VyY2VEYXRhVG9TdHJpbmcoc3Vi cmVzb3VyY2VQcm9wZXJ0eUxpc3QpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIC8v IFNvcnQgdGhlIHN1YnJlc291cmNlcyBzbyB0aGV5J3JlIGFsd2F5cyBpbiBhIHByZWRpY3RhYmxl IG9yZGVyIGZvciB0aGUgZHVtcAotICAgICAgICBpZiAoTlNBcnJheSAqc29ydGVkU3VicmVzb3Vy Y2VzID0gW3N1YnJlc291cmNlcyBzb3J0ZWRBcnJheVVzaW5nRnVuY3Rpb246Y29tcGFyZVJlc291 cmNlVVJMcyBjb250ZXh0Om5pbF0pCi0gICAgICAgICAgICBbcmVzb3VyY2VQcm9wZXJ0eUxpc3Qg c2V0T2JqZWN0OnNvcnRlZFN1YnJlc291cmNlcyBmb3JLZXk6QCJXZWJTdWJyZXNvdXJjZXMiXTsK KyAgICAgICAgQ0ZBcnJheVNvcnRWYWx1ZXMoc3VicmVzb3VyY2VzLCBDRlJhbmdlTWFrZSgwLCBD RkFycmF5R2V0Q291bnQoc3VicmVzb3VyY2VzKSksIGNvbXBhcmVSZXNvdXJjZVVSTHMsIE5VTEwp OwogICAgIH0KIAotICAgIE5TRGF0YSAqeG1sRGF0YSA9IFtOU1Byb3BlcnR5TGlzdFNlcmlhbGl6 YXRpb24gZGF0YUZyb21Qcm9wZXJ0eUxpc3Q6cHJvcGVydHlMaXN0Ci0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZvcm1hdDpO U1Byb3BlcnR5TGlzdFhNTEZvcm1hdF92MV8wCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZXJyb3JEZXNjcmlwdGlvbjomZXJyb3JTdHJpbmdd OwotICAgIGlmICgheG1sRGF0YSkKLSAgICAgICAgcmV0dXJuIGVycm9yU3RyaW5nOworICAgIGVy cm9yID0gTlVMTDsKKyAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiB4bWxEYXRhKEFkb3B0Q0YsIENG UHJvcGVydHlMaXN0Q3JlYXRlRGF0YShOVUxMLCBwcm9wZXJ0eUxpc3QsIGtDRlByb3BlcnR5TGlz dFhNTEZvcm1hdF92MV8wLCAwLCAmZXJyb3IpKTsKIAotICAgIE5TTXV0YWJsZVN0cmluZyAqc3Ry aW5nID0gW1tbTlNNdXRhYmxlU3RyaW5nIGFsbG9jXSBpbml0V2l0aERhdGE6eG1sRGF0YSBlbmNv ZGluZzpOU1VURjhTdHJpbmdFbmNvZGluZ10gYXV0b3JlbGVhc2VdOworICAgIGlmICgheG1sRGF0 YSkgeworICAgICAgICBpZiAoZXJyb3IpCisgICAgICAgICAgICByZXR1cm4gQ0ZFcnJvckNvcHlE ZXNjcmlwdGlvbihlcnJvcik7CisgICAgICAgIHJldHVybiBDRlNUUigiQW4gdW5rbm93biBlcnJv ciBvY2N1cnJlZCBjb252ZXJ0aW5nIHByb3BlcnR5IGxpc3QgdG8gZGF0YS4iKTsKKyAgICB9CisK KyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHhtbFN0cmluZyhBZG9wdENGLCBDRlN0cmluZ0Ny ZWF0ZUZyb21FeHRlcm5hbFJlcHJlc2VudGF0aW9uKE5VTEwsIHhtbERhdGEuZ2V0KCksIGtDRlN0 cmluZ0VuY29kaW5nVVRGOCkpOworICAgIFJldGFpblB0cjxDRk11dGFibGVTdHJpbmdSZWY+IHN0 cmluZyhBZG9wdENGLCBDRlN0cmluZ0NyZWF0ZU11dGFibGVDb3B5KE5VTEwsIDAsIHhtbFN0cmlu Zy5nZXQoKSkpOwogCiAgICAgLy8gUmVwbGFjZSAiQXBwbGUgQ29tcHV0ZXIiIHdpdGggIkFwcGxl IiBpbiB0aGUgRFREIGRlY2xhcmF0aW9uLgotICAgIE5TUmFuZ2UgcmFuZ2UgPSBbc3RyaW5nIHJh bmdlT2ZTdHJpbmc6QCItLy9BcHBsZSBDb21wdXRlci8vIl07Ci0gICAgaWYgKHJhbmdlLmxvY2F0 aW9uICE9IE5TTm90Rm91bmQpCi0gICAgICAgIFtzdHJpbmcgcmVwbGFjZUNoYXJhY3RlcnNJblJh bmdlOnJhbmdlIHdpdGhTdHJpbmc6QCItLy9BcHBsZS8vIl07Ci0gICAgCi0gICAgcmV0dXJuIHN0 cmluZzsKKyAgICBDRlN0cmluZ0ZpbmRBbmRSZXBsYWNlKHN0cmluZy5nZXQoKSwgQ0ZTVFIoIi0v L0FwcGxlIENvbXB1dGVyLy8iKSwgQ0ZTVFIoIi0vL0FwcGxlLy8iKSwgQ0ZSYW5nZU1ha2UoMCwg Q0ZTdHJpbmdHZXRMZW5ndGgoc3RyaW5nLmdldCgpKSksIDApOworCisgICAgcmV0dXJuIHN0cmlu Zy5yZWxlYXNlUmVmKCk7CiB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydE1hYy5tbQppbmRleCA2MGIyZTk2NTBmMzEy NDUxNGQ2OTBiZTA3YTRlMzQ0OGY2N2QyYmFkLi5kOWEzNDM4NzIzNjA4MjE4NmQyNzQ4YzRjMmMw ZGIyZDJlZGRlNWU4IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMv V2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL21hYy9XZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW0KQEAgLTI1LDE4ICsyNSw0OCBAQAog CiAjaW1wb3J0ICJXZWJBcmNoaXZlRHVtcFN1cHBvcnQuaCIKIAorI2ltcG9ydCA8Q0ZOZXR3b3Jr L0NGSFRUUE1lc3NhZ2UuaD4KICNpbXBvcnQgPEZvdW5kYXRpb24vRm91bmRhdGlvbi5oPgogI2lt cG9ydCA8SmF2YVNjcmlwdENvcmUvUmV0YWluUHRyLmg+CiAjaW1wb3J0IDxXZWJLaXQvV2ViSFRN TFJlcHJlc2VudGF0aW9uLmg+CiAKLU5TVVJMUmVzcG9uc2UgKnVuYXJjaGl2ZU5TVVJMUmVzcG9u c2VGcm9tUmVzcG9uc2VEYXRhKE5TRGF0YSAqcmVzcG9uc2VEYXRhKQorZXh0ZXJuICJDIiB7CisK K2VudW0gQ0ZVUkxDYWNoZVN0b3JhZ2VQb2xpY3kgeworICBrQ0ZVUkxDYWNoZVN0b3JhZ2VBbGxv d2VkID0gMCwKKyAga0NGVVJMQ2FjaGVTdG9yYWdlQWxsb3dlZEluTWVtb3J5T25seSA9IDEsCisg IGtDRlVSTENhY2hlU3RvcmFnZU5vdEFsbG93ZWQgPSAyCit9OwordHlwZWRlZiBlbnVtIENGVVJM Q2FjaGVTdG9yYWdlUG9saWN5IENGVVJMQ2FjaGVTdG9yYWdlUG9saWN5OworCitleHRlcm4gY29u c3QgQ0ZTdHJpbmdSZWYga0NGSFRUUFZlcnNpb24xXzE7CisKK0NGVVJMUmVzcG9uc2VSZWYgQ0ZV UkxSZXNwb25zZUNyZWF0ZShDRkFsbG9jYXRvclJlZiBhbGxvYywgQ0ZVUkxSZWYgVVJMLCBDRlN0 cmluZ1JlZiBtaW1lVHlwZSwgU0ludDY0IGV4cGVjdGVkQ29udGVudExlbmd0aCwgQ0ZTdHJpbmdS ZWYgdGV4dEVuY29kaW5nTmFtZSwgQ0ZVUkxDYWNoZVN0b3JhZ2VQb2xpY3kgcmVjb21tZW5kZWRQ b2xpY3kpOworQ0ZVUkxSZXNwb25zZVJlZiBDRlVSTFJlc3BvbnNlQ3JlYXRlV2l0aEhUVFBSZXNw b25zZShDRkFsbG9jYXRvclJlZiBhbGxvYywgQ0ZVUkxSZWYgVVJMLCBDRkhUVFBNZXNzYWdlUmVm IGh0dHBSZXNwb25zZSwgQ0ZVUkxDYWNoZVN0b3JhZ2VQb2xpY3kgcmVjb21tZW5kZWRQb2xpY3kp Owordm9pZCBDRlVSTFJlc3BvbnNlU2V0RXhwZWN0ZWRDb250ZW50TGVuZ3RoKENGVVJMUmVzcG9u c2VSZWYgcmVzcG9uc2UsIFNJbnQ2NCBsZW5ndGgpOwordm9pZCBDRlVSTFJlc3BvbnNlU2V0TUlN RVR5cGUoQ0ZVUkxSZXNwb25zZVJlZiByZXNwb25zZSwgQ0ZTdHJpbmdSZWYgbWltZVR5cGUpOwor fQorCitDRlVSTFJlc3BvbnNlUmVmIGNyZWF0ZUNGVVJMUmVzcG9uc2VGcm9tUmVzcG9uc2VEYXRh KENGRGF0YVJlZiByZXNwb25zZURhdGEpCiB7CiAgICAgLy8gRGVjb2RlIE5TVVJMUmVzcG9uc2UK LSAgICBSZXRhaW5QdHI8TlNLZXllZFVuYXJjaGl2ZXI+IHVuYXJjaGl2ZXIoQWRvcHROUywgW1tO U0tleWVkVW5hcmNoaXZlciBhbGxvY10gaW5pdEZvclJlYWRpbmdXaXRoRGF0YTpyZXNwb25zZURh dGFdKTsKKyAgICBSZXRhaW5QdHI8TlNLZXllZFVuYXJjaGl2ZXI+IHVuYXJjaGl2ZXIoQWRvcHRO UywgW1tOU0tleWVkVW5hcmNoaXZlciBhbGxvY10gaW5pdEZvclJlYWRpbmdXaXRoRGF0YTooTlNE YXRhICopcmVzcG9uc2VEYXRhXSk7CiAgICAgTlNVUkxSZXNwb25zZSAqcmVzcG9uc2UgPSBbdW5h cmNoaXZlci5nZXQoKSBkZWNvZGVPYmplY3RGb3JLZXk6QCJXZWJSZXNvdXJjZVJlc3BvbnNlIl07 IC8vIFdlYlJlc291cmNlUmVzcG9uc2VLZXkgaW4gV2ViUmVzb3VyY2UubQogICAgIFt1bmFyY2hp dmVyLmdldCgpIGZpbmlzaERlY29kaW5nXTsKIAotICAgIHJldHVybiByZXNwb25zZTsKKyAgICBp ZiAoIVtyZXNwb25zZSBpc0tpbmRPZkNsYXNzOltOU0hUVFBVUkxSZXNwb25zZSBjbGFzc11dKQor ICAgICAgICByZXR1cm4gQ0ZVUkxSZXNwb25zZUNyZWF0ZShOVUxMLCAoQ0ZVUkxSZWYpW3Jlc3Bv bnNlIFVSTF0sIChDRlN0cmluZ1JlZilbcmVzcG9uc2UgTUlNRVR5cGVdLCBbcmVzcG9uc2UgZXhw ZWN0ZWRDb250ZW50TGVuZ3RoXSwgKENGU3RyaW5nUmVmKVtyZXNwb25zZSB0ZXh0RW5jb2RpbmdO YW1lXSwga0NGVVJMQ2FjaGVTdG9yYWdlQWxsb3dlZCk7CisKKyAgICBOU0hUVFBVUkxSZXNwb25z ZSAqaHR0cFJlc3BvbnNlID0gKE5TSFRUUFVSTFJlc3BvbnNlICopcmVzcG9uc2U7CisKKyAgICAv LyBOU1VSTFJlc3BvbnNlIGlzIG5vdCB0b2xsLWZyZWUgYnJpZGdlZCB0byBDRlVSTFJlc3BvbnNl LgorICAgIFJldGFpblB0cjxDRkhUVFBNZXNzYWdlUmVmPiBodHRwTWVzc2FnZShBZG9wdENGLCBD RkhUVFBNZXNzYWdlQ3JlYXRlUmVzcG9uc2UoTlVMTCwgW2h0dHBSZXNwb25zZSBzdGF0dXNDb2Rl XSwgTlVMTCwga0NGSFRUUFZlcnNpb24xXzEpKTsKKworICAgIE5TRGljdGlvbmFyeSAqaGVhZGVy RmllbGRzID0gW2h0dHBSZXNwb25zZSBhbGxIZWFkZXJGaWVsZHNdOworICAgIGZvciAoTlNTdHJp bmcgKmhlYWRlckZpZWxkIGluIFtoZWFkZXJGaWVsZHMga2V5RW51bWVyYXRvcl0pCisgICAgICAg IENGSFRUUE1lc3NhZ2VTZXRIZWFkZXJGaWVsZFZhbHVlKGh0dHBNZXNzYWdlLmdldCgpLCAoQ0ZT dHJpbmdSZWYpaGVhZGVyRmllbGQsIChDRlN0cmluZ1JlZilbaGVhZGVyRmllbGRzIG9iamVjdEZv cktleTpoZWFkZXJGaWVsZF0pOworCisgICAgcmV0dXJuIENGVVJMUmVzcG9uc2VDcmVhdGVXaXRo SFRUUFJlc3BvbnNlKE5VTEwsIChDRlVSTFJlZilbcmVzcG9uc2UgVVJMXSwgaHR0cE1lc3NhZ2Uu Z2V0KCksIGtDRlVSTENhY2hlU3RvcmFnZUFsbG93ZWQpOwogfQogCiBDRkFycmF5UmVmIHN1cHBv cnRlZE5vbkltYWdlTUlNRVR5cGVzKCkK 71820 2010-10-25 17:07:56 -0700 2010-10-27 02:20:51 -0700 Part 4: Rename WebArchiveDumpSupport.mm to WebArchiveDumpSupport.cpp bug-48278-20101025170755.patch text/plain 6343 ddkilzer ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBiNDgzNDEwYzQ5ZDQ0YzgxMmUyYTQwYjFjNTg2MDliNWFlNTQ2Y2FiLi44NTZiODVk OTE0MzdiOGY0ZDMwZTNiMDMyYzc4YTY4NjRhMjgwNDg5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMjUgQEAK IDIwMTAtMTAtMjUgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KIAorICAgICAg ICBSZW5hbWUgV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tIHRvIFdlYkFyY2hpdmVEdW1wU3VwcG9y dC5jcHAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBQ YXJ0IDQgb2YgNDogPGh0dHA6Ly93ZWJraXQub3JnL2IvNDgyNzg+IENvbnZlcnQgRHVtcFJlbmRl clRyZWUgd2ViYXJjaGl2ZSBjb2RlIHRvIENvcmVGb3VuZGF0aW9uCisKKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAg ICAgICBVcGRhdGVkIGZvciBmaWxlIG1vdmVzIGFuZCByZW5hbWVzLgorICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL2NmL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5jcHA6IFJlbmFtZWQgZnJvbSBEdW1w UmVuZGVyVHJlZS9tYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tLgorICAgICAgICAoY29udmVy dE1JTUVUeXBlKToKKyAgICAgICAgKGNvbnZlcnRXZWJSZXNvdXJjZURhdGFUb1N0cmluZyk6Cisg ICAgICAgIChub3JtYWxpemVIVFRQUmVzcG9uc2VIZWFkZXJGaWVsZHMpOgorICAgICAgICAobm9y bWFsaXplV2ViUmVzb3VyY2VVUkwpOgorICAgICAgICAoY29udmVydFdlYlJlc291cmNlUmVzcG9u c2VUb0RpY3Rpb25hcnkpOgorICAgICAgICAoY29tcGFyZVJlc291cmNlVVJMcyk6CisgICAgICAg IChjcmVhdGVYTUxTdHJpbmdGcm9tV2ViQXJjaGl2ZURhdGEpOgorICAgICAgICAqIER1bXBSZW5k ZXJUcmVlL2NmL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5oOiBSZW5hbWVkIGZyb20gRHVtcFJlbmRl clRyZWUvbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5oLgorCisyMDEwLTEwLTI1ICBEYXZpZCBL aWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+CisKICAgICAgICAgQ29udmVydCBXZWJBcmNoaXZl RHVtcFN1cHBvcnQubW0gZnJvbSBOUyBvYmplY3RzIHRvIENGIHR5cGVzCiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvRHVtcFJlbmRlclRyZWUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagppbmRleCBjM2ZmMDYyNDFmNWNjMTYyNmM5MGMxYjUzODIwNTBhNmNjOTMxOGU5Li4wMGJh YTc3YWI3Zjk4NmM3YWU0NTA2ZTM3YTgyNzNkOWNjYjcyNzI1IDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9EdW1wUmVuZGVyVHJlZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0R1bXBSZW5kZXJUcmVlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTQ5LDcgKzQ5LDcgQEAKIAkJMzcxM0VERTIxMTVCRTE5 MzAwNzA1NzIwIC8qIENvbG9yQml0cy1BLnBuZyBpbiBDb3B5IEZvbnQgRmlsZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gMzcxM0VEREYxMTVCRTE2RjAwNzA1NzIwIC8qIENv bG9yQml0cy1BLnBuZyAqLzsgfTsKIAkJMzcxM0VERTMxMTVCRTE5MzAwNzA1NzIwIC8qIENvbG9y Qml0cy50dGYgaW4gQ29weSBGb250IEZpbGVzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDM3MTNFREUwMTE1QkUxNkYwMDcwNTcyMCAvKiBDb2xvckJpdHMudHRmICovOyB9Owog CQk0NDA1OTA3MTEyNjg0NTM4MDBDRkQ0OEQgLyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1t IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDQwNTkwNzAx MjY4NDUzODAwQ0ZENDhEIC8qIFdlYkFyY2hpdmVEdW1wU3VwcG9ydE1hYy5tbSAqLzsgfTsKLQkJ NDQzNzczMEUxMjVDQkMzNjAwQUFFMDJDIC8qIFdlYkFyY2hpdmVEdW1wU3VwcG9ydC5tbSBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ0QTk5NzgzMEZDREU4 NjQwMDU4MEYxMCAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnQubW0gKi87IH07CisJCTQ0Mzc3MzBF MTI1Q0JDMzYwMEFBRTAyQyAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnQuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNDRBOTk3ODMwRkNERTg2NDAwNTgw RjEwIC8qIFdlYkFyY2hpdmVEdW1wU3VwcG9ydC5jcHAgKi87IH07CiAJCTQ0Mzc3MzBGMTI1Q0JD NEQwMEFBRTAyQyAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnQuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDQ0QTk5NzgyMEZDREU4NjQwMDU4MEYxMCAvKiBX ZWJBcmNoaXZlRHVtcFN1cHBvcnQuaCAqLzsgfTsKIAkJNTE4NUY2QjIxMDcxNEUwNzAwN0FBMzkz IC8qIEhpc3RvcnlEZWxlZ2F0ZS5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDUxODVGNjlGMTA3MTRBNTcwMDdBQTM5MyAvKiBIaXN0b3J5RGVsZWdhdGUu bW0gKi87IH07CiAJCTUxODVGNkIzMTA3MTRFMTIwMDdBQTM5MyAvKiBIaXN0b3J5RGVsZWdhdGUu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDUxODVGNjlF MTA3MTRBNTcwMDdBQTM5MyAvKiBIaXN0b3J5RGVsZWdhdGUuaCAqLzsgfTsKQEAgLTIyNSw4ICsy MjUsOCBAQAogCQkzNzVGMDk3ODBEQUMzQ0I2MDBDOEI0RTUgLyogV2ViS2l0V2VpZ2h0V2F0Y2hl cjgwMC50dGYgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUg PSBmaWxlOyBuYW1lID0gV2ViS2l0V2VpZ2h0V2F0Y2hlcjgwMC50dGY7IHBhdGggPSBmb250cy9X ZWJLaXRXZWlnaHRXYXRjaGVyODAwLnR0Zjsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ Mzc1RjA5NzkwREFDM0NCNjAwQzhCNEU1IC8qIFdlYktpdFdlaWdodFdhdGNoZXI5MDAudHRmICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gZmlsZTsgbmFt ZSA9IFdlYktpdFdlaWdodFdhdGNoZXI5MDAudHRmOyBwYXRoID0gZm9udHMvV2ViS2l0V2VpZ2h0 V2F0Y2hlcjkwMC50dGY7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTQ0MDU5MDcwMTI2 ODQ1MzgwMENGRDQ4RCAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW0gKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5vYmpjcHA7IG5hbWUgPSBXZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW07 IHBhdGggPSBtYWMvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0TWFjLm1tOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwotCQk0NEE5OTc4MjBGQ0RFODY0MDA1ODBGMTAgLyogV2ViQXJjaGl2ZUR1bXBT dXBwb3J0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgbmFtZSA9IFdlYkFyY2hpdmVEdW1w U3VwcG9ydC5oOyBwYXRoID0gbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwotCQk0NEE5OTc4MzBGQ0RFODY0MDA1ODBGMTAgLyogV2ViQXJjaGl2 ZUR1bXBTdXBwb3J0Lm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBuYW1lID0g V2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lm1tOyBwYXRoID0gbWFjL1dlYkFyY2hpdmVEdW1wU3VwcG9y dC5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNDRBOTk3ODIwRkNERTg2NDAwNTgw RjEwIC8qIFdlYkFyY2hpdmVEdW1wU3VwcG9ydC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IG5hbWUgPSBXZWJBcmNoaXZlRHVtcFN1cHBvcnQuaDsgcGF0aCA9IGNmL1dlYkFyY2hpdmVEdW1w U3VwcG9ydC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk0NEE5OTc4MzBGQ0RFODY0 MDA1ODBGMTAgLyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgbmFtZSA9IFdlYkFyY2hpdmVEdW1wU3VwcG9ydC5jcHA7IHBhdGggPSBjZi9X ZWJBcmNoaXZlRHVtcFN1cHBvcnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1 MTg1RjY5RTEwNzE0QTU3MDA3QUEzOTMgLyogSGlzdG9yeURlbGVnYXRlLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgbmFtZSA9IEhpc3RvcnlEZWxlZ2F0ZS5oOyBwYXRoID0gbWFjL0hpc3Rv cnlEZWxlZ2F0ZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk1MTg1RjY5RjEwNzE0 QTU3MDA3QUEzOTMgLyogSGlzdG9yeURlbGVnYXRlLm1tICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGV4cGxpY2l0RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7IGZpbGVFbmNv ZGluZyA9IDQ7IG5hbWUgPSBIaXN0b3J5RGVsZWdhdGUubW07IHBhdGggPSBtYWMvSGlzdG9yeURl bGVnYXRlLm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4NDY1RTJDNjBGRkE4REYy MDAzQjgzNDIgLyogUGl4ZWxEdW1wU3VwcG9ydC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gUGl4ZWxEdW1wU3VwcG9ydC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CkBAIC0zNjcsNyArMzY3LDcgQEAKIAkJCQlBOEQ3OUNFODBGQzI4QjJDMDA0QUM4RkUg LyogRHVtcFJlbmRlclRyZWVGaWxlRHJhZ2dpbmdTb3VyY2UuaCAqLywKIAkJCQlBOEQ3OUNFOTBG QzI4QjJDMDA0QUM4RkUgLyogRHVtcFJlbmRlclRyZWVGaWxlRHJhZ2dpbmdTb3VyY2UubSAqLywK IAkJCQk0NEE5OTc4MjBGQ0RFODY0MDA1ODBGMTAgLyogV2ViQXJjaGl2ZUR1bXBTdXBwb3J0Lmgg Ki8sCi0JCQkJNDRBOTk3ODMwRkNERTg2NDAwNTgwRjEwIC8qIFdlYkFyY2hpdmVEdW1wU3VwcG9y dC5tbSAqLywKKwkJCQk0NEE5OTc4MzBGQ0RFODY0MDA1ODBGMTAgLyogV2ViQXJjaGl2ZUR1bXBT dXBwb3J0LmNwcCAqLywKIAkJCQk0NDA1OTA3MDEyNjg0NTM4MDBDRkQ0OEQgLyogV2ViQXJjaGl2 ZUR1bXBTdXBwb3J0TWFjLm1tICovLAogCQkJCUJDOUQ5MDIxMEM5NzQ3MkQwMDk5QTRBMyAvKiBX b3JrUXVldWUuY3BwICovLAogCQkJCUJDOUQ5MDIyMEM5NzQ3MkUwMDk5QTRBMyAvKiBXb3JrUXVl dWUuaCAqLywKQEAgLTc4NSw3ICs3ODUsNyBAQAogCQkJCUJDQTE4QjY4MEM5QjA4QzIwMDExNDM2 OSAvKiBSZXNvdXJjZUxvYWREZWxlZ2F0ZS5tbSBpbiBTb3VyY2VzICovLAogCQkJCUJDQTE4QjQ5 MEM5QjAyQzQwMDExNDM2OSAvKiBUZXh0SW5wdXRDb250cm9sbGVyLm0gaW4gU291cmNlcyAqLywK IAkJCQlCQ0ExOEI2QTBDOUIwOEMyMDAxMTQzNjkgLyogVUlEZWxlZ2F0ZS5tbSBpbiBTb3VyY2Vz ICovLAotCQkJCTQ0Mzc3MzBFMTI1Q0JDMzYwMEFBRTAyQyAvKiBXZWJBcmNoaXZlRHVtcFN1cHBv cnQubW0gaW4gU291cmNlcyAqLywKKwkJCQk0NDM3NzMwRTEyNUNCQzM2MDBBQUUwMkMgLyogV2Vi QXJjaGl2ZUR1bXBTdXBwb3J0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTQ0MDU5MDcxMTI2ODQ1 MzgwMENGRDQ4RCAvKiBXZWJBcmNoaXZlRHVtcFN1cHBvcnRNYWMubW0gaW4gU291cmNlcyAqLywK IAkJCQlCQzlEOTAyNDBDOTc0NzJFMDA5OUE0QTMgLyogV29ya1F1ZXVlLmNwcCBpbiBTb3VyY2Vz ICovLAogCQkJCUJDQTE4QjI2MEM5QjAxNUMwMDExNDM2OSAvKiBXb3JrUXVldWVJdGVtTWFjLm1t IGluIFNvdXJjZXMgKi8sCg== 71997 2010-10-27 02:20:51 -0700 2010-10-27 07:32:50 -0700 Fix Leopard build FixDRT.diff text/plain 2683 zimmermann SW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9D aGFuZ2VMb2cJKHJldmlzaW9uIDcwNjI1KQorKysgV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTAtMTAtMjcgIE5pa29sYXMgWmltbWVybWFu biAgPG56aW1tZXJtYW5uQHJpbS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgQ29udmVydCBEdW1wUmVuZGVyVHJlZSB3ZWJhcmNoaXZlIGNvZGUg dG8gQ29yZUZvdW5kYXRpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQ4Mjc4CisKKyAgICAgICAgQ0ZQcm9wZXJ0eUxpc3RDcmVhdGVXaXRoRGF0YSBh bmQgQ0ZQcm9wZXJ0eUxpc3RDcmVhdGVEYXRhIGFyZSBvbmx5IGF2YWlsYWJsZSBpbiAxMC42Ky4K KyAgICAgICAgUmVwbGFjZSBDRlByb3BlcnR5TGlzdENyZWF0ZVdpdGhEYXRhIGJ5IGEgY29tYmlu YXRpb24gb2YgQ0ZSZWFkU3RyZWFtQ3JlYXRlV2l0aEJ5dGVzTm9Db3B5IGFuZCBDRlByb3BlcnR5 TGlzdENyZWF0ZUZyb21TdHJlYW0uCisgICAgICAgIFJlcGxhY2UgQ0ZQcm9wZXJ0eUxpc3RDcmVh dGVEYXRhIGJ5IENGUHJvcGVydHlMaXN0Q3JlYXRlWE1MRGF0YS4KKworICAgICAgICBUaGVzZSBj aGFuZ2VzIGFyZSB3cmFwcGVkIGluIEJVSUxESU5HX09OX0xFT1BBUkQsIGFzIHRoZSBtZXRob2Rz IGFyZSBkZXByZWNhdGVkIG9uIDEwLjYrLgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2Yv V2ViQXJjaGl2ZUR1bXBTdXBwb3J0LmNwcDoKKyAgICAgICAgKGNyZWF0ZVhNTFN0cmluZ0Zyb21X ZWJBcmNoaXZlRGF0YSk6CisKIDIwMTAtMTAtMjYgIEFudG9uaW8gR29tZXMgIDxhZ29tZXNAcmlt LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBNYXJ0aW4gUm9iaW5zb24uCkluZGV4OiBXZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9jZi9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2NmL1dlYkFyY2hpdmVEdW1wU3Vw cG9ydC5jcHAJKHJldmlzaW9uIDcwNjIwKQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv Y2YvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTU2LDcgKzE1 NiwxNiBAQCBDRlN0cmluZ1JlZiBjcmVhdGVYTUxTdHJpbmdGcm9tV2ViQXJjaGl2CiB7CiAgICAg Q0ZFcnJvclJlZiBlcnJvciA9IDA7CiAgICAgQ0ZQcm9wZXJ0eUxpc3RGb3JtYXQgZm9ybWF0ID0g a0NGUHJvcGVydHlMaXN0QmluYXJ5Rm9ybWF0X3YxXzA7CisjaWZkZWYgQlVJTERJTkdfT05fTEVP UEFSRAorICAgIENGSW5kZXggYnl0ZXNDb3VudCA9IENGRGF0YUdldExlbmd0aCh3ZWJBcmNoaXZl RGF0YSk7CisgICAgQ0ZSZWFkU3RyZWFtUmVmIHJlYWRTdHJlYW0gPSBDRlJlYWRTdHJlYW1DcmVh dGVXaXRoQnl0ZXNOb0NvcHkoa0NGQWxsb2NhdG9yRGVmYXVsdCwgQ0ZEYXRhR2V0Qnl0ZVB0cih3 ZWJBcmNoaXZlRGF0YSksIGJ5dGVzQ291bnQsIGtDRkFsbG9jYXRvck51bGwpOworICAgIENGUmVh ZFN0cmVhbU9wZW4ocmVhZFN0cmVhbSk7CisgICAgQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZiBwcm9w ZXJ0eUxpc3QgPSAoQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZilDRlByb3BlcnR5TGlzdENyZWF0ZUZy b21TdHJlYW0oa0NGQWxsb2NhdG9yRGVmYXVsdCwgcmVhZFN0cmVhbSwgYnl0ZXNDb3VudCwga0NG UHJvcGVydHlMaXN0TXV0YWJsZUNvbnRhaW5lcnNBbmRMZWF2ZXMsICZmb3JtYXQsIDApOworICAg IENGUmVhZFN0cmVhbUNsb3NlKHJlYWRTdHJlYW0pOworICAgIENGUmVsZWFzZShyZWFkU3RyZWFt KTsKKyNlbHNlCiAgICAgQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZiBwcm9wZXJ0eUxpc3QgPSAoQ0ZN dXRhYmxlRGljdGlvbmFyeVJlZilDRlByb3BlcnR5TGlzdENyZWF0ZVdpdGhEYXRhKGtDRkFsbG9j YXRvckRlZmF1bHQsIHdlYkFyY2hpdmVEYXRhLCBrQ0ZQcm9wZXJ0eUxpc3RNdXRhYmxlQ29udGFp bmVyc0FuZExlYXZlcywgJmZvcm1hdCwgJmVycm9yKTsKKyNlbmRpZgogCiAgICAgaWYgKCFwcm9w ZXJ0eUxpc3QpIHsKICAgICAgICAgaWYgKGVycm9yKQpAQCAtMTk3LDcgKzIwNiwxMSBAQCBDRlN0 cmluZ1JlZiBjcmVhdGVYTUxTdHJpbmdGcm9tV2ViQXJjaGl2CiAgICAgfQogCiAgICAgZXJyb3Ig PSAwOworI2lmZGVmIEJVSUxESU5HX09OX0xFT1BBUkQKKyAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVm PiB4bWxEYXRhKEFkb3B0Q0YsIENGUHJvcGVydHlMaXN0Q3JlYXRlWE1MRGF0YShrQ0ZBbGxvY2F0 b3JEZWZhdWx0LCBwcm9wZXJ0eUxpc3QpKTsKKyNlbHNlCiAgICAgUmV0YWluUHRyPENGRGF0YVJl Zj4geG1sRGF0YShBZG9wdENGLCBDRlByb3BlcnR5TGlzdENyZWF0ZURhdGEoa0NGQWxsb2NhdG9y RGVmYXVsdCwgcHJvcGVydHlMaXN0LCBrQ0ZQcm9wZXJ0eUxpc3RYTUxGb3JtYXRfdjFfMCwgMCwg JmVycm9yKSk7CisjZW5kaWYKIAogICAgIGlmICgheG1sRGF0YSkgewogICAgICAgICBpZiAoZXJy b3IpCg== 72032 2010-10-27 07:33:25 -0700 2010-10-27 08:43:42 -0700 Fix leak of CFMutableDictionaryRef in createXMLStringFromWebArchiveData() bug-48278-20101027073323.patch text/plain 3667 ddkilzer ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBkYTVlMmY0YjY3Y2U1ZjJjMDc4YzUzN2Q2Njk4ZTFjZTNjNzJiNTM2Li5mMjIzMzY3 YjczODZmNzVlMjdmYjlhOGUwNWY1NzU3NGNlODg0NjcwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTAtMTAtMjcgIERhdmlkIEtpbHplciAgPGRka2lsemVyQGFwcGxlLmNvbT4KKworICAgICAg ICBGaXggbGVhayBvZiBDRk11dGFibGVEaWN0aW9uYXJ5UmVmIGluIGNyZWF0ZVhNTFN0cmluZ0Zy b21XZWJBcmNoaXZlRGF0YSgpCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgRm9sbG93LXVwIGZpeCBmb3I6IDxodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NDgyNzg+CisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jZi9XZWJB cmNoaXZlRHVtcFN1cHBvcnQuY3BwOgorICAgICAgICAoY3JlYXRlWE1MU3RyaW5nRnJvbVdlYkFy Y2hpdmVEYXRhKTogVXNlIFJldGFpblB0cjw+IHRvIGZpeCBhCisgICAgICAgIGxlYWsgaW50cm9k dWNlZCBpbiByNzA2MTMuCisKIDIwMTAtMTAtMjcgIEFkYW0gUm9iZW4gIDxhcm9iZW5AYXBwbGUu Y29tPgogCiAgICAgICAgIENhdGNoIGV4Y2VwdGlvbnMgd2hlbiBjaGVja2luZyBpZiB3ZSdyZSBp bnNpZGUgYSBnaXQgd29ya2luZyBkaXJlY3RvcnkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL2NmL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5jcHAgYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9jZi9XZWJBcmNoaXZlRHVtcFN1cHBvcnQuY3BwCmluZGV4IDI0MDkyODJi YjRhYTNmZDQ0MjI4MTdkMDFjNTUwNjE1MGNhYjJjYmYuLjRkNzc0NTQ5NTQxMWQ3Y2Y0NmIxNDAz OGRiYjZjODNmM2YxNzIzMjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L2NmL1dlYkFyY2hpdmVEdW1wU3VwcG9ydC5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvY2YvV2ViQXJjaGl2ZUR1bXBTdXBwb3J0LmNwcApAQCAtMTYxLDEwICsxNjEsMTAgQEAg Q0ZTdHJpbmdSZWYgY3JlYXRlWE1MU3RyaW5nRnJvbVdlYkFyY2hpdmVEYXRhKENGRGF0YVJlZiB3 ZWJBcmNoaXZlRGF0YSkKICAgICBDRkluZGV4IGJ5dGVzQ291bnQgPSBDRkRhdGFHZXRMZW5ndGgo d2ViQXJjaGl2ZURhdGEpOwogICAgIFJldGFpblB0cjxDRlJlYWRTdHJlYW1SZWY+IHJlYWRTdHJl YW0oQWRvcHRDRiwgQ0ZSZWFkU3RyZWFtQ3JlYXRlV2l0aEJ5dGVzTm9Db3B5KGtDRkFsbG9jYXRv ckRlZmF1bHQsIENGRGF0YUdldEJ5dGVQdHIod2ViQXJjaGl2ZURhdGEpLCBieXRlc0NvdW50LCBr Q0ZBbGxvY2F0b3JOdWxsKSk7CiAgICAgQ0ZSZWFkU3RyZWFtT3BlbihyZWFkU3RyZWFtLmdldCgp KTsKLSAgICBDRk11dGFibGVEaWN0aW9uYXJ5UmVmIHByb3BlcnR5TGlzdCA9IChDRk11dGFibGVE aWN0aW9uYXJ5UmVmKUNGUHJvcGVydHlMaXN0Q3JlYXRlRnJvbVN0cmVhbShrQ0ZBbGxvY2F0b3JE ZWZhdWx0LCByZWFkU3RyZWFtLmdldCgpLCBieXRlc0NvdW50LCBrQ0ZQcm9wZXJ0eUxpc3RNdXRh YmxlQ29udGFpbmVyc0FuZExlYXZlcywgJmZvcm1hdCwgMCk7CisgICAgUmV0YWluUHRyPENGTXV0 YWJsZURpY3Rpb25hcnlSZWY+IHByb3BlcnR5TGlzdChBZG9wdENGLCAoQ0ZNdXRhYmxlRGljdGlv bmFyeVJlZilDRlByb3BlcnR5TGlzdENyZWF0ZUZyb21TdHJlYW0oa0NGQWxsb2NhdG9yRGVmYXVs dCwgcmVhZFN0cmVhbS5nZXQoKSwgYnl0ZXNDb3VudCwga0NGUHJvcGVydHlMaXN0TXV0YWJsZUNv bnRhaW5lcnNBbmRMZWF2ZXMsICZmb3JtYXQsIDApKTsKICAgICBDRlJlYWRTdHJlYW1DbG9zZShy ZWFkU3RyZWFtLmdldCgpKTsKICNlbHNlCi0gICAgQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZiBwcm9w ZXJ0eUxpc3QgPSAoQ0ZNdXRhYmxlRGljdGlvbmFyeVJlZilDRlByb3BlcnR5TGlzdENyZWF0ZVdp dGhEYXRhKGtDRkFsbG9jYXRvckRlZmF1bHQsIHdlYkFyY2hpdmVEYXRhLCBrQ0ZQcm9wZXJ0eUxp c3RNdXRhYmxlQ29udGFpbmVyc0FuZExlYXZlcywgJmZvcm1hdCwgJmVycm9yKTsKKyAgICBSZXRh aW5QdHI8Q0ZNdXRhYmxlRGljdGlvbmFyeVJlZj4gcHJvcGVydHlMaXN0KEFkb3B0Q0YsIChDRk11 dGFibGVEaWN0aW9uYXJ5UmVmKUNGUHJvcGVydHlMaXN0Q3JlYXRlV2l0aERhdGEoa0NGQWxsb2Nh dG9yRGVmYXVsdCwgd2ViQXJjaGl2ZURhdGEsIGtDRlByb3BlcnR5TGlzdE11dGFibGVDb250YWlu ZXJzQW5kTGVhdmVzLCAmZm9ybWF0LCAmZXJyb3IpKTsKICNlbmRpZgogCiAgICAgaWYgKCFwcm9w ZXJ0eUxpc3QpIHsKQEAgLTE3NCw3ICsxNzQsNyBAQCBDRlN0cmluZ1JlZiBjcmVhdGVYTUxTdHJp bmdGcm9tV2ViQXJjaGl2ZURhdGEoQ0ZEYXRhUmVmIHdlYkFyY2hpdmVEYXRhKQogICAgIH0KIAog ICAgIFJldGFpblB0cjxDRk11dGFibGVBcnJheVJlZj4gcmVzb3VyY2VzKEFkb3B0Q0YsIENGQXJy YXlDcmVhdGVNdXRhYmxlKGtDRkFsbG9jYXRvckRlZmF1bHQsIDAsICZrQ0ZUeXBlQXJyYXlDYWxs QmFja3MpKTsKLSAgICBDRkFycmF5QXBwZW5kVmFsdWUocmVzb3VyY2VzLmdldCgpLCBwcm9wZXJ0 eUxpc3QpOworICAgIENGQXJyYXlBcHBlbmRWYWx1ZShyZXNvdXJjZXMuZ2V0KCksIHByb3BlcnR5 TGlzdC5nZXQoKSk7CiAKICAgICB3aGlsZSAoQ0ZBcnJheUdldENvdW50KHJlc291cmNlcy5nZXQo KSkpIHsKICAgICAgICAgUmV0YWluUHRyPENGTXV0YWJsZURpY3Rpb25hcnlSZWY+IHJlc291cmNl UHJvcGVydHlMaXN0ID0gKENGTXV0YWJsZURpY3Rpb25hcnlSZWYpQ0ZBcnJheUdldFZhbHVlQXRJ bmRleChyZXNvdXJjZXMuZ2V0KCksIDApOwpAQCAtMjA4LDkgKzIwOCw5IEBAIENGU3RyaW5nUmVm IGNyZWF0ZVhNTFN0cmluZ0Zyb21XZWJBcmNoaXZlRGF0YShDRkRhdGFSZWYgd2ViQXJjaGl2ZURh dGEpCiAgICAgZXJyb3IgPSAwOwogCiAjaWYgZGVmaW5lZChCVUlMRElOR19PTl9USUdFUikgfHwg ZGVmaW5lZChCVUlMRElOR19PTl9MRU9QQVJEKQotICAgIFJldGFpblB0cjxDRkRhdGFSZWY+IHht bERhdGEoQWRvcHRDRiwgQ0ZQcm9wZXJ0eUxpc3RDcmVhdGVYTUxEYXRhKGtDRkFsbG9jYXRvckRl ZmF1bHQsIHByb3BlcnR5TGlzdCkpOworICAgIFJldGFpblB0cjxDRkRhdGFSZWY+IHhtbERhdGEo QWRvcHRDRiwgQ0ZQcm9wZXJ0eUxpc3RDcmVhdGVYTUxEYXRhKGtDRkFsbG9jYXRvckRlZmF1bHQs IHByb3BlcnR5TGlzdC5nZXQoKSkpOwogI2Vsc2UKLSAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiB4 bWxEYXRhKEFkb3B0Q0YsIENGUHJvcGVydHlMaXN0Q3JlYXRlRGF0YShrQ0ZBbGxvY2F0b3JEZWZh dWx0LCBwcm9wZXJ0eUxpc3QsIGtDRlByb3BlcnR5TGlzdFhNTEZvcm1hdF92MV8wLCAwLCAmZXJy b3IpKTsKKyAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiB4bWxEYXRhKEFkb3B0Q0YsIENGUHJvcGVy dHlMaXN0Q3JlYXRlRGF0YShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBwcm9wZXJ0eUxpc3QuZ2V0KCks IGtDRlByb3BlcnR5TGlzdFhNTEZvcm1hdF92MV8wLCAwLCAmZXJyb3IpKTsKICNlbmRpZgogCiAg ICAgaWYgKCF4bWxEYXRhKSB7Cg==