24887 2009-03-27 08:56:29 -0700 [chromium] Use correct file name for dragging out images. 2011-06-01 14:27:15 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC Windows XP RESOLVED FIXED any URL with an image in it P2 Normal --- 1 mad jens ap commit-queue dcheng dglazkov jens jon oliver tony oldest_to_newest 115548 0 mad 2009-03-27 08:56:29 -0700 If you right-click on an image and choose the "Save Image As.." option, you get the name of the image resource as a proposed file name in the "File Save As" dialog. But if you drag and drop the image to the desktop, then you get another filename. For example, going to Google.com, you get Google.gif as opposed to logo.gif. This bug was reported on Chromium and also reproduced using Safari 4 (528.16). http://crbug.com/7849 115582 1 mad 2009-03-27 12:06:38 -0700 Although the behavior is the same for Chromium and Safari 4 on windows (though not on Safari 4 on the Mac, which does the right thing), there is actually two different pieces of code having the same wrong behavior, so these are separate issues. The problem on the chromium side comes from a file under WebCore\platform\chromium\ClipboardChromium.cpp, and the same problem is also in the WebCore\platform\win\ClipboardWin.cpp file. Here's a snippet of that code: The ClipboardWin::declareAndWriteDragImage() method calls the static writeImageToDataObject which has the following code: HGLOBAL imageFileDescriptor = createGlobalImageFileDescriptor(url.string(), element->getAttribute(altAttr), cachedImage); which wrongly uses the altAttr for the base file name, when it should use the file name from the url. I think... 115889 2 29086 mad 2009-03-30 14:31:34 -0700 Created attachment 29086 Change the way we choose the filename when drang and dropping an image to the filesystem on Windows 115910 3 dglazkov 2009-03-30 15:19:01 -0700 You shouldn't need Frame* in an argument, you can get it from the element: element->document()->frame(); 115998 4 29113 mad 2009-03-31 07:18:20 -0700 Created attachment 29113 Image drag and drop file name on Windows New version now uses the elements->document() as opposed to passing the frame. 115999 5 29114 mad 2009-03-31 07:24:43 -0700 Created attachment 29114 Image drag and drop file name on Windows Oops... Previous upload was missing a changed file... sorry... 116020 6 29114 dglazkov 2009-03-31 09:34:52 -0700 Comment on attachment 29114 Image drag and drop file name on Windows Per ap comments on #webkit, suggestedFilename() should take precedence over actual filename, because it uses the filename value from Content-Disposition header. Also spacing nits. > + if (imageURL.isEmpty() == false) { > + fileName = KURL(element->document()->completeURL(parseURL(imageURL))).lastPathComponent(); 4 spaces > + } else { > + fileName = element->getAttribute(altAttr); > + if (fileName.isEmpty()) 4 spaces. > + if (extension_index != -1) { > + extension = fileName.substring(extension_index + 1); > + fileName.truncate(extension_index); 4 spaces. > + } else { > + extension = MIMETypeRegistry::getPreferredExtensionForMIMEType( > cachedImage->response().mimeType()); 4 spaces. > + if (fileName.isEmpty()) > + return 0; 4 spaces. > + String extension; > + if (extension_index != -1) { > + extension = fileName.substring(extension_index); > + fileName.truncate(extension_index); 4 spaces. > + } else { > + extension = image->image()->filenameExtension(); > + if (extension.isEmpty()) { 4 spaces. > + return 0; > + } > + extension.insert(".", 0); 4 spaces. > + if (imageURL.isEmpty() == false) { > + fileName = KURL(element->document()->completeURL(parseURL(imageURL))).lastPathComponent(); Ditto. > + } else { > + fileName = element->getAttribute(altAttr); > + if (fileName.isEmpty()) Ditto. > + HGLOBAL imageFileDescriptor = createGlobalImageFileDescriptor(url.string(), fileName, cachedImage); > if (!imageFileDescriptor) > return; Ditto. 116041 7 mad 2009-03-31 10:55:28 -0700 OK, here is a summary of recent discussions (and a few open questions) about this: Suggestion: image->response().suggestedFilename() (which comes from the Content-Disposition) should have precedence of the file name extracted from the imageURL. Question 1: Should we also change the code that react to the contextual menu "Save image as..." to do the same? Other question: There are three ways of getting the file extension. 1) From the fileName itself (when it has one) 2) From MIMETypeRegistry::getPreferredExtensionForMIMEType(cachedImage->response().mimeType()) 3) From the image->image()->filenameExtension() What should be the precedence order? 116064 8 ap 2009-03-31 14:20:51 -0700 I don't have an answer to Chromium-specific design choices, but I have some more coding style nitpicks: + if (imageURL.isEmpty() == false) { + fileName = KURL(element->document()->completeURL(parseURL(imageURL))).lastPathComponent(); + } else { We don't use braces around single line blocks (sam issue repeated multiple times). Instead of comparing to false, the style is to use "!": if (!imageURL.isEmpty()) + extension = MIMETypeRegistry::getPreferredExtensionForMIMEType( cachedImage->response().mimeType()); This line isn't really long enough to break (I know that Google has stricter requirements on line length though). + fileName = KURL(element->document()->completeURL(parseURL(imageURL))).lastPathComponent(); Document::completeURL() returns a KURL, no need to copy it again here. 116175 9 dglazkov 2009-04-01 09:23:36 -0700 @ap, he's trying to make Safari 4 and Chromium do the same thing, so it's not just Chromium-specific. Who would be a good person to deem this good? @olliej, would you like to take a peek? 116184 10 29165 mad 2009-04-01 11:05:07 -0700 Created attachment 29165 More style fixes and reversed precedence If we agree on the precedence of the response().suggestedFilename(), this is what the code could be... Still unsure if we also want to change the Save As... context menu option though... 116195 11 29165 oliver 2009-04-01 11:52:45 -0700 Comment on attachment 29165 More style fixes and reversed precedence You can't trust the extension given by the file itself, that's why we explicitly override it with the extension we believe that mimetype should have. 116418 12 29225 mad 2009-04-03 06:24:35 -0700 Created attachment 29225 Fixed extension precendence and other details... HOw about this, if we accept the precedence of the content header filename? 116419 13 mad 2009-04-03 06:26:45 -0700 Oops... Wrong patch file... The new one is on its way... Sorry... 116457 14 29234 mad 2009-04-03 11:25:41 -0700 Created attachment 29234 THis is the one which fixes the extension and filename precedence... 116460 15 29234 fishd 2009-04-03 11:41:11 -0700 Comment on attachment 29234 THis is the one which fixes the extension and filename precedence... >Index: WebCore/platform/chromium/ClipboardChromium.cpp ... >+ String fileName = cachedImage->response().suggestedFilename(); >+ if (fileName.isEmpty()) { >+ String imageURL = element->getAttribute(srcAttr); why don't you use cachedImage->url() here? 116465 16 mad 2009-04-03 12:08:23 -0700 Cause I didn't know I can... I took that code going through the attribute in other parts of the code where we wanted the URL... Will this call always return the same thing as what we find in src attrib? I need to double check... 117036 17 mad 2009-04-09 08:16:55 -0700 Ping? 117319 18 29431 mad 2009-04-13 11:44:49 -0700 Created attachment 29431 New version with a fix to a small goof... re-ping? 122068 19 29431 eric 2009-05-19 22:38:20 -0700 Comment on attachment 29431 New version with a fix to a small goof... Why is the filename fallback stuff not in some shared code? It seems like all WebKit implementations would want the same "try http header, then url, then alt tag" behavior, no? 130441 20 dglazkov 2009-07-08 09:11:15 -0700 Marc, have you given up on this bug? :) 133164 21 jon 2009-07-20 10:22:58 -0700 Someone needs to pick this patch up and finish the work. It is hard to believe that dragging and dropping still gives the wrong name when a patch has been this close to being completed for months. 133278 22 jens 2009-07-20 15:52:17 -0700 Chromium team has asked me to pick up this fix and finish the job. I'll look over Marc-André's last patch and see about moving it into shared code so both Chromium and WinSafari can use it. 137067 23 34076 jens 2009-08-04 11:14:43 -0700 Created attachment 34076 New patch (by Jens) This is a new patch incorporating code from the previous one, but heavily rewritten. The core code for determining the filename has been moved to HTMLImageElement so it can be used in other circumstances (such as Safari for Windows; I don't feel competent to make the changes to hook it up for there, though.) I've also implemented ClipboardChromium::validateFilename for the Mac platform. I'm not aware of a way to create a layout test for this, since it would have to involve simulating a drag out of the browser to the filesystem, and then accessing the filesystem to check the name of the resulting file. 137071 24 34076 oliver 2009-08-04 11:37:13 -0700 Comment on attachment 34076 New patch (by Jens) > Index: WebCore/ChangeLog > =================================================================== > --- WebCore/ChangeLog (revision 46768) > +++ WebCore/ChangeLog (working copy) > @@ -1,3 +1,26 @@ > +2009-08-04 Jens Alfke <snej@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Bug 24887 - Wrong filename when dragging an image to the Desktop. > + Adds functionality to HTMLImageElement to determine the filename to use. > + Modifies ClipboardChromium to use it when setting up the drag. > + Implements validateFileName for Mac Chromium (limits name to 255 UTF-8 bytes.) > + https://bugs.webkit.org/show_bug.cgi?id=24887 > + > + No tests; I don't know if this behavior can be simulated for a test. You can make DRT dump the content of a pasteboard -- it should not be hard to add support if DRT does not already support this. > + > +String HTMLImageElement::suggestedFilename() const > +{ > + String fileName; > + > + // We try to use the suggested filename in the http header first. > + CachedImage* cachedImage = this->cachedImage(); > + if (cachedImage && cachedImage->image() && cachedImage->isLoaded()) > + fileName = cachedImage->response().suggestedFilename(); > + > + if (fileName.isEmpty()) { > + // Then, if there's none, we try to extract the filename from > + // the image URL stored in the src attribute. > + KURL src = this->src(); > + if (src.isValid()) > + fileName = src.lastPathComponent(); > + // If there's none, we then try the alt tag if one exists. > + if (fileName.isEmpty()) > + fileName = this->altText(); > + } > + > + // Leading or trailing '.'s are naughty. In appropriate comment. Also this code looks really similar to the code in other platforms. > + while (fileName.startsWith(".")) > + fileName.remove(0,1); > + while (fileName.endsWith(".")) > + fileName.remove(fileName.length()-1, 1); > + > + // We can't rely on the filename extension, so we must remove it > + // and use the one registered with the MIME type. > + int extension_index = fileName.reverseFind('.'); > + if (extension_index != -1) > + fileName.truncate(extension_index); > + if (!fileName.isEmpty()) { > + String extension = MIMETypeRegistry::getPreferredExtensionForMIMEType(cachedImage->response().mimeType()); > + fileName += "."; > + fileName += extension; > + } > + return fileName; > +} This code should not be on HTMLImageElement, it should probably be shared code on the root Clipboard class so that it's available to all ports in a simple way. > Index: WebCore/platform/chromium/ClipboardChromium.cpp > =================================================================== > --- WebCore/platform/chromium/ClipboardChromium.cpp (revision 46767) > +++ WebCore/platform/chromium/ClipboardChromium.cpp (working copy) > @@ -36,6 +36,7 @@ > #include "FileList.h" > #include "Frame.h" > #include "HTMLNames.h" > +#include "HTMLImageElement.h" > #include "NamedAttrMap.h" > #include "MIMETypeRegistry.h" > #include "markup.h" > @@ -259,33 +260,33 @@ static CachedImage* getCachedImage(Eleme > return 0; > } > > -static void writeImageToDataObject(ChromiumDataObject* dataObject, Element* element, > - const KURL& url) > +void ClipboardChromium::writeImageToDataObject(Element* element) > { > - // Shove image data into a DataObject for use as a file > + if (element->tagName() != "IMG") > + return; This is wrong -- you should always use the tag constants, this requires encoding and a string compare rather than a simple pointer check and matches no other code anyway in webcore. It is also unsafe due to > + // Pick a filename and split out the extension. > + String fileName = ((HTMLImageElement*)element)->suggestedFilename(); This. Your code will attempt to treat anything with the tag "IMG" to HTMLImageElement which is unsafe -- foo:img is not the same as html:img. Also WebKit coding standards prohibit C-style casts. > Given all this code was fairly directly copied from ClipboardWin i would expect it to be fairly obvious how to refactor this to share code. Realistically Clipboard should really be devirtualised and have more code shared between the ports, that way each port doesn't have to fixed these bugs separately. Such a refactoring would be a Good Thing, and i think should be done as cleanup prior to fixing this bug. 137083 25 jens 2009-08-04 12:08:38 -0700 > You can make DRT dump the content of a pasteboard Could you elaborate, or point me at a layout test that does this kind of thing? I don't have much experience writing layout tests. > Also this code looks really similar to the code in other platforms. I don't follow -- there's no platform here, HTMLImageElement is shared code. If there's a utility I should be calling to do this, let me know what it is. >This code should not be on HTMLImageElement, it should probably be shared code >on the root Clipboard class I disagree. The filename is an attribute of the image itself, not of the clipboard. And there are things other than the clipboard that might want the filename (such as the Save As... command.) > This is wrong -- you should always use the tag constants I'll fix that. > Given all this code was fairly directly copied from ClipboardWin i would expect > it to be fairly obvious how to refactor this to share code. I factored as much as possible -- determining the filename -- into HTMLImageElement. The various platform implementations of Clipboard are very different. For example, ClipboardMac delegates the entire implementation of declareAndWriteDragImage to a Mac-specific helper method in DragClient. > Such a refactoring would be a Good Thing, and i think should be > done as cleanup prior to fixing this bug. The Clipboard subclasses are pretty platform-specific; I don't see a lot of other stuff that could be factored out. If you want to make that a prerequisite for fixing this, I'm not qualified to do that, as I'm new to WebKit and have no experience with GUI APIs for Windows or Linux. This bug has already been sitting around for months unfixed, despite being 90% done; the Chromium team wants to fix it for the next milestone release. I think it would be a good idea to fix this user-visible bug before planning any nice-to-have refactoring of the code. 137088 26 oliver 2009-08-04 12:21:39 -0700 (In reply to comment #25) > > You can make DRT dump the content of a pasteboard > > Could you elaborate, or point me at a layout test that does this kind of thing? > I don't have much experience writing layout tests. Look at the other drag and drop tests in webkit -- they should show you how to initiate a drag, etc, then all you need to do is add an API along the lines of getFilenameForClipboardContent() or whatever that returns the filename. Then you can have a test case and we can ensure this does not regress. > > > Also this code looks really similar to the code in other platforms. > > I don't follow -- there's no platform here, HTMLImageElement is shared code. If > there's a utility I should be calling to do this, let me know what it is. That comment was made before i realised it was in htmlimagelement > > >This code should not be on HTMLImageElement, it should probably be shared code > >on the root Clipboard class > > I disagree. The filename is an attribute of the image itself, not of the > clipboard. And there are things other than the clipboard that might want the > filename (such as the Save As... command.) CachedImage would seem to be a better place then, as you're ruling out SVGImageElement as well in that case. > > Given all this code was fairly directly copied from ClipboardWin i would expect > > it to be fairly obvious how to refactor this to share code. > > I factored as much as possible -- determining the filename -- into > HTMLImageElement. The various platform implementations of Clipboard are very > different. For example, ClipboardMac delegates the entire implementation of > declareAndWriteDragImage to a Mac-specific helper method in DragClient. However the only difference between windows and chromium is how they write to the system clipboard -- everything leading up to that point is identical. The correct fix for this would be to refactor the initial platform independent code to be the general entry point for all platforms other that mac (which still has a few pieces of cruft where we call out to a client to preserve historic behaviour -- this is not a good thing, it just hasn't yet been fixed). Then use a (new) low level function on Clipboard to do the final write -- providing the data and appropriate filename -- which can be per-platform. This should not be a hard thing to do. > > > Such a refactoring would be a Good Thing, and i think should be > > done as cleanup prior to fixing this bug. > > The Clipboard subclasses are pretty platform-specific; I don't see a lot of > other stuff that could be factored out. If you want to make that a prerequisite > for fixing this, I'm not qualified to do that, as I'm new to WebKit and have no > experience with GUI APIs for Windows or Linux. They already have the code the does the writing to clipboard, all you're doing is factoring out the name selection. > > This bug has already been sitting around for months unfixed, despite being 90% > done; the Chromium team wants to fix it for the next milestone release. I think > it would be a good idea to fix this user-visible bug before planning any > nice-to-have refactoring of the code. And if you do some minimal refactoring you can actually fix the bug in webkit, rather than fixing the bug in chromium. 137103 27 jens 2009-08-04 13:13:59 -0700 > CachedImage would seem to be a better place then Actually I looked at that earlier, but it doesn't have a reference to the Element so it can't get the 'src' or 'alt' attributes. > the only difference between windows and chromium is how they write to > the system clipboard -- everything leading up to that point is identical. Less identical than it looks, unfortunately. Chromium "m_dataObject" and WIn "m_writableDataObject" are entirely different classes (the Win one appears to be a COM object!) The parts that look like they could be factored out are: 1. The filename 2. The image data 3. The absolute form of the source URL I could have the base class derive these, and add them as extra parameters to the declareAndWriteDragImage method. To avoid breaking existing code, I can implement the existing four-parameter method in the base class, and have it derive the above values and call a new seven-parameter version of the method. ClipboardChromium and ClipboardWin can then just implement the latter method. Other subclasses won't be affected, but later on they can simplify their code in the same way. 137326 28 jens 2009-08-05 10:01:09 -0700 I'm investigating the layout test. It's a lot more involved than it looks, because it gets into the always-tricky area of "file promises" (as they're called on Mac OS), i.e. dragging a file that doesn't exist yet. I can use the HTML5 drag-n-drop API to examine the drag's dataTransfer object. However, this doesn't actually contain any information about the filename. Even the raw NSPasteboard doesn't have the info -- as Apple's "Drag & Drop Programming Topics For Cocoa" puts it: "Before the drag is actually dropped, a potential dragging destination does not have access to the filenames of the files being promised. Only the file types are available from the pasteboard." To get the filenames, I'd need some native code that calls -namesOfPromisedFilesDroppedAtDestination: on the NSDraggingInfo object. I can add a JS glue method to do this, but I don't know how this method would acquire the NSDraggingInfo corresponding to the current drag operation... Of course, all the above is specific to Mac OS. Someone would need to implement similar functionality for every other platform (that goes both for WebKit and for Chromium, which has its own very different implementation of DRT.) 137376 29 jens 2009-08-05 12:31:13 -0700 I've experimented with UIDelegate.mm in DRT and there doesn't seem to be any way, with existing APIs, to get the actual NSDraggingInfo. When the fake drag starts, the -webView:(dragImage:at:... delegate method is called, but it isn't given the draggingInfo object. During the drag, -webView:(dragDestinationActionMaskForDraggingInfo: is called, but it's passed the fake DumpRenderTreeDraggingInfo object that the previous delegate method created. -webView:willPerformDragSourceAction:fromPoint:withPasteboard: is called on drop, but it isn't passed the dragging info. So it seems like, at a minimum, some kind of SPI would need to be plumbed into WebView to make the real draggingInfo accessible. Then it could be captured by DRT, and a new JS accessor could be written so the tests could look at it. This is seeming kind of excessive for just a test for a minor bug-fix. 137377 30 oliver 2009-08-05 12:35:53 -0700 DRT does not use that standard system pasteboard, that's how we do things like the addFileToPasteboard() tests. It should be trivial to add logic to that to be able to query sensibly. (In reply to comment #29) > I've experimented with UIDelegate.mm in DRT and there doesn't seem to be any > way, with existing APIs, to get the actual NSDraggingInfo. > When the fake drag starts, the -webView:(dragImage:at:... delegate method is > called, but it isn't given the draggingInfo object. > During the drag, -webView:(dragDestinationActionMaskForDraggingInfo: is called, > but it's passed the fake DumpRenderTreeDraggingInfo object that the previous > delegate method created. > -webView:willPerformDragSourceAction:fromPoint:withPasteboard: is called on > drop, but it isn't passed the dragging info. > > So it seems like, at a minimum, some kind of SPI would need to be plumbed into > WebView to make the real draggingInfo accessible. Then it could be captured by > DRT, and a new JS accessor could be written so the tests could look at it. > > This is seeming kind of excessive for just a test for a minor bug-fix. 137383 31 34160 jens 2009-08-05 12:44:29 -0700 Created attachment 34160 Updated patch, refactoring Clipboard class As I described above, this patch moves most of the code into the base Clipboard class. The existing declareAndWriteDragImage method is retained for compatibility (to avoid having to modify every subclass) but it now has a base implementation that invokes a new overloaded variant that's passed the important info like the image data, filename, and HTML markup. Subclasses can now just override the new method; I've changed ClipboardChromium to do this. No layout tests are added. See above comments on the difficulty of testing this functionality. 137389 32 34160 darin 2009-08-05 12:50:52 -0700 Comment on attachment 34160 Updated patch, refactoring Clipboard class > +#include "Element.h" > #include "Frame.h" > #include "FrameLoader.h" > +#include "HTMLImageElement.h" Since Element is a base class of HTMLImageElement, you never need to add both these includes. Please add the minimum number of includes. For some reason this is marked review- so I won't try to review any more of it. 137396 33 jens 2009-08-05 13:00:20 -0700 > DRT does not use that standard system pasteboard, that's how we do things like > the addFileToPasteboard() tests. It's not the pasteboard that matters -- the filename is never put on the pasteboard. it's the DraggingInfo object's -namesOfPromisedFilesDroppedAtDestination: method that needs to be called, and I don't see how to get ahold of that object, which is created down inside WebKit. > It should be trivial to Please stop using the word 'trivial' unless you also back it up by providing detailed info about the 'trivial' changes to be made. Thanks. 137397 34 34163 jens 2009-08-05 13:02:15 -0700 Created attachment 34163 Patch with extra include removed Removed redundant #include found by Darin. 137421 35 34163 darin 2009-08-05 13:45:20 -0700 Comment on attachment 34163 Patch with extra include removed I know you're just moving code, but I'm reviewing it as if newly written. > + No tests; would be unreasonably difficult to add the plumbing to access the proposed > + filename from within DRT. Tab in change log will make it impossible to land it as-is. > +static CachedImage* getCachedImage(Element* element) In WebKit we normally don't use get in function names when the function has a result. For those we just use nouns or adjectives. Instead get is reserved for functions with out parameters. However, there's a good chance you moved this from elsewhere and the name is not new. Also, this function doesn't do anything that requires an Element* so you might want to consider making its argument a Node* instead. > + RenderImage* image = toRenderImage(renderer); > + if (image->cachedImage() && !image->cachedImage()->errorOccurred()) > + return image->cachedImage(); Normally we like to make return early for the error, and put the success case in the main line of the function. > + String srcURL; > + AtomicString imageURL = element->getAttribute(HTMLNames::srcAttr); The optimal type for this sort of thing is const AtomicString& -- it avoids a bit of reference count churn. We normally do using namespace HTMLNames at the top of source files rather than qualifying the names within the file. The names have distinctive naming that means there's rarely a cross-namespace conflict. > + if (!imageURL.isEmpty()) > + srcURL = frame->document()->completeURL(deprecatedParseURL(imageURL)); Is this check needed? Document::completeURL already returns KURL() if the passed-in string is null. Maybe the check is needed because of non-null empty strings? > + markup.append("<img src=\""); > + markup.append(srcURL); > + markup.append("\""); Is the quoting right here. Does this work for URLs with quote marks in them? Ampersands? > + // Copy over attributes. If we are dragging an image, we expect things like > + // the id to be copied as well. If this was new code I'd point out we should not > + if (attr->localName() == "src") > + continue; This can be done more efficiently with the srcAttr value from HTMLNames rather than doing a string comparison. > + escapedAttr.replace("\"", "&quot;"); Is this the only escaping that's needed? I'd expect that at least "&" would need escaping to "&amp;" as well. > + // Get the image data (abort if there is none). The word "abort" seems a little strange here. > + SharedBuffer* imageBuffer = NULL; New code in WebKit uses 0 for this, not NULL. > + String htmlMarkup = imageToMarkup(element,frame); Missing space after comma. > + this->declareAndWriteDragImage(url, title, imageBuffer, fileName, htmlMarkup); No need for "this->" here. > +void Clipboard::declareAndWriteDragImage(const KURL&, const String&, > + SharedBuffer*, const String&, > + const String&) We normally don't indent like this for multiple line function declarations. > +{ > + // This method is abstract; a subclass must override it, or the public version that calls it. > + ASSERT_NOT_REACHED(); > +} This is an anti-pattern for WebKit. We prefer to use pure virtual functions when possible instead. But I suppose there's no avoiding it if there are two possible functions you could override. Yuck. > #include "HTMLFormElement.h" > #include "HTMLNames.h" > #include "MappedAttribute.h" > +#include "MIMETypeRegistry.h" > #include "RenderImage.h" > #include "ScriptEventListener.h" These are supposed to be case-sensitive sorted, so I think MIME comes before Mapped. Sorry. That's kind of insane but we want to stay specific. You could try the new check-webkit-style script perhaps. > + KURL src = this->src(); > + if (src.isValid()) > + fileName = src.lastPathComponent(); The isValid check here is not needed, since lastPathComponent is guaranteed to return the null string if the URL is not valid. > + fileName = this->altText(); No need for this-> here. > + while (fileName.startsWith(".")) > + fileName.remove(0,1); > + while (fileName.endsWith(".")) > + fileName.remove(fileName.length()-1, 1); Need spaces around the "-1". This is a unnecessarily inefficient way to strip these dots, but perhaps that doesn't really matter. A more efficient way would mutate the string only once using substring. > +static void splitFileName(const String &fileName, String &outBaseName, String &outExtension) WebKit coding style puts the & characters next to the type name, not the variable name. > + int extension_index = fileName.reverseFind('.'); WebKit coding style forbids the use of underscores in multiple word variable names like this. Instead we would call it extensionIndex. > -void ClipboardChromium::declareAndWriteDragImage(Element* element, const KURL& url, const String& title, Frame* frame) > +void ClipboardChromium::declareAndWriteDragImage(const KURL& url, const String& title, > + SharedBuffer* imageBuffer, const String& fileName, > + const String& htmlMarkup) This multi-line style with the subsequent lines lined up with the "(" is not the WebKit style I don't think. I could be wrong on this one. I never do it, but it might be considered an acceptable style. > class ChromiumDataObject; > + class Element; > class IntPoint; I'm surprised this needed to be added. The old file already used Element* but didn't have it. > + protected: > + virtual void declareAndWriteDragImage(const KURL& url, const String& title, > + SharedBuffer* imageBuffer, const String& fileName, > + const String& htmlMarkup); It seems to me this should be private, not protected. The general rule would be to make things as private as possible, and not make something protected just because it was protected in the base class. Also, it is WebKit style to omit names like "url" in this declaration that add nothing beyond what the type adds. > + void writeImageToDataObject(Element*); Why are you adding this declaration? I don't see any definition of this newly-added member function. > +// On HFS+ the maximum length of a filename is 255 UTF-8 bytes. Other filesystems > +// have different limits, but this is the most common, so use it. > +static const int MaxFilenameLengthBytes = 255; Doesn't sound quite right to me, but I guess you're enough of a Mac expert that I'll bow to your judgement on this. > + String result = title.removeCharacters(&isInvalidFileCharacter); > + String extension = dataObject->fileExtension.removeCharacters(&isInvalidFileCharacter); No need for the "&" characters here. review- for now 137425 36 oliver 2009-08-05 13:54:33 -0700 > > It should be trivial to > > Please stop using the word 'trivial' unless you also back it up by providing > detailed info about the 'trivial' changes to be made. Thanks. Alas you are indeed right, it is trivial to get the extension, but not any of the rest of the filename :-/ I'd still be tempted to test this, even if it's a windows only test 137448 37 jens 2009-08-05 14:46:55 -0700 Responding to comments -- other than as noted below, I've made the changes, and will have a new patch ready for review in a few minutes. >Is this check needed? Document::completeURL already returns KURL() if the >passed-in string is null. Maybe the check is needed because of non-null empty >strings? I don't know; this came from the earlier patch I was adapting. I don't know the String/URL classes well so I'm loath to touch this unless you think it's important to remove the check. >Is the quoting right here. Does this work for URLs with quote marks in them? >Ampersands? Likewise, I don't know, but that's a very good point. This code seems to have been expanded from imageToMarkup() in ClipboardWin.cpp, which has the same issue. The URL string shouldn't have quotes in it, but that assumes the URL class made sure to encode them; I don't know if it does. Both the URL and attribute values can contain ampersands. These ought to be quoted (although browsers seem to be lenient about it; a lot of HTML coders don't seem to know about that rule.) Is there any utility code elsewhere in WebCore that generates HTML, that could be called here instead? >New code in WebKit uses 0 for this, not NULL. I just saw that in the style guide. Mixing up pointers and integers this way seems like a bad idea to me, but I'll follow it. >We normally don't indent like this for multiple line function declarations. I can't find anything in the style guide about breaking up long lines, and I looked around but didn't see any multiline declarations. Does WebKit just keep everything on one long line? (This is the way Xcode indents it by default, and I find it more readable.) >This is an anti-pattern for WebKit. We prefer to use pure virtual functions >when possible instead. But I suppose there's no avoiding it if there are two >possible functions you could override. Yuck. I wanted to preserve the existing method, to avoid having to modify every platform's subclass of Clipboard, and that led to this structure. Sorry. Maybe when/if the other platforms move to using the new method, it can then be made pure-virtual. >This is a unnecessarily inefficient way to strip these dots Yes, but this isn't performance-sensitive code, and this way is extremely simple and safe. >It seems to me this should be private, not protected. The general rule would be >to make things as private as possible, and not make something protected just >because it was protected in the base class. In general OOP design it doesn't make sense for a subclass to make an overridden method more private, because it can still be called through the base class interface. I believe it's actually a compile error in Java, for example. But I've changed it to 'private' and GCC seemed to allow it. 137964 38 34290 jens 2009-08-07 10:33:15 -0700 Created attachment 34290 patch, responding to Darin's review This addresses the points made in Darin's review. In particular, imageToMarkup() now escapes both double-quotes and ampersands, in all attributes including src. Also, I had doubts about the HFS+ filename limits, so I looked them up and found it's actually 255 Unicode characters, not bytes. (I think I was mis-remembering an old thread on macosx-dev-internal; the UTF-8 limit might be in ext3.) 137976 39 34290 eric 2009-08-07 10:47:58 -0700 Comment on attachment 34290 patch, responding to Darin's review Isn't the plumbing already there? You do a drag of an image, with eventSender and then look at what the URLs are on the clipboard. This should all be possible from DRT today, no? There are lots of examples of starting drags in DRT using eventSender.mouseDown(), eventSender.leapForward(), eventSender.mouseMove(), and there are also examples of inspecting the clipboard (event.dataTransfer), which you can do on a drop event. What I don't understand is why this is such a huge amount of code. Is this more than one fix? It's very difficult to understand what's going on in a patch this large, making it difficult to review. Is a bunch of this refactoring which coudl be done first before the actual code change? Also, welcome (back to?) WebKit Jens. :) r- for lack of test (or at least in need of more explaination as to why the above proposed testing strategy would not work.) The code i'm proposing: var dragStart = document.createElement('img'); dragStart.src = "imageName.png"; document.body.appendChild(dragStart); var dragEnd = document.createElement('div'); dragEnd.style.cssText = "width: 100px; height: 100px;" document.body.appendChild(dragEnd); // get the x/y middle of dragStart and dragEnd (see examples in the layout tests). dragEnd.ondrop = function() { event.dataTransfer.getData("URLS"); // do whatever you need to do here. } eventSender.mouseMove(startX, startY); eventSender.mouseDown(); eventSender.leapForward(1000); // to bypass the mac drag delay eventSender.mouseMove(endX, endY); eventSender.mouseUp(); Ideally the test would be dumpAsText with a bunch of nice pass/fail messages, which you would get for free if you use the fast/js testing framework. Search for TEMPLATE.html in the LayoutTests for examples of these types of tests. You write a .js file and then make-js-test-wrappers generates a wrapper for you using the TEMPLATE.html file found in the same directory. 137990 40 jens 2009-08-07 11:18:54 -0700 >Isn't the plumbing already there? You do a drag of an image, with eventSender >and then look at what the URLs are on the clipboard. This should all be >possible from DRT today, no? No. :) You're confusing the source URL with the promised filename. The promised filename is what's being affected by this patch, and it does not appear on the dragging pasteboard. The system drag APIs do not make it available until the drop occurs, and even then only via the DraggingInfo object, not the pasteboard. If you're still doubtful, you could go talk to Oliver about it, since he seemed convinced after a couple of iterations of these same arguments. >What I don't understand is why this is such a huge amount of code. Is this >more than one fix? It's very difficult to understand what's going on in a >patch this large, making it difficult to review. Is a bunch of this >refactoring which coudl be done first before the actual code change? It _was_ a reasonable size patch written by somebody else a few months ago, which was rejected for putting the logic into the ClipboardChromium class (which is where the bug was found) instead of somewhere that it could be shared by other implementations. So I added that. Then it was rejected for not factoring out more logic into the base Clipboard class. So I added that too. The changes to ClipboardChromium could be broken into a later patch. However, that would put the first patch in the weird situation of consisting entirely of unreachable code, since it's only ClipboardChromium that uses the new stuff added to the base class (so far). You could pretend this is two patches by just reading down through HTMLImageElement.h (line 232) as a self-contained patch; taking a coffee break; and then coming back and reading the rest as though it were a dependent follow-on patch. :-) 137992 41 34290 jens 2009-08-07 11:20:09 -0700 Comment on attachment 34290 patch, responding to Darin's review Setting review status back to "?" after responding to Eric's comments. 137993 42 34290 oliver 2009-08-07 11:22:01 -0700 Comment on attachment 34290 patch, responding to Darin's review I said it still needs a test, it just can't be tested on mac -- on windows we provide the filename explicitly so are perfectly able to test (similar may be true of the gtk and qt builds) 137995 43 34290 darin 2009-08-07 11:26:40 -0700 Comment on attachment 34290 patch, responding to Darin's review > + markup.append(" />"); Does this make HTML markup or XHTML? I'm asking because in HTML there is no meaning to "/>" and using it is probably not a good idea. > + fileName.remove(0,1); Missing space after comma here. 137997 44 jens 2009-08-07 11:30:11 -0700 > Does this make HTML markup or XHTML? This came from the earlier patch. My understanding is that the "/>" is harmlessly ignored in HTML mode by all modern browsers (provided the tag is defined as self-closing in HTML.) I can take this out though. And I'll add a space after the comma. 138003 45 34300 jens 2009-08-07 11:38:50 -0700 Created attachment 34300 Patch, fixing 2 more issues from Darin Fixed the "/>" and added a space after a comma. To respond to Oliver: Point taken. But the required test code would be platform-specific (adding native code to DRT to inspect the Windows drag object, or at least using JS to check for some Windows-specific drag data type) and I do not have the knowledge of those APIs needed to write such a test. 138009 46 oliver 2009-08-07 11:44:10 -0700 > To respond to Oliver: Point taken. But the required test code would be > platform-specific (adding native code to DRT to inspect the Windows drag > object, or at least using JS to check for some Windows-specific drag data type) > and I do not have the knowledge of those APIs needed to write such a test. Given this bug is actually specific to windows you cannot *not* test on windows, anyhoo it will be a learning experience :D You can learn to hate windows as we do :D 138013 47 jens 2009-08-07 11:46:50 -0700 It's not specific to Windows. It occurs on all platforms of Chrome, since they share the same Clipboard subclass. I made sure I could reproduce it on my Mac before I started working on it. 138015 48 jens 2009-08-07 11:48:56 -0700 Forgot to add: There's also a difference between testing on Windows, and writing Windows-specific test code. I have VMWare installed and can run Chromium on Windows. What I don't have is the knowledge of Windows APIs. 138018 49 oliver 2009-08-07 11:50:20 -0700 (In reply to comment #48) > Forgot to add: There's also a difference between testing on Windows, and > writing Windows-specific test code. I have VMWare installed and can run > Chromium on Windows. What I don't have is the knowledge of Windows APIs. This is testable on windows, therefore it needs a test, there is no point in arguing over this. 138047 50 jens 2009-08-07 12:38:12 -0700 Then we appear to be stymied. I have no idea how to write such a Windows-specific test. Eric's example above isn't correct -- I assume he meant "URL" as the parameter to getData(), but that returns the source URL of the original image, not the proposed filename. If the proposed filename does show up in the DataTransfer object on Windows, then please tell me the type name to access it with, and I can write a test and try it out on WIndows. Similarly for GTK; I suppose the test could check for multiple platform-specific types. Then maybe the test could check the User-Agent header to see if it's running on Mac, and in that case skip the check. Thanks. 138066 51 34300 darin 2009-08-07 12:59:17 -0700 Comment on attachment 34300 Patch, fixing 2 more issues from Darin > + value.replace("&", "&amp;"); > + value.replace("\"", "&quot;"); There is a faster version of replace that takes a character for the first parameter. You should use that. > + markup.append(" "); > + markup.append(name); > + markup.append("=\""); > + markup.append(value); > + markup.append("\""); There is a version of append that takes a single character. You should use that when possible. > + markup.append(">"); Here too. > +} > + > + > > } // namespace WebCore Although there's no firm policy against it, I prefer not to add this additional vertical space. I guess we can live with this without any further testing. Normally we work very hard to make such things testable when fixing bugs in them. r=me 138074 52 34300 darin 2009-08-07 13:03:28 -0700 Comment on attachment 34300 Patch, fixing 2 more issues from Darin We really *do* need a Windows test case here, and I also think it would be worthwhile to make it testable on Mac. Your "would be unreasonably difficult" comment seems wrong to me. We normally make things testable rather than making excuses like that. It seems you've decided it's too difficult without spending much time on it. Is there a big hurry here? 138095 53 jens 2009-08-07 13:25:21 -0700 I spent the better part of a day digging through the DRT source code (both the WebKit and Chromium versions) and the upper layers of WebKit, trying to figure out how to get to this data. More time than it took to write the code for the patch. I agree that it's important to make everything testable. It's also important to make everything run fast, and have lots of features, and readable source code, and ship on time. Engineering is trade-offs, we all know that, so you can't meet all those goals at once. My determination was that the expense of adding testability for this was well in excess of the value of that testability, given that this is a fairly minor bug I'm fixing; that's what I meant by "unfeasible difficult". I can write a platform-specific (non-Mac) test case if Oliver (or someone else) can tell me the exact data-type string to check for on various platforms. 138099 54 34318 jens 2009-08-07 13:28:02 -0700 Created attachment 34318 patch Uses char versions of String operations. 138117 55 oliver 2009-08-07 13:45:42 -0700 > I agree that it's important to make everything testable. It's also important to > make everything run fast, and have lots of features, and readable source code, > and ship on time. Engineering is trade-offs, we all know that, so you can't > meet all those goals at once. My determination was that the expense of adding > testability for this was well in excess of the value of that testability, given > that this is a fairly minor bug I'm fixing; that's what I meant by "unfeasible > difficult". I've spent 3 days writing support for testing a change that took half an hour. More over adding support for this testing may prove helpful in the future as well. 138171 56 jens 2009-08-07 14:52:24 -0700 I did some more digging; here's what I found. For Mac WebKit (i.e. Safari), the actual logic for computing the filename isn't in Clipboard, or WebCore, at all. It's up in -[WebHTMLView namesOfPromisedFilesDroppedAtDestination:]. This code isn't reachable in DRT, because in order to make drag-and-drop programmatically controllable, DRT fakes out the entire operation, using its own mock draggingSource and draggingInfo. The real draggingInfo implementation (which is in WebHTMLView) doesn't get involved. So, to actually test this would require rewriting the drag-n-drop support in DRT to make the WebHTMLView think it's involved in a real drag, but still without really starting a drag. But! This wouldn't actually test my patch, because as I said, the Mac-WebKit code that determines the file name isn't in Clipboard and doesn't use the code I changed. So writing a Mac test that actually tests my patch would _also_ require rewriting the MacClipboard (and WebHTMLView) code for managing dragging an image, to make it more in line with the other platform implementations. That looks like a big job, and would also make this already-large patch much larger. And to be realistic, I don't think rewriting MacClipboard is something my management at Google would want me to spend time on, since Chrome doesn't even use that code at all. As I said above, I think I can write a Windows-specific test if someone tells me what data type name to look for in the datatransfer object. 138185 57 oliver 2009-08-07 15:22:06 -0700 (In reply to comment #56) > I did some more digging; here's what I found. > For Mac WebKit (i.e. Safari), the actual logic for computing the filename isn't > in Clipboard, or WebCore, at all. It's up in -[WebHTMLView > namesOfPromisedFilesDroppedAtDestination:]. This code isn't reachable in DRT, > because in order to make drag-and-drop programmatically controllable, DRT fakes > out the entire operation, using its own mock draggingSource and draggingInfo. > The real draggingInfo implementation (which is in WebHTMLView) doesn't get > involved. > So, to actually test this would require rewriting the drag-n-drop support in > DRT to make the WebHTMLView think it's involved in a real drag, but still > without really starting a drag. > But! This wouldn't actually test my patch, because as I said, the Mac-WebKit > code that determines the file name isn't in Clipboard and doesn't use the code > I changed. > So writing a Mac test that actually tests my patch would _also_ require > rewriting the MacClipboard (and WebHTMLView) code for managing dragging an > image, to make it more in line with the other platform implementations. That > looks like a big job, and would also make this already-large patch much larger. > And to be realistic, I don't think rewriting MacClipboard is something my > management at Google would want me to spend time on, since Chrome doesn't even > use that code at all. Actually i suspect they wouldn't mind, however i agree that given this code doesn't effect mac it is unnecessary to do such refactoring for this patch (although a bug suggesting this refactoring would probably be a good thing). Like i said though a windows test is a must because this patch does have an observable impact on windows. Anyhoo, the type i think you want to be querying the data object for on windows is CFSTR_FILEDESCRIPTOR -- you can probably get a good idea of what is necessary in ClipboardWin and PasteboardWin's writeImage* method (look at writeImageToDataObject for the writing side)... actually ClipboardUtilitiesWin has code that reads a filename in getURL, you can probably crib that and copy to drt's win and chromium/win ports. I quick search through the repository shows that there's a WCDataObject used by the main windows port, but there's also a ChromiumDataObject so there may be people at google who can help you more directly. 138327 58 34318 eric 2009-08-08 07:44:18 -0700 Comment on attachment 34318 patch I believe you meant to mark this as a patch file. Note if you use a script like "bugzilla-tool post-diff" or "bugzilla-tool post-commits" or git-send-bugzilla it will automatically setup the attachment flags (including review) for you. 138330 59 34318 eric 2009-08-08 07:51:01 -0700 Comment on attachment 34318 patch Given Oliver's comment above about what to look for on the clipboard, marking r- while we wait for a response or test case. I wonder if we really want the suggested filename code on HTMLImageElement. Seems like something that would apply for <video> and <audio> elements eventually too, no? Depends on what browsers chose to make the drag behavior for these objects. Also, I would think <svg> image elements would need this same image code. If you're successful in creating a test case, and add an SVG image element to your test, I think you'll find that we "fail" the SVG image element drags after this patch. 140764 60 jens 2009-08-17 11:05:28 -0700 I've been bringing up a Windows dev environment and building WebKit on it. Unfortunately the first thing I discovered is that all dragging on Windows is currently broken: dragging anything inside a web view causes a crash. This was reported a month ago as 27332 but no one seems to have investigated it yet. That pretty much stymies me from writing any test cases until that bug is fixed. >I wonder if we really want the suggested filename code on HTMLImageElement. >Seems like something that would apply for <video> and <audio> elements Sure, but the logic for which attribute(s) to check is different for each element. For <img> you check the "src" and "alt" attributes; I don't know what the corresponding attributes for the other elements would be. So there'd need to be a base implementation of suggestedFilename on Element, which probably does nothing, and then concrete implementations for the various elements that support it. Sounds like a good idea for a future commit, but this patch is big enough already. 142134 61 dglazkov 2009-08-22 11:16:03 -0700 Since we're blocked on Win crash fix to write a good test, can we submit this fix and file a bug about writing a test? Seems sad that this bug-fixing patch is just sitting here. 411693 62 95223 dcheng 2011-05-27 15:46:40 -0700 Created attachment 95223 Patch 411695 63 dcheng 2011-05-27 15:48:37 -0700 The original issue has been separately fixed in ClipboardWin it appears. I've taken the last patch and simplified it a bit and removed the refactoring of Clipboard. As much as I'd like to share code between ports, I'd rather address the brokenness in Chromium first since it's been around for more than 2 years. 412774 64 95223 tony 2011-05-31 12:14:24 -0700 Comment on attachment 95223 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=95223&action=review > Source/WebCore/ChangeLog:8 > + No new tests since iamge drags aren't accessible through event.dataTransfer.files. iamge -> image Is it possible to add plumbing to the WebKit layer to test this (e.g., by adding a method to eventSender)? 412835 65 dcheng 2011-05-31 13:40:56 -0700 (In reply to comment #64) > (From update of attachment 95223 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=95223&action=review > > > Source/WebCore/ChangeLog:8 > > + No new tests since iamge drags aren't accessible through event.dataTransfer.files. > > iamge -> image > Oops. I'll make sure to fix that before checking in. > Is it possible to add plumbing to the WebKit layer to test this (e.g., by adding a method to eventSender)? It'd have to be a method that takes a event.DataTransfer; presumably there is some way of getting a C++ object from the JS object, and then we'd be able to read the image file name in the drop. It doesn't seem like it belongs on EventSender though, since it seems to be primarily used to trigger DOM events... 412850 66 tony 2011-05-31 14:10:15 -0700 (In reply to comment #65) > (In reply to comment #64) > > Is it possible to add plumbing to the WebKit layer to test this (e.g., by adding a method to eventSender)? > > It'd have to be a method that takes a event.DataTransfer; presumably there is some way of getting a C++ object from the JS object, and then we'd be able to read the image file name in the drop. It doesn't seem like it belongs on EventSender though, since it seems to be primarily used to trigger DOM events... It could be on layoutTestController if you think that makes more sense. It could be a dump method (e.g., dumpFilenameCurrentlyBeingDragged()) so it doesn't have to take the current event.DataTransfer. Alternately, you could make a mode that printfs information whenever a drag event fires. For example, something like layoutTestController.dumpEditingCallbacks(). 412986 67 95510 dcheng 2011-05-31 16:41:35 -0700 Created attachment 95510 Patch 412987 68 dcheng 2011-05-31 16:42:42 -0700 (In reply to comment #66) > (In reply to comment #65) > > (In reply to comment #64) > > > Is it possible to add plumbing to the WebKit layer to test this (e.g., by adding a method to eventSender)? > > > > It'd have to be a method that takes a event.DataTransfer; presumably there is some way of getting a C++ object from the JS object, and then we'd be able to read the image file name in the drop. It doesn't seem like it belongs on EventSender though, since it seems to be primarily used to trigger DOM events... > > It could be on layoutTestController if you think that makes more sense. > > It could be a dump method (e.g., dumpFilenameCurrentlyBeingDragged()) so it doesn't have to take the current event.DataTransfer. Alternately, you could make a mode that printfs information whenever a drag event fires. For example, something like layoutTestController.dumpEditingCallbacks(). I think EventSender is an awkward place to put this, but I would really like to see this checked in rather than linger for another 2 years. 413009 69 95510 tony 2011-05-31 17:16:41 -0700 Comment on attachment 95510 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=95510&action=review Seems OK. Mostly small nits. > LayoutTests/fast/events/drag-image-filename.html:50 > +<p>This test requires DumpRenderTree. > + > +<div id="target" ondragenter="dragEnterOrOver(event)" ondragover="dragEnterOrOver(event)" ondrop="drop(event)"></div> > +<img id="source" src="resources/onload-image.png" alt="Does it work?"> Please include instructions for manually testing (e.g., drag the image to the desktop. The filename should be onload-image.png). > LayoutTests/platform/gtk/Skipped:1147 > +# EventSender::dumpFilenameBeingDragged not implemented. > +fast/events/drag-image-filename.html Please file bugs for each platform that fails and include the bug link in the Skipped files before landing. > Source/WebCore/ChangeLog:6 > + [chromium] Use correct file name for dragging out images. > + https://bugs.webkit.org/show_bug.cgi?id=24887 Please be more specific here. Like, "Prefer the last component of the URL for the filename over alt text when dragging out images." > Tools/DumpRenderTree/chromium/EventSender.cpp:348 > +void EventSender::dumpFilenameBeingDragged(const CppArgumentList& arguments, CppVariant* result) Nit: I think webkit style is to not name params that are unused. 413051 70 95526 dcheng 2011-05-31 18:20:17 -0700 Created attachment 95526 Patch 413054 71 95528 dcheng 2011-05-31 18:26:14 -0700 Created attachment 95528 Patch 413057 72 dcheng 2011-05-31 18:26:37 -0700 (In reply to comment #69) > (From update of attachment 95510 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=95510&action=review > > Seems OK. Mostly small nits. > > > LayoutTests/fast/events/drag-image-filename.html:50 > > +<p>This test requires DumpRenderTree. > > + > > +<div id="target" ondragenter="dragEnterOrOver(event)" ondragover="dragEnterOrOver(event)" ondrop="drop(event)"></div> > > +<img id="source" src="resources/onload-image.png" alt="Does it work?"> > > Please include instructions for manually testing (e.g., drag the image to the desktop. The filename should be onload-image.png). Done. > > > LayoutTests/platform/gtk/Skipped:1147 > > +# EventSender::dumpFilenameBeingDragged not implemented. > > +fast/events/drag-image-filename.html > > Please file bugs for each platform that fails and include the bug link in the Skipped files before landing. Done. > > > Source/WebCore/ChangeLog:6 > > + [chromium] Use correct file name for dragging out images. > > + https://bugs.webkit.org/show_bug.cgi?id=24887 > > Please be more specific here. Like, "Prefer the last component of the URL for the filename over alt text when dragging out images." > Done. > > Tools/DumpRenderTree/chromium/EventSender.cpp:348 > > +void EventSender::dumpFilenameBeingDragged(const CppArgumentList& arguments, CppVariant* result) > > Nit: I think webkit style is to not name params that are unused. Done. 413651 73 commit-queue 2011-06-01 14:11:25 -0700 The commit-queue encountered the following flaky tests while processing attachment 95528: http/tests/xmlhttprequest/remember-bad-password.html bug 51733 (author: ap@webkit.org) The commit-queue is continuing to process your patch. 413653 74 95528 commit-queue 2011-06-01 14:13:20 -0700 Comment on attachment 95528 Patch Clearing flags on attachment: 95528 Committed r87848: <http://trac.webkit.org/changeset/87848> 413654 75 commit-queue 2011-06-01 14:13:30 -0700 All reviewed patches have been landed. Closing bug. 413669 76 commit-queue 2011-06-01 14:27:15 -0700 The commit-queue encountered the following flaky tests while processing attachment 95528: inspector/debugger/debugger-scripts.html bug 59921 (authors: pfeldman@chromium.org and podivilov@chromium.org) The commit-queue is continuing to process your patch. 29086 2009-03-30 14:31:34 -0700 2009-03-31 07:18:20 -0700 Change the way we choose the filename when drang and dropping an image to the filesystem on Windows 24006.txt text/plain 8460 mad SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MjExNykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjIgQEAKKzIwMDktMDMtMzAgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0MDA2CisKKyAgICAg ICAgTXVzdCB1c2UgdGhlIGltYWdlIGZpbGUgbmFtZSBmcm9tIHRoZSBzcmMgYXMgb3Bwb3NlZCB0 byB0aGUKKyAgICAgICAgYWx0ZXJuYXRlIHRleHQgZm9yIGRyYWcgYW5kIGRyb3BwaW5nIGltYWdl cyB0byB0aGUgZmlsZSBzeXN0ZW0KKyAgICAgICAgKGFzIGlzIGRvbmUgZm9yIHRoZSBjb250ZXh0 dWFsIG1lbnUgInNhdmUgaW1hZ2UgYXMiIG9wdGlvbiwgYW5kCisgICAgICAgIGFsc28gb24gdGhl IE1hYyB2ZXJzaW9uKS4KKworICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENo cm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OndyaXRlSW1hZ2VUb0RhdGFPYmplY3QpOgor ICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0ZURyYWdJ bWFnZSk6CisgICAgICAgICogcGxhdGZvcm0vd2luL0NsaXBib2FyZFdpbi5jcHA6CisgICAgICAg IChXZWJDb3JlOjpjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjcmlwdG9yKToKKyAgICAgICAgKFdl YkNvcmU6OndyaXRlSW1hZ2VUb0RhdGFPYmplY3QpOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJv YXJkV2luOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UpOgorCiAyMDA5LTAzLTMwICBHcmVnIEJv bHNpbmdhICA8Ym9sc2luZ2FAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9u IEZyYXNlci4KSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21p dW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJk Q2hyb21pdW0uY3BwCShyZXZpc2lvbiA0MjExNykKKysrIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21p dW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNTEsNyArMjUxLDcg QEAgc3RhdGljIENhY2hlZEltYWdlKiBnZXRDYWNoZWRJbWFnZShFbGVtZQogfQogCiBzdGF0aWMg dm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KENocm9taXVtRGF0YU9iamVjdCogZGF0YU9iamVj dCwgRWxlbWVudCogZWxlbWVudCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y29uc3QgS1VSTCYgdXJsKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25z dCBLVVJMJiB1cmwsIEZyYW1lICogZnJhbWUpCiB7CiAgICAgLy8gU2hvdmUgaW1hZ2UgZGF0YSBp bnRvIGEgRGF0YU9iamVjdCBmb3IgdXNlIGFzIGEgZmlsZQogICAgIENhY2hlZEltYWdlKiBjYWNo ZWRJbWFnZSA9IGdldENhY2hlZEltYWdlKGVsZW1lbnQpOwpAQCAtMjY1LDE4ICsyNjUsMzQgQEAg c3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChDaHJvbQogICAgIGRhdGFPYmplY3Qt PmZpbGVDb250ZW50ID0gaW1hZ2VCdWZmZXI7CiAKICAgICAvLyBEZXRlcm1pbmUgdGhlIGZpbGVu YW1lIGZvciB0aGUgZmlsZSBjb250ZW50cyBvZiB0aGUgaW1hZ2UuICBXZSB0cnkgdG8KLSAgICAv LyB1c2UgdGhlIGFsdCB0YWcgaWYgb25lIGV4aXN0cywgb3RoZXJ3aXNlIHdlIGZhbGwgYmFjayBv biB0aGUgc3VnZ2VzdGVkCi0gICAgLy8gZmlsZW5hbWUgaW4gdGhlIGh0dHAgaGVhZGVyLCBhbmQg ZmluYWxseSB3ZSByZXNvcnQgdG8gdXNpbmcgdGhlIGZpbGVuYW1lCi0gICAgLy8gaW4gdGhlIFVS TC4KLSAgICBTdHJpbmcgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3RyeTo6Z2V0UHJlZmVycmVk RXh0ZW5zaW9uRm9yTUlNRVR5cGUoCisgICAgLy8gdXNlIHRoZSBmaWxlbmFtZSBpbiB0aGUgaW1h Z2UgVVJMIHN0b3JlZCBpbiB0aGUgc3JjIGF0dHJpYnV0ZSBmaXJzdC4KKyAgICAvLyBJZiB0aGVy ZSdzIG5vbmUsIHdlIHRoZW4gdHJ5IHRoZSBhbHQgdGFnIGlmIG9uZSBleGlzdHMsCisgICAgLy8g b3RoZXJ3aXNlIHdlIGZhbGwgYmFjayBvbiB0aGUgc3VnZ2VzdGVkIGZpbGVuYW1lIGluIHRoZSBo dHRwIGhlYWRlciwKKyAgICBTdHJpbmcgZmlsZU5hbWU7CisgICAgU3RyaW5nIGltYWdlVVJMID0g ZWxlbWVudC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOworICAgIGlmIChpbWFnZVVSTC5pc0VtcHR5 KCkgPT0gZmFsc2UpIHsKKyAgICAgIGZpbGVOYW1lID0gS1VSTChmcmFtZS0+ZG9jdW1lbnQoKS0+ Y29tcGxldGVVUkwocGFyc2VVUkwoaW1hZ2VVUkwpKSkubGFzdFBhdGhDb21wb25lbnQoKTsKKyAg ICB9IGVsc2UgeworICAgICAgZmlsZU5hbWUgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoYWx0QXR0 cik7CisgICAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAgICAgICAgIGZpbGVOYW1lID0g Y2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKKyAgICB9CisKKyAg ICAvLyBJZiB0aGUgZmlsZW5hbWUgd2UgZm91bmQgaGFzIGFuIGV4dGVuc2lvbiwgd2UgdXNlIGl0 LAorICAgIC8vIG90aGVyd2lzZSB3ZSByZWx5IG9uIHRoZSBleHRlbnNpb24gcmVnaXN0ZXJlZCB3 aXRoIHRoZSBNSU1FIHR5cGUuCisgICAgaW50IGV4dGVuc2lvbl9pbmRleCA9IGZpbGVOYW1lLnJl dmVyc2VGaW5kKCcuJyk7CisgICAgU3RyaW5nIGV4dGVuc2lvbjsKKyAgICBpZiAoZXh0ZW5zaW9u X2luZGV4ICE9IC0xKSB7CisgICAgICBleHRlbnNpb24gPSBmaWxlTmFtZS5zdWJzdHJpbmcoZXh0 ZW5zaW9uX2luZGV4ICsgMSk7CisgICAgICBmaWxlTmFtZS50cnVuY2F0ZShleHRlbnNpb25faW5k ZXgpOworICAgIH0gZWxzZSB7ICAgIAorICAgICAgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3Ry eTo6Z2V0UHJlZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoCiAgICAgICAgIGNhY2hlZEltYWdl LT5yZXNwb25zZSgpLm1pbWVUeXBlKCkpOworICAgIH0KICAgICBkYXRhT2JqZWN0LT5maWxlRXh0 ZW5zaW9uID0gZXh0ZW5zaW9uLmlzRW1wdHkoKSA/ICIiIDogIi4iICsgZXh0ZW5zaW9uOwotICAg IFN0cmluZyB0aXRsZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKLSAgICBpZiAo dGl0bGUuaXNFbXB0eSgpKQotICAgICAgICB0aXRsZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgp LnN1Z2dlc3RlZEZpbGVuYW1lKCk7CiAKLSAgICB0aXRsZSA9IENsaXBib2FyZENocm9taXVtOjp2 YWxpZGF0ZUZpbGVOYW1lKHRpdGxlLCBkYXRhT2JqZWN0KTsKLSAgICBkYXRhT2JqZWN0LT5maWxl Q29udGVudEZpbGVuYW1lID0gdGl0bGUgKyBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uOworICAg IGZpbGVOYW1lID0gQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoZmlsZU5hbWUs IGRhdGFPYmplY3QpOworICAgIGRhdGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUgPSBmaWxl TmFtZSArIGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb247CiB9CiAKIHZvaWQgQ2xpcGJvYXJkQ2hy b21pdW06OmRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50KiBlbGVtZW50LCBjb25zdCBL VVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkKQEAgLTI4OCw3ICsz MDQsNyBAQCB2b2lkIENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3JpdGVECiAgICAgbV9k YXRhT2JqZWN0LT51cmxUaXRsZSA9IHRpdGxlOwogCiAgICAgLy8gV3JpdGUgdGhlIGJ5dGVzIGlu IHRoZSBpbWFnZSB0byB0aGUgZmlsZSBmb3JtYXQuCi0gICAgd3JpdGVJbWFnZVRvRGF0YU9iamVj dChtX2RhdGFPYmplY3QuZ2V0KCksIGVsZW1lbnQsIHVybCk7CisgICAgd3JpdGVJbWFnZVRvRGF0 YU9iamVjdChtX2RhdGFPYmplY3QuZ2V0KCksIGVsZW1lbnQsIHVybCwgZnJhbWUpOwogCiAgICAg QXRvbWljU3RyaW5nIGltYWdlVVJMID0gZWxlbWVudC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOwog ICAgIGlmIChpbWFnZVVSTC5pc0VtcHR5KCkpCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL3dpbi9D bGlwYm9hcmRXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vd2luL0NsaXBi b2FyZFdpbi5jcHAJKHJldmlzaW9uIDQyMTE3KQorKysgV2ViQ29yZS9wbGF0Zm9ybS93aW4vQ2xp cGJvYXJkV2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzE1LDggKzMxNSwxMSBAQCBzdGF0aWMg SEdMT0JBTCBjcmVhdGVHbG9iYWxVcmxGaWxlRGVzY3JpCiB9CiAKIAotc3RhdGljIEhHTE9CQUwg Y3JlYXRlR2xvYmFsSW1hZ2VGaWxlRGVzY3JpcHRvcihjb25zdCBTdHJpbmcmIHVybCwgY29uc3Qg U3RyaW5nJiB0aXRsZSwgQ2FjaGVkSW1hZ2UqIGltYWdlKQorc3RhdGljIEhHTE9CQUwgY3JlYXRl R2xvYmFsSW1hZ2VGaWxlRGVzY3JpcHRvcihjb25zdCBTdHJpbmcmIHVybCwgU3RyaW5nIGZpbGVO YW1lLCBDYWNoZWRJbWFnZSogaW1hZ2UpCiB7CisgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkK KyAgICAgIHJldHVybiAwOworCiAgICAgQVNTRVJUX0FSRyhpbWFnZSwgaW1hZ2UpOwogICAgIEFT U0VSVChpbWFnZS0+aW1hZ2UoKS0+ZGF0YSgpKTsKIApAQCAtMzMzLDE1ICszMzYsMjMgQEAgc3Rh dGljIEhHTE9CQUwgY3JlYXRlR2xvYmFsSW1hZ2VGaWxlRGVzYwogICAgIGZnZC0+ZmdkWzBdLmR3 RmxhZ3MgPSBGRF9GSUxFU0laRTsKICAgICBmZ2QtPmZnZFswXS5uRmlsZVNpemVMb3cgPSBpbWFn ZS0+aW1hZ2UoKS0+ZGF0YSgpLT5zaXplKCk7CiAgICAgCi0gICAgY29uc3QgU3RyaW5nJiBwcmVm ZXJyZWRUaXRsZSA9IHRpdGxlLmlzRW1wdHkoKSA/IGltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3Rl ZEZpbGVuYW1lKCkgOiB0aXRsZTsKLSAgICBTdHJpbmcgZXh0ZW5zaW9uID0gaW1hZ2UtPmltYWdl KCktPmZpbGVuYW1lRXh0ZW5zaW9uKCk7Ci0gICAgaWYgKGV4dGVuc2lvbi5pc0VtcHR5KCkpIHsK LSAgICAgICAgLy8gRG8gbm90IGNvbnRpbnVlIHByb2Nlc3NpbmcgaW4gdGhlIHJhcmUgYW5kIHVu dXN1YWwgY2FzZSB3aGVyZSBhIGRlY29kZWQgaW1hZ2UgaXMgbm90IGFibGUgCi0gICAgICAgIC8v IHRvIHByb3ZpZGUgYSBmaWxlbmFtZSBleHRlbnNpb24uIFNvbWV0aGluZyB0cmlja3kgKGxpa2Ug YSBiYWl0LW4tc3dpdGNoKSBpcyBnb2luZyBvbgotICAgICAgICByZXR1cm4gMDsKKyAgICAvLyBJ ZiB0aGUgZmlsZW5hbWUgd2Ugd2VyZSBnaXZlbiBoYXMgYW4gZXh0ZW5zaW9uLCB3ZSB1c2UgaXQs CisgICAgLy8gb3RoZXJ3aXNlIHdlIHJlbHkgb24gdGhlIGRlY29kZWQgaW1hZ2UuCisgICAgaW50 IGV4dGVuc2lvbl9pbmRleCA9IGZpbGVOYW1lLnJldmVyc2VGaW5kKCcuJyk7CisgICAgU3RyaW5n IGV4dGVuc2lvbjsKKyAgICBpZiAoZXh0ZW5zaW9uX2luZGV4ICE9IC0xKSB7CisgICAgICBleHRl bnNpb24gPSBmaWxlTmFtZS5zdWJzdHJpbmcoZXh0ZW5zaW9uX2luZGV4KTsKKyAgICAgIGZpbGVO YW1lLnRydW5jYXRlKGV4dGVuc2lvbl9pbmRleCk7CisgICAgfSBlbHNlIHsKKyAgICAgIGV4dGVu c2lvbiA9IGltYWdlLT5pbWFnZSgpLT5maWxlbmFtZUV4dGVuc2lvbigpOworICAgICAgaWYgKGV4 dGVuc2lvbi5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAvLyBEbyBub3QgY29udGludWUgcHJvY2Vz c2luZyBpbiB0aGUgcmFyZSBhbmQgdW51c3VhbCBjYXNlIHdoZXJlIGEgZGVjb2RlZCBpbWFnZSBp cyBub3QgYWJsZSAKKyAgICAgICAgICAvLyB0byBwcm92aWRlIGEgZmlsZW5hbWUgZXh0ZW5zaW9u LiBTb21ldGhpbmcgdHJpY2t5IChsaWtlIGEgYmFpdC1uLXN3aXRjaCkgaXMgZ29pbmcgb24KKyAg ICAgICAgICByZXR1cm4gMDsKKyAgICAgIH0KKyAgICAgIGV4dGVuc2lvbi5pbnNlcnQoIi4iLCAw KTsKICAgICB9Ci0gICAgZXh0ZW5zaW9uLmluc2VydCgiLiIsIDApOwotICAgIGZzUGF0aCA9IGZp bGVzeXN0ZW1QYXRoRnJvbVVybE9yVGl0bGUodXJsLCBwcmVmZXJyZWRUaXRsZSwgKFRDSEFSKill eHRlbnNpb24uY2hhcmFjdGVyc1dpdGhOdWxsVGVybWluYXRpb24oKSwgZmFsc2UpOworICAgIGZz UGF0aCA9IGZpbGVzeXN0ZW1QYXRoRnJvbVVybE9yVGl0bGUodXJsLCBmaWxlTmFtZSwgKFRDSEFS KilleHRlbnNpb24uY2hhcmFjdGVyc1dpdGhOdWxsVGVybWluYXRpb24oKSwgZmFsc2UpOwogCiAg ICAgaWYgKGZzUGF0aC5sZW5ndGgoKSA8PSAwKSB7CiAgICAgICAgIEdsb2JhbFVubG9jayhtZW1P YmopOwpAQCAtNjM5LDcgKzY1MCw3IEBAIHN0YXRpYyBDYWNoZWRJbWFnZSogZ2V0Q2FjaGVkSW1h Z2UoRWxlbWUKICAgICByZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0 YU9iamVjdChJRGF0YU9iamVjdCogZGF0YU9iamVjdCwgRWxlbWVudCogZWxlbWVudCwgY29uc3Qg S1VSTCYgdXJsKQorc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChJRGF0YU9iamVj dCogZGF0YU9iamVjdCwgRWxlbWVudCogZWxlbWVudCwgY29uc3QgS1VSTCYgdXJsLCBGcmFtZSog ZnJhbWUpCiB7CiAgICAgLy8gU2hvdmUgaW1hZ2UgZGF0YSBpbnRvIGEgRGF0YU9iamVjdCBmb3Ig dXNlIGFzIGEgZmlsZQogICAgIENhY2hlZEltYWdlKiBjYWNoZWRJbWFnZSA9IGdldENhY2hlZElt YWdlKGVsZW1lbnQpOwpAQCAtNjUwLDcgKzY2MSwxNiBAQCBzdGF0aWMgdm9pZCB3cml0ZUltYWdl VG9EYXRhT2JqZWN0KElEYXRhCiAgICAgaWYgKCFpbWFnZUJ1ZmZlciB8fCAhaW1hZ2VCdWZmZXIt PnNpemUoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgSEdMT0JBTCBpbWFnZUZpbGVEZXNjcmlw dG9yID0gY3JlYXRlR2xvYmFsSW1hZ2VGaWxlRGVzY3JpcHRvcih1cmwuc3RyaW5nKCksIGVsZW1l bnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKSwgY2FjaGVkSW1hZ2UpOworICAgIFN0cmluZyBmaWxl TmFtZTsKKyAgICBTdHJpbmcgaW1hZ2VVUkwgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0 cik7CisgICAgaWYgKGltYWdlVVJMLmlzRW1wdHkoKSA9PSBmYWxzZSkgeworICAgICAgZmlsZU5h bWUgPSBLVVJMKGZyYW1lLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTChwYXJzZVVSTChpbWFnZVVS TCkpKS5sYXN0UGF0aENvbXBvbmVudCgpOworICAgIH0gZWxzZSB7CisgICAgICBmaWxlTmFtZSA9 IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICAgIGlmIChmaWxlTmFtZS5pc0Vt cHR5KCkpCisgICAgICAgIGZpbGVOYW1lID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2Vz dGVkRmlsZW5hbWUoKTsKKyAgICB9CisgICAgSEdMT0JBTCBpbWFnZUZpbGVEZXNjcmlwdG9yID0g Y3JlYXRlR2xvYmFsSW1hZ2VGaWxlRGVzY3JpcHRvcih1cmwuc3RyaW5nKCksIGZpbGVOYW1lLCBj YWNoZWRJbWFnZSk7CiAgICAgaWYgKCFpbWFnZUZpbGVEZXNjcmlwdG9yKQogICAgICAgICByZXR1 cm47CiAKQEAgLTY2MCw3ICs2ODAsNyBAQCBzdGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2Jq ZWN0KElEYXRhCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBTdHJpbmcgZmlsZU5hbWUg PSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGZpbGVO YW1lID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKICAgICBI R0xPQkFMIGhEcm9wQ29udGVudCA9IGNyZWF0ZUdsb2JhbEhEcm9wQ29udGVudCh1cmwsIGZpbGVO YW1lLCBpbWFnZUJ1ZmZlcik7CiAgICAgaWYgKCFoRHJvcENvbnRlbnQpIHsKICAgICAgICAgR2xv YmFsRnJlZShoRHJvcENvbnRlbnQpOwpAQCAtNjc3LDcgKzY5Nyw3IEBAIHZvaWQgQ2xpcGJvYXJk V2luOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW0KICAgICAgICAgIHJldHVybjsKICAgICBXZWJDb3Jl Ojp3cml0ZVVSTChtX3dyaXRhYmxlRGF0YU9iamVjdC5nZXQoKSwgdXJsLCB0aXRsZSwgdHJ1ZSwg ZmFsc2UpOwogCi0gICAgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChtX3dyaXRhYmxlRGF0YU9iamVj dC5nZXQoKSwgZWxlbWVudCwgdXJsKTsKKyAgICB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KG1fd3Jp dGFibGVEYXRhT2JqZWN0LmdldCgpLCBlbGVtZW50LCB1cmwsIGZyYW1lKTsKIAogICAgIEF0b21p Y1N0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShzcmNBdHRyKTsKICAgICBp ZiAoaW1hZ2VVUkwuaXNFbXB0eSgpKSAK 29113 2009-03-31 07:18:20 -0700 2009-03-31 07:24:43 -0700 Image drag and drop file name on Windows 24006.txt text/plain 7752 mad SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MjExNykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjUgQEAKKzIwMDktMDMtMzAgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0MDA2CisKKyAgICAg ICAgTXVzdCB1c2UgdGhlIGltYWdlIGZpbGUgbmFtZSBmcm9tIHRoZSBzcmMgYXMgb3Bwb3NlZCB0 byB0aGUKKyAgICAgICAgYWx0ZXJuYXRlIHRleHQgZm9yIGRyYWcgYW5kIGRyb3BwaW5nIGltYWdl cyB0byB0aGUgZmlsZSBzeXN0ZW0KKyAgICAgICAgKGFzIGlzIGRvbmUgZm9yIHRoZSBjb250ZXh0 dWFsIG1lbnUgInNhdmUgaW1hZ2UgYXMiIG9wdGlvbiwgYW5kCisgICAgICAgIGFsc28gb24gdGhl IE1hYyB2ZXJzaW9uKS4KKworICAgICAgICBDb3VsZG4ndCBhZGQgYSB0ZXN0IGZvciB0aGlzLCBz aW5jZSB3ZSBkb24ndAorICAgICAgICAoeWV0Pykgc3VwcG9ydCB0aGUgb25kcm9wIGV2ZW50Lgor CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3Jl OjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKToKKyAgICAgICAg KiBwbGF0Zm9ybS93aW4vQ2xpcGJvYXJkV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0 ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IpOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVJbWFn ZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRXaW46OmRlY2xhcmVB bmRXcml0ZURyYWdJbWFnZSk6CisKIDIwMDktMDMtMzAgIEdyZWcgQm9sc2luZ2EgIDxib2xzaW5n YUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gRnJhc2VyLgpJbmRleDog V2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAJKHJl dmlzaW9uIDQyMTE3KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJv bWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI1MSw3ICsyNTEsNyBAQCBzdGF0aWMgQ2FjaGVk SW1hZ2UqIGdldENhY2hlZEltYWdlKEVsZW1lCiB9CiAKIHN0YXRpYyB2b2lkIHdyaXRlSW1hZ2VU b0RhdGFPYmplY3QoQ2hyb21pdW1EYXRhT2JqZWN0KiBkYXRhT2JqZWN0LCBFbGVtZW50KiBlbGVt ZW50LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBLVVJMJiB1cmwp CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IEtVUkwmIHVybCwgRnJh bWUgKiBmcmFtZSkKIHsKICAgICAvLyBTaG92ZSBpbWFnZSBkYXRhIGludG8gYSBEYXRhT2JqZWN0 IGZvciB1c2UgYXMgYSBmaWxlCiAgICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlID0gZ2V0Q2Fj aGVkSW1hZ2UoZWxlbWVudCk7CkBAIC0yNjUsMTggKzI2NSwzNCBAQCBzdGF0aWMgdm9pZCB3cml0 ZUltYWdlVG9EYXRhT2JqZWN0KENocm9tCiAgICAgZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnQgPSBp bWFnZUJ1ZmZlcjsKIAogICAgIC8vIERldGVybWluZSB0aGUgZmlsZW5hbWUgZm9yIHRoZSBmaWxl IGNvbnRlbnRzIG9mIHRoZSBpbWFnZS4gIFdlIHRyeSB0bwotICAgIC8vIHVzZSB0aGUgYWx0IHRh ZyBpZiBvbmUgZXhpc3RzLCBvdGhlcndpc2Ugd2UgZmFsbCBiYWNrIG9uIHRoZSBzdWdnZXN0ZWQK LSAgICAvLyBmaWxlbmFtZSBpbiB0aGUgaHR0cCBoZWFkZXIsIGFuZCBmaW5hbGx5IHdlIHJlc29y dCB0byB1c2luZyB0aGUgZmlsZW5hbWUKLSAgICAvLyBpbiB0aGUgVVJMLgotICAgIFN0cmluZyBl eHRlbnNpb24gPSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRFeHRlbnNpb25Gb3JNSU1F VHlwZSgKKyAgICAvLyB1c2UgdGhlIGZpbGVuYW1lIGluIHRoZSBpbWFnZSBVUkwgc3RvcmVkIGlu IHRoZSBzcmMgYXR0cmlidXRlIGZpcnN0LgorICAgIC8vIElmIHRoZXJlJ3Mgbm9uZSwgd2UgdGhl biB0cnkgdGhlIGFsdCB0YWcgaWYgb25lIGV4aXN0cywKKyAgICAvLyBvdGhlcndpc2Ugd2UgZmFs bCBiYWNrIG9uIHRoZSBzdWdnZXN0ZWQgZmlsZW5hbWUgaW4gdGhlIGh0dHAgaGVhZGVyLAorICAg IFN0cmluZyBmaWxlTmFtZTsKKyAgICBTdHJpbmcgaW1hZ2VVUkwgPSBlbGVtZW50LT5nZXRBdHRy aWJ1dGUoc3JjQXR0cik7CisgICAgaWYgKGltYWdlVVJMLmlzRW1wdHkoKSA9PSBmYWxzZSkgewor ICAgICAgZmlsZU5hbWUgPSBLVVJMKGZyYW1lLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTChwYXJz ZVVSTChpbWFnZVVSTCkpKS5sYXN0UGF0aENvbXBvbmVudCgpOworICAgIH0gZWxzZSB7CisgICAg ICBmaWxlTmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICAgIGlmIChm aWxlTmFtZS5pc0VtcHR5KCkpCisgICAgICAgICAgZmlsZU5hbWUgPSBjYWNoZWRJbWFnZS0+cmVz cG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIH0KKworICAgIC8vIElmIHRoZSBmaWxl bmFtZSB3ZSBmb3VuZCBoYXMgYW4gZXh0ZW5zaW9uLCB3ZSB1c2UgaXQsCisgICAgLy8gb3RoZXJ3 aXNlIHdlIHJlbHkgb24gdGhlIGV4dGVuc2lvbiByZWdpc3RlcmVkIHdpdGggdGhlIE1JTUUgdHlw ZS4KKyAgICBpbnQgZXh0ZW5zaW9uX2luZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsK KyAgICBTdHJpbmcgZXh0ZW5zaW9uOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpIHsK KyAgICAgIGV4dGVuc2lvbiA9IGZpbGVOYW1lLnN1YnN0cmluZyhleHRlbnNpb25faW5kZXggKyAx KTsKKyAgICAgIGZpbGVOYW1lLnRydW5jYXRlKGV4dGVuc2lvbl9pbmRleCk7CisgICAgfSBlbHNl IHsgICAgCisgICAgICBleHRlbnNpb24gPSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRF eHRlbnNpb25Gb3JNSU1FVHlwZSgKICAgICAgICAgY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWlt ZVR5cGUoKSk7CisgICAgfQogICAgIGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24gPSBleHRlbnNp b24uaXNFbXB0eSgpID8gIiIgOiAiLiIgKyBleHRlbnNpb247Ci0gICAgU3RyaW5nIHRpdGxlID0g ZWxlbWVudC0+Z2V0QXR0cmlidXRlKGFsdEF0dHIpOwotICAgIGlmICh0aXRsZS5pc0VtcHR5KCkp Ci0gICAgICAgIHRpdGxlID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5h bWUoKTsKIAotICAgIHRpdGxlID0gQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUo dGl0bGUsIGRhdGFPYmplY3QpOwotICAgIGRhdGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUg PSB0aXRsZSArIGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb247CisgICAgZmlsZU5hbWUgPSBDbGlw Ym9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFtZShmaWxlTmFtZSwgZGF0YU9iamVjdCk7Cisg ICAgZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnRGaWxlbmFtZSA9IGZpbGVOYW1lICsgZGF0YU9iamVj dC0+ZmlsZUV4dGVuc2lvbjsKIH0KIAogdm9pZCBDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFu ZFdyaXRlRHJhZ0ltYWdlKEVsZW1lbnQqIGVsZW1lbnQsIGNvbnN0IEtVUkwmIHVybCwgY29uc3Qg U3RyaW5nJiB0aXRsZSwgRnJhbWUqIGZyYW1lKQpAQCAtMjg4LDcgKzMwNCw3IEBAIHZvaWQgQ2xp cGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0ZUQKICAgICBtX2RhdGFPYmplY3QtPnVybFRp dGxlID0gdGl0bGU7CiAKICAgICAvLyBXcml0ZSB0aGUgYnl0ZXMgaW4gdGhlIGltYWdlIHRvIHRo ZSBmaWxlIGZvcm1hdC4KLSAgICB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KG1fZGF0YU9iamVjdC5n ZXQoKSwgZWxlbWVudCwgdXJsKTsKKyAgICB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KG1fZGF0YU9i amVjdC5nZXQoKSwgZWxlbWVudCwgdXJsLCBmcmFtZSk7CiAKICAgICBBdG9taWNTdHJpbmcgaW1h Z2VVUkwgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CiAgICAgaWYgKGltYWdlVVJM LmlzRW1wdHkoKSkKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vd2luL0NsaXBib2FyZFdpbi5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS93aW4vQ2xpcGJvYXJkV2luLmNwcAkocmV2 aXNpb24gNDIxMTcpCisrKyBXZWJDb3JlL3BsYXRmb3JtL3dpbi9DbGlwYm9hcmRXaW4uY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0zMTUsOCArMzE1LDExIEBAIHN0YXRpYyBIR0xPQkFMIGNyZWF0ZUds b2JhbFVybEZpbGVEZXNjcmkKIH0KIAogCi1zdGF0aWMgSEdMT0JBTCBjcmVhdGVHbG9iYWxJbWFn ZUZpbGVEZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBD YWNoZWRJbWFnZSogaW1hZ2UpCitzdGF0aWMgSEdMT0JBTCBjcmVhdGVHbG9iYWxJbWFnZUZpbGVE ZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJsLCBTdHJpbmcgZmlsZU5hbWUsIENhY2hlZEltYWdl KiBpbWFnZSkKIHsKKyAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAgICAgcmV0dXJuIDA7 CisKICAgICBBU1NFUlRfQVJHKGltYWdlLCBpbWFnZSk7CiAgICAgQVNTRVJUKGltYWdlLT5pbWFn ZSgpLT5kYXRhKCkpOwogCkBAIC0zMzMsMTUgKzMzNiwyMyBAQCBzdGF0aWMgSEdMT0JBTCBjcmVh dGVHbG9iYWxJbWFnZUZpbGVEZXNjCiAgICAgZmdkLT5mZ2RbMF0uZHdGbGFncyA9IEZEX0ZJTEVT SVpFOwogICAgIGZnZC0+ZmdkWzBdLm5GaWxlU2l6ZUxvdyA9IGltYWdlLT5pbWFnZSgpLT5kYXRh KCktPnNpemUoKTsKICAgICAKLSAgICBjb25zdCBTdHJpbmcmIHByZWZlcnJlZFRpdGxlID0gdGl0 bGUuaXNFbXB0eSgpID8gaW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKSA6IHRp dGxlOwotICAgIFN0cmluZyBleHRlbnNpb24gPSBpbWFnZS0+aW1hZ2UoKS0+ZmlsZW5hbWVFeHRl bnNpb24oKTsKLSAgICBpZiAoZXh0ZW5zaW9uLmlzRW1wdHkoKSkgewotICAgICAgICAvLyBEbyBu b3QgY29udGludWUgcHJvY2Vzc2luZyBpbiB0aGUgcmFyZSBhbmQgdW51c3VhbCBjYXNlIHdoZXJl IGEgZGVjb2RlZCBpbWFnZSBpcyBub3QgYWJsZSAKLSAgICAgICAgLy8gdG8gcHJvdmlkZSBhIGZp bGVuYW1lIGV4dGVuc2lvbi4gU29tZXRoaW5nIHRyaWNreSAobGlrZSBhIGJhaXQtbi1zd2l0Y2gp IGlzIGdvaW5nIG9uCi0gICAgICAgIHJldHVybiAwOworICAgIC8vIElmIHRoZSBmaWxlbmFtZSB3 ZSB3ZXJlIGdpdmVuIGhhcyBhbiBleHRlbnNpb24sIHdlIHVzZSBpdCwKKyAgICAvLyBvdGhlcndp c2Ugd2UgcmVseSBvbiB0aGUgZGVjb2RlZCBpbWFnZS4KKyAgICBpbnQgZXh0ZW5zaW9uX2luZGV4 ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICBTdHJpbmcgZXh0ZW5zaW9uOworICAg IGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpIHsKKyAgICAgIGV4dGVuc2lvbiA9IGZpbGVOYW1l LnN1YnN0cmluZyhleHRlbnNpb25faW5kZXgpOworICAgICAgZmlsZU5hbWUudHJ1bmNhdGUoZXh0 ZW5zaW9uX2luZGV4KTsKKyAgICB9IGVsc2UgeworICAgICAgZXh0ZW5zaW9uID0gaW1hZ2UtPmlt YWdlKCktPmZpbGVuYW1lRXh0ZW5zaW9uKCk7CisgICAgICBpZiAoZXh0ZW5zaW9uLmlzRW1wdHko KSkgeworICAgICAgICAgIC8vIERvIG5vdCBjb250aW51ZSBwcm9jZXNzaW5nIGluIHRoZSByYXJl IGFuZCB1bnVzdWFsIGNhc2Ugd2hlcmUgYSBkZWNvZGVkIGltYWdlIGlzIG5vdCBhYmxlIAorICAg ICAgICAgIC8vIHRvIHByb3ZpZGUgYSBmaWxlbmFtZSBleHRlbnNpb24uIFNvbWV0aGluZyB0cmlj a3kgKGxpa2UgYSBiYWl0LW4tc3dpdGNoKSBpcyBnb2luZyBvbgorICAgICAgICAgIHJldHVybiAw OworICAgICAgfQorICAgICAgZXh0ZW5zaW9uLmluc2VydCgiLiIsIDApOwogICAgIH0KLSAgICBl eHRlbnNpb24uaW5zZXJ0KCIuIiwgMCk7Ci0gICAgZnNQYXRoID0gZmlsZXN5c3RlbVBhdGhGcm9t VXJsT3JUaXRsZSh1cmwsIHByZWZlcnJlZFRpdGxlLCAoVENIQVIqKWV4dGVuc2lvbi5jaGFyYWN0 ZXJzV2l0aE51bGxUZXJtaW5hdGlvbigpLCBmYWxzZSk7CisgICAgZnNQYXRoID0gZmlsZXN5c3Rl bVBhdGhGcm9tVXJsT3JUaXRsZSh1cmwsIGZpbGVOYW1lLCAoVENIQVIqKWV4dGVuc2lvbi5jaGFy YWN0ZXJzV2l0aE51bGxUZXJtaW5hdGlvbigpLCBmYWxzZSk7CiAKICAgICBpZiAoZnNQYXRoLmxl bmd0aCgpIDw9IDApIHsKICAgICAgICAgR2xvYmFsVW5sb2NrKG1lbU9iaik7CkBAIC02NTAsNyAr NjYxLDE2IEBAIHN0YXRpYyB2b2lkIHdyaXRlSW1hZ2VUb0RhdGFPYmplY3QoSURhdGEKICAgICBp ZiAoIWltYWdlQnVmZmVyIHx8ICFpbWFnZUJ1ZmZlci0+c2l6ZSgpKQogICAgICAgICByZXR1cm47 CiAKLSAgICBIR0xPQkFMIGltYWdlRmlsZURlc2NyaXB0b3IgPSBjcmVhdGVHbG9iYWxJbWFnZUZp bGVEZXNjcmlwdG9yKHVybC5zdHJpbmcoKSwgZWxlbWVudC0+Z2V0QXR0cmlidXRlKGFsdEF0dHIp LCBjYWNoZWRJbWFnZSk7CisgICAgU3RyaW5nIGZpbGVOYW1lOworICAgIFN0cmluZyBpbWFnZVVS TCA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShzcmNBdHRyKTsKKyAgICBpZiAoaW1hZ2VVUkwuaXNF bXB0eSgpID09IGZhbHNlKSB7CisgICAgICBmaWxlTmFtZSA9IEtVUkwoZWxlbWVudC0+ZG9jdW1l bnQoKS0+Y29tcGxldGVVUkwocGFyc2VVUkwoaW1hZ2VVUkwpKSkubGFzdFBhdGhDb21wb25lbnQo KTsKKyAgICB9IGVsc2UgeworICAgICAgZmlsZU5hbWUgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUo YWx0QXR0cik7CisgICAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAgICAgICBmaWxlTmFt ZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7CisgICAgfQor ICAgIEhHTE9CQUwgaW1hZ2VGaWxlRGVzY3JpcHRvciA9IGNyZWF0ZUdsb2JhbEltYWdlRmlsZURl c2NyaXB0b3IodXJsLnN0cmluZygpLCBmaWxlTmFtZSwgY2FjaGVkSW1hZ2UpOwogICAgIGlmICgh aW1hZ2VGaWxlRGVzY3JpcHRvcikKICAgICAgICAgcmV0dXJuOwogCkBAIC02NjAsNyArNjgwLDcg QEAgc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChJRGF0YQogICAgICAgICByZXR1 cm47CiAgICAgfQogCi0gICAgU3RyaW5nIGZpbGVOYW1lID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNl KCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKKyAgICBmaWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNw b25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7CiAgICAgSEdMT0JBTCBoRHJvcENvbnRlbnQgPSBj cmVhdGVHbG9iYWxIRHJvcENvbnRlbnQodXJsLCBmaWxlTmFtZSwgaW1hZ2VCdWZmZXIpOwogICAg IGlmICghaERyb3BDb250ZW50KSB7CiAgICAgICAgIEdsb2JhbEZyZWUoaERyb3BDb250ZW50KTsK 29114 2009-03-31 07:24:43 -0700 2009-04-01 11:05:07 -0700 Image drag and drop file name on Windows 24006.txt text/plain 6978 mad SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MjExNykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjUgQEAKKzIwMDktMDMtMzAgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0MDA2CisKKyAgICAg ICAgTXVzdCB1c2UgdGhlIGltYWdlIGZpbGUgbmFtZSBmcm9tIHRoZSBzcmMgYXMgb3Bwb3NlZCB0 byB0aGUKKyAgICAgICAgYWx0ZXJuYXRlIHRleHQgZm9yIGRyYWcgYW5kIGRyb3BwaW5nIGltYWdl cyB0byB0aGUgZmlsZSBzeXN0ZW0KKyAgICAgICAgKGFzIGlzIGRvbmUgZm9yIHRoZSBjb250ZXh0 dWFsIG1lbnUgInNhdmUgaW1hZ2UgYXMiIG9wdGlvbiwgYW5kCisgICAgICAgIGFsc28gb24gdGhl IE1hYyB2ZXJzaW9uKS4KKworICAgICAgICBDb3VsZG4ndCBhZGQgYSB0ZXN0IGZvciB0aGlzLCBz aW5jZSB3ZSBkb24ndAorICAgICAgICAoeWV0Pykgc3VwcG9ydCB0aGUgb25kcm9wIGV2ZW50Lgor CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3Jl OjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKToKKyAgICAgICAg KiBwbGF0Zm9ybS93aW4vQ2xpcGJvYXJkV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0 ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IpOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVJbWFn ZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRXaW46OmRlY2xhcmVB bmRXcml0ZURyYWdJbWFnZSk6CisKIDIwMDktMDMtMzAgIEdyZWcgQm9sc2luZ2EgIDxib2xzaW5n YUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gRnJhc2VyLgpJbmRleDog V2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAJKHJl dmlzaW9uIDQyMTE3KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJv bWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI2NSwxOCArMjY1LDM0IEBAIHN0YXRpYyB2b2lk IHdyaXRlSW1hZ2VUb0RhdGFPYmplY3QoQ2hyb20KICAgICBkYXRhT2JqZWN0LT5maWxlQ29udGVu dCA9IGltYWdlQnVmZmVyOwogCiAgICAgLy8gRGV0ZXJtaW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhl IGZpbGUgY29udGVudHMgb2YgdGhlIGltYWdlLiAgV2UgdHJ5IHRvCi0gICAgLy8gdXNlIHRoZSBh bHQgdGFnIGlmIG9uZSBleGlzdHMsIG90aGVyd2lzZSB3ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dl c3RlZAotICAgIC8vIGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciwgYW5kIGZpbmFsbHkgd2Ug cmVzb3J0IHRvIHVzaW5nIHRoZSBmaWxlbmFtZQotICAgIC8vIGluIHRoZSBVUkwuCi0gICAgU3Ry aW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6OmdldFByZWZlcnJlZEV4dGVuc2lvbkZv ck1JTUVUeXBlKAorICAgIC8vIHVzZSB0aGUgZmlsZW5hbWUgaW4gdGhlIGltYWdlIFVSTCBzdG9y ZWQgaW4gdGhlIHNyYyBhdHRyaWJ1dGUgZmlyc3QuCisgICAgLy8gSWYgdGhlcmUncyBub25lLCB3 ZSB0aGVuIHRyeSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3RzLAorICAgIC8vIG90aGVyd2lzZSB3 ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dlc3RlZCBmaWxlbmFtZSBpbiB0aGUgaHR0cCBoZWFkZXIs CisgICAgU3RyaW5nIGZpbGVOYW1lOworICAgIFN0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdl dEF0dHJpYnV0ZShzcmNBdHRyKTsKKyAgICBpZiAoaW1hZ2VVUkwuaXNFbXB0eSgpID09IGZhbHNl KSB7CisgICAgICBmaWxlTmFtZSA9IEtVUkwoZWxlbWVudC0+ZG9jdW1lbnQoKS0+Y29tcGxldGVV UkwocGFyc2VVUkwoaW1hZ2VVUkwpKSkubGFzdFBhdGhDb21wb25lbnQoKTsKKyAgICB9IGVsc2Ug eworICAgICAgZmlsZU5hbWUgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoYWx0QXR0cik7CisgICAg ICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAgICAgICAgIGZpbGVOYW1lID0gY2FjaGVkSW1h Z2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKKyAgICB9CisKKyAgICAvLyBJZiB0 aGUgZmlsZW5hbWUgd2UgZm91bmQgaGFzIGFuIGV4dGVuc2lvbiwgd2UgdXNlIGl0LAorICAgIC8v IG90aGVyd2lzZSB3ZSByZWx5IG9uIHRoZSBleHRlbnNpb24gcmVnaXN0ZXJlZCB3aXRoIHRoZSBN SU1FIHR5cGUuCisgICAgaW50IGV4dGVuc2lvbl9pbmRleCA9IGZpbGVOYW1lLnJldmVyc2VGaW5k KCcuJyk7CisgICAgU3RyaW5nIGV4dGVuc2lvbjsKKyAgICBpZiAoZXh0ZW5zaW9uX2luZGV4ICE9 IC0xKSB7CisgICAgICBleHRlbnNpb24gPSBmaWxlTmFtZS5zdWJzdHJpbmcoZXh0ZW5zaW9uX2lu ZGV4ICsgMSk7CisgICAgICBmaWxlTmFtZS50cnVuY2F0ZShleHRlbnNpb25faW5kZXgpOworICAg IH0gZWxzZSB7ICAgIAorICAgICAgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3RyeTo6Z2V0UHJl ZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoCiAgICAgICAgIGNhY2hlZEltYWdlLT5yZXNwb25z ZSgpLm1pbWVUeXBlKCkpOworICAgIH0KICAgICBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uID0g ZXh0ZW5zaW9uLmlzRW1wdHkoKSA/ICIiIDogIi4iICsgZXh0ZW5zaW9uOwotICAgIFN0cmluZyB0 aXRsZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKLSAgICBpZiAodGl0bGUuaXNF bXB0eSgpKQotICAgICAgICB0aXRsZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3Rl ZEZpbGVuYW1lKCk7CiAKLSAgICB0aXRsZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZp bGVOYW1lKHRpdGxlLCBkYXRhT2JqZWN0KTsKLSAgICBkYXRhT2JqZWN0LT5maWxlQ29udGVudEZp bGVuYW1lID0gdGl0bGUgKyBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uOworICAgIGZpbGVOYW1l ID0gQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoZmlsZU5hbWUsIGRhdGFPYmpl Y3QpOworICAgIGRhdGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUgPSBmaWxlTmFtZSArIGRh dGFPYmplY3QtPmZpbGVFeHRlbnNpb247CiB9CiAKIHZvaWQgQ2xpcGJvYXJkQ2hyb21pdW06OmRl Y2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50KiBlbGVtZW50LCBjb25zdCBLVVJMJiB1cmws IGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkKSW5kZXg6IFdlYkNvcmUvcGxhdGZv cm0vd2luL0NsaXBib2FyZFdpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS93 aW4vQ2xpcGJvYXJkV2luLmNwcAkocmV2aXNpb24gNDIxMTcpCisrKyBXZWJDb3JlL3BsYXRmb3Jt L3dpbi9DbGlwYm9hcmRXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMTUsOCArMzE1LDExIEBA IHN0YXRpYyBIR0xPQkFMIGNyZWF0ZUdsb2JhbFVybEZpbGVEZXNjcmkKIH0KIAogCi1zdGF0aWMg SEdMT0JBTCBjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJs LCBjb25zdCBTdHJpbmcmIHRpdGxlLCBDYWNoZWRJbWFnZSogaW1hZ2UpCitzdGF0aWMgSEdMT0JB TCBjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJsLCBTdHJp bmcgZmlsZU5hbWUsIENhY2hlZEltYWdlKiBpbWFnZSkKIHsKKyAgICBpZiAoZmlsZU5hbWUuaXNF bXB0eSgpKQorICAgICAgcmV0dXJuIDA7CisKICAgICBBU1NFUlRfQVJHKGltYWdlLCBpbWFnZSk7 CiAgICAgQVNTRVJUKGltYWdlLT5pbWFnZSgpLT5kYXRhKCkpOwogCkBAIC0zMzMsMTUgKzMzNiwy MyBAQCBzdGF0aWMgSEdMT0JBTCBjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjCiAgICAgZmdkLT5m Z2RbMF0uZHdGbGFncyA9IEZEX0ZJTEVTSVpFOwogICAgIGZnZC0+ZmdkWzBdLm5GaWxlU2l6ZUxv dyA9IGltYWdlLT5pbWFnZSgpLT5kYXRhKCktPnNpemUoKTsKICAgICAKLSAgICBjb25zdCBTdHJp bmcmIHByZWZlcnJlZFRpdGxlID0gdGl0bGUuaXNFbXB0eSgpID8gaW1hZ2UtPnJlc3BvbnNlKCku c3VnZ2VzdGVkRmlsZW5hbWUoKSA6IHRpdGxlOwotICAgIFN0cmluZyBleHRlbnNpb24gPSBpbWFn ZS0+aW1hZ2UoKS0+ZmlsZW5hbWVFeHRlbnNpb24oKTsKLSAgICBpZiAoZXh0ZW5zaW9uLmlzRW1w dHkoKSkgewotICAgICAgICAvLyBEbyBub3QgY29udGludWUgcHJvY2Vzc2luZyBpbiB0aGUgcmFy ZSBhbmQgdW51c3VhbCBjYXNlIHdoZXJlIGEgZGVjb2RlZCBpbWFnZSBpcyBub3QgYWJsZSAKLSAg ICAgICAgLy8gdG8gcHJvdmlkZSBhIGZpbGVuYW1lIGV4dGVuc2lvbi4gU29tZXRoaW5nIHRyaWNr eSAobGlrZSBhIGJhaXQtbi1zd2l0Y2gpIGlzIGdvaW5nIG9uCi0gICAgICAgIHJldHVybiAwOwor ICAgIC8vIElmIHRoZSBmaWxlbmFtZSB3ZSB3ZXJlIGdpdmVuIGhhcyBhbiBleHRlbnNpb24sIHdl IHVzZSBpdCwKKyAgICAvLyBvdGhlcndpc2Ugd2UgcmVseSBvbiB0aGUgZGVjb2RlZCBpbWFnZS4K KyAgICBpbnQgZXh0ZW5zaW9uX2luZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAg ICBTdHJpbmcgZXh0ZW5zaW9uOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpIHsKKyAg ICAgIGV4dGVuc2lvbiA9IGZpbGVOYW1lLnN1YnN0cmluZyhleHRlbnNpb25faW5kZXgpOworICAg ICAgZmlsZU5hbWUudHJ1bmNhdGUoZXh0ZW5zaW9uX2luZGV4KTsKKyAgICB9IGVsc2UgeworICAg ICAgZXh0ZW5zaW9uID0gaW1hZ2UtPmltYWdlKCktPmZpbGVuYW1lRXh0ZW5zaW9uKCk7CisgICAg ICBpZiAoZXh0ZW5zaW9uLmlzRW1wdHkoKSkgeworICAgICAgICAgIC8vIERvIG5vdCBjb250aW51 ZSBwcm9jZXNzaW5nIGluIHRoZSByYXJlIGFuZCB1bnVzdWFsIGNhc2Ugd2hlcmUgYSBkZWNvZGVk IGltYWdlIGlzIG5vdCBhYmxlIAorICAgICAgICAgIC8vIHRvIHByb3ZpZGUgYSBmaWxlbmFtZSBl eHRlbnNpb24uIFNvbWV0aGluZyB0cmlja3kgKGxpa2UgYSBiYWl0LW4tc3dpdGNoKSBpcyBnb2lu ZyBvbgorICAgICAgICAgIHJldHVybiAwOworICAgICAgfQorICAgICAgZXh0ZW5zaW9uLmluc2Vy dCgiLiIsIDApOwogICAgIH0KLSAgICBleHRlbnNpb24uaW5zZXJ0KCIuIiwgMCk7Ci0gICAgZnNQ YXRoID0gZmlsZXN5c3RlbVBhdGhGcm9tVXJsT3JUaXRsZSh1cmwsIHByZWZlcnJlZFRpdGxlLCAo VENIQVIqKWV4dGVuc2lvbi5jaGFyYWN0ZXJzV2l0aE51bGxUZXJtaW5hdGlvbigpLCBmYWxzZSk7 CisgICAgZnNQYXRoID0gZmlsZXN5c3RlbVBhdGhGcm9tVXJsT3JUaXRsZSh1cmwsIGZpbGVOYW1l LCAoVENIQVIqKWV4dGVuc2lvbi5jaGFyYWN0ZXJzV2l0aE51bGxUZXJtaW5hdGlvbigpLCBmYWxz ZSk7CiAKICAgICBpZiAoZnNQYXRoLmxlbmd0aCgpIDw9IDApIHsKICAgICAgICAgR2xvYmFsVW5s b2NrKG1lbU9iaik7CkBAIC02NTAsNyArNjYxLDE2IEBAIHN0YXRpYyB2b2lkIHdyaXRlSW1hZ2VU b0RhdGFPYmplY3QoSURhdGEKICAgICBpZiAoIWltYWdlQnVmZmVyIHx8ICFpbWFnZUJ1ZmZlci0+ c2l6ZSgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBIR0xPQkFMIGltYWdlRmlsZURlc2NyaXB0 b3IgPSBjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjcmlwdG9yKHVybC5zdHJpbmcoKSwgZWxlbWVu dC0+Z2V0QXR0cmlidXRlKGFsdEF0dHIpLCBjYWNoZWRJbWFnZSk7CisgICAgU3RyaW5nIGZpbGVO YW1lOworICAgIFN0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShzcmNBdHRy KTsKKyAgICBpZiAoaW1hZ2VVUkwuaXNFbXB0eSgpID09IGZhbHNlKSB7CisgICAgICBmaWxlTmFt ZSA9IEtVUkwoZWxlbWVudC0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwocGFyc2VVUkwoaW1hZ2VV UkwpKSkubGFzdFBhdGhDb21wb25lbnQoKTsKKyAgICB9IGVsc2UgeworICAgICAgZmlsZU5hbWUg PSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoYWx0QXR0cik7CisgICAgICBpZiAoZmlsZU5hbWUuaXNF bXB0eSgpKQorICAgICAgICBmaWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dl c3RlZEZpbGVuYW1lKCk7CisgICAgfQorICAgIEhHTE9CQUwgaW1hZ2VGaWxlRGVzY3JpcHRvciA9 IGNyZWF0ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IodXJsLnN0cmluZygpLCBmaWxlTmFtZSwg Y2FjaGVkSW1hZ2UpOwogICAgIGlmICghaW1hZ2VGaWxlRGVzY3JpcHRvcikKICAgICAgICAgcmV0 dXJuOwogCkBAIC02NjAsNyArNjgwLDcgQEAgc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0YU9i amVjdChJRGF0YQogICAgICAgICByZXR1cm47CiAgICAgfQogCi0gICAgU3RyaW5nIGZpbGVOYW1l ID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKKyAgICBmaWxl TmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7CiAgICAg SEdMT0JBTCBoRHJvcENvbnRlbnQgPSBjcmVhdGVHbG9iYWxIRHJvcENvbnRlbnQodXJsLCBmaWxl TmFtZSwgaW1hZ2VCdWZmZXIpOwogICAgIGlmICghaERyb3BDb250ZW50KSB7CiAgICAgICAgIEds b2JhbEZyZWUoaERyb3BDb250ZW50KTsK 29165 2009-04-01 11:05:07 -0700 2009-04-03 06:24:35 -0700 More style fixes and reversed precedence 24006.txt text/plain 7307 mad SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MjE0NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjUgQEAKKzIwMDktMDMtMzAgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0MDA2CisKKyAgICAg ICAgTXVzdCB1c2UgdGhlIGltYWdlIGZpbGUgbmFtZSBmcm9tIHRoZSBzcmMgYXMgb3Bwb3NlZCB0 byB0aGUKKyAgICAgICAgYWx0ZXJuYXRlIHRleHQgZm9yIGRyYWcgYW5kIGRyb3BwaW5nIGltYWdl cyB0byB0aGUgZmlsZSBzeXN0ZW0KKyAgICAgICAgKGFzIGlzIGRvbmUgZm9yIHRoZSBjb250ZXh0 dWFsIG1lbnUgInNhdmUgaW1hZ2UgYXMiIG9wdGlvbiwgYW5kCisgICAgICAgIGFsc28gb24gdGhl IE1hYyB2ZXJzaW9uKS4KKworICAgICAgICBDb3VsZG4ndCBhZGQgYSB0ZXN0IGZvciB0aGlzLCBz aW5jZSB3ZSBkb24ndAorICAgICAgICAoeWV0Pykgc3VwcG9ydCB0aGUgb25kcm9wIGV2ZW50Lgor CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3Jl OjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKToKKyAgICAgICAg KiBwbGF0Zm9ybS93aW4vQ2xpcGJvYXJkV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0 ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IpOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVJbWFn ZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRXaW46OmRlY2xhcmVB bmRXcml0ZURyYWdJbWFnZSk6CisKIDIwMDktMDMtMzEgIEVyaWMgQ2FybHNvbiAgPGVyaWMuY2Fy bHNvbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gRnJhc2VyLgpJbmRl eDogV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAJ KHJldmlzaW9uIDQyMTQ0KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRD aHJvbWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJF bGVtZW50LmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNp bmNsdWRlICJOYW1lZEF0dHJNYXAuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJlZ2lzdHJ5LmgiCiAj aW5jbHVkZSAibWFya3VwLmgiCiAjaW5jbHVkZSAiTmFtZWROb2RlTWFwLmgiCkBAIC0yNjUsMTkg KzI2NiwzNCBAQCBzdGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KENocm9tCiAKICAg ICBkYXRhT2JqZWN0LT5maWxlQ29udGVudCA9IGltYWdlQnVmZmVyOwogCi0gICAgLy8gRGV0ZXJt aW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZpbGUgY29udGVudHMgb2YgdGhlIGltYWdlLiAgV2Ug dHJ5IHRvCi0gICAgLy8gdXNlIHRoZSBhbHQgdGFnIGlmIG9uZSBleGlzdHMsIG90aGVyd2lzZSB3 ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dlc3RlZAotICAgIC8vIGZpbGVuYW1lIGluIHRoZSBodHRw IGhlYWRlciwgYW5kIGZpbmFsbHkgd2UgcmVzb3J0IHRvIHVzaW5nIHRoZSBmaWxlbmFtZQotICAg IC8vIGluIHRoZSBVUkwuCi0gICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6 OmdldFByZWZlcnJlZEV4dGVuc2lvbkZvck1JTUVUeXBlKAotICAgICAgICBjYWNoZWRJbWFnZS0+ cmVzcG9uc2UoKS5taW1lVHlwZSgpKTsKKyAgICAvLyBEZXRlcm1pbmUgdGhlIGZpbGVuYW1lIGZv ciB0aGUgZmlsZSBjb250ZW50cyBvZiB0aGUgaW1hZ2UuCisgICAgLy8gV2UgdHJ5IHRvIHVzZSB0 aGUgc3VnZ2VzdGVkIGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciBmaXJzdC4KKyAgICAvLyBU aGVuLCBpZiB0aGVyZSdzIG5vbmUsIHdlIHRyeSB0byBleHRyYWN0IHRoZSBmaWxlbmFtZSBmcm9t CisgICAgLy8gdGhlIGltYWdlIFVSTCBzdG9yZWQgaW4gdGhlIHNyYyBhdHRyaWJ1dGUuCisgICAg Ly8gSWYgdGhlcmUncyBub25lLCB3ZSB0aGVuIHRyeSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3Rz LgorICAgIFN0cmluZyBmaWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3Rl ZEZpbGVuYW1lKCk7CisgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkgeworICAgICAgICBTdHJp bmcgaW1hZ2VVUkwgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CisgICAgICAgIGlm ICghaW1hZ2VVUkwuaXNFbXB0eSgpKQorICAgICAgICAgICAgZmlsZU5hbWUgPSBlbGVtZW50LT5k b2N1bWVudCgpLT5jb21wbGV0ZVVSTChwYXJzZVVSTChpbWFnZVVSTCkpLmxhc3RQYXRoQ29tcG9u ZW50KCk7CisgICAgICAgIGlmIChmaWxlTmFtZS5pc0VtcHR5KCkpCisgICAgICAgICAgICBmaWxl TmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICB9CisKKyAgICAvLyBJ ZiB0aGUgZmlsZW5hbWUgd2UgZm91bmQgaGFzIGFuIGV4dGVuc2lvbiwgd2UgdXNlIGl0LAorICAg IC8vIG90aGVyd2lzZSB3ZSByZWx5IG9uIHRoZSBleHRlbnNpb24gcmVnaXN0ZXJlZCB3aXRoIHRo ZSBNSU1FIHR5cGUuCisgICAgaW50IGV4dGVuc2lvbl9pbmRleCA9IGZpbGVOYW1lLnJldmVyc2VG aW5kKCcuJyk7CisgICAgU3RyaW5nIGV4dGVuc2lvbjsKKyAgICBpZiAoZXh0ZW5zaW9uX2luZGV4 ICE9IC0xKSB7CisgICAgICAgIGV4dGVuc2lvbiA9IGZpbGVOYW1lLnN1YnN0cmluZyhleHRlbnNp b25faW5kZXggKyAxKTsKKyAgICAgICAgZmlsZU5hbWUudHJ1bmNhdGUoZXh0ZW5zaW9uX2luZGV4 KTsKKyAgICB9IGVsc2UKKyAgICAgICAgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3RyeTo6Z2V0 UHJlZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWlt ZVR5cGUoKSk7CisKICAgICBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uID0gZXh0ZW5zaW9uLmlz RW1wdHkoKSA/ICIiIDogIi4iICsgZXh0ZW5zaW9uOwotICAgIFN0cmluZyB0aXRsZSA9IGVsZW1l bnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKLSAgICBpZiAodGl0bGUuaXNFbXB0eSgpKQotICAg ICAgICB0aXRsZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7 CiAKLSAgICB0aXRsZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKHRpdGxl LCBkYXRhT2JqZWN0KTsKLSAgICBkYXRhT2JqZWN0LT5maWxlQ29udGVudEZpbGVuYW1lID0gdGl0 bGUgKyBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uOworICAgIGZpbGVOYW1lID0gQ2xpcGJvYXJk Q2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoZmlsZU5hbWUsIGRhdGFPYmplY3QpOworICAgIGRh dGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUgPSBmaWxlTmFtZSArIGRhdGFPYmplY3QtPmZp bGVFeHRlbnNpb247CiB9CiAKIHZvaWQgQ2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0 ZURyYWdJbWFnZShFbGVtZW50KiBlbGVtZW50LCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmlu ZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vd2luL0NsaXBi b2FyZFdpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS93aW4vQ2xpcGJvYXJk V2luLmNwcAkocmV2aXNpb24gNDIxNDQpCisrKyBXZWJDb3JlL3BsYXRmb3JtL3dpbi9DbGlwYm9h cmRXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMTUsOCArMzE1LDExIEBAIHN0YXRpYyBIR0xP QkFMIGNyZWF0ZUdsb2JhbFVybEZpbGVEZXNjcmkKIH0KIAogCi1zdGF0aWMgSEdMT0JBTCBjcmVh dGVHbG9iYWxJbWFnZUZpbGVEZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBTdHJp bmcmIHRpdGxlLCBDYWNoZWRJbWFnZSogaW1hZ2UpCitzdGF0aWMgSEdMT0JBTCBjcmVhdGVHbG9i YWxJbWFnZUZpbGVEZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJsLCBTdHJpbmcgZmlsZU5hbWUs IENhY2hlZEltYWdlKiBpbWFnZSkKIHsKKyAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAg ICAgcmV0dXJuIDA7CisKICAgICBBU1NFUlRfQVJHKGltYWdlLCBpbWFnZSk7CiAgICAgQVNTRVJU KGltYWdlLT5pbWFnZSgpLT5kYXRhKCkpOwogCkBAIC0zMzMsMTUgKzMzNiwyMiBAQCBzdGF0aWMg SEdMT0JBTCBjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjCiAgICAgZmdkLT5mZ2RbMF0uZHdGbGFn cyA9IEZEX0ZJTEVTSVpFOwogICAgIGZnZC0+ZmdkWzBdLm5GaWxlU2l6ZUxvdyA9IGltYWdlLT5p bWFnZSgpLT5kYXRhKCktPnNpemUoKTsKICAgICAKLSAgICBjb25zdCBTdHJpbmcmIHByZWZlcnJl ZFRpdGxlID0gdGl0bGUuaXNFbXB0eSgpID8gaW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmls ZW5hbWUoKSA6IHRpdGxlOwotICAgIFN0cmluZyBleHRlbnNpb24gPSBpbWFnZS0+aW1hZ2UoKS0+ ZmlsZW5hbWVFeHRlbnNpb24oKTsKLSAgICBpZiAoZXh0ZW5zaW9uLmlzRW1wdHkoKSkgewotICAg ICAgICAvLyBEbyBub3QgY29udGludWUgcHJvY2Vzc2luZyBpbiB0aGUgcmFyZSBhbmQgdW51c3Vh bCBjYXNlIHdoZXJlIGEgZGVjb2RlZCBpbWFnZSBpcyBub3QgYWJsZSAKLSAgICAgICAgLy8gdG8g cHJvdmlkZSBhIGZpbGVuYW1lIGV4dGVuc2lvbi4gU29tZXRoaW5nIHRyaWNreSAobGlrZSBhIGJh aXQtbi1zd2l0Y2gpIGlzIGdvaW5nIG9uCi0gICAgICAgIHJldHVybiAwOworICAgIC8vIElmIHRo ZSBmaWxlbmFtZSB3ZSB3ZXJlIGdpdmVuIGhhcyBhbiBleHRlbnNpb24sIHdlIHVzZSBpdCwKKyAg ICAvLyBvdGhlcndpc2Ugd2UgcmVseSBvbiB0aGUgZGVjb2RlZCBpbWFnZS4KKyAgICBpbnQgZXh0 ZW5zaW9uX2luZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICBTdHJpbmcgZXh0 ZW5zaW9uOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpIHsKKyAgICAgICAgZXh0ZW5z aW9uID0gZmlsZU5hbWUuc3Vic3RyaW5nKGV4dGVuc2lvbl9pbmRleCk7CisgICAgICAgIGZpbGVO YW1lLnRydW5jYXRlKGV4dGVuc2lvbl9pbmRleCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgZXh0 ZW5zaW9uID0gaW1hZ2UtPmltYWdlKCktPmZpbGVuYW1lRXh0ZW5zaW9uKCk7CisgICAgICAgIGlm IChleHRlbnNpb24uaXNFbXB0eSgpKQorICAgICAgICAgICAgLy8gRG8gbm90IGNvbnRpbnVlIHBy b2Nlc3NpbmcgaW4gdGhlIHJhcmUgYW5kIHVudXN1YWwgY2FzZSB3aGVyZSBhIGRlY29kZWQgaW1h Z2UgaXMgbm90IGFibGUgCisgICAgICAgICAgICAvLyB0byBwcm92aWRlIGEgZmlsZW5hbWUgZXh0 ZW5zaW9uLiBTb21ldGhpbmcgdHJpY2t5IChsaWtlIGEgYmFpdC1uLXN3aXRjaCkgaXMgZ29pbmcg b24KKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICBleHRlbnNpb24uaW5zZXJ0KCIuIiwg MCk7CiAgICAgfQotICAgIGV4dGVuc2lvbi5pbnNlcnQoIi4iLCAwKTsKLSAgICBmc1BhdGggPSBm aWxlc3lzdGVtUGF0aEZyb21VcmxPclRpdGxlKHVybCwgcHJlZmVycmVkVGl0bGUsIChUQ0hBUiop ZXh0ZW5zaW9uLmNoYXJhY3RlcnNXaXRoTnVsbFRlcm1pbmF0aW9uKCksIGZhbHNlKTsKKyAgICBm c1BhdGggPSBmaWxlc3lzdGVtUGF0aEZyb21VcmxPclRpdGxlKHVybCwgZmlsZU5hbWUsIChUQ0hB UiopZXh0ZW5zaW9uLmNoYXJhY3RlcnNXaXRoTnVsbFRlcm1pbmF0aW9uKCksIGZhbHNlKTsKIAog ICAgIGlmIChmc1BhdGgubGVuZ3RoKCkgPD0gMCkgewogICAgICAgICBHbG9iYWxVbmxvY2sobWVt T2JqKTsKQEAgLTY1MCw3ICs2NjAsMTUgQEAgc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0YU9i amVjdChJRGF0YQogICAgIGlmICghaW1hZ2VCdWZmZXIgfHwgIWltYWdlQnVmZmVyLT5zaXplKCkp CiAgICAgICAgIHJldHVybjsKIAotICAgIEhHTE9CQUwgaW1hZ2VGaWxlRGVzY3JpcHRvciA9IGNy ZWF0ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IodXJsLnN0cmluZygpLCBlbGVtZW50LT5nZXRB dHRyaWJ1dGUoYWx0QXR0ciksIGNhY2hlZEltYWdlKTsKKyAgICBTdHJpbmcgZmlsZU5hbWUgPSBj YWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGlmIChmaWxl TmFtZS5pc0VtcHR5KCkpIHsKKyAgICAgIFN0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0 dHJpYnV0ZShzcmNBdHRyKTsKKyAgICAgIGlmICghaW1hZ2VVUkwuaXNFbXB0eSgpKQorICAgICAg ICAgIGZpbGVOYW1lID0gZWxlbWVudC0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwocGFyc2VVUkwo aW1hZ2VVUkwpKS5sYXN0UGF0aENvbXBvbmVudCgpOworICAgICAgaWYgKGZpbGVOYW1lLmlzRW1w dHkoKSkKKyAgICAgICAgICBmaWxlTmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRy KTsKKyAgICB9CisgICAgSEdMT0JBTCBpbWFnZUZpbGVEZXNjcmlwdG9yID0gY3JlYXRlR2xvYmFs SW1hZ2VGaWxlRGVzY3JpcHRvcih1cmwuc3RyaW5nKCksIGZpbGVOYW1lLCBjYWNoZWRJbWFnZSk7 CiAgICAgaWYgKCFpbWFnZUZpbGVEZXNjcmlwdG9yKQogICAgICAgICByZXR1cm47CiAKQEAgLTY2 MCw3ICs2NzgsNyBAQCBzdGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KElEYXRhCiAg ICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBTdHJpbmcgZmlsZU5hbWUgPSBjYWNoZWRJbWFn ZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGZpbGVOYW1lID0gY2FjaGVk SW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKICAgICBIR0xPQkFMIGhEcm9w Q29udGVudCA9IGNyZWF0ZUdsb2JhbEhEcm9wQ29udGVudCh1cmwsIGZpbGVOYW1lLCBpbWFnZUJ1 ZmZlcik7CiAgICAgaWYgKCFoRHJvcENvbnRlbnQpIHsKICAgICAgICAgR2xvYmFsRnJlZShoRHJv cENvbnRlbnQpOwo= 29225 2009-04-03 06:24:35 -0700 2009-04-03 11:25:41 -0700 Fixed extension precendence and other details... 24006.txt text/plain 7307 mad SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MjE0NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjUgQEAKKzIwMDktMDMtMzAgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0MDA2CisKKyAgICAg ICAgTXVzdCB1c2UgdGhlIGltYWdlIGZpbGUgbmFtZSBmcm9tIHRoZSBzcmMgYXMgb3Bwb3NlZCB0 byB0aGUKKyAgICAgICAgYWx0ZXJuYXRlIHRleHQgZm9yIGRyYWcgYW5kIGRyb3BwaW5nIGltYWdl cyB0byB0aGUgZmlsZSBzeXN0ZW0KKyAgICAgICAgKGFzIGlzIGRvbmUgZm9yIHRoZSBjb250ZXh0 dWFsIG1lbnUgInNhdmUgaW1hZ2UgYXMiIG9wdGlvbiwgYW5kCisgICAgICAgIGFsc28gb24gdGhl IE1hYyB2ZXJzaW9uKS4KKworICAgICAgICBDb3VsZG4ndCBhZGQgYSB0ZXN0IGZvciB0aGlzLCBz aW5jZSB3ZSBkb24ndAorICAgICAgICAoeWV0Pykgc3VwcG9ydCB0aGUgb25kcm9wIGV2ZW50Lgor CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3Jl OjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKToKKyAgICAgICAg KiBwbGF0Zm9ybS93aW4vQ2xpcGJvYXJkV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0 ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IpOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVJbWFn ZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRXaW46OmRlY2xhcmVB bmRXcml0ZURyYWdJbWFnZSk6CisKIDIwMDktMDMtMzEgIEVyaWMgQ2FybHNvbiAgPGVyaWMuY2Fy bHNvbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gRnJhc2VyLgpJbmRl eDogV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAJ KHJldmlzaW9uIDQyMTQ0KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRD aHJvbWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJF bGVtZW50LmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNp bmNsdWRlICJOYW1lZEF0dHJNYXAuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJlZ2lzdHJ5LmgiCiAj aW5jbHVkZSAibWFya3VwLmgiCiAjaW5jbHVkZSAiTmFtZWROb2RlTWFwLmgiCkBAIC0yNjUsMTkg KzI2NiwzNCBAQCBzdGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KENocm9tCiAKICAg ICBkYXRhT2JqZWN0LT5maWxlQ29udGVudCA9IGltYWdlQnVmZmVyOwogCi0gICAgLy8gRGV0ZXJt aW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZpbGUgY29udGVudHMgb2YgdGhlIGltYWdlLiAgV2Ug dHJ5IHRvCi0gICAgLy8gdXNlIHRoZSBhbHQgdGFnIGlmIG9uZSBleGlzdHMsIG90aGVyd2lzZSB3 ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dlc3RlZAotICAgIC8vIGZpbGVuYW1lIGluIHRoZSBodHRw IGhlYWRlciwgYW5kIGZpbmFsbHkgd2UgcmVzb3J0IHRvIHVzaW5nIHRoZSBmaWxlbmFtZQotICAg IC8vIGluIHRoZSBVUkwuCi0gICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6 OmdldFByZWZlcnJlZEV4dGVuc2lvbkZvck1JTUVUeXBlKAotICAgICAgICBjYWNoZWRJbWFnZS0+ cmVzcG9uc2UoKS5taW1lVHlwZSgpKTsKKyAgICAvLyBEZXRlcm1pbmUgdGhlIGZpbGVuYW1lIGZv ciB0aGUgZmlsZSBjb250ZW50cyBvZiB0aGUgaW1hZ2UuCisgICAgLy8gV2UgdHJ5IHRvIHVzZSB0 aGUgc3VnZ2VzdGVkIGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciBmaXJzdC4KKyAgICAvLyBU aGVuLCBpZiB0aGVyZSdzIG5vbmUsIHdlIHRyeSB0byBleHRyYWN0IHRoZSBmaWxlbmFtZSBmcm9t CisgICAgLy8gdGhlIGltYWdlIFVSTCBzdG9yZWQgaW4gdGhlIHNyYyBhdHRyaWJ1dGUuCisgICAg Ly8gSWYgdGhlcmUncyBub25lLCB3ZSB0aGVuIHRyeSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3Rz LgorICAgIFN0cmluZyBmaWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3Rl ZEZpbGVuYW1lKCk7CisgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkgeworICAgICAgICBTdHJp bmcgaW1hZ2VVUkwgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CisgICAgICAgIGlm ICghaW1hZ2VVUkwuaXNFbXB0eSgpKQorICAgICAgICAgICAgZmlsZU5hbWUgPSBlbGVtZW50LT5k b2N1bWVudCgpLT5jb21wbGV0ZVVSTChwYXJzZVVSTChpbWFnZVVSTCkpLmxhc3RQYXRoQ29tcG9u ZW50KCk7CisgICAgICAgIGlmIChmaWxlTmFtZS5pc0VtcHR5KCkpCisgICAgICAgICAgICBmaWxl TmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICB9CisKKyAgICAvLyBJ ZiB0aGUgZmlsZW5hbWUgd2UgZm91bmQgaGFzIGFuIGV4dGVuc2lvbiwgd2UgdXNlIGl0LAorICAg IC8vIG90aGVyd2lzZSB3ZSByZWx5IG9uIHRoZSBleHRlbnNpb24gcmVnaXN0ZXJlZCB3aXRoIHRo ZSBNSU1FIHR5cGUuCisgICAgaW50IGV4dGVuc2lvbl9pbmRleCA9IGZpbGVOYW1lLnJldmVyc2VG aW5kKCcuJyk7CisgICAgU3RyaW5nIGV4dGVuc2lvbjsKKyAgICBpZiAoZXh0ZW5zaW9uX2luZGV4 ICE9IC0xKSB7CisgICAgICAgIGV4dGVuc2lvbiA9IGZpbGVOYW1lLnN1YnN0cmluZyhleHRlbnNp b25faW5kZXggKyAxKTsKKyAgICAgICAgZmlsZU5hbWUudHJ1bmNhdGUoZXh0ZW5zaW9uX2luZGV4 KTsKKyAgICB9IGVsc2UKKyAgICAgICAgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3RyeTo6Z2V0 UHJlZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWlt ZVR5cGUoKSk7CisKICAgICBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uID0gZXh0ZW5zaW9uLmlz RW1wdHkoKSA/ICIiIDogIi4iICsgZXh0ZW5zaW9uOwotICAgIFN0cmluZyB0aXRsZSA9IGVsZW1l bnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKLSAgICBpZiAodGl0bGUuaXNFbXB0eSgpKQotICAg ICAgICB0aXRsZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7 CiAKLSAgICB0aXRsZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKHRpdGxl LCBkYXRhT2JqZWN0KTsKLSAgICBkYXRhT2JqZWN0LT5maWxlQ29udGVudEZpbGVuYW1lID0gdGl0 bGUgKyBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uOworICAgIGZpbGVOYW1lID0gQ2xpcGJvYXJk Q2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoZmlsZU5hbWUsIGRhdGFPYmplY3QpOworICAgIGRh dGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUgPSBmaWxlTmFtZSArIGRhdGFPYmplY3QtPmZp bGVFeHRlbnNpb247CiB9CiAKIHZvaWQgQ2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0 ZURyYWdJbWFnZShFbGVtZW50KiBlbGVtZW50LCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmlu ZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vd2luL0NsaXBi b2FyZFdpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS93aW4vQ2xpcGJvYXJk V2luLmNwcAkocmV2aXNpb24gNDIxNDQpCisrKyBXZWJDb3JlL3BsYXRmb3JtL3dpbi9DbGlwYm9h cmRXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMTUsOCArMzE1LDExIEBAIHN0YXRpYyBIR0xP QkFMIGNyZWF0ZUdsb2JhbFVybEZpbGVEZXNjcmkKIH0KIAogCi1zdGF0aWMgSEdMT0JBTCBjcmVh dGVHbG9iYWxJbWFnZUZpbGVEZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBTdHJp bmcmIHRpdGxlLCBDYWNoZWRJbWFnZSogaW1hZ2UpCitzdGF0aWMgSEdMT0JBTCBjcmVhdGVHbG9i YWxJbWFnZUZpbGVEZXNjcmlwdG9yKGNvbnN0IFN0cmluZyYgdXJsLCBTdHJpbmcgZmlsZU5hbWUs IENhY2hlZEltYWdlKiBpbWFnZSkKIHsKKyAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAg ICAgcmV0dXJuIDA7CisKICAgICBBU1NFUlRfQVJHKGltYWdlLCBpbWFnZSk7CiAgICAgQVNTRVJU KGltYWdlLT5pbWFnZSgpLT5kYXRhKCkpOwogCkBAIC0zMzMsMTUgKzMzNiwyMiBAQCBzdGF0aWMg SEdMT0JBTCBjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjCiAgICAgZmdkLT5mZ2RbMF0uZHdGbGFn cyA9IEZEX0ZJTEVTSVpFOwogICAgIGZnZC0+ZmdkWzBdLm5GaWxlU2l6ZUxvdyA9IGltYWdlLT5p bWFnZSgpLT5kYXRhKCktPnNpemUoKTsKICAgICAKLSAgICBjb25zdCBTdHJpbmcmIHByZWZlcnJl ZFRpdGxlID0gdGl0bGUuaXNFbXB0eSgpID8gaW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmls ZW5hbWUoKSA6IHRpdGxlOwotICAgIFN0cmluZyBleHRlbnNpb24gPSBpbWFnZS0+aW1hZ2UoKS0+ ZmlsZW5hbWVFeHRlbnNpb24oKTsKLSAgICBpZiAoZXh0ZW5zaW9uLmlzRW1wdHkoKSkgewotICAg ICAgICAvLyBEbyBub3QgY29udGludWUgcHJvY2Vzc2luZyBpbiB0aGUgcmFyZSBhbmQgdW51c3Vh bCBjYXNlIHdoZXJlIGEgZGVjb2RlZCBpbWFnZSBpcyBub3QgYWJsZSAKLSAgICAgICAgLy8gdG8g cHJvdmlkZSBhIGZpbGVuYW1lIGV4dGVuc2lvbi4gU29tZXRoaW5nIHRyaWNreSAobGlrZSBhIGJh aXQtbi1zd2l0Y2gpIGlzIGdvaW5nIG9uCi0gICAgICAgIHJldHVybiAwOworICAgIC8vIElmIHRo ZSBmaWxlbmFtZSB3ZSB3ZXJlIGdpdmVuIGhhcyBhbiBleHRlbnNpb24sIHdlIHVzZSBpdCwKKyAg ICAvLyBvdGhlcndpc2Ugd2UgcmVseSBvbiB0aGUgZGVjb2RlZCBpbWFnZS4KKyAgICBpbnQgZXh0 ZW5zaW9uX2luZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICBTdHJpbmcgZXh0 ZW5zaW9uOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpIHsKKyAgICAgICAgZXh0ZW5z aW9uID0gZmlsZU5hbWUuc3Vic3RyaW5nKGV4dGVuc2lvbl9pbmRleCk7CisgICAgICAgIGZpbGVO YW1lLnRydW5jYXRlKGV4dGVuc2lvbl9pbmRleCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgZXh0 ZW5zaW9uID0gaW1hZ2UtPmltYWdlKCktPmZpbGVuYW1lRXh0ZW5zaW9uKCk7CisgICAgICAgIGlm IChleHRlbnNpb24uaXNFbXB0eSgpKQorICAgICAgICAgICAgLy8gRG8gbm90IGNvbnRpbnVlIHBy b2Nlc3NpbmcgaW4gdGhlIHJhcmUgYW5kIHVudXN1YWwgY2FzZSB3aGVyZSBhIGRlY29kZWQgaW1h Z2UgaXMgbm90IGFibGUgCisgICAgICAgICAgICAvLyB0byBwcm92aWRlIGEgZmlsZW5hbWUgZXh0 ZW5zaW9uLiBTb21ldGhpbmcgdHJpY2t5IChsaWtlIGEgYmFpdC1uLXN3aXRjaCkgaXMgZ29pbmcg b24KKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICBleHRlbnNpb24uaW5zZXJ0KCIuIiwg MCk7CiAgICAgfQotICAgIGV4dGVuc2lvbi5pbnNlcnQoIi4iLCAwKTsKLSAgICBmc1BhdGggPSBm aWxlc3lzdGVtUGF0aEZyb21VcmxPclRpdGxlKHVybCwgcHJlZmVycmVkVGl0bGUsIChUQ0hBUiop ZXh0ZW5zaW9uLmNoYXJhY3RlcnNXaXRoTnVsbFRlcm1pbmF0aW9uKCksIGZhbHNlKTsKKyAgICBm c1BhdGggPSBmaWxlc3lzdGVtUGF0aEZyb21VcmxPclRpdGxlKHVybCwgZmlsZU5hbWUsIChUQ0hB UiopZXh0ZW5zaW9uLmNoYXJhY3RlcnNXaXRoTnVsbFRlcm1pbmF0aW9uKCksIGZhbHNlKTsKIAog ICAgIGlmIChmc1BhdGgubGVuZ3RoKCkgPD0gMCkgewogICAgICAgICBHbG9iYWxVbmxvY2sobWVt T2JqKTsKQEAgLTY1MCw3ICs2NjAsMTUgQEAgc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0YU9i amVjdChJRGF0YQogICAgIGlmICghaW1hZ2VCdWZmZXIgfHwgIWltYWdlQnVmZmVyLT5zaXplKCkp CiAgICAgICAgIHJldHVybjsKIAotICAgIEhHTE9CQUwgaW1hZ2VGaWxlRGVzY3JpcHRvciA9IGNy ZWF0ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IodXJsLnN0cmluZygpLCBlbGVtZW50LT5nZXRB dHRyaWJ1dGUoYWx0QXR0ciksIGNhY2hlZEltYWdlKTsKKyAgICBTdHJpbmcgZmlsZU5hbWUgPSBj YWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGlmIChmaWxl TmFtZS5pc0VtcHR5KCkpIHsKKyAgICAgIFN0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0 dHJpYnV0ZShzcmNBdHRyKTsKKyAgICAgIGlmICghaW1hZ2VVUkwuaXNFbXB0eSgpKQorICAgICAg ICAgIGZpbGVOYW1lID0gZWxlbWVudC0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwocGFyc2VVUkwo aW1hZ2VVUkwpKS5sYXN0UGF0aENvbXBvbmVudCgpOworICAgICAgaWYgKGZpbGVOYW1lLmlzRW1w dHkoKSkKKyAgICAgICAgICBmaWxlTmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRy KTsKKyAgICB9CisgICAgSEdMT0JBTCBpbWFnZUZpbGVEZXNjcmlwdG9yID0gY3JlYXRlR2xvYmFs SW1hZ2VGaWxlRGVzY3JpcHRvcih1cmwuc3RyaW5nKCksIGZpbGVOYW1lLCBjYWNoZWRJbWFnZSk7 CiAgICAgaWYgKCFpbWFnZUZpbGVEZXNjcmlwdG9yKQogICAgICAgICByZXR1cm47CiAKQEAgLTY2 MCw3ICs2NzgsNyBAQCBzdGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KElEYXRhCiAg ICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBTdHJpbmcgZmlsZU5hbWUgPSBjYWNoZWRJbWFn ZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGZpbGVOYW1lID0gY2FjaGVk SW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKICAgICBIR0xPQkFMIGhEcm9w Q29udGVudCA9IGNyZWF0ZUdsb2JhbEhEcm9wQ29udGVudCh1cmwsIGZpbGVOYW1lLCBpbWFnZUJ1 ZmZlcik7CiAgICAgaWYgKCFoRHJvcENvbnRlbnQpIHsKICAgICAgICAgR2xvYmFsRnJlZShoRHJv cENvbnRlbnQpOwo= 29234 2009-04-03 11:25:41 -0700 2009-04-13 11:44:49 -0700 THis is the one which fixes the extension and filename precedence... 24006.txt text/plain 6557 mad SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MjE5OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjUgQEAKKzIwMDktMDQtMDMgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0MDA2CisKKyAgICAg ICAgTXVzdCB1c2UgdGhlIGltYWdlIGZpbGUgbmFtZSBmcm9tIHRoZSBzcmMgYXMgb3Bwb3NlZCB0 byB0aGUKKyAgICAgICAgYWx0ZXJuYXRlIHRleHQgZm9yIGRyYWcgYW5kIGRyb3BwaW5nIGltYWdl cyB0byB0aGUgZmlsZSBzeXN0ZW0KKyAgICAgICAgKGFzIGlzIGRvbmUgZm9yIHRoZSBjb250ZXh0 dWFsIG1lbnUgInNhdmUgaW1hZ2UgYXMiIG9wdGlvbiwgYW5kCisgICAgICAgIGFsc28gb24gdGhl IE1hYyB2ZXJzaW9uKS4KKworICAgICAgICBDb3VsZG4ndCBhZGQgYSB0ZXN0IGZvciB0aGlzLCBz aW5jZSB3ZSBkb24ndAorICAgICAgICAoeWV0Pykgc3VwcG9ydCB0aGUgb25kcm9wIGV2ZW50Lgor CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3Jl OjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKToKKyAgICAgICAg KiBwbGF0Zm9ybS93aW4vQ2xpcGJvYXJkV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0 ZUdsb2JhbEltYWdlRmlsZURlc2NyaXB0b3IpOgorICAgICAgICAoV2ViQ29yZTo6d3JpdGVJbWFn ZVRvRGF0YU9iamVjdCk6CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRXaW46OmRlY2xhcmVB bmRXcml0ZURyYWdJbWFnZSk6CisKIDIwMDktMDQtMDMgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAg PGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg SG9sZ2VyIEZyZXl0aGVyLgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9h cmRDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9D bGlwYm9hcmRDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDQyMTk5KQorKysgV2ViQ29yZS9wbGF0Zm9y bS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI2Niwx OSArMjY2LDMwIEBAIHN0YXRpYyB2b2lkIHdyaXRlSW1hZ2VUb0RhdGFPYmplY3QoQ2hyb20KIAog ICAgIGRhdGFPYmplY3QtPmZpbGVDb250ZW50ID0gaW1hZ2VCdWZmZXI7CiAKLSAgICAvLyBEZXRl cm1pbmUgdGhlIGZpbGVuYW1lIGZvciB0aGUgZmlsZSBjb250ZW50cyBvZiB0aGUgaW1hZ2UuICBX ZSB0cnkgdG8KLSAgICAvLyB1c2UgdGhlIGFsdCB0YWcgaWYgb25lIGV4aXN0cywgb3RoZXJ3aXNl IHdlIGZhbGwgYmFjayBvbiB0aGUgc3VnZ2VzdGVkCi0gICAgLy8gZmlsZW5hbWUgaW4gdGhlIGh0 dHAgaGVhZGVyLCBhbmQgZmluYWxseSB3ZSByZXNvcnQgdG8gdXNpbmcgdGhlIGZpbGVuYW1lCi0g ICAgLy8gaW4gdGhlIFVSTC4KLSAgICBTdHJpbmcgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3Ry eTo6Z2V0UHJlZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoCi0gICAgICAgIGNhY2hlZEltYWdl LT5yZXNwb25zZSgpLm1pbWVUeXBlKCkpOworICAgIC8vIERldGVybWluZSB0aGUgZmlsZW5hbWUg Zm9yIHRoZSBmaWxlIGNvbnRlbnRzIG9mIHRoZSBpbWFnZS4KKyAgICAvLyBXZSB0cnkgdG8gdXNl IHRoZSBzdWdnZXN0ZWQgZmlsZW5hbWUgaW4gdGhlIGh0dHAgaGVhZGVyIGZpcnN0LgorICAgIC8v IFRoZW4sIGlmIHRoZXJlJ3Mgbm9uZSwgd2UgdHJ5IHRvIGV4dHJhY3QgdGhlIGZpbGVuYW1lIGZy b20KKyAgICAvLyB0aGUgaW1hZ2UgVVJMIHN0b3JlZCBpbiB0aGUgc3JjIGF0dHJpYnV0ZS4KKyAg ICAvLyBJZiB0aGVyZSdzIG5vbmUsIHdlIHRoZW4gdHJ5IHRoZSBhbHQgdGFnIGlmIG9uZSBleGlz dHMuCisgICAgU3RyaW5nIGZpbGVOYW1lID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2Vz dGVkRmlsZW5hbWUoKTsKKyAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKSB7CisgICAgICAgIFN0 cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShzcmNBdHRyKTsKKyAgICAgICAg aWYgKCFpbWFnZVVSTC5pc0VtcHR5KCkpCisgICAgICAgICAgICBmaWxlTmFtZSA9IGVsZW1lbnQt PmRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHBhcnNlVVJMKGltYWdlVVJMKSkubGFzdFBhdGhDb21w b25lbnQoKTsKKyAgICAgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIGZp bGVOYW1lID0gZWxlbWVudC0+Z2V0QXR0cmlidXRlKGFsdEF0dHIpOworICAgIH0KKworICAgIC8v IFdlIGNhbid0IHJlbHkgb24gdGhlIGZpbGVuYW1lIGV4dGVuc2lvbiwgc28gd2UgbXVzdCByZW1v dmUgaXQgYW5kIHVzZSB0aGUgb25lIHJlZ2lzdGVyZWQgd2l0aCB0aGUgTUlNRSB0eXBlLgorICAg IFN0cmluZyBleHRlbnNpb24gPSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRFeHRlbnNp b25Gb3JNSU1FVHlwZShjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5taW1lVHlwZSgpKTsKKyAgICBp bnQgZXh0ZW5zaW9uX2luZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICBpZiAo ZXh0ZW5zaW9uX2luZGV4ICE9IC0xKQorICAgICAgICBmaWxlTmFtZS50cnVuY2F0ZShleHRlbnNp b25faW5kZXgpOworCiAgICAgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbiA9IGV4dGVuc2lvbi5p c0VtcHR5KCkgPyAiIiA6ICIuIiArIGV4dGVuc2lvbjsKLSAgICBTdHJpbmcgdGl0bGUgPSBlbGVt ZW50LT5nZXRBdHRyaWJ1dGUoYWx0QXR0cik7Ci0gICAgaWYgKHRpdGxlLmlzRW1wdHkoKSkKLSAg ICAgICAgdGl0bGUgPSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgp OwogCi0gICAgdGl0bGUgPSBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFtZSh0aXRs ZSwgZGF0YU9iamVjdCk7Ci0gICAgZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnRGaWxlbmFtZSA9IHRp dGxlICsgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbjsKKyAgICBmaWxlTmFtZSA9IENsaXBib2Fy ZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKGZpbGVOYW1lLCBkYXRhT2JqZWN0KTsKKyAgICBk YXRhT2JqZWN0LT5maWxlQ29udGVudEZpbGVuYW1lID0gZmlsZU5hbWUgKyBkYXRhT2JqZWN0LT5m aWxlRXh0ZW5zaW9uOwogfQogCiB2b2lkIENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3Jp dGVEcmFnSW1hZ2UoRWxlbWVudCogZWxlbWVudCwgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJp bmcmIHRpdGxlLCBGcmFtZSogZnJhbWUpCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL3dpbi9DbGlw Ym9hcmRXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vd2luL0NsaXBib2Fy ZFdpbi5jcHAJKHJldmlzaW9uIDQyMTk5KQorKysgV2ViQ29yZS9wbGF0Zm9ybS93aW4vQ2xpcGJv YXJkV2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzE1LDggKzMxNSwxMSBAQCBzdGF0aWMgSEdM T0JBTCBjcmVhdGVHbG9iYWxVcmxGaWxlRGVzY3JpCiB9CiAKIAotc3RhdGljIEhHTE9CQUwgY3Jl YXRlR2xvYmFsSW1hZ2VGaWxlRGVzY3JpcHRvcihjb25zdCBTdHJpbmcmIHVybCwgY29uc3QgU3Ry aW5nJiB0aXRsZSwgQ2FjaGVkSW1hZ2UqIGltYWdlKQorc3RhdGljIEhHTE9CQUwgY3JlYXRlR2xv YmFsSW1hZ2VGaWxlRGVzY3JpcHRvcihjb25zdCBTdHJpbmcmIHVybCwgU3RyaW5nIGZpbGVOYW1l LCBDYWNoZWRJbWFnZSogaW1hZ2UpCiB7CisgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkKKyAg ICAgIHJldHVybiAwOworCiAgICAgQVNTRVJUX0FSRyhpbWFnZSwgaW1hZ2UpOwogICAgIEFTU0VS VChpbWFnZS0+aW1hZ2UoKS0+ZGF0YSgpKTsKIApAQCAtMzMzLDcgKzMzNiw3IEBAIHN0YXRpYyBI R0xPQkFMIGNyZWF0ZUdsb2JhbEltYWdlRmlsZURlc2MKICAgICBmZ2QtPmZnZFswXS5kd0ZsYWdz ID0gRkRfRklMRVNJWkU7CiAgICAgZmdkLT5mZ2RbMF0ubkZpbGVTaXplTG93ID0gaW1hZ2UtPmlt YWdlKCktPmRhdGEoKS0+c2l6ZSgpOwogICAgIAotICAgIGNvbnN0IFN0cmluZyYgcHJlZmVycmVk VGl0bGUgPSB0aXRsZS5pc0VtcHR5KCkgPyBpbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxl bmFtZSgpIDogdGl0bGU7CisgICAgLy8gV2UgY2FuJ3QgcmVseSBvbiB0aGUgZmlsZW5hbWUgZXh0 ZW5zaW9uLCBzbyB3ZSBtdXN0IHJlbW92ZSBpdCBhbmQgdXNlIHRoZSBpbWFnZSgpLT5maWxlbmFt ZUV4dGVuc2lvbi4KICAgICBTdHJpbmcgZXh0ZW5zaW9uID0gaW1hZ2UtPmltYWdlKCktPmZpbGVu YW1lRXh0ZW5zaW9uKCk7CiAgICAgaWYgKGV4dGVuc2lvbi5pc0VtcHR5KCkpIHsKICAgICAgICAg Ly8gRG8gbm90IGNvbnRpbnVlIHByb2Nlc3NpbmcgaW4gdGhlIHJhcmUgYW5kIHVudXN1YWwgY2Fz ZSB3aGVyZSBhIGRlY29kZWQgaW1hZ2UgaXMgbm90IGFibGUgCkBAIC0zNDEsOCArMzQ0LDExIEBA IHN0YXRpYyBIR0xPQkFMIGNyZWF0ZUdsb2JhbEltYWdlRmlsZURlc2MKICAgICAgICAgcmV0dXJu IDA7CiAgICAgfQogICAgIGV4dGVuc2lvbi5pbnNlcnQoIi4iLCAwKTsKLSAgICBmc1BhdGggPSBm aWxlc3lzdGVtUGF0aEZyb21VcmxPclRpdGxlKHVybCwgcHJlZmVycmVkVGl0bGUsIChUQ0hBUiop ZXh0ZW5zaW9uLmNoYXJhY3RlcnNXaXRoTnVsbFRlcm1pbmF0aW9uKCksIGZhbHNlKTsKKyAgICBp bnQgZXh0ZW5zaW9uX2luZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICBpZiAo ZXh0ZW5zaW9uX2luZGV4ICE9IC0xKSB7CisgICAgICAgIGZpbGVOYW1lLnRydW5jYXRlKGV4dGVu c2lvbl9pbmRleCk7CiAKKyAgICBmc1BhdGggPSBmaWxlc3lzdGVtUGF0aEZyb21VcmxPclRpdGxl KHVybCwgZmlsZU5hbWUsIChUQ0hBUiopZXh0ZW5zaW9uLmNoYXJhY3RlcnNXaXRoTnVsbFRlcm1p bmF0aW9uKCksIGZhbHNlKTsKICAgICBpZiAoZnNQYXRoLmxlbmd0aCgpIDw9IDApIHsKICAgICAg ICAgR2xvYmFsVW5sb2NrKG1lbU9iaik7CiAgICAgICAgIEdsb2JhbEZyZWUobWVtT2JqKTsKQEAg LTY1MCw3ICs2NTYsMTUgQEAgc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChJRGF0 YQogICAgIGlmICghaW1hZ2VCdWZmZXIgfHwgIWltYWdlQnVmZmVyLT5zaXplKCkpCiAgICAgICAg IHJldHVybjsKIAotICAgIEhHTE9CQUwgaW1hZ2VGaWxlRGVzY3JpcHRvciA9IGNyZWF0ZUdsb2Jh bEltYWdlRmlsZURlc2NyaXB0b3IodXJsLnN0cmluZygpLCBlbGVtZW50LT5nZXRBdHRyaWJ1dGUo YWx0QXR0ciksIGNhY2hlZEltYWdlKTsKKyAgICBTdHJpbmcgZmlsZU5hbWUgPSBjYWNoZWRJbWFn ZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGlmIChmaWxlTmFtZS5pc0Vt cHR5KCkpIHsKKyAgICAgIFN0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShz cmNBdHRyKTsKKyAgICAgIGlmICghaW1hZ2VVUkwuaXNFbXB0eSgpKQorICAgICAgICAgIGZpbGVO YW1lID0gZWxlbWVudC0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwocGFyc2VVUkwoaW1hZ2VVUkwp KS5sYXN0UGF0aENvbXBvbmVudCgpOworICAgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkKKyAg ICAgICAgICBmaWxlTmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICB9 CisgICAgSEdMT0JBTCBpbWFnZUZpbGVEZXNjcmlwdG9yID0gY3JlYXRlR2xvYmFsSW1hZ2VGaWxl RGVzY3JpcHRvcih1cmwuc3RyaW5nKCksIGZpbGVOYW1lLCBjYWNoZWRJbWFnZSk7CiAgICAgaWYg KCFpbWFnZUZpbGVEZXNjcmlwdG9yKQogICAgICAgICByZXR1cm47CiAKQEAgLTY2MCw3ICs2NzQs NyBAQCBzdGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KElEYXRhCiAgICAgICAgIHJl dHVybjsKICAgICB9CiAKLSAgICBTdHJpbmcgZmlsZU5hbWUgPSBjYWNoZWRJbWFnZS0+cmVzcG9u c2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGZpbGVOYW1lID0gY2FjaGVkSW1hZ2UtPnJl c3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKICAgICBIR0xPQkFMIGhEcm9wQ29udGVudCA9 IGNyZWF0ZUdsb2JhbEhEcm9wQ29udGVudCh1cmwsIGZpbGVOYW1lLCBpbWFnZUJ1ZmZlcik7CiAg ICAgaWYgKCFoRHJvcENvbnRlbnQpIHsKICAgICAgICAgR2xvYmFsRnJlZShoRHJvcENvbnRlbnQp Owo= 29431 2009-04-13 11:44:49 -0700 2009-08-04 11:14:43 -0700 New version with a fix to a small goof... 24006.txt text/plain 5398 mad SW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0u Y3BwCShyZXZpc2lvbiA0MjQzMykKKysrIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJv YXJkQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNjYsMTkgKzI2NiwzMCBAQCBzdGF0 aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KENocm9tCiAKICAgICBkYXRhT2JqZWN0LT5m aWxlQ29udGVudCA9IGltYWdlQnVmZmVyOwogCi0gICAgLy8gRGV0ZXJtaW5lIHRoZSBmaWxlbmFt ZSBmb3IgdGhlIGZpbGUgY29udGVudHMgb2YgdGhlIGltYWdlLiAgV2UgdHJ5IHRvCi0gICAgLy8g dXNlIHRoZSBhbHQgdGFnIGlmIG9uZSBleGlzdHMsIG90aGVyd2lzZSB3ZSBmYWxsIGJhY2sgb24g dGhlIHN1Z2dlc3RlZAotICAgIC8vIGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciwgYW5kIGZp bmFsbHkgd2UgcmVzb3J0IHRvIHVzaW5nIHRoZSBmaWxlbmFtZQotICAgIC8vIGluIHRoZSBVUkwu Ci0gICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6OmdldFByZWZlcnJlZEV4 dGVuc2lvbkZvck1JTUVUeXBlKAotICAgICAgICBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5taW1l VHlwZSgpKTsKKyAgICAvLyBEZXRlcm1pbmUgdGhlIGZpbGVuYW1lIGZvciB0aGUgZmlsZSBjb250 ZW50cyBvZiB0aGUgaW1hZ2UuCisgICAgLy8gV2UgdHJ5IHRvIHVzZSB0aGUgc3VnZ2VzdGVkIGZp bGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciBmaXJzdC4KKyAgICAvLyBUaGVuLCBpZiB0aGVyZSdz IG5vbmUsIHdlIHRyeSB0byBleHRyYWN0IHRoZSBmaWxlbmFtZSBmcm9tCisgICAgLy8gdGhlIGlt YWdlIFVSTCBzdG9yZWQgaW4gdGhlIHNyYyBhdHRyaWJ1dGUuCisgICAgLy8gSWYgdGhlcmUncyBu b25lLCB3ZSB0aGVuIHRyeSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3RzLgorICAgIFN0cmluZyBm aWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7Cisg ICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkgeworICAgICAgICBTdHJpbmcgaW1hZ2VVUkwgPSBl bGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CisgICAgICAgIGlmICghaW1hZ2VVUkwuaXNF bXB0eSgpKQorICAgICAgICAgICAgZmlsZU5hbWUgPSBlbGVtZW50LT5kb2N1bWVudCgpLT5jb21w bGV0ZVVSTChwYXJzZVVSTChpbWFnZVVSTCkpLmxhc3RQYXRoQ29tcG9uZW50KCk7CisgICAgICAg IGlmIChmaWxlTmFtZS5pc0VtcHR5KCkpCisgICAgICAgICAgICBmaWxlTmFtZSA9IGVsZW1lbnQt PmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICB9CisKKyAgICAvLyBXZSBjYW4ndCByZWx5IG9u IHRoZSBmaWxlbmFtZSBleHRlbnNpb24sIHNvIHdlIG11c3QgcmVtb3ZlIGl0IGFuZCB1c2UgdGhl IG9uZSByZWdpc3RlcmVkIHdpdGggdGhlIE1JTUUgdHlwZS4KKyAgICBTdHJpbmcgZXh0ZW5zaW9u ID0gTUlNRVR5cGVSZWdpc3RyeTo6Z2V0UHJlZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoY2Fj aGVkSW1hZ2UtPnJlc3BvbnNlKCkubWltZVR5cGUoKSk7CisgICAgaW50IGV4dGVuc2lvbl9pbmRl eCA9IGZpbGVOYW1lLnJldmVyc2VGaW5kKCcuJyk7CisgICAgaWYgKGV4dGVuc2lvbl9pbmRleCAh PSAtMSkKKyAgICAgICAgZmlsZU5hbWUudHJ1bmNhdGUoZXh0ZW5zaW9uX2luZGV4KTsKKwogICAg IGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24gPSBleHRlbnNpb24uaXNFbXB0eSgpID8gIiIgOiAi LiIgKyBleHRlbnNpb247Ci0gICAgU3RyaW5nIHRpdGxlID0gZWxlbWVudC0+Z2V0QXR0cmlidXRl KGFsdEF0dHIpOwotICAgIGlmICh0aXRsZS5pc0VtcHR5KCkpCi0gICAgICAgIHRpdGxlID0gY2Fj aGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKIAotICAgIHRpdGxlID0g Q2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUodGl0bGUsIGRhdGFPYmplY3QpOwot ICAgIGRhdGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUgPSB0aXRsZSArIGRhdGFPYmplY3Qt PmZpbGVFeHRlbnNpb247CisgICAgZmlsZU5hbWUgPSBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRh dGVGaWxlTmFtZShmaWxlTmFtZSwgZGF0YU9iamVjdCk7CisgICAgZGF0YU9iamVjdC0+ZmlsZUNv bnRlbnRGaWxlbmFtZSA9IGZpbGVOYW1lICsgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbjsKIH0K IAogdm9pZCBDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1l bnQqIGVsZW1lbnQsIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUq IGZyYW1lKQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS93aW4vQ2xpcGJvYXJkV2luLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL3dpbi9DbGlwYm9hcmRXaW4uY3BwCShyZXZpc2lv biA0MjQzMykKKysrIFdlYkNvcmUvcGxhdGZvcm0vd2luL0NsaXBib2FyZFdpbi5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTMxNSw4ICszMTUsMTEgQEAgc3RhdGljIEhHTE9CQUwgY3JlYXRlR2xvYmFs VXJsRmlsZURlc2NyaQogfQogCiAKLXN0YXRpYyBIR0xPQkFMIGNyZWF0ZUdsb2JhbEltYWdlRmls ZURlc2NyaXB0b3IoY29uc3QgU3RyaW5nJiB1cmwsIGNvbnN0IFN0cmluZyYgdGl0bGUsIENhY2hl ZEltYWdlKiBpbWFnZSkKK3N0YXRpYyBIR0xPQkFMIGNyZWF0ZUdsb2JhbEltYWdlRmlsZURlc2Ny aXB0b3IoY29uc3QgU3RyaW5nJiB1cmwsIFN0cmluZyBmaWxlTmFtZSwgQ2FjaGVkSW1hZ2UqIGlt YWdlKQogeworICAgIGlmIChmaWxlTmFtZS5pc0VtcHR5KCkpCisgICAgICByZXR1cm4gMDsKKwog ICAgIEFTU0VSVF9BUkcoaW1hZ2UsIGltYWdlKTsKICAgICBBU1NFUlQoaW1hZ2UtPmltYWdlKCkt PmRhdGEoKSk7CiAKQEAgLTMzMyw3ICszMzYsNyBAQCBzdGF0aWMgSEdMT0JBTCBjcmVhdGVHbG9i YWxJbWFnZUZpbGVEZXNjCiAgICAgZmdkLT5mZ2RbMF0uZHdGbGFncyA9IEZEX0ZJTEVTSVpFOwog ICAgIGZnZC0+ZmdkWzBdLm5GaWxlU2l6ZUxvdyA9IGltYWdlLT5pbWFnZSgpLT5kYXRhKCktPnNp emUoKTsKICAgICAKLSAgICBjb25zdCBTdHJpbmcmIHByZWZlcnJlZFRpdGxlID0gdGl0bGUuaXNF bXB0eSgpID8gaW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKSA6IHRpdGxlOwor ICAgIC8vIFdlIGNhbid0IHJlbHkgb24gdGhlIGZpbGVuYW1lIGV4dGVuc2lvbiwgc28gd2UgbXVz dCByZW1vdmUgaXQgYW5kIHVzZSB0aGUgaW1hZ2UoKS0+ZmlsZW5hbWVFeHRlbnNpb24uCiAgICAg U3RyaW5nIGV4dGVuc2lvbiA9IGltYWdlLT5pbWFnZSgpLT5maWxlbmFtZUV4dGVuc2lvbigpOwog ICAgIGlmIChleHRlbnNpb24uaXNFbXB0eSgpKSB7CiAgICAgICAgIC8vIERvIG5vdCBjb250aW51 ZSBwcm9jZXNzaW5nIGluIHRoZSByYXJlIGFuZCB1bnVzdWFsIGNhc2Ugd2hlcmUgYSBkZWNvZGVk IGltYWdlIGlzIG5vdCBhYmxlIApAQCAtMzQxLDggKzM0NCwxMSBAQCBzdGF0aWMgSEdMT0JBTCBj cmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjCiAgICAgICAgIHJldHVybiAwOwogICAgIH0KICAgICBl eHRlbnNpb24uaW5zZXJ0KCIuIiwgMCk7Ci0gICAgZnNQYXRoID0gZmlsZXN5c3RlbVBhdGhGcm9t VXJsT3JUaXRsZSh1cmwsIHByZWZlcnJlZFRpdGxlLCAoVENIQVIqKWV4dGVuc2lvbi5jaGFyYWN0 ZXJzV2l0aE51bGxUZXJtaW5hdGlvbigpLCBmYWxzZSk7CisgICAgaW50IGV4dGVuc2lvbl9pbmRl eCA9IGZpbGVOYW1lLnJldmVyc2VGaW5kKCcuJyk7CisgICAgaWYgKGV4dGVuc2lvbl9pbmRleCAh PSAtMSkKKyAgICAgICAgZmlsZU5hbWUudHJ1bmNhdGUoZXh0ZW5zaW9uX2luZGV4KTsKIAorICAg IGZzUGF0aCA9IGZpbGVzeXN0ZW1QYXRoRnJvbVVybE9yVGl0bGUodXJsLCBmaWxlTmFtZSwgKFRD SEFSKilleHRlbnNpb24uY2hhcmFjdGVyc1dpdGhOdWxsVGVybWluYXRpb24oKSwgZmFsc2UpOwog ICAgIGlmIChmc1BhdGgubGVuZ3RoKCkgPD0gMCkgewogICAgICAgICBHbG9iYWxVbmxvY2sobWVt T2JqKTsKICAgICAgICAgR2xvYmFsRnJlZShtZW1PYmopOwpAQCAtNjUwLDcgKzY1NiwxNSBAQCBz dGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KElEYXRhCiAgICAgaWYgKCFpbWFnZUJ1 ZmZlciB8fCAhaW1hZ2VCdWZmZXItPnNpemUoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgSEdM T0JBTCBpbWFnZUZpbGVEZXNjcmlwdG9yID0gY3JlYXRlR2xvYmFsSW1hZ2VGaWxlRGVzY3JpcHRv cih1cmwuc3RyaW5nKCksIGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKSwgY2FjaGVkSW1h Z2UpOworICAgIFN0cmluZyBmaWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dl c3RlZEZpbGVuYW1lKCk7CisgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkgeworICAgICAgU3Ry aW5nIGltYWdlVVJMID0gZWxlbWVudC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOworICAgICAgaWYg KCFpbWFnZVVSTC5pc0VtcHR5KCkpCisgICAgICAgICAgZmlsZU5hbWUgPSBlbGVtZW50LT5kb2N1 bWVudCgpLT5jb21wbGV0ZVVSTChwYXJzZVVSTChpbWFnZVVSTCkpLmxhc3RQYXRoQ29tcG9uZW50 KCk7CisgICAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAgICAgICAgIGZpbGVOYW1lID0g ZWxlbWVudC0+Z2V0QXR0cmlidXRlKGFsdEF0dHIpOworICAgIH0KKyAgICBIR0xPQkFMIGltYWdl RmlsZURlc2NyaXB0b3IgPSBjcmVhdGVHbG9iYWxJbWFnZUZpbGVEZXNjcmlwdG9yKHVybC5zdHJp bmcoKSwgZmlsZU5hbWUsIGNhY2hlZEltYWdlKTsKICAgICBpZiAoIWltYWdlRmlsZURlc2NyaXB0 b3IpCiAgICAgICAgIHJldHVybjsKIApAQCAtNjYwLDcgKzY3NCw3IEBAIHN0YXRpYyB2b2lkIHdy aXRlSW1hZ2VUb0RhdGFPYmplY3QoSURhdGEKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAg IFN0cmluZyBmaWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVu YW1lKCk7CisgICAgZmlsZU5hbWUgPSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRG aWxlbmFtZSgpOwogICAgIEhHTE9CQUwgaERyb3BDb250ZW50ID0gY3JlYXRlR2xvYmFsSERyb3BD b250ZW50KHVybCwgZmlsZU5hbWUsIGltYWdlQnVmZmVyKTsKICAgICBpZiAoIWhEcm9wQ29udGVu dCkgewogICAgICAgICBHbG9iYWxGcmVlKGhEcm9wQ29udGVudCk7Cg== 34076 2009-08-04 11:14:43 -0700 2009-08-05 12:44:29 -0700 New patch (by Jens) imageFilename.patch text/plain 9641 jens SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0Njc2OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjYgQEAKKzIwMDktMDgtMDQgIEplbnMgQWxma2UgIDxzbmVqQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBCdWcg MjQ4ODcgLSBXcm9uZyBmaWxlbmFtZSB3aGVuIGRyYWdnaW5nIGFuIGltYWdlIHRvIHRoZSBEZXNr dG9wLgorICAgICAgICBBZGRzIGZ1bmN0aW9uYWxpdHkgdG8gSFRNTEltYWdlRWxlbWVudCB0byBk ZXRlcm1pbmUgdGhlIGZpbGVuYW1lIHRvIHVzZS4KKyAgICAgICAgTW9kaWZpZXMgQ2xpcGJvYXJk Q2hyb21pdW0gdG8gdXNlIGl0IHdoZW4gc2V0dGluZyB1cCB0aGUgZHJhZy4KKyAgICAgICAgSW1w bGVtZW50cyB2YWxpZGF0ZUZpbGVOYW1lIGZvciBNYWMgQ2hyb21pdW0gKGxpbWl0cyBuYW1lIHRv IDI1NSBVVEYtOCBieXRlcy4pCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0yNDg4NworICAgICAgICAKKyAgICAgICAgTm8gdGVzdHM7IEkgZG9uJ3Qga25v dyBpZiB0aGlzIGJlaGF2aW9yIGNhbiBiZSBzaW11bGF0ZWQgZm9yIGEgdGVzdC4KKworICAgICAg ICAqIGh0bWwvSFRNTEltYWdlRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW1h Z2VFbGVtZW50OjpzdWdnZXN0ZWRGaWxlbmFtZSk6CisgICAgICAgICogaHRtbC9IVE1MSW1hZ2VF bGVtZW50Lmg6CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0u Y3BwOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OndyaXRlSW1hZ2VUb0Rh dGFPYmplY3QpOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVB bmRXcml0ZURyYWdJbWFnZSk6CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJk Q2hyb21pdW0uaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1 bU1hYy5jcHA6CisgICAgICAgIChXZWJDb3JlOjppc0ludmFsaWRGaWxlQ2hhcmFjdGVyKToKKyAg ICAgICAgKFdlYkNvcmU6OkNsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKToKKwog MjAwOS0wOC0wMyAgQ2hyaXMgRmxlaXphY2ggIDxjZmxlaXphY2hAYXBwbGUuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IEpvbiBIb25leWN1dHQuCkluZGV4OiBXZWJDb3JlL2h0bWwvSFRNTElt YWdlRWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxJbWFnZUVsZW1l bnQuY3BwCShyZXZpc2lvbiA0Njc2NykKKysrIFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VFbGVtZW50 LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkhUTUxGb3Jt RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIk1hcHBlZEF0dHJp YnV0ZS5oIgorI2luY2x1ZGUgIk1JTUVUeXBlUmVnaXN0cnkuaCIKICNpbmNsdWRlICJSZW5kZXJJ bWFnZS5oIgogI2luY2x1ZGUgIlNjcmlwdEV2ZW50TGlzdGVuZXIuaCIKIApAQCAtNDQxLDUgKzQ0 Miw0NCBAQCB2b2lkIEhUTUxJbWFnZUVsZW1lbnQ6OmFkZFN1YnJlc291cmNlQXR0CiAgICAgYWRk U3VicmVzb3VyY2VVUkwodXJscywgc3JjKCkpOwogICAgIGFkZFN1YnJlc291cmNlVVJMKHVybHMs IGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVzZU1hcCgpKSk7CiB9CisgICAgCitTdHJpbmcgSFRN TEltYWdlRWxlbWVudDo6c3VnZ2VzdGVkRmlsZW5hbWUoKSBjb25zdAoreworICAgIFN0cmluZyBm aWxlTmFtZTsKKyAgICAKKyAgICAvLyBXZSB0cnkgdG8gdXNlIHRoZSBzdWdnZXN0ZWQgZmlsZW5h bWUgaW4gdGhlIGh0dHAgaGVhZGVyIGZpcnN0LgorICAgIENhY2hlZEltYWdlKiBjYWNoZWRJbWFn ZSA9IHRoaXMtPmNhY2hlZEltYWdlKCk7CisgICAgaWYgKGNhY2hlZEltYWdlICYmIGNhY2hlZElt YWdlLT5pbWFnZSgpICYmIGNhY2hlZEltYWdlLT5pc0xvYWRlZCgpKQorICAgICAgICBmaWxlTmFt ZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7CisgICAgCisg ICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkgeworICAgICAgICAvLyBUaGVuLCBpZiB0aGVyZSdz IG5vbmUsIHdlIHRyeSB0byBleHRyYWN0IHRoZSBmaWxlbmFtZSBmcm9tCisgICAgICAgIC8vIHRo ZSBpbWFnZSBVUkwgc3RvcmVkIGluIHRoZSBzcmMgYXR0cmlidXRlLgorICAgICAgICBLVVJMIHNy YyA9IHRoaXMtPnNyYygpOworICAgICAgICBpZiAoc3JjLmlzVmFsaWQoKSkKKyAgICAgICAgICAg IGZpbGVOYW1lID0gc3JjLmxhc3RQYXRoQ29tcG9uZW50KCk7CisgICAgICAgIC8vIElmIHRoZXJl J3Mgbm9uZSwgd2UgdGhlbiB0cnkgdGhlIGFsdCB0YWcgaWYgb25lIGV4aXN0cy4KKyAgICAgICAg aWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIGZpbGVOYW1lID0gdGhpcy0+YWx0 VGV4dCgpOworICAgIH0KKyAgICAKKyAgICAvLyBMZWFkaW5nIG9yIHRyYWlsaW5nICcuJ3MgYXJl IG5hdWdodHkuCisgICAgd2hpbGUgKGZpbGVOYW1lLnN0YXJ0c1dpdGgoIi4iKSkKKyAgICAgICAg ZmlsZU5hbWUucmVtb3ZlKDAsMSk7CisgICAgd2hpbGUgKGZpbGVOYW1lLmVuZHNXaXRoKCIuIikp CisgICAgICAgIGZpbGVOYW1lLnJlbW92ZShmaWxlTmFtZS5sZW5ndGgoKS0xLCAxKTsKKyAgICAK KyAgICAvLyBXZSBjYW4ndCByZWx5IG9uIHRoZSBmaWxlbmFtZSBleHRlbnNpb24sIHNvIHdlIG11 c3QgcmVtb3ZlIGl0CisgICAgLy8gYW5kIHVzZSB0aGUgb25lIHJlZ2lzdGVyZWQgd2l0aCB0aGUg TUlNRSB0eXBlLgorICAgIGludCBleHRlbnNpb25faW5kZXggPSBmaWxlTmFtZS5yZXZlcnNlRmlu ZCgnLicpOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpCisgICAgICAgIGZpbGVOYW1l LnRydW5jYXRlKGV4dGVuc2lvbl9pbmRleCk7CisgICAgaWYgKCFmaWxlTmFtZS5pc0VtcHR5KCkp IHsKKyAgICAgICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6OmdldFByZWZl cnJlZEV4dGVuc2lvbkZvck1JTUVUeXBlKGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLm1pbWVUeXBl KCkpOworICAgICAgICBmaWxlTmFtZSArPSAiLiI7CisgICAgICAgIGZpbGVOYW1lICs9IGV4dGVu c2lvbjsKKyAgICB9CisgICAgcmV0dXJuIGZpbGVOYW1lOworfQogCiB9CkluZGV4OiBXZWJDb3Jl L2h0bWwvSFRNTEltYWdlRWxlbWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1M SW1hZ2VFbGVtZW50LmgJKHJldmlzaW9uIDQ2NzY3KQorKysgV2ViQ29yZS9odG1sL0hUTUxJbWFn ZUVsZW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMTE2LDYgKzExNiw4IEBAIHB1YmxpYzoKICAg ICBib29sIGhhdmVGaXJlZExvYWRFdmVudCgpIGNvbnN0IHsgcmV0dXJuIG1faW1hZ2VMb2FkZXIu aGF2ZUZpcmVkTG9hZEV2ZW50KCk7IH0KIAogICAgIHZpcnR1YWwgdm9pZCBhZGRTdWJyZXNvdXJj ZUF0dHJpYnV0ZVVSTHMoTGlzdEhhc2hTZXQ8S1VSTD4mKSBjb25zdDsKKyAgICAKKyAgICBTdHJp bmcgc3VnZ2VzdGVkRmlsZW5hbWUoKSBjb25zdDsKIAogcHJpdmF0ZToKICAgICBIVE1MSW1hZ2VM b2FkZXIgbV9pbWFnZUxvYWRlcjsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xp cGJvYXJkQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21p dW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCShyZXZpc2lvbiA0Njc2NykKKysrIFdlYkNvcmUvcGxh dGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0z Niw2ICszNiw3IEBACiAjaW5jbHVkZSAiRmlsZUxpc3QuaCIKICNpbmNsdWRlICJGcmFtZS5oIgog I2luY2x1ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNp bmNsdWRlICJOYW1lZEF0dHJNYXAuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJlZ2lzdHJ5LmgiCiAj aW5jbHVkZSAibWFya3VwLmgiCkBAIC0yNTksMzMgKzI2MCwzMyBAQCBzdGF0aWMgQ2FjaGVkSW1h Z2UqIGdldENhY2hlZEltYWdlKEVsZW1lCiAgICAgcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lk IHdyaXRlSW1hZ2VUb0RhdGFPYmplY3QoQ2hyb21pdW1EYXRhT2JqZWN0KiBkYXRhT2JqZWN0LCBF bGVtZW50KiBlbGVtZW50LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25z dCBLVVJMJiB1cmwpCit2b2lkIENsaXBib2FyZENocm9taXVtOjp3cml0ZUltYWdlVG9EYXRhT2Jq ZWN0KEVsZW1lbnQqIGVsZW1lbnQpCiB7Ci0gICAgLy8gU2hvdmUgaW1hZ2UgZGF0YSBpbnRvIGEg RGF0YU9iamVjdCBmb3IgdXNlIGFzIGEgZmlsZQorICAgIGlmIChlbGVtZW50LT50YWdOYW1lKCkg IT0gIklNRyIpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICAvLyBTaG92ZSBpbWFnZSBkYXRh IGludG8gYSBEYXRhT2JqZWN0IGZvciB1c2UgYXMgYSBmaWxlLgogICAgIENhY2hlZEltYWdlKiBj YWNoZWRJbWFnZSA9IGdldENhY2hlZEltYWdlKGVsZW1lbnQpOwogICAgIGlmICghY2FjaGVkSW1h Z2UgfHwgIWNhY2hlZEltYWdlLT5pbWFnZSgpIHx8ICFjYWNoZWRJbWFnZS0+aXNMb2FkZWQoKSkK ICAgICAgICAgcmV0dXJuOwotCiAgICAgU2hhcmVkQnVmZmVyKiBpbWFnZUJ1ZmZlciA9IGNhY2hl ZEltYWdlLT5pbWFnZSgpLT5kYXRhKCk7CiAgICAgaWYgKCFpbWFnZUJ1ZmZlciB8fCAhaW1hZ2VC dWZmZXItPnNpemUoKSkKICAgICAgICAgcmV0dXJuOwotCi0gICAgZGF0YU9iamVjdC0+ZmlsZUNv bnRlbnQgPSBpbWFnZUJ1ZmZlcjsKLQotICAgIC8vIERldGVybWluZSB0aGUgZmlsZW5hbWUgZm9y IHRoZSBmaWxlIGNvbnRlbnRzIG9mIHRoZSBpbWFnZS4gIFdlIHRyeSB0bwotICAgIC8vIHVzZSB0 aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3RzLCBvdGhlcndpc2Ugd2UgZmFsbCBiYWNrIG9uIHRoZSBz dWdnZXN0ZWQKLSAgICAvLyBmaWxlbmFtZSBpbiB0aGUgaHR0cCBoZWFkZXIsIGFuZCBmaW5hbGx5 IHdlIHJlc29ydCB0byB1c2luZyB0aGUgZmlsZW5hbWUKLSAgICAvLyBpbiB0aGUgVVJMLgotICAg IFN0cmluZyBleHRlbnNpb24gPSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRFeHRlbnNp b25Gb3JNSU1FVHlwZSgKLSAgICAgICAgY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWltZVR5cGUo KSk7Ci0gICAgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbiA9IGV4dGVuc2lvbi5pc0VtcHR5KCkg PyAiIiA6ICIuIiArIGV4dGVuc2lvbjsKLSAgICBTdHJpbmcgdGl0bGUgPSBlbGVtZW50LT5nZXRB dHRyaWJ1dGUoYWx0QXR0cik7Ci0gICAgaWYgKHRpdGxlLmlzRW1wdHkoKSkKLSAgICAgICAgdGl0 bGUgPSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOwotCi0gICAg dGl0bGUgPSBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFtZSh0aXRsZSwgZGF0YU9i amVjdCk7Ci0gICAgZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnRGaWxlbmFtZSA9IHRpdGxlICsgZGF0 YU9iamVjdC0+ZmlsZUV4dGVuc2lvbjsKKyAgICBtX2RhdGFPYmplY3QtPmZpbGVDb250ZW50ID0g aW1hZ2VCdWZmZXI7CisgICAgCisgICAgLy8gUGljayBhIGZpbGVuYW1lIGFuZCBzcGxpdCBvdXQg dGhlIGV4dGVuc2lvbi4KKyAgICBTdHJpbmcgZmlsZU5hbWUgPSAoKEhUTUxJbWFnZUVsZW1lbnQq KWVsZW1lbnQpLT5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGludCBleHRlbnNpb25faW5kZXgg PSBmaWxlTmFtZS5yZXZlcnNlRmluZCgnLicpOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0g LTEpIHsKKyAgICAgICAgbV9kYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uID0gZmlsZU5hbWUuc3Vi c3RyaW5nKGV4dGVuc2lvbl9pbmRleCk7CisgICAgICAgIGZpbGVOYW1lID0gZmlsZU5hbWUubGVm dChleHRlbnNpb25faW5kZXgpOworICAgIH0gZWxzZSB7CisgICAgICAgIG1fZGF0YU9iamVjdC0+ ZmlsZUV4dGVuc2lvbiA9ICIiOworICAgIH0KKyAgICAKKyAgICAvLyBSdW4gdGhlIG5hbWUgdGhy b3VnaCBwbGF0Zm9ybS1zcGVjaWZpYyB2YWxpZGF0aW9uLgorICAgIGZpbGVOYW1lID0gQ2xpcGJv YXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoZmlsZU5hbWUsIG1fZGF0YU9iamVjdC5nZXQo KSk7CisgICAgbV9kYXRhT2JqZWN0LT5maWxlQ29udGVudEZpbGVuYW1lID0gZmlsZU5hbWUgKyBt X2RhdGFPYmplY3QtPmZpbGVFeHRlbnNpb247CiB9CiAKIHZvaWQgQ2xpcGJvYXJkQ2hyb21pdW06 OmRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50KiBlbGVtZW50LCBjb25zdCBLVVJMJiB1 cmwsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkKQEAgLTI5Nyw3ICsyOTgsNyBA QCB2b2lkIENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3JpdGVECiAgICAgbV9kYXRhT2Jq ZWN0LT51cmxUaXRsZSA9IHRpdGxlOwogCiAgICAgLy8gV3JpdGUgdGhlIGJ5dGVzIGluIHRoZSBp bWFnZSB0byB0aGUgZmlsZSBmb3JtYXQuCi0gICAgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChtX2Rh dGFPYmplY3QuZ2V0KCksIGVsZW1lbnQsIHVybCk7CisgICAgdGhpcy0+d3JpdGVJbWFnZVRvRGF0 YU9iamVjdChlbGVtZW50KTsKIAogICAgIEF0b21pY1N0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQt PmdldEF0dHJpYnV0ZShzcmNBdHRyKTsKICAgICBpZiAoaW1hZ2VVUkwuaXNFbXB0eSgpKQpJbmRl eDogV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uaAkocmV2 aXNpb24gNDY3NjcpCisrKyBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9t aXVtLmgJKHdvcmtpbmcgY29weSkKQEAgLTM4LDYgKzM4LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogCiAgICAgY2xhc3MgQ2FjaGVkSW1hZ2U7CiAgICAgY2xhc3MgQ2hyb21pdW1EYXRhT2JqZWN0 OworICAgIGNsYXNzIEVsZW1lbnQ7CiAgICAgY2xhc3MgSW50UG9pbnQ7CiAKICAgICBjbGFzcyBD bGlwYm9hcmRDaHJvbWl1bSA6IHB1YmxpYyBDbGlwYm9hcmQsIHB1YmxpYyBDYWNoZWRSZXNvdXJj ZUNsaWVudCB7CkBAIC04Miw2ICs4Myw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAg ICB2b2lkIHJlc2V0RnJvbUNsaXBib2FyZCgpOwogICAgICAgICB2b2lkIHNldERyYWdJbWFnZShD YWNoZWRJbWFnZSosIE5vZGUqLCBjb25zdCBJbnRQb2ludCYpOworICAgICAgICB2b2lkIHdyaXRl SW1hZ2VUb0RhdGFPYmplY3QoRWxlbWVudCopOwogICAgICAgICBSZWZQdHI8Q2hyb21pdW1EYXRh T2JqZWN0PiBtX2RhdGFPYmplY3Q7CiAgICAgfTsKIApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9j aHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9w bGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAJKHJldmlzaW9uIDQ2NzY3 KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTI4LDE0ICsyOCw0NiBAQAogI2luY2x1ZGUgIkNsaXBib2FyZENo cm9taXVtLmgiCiAKICNpbmNsdWRlICJDaHJvbWl1bURhdGFPYmplY3QuaCIKLSNpbmNsdWRlICJO b3RJbXBsZW1lbnRlZC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCisKKy8vIE9uIEhG UysgdGhlIG1heGltdW0gbGVuZ3RoIG9mIGEgZmlsZW5hbWUgaXMgMjU1IFVURi04IGJ5dGVzLiBP dGhlciBmaWxlc3lzdGVtcworLy8gaGF2ZSBkaWZmZXJlbnQgbGltaXRzLCBidXQgdGhpcyBpcyB0 aGUgbW9zdCBjb21tb24sIHNvIHVzZSBpdC4KK3N0YXRpYyBjb25zdCBpbnQgTWF4RmlsZW5hbWVM ZW5ndGhCeXRlcyA9IDI1NTsKKworCitzdGF0aWMgYm9vbCBpc0ludmFsaWRGaWxlQ2hhcmFjdGVy KFVDaGFyIGMpCit7CisgICAgLy8gQWxsb3cgYW55dGhpbmcgYnV0IGNvbnRyb2wgY2hhcmFjdGVy cyBhbmQgdGhlICcvJy4KKyAgICByZXR1cm4gYyA8ICcgJyB8fCBjID09ICcvJzsKK30KIAogU3Ry aW5nIENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKGNvbnN0IFN0cmluZyYgdGl0 bGUsIENocm9taXVtRGF0YU9iamVjdCogZGF0YU9iamVjdCkKIHsKLSAgICBub3RJbXBsZW1lbnRl ZCgpOwotICAgIHJldHVybiB0aXRsZTsKKyAgICAvLyBSZW1vdmUgYW55IGludmFsaWQgZmlsZSBz eXN0ZW0gY2hhcmFjdGVycy4KKyAgICBTdHJpbmcgcmVzdWx0ID0gdGl0bGUucmVtb3ZlQ2hhcmFj dGVycygmaXNJbnZhbGlkRmlsZUNoYXJhY3Rlcik7CisgICAgU3RyaW5nIGV4dGVuc2lvbiA9IGRh dGFPYmplY3QtPmZpbGVFeHRlbnNpb24ucmVtb3ZlQ2hhcmFjdGVycygmaXNJbnZhbGlkRmlsZUNo YXJhY3Rlcik7CisKKyAgICAvLyBMZWFkaW5nICIuInMgYXJlIG5hdWdodHkuCisgICAgd2hpbGUg KHJlc3VsdC5zdGFydHNXaXRoKCIuIikpCisgICAgICAgIHJlc3VsdC5yZW1vdmUoMCwxKTsKKwor ICAgIC8vIFJlbW92ZSBhIHJpZGljdWxvdXNseS1sb25nIGV4dGVuc2lvbi4KKyAgICBpbnQgZXh0 ZW5zaW9uTGVuID0gZXh0ZW5zaW9uLnV0ZjgoKS5sZW5ndGgoKTsKKyAgICBpZiAoZXh0ZW5zaW9u TGVuID49IE1heEZpbGVuYW1lTGVuZ3RoQnl0ZXMpIHsKKyAgICAgICAgZXh0ZW5zaW9uID0gIiI7 CisgICAgICAgIGV4dGVuc2lvbkxlbiA9IDA7CisgICAgfQorICAgIAorICAgIC8vIFRydW5jYXRl IGFuIG92ZXJseS1sb25nIGZpbGVuYW1lLgorICAgIHdoaWxlIChyZXN1bHQudXRmOCgpLmxlbmd0 aCgpICsgZXh0ZW5zaW9uTGVuID4gTWF4RmlsZW5hbWVMZW5ndGhCeXRlcykgeworICAgICAgICAv LyBXZSBrbm93IGhvdyBtYW55IFVURjggX2J5dGVzXyB0byByZW1vdmUsIGJ1dCBub3QgaG93IG1h bnkgX2NoYXJhY3RlcnNfLgorICAgICAgICAvLyBUaGUgZWFzaWVzdCB0aGluZyB0byBkbyBpcyBy ZW1vdmUgb25lIGNoYXJhY3RlciBhdCBhIHRpbWUuCisgICAgICAgIHJlc3VsdC50cnVuY2F0ZShy ZXN1bHQubGVuZ3RoKCkgLSAxKTsKKyAgICB9CisgICAgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lv biA9IGV4dGVuc2lvbjsKKyAgICByZXR1cm4gcmVzdWx0OwogfQogCiB9ICAvLyBuYW1lc3BhY2Ug V2ViQ29yZQo= 34160 2009-08-05 12:44:29 -0700 2009-08-05 13:02:15 -0700 Updated patch, refactoring Clipboard class imageFilename2.patch text/plain 16933 jens SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NjgwNCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMDktMDgtMDQgIEplbnMgQWxma2UgIDxzbmVqQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBCdWcg MjQ4ODcgLSBXcm9uZyBmaWxlbmFtZSB3aGVuIGRyYWdnaW5nIGFuIGltYWdlIHRvIHRoZSBEZXNr dG9wLgorICAgICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI0ODg3CisgICAgICAgIEFkZHMgZnVuY3Rpb25hbGl0eSB0byBIVE1MSW1hZ2VFbGVtZW50IHRv IGRldGVybWluZSB0aGUgZmlsZW5hbWUgdG8gdXNlLgorICAgICAgICBNb2RpZmllcyBDbGlwYm9h cmRDaHJvbWl1bSB0byB1c2UgaXQgd2hlbiBzZXR0aW5nIHVwIHRoZSBkcmFnLgorICAgICAgICBJ bXBsZW1lbnRzIHZhbGlkYXRlRmlsZU5hbWUgZm9yIE1hYyBDaHJvbWl1bSAobGltaXRzIG5hbWUg dG8gMjU1IFVURi04IGJ5dGVzLikKKyAgICAgICAgCisgICAgICAgIE5vIHRlc3RzOyB3b3VsZCBi ZSB1bnJlYXNvbmFibHkgZGlmZmljdWx0IHRvIGFkZCB0aGUgcGx1bWJpbmcgdG8gYWNjZXNzIHRo ZSBwcm9wb3NlZAorCWZpbGVuYW1lIGZyb20gd2l0aGluIERSVC4KKworICAgICAgICAqIGh0bWwv SFRNTEltYWdlRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW1hZ2VFbGVtZW50 OjpzdWdnZXN0ZWRGaWxlbmFtZSk6CisgICAgICAgICogaHRtbC9IVE1MSW1hZ2VFbGVtZW50Lmg6 CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OndyaXRlSW1hZ2VUb0RhdGFPYmplY3Qp OgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0ZURy YWdJbWFnZSk6CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0u aDoKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHA6 CisgICAgICAgIChXZWJDb3JlOjppc0ludmFsaWRGaWxlQ2hhcmFjdGVyKToKKyAgICAgICAgKFdl YkNvcmU6OkNsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKToKKwogMjAwOS0wOC0w NSAgQW5kcmFzIEJlY3NpICA8YmVjc2kuYW5kcmFzQHN0dWQudS1zemVnZWQuaHU+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgU2ltb24gSGF1c21hbm4uCkluZGV4OiBXZWJDb3JlL2RvbS9DbGlwYm9h cmQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL0NsaXBib2FyZC5jcHAJKHJldmlzaW9u IDQ2ODA0KQorKysgV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MjgsOSArMjgsMTQgQEAKIAogI2luY2x1ZGUgIkNhY2hlZEltYWdlLmgiCiAjaW5jbHVkZSAiRE9N SW1wbGVtZW50YXRpb24uaCIKKyNpbmNsdWRlICJFbGVtZW50LmgiCiAjaW5jbHVkZSAiRnJhbWUu aCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQu aCIKKyNpbmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbWFnZS5oIgorI2luY2x1ZGUg IlJlbmRlckltYWdlLmgiCisjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKQEAgLTEzOSw1ICsxNDQsODQgQEAgdm9pZCBDbGlwYm9hcmQ6OnNldEVmZmVj dEFsbG93ZWQoY29uc3QgUwogICAgIGlmIChtX3BvbGljeSA9PSBDbGlwYm9hcmRXcml0YWJsZSkK ICAgICAgICAgbV9lZmZlY3RBbGxvd2VkID0gZWZmZWN0OwogfQorICAgIAorc3RhdGljIENhY2hl ZEltYWdlKiBnZXRDYWNoZWRJbWFnZShFbGVtZW50KiBlbGVtZW50KQoreworICAgIC8vIEF0dGVt cHQgdG8gcHVsbCBDYWNoZWRJbWFnZSBmcm9tIGVsZW1lbnQKKyAgICBBU1NFUlQoZWxlbWVudCk7 CisgICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGVsZW1lbnQtPnJlbmRlcmVyKCk7CisgICAg aWYgKCFyZW5kZXJlciB8fCAhcmVuZGVyZXItPmlzSW1hZ2UoKSkKKyAgICAgICAgcmV0dXJuIDA7 CisgICAgCisgICAgUmVuZGVySW1hZ2UqIGltYWdlID0gdG9SZW5kZXJJbWFnZShyZW5kZXJlcik7 CisgICAgaWYgKGltYWdlLT5jYWNoZWRJbWFnZSgpICYmICFpbWFnZS0+Y2FjaGVkSW1hZ2UoKS0+ ZXJyb3JPY2N1cnJlZCgpKQorICAgICAgICByZXR1cm4gaW1hZ2UtPmNhY2hlZEltYWdlKCk7Cisg ICAgCisgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBTdHJpbmcgaW1hZ2VUb01hcmt1cChFbGVt ZW50KiBlbGVtZW50LCBGcmFtZSAqZnJhbWUpCit7CisgICAgU3RyaW5nIHNyY1VSTDsKKyAgICBB dG9taWNTdHJpbmcgaW1hZ2VVUkwgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoSFRNTE5hbWVzOjpz cmNBdHRyKTsKKyAgICBpZiAoIWltYWdlVVJMLmlzRW1wdHkoKSkKKyAgICAgICAgc3JjVVJMID0g ZnJhbWUtPmRvY3VtZW50KCktPmNvbXBsZXRlVVJMKGRlcHJlY2F0ZWRQYXJzZVVSTChpbWFnZVVS TCkpOworICAgIAorICAgIFN0cmluZ0J1aWxkZXIgbWFya3VwOworICAgIG1hcmt1cC5hcHBlbmQo IjxpbWcgc3JjPVwiIik7CisgICAgbWFya3VwLmFwcGVuZChzcmNVUkwpOworICAgIG1hcmt1cC5h cHBlbmQoIlwiIik7CisgICAgLy8gQ29weSBvdmVyIGF0dHJpYnV0ZXMuICBJZiB3ZSBhcmUgZHJh Z2dpbmcgYW4gaW1hZ2UsIHdlIGV4cGVjdCB0aGluZ3MgbGlrZQorICAgIC8vIHRoZSBpZCB0byBi ZSBjb3BpZWQgYXMgd2VsbC4KKyAgICBOYW1lZE5vZGVNYXAqIGF0dHJzID0gZWxlbWVudC0+YXR0 cmlidXRlcygpOworICAgIHVuc2lnbmVkIGxlbmd0aCA9IGF0dHJzLT5sZW5ndGgoKTsKKyAgICBm b3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbGVuZ3RoOyArK2kpIHsKKyAgICAgICAgQXR0cmlidXRl KiBhdHRyID0gYXR0cnMtPmF0dHJpYnV0ZUl0ZW0oaSk7CisgICAgICAgIGlmIChhdHRyLT5sb2Nh bE5hbWUoKSA9PSAic3JjIikKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICBtYXJrdXAu YXBwZW5kKCIgIik7CisgICAgICAgIG1hcmt1cC5hcHBlbmQoYXR0ci0+bG9jYWxOYW1lKCkpOwor ICAgICAgICBtYXJrdXAuYXBwZW5kKCI9XCIiKTsKKyAgICAgICAgU3RyaW5nIGVzY2FwZWRBdHRy ID0gYXR0ci0+dmFsdWUoKTsKKyAgICAgICAgZXNjYXBlZEF0dHIucmVwbGFjZSgiXCIiLCAiJnF1 b3Q7Iik7CisgICAgICAgIG1hcmt1cC5hcHBlbmQoZXNjYXBlZEF0dHIpOworICAgICAgICBtYXJr dXAuYXBwZW5kKCJcIiIpOworICAgIH0KKyAgICAKKyAgICBtYXJrdXAuYXBwZW5kKCIvPiIpOwor ICAgIHJldHVybiBtYXJrdXAudG9TdHJpbmcoKTsKK30KKwordm9pZCBDbGlwYm9hcmQ6OmRlY2xh cmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50KiBlbGVtZW50LCBjb25zdCBLVVJMJiB1cmwsIGNv bnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkKK3sKKyAgICAvLyBHZXQgdGhlIGltYWdl IGRhdGEgKGFib3J0IGlmIHRoZXJlIGlzIG5vbmUpLgorICAgIFNoYXJlZEJ1ZmZlciogaW1hZ2VC dWZmZXIgPSBOVUxMOworICAgIENhY2hlZEltYWdlKiBjYWNoZWRJbWFnZSA9IGdldENhY2hlZElt YWdlKGVsZW1lbnQpOworICAgIGlmIChjYWNoZWRJbWFnZSAmJiBjYWNoZWRJbWFnZS0+aW1hZ2Uo KSAmJiBjYWNoZWRJbWFnZS0+aXNMb2FkZWQoKSkKKyAgICAgICAgaW1hZ2VCdWZmZXIgPSBjYWNo ZWRJbWFnZS0+aW1hZ2UoKS0+ZGF0YSgpOworICAgIGlmICghaW1hZ2VCdWZmZXIgfHwgIWltYWdl QnVmZmVyLT5zaXplKCkpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICAvLyBHZXQgdGhlIGZp bGVuYW1lIHRvIHVzZS4KKyAgICBTdHJpbmcgZmlsZU5hbWU7CisgICAgaWYgKGVsZW1lbnQtPmhh c1RhZ05hbWUoSFRNTE5hbWVzOjppbWdUYWcpKQorICAgICAgICBmaWxlTmFtZSA9IHN0YXRpY19j YXN0PEhUTUxJbWFnZUVsZW1lbnQqPihlbGVtZW50KS0+c3VnZ2VzdGVkRmlsZW5hbWUoKTsKKyAg ICAKKyAgICAvLyBDcmVhdGUgSFRNTCA8aW1nPiBtYXJrdXA6CisgICAgU3RyaW5nIGh0bWxNYXJr dXAgPSBpbWFnZVRvTWFya3VwKGVsZW1lbnQsZnJhbWUpOworICAgIAorICAgIC8vIE5vdyBjYWxs IHRoZSBhYnN0cmFjdCBmdWxseS1zcGVjaWZpZWQgdmVyc2lvbiBvZiB0aGlzIG1ldGhvZC4KKyAg ICB0aGlzLT5kZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UodXJsLCB0aXRsZSwgaW1hZ2VCdWZmZXIs IGZpbGVOYW1lLCBodG1sTWFya3VwKTsKK30KKyAgICAKK3ZvaWQgQ2xpcGJvYXJkOjpkZWNsYXJl QW5kV3JpdGVEcmFnSW1hZ2UoY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNoYXJlZEJ1ZmZlciosIGNvbnN0IFN0cmlu ZyYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFN0cmlu ZyYpCit7CisgICAgLy8gVGhpcyBtZXRob2QgaXMgYWJzdHJhY3Q7IGEgc3ViY2xhc3MgbXVzdCBv dmVycmlkZSBpdCwgb3IgdGhlIHB1YmxpYyB2ZXJzaW9uIHRoYXQgY2FsbHMgaXQuCisgICAgQVNT RVJUX05PVF9SRUFDSEVEKCk7Cit9CisgICAgCisKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJ bmRleDogV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9kb20v Q2xpcGJvYXJkLmgJKHJldmlzaW9uIDQ2ODA0KQorKysgV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmgJ KHdvcmtpbmcgY29weSkKQEAgLTY0LDcgKzY0LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAg ICAgICB2aXJ0dWFsIHZvaWQgc2V0RHJhZ0ltYWdlRWxlbWVudChOb2RlKiwgY29uc3QgSW50UG9p bnQmKSA9IDA7CiAgICAgICAgIAogICAgICAgICB2aXJ0dWFsIERyYWdJbWFnZVJlZiBjcmVhdGVE cmFnSW1hZ2UoSW50UG9pbnQmIGRyYWdMb2NhdGlvbikgY29uc3QgPSAwOwotICAgICAgICB2aXJ0 dWFsIHZvaWQgZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1lbnQqLCBjb25zdCBLVVJMJiwg Y29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqKSA9IDA7CisgICAgICAgIHZpcnR1YWwgdm9pZCBk ZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoRWxlbWVudCosIGNvbnN0IEtVUkwmLCBjb25zdCBTdHJp bmcmIHRpdGxlLCBGcmFtZSopOwogICAgICAgICB2aXJ0dWFsIHZvaWQgd3JpdGVVUkwoY29uc3Qg S1VSTCYsIGNvbnN0IFN0cmluZyYsIEZyYW1lKikgPSAwOwogICAgICAgICB2aXJ0dWFsIHZvaWQg d3JpdGVSYW5nZShSYW5nZSosIEZyYW1lKikgPSAwOwogCkBAIC04NSw2ICs4NSwxMCBAQCBuYW1l c3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIENsaXBib2FyZEFjY2Vzc1BvbGljeSBwb2xpY3koKSBj b25zdCB7IHJldHVybiBtX3BvbGljeTsgfQogICAgICAgICBib29sIGRyYWdTdGFydGVkKCkgY29u c3QgeyByZXR1cm4gbV9kcmFnU3RhcnRlZDsgfQogICAgICAgICAKKyAgICAgICAgdmlydHVhbCB2 b2lkIGRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmlu ZyYgdGl0bGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg U2hhcmVkQnVmZmVyKiBpbWFnZUJ1ZmZlciwgY29uc3QgU3RyaW5nJiBmaWxlTmFtZSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBTdHJpbmcmIG1h cmt1cCk7CisgICAgICAgIAogICAgIHByaXZhdGU6CiAgICAgICAgIENsaXBib2FyZEFjY2Vzc1Bv bGljeSBtX3BvbGljeTsKICAgICAgICAgU3RyaW5nIG1fZHJvcEVmZmVjdDsKSW5kZXg6IFdlYkNv cmUvaHRtbC9IVE1MSW1hZ2VFbGVtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwv SFRNTEltYWdlRWxlbWVudC5jcHAJKHJldmlzaW9uIDQ2ODA0KQorKysgV2ViQ29yZS9odG1sL0hU TUxJbWFnZUVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMSw2ICszMSw3IEBACiAjaW5j bHVkZSAiSFRNTEZvcm1FbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVk ZSAiTWFwcGVkQXR0cmlidXRlLmgiCisjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgogI2lu Y2x1ZGUgIlJlbmRlckltYWdlLmgiCiAjaW5jbHVkZSAiU2NyaXB0RXZlbnRMaXN0ZW5lci5oIgog CkBAIC00NDEsNSArNDQyLDQ0IEBAIHZvaWQgSFRNTEltYWdlRWxlbWVudDo6YWRkU3VicmVzb3Vy Y2VBdHQKICAgICBhZGRTdWJyZXNvdXJjZVVSTCh1cmxzLCBzcmMoKSk7CiAgICAgYWRkU3VicmVz b3VyY2VVUkwodXJscywgZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXNlTWFwKCkpKTsKIH0KKyAg ICAKK1N0cmluZyBIVE1MSW1hZ2VFbGVtZW50OjpzdWdnZXN0ZWRGaWxlbmFtZSgpIGNvbnN0Cit7 CisgICAgU3RyaW5nIGZpbGVOYW1lOworICAgIAorICAgIC8vIFdlIHRyeSB0byB1c2UgdGhlIHN1 Z2dlc3RlZCBmaWxlbmFtZSBpbiB0aGUgaHR0cCBoZWFkZXIgZmlyc3QuCisgICAgQ2FjaGVkSW1h Z2UqIGNhY2hlZEltYWdlID0gdGhpcy0+Y2FjaGVkSW1hZ2UoKTsKKyAgICBpZiAoY2FjaGVkSW1h Z2UgJiYgY2FjaGVkSW1hZ2UtPmltYWdlKCkgJiYgY2FjaGVkSW1hZ2UtPmlzTG9hZGVkKCkpCisg ICAgICAgIGZpbGVOYW1lID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5h bWUoKTsKKyAgICAKKyAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKSB7CisgICAgICAgIC8vIFRo ZW4sIGlmIHRoZXJlJ3Mgbm9uZSwgd2UgdHJ5IHRvIGV4dHJhY3QgdGhlIGZpbGVuYW1lIGZyb20K KyAgICAgICAgLy8gdGhlIGltYWdlIFVSTCBzdG9yZWQgaW4gdGhlIHNyYyBhdHRyaWJ1dGUuCisg ICAgICAgIEtVUkwgc3JjID0gdGhpcy0+c3JjKCk7CisgICAgICAgIGlmIChzcmMuaXNWYWxpZCgp KQorICAgICAgICAgICAgZmlsZU5hbWUgPSBzcmMubGFzdFBhdGhDb21wb25lbnQoKTsKKyAgICAg ICAgLy8gSWYgdGhlcmUncyBub25lLCB3ZSB0aGVuIHRyeSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhp c3RzLgorICAgICAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAgICAgICAgICAgZmlsZU5h bWUgPSB0aGlzLT5hbHRUZXh0KCk7CisgICAgfQorICAgIAorICAgIC8vIFJlbW92ZSBsZWFkaW5n IG9yIHRyYWlsaW5nICcuJ3MuCisgICAgd2hpbGUgKGZpbGVOYW1lLnN0YXJ0c1dpdGgoIi4iKSkK KyAgICAgICAgZmlsZU5hbWUucmVtb3ZlKDAsMSk7CisgICAgd2hpbGUgKGZpbGVOYW1lLmVuZHNX aXRoKCIuIikpCisgICAgICAgIGZpbGVOYW1lLnJlbW92ZShmaWxlTmFtZS5sZW5ndGgoKS0xLCAx KTsKKyAgICAKKyAgICAvLyBXZSBjYW4ndCByZWx5IG9uIHRoZSBmaWxlbmFtZSBleHRlbnNpb24s IHNvIHdlIG11c3QgcmVtb3ZlIGl0CisgICAgLy8gYW5kIHVzZSB0aGUgb25lIHJlZ2lzdGVyZWQg d2l0aCB0aGUgTUlNRSB0eXBlLgorICAgIGludCBleHRlbnNpb25faW5kZXggPSBmaWxlTmFtZS5y ZXZlcnNlRmluZCgnLicpOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpCisgICAgICAg IGZpbGVOYW1lLnRydW5jYXRlKGV4dGVuc2lvbl9pbmRleCk7CisgICAgaWYgKCFmaWxlTmFtZS5p c0VtcHR5KCkpIHsKKyAgICAgICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6 OmdldFByZWZlcnJlZEV4dGVuc2lvbkZvck1JTUVUeXBlKGNhY2hlZEltYWdlLT5yZXNwb25zZSgp Lm1pbWVUeXBlKCkpOworICAgICAgICBmaWxlTmFtZSArPSAiLiI7CisgICAgICAgIGZpbGVOYW1l ICs9IGV4dGVuc2lvbjsKKyAgICB9CisgICAgcmV0dXJuIGZpbGVOYW1lOworfQogCiB9CkluZGV4 OiBXZWJDb3JlL2h0bWwvSFRNTEltYWdlRWxlbWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv aHRtbC9IVE1MSW1hZ2VFbGVtZW50LmgJKHJldmlzaW9uIDQ2ODA0KQorKysgV2ViQ29yZS9odG1s L0hUTUxJbWFnZUVsZW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMTE2LDYgKzExNiw4IEBAIHB1 YmxpYzoKICAgICBib29sIGhhdmVGaXJlZExvYWRFdmVudCgpIGNvbnN0IHsgcmV0dXJuIG1faW1h Z2VMb2FkZXIuaGF2ZUZpcmVkTG9hZEV2ZW50KCk7IH0KIAogICAgIHZpcnR1YWwgdm9pZCBhZGRT dWJyZXNvdXJjZUF0dHJpYnV0ZVVSTHMoTGlzdEhhc2hTZXQ8S1VSTD4mKSBjb25zdDsKKyAgICAK KyAgICBTdHJpbmcgc3VnZ2VzdGVkRmlsZW5hbWUoKSBjb25zdDsKIAogcHJpdmF0ZToKICAgICBI VE1MSW1hZ2VMb2FkZXIgbV9pbWFnZUxvYWRlcjsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vY2hy b21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZv cm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCShyZXZpc2lvbiA0NjgwNCkKKysrIFdl YkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0zNiw2ICszNiw3IEBACiAjaW5jbHVkZSAiRmlsZUxpc3QuaCIKICNpbmNsdWRlICJG cmFtZS5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1l bnQuaCIKICNpbmNsdWRlICJOYW1lZEF0dHJNYXAuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJlZ2lz dHJ5LmgiCiAjaW5jbHVkZSAibWFya3VwLmgiCkBAIC0yMTYsOTkgKzIxNywzNSBAQCBEcmFnSW1h Z2VSZWYgQ2xpcGJvYXJkQ2hyb21pdW06OmNyZWF0ZURyCiAgICAgfQogICAgIHJldHVybiByZXN1 bHQ7CiB9Ci0KLXN0YXRpYyBTdHJpbmcgaW1hZ2VUb01hcmt1cChjb25zdCBTdHJpbmcmIHVybCwg RWxlbWVudCogZWxlbWVudCkKKyAgICAKK3N0YXRpYyB2b2lkIHNwbGl0RmlsZU5hbWUoY29uc3Qg U3RyaW5nICZmaWxlTmFtZSwgU3RyaW5nICZvdXRCYXNlTmFtZSwgU3RyaW5nICZvdXRFeHRlbnNp b24pCiB7Ci0gICAgU3RyaW5nQnVpbGRlciBtYXJrdXA7Ci0gICAgbWFya3VwLmFwcGVuZCgiPGlt ZyBzcmM9XCIiKTsKLSAgICBtYXJrdXAuYXBwZW5kKHVybCk7Ci0gICAgbWFya3VwLmFwcGVuZCgi XCIiKTsKLSAgICAvLyBDb3B5IG92ZXIgYXR0cmlidXRlcy4gIElmIHdlIGFyZSBkcmFnZ2luZyBh biBpbWFnZSwgd2UgZXhwZWN0IHRoaW5ncyBsaWtlCi0gICAgLy8gdGhlIGlkIHRvIGJlIGNvcGll ZCBhcyB3ZWxsLgotICAgIE5hbWVkTm9kZU1hcCogYXR0cnMgPSBlbGVtZW50LT5hdHRyaWJ1dGVz KCk7Ci0gICAgdW5zaWduZWQgbGVuZ3RoID0gYXR0cnMtPmxlbmd0aCgpOwotICAgIGZvciAodW5z aWduZWQgaSA9IDA7IGkgPCBsZW5ndGg7ICsraSkgewotICAgICAgICBBdHRyaWJ1dGUqIGF0dHIg PSBhdHRycy0+YXR0cmlidXRlSXRlbShpKTsKLSAgICAgICAgaWYgKGF0dHItPmxvY2FsTmFtZSgp ID09ICJzcmMiKQotICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAgIG1hcmt1cC5hcHBlbmQo IiAiKTsKLSAgICAgICAgbWFya3VwLmFwcGVuZChhdHRyLT5sb2NhbE5hbWUoKSk7Ci0gICAgICAg IG1hcmt1cC5hcHBlbmQoIj1cIiIpOwotICAgICAgICBTdHJpbmcgZXNjYXBlZEF0dHIgPSBhdHRy LT52YWx1ZSgpOwotICAgICAgICBlc2NhcGVkQXR0ci5yZXBsYWNlKCJcIiIsICImcXVvdDsiKTsK LSAgICAgICAgbWFya3VwLmFwcGVuZChlc2NhcGVkQXR0cik7Ci0gICAgICAgIG1hcmt1cC5hcHBl bmQoIlwiIik7CisgICAgaW50IGV4dGVuc2lvbl9pbmRleCA9IGZpbGVOYW1lLnJldmVyc2VGaW5k KCcuJyk7CisgICAgaWYgKGV4dGVuc2lvbl9pbmRleCAhPSAtMSkgeworICAgICAgICBvdXRCYXNl TmFtZSA9IGZpbGVOYW1lLmxlZnQoZXh0ZW5zaW9uX2luZGV4KTsKKyAgICAgICAgb3V0RXh0ZW5z aW9uID0gZmlsZU5hbWUuc3Vic3RyaW5nKGV4dGVuc2lvbl9pbmRleCk7CisgICAgfSBlbHNlIHsK KyAgICAgICAgb3V0QmFzZU5hbWUgPSBmaWxlTmFtZTsKKyAgICAgICAgb3V0RXh0ZW5zaW9uID0g IiI7CiAgICAgfQotCi0gICAgbWFya3VwLmFwcGVuZCgiLz4iKTsKLSAgICByZXR1cm4gbWFya3Vw LnRvU3RyaW5nKCk7Ci19Ci0KLXN0YXRpYyBDYWNoZWRJbWFnZSogZ2V0Q2FjaGVkSW1hZ2UoRWxl bWVudCogZWxlbWVudCkKLXsKLSAgICAvLyBBdHRlbXB0IHRvIHB1bGwgQ2FjaGVkSW1hZ2UgZnJv bSBlbGVtZW50Ci0gICAgQVNTRVJUKGVsZW1lbnQpOwotICAgIFJlbmRlck9iamVjdCogcmVuZGVy ZXIgPSBlbGVtZW50LT5yZW5kZXJlcigpOwotICAgIGlmICghcmVuZGVyZXIgfHwgIXJlbmRlcmVy LT5pc0ltYWdlKCkpCi0gICAgICAgIHJldHVybiAwOwotCi0gICAgUmVuZGVySW1hZ2UqIGltYWdl ID0gdG9SZW5kZXJJbWFnZShyZW5kZXJlcik7Ci0gICAgaWYgKGltYWdlLT5jYWNoZWRJbWFnZSgp ICYmICFpbWFnZS0+Y2FjaGVkSW1hZ2UoKS0+ZXJyb3JPY2N1cnJlZCgpKQotICAgICAgICByZXR1 cm4gaW1hZ2UtPmNhY2hlZEltYWdlKCk7Ci0KLSAgICByZXR1cm4gMDsKIH0KIAotc3RhdGljIHZv aWQgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChDaHJvbWl1bURhdGFPYmplY3QqIGRhdGFPYmplY3Qs IEVsZW1lbnQqIGVsZW1lbnQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNv bnN0IEtVUkwmIHVybCkKLXsKLSAgICAvLyBTaG92ZSBpbWFnZSBkYXRhIGludG8gYSBEYXRhT2Jq ZWN0IGZvciB1c2UgYXMgYSBmaWxlCi0gICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlID0gZ2V0 Q2FjaGVkSW1hZ2UoZWxlbWVudCk7Ci0gICAgaWYgKCFjYWNoZWRJbWFnZSB8fCAhY2FjaGVkSW1h Z2UtPmltYWdlKCkgfHwgIWNhY2hlZEltYWdlLT5pc0xvYWRlZCgpKQotICAgICAgICByZXR1cm47 Ci0KLSAgICBTaGFyZWRCdWZmZXIqIGltYWdlQnVmZmVyID0gY2FjaGVkSW1hZ2UtPmltYWdlKCkt PmRhdGEoKTsKLSAgICBpZiAoIWltYWdlQnVmZmVyIHx8ICFpbWFnZUJ1ZmZlci0+c2l6ZSgpKQot ICAgICAgICByZXR1cm47Ci0KLSAgICBkYXRhT2JqZWN0LT5maWxlQ29udGVudCA9IGltYWdlQnVm ZmVyOwotCi0gICAgLy8gRGV0ZXJtaW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZpbGUgY29udGVu dHMgb2YgdGhlIGltYWdlLiAgV2UgdHJ5IHRvCi0gICAgLy8gdXNlIHRoZSBhbHQgdGFnIGlmIG9u ZSBleGlzdHMsIG90aGVyd2lzZSB3ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dlc3RlZAotICAgIC8v IGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciwgYW5kIGZpbmFsbHkgd2UgcmVzb3J0IHRvIHVz aW5nIHRoZSBmaWxlbmFtZQotICAgIC8vIGluIHRoZSBVUkwuCi0gICAgU3RyaW5nIGV4dGVuc2lv biA9IE1JTUVUeXBlUmVnaXN0cnk6OmdldFByZWZlcnJlZEV4dGVuc2lvbkZvck1JTUVUeXBlKAot ICAgICAgICBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5taW1lVHlwZSgpKTsKLSAgICBkYXRhT2Jq ZWN0LT5maWxlRXh0ZW5zaW9uID0gZXh0ZW5zaW9uLmlzRW1wdHkoKSA/ICIiIDogIi4iICsgZXh0 ZW5zaW9uOwotICAgIFN0cmluZyB0aXRsZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRy KTsKLSAgICBpZiAodGl0bGUuaXNFbXB0eSgpKQotICAgICAgICB0aXRsZSA9IGNhY2hlZEltYWdl LT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7Ci0KLSAgICB0aXRsZSA9IENsaXBib2Fy ZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKHRpdGxlLCBkYXRhT2JqZWN0KTsKLSAgICBkYXRh T2JqZWN0LT5maWxlQ29udGVudEZpbGVuYW1lID0gdGl0bGUgKyBkYXRhT2JqZWN0LT5maWxlRXh0 ZW5zaW9uOwotfQotCi12b2lkIENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3JpdGVEcmFn SW1hZ2UoRWxlbWVudCogZWxlbWVudCwgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRp dGxlLCBGcmFtZSogZnJhbWUpCit2b2lkIENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3Jp dGVEcmFnSW1hZ2UoY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNoYXJlZEJ1ZmZlciog aW1hZ2VCdWZmZXIsIGNvbnN0IFN0cmluZyYgZmlsZU5hbWUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBodG1sTWFya3VwKQog ewogICAgIGlmICghbV9kYXRhT2JqZWN0KQogICAgICAgICByZXR1cm47CiAKICAgICBtX2RhdGFP YmplY3QtPnVybCA9IHVybDsKICAgICBtX2RhdGFPYmplY3QtPnVybFRpdGxlID0gdGl0bGU7Ci0K LSAgICAvLyBXcml0ZSB0aGUgYnl0ZXMgaW4gdGhlIGltYWdlIHRvIHRoZSBmaWxlIGZvcm1hdC4K LSAgICB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KG1fZGF0YU9iamVjdC5nZXQoKSwgZWxlbWVudCwg dXJsKTsKLQotICAgIEF0b21pY1N0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0dHJpYnV0 ZShzcmNBdHRyKTsKLSAgICBpZiAoaW1hZ2VVUkwuaXNFbXB0eSgpKQotICAgICAgICByZXR1cm47 Ci0KLSAgICBTdHJpbmcgZnVsbFVSTCA9IGZyYW1lLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTChk ZXByZWNhdGVkUGFyc2VVUkwoaW1hZ2VVUkwpKTsKLSAgICBpZiAoZnVsbFVSTC5pc0VtcHR5KCkp Ci0gICAgICAgIHJldHVybjsKLQotICAgIC8vIFB1dCBpbWcgdGFnIG9uIHRoZSBjbGlwYm9hcmQg cmVmZXJlbmNpbmcgdGhlIGltYWdlCi0gICAgbV9kYXRhT2JqZWN0LT50ZXh0SHRtbCA9IGltYWdl VG9NYXJrdXAoZnVsbFVSTCwgZWxlbWVudCk7CisgICAgbV9kYXRhT2JqZWN0LT5maWxlQ29udGVu dCA9IGltYWdlQnVmZmVyOworICAgIG1fZGF0YU9iamVjdC0+dGV4dEh0bWwgPSBodG1sTWFya3Vw OworICAgIAorICAgIFN0cmluZyBiYXNlTmFtZTsKKyAgICBzcGxpdEZpbGVOYW1lKGZpbGVOYW1l LCBiYXNlTmFtZSxtX2RhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24pOworICAgIGJhc2VOYW1lID0g Q2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoYmFzZU5hbWUsbV9kYXRhT2JqZWN0 LmdldCgpKTsKKyAgICBtX2RhdGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUgPSBiYXNlTmFt ZSArIG1fZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbjsKIH0KIAogdm9pZCBDbGlwYm9hcmRDaHJv bWl1bTo6d3JpdGVVUkwoY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBGcmFt ZSopCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1 bS5oCShyZXZpc2lvbiA0NjgwNCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJv YXJkQ2hyb21pdW0uaAkod29ya2luZyBjb3B5KQpAQCAtMzgsNiArMzgsNyBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKICAgICBjbGFzcyBDYWNoZWRJbWFnZTsKICAgICBjbGFzcyBDaHJvbWl1bURh dGFPYmplY3Q7CisgICAgY2xhc3MgRWxlbWVudDsKICAgICBjbGFzcyBJbnRQb2ludDsKIAogICAg IGNsYXNzIENsaXBib2FyZENocm9taXVtIDogcHVibGljIENsaXBib2FyZCwgcHVibGljIENhY2hl ZFJlc291cmNlQ2xpZW50IHsKQEAgLTcxLDE3ICs3MiwyMiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAgICAgICAgIH0KIAogICAgICAgICB2aXJ0dWFsIERyYWdJbWFnZVJlZiBjcmVhdGVEcmFnSW1h Z2UoSW50UG9pbnQmIGRyYWdMb2MpIGNvbnN0OwotICAgICAgICB2aXJ0dWFsIHZvaWQgZGVjbGFy ZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1lbnQqLCBjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiB0 aXRsZSwgRnJhbWUqKTsKICAgICAgICAgdmlydHVhbCB2b2lkIHdyaXRlVVJMKGNvbnN0IEtVUkwm LCBjb25zdCBTdHJpbmcmLCBGcmFtZSopOwogICAgICAgICB2aXJ0dWFsIHZvaWQgd3JpdGVSYW5n ZShSYW5nZSosIEZyYW1lKik7CiAKICAgICAgICAgdmlydHVhbCBib29sIGhhc0RhdGEoKTsKLQor ICAgICAgICAKKyAgICBwcm90ZWN0ZWQ6CisgICAgICAgIHZpcnR1YWwgdm9pZCBkZWNsYXJlQW5k V3JpdGVEcmFnSW1hZ2UoY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNoYXJlZEJ1ZmZlciog aW1hZ2VCdWZmZXIsIGNvbnN0IFN0cmluZyYgZmlsZU5hbWUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBodG1sTWFya3VwKTsKKyAg ICAgICAgCiAgICAgcHJpdmF0ZToKICAgICAgICAgQ2xpcGJvYXJkQ2hyb21pdW0oYm9vbCwgUGFz c1JlZlB0cjxDaHJvbWl1bURhdGFPYmplY3Q+LCBDbGlwYm9hcmRBY2Nlc3NQb2xpY3kpOwogCiAg ICAgICAgIHZvaWQgcmVzZXRGcm9tQ2xpcGJvYXJkKCk7CiAgICAgICAgIHZvaWQgc2V0RHJhZ0lt YWdlKENhY2hlZEltYWdlKiwgTm9kZSosIGNvbnN0IEludFBvaW50Jik7CisgICAgICAgIHZvaWQg d3JpdGVJbWFnZVRvRGF0YU9iamVjdChFbGVtZW50Kik7CiAgICAgICAgIFJlZlB0cjxDaHJvbWl1 bURhdGFPYmplY3Q+IG1fZGF0YU9iamVjdDsKICAgICB9OwogCkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcAkocmV2aXNpb24g NDY4MDQpCisrKyBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFj LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjgsMTQgKzI4LDQ2IEBACiAjaW5jbHVkZSAiQ2xpcGJv YXJkQ2hyb21pdW0uaCIKIAogI2luY2x1ZGUgIkNocm9taXVtRGF0YU9iamVjdC5oIgotI2luY2x1 ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKKworLy8g T24gSEZTKyB0aGUgbWF4aW11bSBsZW5ndGggb2YgYSBmaWxlbmFtZSBpcyAyNTUgVVRGLTggYnl0 ZXMuIE90aGVyIGZpbGVzeXN0ZW1zCisvLyBoYXZlIGRpZmZlcmVudCBsaW1pdHMsIGJ1dCB0aGlz IGlzIHRoZSBtb3N0IGNvbW1vbiwgc28gdXNlIGl0Lgorc3RhdGljIGNvbnN0IGludCBNYXhGaWxl bmFtZUxlbmd0aEJ5dGVzID0gMjU1OworCisKK3N0YXRpYyBib29sIGlzSW52YWxpZEZpbGVDaGFy YWN0ZXIoVUNoYXIgYykKK3sKKyAgICAvLyBBbGxvdyBhbnl0aGluZyBidXQgY29udHJvbCBjaGFy YWN0ZXJzIGFuZCB0aGUgJy8nLgorICAgIHJldHVybiBjIDwgJyAnIHx8IGMgPT0gJy8nOworfQog CiBTdHJpbmcgQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoY29uc3QgU3RyaW5n JiB0aXRsZSwgQ2hyb21pdW1EYXRhT2JqZWN0KiBkYXRhT2JqZWN0KQogewotICAgIG5vdEltcGxl bWVudGVkKCk7Ci0gICAgcmV0dXJuIHRpdGxlOworICAgIC8vIFJlbW92ZSBhbnkgaW52YWxpZCBm aWxlIHN5c3RlbSBjaGFyYWN0ZXJzLCBlc3BlY2lhbGx5ICIvIi4KKyAgICBTdHJpbmcgcmVzdWx0 ID0gdGl0bGUucmVtb3ZlQ2hhcmFjdGVycygmaXNJbnZhbGlkRmlsZUNoYXJhY3Rlcik7CisgICAg U3RyaW5nIGV4dGVuc2lvbiA9IGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24ucmVtb3ZlQ2hhcmFj dGVycygmaXNJbnZhbGlkRmlsZUNoYXJhY3Rlcik7CisKKyAgICAvLyBMZWFkaW5nICIuInMgd291 bGQgbWFrZSB0aGUgZmlsZSBpbnZpc2libGUgLS0gc3RyaXAgdGhlbS4KKyAgICB3aGlsZSAocmVz dWx0LnN0YXJ0c1dpdGgoIi4iKSkKKyAgICAgICAgcmVzdWx0LnJlbW92ZSgwLDEpOworCisgICAg Ly8gUmVtb3ZlIGEgcmlkaWN1bG91c2x5LWxvbmcgZXh0ZW5zaW9uLgorICAgIGludCBleHRlbnNp b25MZW4gPSBleHRlbnNpb24udXRmOCgpLmxlbmd0aCgpOworICAgIGlmIChleHRlbnNpb25MZW4g Pj0gTWF4RmlsZW5hbWVMZW5ndGhCeXRlcykgeworICAgICAgICBleHRlbnNpb24gPSAiIjsKKyAg ICAgICAgZXh0ZW5zaW9uTGVuID0gMDsKKyAgICB9CisgICAgCisgICAgLy8gVHJ1bmNhdGUgYW4g b3Zlcmx5LWxvbmcgZmlsZW5hbWUuCisgICAgd2hpbGUgKHJlc3VsdC51dGY4KCkubGVuZ3RoKCkg KyBleHRlbnNpb25MZW4gPiBNYXhGaWxlbmFtZUxlbmd0aEJ5dGVzKSB7CisgICAgICAgIC8vIFdl IGtub3cgaG93IG1hbnkgVVRGOCBfYnl0ZXNfIHRvIHJlbW92ZSwgYnV0IG5vdCBob3cgbWFueSBf Y2hhcmFjdGVyc18uCisgICAgICAgIC8vIFRoZSBlYXNpZXN0IHRoaW5nIHRvIGRvIGlzIHJlbW92 ZSBvbmUgY2hhcmFjdGVyIGF0IGEgdGltZS4KKyAgICAgICAgcmVzdWx0LnRydW5jYXRlKHJlc3Vs dC5sZW5ndGgoKSAtIDEpOworICAgIH0KKyAgICBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uID0g ZXh0ZW5zaW9uOworICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIH0gIC8vIG5hbWVzcGFjZSBXZWJD b3JlCg== 34163 2009-08-05 13:02:15 -0700 2009-08-07 11:19:26 -0700 Patch with extra include removed imageFilename2.patch text/plain 16883 jens SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0NjgwNCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMDktMDgtMDQgIEplbnMgQWxma2UgIDxzbmVqQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBCdWcg MjQ4ODcgLSBXcm9uZyBmaWxlbmFtZSB3aGVuIGRyYWdnaW5nIGFuIGltYWdlIHRvIHRoZSBEZXNr dG9wLgorICAgICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI0ODg3CisgICAgICAgIEFkZHMgZnVuY3Rpb25hbGl0eSB0byBIVE1MSW1hZ2VFbGVtZW50IHRv IGRldGVybWluZSB0aGUgZmlsZW5hbWUgdG8gdXNlLgorICAgICAgICBNb2RpZmllcyBDbGlwYm9h cmRDaHJvbWl1bSB0byB1c2UgaXQgd2hlbiBzZXR0aW5nIHVwIHRoZSBkcmFnLgorICAgICAgICBJ bXBsZW1lbnRzIHZhbGlkYXRlRmlsZU5hbWUgZm9yIE1hYyBDaHJvbWl1bSAobGltaXRzIG5hbWUg dG8gMjU1IFVURi04IGJ5dGVzLikKKyAgICAgICAgCisgICAgICAgIE5vIHRlc3RzOyB3b3VsZCBi ZSB1bnJlYXNvbmFibHkgZGlmZmljdWx0IHRvIGFkZCB0aGUgcGx1bWJpbmcgdG8gYWNjZXNzIHRo ZSBwcm9wb3NlZAorCWZpbGVuYW1lIGZyb20gd2l0aGluIERSVC4KKworICAgICAgICAqIGh0bWwv SFRNTEltYWdlRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW1hZ2VFbGVtZW50 OjpzdWdnZXN0ZWRGaWxlbmFtZSk6CisgICAgICAgICogaHRtbC9IVE1MSW1hZ2VFbGVtZW50Lmg6 CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwOgorICAg ICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OndyaXRlSW1hZ2VUb0RhdGFPYmplY3Qp OgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0ZURy YWdJbWFnZSk6CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0u aDoKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHA6 CisgICAgICAgIChXZWJDb3JlOjppc0ludmFsaWRGaWxlQ2hhcmFjdGVyKToKKyAgICAgICAgKFdl YkNvcmU6OkNsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKToKKwogMjAwOS0wOC0w NSAgQW5kcmFzIEJlY3NpICA8YmVjc2kuYW5kcmFzQHN0dWQudS1zemVnZWQuaHU+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgU2ltb24gSGF1c21hbm4uCkluZGV4OiBXZWJDb3JlL2RvbS9DbGlwYm9h cmQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL0NsaXBib2FyZC5jcHAJKHJldmlzaW9u IDQ2ODA0KQorKysgV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MzAsNyArMzAsMTEgQEAKICNpbmNsdWRlICJET01JbXBsZW1lbnRhdGlvbi5oIgogI2luY2x1ZGUg IkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJIVE1MSW1hZ2VF bGVtZW50LmgiCisjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiSW1hZ2UuaCIKKyNp bmNsdWRlICJSZW5kZXJJbWFnZS5oIgorI2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIuaCIKIAogbmFt ZXNwYWNlIFdlYkNvcmUgewogCkBAIC0xMzksNSArMTQzLDg0IEBAIHZvaWQgQ2xpcGJvYXJkOjpz ZXRFZmZlY3RBbGxvd2VkKGNvbnN0IFMKICAgICBpZiAobV9wb2xpY3kgPT0gQ2xpcGJvYXJkV3Jp dGFibGUpCiAgICAgICAgIG1fZWZmZWN0QWxsb3dlZCA9IGVmZmVjdDsKIH0KKyAgICAKK3N0YXRp YyBDYWNoZWRJbWFnZSogZ2V0Q2FjaGVkSW1hZ2UoRWxlbWVudCogZWxlbWVudCkKK3sKKyAgICAv LyBBdHRlbXB0IHRvIHB1bGwgQ2FjaGVkSW1hZ2UgZnJvbSBlbGVtZW50CisgICAgQVNTRVJUKGVs ZW1lbnQpOworICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBlbGVtZW50LT5yZW5kZXJlcigp OworICAgIGlmICghcmVuZGVyZXIgfHwgIXJlbmRlcmVyLT5pc0ltYWdlKCkpCisgICAgICAgIHJl dHVybiAwOworICAgIAorICAgIFJlbmRlckltYWdlKiBpbWFnZSA9IHRvUmVuZGVySW1hZ2UocmVu ZGVyZXIpOworICAgIGlmIChpbWFnZS0+Y2FjaGVkSW1hZ2UoKSAmJiAhaW1hZ2UtPmNhY2hlZElt YWdlKCktPmVycm9yT2NjdXJyZWQoKSkKKyAgICAgICAgcmV0dXJuIGltYWdlLT5jYWNoZWRJbWFn ZSgpOworICAgIAorICAgIHJldHVybiAwOworfQorCitzdGF0aWMgU3RyaW5nIGltYWdlVG9NYXJr dXAoRWxlbWVudCogZWxlbWVudCwgRnJhbWUgKmZyYW1lKQoreworICAgIFN0cmluZyBzcmNVUkw7 CisgICAgQXRvbWljU3RyaW5nIGltYWdlVVJMID0gZWxlbWVudC0+Z2V0QXR0cmlidXRlKEhUTUxO YW1lczo6c3JjQXR0cik7CisgICAgaWYgKCFpbWFnZVVSTC5pc0VtcHR5KCkpCisgICAgICAgIHNy Y1VSTCA9IGZyYW1lLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTChkZXByZWNhdGVkUGFyc2VVUkwo aW1hZ2VVUkwpKTsKKyAgICAKKyAgICBTdHJpbmdCdWlsZGVyIG1hcmt1cDsKKyAgICBtYXJrdXAu YXBwZW5kKCI8aW1nIHNyYz1cIiIpOworICAgIG1hcmt1cC5hcHBlbmQoc3JjVVJMKTsKKyAgICBt YXJrdXAuYXBwZW5kKCJcIiIpOworICAgIC8vIENvcHkgb3ZlciBhdHRyaWJ1dGVzLiAgSWYgd2Ug YXJlIGRyYWdnaW5nIGFuIGltYWdlLCB3ZSBleHBlY3QgdGhpbmdzIGxpa2UKKyAgICAvLyB0aGUg aWQgdG8gYmUgY29waWVkIGFzIHdlbGwuCisgICAgTmFtZWROb2RlTWFwKiBhdHRycyA9IGVsZW1l bnQtPmF0dHJpYnV0ZXMoKTsKKyAgICB1bnNpZ25lZCBsZW5ndGggPSBhdHRycy0+bGVuZ3RoKCk7 CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGxlbmd0aDsgKytpKSB7CisgICAgICAgIEF0 dHJpYnV0ZSogYXR0ciA9IGF0dHJzLT5hdHRyaWJ1dGVJdGVtKGkpOworICAgICAgICBpZiAoYXR0 ci0+bG9jYWxOYW1lKCkgPT0gInNyYyIpCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAg bWFya3VwLmFwcGVuZCgiICIpOworICAgICAgICBtYXJrdXAuYXBwZW5kKGF0dHItPmxvY2FsTmFt ZSgpKTsKKyAgICAgICAgbWFya3VwLmFwcGVuZCgiPVwiIik7CisgICAgICAgIFN0cmluZyBlc2Nh cGVkQXR0ciA9IGF0dHItPnZhbHVlKCk7CisgICAgICAgIGVzY2FwZWRBdHRyLnJlcGxhY2UoIlwi IiwgIiZxdW90OyIpOworICAgICAgICBtYXJrdXAuYXBwZW5kKGVzY2FwZWRBdHRyKTsKKyAgICAg ICAgbWFya3VwLmFwcGVuZCgiXCIiKTsKKyAgICB9CisgICAgCisgICAgbWFya3VwLmFwcGVuZCgi Lz4iKTsKKyAgICByZXR1cm4gbWFya3VwLnRvU3RyaW5nKCk7Cit9CisKK3ZvaWQgQ2xpcGJvYXJk OjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoRWxlbWVudCogZWxlbWVudCwgY29uc3QgS1VSTCYg dXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBGcmFtZSogZnJhbWUpCit7CisgICAgLy8gR2V0IHRo ZSBpbWFnZSBkYXRhIChhYm9ydCBpZiB0aGVyZSBpcyBub25lKS4KKyAgICBTaGFyZWRCdWZmZXIq IGltYWdlQnVmZmVyID0gTlVMTDsKKyAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UgPSBnZXRD YWNoZWRJbWFnZShlbGVtZW50KTsKKyAgICBpZiAoY2FjaGVkSW1hZ2UgJiYgY2FjaGVkSW1hZ2Ut PmltYWdlKCkgJiYgY2FjaGVkSW1hZ2UtPmlzTG9hZGVkKCkpCisgICAgICAgIGltYWdlQnVmZmVy ID0gY2FjaGVkSW1hZ2UtPmltYWdlKCktPmRhdGEoKTsKKyAgICBpZiAoIWltYWdlQnVmZmVyIHx8 ICFpbWFnZUJ1ZmZlci0+c2l6ZSgpKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgLy8gR2V0 IHRoZSBmaWxlbmFtZSB0byB1c2UuCisgICAgU3RyaW5nIGZpbGVOYW1lOworICAgIGlmIChlbGVt ZW50LT5oYXNUYWdOYW1lKEhUTUxOYW1lczo6aW1nVGFnKSkKKyAgICAgICAgZmlsZU5hbWUgPSBz dGF0aWNfY2FzdDxIVE1MSW1hZ2VFbGVtZW50Kj4oZWxlbWVudCktPnN1Z2dlc3RlZEZpbGVuYW1l KCk7CisgICAgCisgICAgLy8gQ3JlYXRlIEhUTUwgPGltZz4gbWFya3VwOgorICAgIFN0cmluZyBo dG1sTWFya3VwID0gaW1hZ2VUb01hcmt1cChlbGVtZW50LGZyYW1lKTsKKyAgICAKKyAgICAvLyBO b3cgY2FsbCB0aGUgYWJzdHJhY3QgZnVsbHktc3BlY2lmaWVkIHZlcnNpb24gb2YgdGhpcyBtZXRo b2QuCisgICAgdGhpcy0+ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKHVybCwgdGl0bGUsIGltYWdl QnVmZmVyLCBmaWxlTmFtZSwgaHRtbE1hcmt1cCk7Cit9CisgICAgCit2b2lkIENsaXBib2FyZDo6 ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTaGFyZWRCdWZmZXIqLCBjb25z dCBTdHJpbmcmLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25z dCBTdHJpbmcmKQoreworICAgIC8vIFRoaXMgbWV0aG9kIGlzIGFic3RyYWN0OyBhIHN1YmNsYXNz IG11c3Qgb3ZlcnJpZGUgaXQsIG9yIHRoZSBwdWJsaWMgdmVyc2lvbiB0aGF0IGNhbGxzIGl0Lgor ICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQorICAgIAorCiAKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKSW5kZXg6IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUvZG9tL0NsaXBib2FyZC5oCShyZXZpc2lvbiA0NjgwNCkKKysrIFdlYkNvcmUvZG9tL0NsaXBi b2FyZC5oCSh3b3JraW5nIGNvcHkpCkBAIC02NCw3ICs2NCw3IEBAIG5hbWVzcGFjZSBXZWJDb3Jl IHsKICAgICAgICAgdmlydHVhbCB2b2lkIHNldERyYWdJbWFnZUVsZW1lbnQoTm9kZSosIGNvbnN0 IEludFBvaW50JikgPSAwOwogICAgICAgICAKICAgICAgICAgdmlydHVhbCBEcmFnSW1hZ2VSZWYg Y3JlYXRlRHJhZ0ltYWdlKEludFBvaW50JiBkcmFnTG9jYXRpb24pIGNvbnN0ID0gMDsKLSAgICAg ICAgdmlydHVhbCB2b2lkIGRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50KiwgY29uc3Qg S1VSTCYsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKikgPSAwOworICAgICAgICB2aXJ0dWFs IHZvaWQgZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1lbnQqLCBjb25zdCBLVVJMJiwgY29u c3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqKTsKICAgICAgICAgdmlydHVhbCB2b2lkIHdyaXRlVVJM KGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmLCBGcmFtZSopID0gMDsKICAgICAgICAgdmlydHVh bCB2b2lkIHdyaXRlUmFuZ2UoUmFuZ2UqLCBGcmFtZSopID0gMDsKIApAQCAtODUsNiArODUsMTAg QEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBDbGlwYm9hcmRBY2Nlc3NQb2xpY3kgcG9s aWN5KCkgY29uc3QgeyByZXR1cm4gbV9wb2xpY3k7IH0KICAgICAgICAgYm9vbCBkcmFnU3RhcnRl ZCgpIGNvbnN0IHsgcmV0dXJuIG1fZHJhZ1N0YXJ0ZWQ7IH0KICAgICAgICAgCisgICAgICAgIHZp cnR1YWwgdm9pZCBkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoY29uc3QgS1VSTCYgdXJsLCBjb25z dCBTdHJpbmcmIHRpdGxlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFNoYXJlZEJ1ZmZlciogaW1hZ2VCdWZmZXIsIGNvbnN0IFN0cmluZyYgZmlsZU5hbWUs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgU3Ry aW5nJiBtYXJrdXApOworICAgICAgICAKICAgICBwcml2YXRlOgogICAgICAgICBDbGlwYm9hcmRB Y2Nlc3NQb2xpY3kgbV9wb2xpY3k7CiAgICAgICAgIFN0cmluZyBtX2Ryb3BFZmZlY3Q7CkluZGV4 OiBXZWJDb3JlL2h0bWwvSFRNTEltYWdlRWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29y ZS9odG1sL0hUTUxJbWFnZUVsZW1lbnQuY3BwCShyZXZpc2lvbiA0NjgwNCkKKysrIFdlYkNvcmUv aHRtbC9IVE1MSW1hZ2VFbGVtZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzEsNiArMzEsNyBA QAogI2luY2x1ZGUgIkhUTUxGb3JtRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgog I2luY2x1ZGUgIk1hcHBlZEF0dHJpYnV0ZS5oIgorI2luY2x1ZGUgIk1JTUVUeXBlUmVnaXN0cnku aCIKICNpbmNsdWRlICJSZW5kZXJJbWFnZS5oIgogI2luY2x1ZGUgIlNjcmlwdEV2ZW50TGlzdGVu ZXIuaCIKIApAQCAtNDQxLDUgKzQ0Miw0NCBAQCB2b2lkIEhUTUxJbWFnZUVsZW1lbnQ6OmFkZFN1 YnJlc291cmNlQXR0CiAgICAgYWRkU3VicmVzb3VyY2VVUkwodXJscywgc3JjKCkpOwogICAgIGFk ZFN1YnJlc291cmNlVVJMKHVybHMsIGRvY3VtZW50KCktPmNvbXBsZXRlVVJMKHVzZU1hcCgpKSk7 CiB9CisgICAgCitTdHJpbmcgSFRNTEltYWdlRWxlbWVudDo6c3VnZ2VzdGVkRmlsZW5hbWUoKSBj b25zdAoreworICAgIFN0cmluZyBmaWxlTmFtZTsKKyAgICAKKyAgICAvLyBXZSB0cnkgdG8gdXNl IHRoZSBzdWdnZXN0ZWQgZmlsZW5hbWUgaW4gdGhlIGh0dHAgaGVhZGVyIGZpcnN0LgorICAgIENh Y2hlZEltYWdlKiBjYWNoZWRJbWFnZSA9IHRoaXMtPmNhY2hlZEltYWdlKCk7CisgICAgaWYgKGNh Y2hlZEltYWdlICYmIGNhY2hlZEltYWdlLT5pbWFnZSgpICYmIGNhY2hlZEltYWdlLT5pc0xvYWRl ZCgpKQorICAgICAgICBmaWxlTmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3Rl ZEZpbGVuYW1lKCk7CisgICAgCisgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkgeworICAgICAg ICAvLyBUaGVuLCBpZiB0aGVyZSdzIG5vbmUsIHdlIHRyeSB0byBleHRyYWN0IHRoZSBmaWxlbmFt ZSBmcm9tCisgICAgICAgIC8vIHRoZSBpbWFnZSBVUkwgc3RvcmVkIGluIHRoZSBzcmMgYXR0cmli dXRlLgorICAgICAgICBLVVJMIHNyYyA9IHRoaXMtPnNyYygpOworICAgICAgICBpZiAoc3JjLmlz VmFsaWQoKSkKKyAgICAgICAgICAgIGZpbGVOYW1lID0gc3JjLmxhc3RQYXRoQ29tcG9uZW50KCk7 CisgICAgICAgIC8vIElmIHRoZXJlJ3Mgbm9uZSwgd2UgdGhlbiB0cnkgdGhlIGFsdCB0YWcgaWYg b25lIGV4aXN0cy4KKyAgICAgICAgaWYgKGZpbGVOYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgICAg IGZpbGVOYW1lID0gdGhpcy0+YWx0VGV4dCgpOworICAgIH0KKyAgICAKKyAgICAvLyBSZW1vdmUg bGVhZGluZyBvciB0cmFpbGluZyAnLidzLgorICAgIHdoaWxlIChmaWxlTmFtZS5zdGFydHNXaXRo KCIuIikpCisgICAgICAgIGZpbGVOYW1lLnJlbW92ZSgwLDEpOworICAgIHdoaWxlIChmaWxlTmFt ZS5lbmRzV2l0aCgiLiIpKQorICAgICAgICBmaWxlTmFtZS5yZW1vdmUoZmlsZU5hbWUubGVuZ3Ro KCktMSwgMSk7CisgICAgCisgICAgLy8gV2UgY2FuJ3QgcmVseSBvbiB0aGUgZmlsZW5hbWUgZXh0 ZW5zaW9uLCBzbyB3ZSBtdXN0IHJlbW92ZSBpdAorICAgIC8vIGFuZCB1c2UgdGhlIG9uZSByZWdp c3RlcmVkIHdpdGggdGhlIE1JTUUgdHlwZS4KKyAgICBpbnQgZXh0ZW5zaW9uX2luZGV4ID0gZmls ZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICBpZiAoZXh0ZW5zaW9uX2luZGV4ICE9IC0xKQor ICAgICAgICBmaWxlTmFtZS50cnVuY2F0ZShleHRlbnNpb25faW5kZXgpOworICAgIGlmICghZmls ZU5hbWUuaXNFbXB0eSgpKSB7CisgICAgICAgIFN0cmluZyBleHRlbnNpb24gPSBNSU1FVHlwZVJl Z2lzdHJ5OjpnZXRQcmVmZXJyZWRFeHRlbnNpb25Gb3JNSU1FVHlwZShjYWNoZWRJbWFnZS0+cmVz cG9uc2UoKS5taW1lVHlwZSgpKTsKKyAgICAgICAgZmlsZU5hbWUgKz0gIi4iOworICAgICAgICBm aWxlTmFtZSArPSBleHRlbnNpb247CisgICAgfQorICAgIHJldHVybiBmaWxlTmFtZTsKK30KIAog fQpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxJbWFnZUVsZW1lbnQuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL2h0bWwvSFRNTEltYWdlRWxlbWVudC5oCShyZXZpc2lvbiA0NjgwNCkKKysrIFdlYkNv cmUvaHRtbC9IVE1MSW1hZ2VFbGVtZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTExNiw2ICsxMTYs OCBAQCBwdWJsaWM6CiAgICAgYm9vbCBoYXZlRmlyZWRMb2FkRXZlbnQoKSBjb25zdCB7IHJldHVy biBtX2ltYWdlTG9hZGVyLmhhdmVGaXJlZExvYWRFdmVudCgpOyB9CiAKICAgICB2aXJ0dWFsIHZv aWQgYWRkU3VicmVzb3VyY2VBdHRyaWJ1dGVVUkxzKExpc3RIYXNoU2V0PEtVUkw+JikgY29uc3Q7 CisgICAgCisgICAgU3RyaW5nIHN1Z2dlc3RlZEZpbGVuYW1lKCkgY29uc3Q7CiAKIHByaXZhdGU6 CiAgICAgSFRNTEltYWdlTG9hZGVyIG1faW1hZ2VMb2FkZXI7CkluZGV4OiBXZWJDb3JlL3BsYXRm b3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcAkocmV2aXNpb24gNDY4MDQp CisrKyBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcAkod29y a2luZyBjb3B5KQpAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIkZpbGVMaXN0LmgiCiAjaW5j bHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJIVE1MSW1h Z2VFbGVtZW50LmgiCiAjaW5jbHVkZSAiTmFtZWRBdHRyTWFwLmgiCiAjaW5jbHVkZSAiTUlNRVR5 cGVSZWdpc3RyeS5oIgogI2luY2x1ZGUgIm1hcmt1cC5oIgpAQCAtMjE2LDk5ICsyMTcsMzUgQEAg RHJhZ0ltYWdlUmVmIENsaXBib2FyZENocm9taXVtOjpjcmVhdGVEcgogICAgIH0KICAgICByZXR1 cm4gcmVzdWx0OwogfQotCi1zdGF0aWMgU3RyaW5nIGltYWdlVG9NYXJrdXAoY29uc3QgU3RyaW5n JiB1cmwsIEVsZW1lbnQqIGVsZW1lbnQpCisgICAgCitzdGF0aWMgdm9pZCBzcGxpdEZpbGVOYW1l KGNvbnN0IFN0cmluZyAmZmlsZU5hbWUsIFN0cmluZyAmb3V0QmFzZU5hbWUsIFN0cmluZyAmb3V0 RXh0ZW5zaW9uKQogewotICAgIFN0cmluZ0J1aWxkZXIgbWFya3VwOwotICAgIG1hcmt1cC5hcHBl bmQoIjxpbWcgc3JjPVwiIik7Ci0gICAgbWFya3VwLmFwcGVuZCh1cmwpOwotICAgIG1hcmt1cC5h cHBlbmQoIlwiIik7Ci0gICAgLy8gQ29weSBvdmVyIGF0dHJpYnV0ZXMuICBJZiB3ZSBhcmUgZHJh Z2dpbmcgYW4gaW1hZ2UsIHdlIGV4cGVjdCB0aGluZ3MgbGlrZQotICAgIC8vIHRoZSBpZCB0byBi ZSBjb3BpZWQgYXMgd2VsbC4KLSAgICBOYW1lZE5vZGVNYXAqIGF0dHJzID0gZWxlbWVudC0+YXR0 cmlidXRlcygpOwotICAgIHVuc2lnbmVkIGxlbmd0aCA9IGF0dHJzLT5sZW5ndGgoKTsKLSAgICBm b3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbGVuZ3RoOyArK2kpIHsKLSAgICAgICAgQXR0cmlidXRl KiBhdHRyID0gYXR0cnMtPmF0dHJpYnV0ZUl0ZW0oaSk7Ci0gICAgICAgIGlmIChhdHRyLT5sb2Nh bE5hbWUoKSA9PSAic3JjIikKLSAgICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICBtYXJrdXAu YXBwZW5kKCIgIik7Ci0gICAgICAgIG1hcmt1cC5hcHBlbmQoYXR0ci0+bG9jYWxOYW1lKCkpOwot ICAgICAgICBtYXJrdXAuYXBwZW5kKCI9XCIiKTsKLSAgICAgICAgU3RyaW5nIGVzY2FwZWRBdHRy ID0gYXR0ci0+dmFsdWUoKTsKLSAgICAgICAgZXNjYXBlZEF0dHIucmVwbGFjZSgiXCIiLCAiJnF1 b3Q7Iik7Ci0gICAgICAgIG1hcmt1cC5hcHBlbmQoZXNjYXBlZEF0dHIpOwotICAgICAgICBtYXJr dXAuYXBwZW5kKCJcIiIpOworICAgIGludCBleHRlbnNpb25faW5kZXggPSBmaWxlTmFtZS5yZXZl cnNlRmluZCgnLicpOworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpIHsKKyAgICAgICAg b3V0QmFzZU5hbWUgPSBmaWxlTmFtZS5sZWZ0KGV4dGVuc2lvbl9pbmRleCk7CisgICAgICAgIG91 dEV4dGVuc2lvbiA9IGZpbGVOYW1lLnN1YnN0cmluZyhleHRlbnNpb25faW5kZXgpOworICAgIH0g ZWxzZSB7CisgICAgICAgIG91dEJhc2VOYW1lID0gZmlsZU5hbWU7CisgICAgICAgIG91dEV4dGVu c2lvbiA9ICIiOwogICAgIH0KLQotICAgIG1hcmt1cC5hcHBlbmQoIi8+Iik7Ci0gICAgcmV0dXJu IG1hcmt1cC50b1N0cmluZygpOwotfQotCi1zdGF0aWMgQ2FjaGVkSW1hZ2UqIGdldENhY2hlZElt YWdlKEVsZW1lbnQqIGVsZW1lbnQpCi17Ci0gICAgLy8gQXR0ZW1wdCB0byBwdWxsIENhY2hlZElt YWdlIGZyb20gZWxlbWVudAotICAgIEFTU0VSVChlbGVtZW50KTsKLSAgICBSZW5kZXJPYmplY3Qq IHJlbmRlcmVyID0gZWxlbWVudC0+cmVuZGVyZXIoKTsKLSAgICBpZiAoIXJlbmRlcmVyIHx8ICFy ZW5kZXJlci0+aXNJbWFnZSgpKQotICAgICAgICByZXR1cm4gMDsKLQotICAgIFJlbmRlckltYWdl KiBpbWFnZSA9IHRvUmVuZGVySW1hZ2UocmVuZGVyZXIpOwotICAgIGlmIChpbWFnZS0+Y2FjaGVk SW1hZ2UoKSAmJiAhaW1hZ2UtPmNhY2hlZEltYWdlKCktPmVycm9yT2NjdXJyZWQoKSkKLSAgICAg ICAgcmV0dXJuIGltYWdlLT5jYWNoZWRJbWFnZSgpOwotCi0gICAgcmV0dXJuIDA7CiB9CiAKLXN0 YXRpYyB2b2lkIHdyaXRlSW1hZ2VUb0RhdGFPYmplY3QoQ2hyb21pdW1EYXRhT2JqZWN0KiBkYXRh T2JqZWN0LCBFbGVtZW50KiBlbGVtZW50LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBjb25zdCBLVVJMJiB1cmwpCi17Ci0gICAgLy8gU2hvdmUgaW1hZ2UgZGF0YSBpbnRvIGEg RGF0YU9iamVjdCBmb3IgdXNlIGFzIGEgZmlsZQotICAgIENhY2hlZEltYWdlKiBjYWNoZWRJbWFn ZSA9IGdldENhY2hlZEltYWdlKGVsZW1lbnQpOwotICAgIGlmICghY2FjaGVkSW1hZ2UgfHwgIWNh Y2hlZEltYWdlLT5pbWFnZSgpIHx8ICFjYWNoZWRJbWFnZS0+aXNMb2FkZWQoKSkKLSAgICAgICAg cmV0dXJuOwotCi0gICAgU2hhcmVkQnVmZmVyKiBpbWFnZUJ1ZmZlciA9IGNhY2hlZEltYWdlLT5p bWFnZSgpLT5kYXRhKCk7Ci0gICAgaWYgKCFpbWFnZUJ1ZmZlciB8fCAhaW1hZ2VCdWZmZXItPnNp emUoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnQgPSBp bWFnZUJ1ZmZlcjsKLQotICAgIC8vIERldGVybWluZSB0aGUgZmlsZW5hbWUgZm9yIHRoZSBmaWxl IGNvbnRlbnRzIG9mIHRoZSBpbWFnZS4gIFdlIHRyeSB0bwotICAgIC8vIHVzZSB0aGUgYWx0IHRh ZyBpZiBvbmUgZXhpc3RzLCBvdGhlcndpc2Ugd2UgZmFsbCBiYWNrIG9uIHRoZSBzdWdnZXN0ZWQK LSAgICAvLyBmaWxlbmFtZSBpbiB0aGUgaHR0cCBoZWFkZXIsIGFuZCBmaW5hbGx5IHdlIHJlc29y dCB0byB1c2luZyB0aGUgZmlsZW5hbWUKLSAgICAvLyBpbiB0aGUgVVJMLgotICAgIFN0cmluZyBl eHRlbnNpb24gPSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRFeHRlbnNpb25Gb3JNSU1F VHlwZSgKLSAgICAgICAgY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWltZVR5cGUoKSk7Ci0gICAg ZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbiA9IGV4dGVuc2lvbi5pc0VtcHR5KCkgPyAiIiA6ICIu IiArIGV4dGVuc2lvbjsKLSAgICBTdHJpbmcgdGl0bGUgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUo YWx0QXR0cik7Ci0gICAgaWYgKHRpdGxlLmlzRW1wdHkoKSkKLSAgICAgICAgdGl0bGUgPSBjYWNo ZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOwotCi0gICAgdGl0bGUgPSBD bGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFtZSh0aXRsZSwgZGF0YU9iamVjdCk7Ci0g ICAgZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnRGaWxlbmFtZSA9IHRpdGxlICsgZGF0YU9iamVjdC0+ ZmlsZUV4dGVuc2lvbjsKLX0KLQotdm9pZCBDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdy aXRlRHJhZ0ltYWdlKEVsZW1lbnQqIGVsZW1lbnQsIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3Ry aW5nJiB0aXRsZSwgRnJhbWUqIGZyYW1lKQordm9pZCBDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFy ZUFuZFdyaXRlRHJhZ0ltYWdlKGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiB0aXRsZSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTaGFyZWRC dWZmZXIqIGltYWdlQnVmZmVyLCBjb25zdCBTdHJpbmcmIGZpbGVOYW1lLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgaHRtbE1h cmt1cCkKIHsKICAgICBpZiAoIW1fZGF0YU9iamVjdCkKICAgICAgICAgcmV0dXJuOwogCiAgICAg bV9kYXRhT2JqZWN0LT51cmwgPSB1cmw7CiAgICAgbV9kYXRhT2JqZWN0LT51cmxUaXRsZSA9IHRp dGxlOwotCi0gICAgLy8gV3JpdGUgdGhlIGJ5dGVzIGluIHRoZSBpbWFnZSB0byB0aGUgZmlsZSBm b3JtYXQuCi0gICAgd3JpdGVJbWFnZVRvRGF0YU9iamVjdChtX2RhdGFPYmplY3QuZ2V0KCksIGVs ZW1lbnQsIHVybCk7Ci0KLSAgICBBdG9taWNTdHJpbmcgaW1hZ2VVUkwgPSBlbGVtZW50LT5nZXRB dHRyaWJ1dGUoc3JjQXR0cik7Ci0gICAgaWYgKGltYWdlVVJMLmlzRW1wdHkoKSkKLSAgICAgICAg cmV0dXJuOwotCi0gICAgU3RyaW5nIGZ1bGxVUkwgPSBmcmFtZS0+ZG9jdW1lbnQoKS0+Y29tcGxl dGVVUkwoZGVwcmVjYXRlZFBhcnNlVVJMKGltYWdlVVJMKSk7Ci0gICAgaWYgKGZ1bGxVUkwuaXNF bXB0eSgpKQotICAgICAgICByZXR1cm47Ci0KLSAgICAvLyBQdXQgaW1nIHRhZyBvbiB0aGUgY2xp cGJvYXJkIHJlZmVyZW5jaW5nIHRoZSBpbWFnZQotICAgIG1fZGF0YU9iamVjdC0+dGV4dEh0bWwg PSBpbWFnZVRvTWFya3VwKGZ1bGxVUkwsIGVsZW1lbnQpOworICAgIG1fZGF0YU9iamVjdC0+Zmls ZUNvbnRlbnQgPSBpbWFnZUJ1ZmZlcjsKKyAgICBtX2RhdGFPYmplY3QtPnRleHRIdG1sID0gaHRt bE1hcmt1cDsKKyAgICAKKyAgICBTdHJpbmcgYmFzZU5hbWU7CisgICAgc3BsaXRGaWxlTmFtZShm aWxlTmFtZSwgYmFzZU5hbWUsbV9kYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uKTsKKyAgICBiYXNl TmFtZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKGJhc2VOYW1lLG1fZGF0 YU9iamVjdC5nZXQoKSk7CisgICAgbV9kYXRhT2JqZWN0LT5maWxlQ29udGVudEZpbGVuYW1lID0g YmFzZU5hbWUgKyBtX2RhdGFPYmplY3QtPmZpbGVFeHRlbnNpb247CiB9CiAKIHZvaWQgQ2xpcGJv YXJkQ2hyb21pdW06OndyaXRlVVJMKGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiB0aXRs ZSwgRnJhbWUqKQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJv bWl1bS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJk Q2hyb21pdW0uaAkocmV2aXNpb24gNDY4MDQpCisrKyBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVt L0NsaXBib2FyZENocm9taXVtLmgJKHdvcmtpbmcgY29weSkKQEAgLTM4LDYgKzM4LDcgQEAgbmFt ZXNwYWNlIFdlYkNvcmUgewogCiAgICAgY2xhc3MgQ2FjaGVkSW1hZ2U7CiAgICAgY2xhc3MgQ2hy b21pdW1EYXRhT2JqZWN0OworICAgIGNsYXNzIEVsZW1lbnQ7CiAgICAgY2xhc3MgSW50UG9pbnQ7 CiAKICAgICBjbGFzcyBDbGlwYm9hcmRDaHJvbWl1bSA6IHB1YmxpYyBDbGlwYm9hcmQsIHB1Ymxp YyBDYWNoZWRSZXNvdXJjZUNsaWVudCB7CkBAIC03MSwxNyArNzIsMjIgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogICAgICAgICB9CiAKICAgICAgICAgdmlydHVhbCBEcmFnSW1hZ2VSZWYgY3JlYXRl RHJhZ0ltYWdlKEludFBvaW50JiBkcmFnTG9jKSBjb25zdDsKLSAgICAgICAgdmlydHVhbCB2b2lk IGRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50KiwgY29uc3QgS1VSTCYsIGNvbnN0IFN0 cmluZyYgdGl0bGUsIEZyYW1lKik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCB3cml0ZVVSTChjb25z dCBLVVJMJiwgY29uc3QgU3RyaW5nJiwgRnJhbWUqKTsKICAgICAgICAgdmlydHVhbCB2b2lkIHdy aXRlUmFuZ2UoUmFuZ2UqLCBGcmFtZSopOwogCiAgICAgICAgIHZpcnR1YWwgYm9vbCBoYXNEYXRh KCk7Ci0KKyAgICAgICAgCisgICAgcHJvdGVjdGVkOgorICAgICAgICB2aXJ0dWFsIHZvaWQgZGVj bGFyZUFuZFdyaXRlRHJhZ0ltYWdlKGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiB0aXRs ZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTaGFyZWRC dWZmZXIqIGltYWdlQnVmZmVyLCBjb25zdCBTdHJpbmcmIGZpbGVOYW1lLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgaHRtbE1hcmt1 cCk7CisgICAgICAgIAogICAgIHByaXZhdGU6CiAgICAgICAgIENsaXBib2FyZENocm9taXVtKGJv b2wsIFBhc3NSZWZQdHI8Q2hyb21pdW1EYXRhT2JqZWN0PiwgQ2xpcGJvYXJkQWNjZXNzUG9saWN5 KTsKIAogICAgICAgICB2b2lkIHJlc2V0RnJvbUNsaXBib2FyZCgpOwogICAgICAgICB2b2lkIHNl dERyYWdJbWFnZShDYWNoZWRJbWFnZSosIE5vZGUqLCBjb25zdCBJbnRQb2ludCYpOworICAgICAg ICB2b2lkIHdyaXRlSW1hZ2VUb0RhdGFPYmplY3QoRWxlbWVudCopOwogICAgICAgICBSZWZQdHI8 Q2hyb21pdW1EYXRhT2JqZWN0PiBtX2RhdGFPYmplY3Q7CiAgICAgfTsKIApJbmRleDogV2ViQ29y ZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAJKHJl dmlzaW9uIDQ2ODA0KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJv bWl1bU1hYy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI4LDE0ICsyOCw0NiBAQAogI2luY2x1ZGUg IkNsaXBib2FyZENocm9taXVtLmgiCiAKICNpbmNsdWRlICJDaHJvbWl1bURhdGFPYmplY3QuaCIK LSNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CisgICAg CisKKy8vIE9uIEhGUysgdGhlIG1heGltdW0gbGVuZ3RoIG9mIGEgZmlsZW5hbWUgaXMgMjU1IFVU Ri04IGJ5dGVzLiBPdGhlciBmaWxlc3lzdGVtcworLy8gaGF2ZSBkaWZmZXJlbnQgbGltaXRzLCBi dXQgdGhpcyBpcyB0aGUgbW9zdCBjb21tb24sIHNvIHVzZSBpdC4KK3N0YXRpYyBjb25zdCBpbnQg TWF4RmlsZW5hbWVMZW5ndGhCeXRlcyA9IDI1NTsKKworCitzdGF0aWMgYm9vbCBpc0ludmFsaWRG aWxlQ2hhcmFjdGVyKFVDaGFyIGMpCit7CisgICAgLy8gQWxsb3cgYW55dGhpbmcgYnV0IGNvbnRy b2wgY2hhcmFjdGVycyBhbmQgdGhlICcvJy4KKyAgICByZXR1cm4gYyA8ICcgJyB8fCBjID09ICcv JzsKK30KIAogU3RyaW5nIENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKGNvbnN0 IFN0cmluZyYgdGl0bGUsIENocm9taXVtRGF0YU9iamVjdCogZGF0YU9iamVjdCkKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiB0aXRsZTsKKyAgICAvLyBSZW1vdmUgYW55IGlu dmFsaWQgZmlsZSBzeXN0ZW0gY2hhcmFjdGVycywgZXNwZWNpYWxseSAiLyIuCisgICAgU3RyaW5n IHJlc3VsdCA9IHRpdGxlLnJlbW92ZUNoYXJhY3RlcnMoJmlzSW52YWxpZEZpbGVDaGFyYWN0ZXIp OworICAgIFN0cmluZyBleHRlbnNpb24gPSBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uLnJlbW92 ZUNoYXJhY3RlcnMoJmlzSW52YWxpZEZpbGVDaGFyYWN0ZXIpOworCisgICAgLy8gTGVhZGluZyAi LiJzIHdvdWxkIG1ha2UgdGhlIGZpbGUgaW52aXNpYmxlIC0tIHN0cmlwIHRoZW0uCisgICAgd2hp bGUgKHJlc3VsdC5zdGFydHNXaXRoKCIuIikpCisgICAgICAgIHJlc3VsdC5yZW1vdmUoMCwxKTsK KworICAgIC8vIFJlbW92ZSBhIHJpZGljdWxvdXNseS1sb25nIGV4dGVuc2lvbi4KKyAgICBpbnQg ZXh0ZW5zaW9uTGVuID0gZXh0ZW5zaW9uLnV0ZjgoKS5sZW5ndGgoKTsKKyAgICBpZiAoZXh0ZW5z aW9uTGVuID49IE1heEZpbGVuYW1lTGVuZ3RoQnl0ZXMpIHsKKyAgICAgICAgZXh0ZW5zaW9uID0g IiI7CisgICAgICAgIGV4dGVuc2lvbkxlbiA9IDA7CisgICAgfQorICAgIAorICAgIC8vIFRydW5j YXRlIGFuIG92ZXJseS1sb25nIGZpbGVuYW1lLgorICAgIHdoaWxlIChyZXN1bHQudXRmOCgpLmxl bmd0aCgpICsgZXh0ZW5zaW9uTGVuID4gTWF4RmlsZW5hbWVMZW5ndGhCeXRlcykgeworICAgICAg ICAvLyBXZSBrbm93IGhvdyBtYW55IFVURjggX2J5dGVzXyB0byByZW1vdmUsIGJ1dCBub3QgaG93 IG1hbnkgX2NoYXJhY3RlcnNfLgorICAgICAgICAvLyBUaGUgZWFzaWVzdCB0aGluZyB0byBkbyBp cyByZW1vdmUgb25lIGNoYXJhY3RlciBhdCBhIHRpbWUuCisgICAgICAgIHJlc3VsdC50cnVuY2F0 ZShyZXN1bHQubGVuZ3RoKCkgLSAxKTsKKyAgICB9CisgICAgZGF0YU9iamVjdC0+ZmlsZUV4dGVu c2lvbiA9IGV4dGVuc2lvbjsKKyAgICByZXR1cm4gcmVzdWx0OwogfQogCiB9ICAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQo= 34290 2009-08-07 10:33:15 -0700 2009-08-07 11:38:50 -0700 patch, responding to Darin's review imageFilename3.patch text/plain 16749 jens SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0Njg5NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMDktMDgtMDcgIEplbnMgQWxma2UgIDxzbmVqQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBCdWcg MjQ4ODcgLSBXcm9uZyBmaWxlbmFtZSB3aGVuIGRyYWdnaW5nIGFuIGltYWdlIHRvIHRoZSBEZXNr dG9wLgorICAgICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI0ODg3CisgICAgICAgIEFkZHMgZnVuY3Rpb25hbGl0eSB0byBIVE1MSW1hZ2VFbGVtZW50IHRv IGRldGVybWluZSB0aGUgZmlsZW5hbWUgdG8gdXNlLgorICAgICAgICBNb2RpZmllcyBDbGlwYm9h cmRDaHJvbWl1bSB0byB1c2UgaXQgd2hlbiBzZXR0aW5nIHVwIHRoZSBkcmFnLgorICAgICAgICBJ bXBsZW1lbnRzIHZhbGlkYXRlRmlsZU5hbWUgZm9yIE1hYyBDaHJvbWl1bSAobGltaXRzIG5hbWUg dG8gMjU1IFVURi04IGJ5dGVzLikKKworICAgICAgICBObyB0ZXN0czsgd291bGQgYmUgdW5yZWFz b25hYmx5IGRpZmZpY3VsdCB0byBhZGQgdGhlIHBsdW1iaW5nIHRvIGFjY2VzcyB0aGUgcHJvcG9z ZWQKKyAgICAgICAgZmlsZW5hbWUgZnJvbSB3aXRoaW4gRFJULgorCisgICAgICAgICogaHRtbC9I VE1MSW1hZ2VFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbWFnZUVsZW1lbnQ6 OnN1Z2dlc3RlZEZpbGVuYW1lKToKKyAgICAgICAgKiBodG1sL0hUTUxJbWFnZUVsZW1lbnQuaDoK KyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpDbGlwYm9hcmRDaHJvbWl1bTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6 CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJh Z0ltYWdlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5o OgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OmlzSW52YWxpZEZpbGVDaGFyYWN0ZXIpOgorICAgICAgICAoV2Vi Q29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUpOgorCiAyMDA5LTA4LTA1 ICBEaW1pdHJpIEdsYXprb3YgIDxkZ2xhemtvdkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5y ZXZpZXdlZCwgYnVpbGQgZml4LgpJbmRleDogV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9DbGlwYm9hcmQuY3BwCShyZXZpc2lvbiA0Njg5NCkKKysr IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMwLDkgKzMwLDE1 IEBACiAjaW5jbHVkZSAiRE9NSW1wbGVtZW50YXRpb24uaCIKICNpbmNsdWRlICJGcmFtZS5oIgog I2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgor I2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiUmVu ZGVySW1hZ2UuaCIKKyNpbmNsdWRlICJTdHJpbmdCdWlsZGVyLmgiCiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKKyAgICAKK3VzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CiAKIENsaXBib2FyZDo6Q2xp cGJvYXJkKENsaXBib2FyZEFjY2Vzc1BvbGljeSBwb2xpY3ksIGJvb2wgaXNGb3JEcmFnZ2luZykg CiAgICAgOiBtX3BvbGljeShwb2xpY3kpIApAQCAtMTM5LDUgKzE0NSw4NyBAQCB2b2lkIENsaXBi b2FyZDo6c2V0RWZmZWN0QWxsb3dlZChjb25zdCBTCiAgICAgaWYgKG1fcG9saWN5ID09IENsaXBi b2FyZFdyaXRhYmxlKQogICAgICAgICBtX2VmZmVjdEFsbG93ZWQgPSBlZmZlY3Q7CiB9CisgICAg CitzdGF0aWMgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlT2ZOb2RlKE5vZGUqIG5vZGUpCit7Cisg ICAgQVNTRVJUKG5vZGUpOworICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBub2RlLT5yZW5k ZXJlcigpOworICAgIGlmICghcmVuZGVyZXIgfHwgIXJlbmRlcmVyLT5pc0ltYWdlKCkpCisgICAg ICAgIHJldHVybiAwOworICAgIAorICAgIFJlbmRlckltYWdlKiBpbWFnZSA9IHRvUmVuZGVySW1h Z2UocmVuZGVyZXIpOworICAgIGlmICghaW1hZ2UtPmNhY2hlZEltYWdlKCkgfHwgaW1hZ2UtPmNh Y2hlZEltYWdlKCktPmVycm9yT2NjdXJyZWQoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgCisg ICAgcmV0dXJuIGltYWdlLT5jYWNoZWRJbWFnZSgpOworfQorICAgIAorc3RhdGljIHZvaWQgYXBw ZW5kQXR0cmlidXRlKFN0cmluZ0J1aWxkZXImIG1hcmt1cCwgY29uc3QgU3RyaW5nJiBuYW1lLCBT dHJpbmcgdmFsdWUpCit7CisgICAgdmFsdWUucmVwbGFjZSgiJiIsICImYW1wOyIpOworICAgIHZh bHVlLnJlcGxhY2UoIlwiIiwgIiZxdW90OyIpOworICAgIG1hcmt1cC5hcHBlbmQoIiAiKTsKKyAg ICBtYXJrdXAuYXBwZW5kKG5hbWUpOworICAgIG1hcmt1cC5hcHBlbmQoIj1cIiIpOworICAgIG1h cmt1cC5hcHBlbmQodmFsdWUpOworICAgIG1hcmt1cC5hcHBlbmQoIlwiIik7Cit9CisKK3N0YXRp YyBTdHJpbmcgaW1hZ2VUb01hcmt1cChFbGVtZW50KiBlbGVtZW50LCBGcmFtZSogZnJhbWUpCit7 CisgICAgU3RyaW5nIHNyY1VSTDsKKyAgICBjb25zdCBBdG9taWNTdHJpbmcmIGltYWdlVVJMID0g ZWxlbWVudC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOworICAgIGlmICghaW1hZ2VVUkwuaXNFbXB0 eSgpKQorICAgICAgICBzcmNVUkwgPSBmcmFtZS0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoZGVw cmVjYXRlZFBhcnNlVVJMKGltYWdlVVJMKSk7CisgICAgCisgICAgU3RyaW5nQnVpbGRlciBtYXJr dXA7CisgICAgbWFya3VwLmFwcGVuZCgiPGltZyIpOworICAgIGFwcGVuZEF0dHJpYnV0ZShtYXJr dXAsIHNyY0F0dHIubG9jYWxOYW1lKCksIHNyY1VSTCk7CisKKyAgICAvLyBDb3B5IG92ZXIgYXR0 cmlidXRlcy4gIElmIHdlIGFyZSBkcmFnZ2luZyBhbiBpbWFnZSwgd2UgZXhwZWN0IHRoaW5ncyBs aWtlCisgICAgLy8gdGhlIGlkIHRvIGJlIGNvcGllZCBhcyB3ZWxsLgorICAgIE5hbWVkTm9kZU1h cCogYXR0cnMgPSBlbGVtZW50LT5hdHRyaWJ1dGVzKCk7CisgICAgdW5zaWduZWQgbGVuZ3RoID0g YXR0cnMtPmxlbmd0aCgpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsZW5ndGg7ICsr aSkgeworICAgICAgICBBdHRyaWJ1dGUqIGF0dHIgPSBhdHRycy0+YXR0cmlidXRlSXRlbShpKTsK KyAgICAgICAgaWYgKGF0dHItPm5hbWUoKSAhPSBzcmNBdHRyKQorICAgICAgICAgICAgYXBwZW5k QXR0cmlidXRlKG1hcmt1cCwgYXR0ci0+bG9jYWxOYW1lKCksIGF0dHItPnZhbHVlKCkpOworICAg IH0KKyAgICAKKyAgICBtYXJrdXAuYXBwZW5kKCIgLz4iKTsKKyAgICByZXR1cm4gbWFya3VwLnRv U3RyaW5nKCk7Cit9CisKK3ZvaWQgQ2xpcGJvYXJkOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2Uo RWxlbWVudCogZWxlbWVudCwgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBG cmFtZSogZnJhbWUpCit7CisgICAgLy8gR2V0IHRoZSBpbWFnZSBkYXRhIChyZXR1cm4gZWFybHkg aWYgdGhlcmUgaXMgbm9uZSkuCisgICAgU2hhcmVkQnVmZmVyKiBpbWFnZUJ1ZmZlciA9IDA7Cisg ICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlID0gY2FjaGVkSW1hZ2VPZk5vZGUoZWxlbWVudCk7 CisgICAgaWYgKGNhY2hlZEltYWdlICYmIGNhY2hlZEltYWdlLT5pbWFnZSgpICYmIGNhY2hlZElt YWdlLT5pc0xvYWRlZCgpKQorICAgICAgICBpbWFnZUJ1ZmZlciA9IGNhY2hlZEltYWdlLT5pbWFn ZSgpLT5kYXRhKCk7CisgICAgaWYgKCFpbWFnZUJ1ZmZlciB8fCAhaW1hZ2VCdWZmZXItPnNpemUo KSkKKyAgICAgICAgcmV0dXJuOworICAgIAorICAgIC8vIEdldCB0aGUgZmlsZW5hbWUgdG8gdXNl LgorICAgIFN0cmluZyBmaWxlTmFtZTsKKyAgICBpZiAoZWxlbWVudC0+aGFzVGFnTmFtZShpbWdU YWcpKQorICAgICAgICBmaWxlTmFtZSA9IHN0YXRpY19jYXN0PEhUTUxJbWFnZUVsZW1lbnQqPihl bGVtZW50KS0+c3VnZ2VzdGVkRmlsZW5hbWUoKTsKKyAgICAKKyAgICAvLyBDcmVhdGUgSFRNTCA8 aW1nPiBtYXJrdXA6CisgICAgU3RyaW5nIGh0bWxNYXJrdXAgPSBpbWFnZVRvTWFya3VwKGVsZW1l bnQsIGZyYW1lKTsKKyAgICAKKyAgICAvLyBOb3cgY2FsbCB0aGUgYWJzdHJhY3QgZnVsbHktc3Bl Y2lmaWVkIHZlcnNpb24gb2YgdGhpcyBtZXRob2QuCisgICAgZGVjbGFyZUFuZFdyaXRlRHJhZ0lt YWdlKHVybCwgdGl0bGUsIGltYWdlQnVmZmVyLCBmaWxlTmFtZSwgaHRtbE1hcmt1cCk7Cit9Cisg ICAgCit2b2lkIENsaXBib2FyZDo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKGNvbnN0IEtVUkwm LCBjb25zdCBTdHJpbmcmLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBTaGFyZWRCdWZmZXIqLCBjb25zdCBTdHJpbmcmLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjb25zdCBTdHJpbmcmKQoreworICAgIC8vIFRoaXMgbWV0aG9kIGlz IGFic3RyYWN0OyBhIHN1YmNsYXNzIG11c3Qgb3ZlcnJpZGUgaXQsIG9yIHRoZSBwdWJsaWMgdmVy c2lvbiB0aGF0IGNhbGxzIGl0LgorICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworfQorICAgIAor CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCShyZXZpc2lvbiA0Njg5NCkK KysrIFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCSh3b3JraW5nIGNvcHkpCkBAIC02NCw3ICs2NCw3 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCB2b2lkIHNldERyYWdJbWFn ZUVsZW1lbnQoTm9kZSosIGNvbnN0IEludFBvaW50JikgPSAwOwogICAgICAgICAKICAgICAgICAg dmlydHVhbCBEcmFnSW1hZ2VSZWYgY3JlYXRlRHJhZ0ltYWdlKEludFBvaW50JiBkcmFnTG9jYXRp b24pIGNvbnN0ID0gMDsKLSAgICAgICAgdmlydHVhbCB2b2lkIGRlY2xhcmVBbmRXcml0ZURyYWdJ bWFnZShFbGVtZW50KiwgY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKikg PSAwOworICAgICAgICB2aXJ0dWFsIHZvaWQgZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1l bnQqLCBjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqKTsKICAgICAgICAg dmlydHVhbCB2b2lkIHdyaXRlVVJMKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmLCBGcmFtZSop ID0gMDsKICAgICAgICAgdmlydHVhbCB2b2lkIHdyaXRlUmFuZ2UoUmFuZ2UqLCBGcmFtZSopID0g MDsKIApAQCAtODUsNiArODUsMTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBDbGlw Ym9hcmRBY2Nlc3NQb2xpY3kgcG9saWN5KCkgY29uc3QgeyByZXR1cm4gbV9wb2xpY3k7IH0KICAg ICAgICAgYm9vbCBkcmFnU3RhcnRlZCgpIGNvbnN0IHsgcmV0dXJuIG1fZHJhZ1N0YXJ0ZWQ7IH0K ICAgICAgICAgCisgICAgICAgIHZpcnR1YWwgdm9pZCBkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2Uo Y29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNoYXJlZEJ1ZmZlciogaW1hZ2VCdWZmZXIsIGNv bnN0IFN0cmluZyYgZmlsZU5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBtYXJrdXApOworICAgICAgICAKICAgICBwcml2YXRl OgogICAgICAgICBDbGlwYm9hcmRBY2Nlc3NQb2xpY3kgbV9wb2xpY3k7CiAgICAgICAgIFN0cmlu ZyBtX2Ryb3BFZmZlY3Q7CkluZGV4OiBXZWJDb3JlL2h0bWwvSFRNTEltYWdlRWxlbWVudC5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxJbWFnZUVsZW1lbnQuY3BwCShyZXZpc2lv biA0Njg5NCkKKysrIFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VFbGVtZW50LmNwcAkod29ya2luZyBj b3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgIkhUTUxEb2N1bWVudC5oIgogI2luY2x1 ZGUgIkhUTUxGb3JtRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUg Ik1JTUVUeXBlUmVnaXN0cnkuaCIKICNpbmNsdWRlICJNYXBwZWRBdHRyaWJ1dGUuaCIKICNpbmNs dWRlICJSZW5kZXJJbWFnZS5oIgogI2luY2x1ZGUgIlNjcmlwdEV2ZW50TGlzdGVuZXIuaCIKQEAg LTQ0MSw1ICs0NDIsNDIgQEAgdm9pZCBIVE1MSW1hZ2VFbGVtZW50OjphZGRTdWJyZXNvdXJjZUF0 dAogICAgIGFkZFN1YnJlc291cmNlVVJMKHVybHMsIHNyYygpKTsKICAgICBhZGRTdWJyZXNvdXJj ZVVSTCh1cmxzLCBkb2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1c2VNYXAoKSkpOwogfQorICAgIAor U3RyaW5nIEhUTUxJbWFnZUVsZW1lbnQ6OnN1Z2dlc3RlZEZpbGVuYW1lKCkgY29uc3QKK3sKKyAg ICBTdHJpbmcgZmlsZU5hbWU7CisgICAgCisgICAgLy8gV2UgdHJ5IHRvIHVzZSB0aGUgc3VnZ2Vz dGVkIGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciBmaXJzdC4KKyAgICBDYWNoZWRJbWFnZSog Y2FjaGVkSW1hZ2UgPSB0aGlzLT5jYWNoZWRJbWFnZSgpOworICAgIGlmIChjYWNoZWRJbWFnZSAm JiBjYWNoZWRJbWFnZS0+aW1hZ2UoKSAmJiBjYWNoZWRJbWFnZS0+aXNMb2FkZWQoKSkKKyAgICAg ICAgZmlsZU5hbWUgPSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgp OworICAgIAorICAgIGlmIChmaWxlTmFtZS5pc0VtcHR5KCkpIHsKKyAgICAgICAgLy8gVGhlbiwg aWYgdGhlcmUncyBub25lLCB3ZSB0cnkgdG8gZXh0cmFjdCB0aGUgZmlsZW5hbWUgZnJvbQorICAg ICAgICAvLyB0aGUgaW1hZ2UgVVJMIHN0b3JlZCBpbiB0aGUgc3JjIGF0dHJpYnV0ZS4KKyAgICAg ICAgZmlsZU5hbWUgPSBzcmMoKS5sYXN0UGF0aENvbXBvbmVudCgpOworICAgICAgICAvLyBJZiB0 aGVyZSdzIG5vbmUsIHdlIHRoZW4gdHJ5IHRoZSBhbHQgdGFnIGlmIG9uZSBleGlzdHMuCisgICAg ICAgIGlmIChmaWxlTmFtZS5pc0VtcHR5KCkpCisgICAgICAgICAgICBmaWxlTmFtZSA9IGFsdFRl eHQoKTsKKyAgICB9CisgICAgCisgICAgLy8gUmVtb3ZlIGxlYWRpbmcgb3IgdHJhaWxpbmcgJy4n cy4KKyAgICB3aGlsZSAoZmlsZU5hbWUuc3RhcnRzV2l0aCgiLiIpKQorICAgICAgICBmaWxlTmFt ZS5yZW1vdmUoMCwxKTsKKyAgICB3aGlsZSAoZmlsZU5hbWUuZW5kc1dpdGgoIi4iKSkKKyAgICAg ICAgZmlsZU5hbWUucmVtb3ZlKGZpbGVOYW1lLmxlbmd0aCgpIC0gMSwgMSk7CisgICAgCisgICAg Ly8gV2UgY2FuJ3QgcmVseSBvbiB0aGUgZmlsZW5hbWUgZXh0ZW5zaW9uLCBzbyB3ZSBtdXN0IHJl bW92ZSBpdAorICAgIC8vIGFuZCB1c2UgdGhlIG9uZSByZWdpc3RlcmVkIHdpdGggdGhlIE1JTUUg dHlwZS4KKyAgICBpbnQgZXh0ZW5zaW9uX2luZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4n KTsKKyAgICBpZiAoZXh0ZW5zaW9uX2luZGV4ICE9IC0xKQorICAgICAgICBmaWxlTmFtZS50cnVu Y2F0ZShleHRlbnNpb25faW5kZXgpOworICAgIGlmICghZmlsZU5hbWUuaXNFbXB0eSgpKSB7Cisg ICAgICAgIFN0cmluZyBleHRlbnNpb24gPSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRF eHRlbnNpb25Gb3JNSU1FVHlwZShjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5taW1lVHlwZSgpKTsK KyAgICAgICAgZmlsZU5hbWUgKz0gIi4iOworICAgICAgICBmaWxlTmFtZSArPSBleHRlbnNpb247 CisgICAgfQorICAgIHJldHVybiBmaWxlTmFtZTsKK30KIAogfQpJbmRleDogV2ViQ29yZS9odG1s L0hUTUxJbWFnZUVsZW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvSFRNTEltYWdl RWxlbWVudC5oCShyZXZpc2lvbiA0Njg5NCkKKysrIFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VFbGVt ZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTExNiw2ICsxMTYsOCBAQCBwdWJsaWM6CiAgICAgYm9v bCBoYXZlRmlyZWRMb2FkRXZlbnQoKSBjb25zdCB7IHJldHVybiBtX2ltYWdlTG9hZGVyLmhhdmVG aXJlZExvYWRFdmVudCgpOyB9CiAKICAgICB2aXJ0dWFsIHZvaWQgYWRkU3VicmVzb3VyY2VBdHRy aWJ1dGVVUkxzKExpc3RIYXNoU2V0PEtVUkw+JikgY29uc3Q7CisgICAgCisgICAgU3RyaW5nIHN1 Z2dlc3RlZEZpbGVuYW1lKCkgY29uc3Q7CiAKIHByaXZhdGU6CiAgICAgSFRNTEltYWdlTG9hZGVy IG1faW1hZ2VMb2FkZXI7CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2Fy ZENocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0Ns aXBib2FyZENocm9taXVtLmNwcAkocmV2aXNpb24gNDY4OTQpCisrKyBXZWJDb3JlL3BsYXRmb3Jt L2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzYsNiAr MzYsNyBAQAogI2luY2x1ZGUgIkZpbGVMaXN0LmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNs dWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50LmgiCiAjaW5jbHVk ZSAiTmFtZWRBdHRyTWFwLmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3RyeS5oIgogI2luY2x1 ZGUgIm1hcmt1cC5oIgpAQCAtMjE2LDk5ICsyMTcsMzUgQEAgRHJhZ0ltYWdlUmVmIENsaXBib2Fy ZENocm9taXVtOjpjcmVhdGVEcgogICAgIH0KICAgICByZXR1cm4gcmVzdWx0OwogfQotCi1zdGF0 aWMgU3RyaW5nIGltYWdlVG9NYXJrdXAoY29uc3QgU3RyaW5nJiB1cmwsIEVsZW1lbnQqIGVsZW1l bnQpCisgICAgCitzdGF0aWMgdm9pZCBzcGxpdEZpbGVOYW1lKGNvbnN0IFN0cmluZyYgZmlsZU5h bWUsIFN0cmluZyYgb3V0QmFzZU5hbWUsIFN0cmluZyYgb3V0RXh0ZW5zaW9uKQogewotICAgIFN0 cmluZ0J1aWxkZXIgbWFya3VwOwotICAgIG1hcmt1cC5hcHBlbmQoIjxpbWcgc3JjPVwiIik7Ci0g ICAgbWFya3VwLmFwcGVuZCh1cmwpOwotICAgIG1hcmt1cC5hcHBlbmQoIlwiIik7Ci0gICAgLy8g Q29weSBvdmVyIGF0dHJpYnV0ZXMuICBJZiB3ZSBhcmUgZHJhZ2dpbmcgYW4gaW1hZ2UsIHdlIGV4 cGVjdCB0aGluZ3MgbGlrZQotICAgIC8vIHRoZSBpZCB0byBiZSBjb3BpZWQgYXMgd2VsbC4KLSAg ICBOYW1lZE5vZGVNYXAqIGF0dHJzID0gZWxlbWVudC0+YXR0cmlidXRlcygpOwotICAgIHVuc2ln bmVkIGxlbmd0aCA9IGF0dHJzLT5sZW5ndGgoKTsKLSAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBp IDwgbGVuZ3RoOyArK2kpIHsKLSAgICAgICAgQXR0cmlidXRlKiBhdHRyID0gYXR0cnMtPmF0dHJp YnV0ZUl0ZW0oaSk7Ci0gICAgICAgIGlmIChhdHRyLT5sb2NhbE5hbWUoKSA9PSAic3JjIikKLSAg ICAgICAgICAgIGNvbnRpbnVlOwotICAgICAgICBtYXJrdXAuYXBwZW5kKCIgIik7Ci0gICAgICAg IG1hcmt1cC5hcHBlbmQoYXR0ci0+bG9jYWxOYW1lKCkpOwotICAgICAgICBtYXJrdXAuYXBwZW5k KCI9XCIiKTsKLSAgICAgICAgU3RyaW5nIGVzY2FwZWRBdHRyID0gYXR0ci0+dmFsdWUoKTsKLSAg ICAgICAgZXNjYXBlZEF0dHIucmVwbGFjZSgiXCIiLCAiJnF1b3Q7Iik7Ci0gICAgICAgIG1hcmt1 cC5hcHBlbmQoZXNjYXBlZEF0dHIpOwotICAgICAgICBtYXJrdXAuYXBwZW5kKCJcIiIpOworICAg IGludCBleHRlbnNpb25JbmRleCA9IGZpbGVOYW1lLnJldmVyc2VGaW5kKCcuJyk7CisgICAgaWYg KGV4dGVuc2lvbkluZGV4ICE9IC0xKSB7CisgICAgICAgIG91dEJhc2VOYW1lID0gZmlsZU5hbWUu bGVmdChleHRlbnNpb25JbmRleCk7CisgICAgICAgIG91dEV4dGVuc2lvbiA9IGZpbGVOYW1lLnN1 YnN0cmluZyhleHRlbnNpb25JbmRleCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgb3V0QmFzZU5h bWUgPSBmaWxlTmFtZTsKKyAgICAgICAgb3V0RXh0ZW5zaW9uID0gIiI7CiAgICAgfQotCi0gICAg bWFya3VwLmFwcGVuZCgiLz4iKTsKLSAgICByZXR1cm4gbWFya3VwLnRvU3RyaW5nKCk7Ci19Ci0K LXN0YXRpYyBDYWNoZWRJbWFnZSogZ2V0Q2FjaGVkSW1hZ2UoRWxlbWVudCogZWxlbWVudCkKLXsK LSAgICAvLyBBdHRlbXB0IHRvIHB1bGwgQ2FjaGVkSW1hZ2UgZnJvbSBlbGVtZW50Ci0gICAgQVNT RVJUKGVsZW1lbnQpOwotICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBlbGVtZW50LT5yZW5k ZXJlcigpOwotICAgIGlmICghcmVuZGVyZXIgfHwgIXJlbmRlcmVyLT5pc0ltYWdlKCkpCi0gICAg ICAgIHJldHVybiAwOwotCi0gICAgUmVuZGVySW1hZ2UqIGltYWdlID0gdG9SZW5kZXJJbWFnZShy ZW5kZXJlcik7Ci0gICAgaWYgKGltYWdlLT5jYWNoZWRJbWFnZSgpICYmICFpbWFnZS0+Y2FjaGVk SW1hZ2UoKS0+ZXJyb3JPY2N1cnJlZCgpKQotICAgICAgICByZXR1cm4gaW1hZ2UtPmNhY2hlZElt YWdlKCk7Ci0KLSAgICByZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgd3JpdGVJbWFnZVRvRGF0 YU9iamVjdChDaHJvbWl1bURhdGFPYmplY3QqIGRhdGFPYmplY3QsIEVsZW1lbnQqIGVsZW1lbnQs Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IEtVUkwmIHVybCkKLXsK LSAgICAvLyBTaG92ZSBpbWFnZSBkYXRhIGludG8gYSBEYXRhT2JqZWN0IGZvciB1c2UgYXMgYSBm aWxlCi0gICAgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlID0gZ2V0Q2FjaGVkSW1hZ2UoZWxlbWVu dCk7Ci0gICAgaWYgKCFjYWNoZWRJbWFnZSB8fCAhY2FjaGVkSW1hZ2UtPmltYWdlKCkgfHwgIWNh Y2hlZEltYWdlLT5pc0xvYWRlZCgpKQotICAgICAgICByZXR1cm47Ci0KLSAgICBTaGFyZWRCdWZm ZXIqIGltYWdlQnVmZmVyID0gY2FjaGVkSW1hZ2UtPmltYWdlKCktPmRhdGEoKTsKLSAgICBpZiAo IWltYWdlQnVmZmVyIHx8ICFpbWFnZUJ1ZmZlci0+c2l6ZSgpKQotICAgICAgICByZXR1cm47Ci0K LSAgICBkYXRhT2JqZWN0LT5maWxlQ29udGVudCA9IGltYWdlQnVmZmVyOwotCi0gICAgLy8gRGV0 ZXJtaW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZpbGUgY29udGVudHMgb2YgdGhlIGltYWdlLiAg V2UgdHJ5IHRvCi0gICAgLy8gdXNlIHRoZSBhbHQgdGFnIGlmIG9uZSBleGlzdHMsIG90aGVyd2lz ZSB3ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dlc3RlZAotICAgIC8vIGZpbGVuYW1lIGluIHRoZSBo dHRwIGhlYWRlciwgYW5kIGZpbmFsbHkgd2UgcmVzb3J0IHRvIHVzaW5nIHRoZSBmaWxlbmFtZQot ICAgIC8vIGluIHRoZSBVUkwuCi0gICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0 cnk6OmdldFByZWZlcnJlZEV4dGVuc2lvbkZvck1JTUVUeXBlKAotICAgICAgICBjYWNoZWRJbWFn ZS0+cmVzcG9uc2UoKS5taW1lVHlwZSgpKTsKLSAgICBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9u ID0gZXh0ZW5zaW9uLmlzRW1wdHkoKSA/ICIiIDogIi4iICsgZXh0ZW5zaW9uOwotICAgIFN0cmlu ZyB0aXRsZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKLSAgICBpZiAodGl0bGUu aXNFbXB0eSgpKQotICAgICAgICB0aXRsZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dl c3RlZEZpbGVuYW1lKCk7Ci0KLSAgICB0aXRsZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0 ZUZpbGVOYW1lKHRpdGxlLCBkYXRhT2JqZWN0KTsKLSAgICBkYXRhT2JqZWN0LT5maWxlQ29udGVu dEZpbGVuYW1lID0gdGl0bGUgKyBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uOwotfQotCi12b2lk IENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoRWxlbWVudCogZWxl bWVudCwgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBGcmFtZSogZnJhbWUp Cit2b2lkIENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoY29uc3Qg S1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFNoYXJlZEJ1ZmZlciogaW1hZ2VCdWZmZXIsIGNvbnN0 IFN0cmluZyYgZmlsZU5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBodG1sTWFya3VwKQogewogICAgIGlmICghbV9kYXRh T2JqZWN0KQogICAgICAgICByZXR1cm47CiAKICAgICBtX2RhdGFPYmplY3QtPnVybCA9IHVybDsK ICAgICBtX2RhdGFPYmplY3QtPnVybFRpdGxlID0gdGl0bGU7Ci0KLSAgICAvLyBXcml0ZSB0aGUg Ynl0ZXMgaW4gdGhlIGltYWdlIHRvIHRoZSBmaWxlIGZvcm1hdC4KLSAgICB3cml0ZUltYWdlVG9E YXRhT2JqZWN0KG1fZGF0YU9iamVjdC5nZXQoKSwgZWxlbWVudCwgdXJsKTsKLQotICAgIEF0b21p Y1N0cmluZyBpbWFnZVVSTCA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShzcmNBdHRyKTsKLSAgICBp ZiAoaW1hZ2VVUkwuaXNFbXB0eSgpKQotICAgICAgICByZXR1cm47Ci0KLSAgICBTdHJpbmcgZnVs bFVSTCA9IGZyYW1lLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTChkZXByZWNhdGVkUGFyc2VVUkwo aW1hZ2VVUkwpKTsKLSAgICBpZiAoZnVsbFVSTC5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVybjsK LQotICAgIC8vIFB1dCBpbWcgdGFnIG9uIHRoZSBjbGlwYm9hcmQgcmVmZXJlbmNpbmcgdGhlIGlt YWdlCi0gICAgbV9kYXRhT2JqZWN0LT50ZXh0SHRtbCA9IGltYWdlVG9NYXJrdXAoZnVsbFVSTCwg ZWxlbWVudCk7CisgICAgbV9kYXRhT2JqZWN0LT5maWxlQ29udGVudCA9IGltYWdlQnVmZmVyOwor ICAgIG1fZGF0YU9iamVjdC0+dGV4dEh0bWwgPSBodG1sTWFya3VwOworICAgIAorICAgIFN0cmlu ZyBiYXNlTmFtZTsKKyAgICBzcGxpdEZpbGVOYW1lKGZpbGVOYW1lLCBiYXNlTmFtZSxtX2RhdGFP YmplY3QtPmZpbGVFeHRlbnNpb24pOworICAgIGJhc2VOYW1lID0gQ2xpcGJvYXJkQ2hyb21pdW06 OnZhbGlkYXRlRmlsZU5hbWUoYmFzZU5hbWUsbV9kYXRhT2JqZWN0LmdldCgpKTsKKyAgICBtX2Rh dGFPYmplY3QtPmZpbGVDb250ZW50RmlsZW5hbWUgPSBiYXNlTmFtZSArIG1fZGF0YU9iamVjdC0+ ZmlsZUV4dGVuc2lvbjsKIH0KIAogdm9pZCBDbGlwYm9hcmRDaHJvbWl1bTo6d3JpdGVVUkwoY29u c3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBGcmFtZSopCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5oCShyZXZpc2lvbiA0Njg5 NCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uaAkod29y a2luZyBjb3B5KQpAQCAtNzEsMTcgKzcxLDIwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAg ICAgfQogCiAgICAgICAgIHZpcnR1YWwgRHJhZ0ltYWdlUmVmIGNyZWF0ZURyYWdJbWFnZShJbnRQ b2ludCYgZHJhZ0xvYykgY29uc3Q7Ci0gICAgICAgIHZpcnR1YWwgdm9pZCBkZWNsYXJlQW5kV3Jp dGVEcmFnSW1hZ2UoRWxlbWVudCosIGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBG cmFtZSopOwogICAgICAgICB2aXJ0dWFsIHZvaWQgd3JpdGVVUkwoY29uc3QgS1VSTCYsIGNvbnN0 IFN0cmluZyYsIEZyYW1lKik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCB3cml0ZVJhbmdlKFJhbmdl KiwgRnJhbWUqKTsKIAogICAgICAgICB2aXJ0dWFsIGJvb2wgaGFzRGF0YSgpOwotCisgICAgICAg IAogICAgIHByaXZhdGU6CiAgICAgICAgIENsaXBib2FyZENocm9taXVtKGJvb2wsIFBhc3NSZWZQ dHI8Q2hyb21pdW1EYXRhT2JqZWN0PiwgQ2xpcGJvYXJkQWNjZXNzUG9saWN5KTsKIAogICAgICAg ICB2b2lkIHJlc2V0RnJvbUNsaXBib2FyZCgpOwogICAgICAgICB2b2lkIHNldERyYWdJbWFnZShD YWNoZWRJbWFnZSosIE5vZGUqLCBjb25zdCBJbnRQb2ludCYpOworICAgICAgICB2aXJ0dWFsIHZv aWQgZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmIHRp dGxlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNoYXJl ZEJ1ZmZlciogaW1hZ2VCdWZmZXIsIGNvbnN0IFN0cmluZyYgZmlsZU5hbWUsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgU3RyaW5nJiBodG1sTWFy a3VwKTsKKwogICAgICAgICBSZWZQdHI8Q2hyb21pdW1EYXRhT2JqZWN0PiBtX2RhdGFPYmplY3Q7 CiAgICAgfTsKIApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJv bWl1bU1hYy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlw Ym9hcmRDaHJvbWl1bU1hYy5jcHAJKHJldmlzaW9uIDQ2ODk0KQorKysgV2ViQ29yZS9wbGF0Zm9y bS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI4 LDE0ICsyOCw0NiBAQAogI2luY2x1ZGUgIkNsaXBib2FyZENocm9taXVtLmgiCiAKICNpbmNsdWRl ICJDaHJvbWl1bURhdGFPYmplY3QuaCIKLSNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCisKKy8vIEZpbGVuYW1lIGxlbmd0aCBhbmQgY2hhcmFj dGVyLXNldCBsaW1pdHMgdmFyeSBieSBmaWxlc3lzdGVtLCBhbmQgdGhlcmUncyBubworLy8gcmVh bCB3YXkgdG8gdGVsbCB3aGF0IGZpbGVzeXN0ZW0gaXMgaW4gdXNlLiBTaW5jZSBIRlMrIGlzIGJ5 IGZhciB0aGUgbW9zdAorLy8gY29tbW9uLCB3ZSdsbCBhYmlkZSBieSBpdHMgbGltaXRzLCB3aGlj aCBhcmUgMjU1IFVuaWNvZGUgY2hhcmFjdGVycyAoc2xpZ2h0bHkKKy8vIHNpbXBsaWZpZWQ7IHJl YWxseSBpdCB1c2VzIE5vcm1hbGl6YXRpb24gRm9ybSBELCBidXQgdGhlIGRpZmZlcmVuY2VzIGFy ZW4ndAorLy8gcmVhbGx5IHdvcnRoIGRlYWxpbmcgd2l0aCBoZXJlLikKK3N0YXRpYyBjb25zdCBp bnQgTWF4SEZTRmlsZW5hbWVMZW5ndGggPSAyNTU7CisKKworc3RhdGljIGJvb2wgaXNJbnZhbGlk RmlsZUNoYXJhY3RlcihVQ2hhciBjKQoreworICAgIC8vIEhGUysgYmFzaWNhbGx5IGFsbG93cyBh bnl0aGluZyBidXQgJy8nLiBGb3Igc2FuaXR5J3Mgc2FrZSB3ZSdsbCBkaXNhbGxvdworICAgIC8v IGNvbnRyb2wgY2hhcmFjdGVycy4KKyAgICByZXR1cm4gYyA8ICcgJyB8fCBjID09IDB4N0YgfHwg YyA9PSAnLyc7Cit9CiAKIFN0cmluZyBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFt ZShjb25zdCBTdHJpbmcmIHRpdGxlLCBDaHJvbWl1bURhdGFPYmplY3QqIGRhdGFPYmplY3QpCiB7 Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKLSAgICByZXR1cm4gdGl0bGU7CisgICAgLy8gUmVtb3Zl IGFueSBpbnZhbGlkIGZpbGUgc3lzdGVtIGNoYXJhY3RlcnMsIGVzcGVjaWFsbHkgIi8iLgorICAg IFN0cmluZyByZXN1bHQgPSB0aXRsZS5yZW1vdmVDaGFyYWN0ZXJzKGlzSW52YWxpZEZpbGVDaGFy YWN0ZXIpOworICAgIFN0cmluZyBleHRlbnNpb24gPSBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9u LnJlbW92ZUNoYXJhY3RlcnMoJmlzSW52YWxpZEZpbGVDaGFyYWN0ZXIpOworCisgICAgLy8gTGVh ZGluZyAiLiJzIHdvdWxkIG1ha2UgdGhlIGZpbGUgaW52aXNpYmxlIC0tIHN0cmlwIHRoZW0uCisg ICAgd2hpbGUgKHJlc3VsdC5zdGFydHNXaXRoKCIuIikpCisgICAgICAgIHJlc3VsdC5yZW1vdmUo MCwxKTsKKworICAgIC8vIFJlbW92ZSBhIHJpZGljdWxvdXNseS1sb25nIGV4dGVuc2lvbi4KKyAg ICBpZiAoZXh0ZW5zaW9uLmxlbmd0aCgpID49IE1heEhGU0ZpbGVuYW1lTGVuZ3RoKQorICAgICAg ICBleHRlbnNpb24gPSAiIjsKKyAgICAKKyAgICAvLyBUcnVuY2F0ZSBhbiBvdmVybHktbG9uZyBm aWxlbmFtZS4KKyAgICBpbnQgb3ZlcmZsb3cgPSByZXN1bHQubGVuZ3RoKCkgKyBleHRlbnNpb24u bGVuZ3RoKCkgLSBNYXhIRlNGaWxlbmFtZUxlbmd0aDsKKyAgICBpZiAob3ZlcmZsb3cgPiAwKSAK KyAgICAgICAgcmVzdWx0LnJlbW92ZShyZXN1bHQubGVuZ3RoKCkgLSBvdmVyZmxvdywgb3ZlcmZs b3cpOworICAgIAorICAgIGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24gPSBleHRlbnNpb247Cisg ICAgcmV0dXJuIHJlc3VsdDsKIH0KIAogfSAgLy8gbmFtZXNwYWNlIFdlYkNvcmUK 34300 2009-08-07 11:38:50 -0700 2009-08-07 13:28:02 -0700 Patch, fixing 2 more issues from Darin imageFilename3.patch text/plain 16748 jens SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0Njg5NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMDktMDgtMDcgIEplbnMgQWxma2UgIDxzbmVqQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBCdWcg MjQ4ODcgLSBXcm9uZyBmaWxlbmFtZSB3aGVuIGRyYWdnaW5nIGFuIGltYWdlIHRvIHRoZSBEZXNr dG9wLgorICAgICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI0ODg3CisgICAgICAgIEFkZHMgZnVuY3Rpb25hbGl0eSB0byBIVE1MSW1hZ2VFbGVtZW50IHRv IGRldGVybWluZSB0aGUgZmlsZW5hbWUgdG8gdXNlLgorICAgICAgICBNb2RpZmllcyBDbGlwYm9h cmRDaHJvbWl1bSB0byB1c2UgaXQgd2hlbiBzZXR0aW5nIHVwIHRoZSBkcmFnLgorICAgICAgICBJ bXBsZW1lbnRzIHZhbGlkYXRlRmlsZU5hbWUgZm9yIE1hYyBDaHJvbWl1bSAobGltaXRzIG5hbWUg dG8gMjU1IFVURi04IGJ5dGVzLikKKworICAgICAgICBObyB0ZXN0czsgd291bGQgYmUgdW5yZWFz b25hYmx5IGRpZmZpY3VsdCB0byBhZGQgdGhlIHBsdW1iaW5nIHRvIGFjY2VzcyB0aGUgcHJvcG9z ZWQKKyAgICAgICAgZmlsZW5hbWUgZnJvbSB3aXRoaW4gRFJULgorCisgICAgICAgICogaHRtbC9I VE1MSW1hZ2VFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbWFnZUVsZW1lbnQ6 OnN1Z2dlc3RlZEZpbGVuYW1lKToKKyAgICAgICAgKiBodG1sL0hUTUxJbWFnZUVsZW1lbnQuaDoK KyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpDbGlwYm9hcmRDaHJvbWl1bTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6 CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJh Z0ltYWdlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5o OgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OmlzSW52YWxpZEZpbGVDaGFyYWN0ZXIpOgorICAgICAgICAoV2Vi Q29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUpOgorCiAyMDA5LTA4LTA1 ICBEaW1pdHJpIEdsYXprb3YgIDxkZ2xhemtvdkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5y ZXZpZXdlZCwgYnVpbGQgZml4LgpJbmRleDogV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9DbGlwYm9hcmQuY3BwCShyZXZpc2lvbiA0Njg5NCkKKysr IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMwLDkgKzMwLDE1 IEBACiAjaW5jbHVkZSAiRE9NSW1wbGVtZW50YXRpb24uaCIKICNpbmNsdWRlICJGcmFtZS5oIgog I2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgor I2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiUmVu ZGVySW1hZ2UuaCIKKyNpbmNsdWRlICJTdHJpbmdCdWlsZGVyLmgiCiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKKyAgICAKK3VzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CiAKIENsaXBib2FyZDo6Q2xp cGJvYXJkKENsaXBib2FyZEFjY2Vzc1BvbGljeSBwb2xpY3ksIGJvb2wgaXNGb3JEcmFnZ2luZykg CiAgICAgOiBtX3BvbGljeShwb2xpY3kpIApAQCAtMTM5LDUgKzE0NSw4NyBAQCB2b2lkIENsaXBi b2FyZDo6c2V0RWZmZWN0QWxsb3dlZChjb25zdCBTCiAgICAgaWYgKG1fcG9saWN5ID09IENsaXBi b2FyZFdyaXRhYmxlKQogICAgICAgICBtX2VmZmVjdEFsbG93ZWQgPSBlZmZlY3Q7CiB9CisgICAg CitzdGF0aWMgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlT2ZOb2RlKE5vZGUqIG5vZGUpCit7Cisg ICAgQVNTRVJUKG5vZGUpOworICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBub2RlLT5yZW5k ZXJlcigpOworICAgIGlmICghcmVuZGVyZXIgfHwgIXJlbmRlcmVyLT5pc0ltYWdlKCkpCisgICAg ICAgIHJldHVybiAwOworICAgIAorICAgIFJlbmRlckltYWdlKiBpbWFnZSA9IHRvUmVuZGVySW1h Z2UocmVuZGVyZXIpOworICAgIGlmICghaW1hZ2UtPmNhY2hlZEltYWdlKCkgfHwgaW1hZ2UtPmNh Y2hlZEltYWdlKCktPmVycm9yT2NjdXJyZWQoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgCisg ICAgcmV0dXJuIGltYWdlLT5jYWNoZWRJbWFnZSgpOworfQorICAgIAorc3RhdGljIHZvaWQgYXBw ZW5kQXR0cmlidXRlKFN0cmluZ0J1aWxkZXImIG1hcmt1cCwgY29uc3QgU3RyaW5nJiBuYW1lLCBT dHJpbmcgdmFsdWUpCit7CisgICAgdmFsdWUucmVwbGFjZSgiJiIsICImYW1wOyIpOworICAgIHZh bHVlLnJlcGxhY2UoIlwiIiwgIiZxdW90OyIpOworICAgIG1hcmt1cC5hcHBlbmQoIiAiKTsKKyAg ICBtYXJrdXAuYXBwZW5kKG5hbWUpOworICAgIG1hcmt1cC5hcHBlbmQoIj1cIiIpOworICAgIG1h cmt1cC5hcHBlbmQodmFsdWUpOworICAgIG1hcmt1cC5hcHBlbmQoIlwiIik7Cit9CisKK3N0YXRp YyBTdHJpbmcgaW1hZ2VUb01hcmt1cChFbGVtZW50KiBlbGVtZW50LCBGcmFtZSogZnJhbWUpCit7 CisgICAgU3RyaW5nIHNyY1VSTDsKKyAgICBjb25zdCBBdG9taWNTdHJpbmcmIGltYWdlVVJMID0g ZWxlbWVudC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOworICAgIGlmICghaW1hZ2VVUkwuaXNFbXB0 eSgpKQorICAgICAgICBzcmNVUkwgPSBmcmFtZS0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoZGVw cmVjYXRlZFBhcnNlVVJMKGltYWdlVVJMKSk7CisgICAgCisgICAgU3RyaW5nQnVpbGRlciBtYXJr dXA7CisgICAgbWFya3VwLmFwcGVuZCgiPGltZyIpOworICAgIGFwcGVuZEF0dHJpYnV0ZShtYXJr dXAsIHNyY0F0dHIubG9jYWxOYW1lKCksIHNyY1VSTCk7CisKKyAgICAvLyBDb3B5IG92ZXIgYXR0 cmlidXRlcy4gIElmIHdlIGFyZSBkcmFnZ2luZyBhbiBpbWFnZSwgd2UgZXhwZWN0IHRoaW5ncyBs aWtlCisgICAgLy8gdGhlIGlkIHRvIGJlIGNvcGllZCBhcyB3ZWxsLgorICAgIE5hbWVkTm9kZU1h cCogYXR0cnMgPSBlbGVtZW50LT5hdHRyaWJ1dGVzKCk7CisgICAgdW5zaWduZWQgbGVuZ3RoID0g YXR0cnMtPmxlbmd0aCgpOworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsZW5ndGg7ICsr aSkgeworICAgICAgICBBdHRyaWJ1dGUqIGF0dHIgPSBhdHRycy0+YXR0cmlidXRlSXRlbShpKTsK KyAgICAgICAgaWYgKGF0dHItPm5hbWUoKSAhPSBzcmNBdHRyKQorICAgICAgICAgICAgYXBwZW5k QXR0cmlidXRlKG1hcmt1cCwgYXR0ci0+bG9jYWxOYW1lKCksIGF0dHItPnZhbHVlKCkpOworICAg IH0KKyAgICAKKyAgICBtYXJrdXAuYXBwZW5kKCI+Iik7CisgICAgcmV0dXJuIG1hcmt1cC50b1N0 cmluZygpOworfQorCit2b2lkIENsaXBib2FyZDo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVs ZW1lbnQqIGVsZW1lbnQsIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJh bWUqIGZyYW1lKQoreworICAgIC8vIEdldCB0aGUgaW1hZ2UgZGF0YSAocmV0dXJuIGVhcmx5IGlm IHRoZXJlIGlzIG5vbmUpLgorICAgIFNoYXJlZEJ1ZmZlciogaW1hZ2VCdWZmZXIgPSAwOworICAg IENhY2hlZEltYWdlKiBjYWNoZWRJbWFnZSA9IGNhY2hlZEltYWdlT2ZOb2RlKGVsZW1lbnQpOwor ICAgIGlmIChjYWNoZWRJbWFnZSAmJiBjYWNoZWRJbWFnZS0+aW1hZ2UoKSAmJiBjYWNoZWRJbWFn ZS0+aXNMb2FkZWQoKSkKKyAgICAgICAgaW1hZ2VCdWZmZXIgPSBjYWNoZWRJbWFnZS0+aW1hZ2Uo KS0+ZGF0YSgpOworICAgIGlmICghaW1hZ2VCdWZmZXIgfHwgIWltYWdlQnVmZmVyLT5zaXplKCkp CisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICAvLyBHZXQgdGhlIGZpbGVuYW1lIHRvIHVzZS4K KyAgICBTdHJpbmcgZmlsZU5hbWU7CisgICAgaWYgKGVsZW1lbnQtPmhhc1RhZ05hbWUoaW1nVGFn KSkKKyAgICAgICAgZmlsZU5hbWUgPSBzdGF0aWNfY2FzdDxIVE1MSW1hZ2VFbGVtZW50Kj4oZWxl bWVudCktPnN1Z2dlc3RlZEZpbGVuYW1lKCk7CisgICAgCisgICAgLy8gQ3JlYXRlIEhUTUwgPGlt Zz4gbWFya3VwOgorICAgIFN0cmluZyBodG1sTWFya3VwID0gaW1hZ2VUb01hcmt1cChlbGVtZW50 LCBmcmFtZSk7CisgICAgCisgICAgLy8gTm93IGNhbGwgdGhlIGFic3RyYWN0IGZ1bGx5LXNwZWNp ZmllZCB2ZXJzaW9uIG9mIHRoaXMgbWV0aG9kLgorICAgIGRlY2xhcmVBbmRXcml0ZURyYWdJbWFn ZSh1cmwsIHRpdGxlLCBpbWFnZUJ1ZmZlciwgZmlsZU5hbWUsIGh0bWxNYXJrdXApOworfQorICAg IAordm9pZCBDbGlwYm9hcmQ6OmRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShjb25zdCBLVVJMJiwg Y29uc3QgU3RyaW5nJiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg U2hhcmVkQnVmZmVyKiwgY29uc3QgU3RyaW5nJiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgY29uc3QgU3RyaW5nJikKK3sKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBh YnN0cmFjdDsgYSBzdWJjbGFzcyBtdXN0IG92ZXJyaWRlIGl0LCBvciB0aGUgcHVibGljIHZlcnNp b24gdGhhdCBjYWxscyBpdC4KKyAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKK30KKyAgICAKKwog CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3JlL2RvbS9DbGlwYm9hcmQuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9DbGlwYm9hcmQuaAkocmV2aXNpb24gNDY4OTQpCisr KyBXZWJDb3JlL2RvbS9DbGlwYm9hcmQuaAkod29ya2luZyBjb3B5KQpAQCAtNjQsNyArNjQsNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBzZXREcmFnSW1hZ2VF bGVtZW50KE5vZGUqLCBjb25zdCBJbnRQb2ludCYpID0gMDsKICAgICAgICAgCiAgICAgICAgIHZp cnR1YWwgRHJhZ0ltYWdlUmVmIGNyZWF0ZURyYWdJbWFnZShJbnRQb2ludCYgZHJhZ0xvY2F0aW9u KSBjb25zdCA9IDA7Ci0gICAgICAgIHZpcnR1YWwgdm9pZCBkZWNsYXJlQW5kV3JpdGVEcmFnSW1h Z2UoRWxlbWVudCosIGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBGcmFtZSopID0g MDsKKyAgICAgICAgdmlydHVhbCB2b2lkIGRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50 KiwgY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKik7CiAgICAgICAgIHZp cnR1YWwgdm9pZCB3cml0ZVVSTChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiwgRnJhbWUqKSA9 IDA7CiAgICAgICAgIHZpcnR1YWwgdm9pZCB3cml0ZVJhbmdlKFJhbmdlKiwgRnJhbWUqKSA9IDA7 CiAKQEAgLTg1LDYgKzg1LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgQ2xpcGJv YXJkQWNjZXNzUG9saWN5IHBvbGljeSgpIGNvbnN0IHsgcmV0dXJuIG1fcG9saWN5OyB9CiAgICAg ICAgIGJvb2wgZHJhZ1N0YXJ0ZWQoKSBjb25zdCB7IHJldHVybiBtX2RyYWdTdGFydGVkOyB9CiAg ICAgICAgIAorICAgICAgICB2aXJ0dWFsIHZvaWQgZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKGNv bnN0IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiB0aXRsZSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBTaGFyZWRCdWZmZXIqIGltYWdlQnVmZmVyLCBjb25z dCBTdHJpbmcmIGZpbGVOYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnN0IFN0cmluZyYgbWFya3VwKTsKKyAgICAgICAgCiAgICAgcHJpdmF0ZToK ICAgICAgICAgQ2xpcGJvYXJkQWNjZXNzUG9saWN5IG1fcG9saWN5OwogICAgICAgICBTdHJpbmcg bV9kcm9wRWZmZWN0OwpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxJbWFnZUVsZW1lbnQuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VFbGVtZW50LmNwcAkocmV2aXNpb24g NDY4OTQpCisrKyBXZWJDb3JlL2h0bWwvSFRNTEltYWdlRWxlbWVudC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJIVE1MRG9jdW1lbnQuaCIKICNpbmNsdWRl ICJIVE1MRm9ybUVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJN SU1FVHlwZVJlZ2lzdHJ5LmgiCiAjaW5jbHVkZSAiTWFwcGVkQXR0cmlidXRlLmgiCiAjaW5jbHVk ZSAiUmVuZGVySW1hZ2UuaCIKICNpbmNsdWRlICJTY3JpcHRFdmVudExpc3RlbmVyLmgiCkBAIC00 NDEsNSArNDQyLDQyIEBAIHZvaWQgSFRNTEltYWdlRWxlbWVudDo6YWRkU3VicmVzb3VyY2VBdHQK ICAgICBhZGRTdWJyZXNvdXJjZVVSTCh1cmxzLCBzcmMoKSk7CiAgICAgYWRkU3VicmVzb3VyY2VV UkwodXJscywgZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwodXNlTWFwKCkpKTsKIH0KKyAgICAKK1N0 cmluZyBIVE1MSW1hZ2VFbGVtZW50OjpzdWdnZXN0ZWRGaWxlbmFtZSgpIGNvbnN0Cit7CisgICAg U3RyaW5nIGZpbGVOYW1lOworICAgIAorICAgIC8vIFdlIHRyeSB0byB1c2UgdGhlIHN1Z2dlc3Rl ZCBmaWxlbmFtZSBpbiB0aGUgaHR0cCBoZWFkZXIgZmlyc3QuCisgICAgQ2FjaGVkSW1hZ2UqIGNh Y2hlZEltYWdlID0gdGhpcy0+Y2FjaGVkSW1hZ2UoKTsKKyAgICBpZiAoY2FjaGVkSW1hZ2UgJiYg Y2FjaGVkSW1hZ2UtPmltYWdlKCkgJiYgY2FjaGVkSW1hZ2UtPmlzTG9hZGVkKCkpCisgICAgICAg IGZpbGVOYW1lID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsK KyAgICAKKyAgICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKSB7CisgICAgICAgIC8vIFRoZW4sIGlm IHRoZXJlJ3Mgbm9uZSwgd2UgdHJ5IHRvIGV4dHJhY3QgdGhlIGZpbGVuYW1lIGZyb20KKyAgICAg ICAgLy8gdGhlIGltYWdlIFVSTCBzdG9yZWQgaW4gdGhlIHNyYyBhdHRyaWJ1dGUuCisgICAgICAg IGZpbGVOYW1lID0gc3JjKCkubGFzdFBhdGhDb21wb25lbnQoKTsKKyAgICAgICAgLy8gSWYgdGhl cmUncyBub25lLCB3ZSB0aGVuIHRyeSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3RzLgorICAgICAg ICBpZiAoZmlsZU5hbWUuaXNFbXB0eSgpKQorICAgICAgICAgICAgZmlsZU5hbWUgPSBhbHRUZXh0 KCk7CisgICAgfQorICAgIAorICAgIC8vIFJlbW92ZSBsZWFkaW5nIG9yIHRyYWlsaW5nICcuJ3Mu CisgICAgd2hpbGUgKGZpbGVOYW1lLnN0YXJ0c1dpdGgoIi4iKSkKKyAgICAgICAgZmlsZU5hbWUu cmVtb3ZlKDAsIDEpOworICAgIHdoaWxlIChmaWxlTmFtZS5lbmRzV2l0aCgiLiIpKQorICAgICAg ICBmaWxlTmFtZS5yZW1vdmUoZmlsZU5hbWUubGVuZ3RoKCkgLSAxLCAxKTsKKyAgICAKKyAgICAv LyBXZSBjYW4ndCByZWx5IG9uIHRoZSBmaWxlbmFtZSBleHRlbnNpb24sIHNvIHdlIG11c3QgcmVt b3ZlIGl0CisgICAgLy8gYW5kIHVzZSB0aGUgb25lIHJlZ2lzdGVyZWQgd2l0aCB0aGUgTUlNRSB0 eXBlLgorICAgIGludCBleHRlbnNpb25faW5kZXggPSBmaWxlTmFtZS5yZXZlcnNlRmluZCgnLicp OworICAgIGlmIChleHRlbnNpb25faW5kZXggIT0gLTEpCisgICAgICAgIGZpbGVOYW1lLnRydW5j YXRlKGV4dGVuc2lvbl9pbmRleCk7CisgICAgaWYgKCFmaWxlTmFtZS5pc0VtcHR5KCkpIHsKKyAg ICAgICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6OmdldFByZWZlcnJlZEV4 dGVuc2lvbkZvck1JTUVUeXBlKGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLm1pbWVUeXBlKCkpOwor ICAgICAgICBmaWxlTmFtZSArPSAiLiI7CisgICAgICAgIGZpbGVOYW1lICs9IGV4dGVuc2lvbjsK KyAgICB9CisgICAgcmV0dXJuIGZpbGVOYW1lOworfQogCiB9CkluZGV4OiBXZWJDb3JlL2h0bWwv SFRNTEltYWdlRWxlbWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VF bGVtZW50LmgJKHJldmlzaW9uIDQ2ODk0KQorKysgV2ViQ29yZS9odG1sL0hUTUxJbWFnZUVsZW1l bnQuaAkod29ya2luZyBjb3B5KQpAQCAtMTE2LDYgKzExNiw4IEBAIHB1YmxpYzoKICAgICBib29s IGhhdmVGaXJlZExvYWRFdmVudCgpIGNvbnN0IHsgcmV0dXJuIG1faW1hZ2VMb2FkZXIuaGF2ZUZp cmVkTG9hZEV2ZW50KCk7IH0KIAogICAgIHZpcnR1YWwgdm9pZCBhZGRTdWJyZXNvdXJjZUF0dHJp YnV0ZVVSTHMoTGlzdEhhc2hTZXQ8S1VSTD4mKSBjb25zdDsKKyAgICAKKyAgICBTdHJpbmcgc3Vn Z2VzdGVkRmlsZW5hbWUoKSBjb25zdDsKIAogcHJpdmF0ZToKICAgICBIVE1MSW1hZ2VMb2FkZXIg bV9pbWFnZUxvYWRlcjsKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJk Q2hyb21pdW0uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xp cGJvYXJkQ2hyb21pdW0uY3BwCShyZXZpc2lvbiA0Njg5NCkKKysrIFdlYkNvcmUvcGxhdGZvcm0v Y2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNiw2ICsz Niw3IEBACiAjaW5jbHVkZSAiRmlsZUxpc3QuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1 ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNpbmNsdWRl ICJOYW1lZEF0dHJNYXAuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJlZ2lzdHJ5LmgiCiAjaW5jbHVk ZSAibWFya3VwLmgiCkBAIC0yMTYsOTkgKzIxNywzNSBAQCBEcmFnSW1hZ2VSZWYgQ2xpcGJvYXJk Q2hyb21pdW06OmNyZWF0ZURyCiAgICAgfQogICAgIHJldHVybiByZXN1bHQ7CiB9Ci0KLXN0YXRp YyBTdHJpbmcgaW1hZ2VUb01hcmt1cChjb25zdCBTdHJpbmcmIHVybCwgRWxlbWVudCogZWxlbWVu dCkKKyAgICAKK3N0YXRpYyB2b2lkIHNwbGl0RmlsZU5hbWUoY29uc3QgU3RyaW5nJiBmaWxlTmFt ZSwgU3RyaW5nJiBvdXRCYXNlTmFtZSwgU3RyaW5nJiBvdXRFeHRlbnNpb24pCiB7Ci0gICAgU3Ry aW5nQnVpbGRlciBtYXJrdXA7Ci0gICAgbWFya3VwLmFwcGVuZCgiPGltZyBzcmM9XCIiKTsKLSAg ICBtYXJrdXAuYXBwZW5kKHVybCk7Ci0gICAgbWFya3VwLmFwcGVuZCgiXCIiKTsKLSAgICAvLyBD b3B5IG92ZXIgYXR0cmlidXRlcy4gIElmIHdlIGFyZSBkcmFnZ2luZyBhbiBpbWFnZSwgd2UgZXhw ZWN0IHRoaW5ncyBsaWtlCi0gICAgLy8gdGhlIGlkIHRvIGJlIGNvcGllZCBhcyB3ZWxsLgotICAg IE5hbWVkTm9kZU1hcCogYXR0cnMgPSBlbGVtZW50LT5hdHRyaWJ1dGVzKCk7Ci0gICAgdW5zaWdu ZWQgbGVuZ3RoID0gYXR0cnMtPmxlbmd0aCgpOwotICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkg PCBsZW5ndGg7ICsraSkgewotICAgICAgICBBdHRyaWJ1dGUqIGF0dHIgPSBhdHRycy0+YXR0cmli dXRlSXRlbShpKTsKLSAgICAgICAgaWYgKGF0dHItPmxvY2FsTmFtZSgpID09ICJzcmMiKQotICAg ICAgICAgICAgY29udGludWU7Ci0gICAgICAgIG1hcmt1cC5hcHBlbmQoIiAiKTsKLSAgICAgICAg bWFya3VwLmFwcGVuZChhdHRyLT5sb2NhbE5hbWUoKSk7Ci0gICAgICAgIG1hcmt1cC5hcHBlbmQo Ij1cIiIpOwotICAgICAgICBTdHJpbmcgZXNjYXBlZEF0dHIgPSBhdHRyLT52YWx1ZSgpOwotICAg ICAgICBlc2NhcGVkQXR0ci5yZXBsYWNlKCJcIiIsICImcXVvdDsiKTsKLSAgICAgICAgbWFya3Vw LmFwcGVuZChlc2NhcGVkQXR0cik7Ci0gICAgICAgIG1hcmt1cC5hcHBlbmQoIlwiIik7CisgICAg aW50IGV4dGVuc2lvbkluZGV4ID0gZmlsZU5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICBpZiAo ZXh0ZW5zaW9uSW5kZXggIT0gLTEpIHsKKyAgICAgICAgb3V0QmFzZU5hbWUgPSBmaWxlTmFtZS5s ZWZ0KGV4dGVuc2lvbkluZGV4KTsKKyAgICAgICAgb3V0RXh0ZW5zaW9uID0gZmlsZU5hbWUuc3Vi c3RyaW5nKGV4dGVuc2lvbkluZGV4KTsKKyAgICB9IGVsc2UgeworICAgICAgICBvdXRCYXNlTmFt ZSA9IGZpbGVOYW1lOworICAgICAgICBvdXRFeHRlbnNpb24gPSAiIjsKICAgICB9Ci0KLSAgICBt YXJrdXAuYXBwZW5kKCIvPiIpOwotICAgIHJldHVybiBtYXJrdXAudG9TdHJpbmcoKTsKLX0KLQot c3RhdGljIENhY2hlZEltYWdlKiBnZXRDYWNoZWRJbWFnZShFbGVtZW50KiBlbGVtZW50KQotewot ICAgIC8vIEF0dGVtcHQgdG8gcHVsbCBDYWNoZWRJbWFnZSBmcm9tIGVsZW1lbnQKLSAgICBBU1NF UlQoZWxlbWVudCk7Ci0gICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGVsZW1lbnQtPnJlbmRl cmVyKCk7Ci0gICAgaWYgKCFyZW5kZXJlciB8fCAhcmVuZGVyZXItPmlzSW1hZ2UoKSkKLSAgICAg ICAgcmV0dXJuIDA7Ci0KLSAgICBSZW5kZXJJbWFnZSogaW1hZ2UgPSB0b1JlbmRlckltYWdlKHJl bmRlcmVyKTsKLSAgICBpZiAoaW1hZ2UtPmNhY2hlZEltYWdlKCkgJiYgIWltYWdlLT5jYWNoZWRJ bWFnZSgpLT5lcnJvck9jY3VycmVkKCkpCi0gICAgICAgIHJldHVybiBpbWFnZS0+Y2FjaGVkSW1h Z2UoKTsKLQotICAgIHJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRh T2JqZWN0KENocm9taXVtRGF0YU9iamVjdCogZGF0YU9iamVjdCwgRWxlbWVudCogZWxlbWVudCwK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgS1VSTCYgdXJsKQotewot ICAgIC8vIFNob3ZlIGltYWdlIGRhdGEgaW50byBhIERhdGFPYmplY3QgZm9yIHVzZSBhcyBhIGZp bGUKLSAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UgPSBnZXRDYWNoZWRJbWFnZShlbGVtZW50 KTsKLSAgICBpZiAoIWNhY2hlZEltYWdlIHx8ICFjYWNoZWRJbWFnZS0+aW1hZ2UoKSB8fCAhY2Fj aGVkSW1hZ2UtPmlzTG9hZGVkKCkpCi0gICAgICAgIHJldHVybjsKLQotICAgIFNoYXJlZEJ1ZmZl ciogaW1hZ2VCdWZmZXIgPSBjYWNoZWRJbWFnZS0+aW1hZ2UoKS0+ZGF0YSgpOwotICAgIGlmICgh aW1hZ2VCdWZmZXIgfHwgIWltYWdlQnVmZmVyLT5zaXplKCkpCi0gICAgICAgIHJldHVybjsKLQot ICAgIGRhdGFPYmplY3QtPmZpbGVDb250ZW50ID0gaW1hZ2VCdWZmZXI7Ci0KLSAgICAvLyBEZXRl cm1pbmUgdGhlIGZpbGVuYW1lIGZvciB0aGUgZmlsZSBjb250ZW50cyBvZiB0aGUgaW1hZ2UuICBX ZSB0cnkgdG8KLSAgICAvLyB1c2UgdGhlIGFsdCB0YWcgaWYgb25lIGV4aXN0cywgb3RoZXJ3aXNl IHdlIGZhbGwgYmFjayBvbiB0aGUgc3VnZ2VzdGVkCi0gICAgLy8gZmlsZW5hbWUgaW4gdGhlIGh0 dHAgaGVhZGVyLCBhbmQgZmluYWxseSB3ZSByZXNvcnQgdG8gdXNpbmcgdGhlIGZpbGVuYW1lCi0g ICAgLy8gaW4gdGhlIFVSTC4KLSAgICBTdHJpbmcgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3Ry eTo6Z2V0UHJlZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoCi0gICAgICAgIGNhY2hlZEltYWdl LT5yZXNwb25zZSgpLm1pbWVUeXBlKCkpOwotICAgIGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24g PSBleHRlbnNpb24uaXNFbXB0eSgpID8gIiIgOiAiLiIgKyBleHRlbnNpb247Ci0gICAgU3RyaW5n IHRpdGxlID0gZWxlbWVudC0+Z2V0QXR0cmlidXRlKGFsdEF0dHIpOwotICAgIGlmICh0aXRsZS5p c0VtcHR5KCkpCi0gICAgICAgIHRpdGxlID0gY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2Vz dGVkRmlsZW5hbWUoKTsKLQotICAgIHRpdGxlID0gQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRl RmlsZU5hbWUodGl0bGUsIGRhdGFPYmplY3QpOwotICAgIGRhdGFPYmplY3QtPmZpbGVDb250ZW50 RmlsZW5hbWUgPSB0aXRsZSArIGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb247Ci19Ci0KLXZvaWQg Q2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50KiBlbGVt ZW50LCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkK K3ZvaWQgQ2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShjb25zdCBL VVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgdGl0bGUsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgU2hhcmVkQnVmZmVyKiBpbWFnZUJ1ZmZlciwgY29uc3Qg U3RyaW5nJiBmaWxlTmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBjb25zdCBTdHJpbmcmIGh0bWxNYXJrdXApCiB7CiAgICAgaWYgKCFtX2RhdGFP YmplY3QpCiAgICAgICAgIHJldHVybjsKIAogICAgIG1fZGF0YU9iamVjdC0+dXJsID0gdXJsOwog ICAgIG1fZGF0YU9iamVjdC0+dXJsVGl0bGUgPSB0aXRsZTsKLQotICAgIC8vIFdyaXRlIHRoZSBi eXRlcyBpbiB0aGUgaW1hZ2UgdG8gdGhlIGZpbGUgZm9ybWF0LgotICAgIHdyaXRlSW1hZ2VUb0Rh dGFPYmplY3QobV9kYXRhT2JqZWN0LmdldCgpLCBlbGVtZW50LCB1cmwpOwotCi0gICAgQXRvbWlj U3RyaW5nIGltYWdlVVJMID0gZWxlbWVudC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOwotICAgIGlm IChpbWFnZVVSTC5pc0VtcHR5KCkpCi0gICAgICAgIHJldHVybjsKLQotICAgIFN0cmluZyBmdWxs VVJMID0gZnJhbWUtPmRvY3VtZW50KCktPmNvbXBsZXRlVVJMKGRlcHJlY2F0ZWRQYXJzZVVSTChp bWFnZVVSTCkpOwotICAgIGlmIChmdWxsVVJMLmlzRW1wdHkoKSkKLSAgICAgICAgcmV0dXJuOwot Ci0gICAgLy8gUHV0IGltZyB0YWcgb24gdGhlIGNsaXBib2FyZCByZWZlcmVuY2luZyB0aGUgaW1h Z2UKLSAgICBtX2RhdGFPYmplY3QtPnRleHRIdG1sID0gaW1hZ2VUb01hcmt1cChmdWxsVVJMLCBl bGVtZW50KTsKKyAgICBtX2RhdGFPYmplY3QtPmZpbGVDb250ZW50ID0gaW1hZ2VCdWZmZXI7Cisg ICAgbV9kYXRhT2JqZWN0LT50ZXh0SHRtbCA9IGh0bWxNYXJrdXA7CisgICAgCisgICAgU3RyaW5n IGJhc2VOYW1lOworICAgIHNwbGl0RmlsZU5hbWUoZmlsZU5hbWUsIGJhc2VOYW1lLG1fZGF0YU9i amVjdC0+ZmlsZUV4dGVuc2lvbik7CisgICAgYmFzZU5hbWUgPSBDbGlwYm9hcmRDaHJvbWl1bTo6 dmFsaWRhdGVGaWxlTmFtZShiYXNlTmFtZSxtX2RhdGFPYmplY3QuZ2V0KCkpOworICAgIG1fZGF0 YU9iamVjdC0+ZmlsZUNvbnRlbnRGaWxlbmFtZSA9IGJhc2VOYW1lICsgbV9kYXRhT2JqZWN0LT5m aWxlRXh0ZW5zaW9uOwogfQogCiB2b2lkIENsaXBib2FyZENocm9taXVtOjp3cml0ZVVSTChjb25z dCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKikKSW5kZXg6IFdlYkNvcmUv cGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmgJKHJldmlzaW9uIDQ2ODk0 KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5oCSh3b3Jr aW5nIGNvcHkpCkBAIC03MSwxNyArNzEsMjAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAg ICB9CiAKICAgICAgICAgdmlydHVhbCBEcmFnSW1hZ2VSZWYgY3JlYXRlRHJhZ0ltYWdlKEludFBv aW50JiBkcmFnTG9jKSBjb25zdDsKLSAgICAgICAgdmlydHVhbCB2b2lkIGRlY2xhcmVBbmRXcml0 ZURyYWdJbWFnZShFbGVtZW50KiwgY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZy YW1lKik7CiAgICAgICAgIHZpcnR1YWwgdm9pZCB3cml0ZVVSTChjb25zdCBLVVJMJiwgY29uc3Qg U3RyaW5nJiwgRnJhbWUqKTsKICAgICAgICAgdmlydHVhbCB2b2lkIHdyaXRlUmFuZ2UoUmFuZ2Uq LCBGcmFtZSopOwogCiAgICAgICAgIHZpcnR1YWwgYm9vbCBoYXNEYXRhKCk7Ci0KKyAgICAgICAg CiAgICAgcHJpdmF0ZToKICAgICAgICAgQ2xpcGJvYXJkQ2hyb21pdW0oYm9vbCwgUGFzc1JlZlB0 cjxDaHJvbWl1bURhdGFPYmplY3Q+LCBDbGlwYm9hcmRBY2Nlc3NQb2xpY3kpOwogCiAgICAgICAg IHZvaWQgcmVzZXRGcm9tQ2xpcGJvYXJkKCk7CiAgICAgICAgIHZvaWQgc2V0RHJhZ0ltYWdlKENh Y2hlZEltYWdlKiwgTm9kZSosIGNvbnN0IEludFBvaW50Jik7CisgICAgICAgIHZpcnR1YWwgdm9p ZCBkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgdGl0 bGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU2hhcmVk QnVmZmVyKiBpbWFnZUJ1ZmZlciwgY29uc3QgU3RyaW5nJiBmaWxlTmFtZSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBTdHJpbmcmIGh0bWxNYXJr dXApOworCiAgICAgICAgIFJlZlB0cjxDaHJvbWl1bURhdGFPYmplY3Q+IG1fZGF0YU9iamVjdDsK ICAgICB9OwogCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9t aXVtTWFjLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBi b2FyZENocm9taXVtTWFjLmNwcAkocmV2aXNpb24gNDY4OTQpCisrKyBXZWJDb3JlL3BsYXRmb3Jt L2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjgs MTQgKzI4LDQ2IEBACiAjaW5jbHVkZSAiQ2xpcGJvYXJkQ2hyb21pdW0uaCIKIAogI2luY2x1ZGUg IkNocm9taXVtRGF0YU9iamVjdC5oIgotI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKKworLy8gRmlsZW5hbWUgbGVuZ3RoIGFuZCBjaGFyYWN0 ZXItc2V0IGxpbWl0cyB2YXJ5IGJ5IGZpbGVzeXN0ZW0sIGFuZCB0aGVyZSdzIG5vCisvLyByZWFs IHdheSB0byB0ZWxsIHdoYXQgZmlsZXN5c3RlbSBpcyBpbiB1c2UuIFNpbmNlIEhGUysgaXMgYnkg ZmFyIHRoZSBtb3N0CisvLyBjb21tb24sIHdlJ2xsIGFiaWRlIGJ5IGl0cyBsaW1pdHMsIHdoaWNo IGFyZSAyNTUgVW5pY29kZSBjaGFyYWN0ZXJzIChzbGlnaHRseQorLy8gc2ltcGxpZmllZDsgcmVh bGx5IGl0IHVzZXMgTm9ybWFsaXphdGlvbiBGb3JtIEQsIGJ1dCB0aGUgZGlmZmVyZW5jZXMgYXJl bid0CisvLyByZWFsbHkgd29ydGggZGVhbGluZyB3aXRoIGhlcmUuKQorc3RhdGljIGNvbnN0IGlu dCBNYXhIRlNGaWxlbmFtZUxlbmd0aCA9IDI1NTsKKworCitzdGF0aWMgYm9vbCBpc0ludmFsaWRG aWxlQ2hhcmFjdGVyKFVDaGFyIGMpCit7CisgICAgLy8gSEZTKyBiYXNpY2FsbHkgYWxsb3dzIGFu eXRoaW5nIGJ1dCAnLycuIEZvciBzYW5pdHkncyBzYWtlIHdlJ2xsIGRpc2FsbG93CisgICAgLy8g Y29udHJvbCBjaGFyYWN0ZXJzLgorICAgIHJldHVybiBjIDwgJyAnIHx8IGMgPT0gMHg3RiB8fCBj ID09ICcvJzsKK30KIAogU3RyaW5nIENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1l KGNvbnN0IFN0cmluZyYgdGl0bGUsIENocm9taXVtRGF0YU9iamVjdCogZGF0YU9iamVjdCkKIHsK LSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiB0aXRsZTsKKyAgICAvLyBSZW1vdmUg YW55IGludmFsaWQgZmlsZSBzeXN0ZW0gY2hhcmFjdGVycywgZXNwZWNpYWxseSAiLyIuCisgICAg U3RyaW5nIHJlc3VsdCA9IHRpdGxlLnJlbW92ZUNoYXJhY3RlcnMoaXNJbnZhbGlkRmlsZUNoYXJh Y3Rlcik7CisgICAgU3RyaW5nIGV4dGVuc2lvbiA9IGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24u cmVtb3ZlQ2hhcmFjdGVycygmaXNJbnZhbGlkRmlsZUNoYXJhY3Rlcik7CisKKyAgICAvLyBMZWFk aW5nICIuInMgd291bGQgbWFrZSB0aGUgZmlsZSBpbnZpc2libGUgLS0gc3RyaXAgdGhlbS4KKyAg ICB3aGlsZSAocmVzdWx0LnN0YXJ0c1dpdGgoIi4iKSkKKyAgICAgICAgcmVzdWx0LnJlbW92ZSgw LDEpOworCisgICAgLy8gUmVtb3ZlIGEgcmlkaWN1bG91c2x5LWxvbmcgZXh0ZW5zaW9uLgorICAg IGlmIChleHRlbnNpb24ubGVuZ3RoKCkgPj0gTWF4SEZTRmlsZW5hbWVMZW5ndGgpCisgICAgICAg IGV4dGVuc2lvbiA9ICIiOworICAgIAorICAgIC8vIFRydW5jYXRlIGFuIG92ZXJseS1sb25nIGZp bGVuYW1lLgorICAgIGludCBvdmVyZmxvdyA9IHJlc3VsdC5sZW5ndGgoKSArIGV4dGVuc2lvbi5s ZW5ndGgoKSAtIE1heEhGU0ZpbGVuYW1lTGVuZ3RoOworICAgIGlmIChvdmVyZmxvdyA+IDApIAor ICAgICAgICByZXN1bHQucmVtb3ZlKHJlc3VsdC5sZW5ndGgoKSAtIG92ZXJmbG93LCBvdmVyZmxv dyk7CisgICAgCisgICAgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbiA9IGV4dGVuc2lvbjsKKyAg ICByZXR1cm4gcmVzdWx0OwogfQogCiB9ICAvLyBuYW1lc3BhY2UgV2ViQ29yZQo= 34318 2009-08-07 13:28:02 -0700 2011-05-27 15:46:34 -0700 patch imageFilename3.patch text/plain 16738 jens SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0Njg5NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMDktMDgtMDcgIEplbnMgQWxma2UgIDxzbmVqQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBCdWcg MjQ4ODcgLSBXcm9uZyBmaWxlbmFtZSB3aGVuIGRyYWdnaW5nIGFuIGltYWdlIHRvIHRoZSBEZXNr dG9wLgorICAgICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI0ODg3CisgICAgICAgIEFkZHMgZnVuY3Rpb25hbGl0eSB0byBIVE1MSW1hZ2VFbGVtZW50IHRv IGRldGVybWluZSB0aGUgZmlsZW5hbWUgdG8gdXNlLgorICAgICAgICBNb2RpZmllcyBDbGlwYm9h cmRDaHJvbWl1bSB0byB1c2UgaXQgd2hlbiBzZXR0aW5nIHVwIHRoZSBkcmFnLgorICAgICAgICBJ bXBsZW1lbnRzIHZhbGlkYXRlRmlsZU5hbWUgZm9yIE1hYyBDaHJvbWl1bSAobGltaXRzIG5hbWUg dG8gMjU1IFVURi04IGJ5dGVzLikKKworICAgICAgICBObyB0ZXN0czsgd291bGQgYmUgdW5yZWFz b25hYmx5IGRpZmZpY3VsdCB0byBhZGQgdGhlIHBsdW1iaW5nIHRvIGFjY2VzcyB0aGUgcHJvcG9z ZWQKKyAgICAgICAgZmlsZW5hbWUgZnJvbSB3aXRoaW4gRFJULgorCisgICAgICAgICogaHRtbC9I VE1MSW1hZ2VFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbWFnZUVsZW1lbnQ6 OnN1Z2dlc3RlZEZpbGVuYW1lKToKKyAgICAgICAgKiBodG1sL0hUTUxJbWFnZUVsZW1lbnQuaDoK KyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpDbGlwYm9hcmRDaHJvbWl1bTo6d3JpdGVJbWFnZVRvRGF0YU9iamVjdCk6 CisgICAgICAgIChXZWJDb3JlOjpDbGlwYm9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJh Z0ltYWdlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5o OgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OmlzSW52YWxpZEZpbGVDaGFyYWN0ZXIpOgorICAgICAgICAoV2Vi Q29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUpOgorCiAyMDA5LTA4LTA1 ICBEaW1pdHJpIEdsYXprb3YgIDxkZ2xhemtvdkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5y ZXZpZXdlZCwgYnVpbGQgZml4LgpJbmRleDogV2ViQ29yZS9kb20vQ2xpcGJvYXJkLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL2RvbS9DbGlwYm9hcmQuY3BwCShyZXZpc2lvbiA0Njg5NCkKKysr IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMwLDkgKzMwLDE1 IEBACiAjaW5jbHVkZSAiRE9NSW1wbGVtZW50YXRpb24uaCIKICNpbmNsdWRlICJGcmFtZS5oIgog I2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgor I2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiUmVu ZGVySW1hZ2UuaCIKKyNpbmNsdWRlICJTdHJpbmdCdWlsZGVyLmgiCiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKKyAgICAKK3VzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CiAKIENsaXBib2FyZDo6Q2xp cGJvYXJkKENsaXBib2FyZEFjY2Vzc1BvbGljeSBwb2xpY3ksIGJvb2wgaXNGb3JEcmFnZ2luZykg CiAgICAgOiBtX3BvbGljeShwb2xpY3kpIApAQCAtMTM5LDUgKzE0NSw4NSBAQCB2b2lkIENsaXBi b2FyZDo6c2V0RWZmZWN0QWxsb3dlZChjb25zdCBTCiAgICAgaWYgKG1fcG9saWN5ID09IENsaXBi b2FyZFdyaXRhYmxlKQogICAgICAgICBtX2VmZmVjdEFsbG93ZWQgPSBlZmZlY3Q7CiB9CisgICAg CitzdGF0aWMgQ2FjaGVkSW1hZ2UqIGNhY2hlZEltYWdlT2ZOb2RlKE5vZGUqIG5vZGUpCit7Cisg ICAgQVNTRVJUKG5vZGUpOworICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBub2RlLT5yZW5k ZXJlcigpOworICAgIGlmICghcmVuZGVyZXIgfHwgIXJlbmRlcmVyLT5pc0ltYWdlKCkpCisgICAg ICAgIHJldHVybiAwOworICAgIAorICAgIFJlbmRlckltYWdlKiBpbWFnZSA9IHRvUmVuZGVySW1h Z2UocmVuZGVyZXIpOworICAgIGlmICghaW1hZ2UtPmNhY2hlZEltYWdlKCkgfHwgaW1hZ2UtPmNh Y2hlZEltYWdlKCktPmVycm9yT2NjdXJyZWQoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgCisg ICAgcmV0dXJuIGltYWdlLT5jYWNoZWRJbWFnZSgpOworfQorICAgIAorc3RhdGljIHZvaWQgYXBw ZW5kQXR0cmlidXRlKFN0cmluZ0J1aWxkZXImIG1hcmt1cCwgY29uc3QgU3RyaW5nJiBuYW1lLCBT dHJpbmcgdmFsdWUpCit7CisgICAgdmFsdWUucmVwbGFjZSgnJicsICImYW1wOyIpOworICAgIHZh bHVlLnJlcGxhY2UoJyInLCAiJnF1b3Q7Iik7CisgICAgbWFya3VwLmFwcGVuZCgnICcpOworICAg IG1hcmt1cC5hcHBlbmQobmFtZSk7CisgICAgbWFya3VwLmFwcGVuZCgiPVwiIik7CisgICAgbWFy a3VwLmFwcGVuZCh2YWx1ZSk7CisgICAgbWFya3VwLmFwcGVuZCgnIicpOworfQorCitzdGF0aWMg U3RyaW5nIGltYWdlVG9NYXJrdXAoRWxlbWVudCogZWxlbWVudCwgRnJhbWUqIGZyYW1lKQorewor ICAgIFN0cmluZyBzcmNVUkw7CisgICAgY29uc3QgQXRvbWljU3RyaW5nJiBpbWFnZVVSTCA9IGVs ZW1lbnQtPmdldEF0dHJpYnV0ZShzcmNBdHRyKTsKKyAgICBpZiAoIWltYWdlVVJMLmlzRW1wdHko KSkKKyAgICAgICAgc3JjVVJMID0gZnJhbWUtPmRvY3VtZW50KCktPmNvbXBsZXRlVVJMKGRlcHJl Y2F0ZWRQYXJzZVVSTChpbWFnZVVSTCkpOworICAgIAorICAgIFN0cmluZ0J1aWxkZXIgbWFya3Vw OworICAgIG1hcmt1cC5hcHBlbmQoIjxpbWciKTsKKyAgICBhcHBlbmRBdHRyaWJ1dGUobWFya3Vw LCBzcmNBdHRyLmxvY2FsTmFtZSgpLCBzcmNVUkwpOworCisgICAgLy8gQ29weSBvdmVyIGF0dHJp YnV0ZXMuICBJZiB3ZSBhcmUgZHJhZ2dpbmcgYW4gaW1hZ2UsIHdlIGV4cGVjdCB0aGluZ3MgbGlr ZQorICAgIC8vIHRoZSBpZCB0byBiZSBjb3BpZWQgYXMgd2VsbC4KKyAgICBOYW1lZE5vZGVNYXAq IGF0dHJzID0gZWxlbWVudC0+YXR0cmlidXRlcygpOworICAgIHVuc2lnbmVkIGxlbmd0aCA9IGF0 dHJzLT5sZW5ndGgoKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbGVuZ3RoOyArK2kp IHsKKyAgICAgICAgQXR0cmlidXRlKiBhdHRyID0gYXR0cnMtPmF0dHJpYnV0ZUl0ZW0oaSk7Cisg ICAgICAgIGlmIChhdHRyLT5uYW1lKCkgIT0gc3JjQXR0cikKKyAgICAgICAgICAgIGFwcGVuZEF0 dHJpYnV0ZShtYXJrdXAsIGF0dHItPmxvY2FsTmFtZSgpLCBhdHRyLT52YWx1ZSgpKTsKKyAgICB9 CisgICAgCisgICAgbWFya3VwLmFwcGVuZCgnPicpOworICAgIHJldHVybiBtYXJrdXAudG9TdHJp bmcoKTsKK30KKwordm9pZCBDbGlwYm9hcmQ6OmRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVt ZW50KiBlbGVtZW50LCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1l KiBmcmFtZSkKK3sKKyAgICAvLyBHZXQgdGhlIGltYWdlIGRhdGEgKHJldHVybiBlYXJseSBpZiB0 aGVyZSBpcyBub25lKS4KKyAgICBTaGFyZWRCdWZmZXIqIGltYWdlQnVmZmVyID0gMDsKKyAgICBD YWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UgPSBjYWNoZWRJbWFnZU9mTm9kZShlbGVtZW50KTsKKyAg ICBpZiAoY2FjaGVkSW1hZ2UgJiYgY2FjaGVkSW1hZ2UtPmltYWdlKCkgJiYgY2FjaGVkSW1hZ2Ut PmlzTG9hZGVkKCkpCisgICAgICAgIGltYWdlQnVmZmVyID0gY2FjaGVkSW1hZ2UtPmltYWdlKCkt PmRhdGEoKTsKKyAgICBpZiAoIWltYWdlQnVmZmVyIHx8ICFpbWFnZUJ1ZmZlci0+c2l6ZSgpKQor ICAgICAgICByZXR1cm47CisgICAgCisgICAgLy8gR2V0IHRoZSBmaWxlbmFtZSB0byB1c2UuCisg ICAgU3RyaW5nIGZpbGVOYW1lOworICAgIGlmIChlbGVtZW50LT5oYXNUYWdOYW1lKGltZ1RhZykp CisgICAgICAgIGZpbGVOYW1lID0gc3RhdGljX2Nhc3Q8SFRNTEltYWdlRWxlbWVudCo+KGVsZW1l bnQpLT5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIAorICAgIC8vIENyZWF0ZSBIVE1MIDxpbWc+ IG1hcmt1cDoKKyAgICBTdHJpbmcgaHRtbE1hcmt1cCA9IGltYWdlVG9NYXJrdXAoZWxlbWVudCwg ZnJhbWUpOworICAgIAorICAgIC8vIE5vdyBjYWxsIHRoZSBhYnN0cmFjdCBmdWxseS1zcGVjaWZp ZWQgdmVyc2lvbiBvZiB0aGlzIG1ldGhvZC4KKyAgICBkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2Uo dXJsLCB0aXRsZSwgaW1hZ2VCdWZmZXIsIGZpbGVOYW1lLCBodG1sTWFya3VwKTsKK30KKyAgICAK K3ZvaWQgQ2xpcGJvYXJkOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoY29uc3QgS1VSTCYsIGNv bnN0IFN0cmluZyYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNo YXJlZEJ1ZmZlciosIGNvbnN0IFN0cmluZyYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYpCit7CisgICAgLy8gVGhpcyBtZXRob2QgaXMgYWJz dHJhY3Q7IGEgc3ViY2xhc3MgbXVzdCBvdmVycmlkZSBpdCwgb3IgdGhlIHB1YmxpYyB2ZXJzaW9u IHRoYXQgY2FsbHMgaXQuCisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Cit9CiAKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvZG9tL0NsaXBib2FyZC5oCShyZXZpc2lvbiA0Njg5NCkKKysrIFdlYkNvcmUv ZG9tL0NsaXBib2FyZC5oCSh3b3JraW5nIGNvcHkpCkBAIC02NCw3ICs2NCw3IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCB2b2lkIHNldERyYWdJbWFnZUVsZW1lbnQoTm9k ZSosIGNvbnN0IEludFBvaW50JikgPSAwOwogICAgICAgICAKICAgICAgICAgdmlydHVhbCBEcmFn SW1hZ2VSZWYgY3JlYXRlRHJhZ0ltYWdlKEludFBvaW50JiBkcmFnTG9jYXRpb24pIGNvbnN0ID0g MDsKLSAgICAgICAgdmlydHVhbCB2b2lkIGRlY2xhcmVBbmRXcml0ZURyYWdJbWFnZShFbGVtZW50 KiwgY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgdGl0bGUsIEZyYW1lKikgPSAwOworICAgICAg ICB2aXJ0dWFsIHZvaWQgZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1lbnQqLCBjb25zdCBL VVJMJiwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqKTsKICAgICAgICAgdmlydHVhbCB2b2lk IHdyaXRlVVJMKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmLCBGcmFtZSopID0gMDsKICAgICAg ICAgdmlydHVhbCB2b2lkIHdyaXRlUmFuZ2UoUmFuZ2UqLCBGcmFtZSopID0gMDsKIApAQCAtODUs NiArODUsMTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAgICBDbGlwYm9hcmRBY2Nlc3NQ b2xpY3kgcG9saWN5KCkgY29uc3QgeyByZXR1cm4gbV9wb2xpY3k7IH0KICAgICAgICAgYm9vbCBk cmFnU3RhcnRlZCgpIGNvbnN0IHsgcmV0dXJuIG1fZHJhZ1N0YXJ0ZWQ7IH0KICAgICAgICAgCisg ICAgICAgIHZpcnR1YWwgdm9pZCBkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoY29uc3QgS1VSTCYg dXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFNoYXJlZEJ1ZmZlciogaW1hZ2VCdWZmZXIsIGNvbnN0IFN0cmluZyYg ZmlsZU5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y29uc3QgU3RyaW5nJiBtYXJrdXApOworICAgICAgICAKICAgICBwcml2YXRlOgogICAgICAgICBD bGlwYm9hcmRBY2Nlc3NQb2xpY3kgbV9wb2xpY3k7CiAgICAgICAgIFN0cmluZyBtX2Ryb3BFZmZl Y3Q7CkluZGV4OiBXZWJDb3JlL2h0bWwvSFRNTEltYWdlRWxlbWVudC5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9odG1sL0hUTUxJbWFnZUVsZW1lbnQuY3BwCShyZXZpc2lvbiA0Njg5NCkKKysr IFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VFbGVtZW50LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzAs NiArMzAsNyBAQAogI2luY2x1ZGUgIkhUTUxEb2N1bWVudC5oIgogI2luY2x1ZGUgIkhUTUxGb3Jt RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUgIk1JTUVUeXBlUmVn aXN0cnkuaCIKICNpbmNsdWRlICJNYXBwZWRBdHRyaWJ1dGUuaCIKICNpbmNsdWRlICJSZW5kZXJJ bWFnZS5oIgogI2luY2x1ZGUgIlNjcmlwdEV2ZW50TGlzdGVuZXIuaCIKQEAgLTQ0MSw1ICs0NDIs NDIgQEAgdm9pZCBIVE1MSW1hZ2VFbGVtZW50OjphZGRTdWJyZXNvdXJjZUF0dAogICAgIGFkZFN1 YnJlc291cmNlVVJMKHVybHMsIHNyYygpKTsKICAgICBhZGRTdWJyZXNvdXJjZVVSTCh1cmxzLCBk b2N1bWVudCgpLT5jb21wbGV0ZVVSTCh1c2VNYXAoKSkpOwogfQorICAgIAorU3RyaW5nIEhUTUxJ bWFnZUVsZW1lbnQ6OnN1Z2dlc3RlZEZpbGVuYW1lKCkgY29uc3QKK3sKKyAgICBTdHJpbmcgZmls ZU5hbWU7CisgICAgCisgICAgLy8gV2UgdHJ5IHRvIHVzZSB0aGUgc3VnZ2VzdGVkIGZpbGVuYW1l IGluIHRoZSBodHRwIGhlYWRlciBmaXJzdC4KKyAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2Ug PSB0aGlzLT5jYWNoZWRJbWFnZSgpOworICAgIGlmIChjYWNoZWRJbWFnZSAmJiBjYWNoZWRJbWFn ZS0+aW1hZ2UoKSAmJiBjYWNoZWRJbWFnZS0+aXNMb2FkZWQoKSkKKyAgICAgICAgZmlsZU5hbWUg PSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIAorICAg IGlmIChmaWxlTmFtZS5pc0VtcHR5KCkpIHsKKyAgICAgICAgLy8gVGhlbiwgaWYgdGhlcmUncyBu b25lLCB3ZSB0cnkgdG8gZXh0cmFjdCB0aGUgZmlsZW5hbWUgZnJvbQorICAgICAgICAvLyB0aGUg aW1hZ2UgVVJMIHN0b3JlZCBpbiB0aGUgc3JjIGF0dHJpYnV0ZS4KKyAgICAgICAgZmlsZU5hbWUg PSBzcmMoKS5sYXN0UGF0aENvbXBvbmVudCgpOworICAgICAgICAvLyBJZiB0aGVyZSdzIG5vbmUs IHdlIHRoZW4gdHJ5IHRoZSBhbHQgdGFnIGlmIG9uZSBleGlzdHMuCisgICAgICAgIGlmIChmaWxl TmFtZS5pc0VtcHR5KCkpCisgICAgICAgICAgICBmaWxlTmFtZSA9IGFsdFRleHQoKTsKKyAgICB9 CisgICAgCisgICAgLy8gUmVtb3ZlIGxlYWRpbmcgb3IgdHJhaWxpbmcgJy4ncy4KKyAgICB3aGls ZSAoZmlsZU5hbWUuc3RhcnRzV2l0aCgiLiIpKQorICAgICAgICBmaWxlTmFtZS5yZW1vdmUoMCwg MSk7CisgICAgd2hpbGUgKGZpbGVOYW1lLmVuZHNXaXRoKCIuIikpCisgICAgICAgIGZpbGVOYW1l LnJlbW92ZShmaWxlTmFtZS5sZW5ndGgoKSAtIDEsIDEpOworICAgIAorICAgIC8vIFdlIGNhbid0 IHJlbHkgb24gdGhlIGZpbGVuYW1lIGV4dGVuc2lvbiwgc28gd2UgbXVzdCByZW1vdmUgaXQKKyAg ICAvLyBhbmQgdXNlIHRoZSBvbmUgcmVnaXN0ZXJlZCB3aXRoIHRoZSBNSU1FIHR5cGUuCisgICAg aW50IGV4dGVuc2lvbl9pbmRleCA9IGZpbGVOYW1lLnJldmVyc2VGaW5kKCcuJyk7CisgICAgaWYg KGV4dGVuc2lvbl9pbmRleCAhPSAtMSkKKyAgICAgICAgZmlsZU5hbWUudHJ1bmNhdGUoZXh0ZW5z aW9uX2luZGV4KTsKKyAgICBpZiAoIWZpbGVOYW1lLmlzRW1wdHkoKSkgeworICAgICAgICBTdHJp bmcgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3RyeTo6Z2V0UHJlZmVycmVkRXh0ZW5zaW9uRm9y TUlNRVR5cGUoY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWltZVR5cGUoKSk7CisgICAgICAgIGZp bGVOYW1lICs9ICIuIjsKKyAgICAgICAgZmlsZU5hbWUgKz0gZXh0ZW5zaW9uOworICAgIH0KKyAg ICByZXR1cm4gZmlsZU5hbWU7Cit9CiAKIH0KSW5kZXg6IFdlYkNvcmUvaHRtbC9IVE1MSW1hZ2VF bGVtZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxJbWFnZUVsZW1lbnQuaAko cmV2aXNpb24gNDY4OTQpCisrKyBXZWJDb3JlL2h0bWwvSFRNTEltYWdlRWxlbWVudC5oCSh3b3Jr aW5nIGNvcHkpCkBAIC0xMTYsNiArMTE2LDggQEAgcHVibGljOgogICAgIGJvb2wgaGF2ZUZpcmVk TG9hZEV2ZW50KCkgY29uc3QgeyByZXR1cm4gbV9pbWFnZUxvYWRlci5oYXZlRmlyZWRMb2FkRXZl bnQoKTsgfQogCiAgICAgdmlydHVhbCB2b2lkIGFkZFN1YnJlc291cmNlQXR0cmlidXRlVVJMcyhM aXN0SGFzaFNldDxLVVJMPiYpIGNvbnN0OworICAgIAorICAgIFN0cmluZyBzdWdnZXN0ZWRGaWxl bmFtZSgpIGNvbnN0OwogCiBwcml2YXRlOgogICAgIEhUTUxJbWFnZUxvYWRlciBtX2ltYWdlTG9h ZGVyOwpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJv bWl1bS5jcHAJKHJldmlzaW9uIDQ2ODk0KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9D bGlwYm9hcmRDaHJvbWl1bS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM2LDYgKzM2LDcgQEAKICNp bmNsdWRlICJGaWxlTGlzdC5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiSFRNTE5h bWVzLmgiCisjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgogI2luY2x1ZGUgIk5hbWVkQXR0 ck1hcC5oIgogI2luY2x1ZGUgIk1JTUVUeXBlUmVnaXN0cnkuaCIKICNpbmNsdWRlICJtYXJrdXAu aCIKQEAgLTIxNiw5OSArMjE3LDM1IEBAIERyYWdJbWFnZVJlZiBDbGlwYm9hcmRDaHJvbWl1bTo6 Y3JlYXRlRHIKICAgICB9CiAgICAgcmV0dXJuIHJlc3VsdDsKIH0KLQotc3RhdGljIFN0cmluZyBp bWFnZVRvTWFya3VwKGNvbnN0IFN0cmluZyYgdXJsLCBFbGVtZW50KiBlbGVtZW50KQorICAgIAor c3RhdGljIHZvaWQgc3BsaXRGaWxlTmFtZShjb25zdCBTdHJpbmcmIGZpbGVOYW1lLCBTdHJpbmcm IG91dEJhc2VOYW1lLCBTdHJpbmcmIG91dEV4dGVuc2lvbikKIHsKLSAgICBTdHJpbmdCdWlsZGVy IG1hcmt1cDsKLSAgICBtYXJrdXAuYXBwZW5kKCI8aW1nIHNyYz1cIiIpOwotICAgIG1hcmt1cC5h cHBlbmQodXJsKTsKLSAgICBtYXJrdXAuYXBwZW5kKCJcIiIpOwotICAgIC8vIENvcHkgb3ZlciBh dHRyaWJ1dGVzLiAgSWYgd2UgYXJlIGRyYWdnaW5nIGFuIGltYWdlLCB3ZSBleHBlY3QgdGhpbmdz IGxpa2UKLSAgICAvLyB0aGUgaWQgdG8gYmUgY29waWVkIGFzIHdlbGwuCi0gICAgTmFtZWROb2Rl TWFwKiBhdHRycyA9IGVsZW1lbnQtPmF0dHJpYnV0ZXMoKTsKLSAgICB1bnNpZ25lZCBsZW5ndGgg PSBhdHRycy0+bGVuZ3RoKCk7Ci0gICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGxlbmd0aDsg KytpKSB7Ci0gICAgICAgIEF0dHJpYnV0ZSogYXR0ciA9IGF0dHJzLT5hdHRyaWJ1dGVJdGVtKGkp OwotICAgICAgICBpZiAoYXR0ci0+bG9jYWxOYW1lKCkgPT0gInNyYyIpCi0gICAgICAgICAgICBj b250aW51ZTsKLSAgICAgICAgbWFya3VwLmFwcGVuZCgiICIpOwotICAgICAgICBtYXJrdXAuYXBw ZW5kKGF0dHItPmxvY2FsTmFtZSgpKTsKLSAgICAgICAgbWFya3VwLmFwcGVuZCgiPVwiIik7Ci0g ICAgICAgIFN0cmluZyBlc2NhcGVkQXR0ciA9IGF0dHItPnZhbHVlKCk7Ci0gICAgICAgIGVzY2Fw ZWRBdHRyLnJlcGxhY2UoIlwiIiwgIiZxdW90OyIpOwotICAgICAgICBtYXJrdXAuYXBwZW5kKGVz Y2FwZWRBdHRyKTsKLSAgICAgICAgbWFya3VwLmFwcGVuZCgiXCIiKTsKKyAgICBpbnQgZXh0ZW5z aW9uSW5kZXggPSBmaWxlTmFtZS5yZXZlcnNlRmluZCgnLicpOworICAgIGlmIChleHRlbnNpb25J bmRleCAhPSAtMSkgeworICAgICAgICBvdXRCYXNlTmFtZSA9IGZpbGVOYW1lLmxlZnQoZXh0ZW5z aW9uSW5kZXgpOworICAgICAgICBvdXRFeHRlbnNpb24gPSBmaWxlTmFtZS5zdWJzdHJpbmcoZXh0 ZW5zaW9uSW5kZXgpOworICAgIH0gZWxzZSB7CisgICAgICAgIG91dEJhc2VOYW1lID0gZmlsZU5h bWU7CisgICAgICAgIG91dEV4dGVuc2lvbiA9ICIiOwogICAgIH0KLQotICAgIG1hcmt1cC5hcHBl bmQoIi8+Iik7Ci0gICAgcmV0dXJuIG1hcmt1cC50b1N0cmluZygpOwotfQotCi1zdGF0aWMgQ2Fj aGVkSW1hZ2UqIGdldENhY2hlZEltYWdlKEVsZW1lbnQqIGVsZW1lbnQpCi17Ci0gICAgLy8gQXR0 ZW1wdCB0byBwdWxsIENhY2hlZEltYWdlIGZyb20gZWxlbWVudAotICAgIEFTU0VSVChlbGVtZW50 KTsKLSAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gZWxlbWVudC0+cmVuZGVyZXIoKTsKLSAg ICBpZiAoIXJlbmRlcmVyIHx8ICFyZW5kZXJlci0+aXNJbWFnZSgpKQotICAgICAgICByZXR1cm4g MDsKLQotICAgIFJlbmRlckltYWdlKiBpbWFnZSA9IHRvUmVuZGVySW1hZ2UocmVuZGVyZXIpOwot ICAgIGlmIChpbWFnZS0+Y2FjaGVkSW1hZ2UoKSAmJiAhaW1hZ2UtPmNhY2hlZEltYWdlKCktPmVy cm9yT2NjdXJyZWQoKSkKLSAgICAgICAgcmV0dXJuIGltYWdlLT5jYWNoZWRJbWFnZSgpOwotCi0g ICAgcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIHdyaXRlSW1hZ2VUb0RhdGFPYmplY3QoQ2hy b21pdW1EYXRhT2JqZWN0KiBkYXRhT2JqZWN0LCBFbGVtZW50KiBlbGVtZW50LAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBLVVJMJiB1cmwpCi17Ci0gICAgLy8gU2hv dmUgaW1hZ2UgZGF0YSBpbnRvIGEgRGF0YU9iamVjdCBmb3IgdXNlIGFzIGEgZmlsZQotICAgIENh Y2hlZEltYWdlKiBjYWNoZWRJbWFnZSA9IGdldENhY2hlZEltYWdlKGVsZW1lbnQpOwotICAgIGlm ICghY2FjaGVkSW1hZ2UgfHwgIWNhY2hlZEltYWdlLT5pbWFnZSgpIHx8ICFjYWNoZWRJbWFnZS0+ aXNMb2FkZWQoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgU2hhcmVkQnVmZmVyKiBpbWFnZUJ1 ZmZlciA9IGNhY2hlZEltYWdlLT5pbWFnZSgpLT5kYXRhKCk7Ci0gICAgaWYgKCFpbWFnZUJ1ZmZl ciB8fCAhaW1hZ2VCdWZmZXItPnNpemUoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgZGF0YU9i amVjdC0+ZmlsZUNvbnRlbnQgPSBpbWFnZUJ1ZmZlcjsKLQotICAgIC8vIERldGVybWluZSB0aGUg ZmlsZW5hbWUgZm9yIHRoZSBmaWxlIGNvbnRlbnRzIG9mIHRoZSBpbWFnZS4gIFdlIHRyeSB0bwot ICAgIC8vIHVzZSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3RzLCBvdGhlcndpc2Ugd2UgZmFsbCBi YWNrIG9uIHRoZSBzdWdnZXN0ZWQKLSAgICAvLyBmaWxlbmFtZSBpbiB0aGUgaHR0cCBoZWFkZXIs IGFuZCBmaW5hbGx5IHdlIHJlc29ydCB0byB1c2luZyB0aGUgZmlsZW5hbWUKLSAgICAvLyBpbiB0 aGUgVVJMLgotICAgIFN0cmluZyBleHRlbnNpb24gPSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVm ZXJyZWRFeHRlbnNpb25Gb3JNSU1FVHlwZSgKLSAgICAgICAgY2FjaGVkSW1hZ2UtPnJlc3BvbnNl KCkubWltZVR5cGUoKSk7Ci0gICAgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbiA9IGV4dGVuc2lv bi5pc0VtcHR5KCkgPyAiIiA6ICIuIiArIGV4dGVuc2lvbjsKLSAgICBTdHJpbmcgdGl0bGUgPSBl bGVtZW50LT5nZXRBdHRyaWJ1dGUoYWx0QXR0cik7Ci0gICAgaWYgKHRpdGxlLmlzRW1wdHkoKSkK LSAgICAgICAgdGl0bGUgPSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFt ZSgpOwotCi0gICAgdGl0bGUgPSBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFtZSh0 aXRsZSwgZGF0YU9iamVjdCk7Ci0gICAgZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnRGaWxlbmFtZSA9 IHRpdGxlICsgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbjsKLX0KLQotdm9pZCBDbGlwYm9hcmRD aHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1lbnQqIGVsZW1lbnQsIGNvbnN0 IEtVUkwmIHVybCwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqIGZyYW1lKQordm9pZCBDbGlw Ym9hcmRDaHJvbWl1bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKGNvbnN0IEtVUkwmIHVybCwg Y29uc3QgU3RyaW5nJiB0aXRsZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBTaGFyZWRCdWZmZXIqIGltYWdlQnVmZmVyLCBjb25zdCBTdHJpbmcmIGZp bGVOYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGNvbnN0IFN0cmluZyYgaHRtbE1hcmt1cCkKIHsKICAgICBpZiAoIW1fZGF0YU9iamVjdCkKICAg ICAgICAgcmV0dXJuOwogCiAgICAgbV9kYXRhT2JqZWN0LT51cmwgPSB1cmw7CiAgICAgbV9kYXRh T2JqZWN0LT51cmxUaXRsZSA9IHRpdGxlOwotCi0gICAgLy8gV3JpdGUgdGhlIGJ5dGVzIGluIHRo ZSBpbWFnZSB0byB0aGUgZmlsZSBmb3JtYXQuCi0gICAgd3JpdGVJbWFnZVRvRGF0YU9iamVjdCht X2RhdGFPYmplY3QuZ2V0KCksIGVsZW1lbnQsIHVybCk7Ci0KLSAgICBBdG9taWNTdHJpbmcgaW1h Z2VVUkwgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7Ci0gICAgaWYgKGltYWdlVVJM LmlzRW1wdHkoKSkKLSAgICAgICAgcmV0dXJuOwotCi0gICAgU3RyaW5nIGZ1bGxVUkwgPSBmcmFt ZS0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoZGVwcmVjYXRlZFBhcnNlVVJMKGltYWdlVVJMKSk7 Ci0gICAgaWYgKGZ1bGxVUkwuaXNFbXB0eSgpKQotICAgICAgICByZXR1cm47Ci0KLSAgICAvLyBQ dXQgaW1nIHRhZyBvbiB0aGUgY2xpcGJvYXJkIHJlZmVyZW5jaW5nIHRoZSBpbWFnZQotICAgIG1f ZGF0YU9iamVjdC0+dGV4dEh0bWwgPSBpbWFnZVRvTWFya3VwKGZ1bGxVUkwsIGVsZW1lbnQpOwor ICAgIG1fZGF0YU9iamVjdC0+ZmlsZUNvbnRlbnQgPSBpbWFnZUJ1ZmZlcjsKKyAgICBtX2RhdGFP YmplY3QtPnRleHRIdG1sID0gaHRtbE1hcmt1cDsKKyAgICAKKyAgICBTdHJpbmcgYmFzZU5hbWU7 CisgICAgc3BsaXRGaWxlTmFtZShmaWxlTmFtZSwgYmFzZU5hbWUsbV9kYXRhT2JqZWN0LT5maWxl RXh0ZW5zaW9uKTsKKyAgICBiYXNlTmFtZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0ZUZp bGVOYW1lKGJhc2VOYW1lLG1fZGF0YU9iamVjdC5nZXQoKSk7CisgICAgbV9kYXRhT2JqZWN0LT5m aWxlQ29udGVudEZpbGVuYW1lID0gYmFzZU5hbWUgKyBtX2RhdGFPYmplY3QtPmZpbGVFeHRlbnNp b247CiB9CiAKIHZvaWQgQ2xpcGJvYXJkQ2hyb21pdW06OndyaXRlVVJMKGNvbnN0IEtVUkwmIHVy bCwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqKQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9j aHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZv cm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uaAkocmV2aXNpb24gNDY4OTQpCisrKyBXZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmgJKHdvcmtpbmcgY29weSkK QEAgLTcxLDE3ICs3MSwyMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIH0KIAogICAg ICAgICB2aXJ0dWFsIERyYWdJbWFnZVJlZiBjcmVhdGVEcmFnSW1hZ2UoSW50UG9pbnQmIGRyYWdM b2MpIGNvbnN0OwotICAgICAgICB2aXJ0dWFsIHZvaWQgZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdl KEVsZW1lbnQqLCBjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqKTsKICAg ICAgICAgdmlydHVhbCB2b2lkIHdyaXRlVVJMKGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmLCBG cmFtZSopOwogICAgICAgICB2aXJ0dWFsIHZvaWQgd3JpdGVSYW5nZShSYW5nZSosIEZyYW1lKik7 CiAKICAgICAgICAgdmlydHVhbCBib29sIGhhc0RhdGEoKTsKLQorICAgICAgICAKICAgICBwcml2 YXRlOgogICAgICAgICBDbGlwYm9hcmRDaHJvbWl1bShib29sLCBQYXNzUmVmUHRyPENocm9taXVt RGF0YU9iamVjdD4sIENsaXBib2FyZEFjY2Vzc1BvbGljeSk7CiAKICAgICAgICAgdm9pZCByZXNl dEZyb21DbGlwYm9hcmQoKTsKICAgICAgICAgdm9pZCBzZXREcmFnSW1hZ2UoQ2FjaGVkSW1hZ2Uq LCBOb2RlKiwgY29uc3QgSW50UG9pbnQmKTsKKyAgICAgICAgdmlydHVhbCB2b2lkIGRlY2xhcmVB bmRXcml0ZURyYWdJbWFnZShjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiB0aXRsZSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTaGFyZWRCdWZmZXIqIGlt YWdlQnVmZmVyLCBjb25zdCBTdHJpbmcmIGZpbGVOYW1lLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFN0cmluZyYgaHRtbE1hcmt1cCk7CisKICAg ICAgICAgUmVmUHRyPENocm9taXVtRGF0YU9iamVjdD4gbV9kYXRhT2JqZWN0OwogICAgIH07CiAK SW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW1NYWMuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21p dW1NYWMuY3BwCShyZXZpc2lvbiA0Njg5NCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0v Q2xpcGJvYXJkQ2hyb21pdW1NYWMuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yOCwxNCArMjgsNDYg QEAKICNpbmNsdWRlICJDbGlwYm9hcmRDaHJvbWl1bS5oIgogCiAjaW5jbHVkZSAiQ2hyb21pdW1E YXRhT2JqZWN0LmgiCi0jaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKIAogbmFtZXNwYWNlIFdl YkNvcmUgeworICAgIAorCisvLyBGaWxlbmFtZSBsZW5ndGggYW5kIGNoYXJhY3Rlci1zZXQgbGlt aXRzIHZhcnkgYnkgZmlsZXN5c3RlbSwgYW5kIHRoZXJlJ3Mgbm8KKy8vIHJlYWwgd2F5IHRvIHRl bGwgd2hhdCBmaWxlc3lzdGVtIGlzIGluIHVzZS4gU2luY2UgSEZTKyBpcyBieSBmYXIgdGhlIG1v c3QKKy8vIGNvbW1vbiwgd2UnbGwgYWJpZGUgYnkgaXRzIGxpbWl0cywgd2hpY2ggYXJlIDI1NSBV bmljb2RlIGNoYXJhY3RlcnMgKHNsaWdodGx5CisvLyBzaW1wbGlmaWVkOyByZWFsbHkgaXQgdXNl cyBOb3JtYWxpemF0aW9uIEZvcm0gRCwgYnV0IHRoZSBkaWZmZXJlbmNlcyBhcmVuJ3QKKy8vIHJl YWxseSB3b3J0aCBkZWFsaW5nIHdpdGggaGVyZS4pCitzdGF0aWMgY29uc3QgaW50IE1heEhGU0Zp bGVuYW1lTGVuZ3RoID0gMjU1OworCisKK3N0YXRpYyBib29sIGlzSW52YWxpZEZpbGVDaGFyYWN0 ZXIoVUNoYXIgYykKK3sKKyAgICAvLyBIRlMrIGJhc2ljYWxseSBhbGxvd3MgYW55dGhpbmcgYnV0 ICcvJy4gRm9yIHNhbml0eSdzIHNha2Ugd2UnbGwgZGlzYWxsb3cKKyAgICAvLyBjb250cm9sIGNo YXJhY3RlcnMuCisgICAgcmV0dXJuIGMgPCAnICcgfHwgYyA9PSAweDdGIHx8IGMgPT0gJy8nOwor fQogCiBTdHJpbmcgQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoY29uc3QgU3Ry aW5nJiB0aXRsZSwgQ2hyb21pdW1EYXRhT2JqZWN0KiBkYXRhT2JqZWN0KQogewotICAgIG5vdElt cGxlbWVudGVkKCk7Ci0gICAgcmV0dXJuIHRpdGxlOworICAgIC8vIFJlbW92ZSBhbnkgaW52YWxp ZCBmaWxlIHN5c3RlbSBjaGFyYWN0ZXJzLCBlc3BlY2lhbGx5ICIvIi4KKyAgICBTdHJpbmcgcmVz dWx0ID0gdGl0bGUucmVtb3ZlQ2hhcmFjdGVycyhpc0ludmFsaWRGaWxlQ2hhcmFjdGVyKTsKKyAg ICBTdHJpbmcgZXh0ZW5zaW9uID0gZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbi5yZW1vdmVDaGFy YWN0ZXJzKCZpc0ludmFsaWRGaWxlQ2hhcmFjdGVyKTsKKworICAgIC8vIExlYWRpbmcgIi4icyB3 b3VsZCBtYWtlIHRoZSBmaWxlIGludmlzaWJsZSAtLSBzdHJpcCB0aGVtLgorICAgIHdoaWxlIChy ZXN1bHQuc3RhcnRzV2l0aCgiLiIpKQorICAgICAgICByZXN1bHQucmVtb3ZlKDAsMSk7CisKKyAg ICAvLyBSZW1vdmUgYSByaWRpY3Vsb3VzbHktbG9uZyBleHRlbnNpb24uCisgICAgaWYgKGV4dGVu c2lvbi5sZW5ndGgoKSA+PSBNYXhIRlNGaWxlbmFtZUxlbmd0aCkKKyAgICAgICAgZXh0ZW5zaW9u ID0gIiI7CisgICAgCisgICAgLy8gVHJ1bmNhdGUgYW4gb3Zlcmx5LWxvbmcgZmlsZW5hbWUuCisg ICAgaW50IG92ZXJmbG93ID0gcmVzdWx0Lmxlbmd0aCgpICsgZXh0ZW5zaW9uLmxlbmd0aCgpIC0g TWF4SEZTRmlsZW5hbWVMZW5ndGg7CisgICAgaWYgKG92ZXJmbG93ID4gMCkgCisgICAgICAgIHJl c3VsdC5yZW1vdmUocmVzdWx0Lmxlbmd0aCgpIC0gb3ZlcmZsb3csIG92ZXJmbG93KTsKKyAgICAK KyAgICBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uID0gZXh0ZW5zaW9uOworICAgIHJldHVybiBy ZXN1bHQ7CiB9CiAKIH0gIC8vIG5hbWVzcGFjZSBXZWJDb3JlCg== 95223 2011-05-27 15:46:40 -0700 2011-05-31 16:41:29 -0700 Patch bug-24887-20110527154639.patch text/plain 4943 dcheng U3VidmVyc2lvbiBSZXZpc2lvbjogODc1MTkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA4MTg5ZWFkNWVkZTY2M2Rh MWI2ZTZkODE3YzU1MWY1YjMxZjA2MDNiLi5kNThiZDYyOTg2YTYwN2IzOTU4NzRmNGNhMGJkY2I4 MzI3ZjVlNWJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMDUtMjcgIERhbmll bCBDaGVuZyAgPGRjaGVuZ0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBVc2UgY29ycmVjdCBmaWxlIG5hbWUg Zm9yIGRyYWdnaW5nIG91dCBpbWFnZXMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNDg4NworCisgICAgICAgIE5vIG5ldyB0ZXN0cyBzaW5jZSBpYW1n ZSBkcmFncyBhcmVuJ3QgYWNjZXNzaWJsZSB0aHJvdWdoIGV2ZW50LmRhdGFUcmFuc2Zlci5maWxl cy4KKworICAgICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OndyaXRlSW1hZ2VUb0RhdGFPYmplY3QpOgorICAgICAgICAqIHBs YXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmlzSW52YWxpZEZpbGVDaGFyYWN0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJk Q2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUpOgorCiAyMDExLTA1LTI3ICBTaGVyaWZmIEJvdCAg PHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xs aW5nIG91dCByODc0NjQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJv bWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJv bWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAKaW5kZXggNWJjMjZmNzRkODAyZjliYTgwNGYzMTlh MjVhZDJlOWM2MmUxOTY0Ny4uZjU2NzVlMjRlNjE5MmZlZmY3ZjhmNGY3MzEzZDhlOTdlN2ZiYzJl YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJk Q2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBi b2FyZENocm9taXVtLmNwcApAQCAtMjI0LDE5ICsyMjQsMjUgQEAgc3RhdGljIHZvaWQgd3JpdGVJ bWFnZVRvRGF0YU9iamVjdChDaHJvbWl1bURhdGFPYmplY3QqIGRhdGFPYmplY3QsIEVsZW1lbnQq IGVsZW0KIAogICAgIGRhdGFPYmplY3QtPnNldEZpbGVDb250ZW50KGltYWdlQnVmZmVyKTsKIAot ICAgIC8vIERldGVybWluZSB0aGUgZmlsZW5hbWUgZm9yIHRoZSBmaWxlIGNvbnRlbnRzIG9mIHRo ZSBpbWFnZS4gIFdlIHRyeSB0bwotICAgIC8vIHVzZSB0aGUgYWx0IHRhZyBpZiBvbmUgZXhpc3Rz LCBvdGhlcndpc2Ugd2UgZmFsbCBiYWNrIG9uIHRoZSBzdWdnZXN0ZWQKLSAgICAvLyBmaWxlbmFt ZSBpbiB0aGUgaHR0cCBoZWFkZXIsIGFuZCBmaW5hbGx5IHdlIHJlc29ydCB0byB1c2luZyB0aGUg ZmlsZW5hbWUKLSAgICAvLyBpbiB0aGUgVVJMLgorICAgIC8vIERldGVybWluZSB0aGUgZmlsZW5h bWUgZm9yIHRoZSBmaWxlIGNvbnRlbnRzIG9mIHRoZSBpbWFnZS4KKyAgICBTdHJpbmcgZmlsZW5h bWUgPSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRGaWxlbmFtZSgpOworICAgIGlm IChmaWxlbmFtZS5pc0VtcHR5KCkpCisgICAgICAgIGZpbGVuYW1lID0gdXJsLmxhc3RQYXRoQ29t cG9uZW50KCk7CisgICAgaWYgKGZpbGVuYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgZmlsZW5hbWUg PSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoYWx0QXR0cik7CisgICAgZWxzZSB7CisgICAgICAgIC8v IFN0cmlwIGFueSBleGlzdGluZyBleHRlbnNpb24uIEFzc3VtZSB0aGF0IGFsdCB0ZXh0IGlzIHVz dWFsbHkgbm90IGEgZmlsZW5hbWUuCisgICAgICAgIGludCBleHRlbnNpb25JbmRleCA9IGZpbGVu YW1lLnJldmVyc2VGaW5kKCcuJyk7CisgICAgICAgIGlmIChleHRlbnNpb25JbmRleCAhPSAtMSkK KyAgICAgICAgICAgIGZpbGVuYW1lLnRydW5jYXRlKGV4dGVuc2lvbkluZGV4KTsKKyAgICB9Cisg ICAgZmlsZW5hbWUgPSBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFtZShmaWxlbmFt ZSwgZGF0YU9iamVjdCk7CisKICAgICBTdHJpbmcgZXh0ZW5zaW9uID0gTUlNRVR5cGVSZWdpc3Ry eTo6Z2V0UHJlZmVycmVkRXh0ZW5zaW9uRm9yTUlNRVR5cGUoCiAgICAgICAgIGNhY2hlZEltYWdl LT5yZXNwb25zZSgpLm1pbWVUeXBlKCkpOwogICAgIGRhdGFPYmplY3QtPnNldEZpbGVFeHRlbnNp b24oZXh0ZW5zaW9uLmlzRW1wdHkoKSA/IGVtcHR5U3RyaW5nKCkgOiAiLiIgKyBleHRlbnNpb24p OwotICAgIFN0cmluZyB0aXRsZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKLSAg ICBpZiAodGl0bGUuaXNFbXB0eSgpKQotICAgICAgICB0aXRsZSA9IGNhY2hlZEltYWdlLT5yZXNw b25zZSgpLnN1Z2dlc3RlZEZpbGVuYW1lKCk7CiAKLSAgICB0aXRsZSA9IENsaXBib2FyZENocm9t aXVtOjp2YWxpZGF0ZUZpbGVOYW1lKHRpdGxlLCBkYXRhT2JqZWN0KTsKLSAgICBkYXRhT2JqZWN0 LT5zZXRGaWxlQ29udGVudEZpbGVuYW1lKHRpdGxlICsgZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lv bigpKTsKKyAgICBkYXRhT2JqZWN0LT5zZXRGaWxlQ29udGVudEZpbGVuYW1lKGZpbGVuYW1lICsg ZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbigpKTsKIH0KIAogdm9pZCBDbGlwYm9hcmRDaHJvbWl1 bTo6ZGVjbGFyZUFuZFdyaXRlRHJhZ0ltYWdlKEVsZW1lbnQqIGVsZW1lbnQsIGNvbnN0IEtVUkwm IHVybCwgY29uc3QgU3RyaW5nJiB0aXRsZSwgRnJhbWUqIGZyYW1lKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW1NYWMuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW1NYWMuY3Bw CmluZGV4IDJjODlmNmU4ZWU5OTkyMDI5MTJiM2Q4ZGI5YmY1YmI3NzI1NzdhOTcuLjM4MDIxNDAy ZWI5MjllM2NjNmUyNTFkMjIzZjAwNzQ2NmFkZjJmMjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAKQEAg LTI4LDE0ICsyOCw0MiBAQAogI2luY2x1ZGUgIkNsaXBib2FyZENocm9taXVtLmgiCiAKICNpbmNs dWRlICJDaHJvbWl1bURhdGFPYmplY3QuaCIKLSNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgCisKKy8vIEZpbGVuYW1lIGxlbmd0aCBhbmQgY2hh cmFjdGVyLXNldCBsaW1pdHMgdmFyeSBieSBmaWxlc3lzdGVtLCBhbmQgdGhlcmUncyBubworLy8g cmVhbCB3YXkgdG8gdGVsbCB3aGF0IGZpbGVzeXN0ZW0gaXMgaW4gdXNlLiBTaW5jZSBIRlMrIGlz IGJ5IGZhciB0aGUgbW9zdAorLy8gY29tbW9uLCB3ZSdsbCBhYmlkZSBieSBpdHMgbGltaXRzLCB3 aGljaCBhcmUgMjU1IFVuaWNvZGUgY2hhcmFjdGVycyAoc2xpZ2h0bHkKKy8vIHNpbXBsaWZpZWQ7 IHJlYWxseSBpdCB1c2VzIE5vcm1hbGl6YXRpb24gRm9ybSBELCBidXQgdGhlIGRpZmZlcmVuY2Vz IGFyZW4ndAorLy8gcmVhbGx5IHdvcnRoIGRlYWxpbmcgd2l0aCBoZXJlLikKK3N0YXRpYyBjb25z dCB1bnNpZ25lZCBNYXhIRlNGaWxlbmFtZUxlbmd0aCA9IDI1NTsKKworCitzdGF0aWMgYm9vbCBp c0ludmFsaWRGaWxlQ2hhcmFjdGVyKFVDaGFyIGMpCit7CisgICAgLy8gSEZTKyBiYXNpY2FsbHkg YWxsb3dzIGFueXRoaW5nIGJ1dCAnLycuIEZvciBzYW5pdHkncyBzYWtlIHdlJ2xsIGRpc2FsbG93 CisgICAgLy8gY29udHJvbCBjaGFyYWN0ZXJzLgorICAgIHJldHVybiBjIDwgJyAnIHx8IGMgPT0g MHg3RiB8fCBjID09ICcvJzsKK30KIAogU3RyaW5nIENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0 ZUZpbGVOYW1lKGNvbnN0IFN0cmluZyYgdGl0bGUsIENocm9taXVtRGF0YU9iamVjdCogZGF0YU9i amVjdCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOwotICAgIHJldHVybiB0aXRsZTsKKyAgICAv LyBSZW1vdmUgYW55IGludmFsaWQgZmlsZSBzeXN0ZW0gY2hhcmFjdGVycywgZXNwZWNpYWxseSAi LyIuCisgICAgU3RyaW5nIHJlc3VsdCA9IHRpdGxlLnJlbW92ZUNoYXJhY3RlcnMoaXNJbnZhbGlk RmlsZUNoYXJhY3Rlcik7CisgICAgU3RyaW5nIGV4dGVuc2lvbiA9IGRhdGFPYmplY3QtPmZpbGVF eHRlbnNpb24oKS5yZW1vdmVDaGFyYWN0ZXJzKCZpc0ludmFsaWRGaWxlQ2hhcmFjdGVyKTsKKwor ICAgIC8vIFJlbW92ZSBhIHJpZGljdWxvdXNseS1sb25nIGV4dGVuc2lvbi4KKyAgICBpZiAoZXh0 ZW5zaW9uLmxlbmd0aCgpID49IE1heEhGU0ZpbGVuYW1lTGVuZ3RoKQorICAgICAgICBleHRlbnNp b24gPSAiIjsKKyAgICAKKyAgICAvLyBUcnVuY2F0ZSBhbiBvdmVybHktbG9uZyBmaWxlbmFtZS4K KyAgICBpbnQgb3ZlcmZsb3cgPSByZXN1bHQubGVuZ3RoKCkgKyBleHRlbnNpb24ubGVuZ3RoKCkg LSBNYXhIRlNGaWxlbmFtZUxlbmd0aDsKKyAgICBpZiAob3ZlcmZsb3cgPiAwKSAKKyAgICAgICAg cmVzdWx0LnJlbW92ZShyZXN1bHQubGVuZ3RoKCkgLSBvdmVyZmxvdywgb3ZlcmZsb3cpOworICAg IAorICAgIGRhdGFPYmplY3QtPnNldEZpbGVFeHRlbnNpb24oZXh0ZW5zaW9uKTsKKyAgICByZXR1 cm4gcmVzdWx0OwogfQogCiB9ICAvLyBuYW1lc3BhY2UgV2ViQ29yZQo= 95510 2011-05-31 16:41:35 -0700 2011-05-31 18:20:12 -0700 Patch bug-24887-20110531164134.patch text/plain 12991 dcheng U3VidmVyc2lvbiBSZXZpc2lvbjogODc3NDUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCAwNDg4ODE1MTliMjk1ZWJiYjQ2MWU1 YWJmOGNiN2Q2MjkzNDk5ZjU5Li5lMTdlZjBmNGVkZWFkOTMzY2JiMjU2OTAzZTgzODAzNTg5NGM1 MjMwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDUtMzEgIERhbmllbCBDaGVuZyAgPGRj aGVuZ0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgW2Nocm9taXVtXSBVc2UgY29ycmVjdCBmaWxlIG5hbWUgZm9yIGRyYWdnaW5n IG91dCBpbWFnZXMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNDg4NworCisgICAgICAgICogZmFzdC9ldmVudHMvZHJhZy1pbWFnZS1maWxlbmFtZS1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmls ZW5hbWUuaHRtbDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBwZWQ6CisgICAg ICAgICogcGxhdGZvcm0vbWFjL1NraXBwZWQ6CisgICAgICAgICogcGxhdGZvcm0vcXQvU2tpcHBl ZDoKKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDoKKwogMjAxMS0wNS0zMSAgQWJoaXNo ZWsgQXJ5YSAgPGluZmVybm9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERp bWl0cmkgR2xhemtvdi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2RyYWct aW1hZ2UtZmlsZW5hbWUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9ldmVudHMvZHJh Zy1pbWFnZS1maWxlbmFtZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMzZhNDkyZTAzZDQ0MTNm ZWJmMjZjYmNiYTlmNTNiNmY3YzhhYjc4OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmlsZW5hbWUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEs NCBAQAorRmlsZW5hbWUgYmVpbmcgZHJhZ2dlZDogb25sb2FkLWltYWdlLnBuZworVGhpcyB0ZXN0 IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVlLgorCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZXZlbnRzL2RyYWctaW1hZ2UtZmlsZW5hbWUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZXZl bnRzL2RyYWctaW1hZ2UtZmlsZW5hbWUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lMTA5ZWI4ZjNmZWViZjQ0 MzI2ODg5YTg1NjA2OGRhMDgwYjVmMzliCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9ldmVudHMvZHJhZy1pbWFnZS1maWxlbmFtZS5odG1sCkBAIC0wLDAgKzEsNTMgQEAKKzwh RE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQ+CitmdW5jdGlvbiBydW5UZXN0 KCkgeworICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci53YWl0VW50aWxEb25lKCk7CisgICAgfSBlbHNlCisgICAgICAgIHJldHVybjsKKyAgICAK KyAgICBlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNvdXJjZSIpOworICAgIHggPSBlLm9m ZnNldExlZnQgKyBlLm9mZnNldFdpZHRoIC8gMjsKKyAgICB5ID0gZS5vZmZzZXRUb3AgKyBlLm9m ZnNldEhlaWdodCAvIDI7CisKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4LCB5KTsKKyAg ICBldmVudFNlbmRlci5tb3VzZURvd24oKTsgICAgCisgICAgZSA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJ0YXJnZXQiKTsKKyAgICB4ID0gZS5vZmZzZXRMZWZ0ICsgZS5vZmZzZXRXaWR0aCAv IDI7CisgICAgeSA9IGUub2Zmc2V0VG9wICsgZS5vZmZzZXRIZWlnaHQgLyAyOworICAgIAorICAg IGV2ZW50U2VuZGVyLm1vdXNlTW92ZVRvKHgsIHkpOworICAgIGV2ZW50U2VuZGVyLm1vdXNlVXAo KTsKK30KKworZnVuY3Rpb24gZHJhZ0VudGVyT3JPdmVyKGV2ZW50KSB7CisgICAgZXZlbnQuZGF0 YVRyYW5zZmVyLmRyb3BFZmZlY3QgPSAiY29weSI7CisgICAgZXZlbnQucHJldmVudERlZmF1bHQo KTsKK30KKworZnVuY3Rpb24gZHJvcChldmVudCkgeworICAgIGV2ZW50LnByZXZlbnREZWZhdWx0 KCk7CisgICAgZXZlbnRTZW5kZXIuZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkKCk7CisgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworfQorPC9zY3JpcHQ+Cis8c3R5bGU+Cisj dGFyZ2V0IHsKKyAgICBoZWlnaHQ6IDEwMHB4OworICAgIHdpZHRoOiAxMDBweDsKK30KKzwvc3R5 bGU+Cis8L2hlYWQ+CisKKzxib2R5IG9ubG9hZD0icnVuVGVzdCgpIj4gIAorCis8cD5UaGlzIHRl c3QgcmVxdWlyZXMgRHVtcFJlbmRlclRyZWUuCisKKzxkaXYgaWQ9InRhcmdldCIgb25kcmFnZW50 ZXI9ImRyYWdFbnRlck9yT3ZlcihldmVudCkiIG9uZHJhZ292ZXI9ImRyYWdFbnRlck9yT3Zlcihl dmVudCkiIG9uZHJvcD0iZHJvcChldmVudCkiPjwvZGl2PgorPGltZyBpZD0ic291cmNlIiBzcmM9 InJlc291cmNlcy9vbmxvYWQtaW1hZ2UucG5nIiBhbHQ9IkRvZXMgaXQgd29yaz8iPgorCis8L2Jv ZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBl ZCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkCmluZGV4IGI5ODQ0M2I1MDQ0NTFj NzM0OGI3OTViZjRlYjhjZDg5MDY4NzdiZGMuLmY3MDBiNmVlMDNhNTkxNTZiNTQ2MGI5NjMyMmNi NTM0ZTBhOTQwMDQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVk CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkCkBAIC0xMTQzLDYgKzExNDMs OSBAQCBodHRwL3Rlc3RzL3htbGh0dHByZXF1ZXN0L3JlbWVtYmVyLWJhZC1wYXNzd29yZC5odG1s CiBmYXN0L2Nzcy91c2VyLWRyYWctbm9uZS5odG1sCiBmYXN0L2V2ZW50cy81MDU2NjE5Lmh0bWwK IAorIyBFdmVudFNlbmRlcjo6ZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkIG5vdCBpbXBsZW1lbnRl ZC4KK2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmlsZW5hbWUuaHRtbAorCiAjIFRlc3RzIHRoYXQg ZmFpbCBiZWNhdXNlIHRoZXkgYXNzdW1lIGEgY2VydGFpbiBudW1iZXIgb2YgbW91c2UKICMgbW92 ZW1lbnRzIGR1cmluZyBkcmFncyBvciBmYWlsIG9ubHkgaW4gWHZmYgogaHR0cC90ZXN0cy9sb2Nh bC9kcmFnLW92ZXItcmVtb3RlLWNvbnRlbnQuaHRtbApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv cGxhdGZvcm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZApp bmRleCBiMDJkNDJhODkyMjg1NmRjMTM4MTgxN2Q4NGExZWY3OGIyNzQ2OGUxLi42NjAwODRhYjRl NGEwODgxMjk1MTFjNTU4ZWU0YmNkYjI1ZjdkYmQ4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9tYWMvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBl ZApAQCAtMTkxLDYgKzE5MSw5IEBAIGh0dHAvdGVzdHMvbWlzYy9wcmVmZXRjaC1wdXJwb3NlLmh0 bWwKICMgRmlsZW5hbWVzIGFyZW4ndCBmaWx0ZXJlZCBvdXQgZnJvbSBlZGl0IGRyYWdzIHlldCwg c2VlIGh0dHBzOi8vYnVncy53ZWtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4ODI2CiBlZGl0aW5n L3Bhc3RlYm9hcmQvZmlsZS1kcmFnLXRvLWVkaXRhYmxlLmh0bWwKIAorIyBFdmVudFNlbmRlcjo6 ZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkIG5vdCBpbXBsZW1lbnRlZC4KK2Zhc3QvZXZlbnRzL2Ry YWctaW1hZ2UtZmlsZW5hbWUuaHRtbAorCiAjIEhpdHMgYW4gYXNzZXJ0IGluIEZyYW1lTG9hZGVy LmNwcC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMxMzg3CiBodHRw L3Rlc3RzL211bHRpcGFydC9wb2xpY3ktaWdub3JlLWNyYXNoLnBocAogCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9Ta2lwcGVkIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQv U2tpcHBlZAppbmRleCAzMWZlNGI4NzA3YzUxMTE5NzFjNTk4YWM5MjBiNTgyYzZmZGIzZjE1Li5i MzhjMjUyZmFmODdkNzQxMGQ0ODVmZTI0N2Y5ZGJlZjY2OWY5Zjg4IDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9xdC9Ta2lwcGVkCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0 L1NraXBwZWQKQEAgLTE2OSw2ICsxNjksNyBAQCBlZGl0aW5nL3Bhc3RlYm9hcmQvZGF0YS10cmFu c2Zlci1pdGVtcy5odG1sCiAjIE1pc3NpbmcgZHJhZyAmIGRyb3AgZnVuY3Rpb25hbGl0eSBpbiBE UlQKIGVkaXRpbmcvcGFzdGVib2FyZC9kcm9wLWlucHV0dGV4dC1hY3F1aXJlcy1zdHlsZS5odG1s CiBmYXN0L2Nzcy91c2VyLWRyYWctbm9uZS5odG1sCitmYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZp bGVuYW1lLmh0bWwKIGZhc3QvaW1hZ2VzL2RyYWctc3ZnLWFzLWltYWdlLmh0bWwKIGZhc3QvZm9y bXMvc2xpZGVyLWRlbGV0ZS13aGlsZS1kcmFnZ2luZy10aHVtYi5odG1sCiAKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9Ta2lwcGVkIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0v d2luL1NraXBwZWQKaW5kZXggMzhiMjc0OTFiNzc0NGRiNGZlNTAyMmY2ZWQxZmIyZGUxYWJhZGY4 MC4uNGZiM2FjYjE1ZjA0Zjk4ODUxMzhiMWU2Y2RkYTQwZTc0ZThmMzBjYyAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luL1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZv cm0vd2luL1NraXBwZWQKQEAgLTEyMiw2ICsxMjIsNyBAQCBlZGl0aW5nL2V4ZWNDb21tYW5kL2Nv cHktd2l0aG91dC1zZWxlY3Rpb24uaHRtbAogZWRpdGluZy9wYXN0ZWJvYXJkL2RyYWctaW1hZ2Ut aW4tYWJvdXQtYmxhbmstZnJhbWUuaHRtbAogZWRpdGluZy9wYXN0ZWJvYXJkL2Ryb3AtZmlsZS1z dmcuaHRtbAogZWRpdGluZy9wYXN0ZWJvYXJkL2dldC1kYXRhLXRleHQtcGxhaW4tZHJvcC5odG1s CitmYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZpbGVuYW1lLmh0bWwKIGZhc3QvZXZlbnRzL2RyYWct aW4tZnJhbWVzLmh0bWwKIGZhc3QvZXZlbnRzL3N0YW5kYWxvbmUtaW1hZ2UtZHJhZy10by1lZGl0 YWJsZS5odG1sCiBodHRwL3Rlc3RzL3NlY3VyaXR5L2RyYWctZHJvcC1zYW1lLXVuaXF1ZS1vcmln aW4uaHRtbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCmluZGV4IGVkYzNkZjlmYzEzYTFkMTdhNzNjMjBmMThkMmJkNmJhZDhh YjFiODYuLjlmZDBiMmJhODRhZWRlNTMwMzc1ZmFlZjE1OGIyYTQxMzU3MmY5ZDMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxOCBAQAorMjAxMS0wNS0zMSAgRGFuaWVsIENoZW5nICA8ZGNoZW5nQGNo cm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBbY2hyb21pdW1dIFVzZSBjb3JyZWN0IGZpbGUgbmFtZSBmb3IgZHJhZ2dpbmcgb3V0IGlt YWdlcy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI0 ODg3CisKKyAgICAgICAgVGVzdDogZmFzdC9ldmVudHMvZHJhZy1pbWFnZS1maWxlbmFtZS5odG1s CisKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjp3cml0ZUltYWdlVG9EYXRhT2JqZWN0KToKKyAgICAgICAgKiBwbGF0 Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHA6CisgICAgICAgIChXZWJDb3Jl Ojppc0ludmFsaWRGaWxlQ2hhcmFjdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkNsaXBib2FyZENo cm9taXVtOjp2YWxpZGF0ZUZpbGVOYW1lKToKKwogMjAxMS0wNS0zMSAgUm9iaW4gRHVubiAgPHJv YmluQGFsbGR1bm4uY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtldmluIE9sbGl2aWVyLgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hy b21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hy b21pdW0uY3BwCmluZGV4IDViYzI2Zjc0ZDgwMmY5YmE4MDRmMzE5YTI1YWQyZTljNjJlMTk2NDcu LmY1Njc1ZTI0ZTYxOTJmZWZmN2Y4ZjRmNzMxM2Q4ZTk3ZTdmYmMyZWIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAK QEAgLTIyNCwxOSArMjI0LDI1IEBAIHN0YXRpYyB2b2lkIHdyaXRlSW1hZ2VUb0RhdGFPYmplY3Qo Q2hyb21pdW1EYXRhT2JqZWN0KiBkYXRhT2JqZWN0LCBFbGVtZW50KiBlbGVtCiAKICAgICBkYXRh T2JqZWN0LT5zZXRGaWxlQ29udGVudChpbWFnZUJ1ZmZlcik7CiAKLSAgICAvLyBEZXRlcm1pbmUg dGhlIGZpbGVuYW1lIGZvciB0aGUgZmlsZSBjb250ZW50cyBvZiB0aGUgaW1hZ2UuICBXZSB0cnkg dG8KLSAgICAvLyB1c2UgdGhlIGFsdCB0YWcgaWYgb25lIGV4aXN0cywgb3RoZXJ3aXNlIHdlIGZh bGwgYmFjayBvbiB0aGUgc3VnZ2VzdGVkCi0gICAgLy8gZmlsZW5hbWUgaW4gdGhlIGh0dHAgaGVh ZGVyLCBhbmQgZmluYWxseSB3ZSByZXNvcnQgdG8gdXNpbmcgdGhlIGZpbGVuYW1lCi0gICAgLy8g aW4gdGhlIFVSTC4KKyAgICAvLyBEZXRlcm1pbmUgdGhlIGZpbGVuYW1lIGZvciB0aGUgZmlsZSBj b250ZW50cyBvZiB0aGUgaW1hZ2UuCisgICAgU3RyaW5nIGZpbGVuYW1lID0gY2FjaGVkSW1hZ2Ut PnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKKyAgICBpZiAoZmlsZW5hbWUuaXNFbXB0 eSgpKQorICAgICAgICBmaWxlbmFtZSA9IHVybC5sYXN0UGF0aENvbXBvbmVudCgpOworICAgIGlm IChmaWxlbmFtZS5pc0VtcHR5KCkpCisgICAgICAgIGZpbGVuYW1lID0gZWxlbWVudC0+Z2V0QXR0 cmlidXRlKGFsdEF0dHIpOworICAgIGVsc2UgeworICAgICAgICAvLyBTdHJpcCBhbnkgZXhpc3Rp bmcgZXh0ZW5zaW9uLiBBc3N1bWUgdGhhdCBhbHQgdGV4dCBpcyB1c3VhbGx5IG5vdCBhIGZpbGVu YW1lLgorICAgICAgICBpbnQgZXh0ZW5zaW9uSW5kZXggPSBmaWxlbmFtZS5yZXZlcnNlRmluZCgn LicpOworICAgICAgICBpZiAoZXh0ZW5zaW9uSW5kZXggIT0gLTEpCisgICAgICAgICAgICBmaWxl bmFtZS50cnVuY2F0ZShleHRlbnNpb25JbmRleCk7CisgICAgfQorICAgIGZpbGVuYW1lID0gQ2xp cGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoZmlsZW5hbWUsIGRhdGFPYmplY3QpOwor CiAgICAgU3RyaW5nIGV4dGVuc2lvbiA9IE1JTUVUeXBlUmVnaXN0cnk6OmdldFByZWZlcnJlZEV4 dGVuc2lvbkZvck1JTUVUeXBlKAogICAgICAgICBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5taW1l VHlwZSgpKTsKICAgICBkYXRhT2JqZWN0LT5zZXRGaWxlRXh0ZW5zaW9uKGV4dGVuc2lvbi5pc0Vt cHR5KCkgPyBlbXB0eVN0cmluZygpIDogIi4iICsgZXh0ZW5zaW9uKTsKLSAgICBTdHJpbmcgdGl0 bGUgPSBlbGVtZW50LT5nZXRBdHRyaWJ1dGUoYWx0QXR0cik7Ci0gICAgaWYgKHRpdGxlLmlzRW1w dHkoKSkKLSAgICAgICAgdGl0bGUgPSBjYWNoZWRJbWFnZS0+cmVzcG9uc2UoKS5zdWdnZXN0ZWRG aWxlbmFtZSgpOwogCi0gICAgdGl0bGUgPSBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxl TmFtZSh0aXRsZSwgZGF0YU9iamVjdCk7Ci0gICAgZGF0YU9iamVjdC0+c2V0RmlsZUNvbnRlbnRG aWxlbmFtZSh0aXRsZSArIGRhdGFPYmplY3QtPmZpbGVFeHRlbnNpb24oKSk7CisgICAgZGF0YU9i amVjdC0+c2V0RmlsZUNvbnRlbnRGaWxlbmFtZShmaWxlbmFtZSArIGRhdGFPYmplY3QtPmZpbGVF eHRlbnNpb24oKSk7CiB9CiAKIHZvaWQgQ2xpcGJvYXJkQ2hyb21pdW06OmRlY2xhcmVBbmRXcml0 ZURyYWdJbWFnZShFbGVtZW50KiBlbGVtZW50LCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmlu ZyYgdGl0bGUsIEZyYW1lKiBmcmFtZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcAppbmRleCAyYzg5ZjZlOGVl OTk5MjAyOTEyYjNkOGRiOWJmNWJiNzcyNTc3YTk3Li4zODAyMTQwMmViOTI5ZTNjYzZlMjUxZDIy M2YwMDc0NjZhZGYyZjI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJv bWl1bS9DbGlwYm9hcmRDaHJvbWl1bU1hYy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW1NYWMuY3BwCkBAIC0yOCwxNCArMjgsNDIgQEAK ICNpbmNsdWRlICJDbGlwYm9hcmRDaHJvbWl1bS5oIgogCiAjaW5jbHVkZSAiQ2hyb21pdW1EYXRh T2JqZWN0LmgiCi0jaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKIAogbmFtZXNwYWNlIFdlYkNv cmUgeworICAgIAorCisvLyBGaWxlbmFtZSBsZW5ndGggYW5kIGNoYXJhY3Rlci1zZXQgbGltaXRz IHZhcnkgYnkgZmlsZXN5c3RlbSwgYW5kIHRoZXJlJ3Mgbm8KKy8vIHJlYWwgd2F5IHRvIHRlbGwg d2hhdCBmaWxlc3lzdGVtIGlzIGluIHVzZS4gU2luY2UgSEZTKyBpcyBieSBmYXIgdGhlIG1vc3QK Ky8vIGNvbW1vbiwgd2UnbGwgYWJpZGUgYnkgaXRzIGxpbWl0cywgd2hpY2ggYXJlIDI1NSBVbmlj b2RlIGNoYXJhY3RlcnMgKHNsaWdodGx5CisvLyBzaW1wbGlmaWVkOyByZWFsbHkgaXQgdXNlcyBO b3JtYWxpemF0aW9uIEZvcm0gRCwgYnV0IHRoZSBkaWZmZXJlbmNlcyBhcmVuJ3QKKy8vIHJlYWxs eSB3b3J0aCBkZWFsaW5nIHdpdGggaGVyZS4pCitzdGF0aWMgY29uc3QgdW5zaWduZWQgTWF4SEZT RmlsZW5hbWVMZW5ndGggPSAyNTU7CisKKworc3RhdGljIGJvb2wgaXNJbnZhbGlkRmlsZUNoYXJh Y3RlcihVQ2hhciBjKQoreworICAgIC8vIEhGUysgYmFzaWNhbGx5IGFsbG93cyBhbnl0aGluZyBi dXQgJy8nLiBGb3Igc2FuaXR5J3Mgc2FrZSB3ZSdsbCBkaXNhbGxvdworICAgIC8vIGNvbnRyb2wg Y2hhcmFjdGVycy4KKyAgICByZXR1cm4gYyA8ICcgJyB8fCBjID09IDB4N0YgfHwgYyA9PSAnLyc7 Cit9CiAKIFN0cmluZyBDbGlwYm9hcmRDaHJvbWl1bTo6dmFsaWRhdGVGaWxlTmFtZShjb25zdCBT dHJpbmcmIHRpdGxlLCBDaHJvbWl1bURhdGFPYmplY3QqIGRhdGFPYmplY3QpCiB7Ci0gICAgbm90 SW1wbGVtZW50ZWQoKTsKLSAgICByZXR1cm4gdGl0bGU7CisgICAgLy8gUmVtb3ZlIGFueSBpbnZh bGlkIGZpbGUgc3lzdGVtIGNoYXJhY3RlcnMsIGVzcGVjaWFsbHkgIi8iLgorICAgIFN0cmluZyBy ZXN1bHQgPSB0aXRsZS5yZW1vdmVDaGFyYWN0ZXJzKGlzSW52YWxpZEZpbGVDaGFyYWN0ZXIpOwor ICAgIFN0cmluZyBleHRlbnNpb24gPSBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uKCkucmVtb3Zl Q2hhcmFjdGVycygmaXNJbnZhbGlkRmlsZUNoYXJhY3Rlcik7CisKKyAgICAvLyBSZW1vdmUgYSBy aWRpY3Vsb3VzbHktbG9uZyBleHRlbnNpb24uCisgICAgaWYgKGV4dGVuc2lvbi5sZW5ndGgoKSA+ PSBNYXhIRlNGaWxlbmFtZUxlbmd0aCkKKyAgICAgICAgZXh0ZW5zaW9uID0gIiI7CisgICAgCisg ICAgLy8gVHJ1bmNhdGUgYW4gb3Zlcmx5LWxvbmcgZmlsZW5hbWUuCisgICAgaW50IG92ZXJmbG93 ID0gcmVzdWx0Lmxlbmd0aCgpICsgZXh0ZW5zaW9uLmxlbmd0aCgpIC0gTWF4SEZTRmlsZW5hbWVM ZW5ndGg7CisgICAgaWYgKG92ZXJmbG93ID4gMCkgCisgICAgICAgIHJlc3VsdC5yZW1vdmUocmVz dWx0Lmxlbmd0aCgpIC0gb3ZlcmZsb3csIG92ZXJmbG93KTsKKyAgICAKKyAgICBkYXRhT2JqZWN0 LT5zZXRGaWxlRXh0ZW5zaW9uKGV4dGVuc2lvbik7CisgICAgcmV0dXJuIHJlc3VsdDsKIH0KIAog fSAgLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rv b2xzL0NoYW5nZUxvZwppbmRleCAxODkzMDBhOTUxODk2Y2RmZWY4YzUxY2I1YzBmMDhhODcwZTc5 Yzg4Li5kNzhhZTYwYzYzMzZmNTlhNmFmYTQ0YjQwNTgzODMwMmUyNGU2Y2Q5IDEwMDY0NAotLS0g YS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTEtMDUtMzEgIERhbmllbCBDaGVuZyAgPGRjaGVuZ0BjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW2Nocm9taXVtXSBVc2Ug Y29ycmVjdCBmaWxlIG5hbWUgZm9yIGRyYWdnaW5nIG91dCBpbWFnZXMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNDg4NworCisgICAgICAgICogRHVt cFJlbmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIuY3BwOgorICAgICAgICAoRXZlbnRTZW5k ZXI6OkV2ZW50U2VuZGVyKToKKyAgICAgICAgKEV2ZW50U2VuZGVyOjpkdW1wRmlsZW5hbWVCZWlu Z0RyYWdnZWQpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0V2ZW50U2VuZGVy Lmg6CisKIDIwMTEtMDUtMzEgIEtyaXN0w7NmIEtvc3p0ecOzICA8S29zenR5by5LcmlzdG9mQHN0 dWQudS1zemVnZWQuaHU+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQ3NhYmEgT3N6dHJvZ29uw6Fj LgpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIu Y3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIuY3BwCmluZGV4 IDllNTU1ODkzZTk4YTdhMDRkZDQ1YzU1Y2IwMjlkYzE3NWJmOGNjMDUuLjU4ZmU0ZmNkMjI3Mzc4 MWMxZmE3NDJiMTIwZTJmMzYzMTQ3OTM3MmQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmNwcAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9FdmVudFNlbmRlci5jcHAKQEAgLTI1OSw2ICsyNTksNyBAQCBFdmVudFNlbmRlcjo6 RXZlbnRTZW5kZXIoVGVzdFNoZWxsKiBzaGVsbCkKICAgICBiaW5kTWV0aG9kKCJjb250ZXh0Q2xp Y2siLCAmRXZlbnRTZW5kZXI6OmNvbnRleHRDbGljayk7CiAgICAgYmluZE1ldGhvZCgiY29udGlu dW91c01vdXNlU2Nyb2xsQnkiLCAmRXZlbnRTZW5kZXI6OmNvbnRpbnVvdXNNb3VzZVNjcm9sbEJ5 KTsKICAgICBiaW5kTWV0aG9kKCJkaXNwYXRjaE1lc3NhZ2UiLCAmRXZlbnRTZW5kZXI6OmRpc3Bh dGNoTWVzc2FnZSk7CisgICAgYmluZE1ldGhvZCgiZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkIiwg JkV2ZW50U2VuZGVyOjpkdW1wRmlsZW5hbWVCZWluZ0RyYWdnZWQpOwogICAgIGJpbmRNZXRob2Qo ImVuYWJsZURPTVVJRXZlbnRMb2dnaW5nIiwgJkV2ZW50U2VuZGVyOjplbmFibGVET01VSUV2ZW50 TG9nZ2luZyk7CiAgICAgYmluZE1ldGhvZCgiZmlyZUtleWJvYXJkRXZlbnRzVG9FbGVtZW50Iiwg JkV2ZW50U2VuZGVyOjpmaXJlS2V5Ym9hcmRFdmVudHNUb0VsZW1lbnQpOwogICAgIGJpbmRNZXRo b2QoImtleURvd24iLCAmRXZlbnRTZW5kZXI6OmtleURvd24pOwpAQCAtMzQ0LDYgKzM0NSwxMSBA QCB2b2lkIEV2ZW50U2VuZGVyOjpkb0RyYWdEcm9wKGNvbnN0IFdlYkRyYWdEYXRhJiBkcmFnRGF0 YSwgV2ViRHJhZ09wZXJhdGlvbnNNYXNrCiAgICAgcmVwbGF5U2F2ZWRFdmVudHMoKTsKIH0KIAor dm9pZCBFdmVudFNlbmRlcjo6ZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkKGNvbnN0IENwcEFyZ3Vt ZW50TGlzdCYgYXJndW1lbnRzLCBDcHBWYXJpYW50KiByZXN1bHQpCit7CisgICAgcHJpbnRmKCJG aWxlbmFtZSBiZWluZyBkcmFnZ2VkOiAlc1xuIiwgY3VycmVudERyYWdEYXRhLmZpbGVDb250ZW50 RmlsZW5hbWUoKS51dGY4KCkuZGF0YSgpKTsKK30KKwogV2ViTW91c2VFdmVudDo6QnV0dG9uIEV2 ZW50U2VuZGVyOjpnZXRCdXR0b25UeXBlRnJvbUJ1dHRvbk51bWJlcihpbnQgYnV0dG9uQ29kZSkK IHsKICAgICBpZiAoIWJ1dHRvbkNvZGUpCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9FdmVudFNlbmRlci5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0v RXZlbnRTZW5kZXIuaAppbmRleCBkZTFjYTA1NDAzOTEyMjU3N2M5ZDZkYmUzYzlmNmE4NTRhNGM4 YTg2Li41NGIwNjUwMzNjNjgxOTJjMzc3MjE4MzY1NTM5ZWM0Nzk4ZjkxYjNiIDEwMDY0NAotLS0g YS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5oCisrKyBiL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmgKQEAgLTYyLDYgKzYyLDkgQEAg cHVibGljOgogICAgIC8vIFNpbXVsYXRlIGRyYWcmZHJvcCBzeXN0ZW0gY2FsbC4KICAgICB2b2lk IGRvRHJhZ0Ryb3AoY29uc3QgV2ViS2l0OjpXZWJEcmFnRGF0YSYsIFdlYktpdDo6V2ViRHJhZ09w ZXJhdGlvbnNNYXNrKTsKIAorICAgIC8vIFRlc3QgaGVscGVyIGZvciBkcmFnZ2luZyBvdXQgaW1h Z2VzLgorICAgIHZvaWQgZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkKGNvbnN0IENwcEFyZ3VtZW50 TGlzdCYsIENwcFZhcmlhbnQqKTsKKwogICAgIC8vIEpTIGNhbGxiYWNrIG1ldGhvZHMuCiAgICAg dm9pZCBtb3VzZURvd24oY29uc3QgQ3BwQXJndW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopOwogICAg IHZvaWQgbW91c2VVcChjb25zdCBDcHBBcmd1bWVudExpc3QmLCBDcHBWYXJpYW50Kik7Cg== 95526 2011-05-31 18:20:17 -0700 2011-05-31 18:26:08 -0700 Patch bug-24887-20110531182016.patch text/plain 14136 dcheng U3VidmVyc2lvbiBSZXZpc2lvbjogODc3NTYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA0ZGZlNTdmNzhmMjczMWM4ZjlmZTdm M2NlMjk5ZTlkOGEyYjUwZTQ5Li45OTk5NjQ5MGZlYjdmOGI4ZmVjMWE0N2EwOTViYWQ5MDVhMDg0 NmQ1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDUtMzEgIERhbmllbCBDaGVuZyAgPGRj aGVuZ0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgW2Nocm9taXVtXSBVc2UgY29ycmVjdCBmaWxlIG5hbWUgZm9yIGRyYWdnaW5n IG91dCBpbWFnZXMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNDg4NworCisgICAgICAgICogZmFzdC9ldmVudHMvZHJhZy1pbWFnZS1maWxlbmFtZS1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmls ZW5hbWUuaHRtbDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBwZWQ6CisgICAg ICAgICogcGxhdGZvcm0vbWFjL1NraXBwZWQ6CisgICAgICAgICogcGxhdGZvcm0vcXQvU2tpcHBl ZDoKKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDoKKwogMjAxMS0wNS0zMSAgSGFvIFpo ZW5nICA8emhlbmdoYW9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFRvbnkg Q2hhbmcuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZp bGVuYW1lLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2Ut ZmlsZW5hbWUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdhMjI0YmEwZmU0YTdjZmYxYWNjZTgx Y2FjNGZmOTA0OGIzMmJlZjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2 ZW50cy9kcmFnLWltYWdlLWZpbGVuYW1lLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDQgQEAKK0Zp bGVuYW1lIGJlaW5nIGRyYWdnZWQ6IG9ubG9hZC1pbWFnZS5wbmcKK1RoaXMgdGVzdCByZXF1aXJl cyBEdW1wUmVuZGVyVHJlZS4gVG8gdGVzdCBtYW51YWxseSwgZHJhZyB0aGUgaW1hZ2UgdG8gdGhl IGRlc2t0b3AuIEl0IHNob3VsZCByZWNlaXZlIHRoZSBuYW1lICJvbmxvYWQtaW1hZ2UucG5nIi4K KworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZpbGVu YW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZpbGVuYW1lLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZTc4ZTdkNTVhODVlZmQyNmRhOGFkZmRiYTY3NzNkNjhhOTI5MDgyNwot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmls ZW5hbWUuaHRtbApAQCAtMCwwICsxLDUzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhl YWQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gcnVuVGVzdCgpIHsKKyAgICBpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAg IH0gZWxzZQorICAgICAgICByZXR1cm47CisgICAgCisgICAgZSA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJzb3VyY2UiKTsKKyAgICB4ID0gZS5vZmZzZXRMZWZ0ICsgZS5vZmZzZXRXaWR0aCAv IDI7CisgICAgeSA9IGUub2Zmc2V0VG9wICsgZS5vZmZzZXRIZWlnaHQgLyAyOworCisgICAgZXZl bnRTZW5kZXIubW91c2VNb3ZlVG8oeCwgeSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7 ICAgIAorICAgIGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CisgICAgeCA9 IGUub2Zmc2V0TGVmdCArIGUub2Zmc2V0V2lkdGggLyAyOworICAgIHkgPSBlLm9mZnNldFRvcCAr IGUub2Zmc2V0SGVpZ2h0IC8gMjsKKyAgICAKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4 LCB5KTsKKyAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7Cit9CisKK2Z1bmN0aW9uIGRyYWdFbnRl ck9yT3ZlcihldmVudCkgeworICAgIGV2ZW50LmRhdGFUcmFuc2Zlci5kcm9wRWZmZWN0ID0gImNv cHkiOworICAgIGV2ZW50LnByZXZlbnREZWZhdWx0KCk7Cit9CisKK2Z1bmN0aW9uIGRyb3AoZXZl bnQpIHsKKyAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpOworICAgIGV2ZW50U2VuZGVyLmR1bXBG aWxlbmFtZUJlaW5nRHJhZ2dlZCgpOworICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKK30KKzwvc2NyaXB0PgorPHN0eWxlPgorI3RhcmdldCB7CisgICAgaGVpZ2h0OiAxMDBw eDsKKyAgICB3aWR0aDogMTAwcHg7Cit9Cis8L3N0eWxlPgorPC9oZWFkPgorCis8Ym9keSBvbmxv YWQ9InJ1blRlc3QoKSI+ICAKKworPHA+VGhpcyB0ZXN0IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVl LiBUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIHRoZSBpbWFnZSB0byB0aGUgZGVza3RvcC4gSXQgc2hv dWxkIHJlY2VpdmUgdGhlIG5hbWUgIm9ubG9hZC1pbWFnZS5wbmciLgorCis8ZGl2IGlkPSJ0YXJn ZXQiIG9uZHJhZ2VudGVyPSJkcmFnRW50ZXJPck92ZXIoZXZlbnQpIiBvbmRyYWdvdmVyPSJkcmFn RW50ZXJPck92ZXIoZXZlbnQpIiBvbmRyb3A9ImRyb3AoZXZlbnQpIj48L2Rpdj4KKzxpbWcgaWQ9 InNvdXJjZSIgc3JjPSJyZXNvdXJjZXMvb25sb2FkLWltYWdlLnBuZyIgYWx0PSJEb2VzIGl0IHdv cms/Ij4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vZ3RrL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAppbmRleCBi OTg0NDNiNTA0NDUxYzczNDhiNzk1YmY0ZWI4Y2Q4OTA2ODc3YmRjLi40NTU2NTQwODc2MGY3OTIx MTIwY2FlN2FlMzlkYmU3ZGJkYTk5MWNhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9ndGsvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApAQCAt MTE0Myw2ICsxMTQzLDEwIEBAIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvcmVtZW1iZXItYmFk LXBhc3N3b3JkLmh0bWwKIGZhc3QvY3NzL3VzZXItZHJhZy1ub25lLmh0bWwKIGZhc3QvZXZlbnRz LzUwNTY2MTkuaHRtbAogCisjIEV2ZW50U2VuZGVyOjpkdW1wRmlsZW5hbWVCZWluZ0RyYWdnZWQg bm90IGltcGxlbWVudGVkLgorIyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NjE4MjYKK2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmlsZW5hbWUuaHRtbAorCiAjIFRlc3Rz IHRoYXQgZmFpbCBiZWNhdXNlIHRoZXkgYXNzdW1lIGEgY2VydGFpbiBudW1iZXIgb2YgbW91c2UK ICMgbW92ZW1lbnRzIGR1cmluZyBkcmFncyBvciBmYWlsIG9ubHkgaW4gWHZmYgogaHR0cC90ZXN0 cy9sb2NhbC9kcmFnLW92ZXItcmVtb3RlLWNvbnRlbnQuaHRtbApkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tp cHBlZAppbmRleCBiMDJkNDJhODkyMjg1NmRjMTM4MTgxN2Q4NGExZWY3OGIyNzQ2OGUxLi4wYzBm Mzg5OWM0NGRjYThkZWEwMTVhMDVkOWE2MjljM2Q3Nzc4YmIxIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv U2tpcHBlZApAQCAtMTkxLDYgKzE5MSwxMCBAQCBodHRwL3Rlc3RzL21pc2MvcHJlZmV0Y2gtcHVy cG9zZS5odG1sCiAjIEZpbGVuYW1lcyBhcmVuJ3QgZmlsdGVyZWQgb3V0IGZyb20gZWRpdCBkcmFn cyB5ZXQsIHNlZSBodHRwczovL2J1Z3Mud2VraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODgyNgog ZWRpdGluZy9wYXN0ZWJvYXJkL2ZpbGUtZHJhZy10by1lZGl0YWJsZS5odG1sCiAKKyMgRXZlbnRT ZW5kZXI6OmR1bXBGaWxlbmFtZUJlaW5nRHJhZ2dlZCBub3QgaW1wbGVtZW50ZWQuCisjIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02MTgyNworZmFzdC9ldmVudHMvZHJh Zy1pbWFnZS1maWxlbmFtZS5odG1sCisKICMgSGl0cyBhbiBhc3NlcnQgaW4gRnJhbWVMb2FkZXIu Y3BwLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzEzODcKIGh0dHAv dGVzdHMvbXVsdGlwYXJ0L3BvbGljeS1pZ25vcmUtY3Jhc2gucGhwCiAKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL3F0L1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9T a2lwcGVkCmluZGV4IDMxZmU0Yjg3MDdjNTExMTk3MWM1OThhYzkyMGI1ODJjNmZkYjNmMTUuLjFk ZDJlNjQxYmE3OTZjZmEzMDU2MWQ2MGVmOGI1MmEyZGQ2NDkyMjAgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL3F0L1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQv U2tpcHBlZApAQCAtMTcyLDYgKzE3MiwxMCBAQCBmYXN0L2Nzcy91c2VyLWRyYWctbm9uZS5odG1s CiBmYXN0L2ltYWdlcy9kcmFnLXN2Zy1hcy1pbWFnZS5odG1sCiBmYXN0L2Zvcm1zL3NsaWRlci1k ZWxldGUtd2hpbGUtZHJhZ2dpbmctdGh1bWIuaHRtbAogCisjIEV2ZW50U2VuZGVyOjpkdW1wRmls ZW5hbWVCZWluZ0RyYWdnZWQgbm90IGltcGxlbWVudGVkLgorIyBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE4MjgKK2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmlsZW5h bWUuaHRtbAorCiAjIC0tLS0tLS0gbWlzc2luZyBkcmFnLWFuZC1kcm9wIHN1cHBvcnQKICMgU2Vl IGJ1ZyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzEzMzIKIGZhc3Qv ZXZlbnRzL2RyYWctcGFyZW50LW5vZGUuaHRtbApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxh dGZvcm0vd2luL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZAppbmRl eCAzOGIyNzQ5MWI3NzQ0ZGI0ZmU1MDIyZjZlZDFmYjJkZTFhYmFkZjgwLi4yYzY0ZGFmYTE2NGRh ZmIxYzEyOGJlZWQ4YTE5MmFiYTAzZTFlYmFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS93aW4vU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZApA QCAtMTI2LDYgKzEyNiwxMCBAQCBmYXN0L2V2ZW50cy9kcmFnLWluLWZyYW1lcy5odG1sCiBmYXN0 L2V2ZW50cy9zdGFuZGFsb25lLWltYWdlLWRyYWctdG8tZWRpdGFibGUuaHRtbAogaHR0cC90ZXN0 cy9zZWN1cml0eS9kcmFnLWRyb3Atc2FtZS11bmlxdWUtb3JpZ2luLmh0bWwKIAorIyBFdmVudFNl bmRlcjo6ZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkIG5vdCBpbXBsZW1lbnRlZC4KKyMgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYxODI5CitmYXN0L2V2ZW50cy9kcmFn LWltYWdlLWZpbGVuYW1lLmh0bWwKKwogIyA8cmRhcjovL3Byb2JsZW0vNTY0MzY3NT4gd2luZG93 LnNjcm9sbFRvIHNjcm9sbHMgYSB3aW5kb3cgd2l0aCBubyBzY3JvbGxiYXJzCiBmYXN0L2V2ZW50 cy9hdHRlbXB0LXNjcm9sbC13aXRoLW5vLXNjcm9sbGJhcnMuaHRtbAogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YzM0NzMzNWYzMDk3ZjIwMmZkZDE0NTMzNjk0MjM0NzQ2MzYxN2QzNC4uZWYwNDZmNTAwNzlmOTM1 NjM2N2FhNWExM2Y5YmJlNDgxZGE3NTdmZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisy MDExLTA1LTMxICBEYW5pZWwgQ2hlbmcgIDxkY2hlbmdAY2hyb21pdW0ub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVXNlIGNv cnJlY3QgZmlsZSBuYW1lIGZvciBkcmFnZ2luZyBvdXQgaW1hZ2VzLgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjQ4ODcKKworICAgICAgICBXZSB0cnkg dG8gZ3Vlc3MgYW4gYXBwcm9wcmlhdGUgZmlsZW5hbWUgd2hlbiBkcmFnZ2luZyBvdXQgaW1hZ2Vz LiBJbiBvcmRlciwgd2UgdHJ5IHRvIHVzZToKKyAgICAgICAgLSBUaGUgZmlsZW5hbWUgc3VnZ2Vz dGVkIGluIHRoZSBIVFRQIGhlYWRlci4KKyAgICAgICAgLSBUaGUgbGFzdCBwYXRoIGNvbXBvbmVu dCBvZiB0aGUgc291cmNlIFVSTC4KKyAgICAgICAgLSBUaGUgYWx0IHRleHQuCisgICAgICAgIFRo aXMgbWF0Y2hlcyB0aGUgYmVoYXZpb3Igb2YgdGhlIG90aGVyIFdlYktpdCBwb3J0cy4KKworICAg ICAgICBUZXN0OiBmYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZpbGVuYW1lLmh0bWwKKworICAgICAg ICAqIHBsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OndyaXRlSW1hZ2VUb0RhdGFPYmplY3QpOgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9t aXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzSW52YWxp ZEZpbGVDaGFyYWN0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OnZh bGlkYXRlRmlsZU5hbWUpOgorCiAyMDExLTA1LTMxICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KQEAgLTExMCw3ICsx MzEsNiBAQAogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb29wQmxpbm5NYXRoVXRp bHMuY3BwOgogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9UaWxpbmdEYXRhLmNwcDoK IAotPDw8PDw8PCAubWluZQogMjAxMS0wNS0zMSAgSnVzdGluIE5vdm9zYWQgIDxqdW5vdkBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU3RlcGhlbiBXaGl0ZS4KQEAgLTEyMyw3 ICsxNDMsNiBAQAogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb29wQmxpbm5NYXRo VXRpbHMuY3BwOgogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9UaWxpbmdEYXRhLmNw cDoKIAotPT09PT09PQogMjAxMS0wNS0zMSAgUm9iIEJ1aXMgIDxyYnVpc0ByaW0uY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IERpcmsgU2NodWx6ZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcAppbmRleCA1YmMyNmY3 NGQ4MDJmOWJhODA0ZjMxOWEyNWFkMmU5YzYyZTE5NjQ3Li5mNTY3NWUyNGU2MTkyZmVmZjdmOGY0 ZjczMTNkOGU5N2U3ZmJjMmViIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9j aHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCkBAIC0yMjQsMTkgKzIyNCwyNSBAQCBz dGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KENocm9taXVtRGF0YU9iamVjdCogZGF0 YU9iamVjdCwgRWxlbWVudCogZWxlbQogCiAgICAgZGF0YU9iamVjdC0+c2V0RmlsZUNvbnRlbnQo aW1hZ2VCdWZmZXIpOwogCi0gICAgLy8gRGV0ZXJtaW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZp bGUgY29udGVudHMgb2YgdGhlIGltYWdlLiAgV2UgdHJ5IHRvCi0gICAgLy8gdXNlIHRoZSBhbHQg dGFnIGlmIG9uZSBleGlzdHMsIG90aGVyd2lzZSB3ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dlc3Rl ZAotICAgIC8vIGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciwgYW5kIGZpbmFsbHkgd2UgcmVz b3J0IHRvIHVzaW5nIHRoZSBmaWxlbmFtZQotICAgIC8vIGluIHRoZSBVUkwuCisgICAgLy8gRGV0 ZXJtaW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZpbGUgY29udGVudHMgb2YgdGhlIGltYWdlLgor ICAgIFN0cmluZyBmaWxlbmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZp bGVuYW1lKCk7CisgICAgaWYgKGZpbGVuYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgZmlsZW5hbWUg PSB1cmwubGFzdFBhdGhDb21wb25lbnQoKTsKKyAgICBpZiAoZmlsZW5hbWUuaXNFbXB0eSgpKQor ICAgICAgICBmaWxlbmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICBl bHNlIHsKKyAgICAgICAgLy8gU3RyaXAgYW55IGV4aXN0aW5nIGV4dGVuc2lvbi4gQXNzdW1lIHRo YXQgYWx0IHRleHQgaXMgdXN1YWxseSBub3QgYSBmaWxlbmFtZS4KKyAgICAgICAgaW50IGV4dGVu c2lvbkluZGV4ID0gZmlsZW5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICAgICAgaWYgKGV4dGVu c2lvbkluZGV4ICE9IC0xKQorICAgICAgICAgICAgZmlsZW5hbWUudHJ1bmNhdGUoZXh0ZW5zaW9u SW5kZXgpOworICAgIH0KKyAgICBmaWxlbmFtZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0 ZUZpbGVOYW1lKGZpbGVuYW1lLCBkYXRhT2JqZWN0KTsKKwogICAgIFN0cmluZyBleHRlbnNpb24g PSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRFeHRlbnNpb25Gb3JNSU1FVHlwZSgKICAg ICAgICAgY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWltZVR5cGUoKSk7CiAgICAgZGF0YU9iamVj dC0+c2V0RmlsZUV4dGVuc2lvbihleHRlbnNpb24uaXNFbXB0eSgpID8gZW1wdHlTdHJpbmcoKSA6 ICIuIiArIGV4dGVuc2lvbik7Ci0gICAgU3RyaW5nIHRpdGxlID0gZWxlbWVudC0+Z2V0QXR0cmli dXRlKGFsdEF0dHIpOwotICAgIGlmICh0aXRsZS5pc0VtcHR5KCkpCi0gICAgICAgIHRpdGxlID0g Y2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKIAotICAgIHRpdGxl ID0gQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUodGl0bGUsIGRhdGFPYmplY3Qp OwotICAgIGRhdGFPYmplY3QtPnNldEZpbGVDb250ZW50RmlsZW5hbWUodGl0bGUgKyBkYXRhT2Jq ZWN0LT5maWxlRXh0ZW5zaW9uKCkpOworICAgIGRhdGFPYmplY3QtPnNldEZpbGVDb250ZW50Rmls ZW5hbWUoZmlsZW5hbWUgKyBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uKCkpOwogfQogCiB2b2lk IENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoRWxlbWVudCogZWxl bWVudCwgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBGcmFtZSogZnJhbWUp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRD aHJvbWl1bU1hYy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9h cmRDaHJvbWl1bU1hYy5jcHAKaW5kZXggMmM4OWY2ZThlZTk5OTIwMjkxMmIzZDhkYjliZjViYjc3 MjU3N2E5Ny4uMzgwMjE0MDJlYjkyOWUzY2M2ZTI1MWQyMjNmMDA3NDY2YWRmMmYyNyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW1N YWMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENo cm9taXVtTWFjLmNwcApAQCAtMjgsMTQgKzI4LDQyIEBACiAjaW5jbHVkZSAiQ2xpcGJvYXJkQ2hy b21pdW0uaCIKIAogI2luY2x1ZGUgIkNocm9taXVtRGF0YU9iamVjdC5oIgotI2luY2x1ZGUgIk5v dEltcGxlbWVudGVkLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKKworLy8gRmlsZW5h bWUgbGVuZ3RoIGFuZCBjaGFyYWN0ZXItc2V0IGxpbWl0cyB2YXJ5IGJ5IGZpbGVzeXN0ZW0sIGFu ZCB0aGVyZSdzIG5vCisvLyByZWFsIHdheSB0byB0ZWxsIHdoYXQgZmlsZXN5c3RlbSBpcyBpbiB1 c2UuIFNpbmNlIEhGUysgaXMgYnkgZmFyIHRoZSBtb3N0CisvLyBjb21tb24sIHdlJ2xsIGFiaWRl IGJ5IGl0cyBsaW1pdHMsIHdoaWNoIGFyZSAyNTUgVW5pY29kZSBjaGFyYWN0ZXJzIChzbGlnaHRs eQorLy8gc2ltcGxpZmllZDsgcmVhbGx5IGl0IHVzZXMgTm9ybWFsaXphdGlvbiBGb3JtIEQsIGJ1 dCB0aGUgZGlmZmVyZW5jZXMgYXJlbid0CisvLyByZWFsbHkgd29ydGggZGVhbGluZyB3aXRoIGhl cmUuKQorc3RhdGljIGNvbnN0IHVuc2lnbmVkIE1heEhGU0ZpbGVuYW1lTGVuZ3RoID0gMjU1Owor CisKK3N0YXRpYyBib29sIGlzSW52YWxpZEZpbGVDaGFyYWN0ZXIoVUNoYXIgYykKK3sKKyAgICAv LyBIRlMrIGJhc2ljYWxseSBhbGxvd3MgYW55dGhpbmcgYnV0ICcvJy4gRm9yIHNhbml0eSdzIHNh a2Ugd2UnbGwgZGlzYWxsb3cKKyAgICAvLyBjb250cm9sIGNoYXJhY3RlcnMuCisgICAgcmV0dXJu IGMgPCAnICcgfHwgYyA9PSAweDdGIHx8IGMgPT0gJy8nOworfQogCiBTdHJpbmcgQ2xpcGJvYXJk Q2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoY29uc3QgU3RyaW5nJiB0aXRsZSwgQ2hyb21pdW1E YXRhT2JqZWN0KiBkYXRhT2JqZWN0KQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0 dXJuIHRpdGxlOworICAgIC8vIFJlbW92ZSBhbnkgaW52YWxpZCBmaWxlIHN5c3RlbSBjaGFyYWN0 ZXJzLCBlc3BlY2lhbGx5ICIvIi4KKyAgICBTdHJpbmcgcmVzdWx0ID0gdGl0bGUucmVtb3ZlQ2hh cmFjdGVycyhpc0ludmFsaWRGaWxlQ2hhcmFjdGVyKTsKKyAgICBTdHJpbmcgZXh0ZW5zaW9uID0g ZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbigpLnJlbW92ZUNoYXJhY3RlcnMoJmlzSW52YWxpZEZp bGVDaGFyYWN0ZXIpOworCisgICAgLy8gUmVtb3ZlIGEgcmlkaWN1bG91c2x5LWxvbmcgZXh0ZW5z aW9uLgorICAgIGlmIChleHRlbnNpb24ubGVuZ3RoKCkgPj0gTWF4SEZTRmlsZW5hbWVMZW5ndGgp CisgICAgICAgIGV4dGVuc2lvbiA9ICIiOworICAgIAorICAgIC8vIFRydW5jYXRlIGFuIG92ZXJs eS1sb25nIGZpbGVuYW1lLgorICAgIGludCBvdmVyZmxvdyA9IHJlc3VsdC5sZW5ndGgoKSArIGV4 dGVuc2lvbi5sZW5ndGgoKSAtIE1heEhGU0ZpbGVuYW1lTGVuZ3RoOworICAgIGlmIChvdmVyZmxv dyA+IDApIAorICAgICAgICByZXN1bHQucmVtb3ZlKHJlc3VsdC5sZW5ndGgoKSAtIG92ZXJmbG93 LCBvdmVyZmxvdyk7CisgICAgCisgICAgZGF0YU9iamVjdC0+c2V0RmlsZUV4dGVuc2lvbihleHRl bnNpb24pOworICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIH0gIC8vIG5hbWVzcGFjZSBXZWJDb3Jl CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZTQ3 YzlkZWIzNzM5OWRlMjYyMmRiNTlmOTJlMGRkY2I4NzgzOWMzYS4uMTJlODFkM2M2ZTdjZWZiNWE2 ZjFmYTI1YzYyNjE4OGYyYjMwZjVlZiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBi L1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDExLTA1LTMxICBEYW5pZWwgQ2hl bmcgIDxkY2hlbmdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVXNlIGNvcnJlY3QgZmlsZSBuYW1lIGZvciBk cmFnZ2luZyBvdXQgaW1hZ2VzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjQ4ODcKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0V2 ZW50U2VuZGVyLmNwcDoKKyAgICAgICAgKEV2ZW50U2VuZGVyOjpFdmVudFNlbmRlcik6CisgICAg ICAgIChFdmVudFNlbmRlcjo6ZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkKToKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5oOgorCiAyMDExLTA1LTMxICBFcmlj IFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZpZCBL aWx6ZXIuCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNl bmRlci5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5jcHAK aW5kZXggOWU1NTU4OTNlOThhN2EwNGRkNDVjNTVjYjAyOWRjMTc1YmY4Y2MwNS4uNThmZTRmY2Qy MjczNzgxYzFmYTc0MmIxMjBlMmYzNjMxNDc5MzcyZCAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJl bmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmNwcApAQCAtMjU5LDYgKzI1OSw3IEBAIEV2ZW50U2Vu ZGVyOjpFdmVudFNlbmRlcihUZXN0U2hlbGwqIHNoZWxsKQogICAgIGJpbmRNZXRob2QoImNvbnRl eHRDbGljayIsICZFdmVudFNlbmRlcjo6Y29udGV4dENsaWNrKTsKICAgICBiaW5kTWV0aG9kKCJj b250aW51b3VzTW91c2VTY3JvbGxCeSIsICZFdmVudFNlbmRlcjo6Y29udGludW91c01vdXNlU2Ny b2xsQnkpOwogICAgIGJpbmRNZXRob2QoImRpc3BhdGNoTWVzc2FnZSIsICZFdmVudFNlbmRlcjo6 ZGlzcGF0Y2hNZXNzYWdlKTsKKyAgICBiaW5kTWV0aG9kKCJkdW1wRmlsZW5hbWVCZWluZ0RyYWdn ZWQiLCAmRXZlbnRTZW5kZXI6OmR1bXBGaWxlbmFtZUJlaW5nRHJhZ2dlZCk7CiAgICAgYmluZE1l dGhvZCgiZW5hYmxlRE9NVUlFdmVudExvZ2dpbmciLCAmRXZlbnRTZW5kZXI6OmVuYWJsZURPTVVJ RXZlbnRMb2dnaW5nKTsKICAgICBiaW5kTWV0aG9kKCJmaXJlS2V5Ym9hcmRFdmVudHNUb0VsZW1l bnQiLCAmRXZlbnRTZW5kZXI6OmZpcmVLZXlib2FyZEV2ZW50c1RvRWxlbWVudCk7CiAgICAgYmlu ZE1ldGhvZCgia2V5RG93biIsICZFdmVudFNlbmRlcjo6a2V5RG93bik7CkBAIC0zNDQsNiArMzQ1 LDExIEBAIHZvaWQgRXZlbnRTZW5kZXI6OmRvRHJhZ0Ryb3AoY29uc3QgV2ViRHJhZ0RhdGEmIGRy YWdEYXRhLCBXZWJEcmFnT3BlcmF0aW9uc01hc2sKICAgICByZXBsYXlTYXZlZEV2ZW50cygpOwog fQogCit2b2lkIEV2ZW50U2VuZGVyOjpkdW1wRmlsZW5hbWVCZWluZ0RyYWdnZWQoY29uc3QgQ3Bw QXJndW1lbnRMaXN0JiBhcmd1bWVudHMsIENwcFZhcmlhbnQqIHJlc3VsdCkKK3sKKyAgICBwcmlu dGYoIkZpbGVuYW1lIGJlaW5nIGRyYWdnZWQ6ICVzXG4iLCBjdXJyZW50RHJhZ0RhdGEuZmlsZUNv bnRlbnRGaWxlbmFtZSgpLnV0ZjgoKS5kYXRhKCkpOworfQorCiBXZWJNb3VzZUV2ZW50OjpCdXR0 b24gRXZlbnRTZW5kZXI6OmdldEJ1dHRvblR5cGVGcm9tQnV0dG9uTnVtYmVyKGludCBidXR0b25D b2RlKQogewogICAgIGlmICghYnV0dG9uQ29kZSkKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmggYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJv bWl1bS9FdmVudFNlbmRlci5oCmluZGV4IGRlMWNhMDU0MDM5MTIyNTc3YzlkNmRiZTNjOWY2YTg1 NGE0YzhhODYuLjU0YjA2NTAzM2M2ODE5MmMzNzcyMTgzNjU1MzllYzQ3OThmOTFiM2IgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmgKKysrIGIv VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIuaApAQCAtNjIsNiArNjIs OSBAQCBwdWJsaWM6CiAgICAgLy8gU2ltdWxhdGUgZHJhZyZkcm9wIHN5c3RlbSBjYWxsLgogICAg IHZvaWQgZG9EcmFnRHJvcChjb25zdCBXZWJLaXQ6OldlYkRyYWdEYXRhJiwgV2ViS2l0OjpXZWJE cmFnT3BlcmF0aW9uc01hc2spOwogCisgICAgLy8gVGVzdCBoZWxwZXIgZm9yIGRyYWdnaW5nIG91 dCBpbWFnZXMuCisgICAgdm9pZCBkdW1wRmlsZW5hbWVCZWluZ0RyYWdnZWQoY29uc3QgQ3BwQXJn dW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopOworCiAgICAgLy8gSlMgY2FsbGJhY2sgbWV0aG9kcy4K ICAgICB2b2lkIG1vdXNlRG93bihjb25zdCBDcHBBcmd1bWVudExpc3QmLCBDcHBWYXJpYW50Kik7 CiAgICAgdm9pZCBtb3VzZVVwKGNvbnN0IENwcEFyZ3VtZW50TGlzdCYsIENwcFZhcmlhbnQqKTsK 95528 2011-05-31 18:26:14 -0700 2011-06-01 14:13:20 -0700 Patch bug-24887-20110531182613.patch text/plain 14119 dcheng U3VidmVyc2lvbiBSZXZpc2lvbjogODc3NTYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA0ZGZlNTdmNzhmMjczMWM4ZjlmZTdm M2NlMjk5ZTlkOGEyYjUwZTQ5Li45OTk5NjQ5MGZlYjdmOGI4ZmVjMWE0N2EwOTViYWQ5MDVhMDg0 NmQ1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDUtMzEgIERhbmllbCBDaGVuZyAgPGRj aGVuZ0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgW2Nocm9taXVtXSBVc2UgY29ycmVjdCBmaWxlIG5hbWUgZm9yIGRyYWdnaW5n IG91dCBpbWFnZXMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNDg4NworCisgICAgICAgICogZmFzdC9ldmVudHMvZHJhZy1pbWFnZS1maWxlbmFtZS1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmls ZW5hbWUuaHRtbDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBwZWQ6CisgICAg ICAgICogcGxhdGZvcm0vbWFjL1NraXBwZWQ6CisgICAgICAgICogcGxhdGZvcm0vcXQvU2tpcHBl ZDoKKyAgICAgICAgKiBwbGF0Zm9ybS93aW4vU2tpcHBlZDoKKwogMjAxMS0wNS0zMSAgSGFvIFpo ZW5nICA8emhlbmdoYW9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFRvbnkg Q2hhbmcuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZp bGVuYW1lLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2Ut ZmlsZW5hbWUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdhMjI0YmEwZmU0YTdjZmYxYWNjZTgx Y2FjNGZmOTA0OGIzMmJlZjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2V2 ZW50cy9kcmFnLWltYWdlLWZpbGVuYW1lLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDQgQEAKK0Zp bGVuYW1lIGJlaW5nIGRyYWdnZWQ6IG9ubG9hZC1pbWFnZS5wbmcKK1RoaXMgdGVzdCByZXF1aXJl cyBEdW1wUmVuZGVyVHJlZS4gVG8gdGVzdCBtYW51YWxseSwgZHJhZyB0aGUgaW1hZ2UgdG8gdGhl IGRlc2t0b3AuIEl0IHNob3VsZCByZWNlaXZlIHRoZSBuYW1lICJvbmxvYWQtaW1hZ2UucG5nIi4K KworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZpbGVu YW1lLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZpbGVuYW1lLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZTc4ZTdkNTVhODVlZmQyNmRhOGFkZmRiYTY3NzNkNjhhOTI5MDgyNwot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmls ZW5hbWUuaHRtbApAQCAtMCwwICsxLDUzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhl YWQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gcnVuVGVzdCgpIHsKKyAgICBpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAg IH0gZWxzZQorICAgICAgICByZXR1cm47CisgICAgCisgICAgZSA9IGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJzb3VyY2UiKTsKKyAgICB4ID0gZS5vZmZzZXRMZWZ0ICsgZS5vZmZzZXRXaWR0aCAv IDI7CisgICAgeSA9IGUub2Zmc2V0VG9wICsgZS5vZmZzZXRIZWlnaHQgLyAyOworCisgICAgZXZl bnRTZW5kZXIubW91c2VNb3ZlVG8oeCwgeSk7CisgICAgZXZlbnRTZW5kZXIubW91c2VEb3duKCk7 ICAgIAorICAgIGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CisgICAgeCA9 IGUub2Zmc2V0TGVmdCArIGUub2Zmc2V0V2lkdGggLyAyOworICAgIHkgPSBlLm9mZnNldFRvcCAr IGUub2Zmc2V0SGVpZ2h0IC8gMjsKKyAgICAKKyAgICBldmVudFNlbmRlci5tb3VzZU1vdmVUbyh4 LCB5KTsKKyAgICBldmVudFNlbmRlci5tb3VzZVVwKCk7Cit9CisKK2Z1bmN0aW9uIGRyYWdFbnRl ck9yT3ZlcihldmVudCkgeworICAgIGV2ZW50LmRhdGFUcmFuc2Zlci5kcm9wRWZmZWN0ID0gImNv cHkiOworICAgIGV2ZW50LnByZXZlbnREZWZhdWx0KCk7Cit9CisKK2Z1bmN0aW9uIGRyb3AoZXZl bnQpIHsKKyAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpOworICAgIGV2ZW50U2VuZGVyLmR1bXBG aWxlbmFtZUJlaW5nRHJhZ2dlZCgpOworICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKK30KKzwvc2NyaXB0PgorPHN0eWxlPgorI3RhcmdldCB7CisgICAgaGVpZ2h0OiAxMDBw eDsKKyAgICB3aWR0aDogMTAwcHg7Cit9Cis8L3N0eWxlPgorPC9oZWFkPgorCis8Ym9keSBvbmxv YWQ9InJ1blRlc3QoKSI+ICAKKworPHA+VGhpcyB0ZXN0IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVl LiBUbyB0ZXN0IG1hbnVhbGx5LCBkcmFnIHRoZSBpbWFnZSB0byB0aGUgZGVza3RvcC4gSXQgc2hv dWxkIHJlY2VpdmUgdGhlIG5hbWUgIm9ubG9hZC1pbWFnZS5wbmciLgorCis8ZGl2IGlkPSJ0YXJn ZXQiIG9uZHJhZ2VudGVyPSJkcmFnRW50ZXJPck92ZXIoZXZlbnQpIiBvbmRyYWdvdmVyPSJkcmFn RW50ZXJPck92ZXIoZXZlbnQpIiBvbmRyb3A9ImRyb3AoZXZlbnQpIj48L2Rpdj4KKzxpbWcgaWQ9 InNvdXJjZSIgc3JjPSJyZXNvdXJjZXMvb25sb2FkLWltYWdlLnBuZyIgYWx0PSJEb2VzIGl0IHdv cms/Ij4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vZ3RrL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAppbmRleCBi OTg0NDNiNTA0NDUxYzczNDhiNzk1YmY0ZWI4Y2Q4OTA2ODc3YmRjLi40NTU2NTQwODc2MGY3OTIx MTIwY2FlN2FlMzlkYmU3ZGJkYTk5MWNhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9ndGsvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApAQCAt MTE0Myw2ICsxMTQzLDEwIEBAIGh0dHAvdGVzdHMveG1saHR0cHJlcXVlc3QvcmVtZW1iZXItYmFk LXBhc3N3b3JkLmh0bWwKIGZhc3QvY3NzL3VzZXItZHJhZy1ub25lLmh0bWwKIGZhc3QvZXZlbnRz LzUwNTY2MTkuaHRtbAogCisjIEV2ZW50U2VuZGVyOjpkdW1wRmlsZW5hbWVCZWluZ0RyYWdnZWQg bm90IGltcGxlbWVudGVkLgorIyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NjE4MjYKK2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmlsZW5hbWUuaHRtbAorCiAjIFRlc3Rz IHRoYXQgZmFpbCBiZWNhdXNlIHRoZXkgYXNzdW1lIGEgY2VydGFpbiBudW1iZXIgb2YgbW91c2UK ICMgbW92ZW1lbnRzIGR1cmluZyBkcmFncyBvciBmYWlsIG9ubHkgaW4gWHZmYgogaHR0cC90ZXN0 cy9sb2NhbC9kcmFnLW92ZXItcmVtb3RlLWNvbnRlbnQuaHRtbApkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vbWFjL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvU2tp cHBlZAppbmRleCBiMDJkNDJhODkyMjg1NmRjMTM4MTgxN2Q4NGExZWY3OGIyNzQ2OGUxLi4wYzBm Mzg5OWM0NGRjYThkZWEwMTVhMDVkOWE2MjljM2Q3Nzc4YmIxIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv U2tpcHBlZApAQCAtMTkxLDYgKzE5MSwxMCBAQCBodHRwL3Rlc3RzL21pc2MvcHJlZmV0Y2gtcHVy cG9zZS5odG1sCiAjIEZpbGVuYW1lcyBhcmVuJ3QgZmlsdGVyZWQgb3V0IGZyb20gZWRpdCBkcmFn cyB5ZXQsIHNlZSBodHRwczovL2J1Z3Mud2VraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODgyNgog ZWRpdGluZy9wYXN0ZWJvYXJkL2ZpbGUtZHJhZy10by1lZGl0YWJsZS5odG1sCiAKKyMgRXZlbnRT ZW5kZXI6OmR1bXBGaWxlbmFtZUJlaW5nRHJhZ2dlZCBub3QgaW1wbGVtZW50ZWQuCisjIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02MTgyNworZmFzdC9ldmVudHMvZHJh Zy1pbWFnZS1maWxlbmFtZS5odG1sCisKICMgSGl0cyBhbiBhc3NlcnQgaW4gRnJhbWVMb2FkZXIu Y3BwLiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzEzODcKIGh0dHAv dGVzdHMvbXVsdGlwYXJ0L3BvbGljeS1pZ25vcmUtY3Jhc2gucGhwCiAKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL3F0L1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9T a2lwcGVkCmluZGV4IDMxZmU0Yjg3MDdjNTExMTk3MWM1OThhYzkyMGI1ODJjNmZkYjNmMTUuLjFk ZDJlNjQxYmE3OTZjZmEzMDU2MWQ2MGVmOGI1MmEyZGQ2NDkyMjAgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL3F0L1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQv U2tpcHBlZApAQCAtMTcyLDYgKzE3MiwxMCBAQCBmYXN0L2Nzcy91c2VyLWRyYWctbm9uZS5odG1s CiBmYXN0L2ltYWdlcy9kcmFnLXN2Zy1hcy1pbWFnZS5odG1sCiBmYXN0L2Zvcm1zL3NsaWRlci1k ZWxldGUtd2hpbGUtZHJhZ2dpbmctdGh1bWIuaHRtbAogCisjIEV2ZW50U2VuZGVyOjpkdW1wRmls ZW5hbWVCZWluZ0RyYWdnZWQgbm90IGltcGxlbWVudGVkLgorIyBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjE4MjgKK2Zhc3QvZXZlbnRzL2RyYWctaW1hZ2UtZmlsZW5h bWUuaHRtbAorCiAjIC0tLS0tLS0gbWlzc2luZyBkcmFnLWFuZC1kcm9wIHN1cHBvcnQKICMgU2Vl IGJ1ZyBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzEzMzIKIGZhc3Qv ZXZlbnRzL2RyYWctcGFyZW50LW5vZGUuaHRtbApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxh dGZvcm0vd2luL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZAppbmRl eCAzOGIyNzQ5MWI3NzQ0ZGI0ZmU1MDIyZjZlZDFmYjJkZTFhYmFkZjgwLi4yYzY0ZGFmYTE2NGRh ZmIxYzEyOGJlZWQ4YTE5MmFiYTAzZTFlYmFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS93aW4vU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vU2tpcHBlZApA QCAtMTI2LDYgKzEyNiwxMCBAQCBmYXN0L2V2ZW50cy9kcmFnLWluLWZyYW1lcy5odG1sCiBmYXN0 L2V2ZW50cy9zdGFuZGFsb25lLWltYWdlLWRyYWctdG8tZWRpdGFibGUuaHRtbAogaHR0cC90ZXN0 cy9zZWN1cml0eS9kcmFnLWRyb3Atc2FtZS11bmlxdWUtb3JpZ2luLmh0bWwKIAorIyBFdmVudFNl bmRlcjo6ZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkIG5vdCBpbXBsZW1lbnRlZC4KKyMgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYxODI5CitmYXN0L2V2ZW50cy9kcmFn LWltYWdlLWZpbGVuYW1lLmh0bWwKKwogIyA8cmRhcjovL3Byb2JsZW0vNTY0MzY3NT4gd2luZG93 LnNjcm9sbFRvIHNjcm9sbHMgYSB3aW5kb3cgd2l0aCBubyBzY3JvbGxiYXJzCiBmYXN0L2V2ZW50 cy9hdHRlbXB0LXNjcm9sbC13aXRoLW5vLXNjcm9sbGJhcnMuaHRtbAogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YzM0NzMzNWYzMDk3ZjIwMmZkZDE0NTMzNjk0MjM0NzQ2MzYxN2QzNC4uZWYwNDZmNTAwNzlmOTM1 NjM2N2FhNWExM2Y5YmJlNDgxZGE3NTdmZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisy MDExLTA1LTMxICBEYW5pZWwgQ2hlbmcgIDxkY2hlbmdAY2hyb21pdW0ub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVXNlIGNv cnJlY3QgZmlsZSBuYW1lIGZvciBkcmFnZ2luZyBvdXQgaW1hZ2VzLgorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjQ4ODcKKworICAgICAgICBXZSB0cnkg dG8gZ3Vlc3MgYW4gYXBwcm9wcmlhdGUgZmlsZW5hbWUgd2hlbiBkcmFnZ2luZyBvdXQgaW1hZ2Vz LiBJbiBvcmRlciwgd2UgdHJ5IHRvIHVzZToKKyAgICAgICAgLSBUaGUgZmlsZW5hbWUgc3VnZ2Vz dGVkIGluIHRoZSBIVFRQIGhlYWRlci4KKyAgICAgICAgLSBUaGUgbGFzdCBwYXRoIGNvbXBvbmVu dCBvZiB0aGUgc291cmNlIFVSTC4KKyAgICAgICAgLSBUaGUgYWx0IHRleHQuCisgICAgICAgIFRo aXMgbWF0Y2hlcyB0aGUgYmVoYXZpb3Igb2YgdGhlIG90aGVyIFdlYktpdCBwb3J0cy4KKworICAg ICAgICBUZXN0OiBmYXN0L2V2ZW50cy9kcmFnLWltYWdlLWZpbGVuYW1lLmh0bWwKKworICAgICAg ICAqIHBsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OndyaXRlSW1hZ2VUb0RhdGFPYmplY3QpOgorICAgICAgICAqIHBsYXRmb3JtL2Nocm9t aXVtL0NsaXBib2FyZENocm9taXVtTWFjLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzSW52YWxp ZEZpbGVDaGFyYWN0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkQ2hyb21pdW06OnZh bGlkYXRlRmlsZU5hbWUpOgorCiAyMDExLTA1LTMxICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KQEAgLTExMCw3ICsx MzEsNiBAQAogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb29wQmxpbm5NYXRoVXRp bHMuY3BwOgogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9UaWxpbmdEYXRhLmNwcDoK IAotPDw8PDw8PCAubWluZQogMjAxMS0wNS0zMSAgSnVzdGluIE5vdm9zYWQgIDxqdW5vdkBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU3RlcGhlbiBXaGl0ZS4KQEAgLTEyMyw3 ICsxNDMsNiBAQAogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9Mb29wQmxpbm5NYXRo VXRpbHMuY3BwOgogICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9UaWxpbmdEYXRhLmNw cDoKIAotPT09PT09PQogMjAxMS0wNS0zMSAgUm9iIEJ1aXMgIDxyYnVpc0ByaW0uY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IERpcmsgU2NodWx6ZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENocm9taXVtLmNwcAppbmRleCA1YmMyNmY3 NGQ4MDJmOWJhODA0ZjMxOWEyNWFkMmU5YzYyZTE5NjQ3Li5mNTY3NWUyNGU2MTkyZmVmZjdmOGY0 ZjczMTNkOGU5N2U3ZmJjMmViIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9j aHJvbWl1bS9DbGlwYm9hcmRDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW0uY3BwCkBAIC0yMjQsMTkgKzIyNCwyNSBAQCBz dGF0aWMgdm9pZCB3cml0ZUltYWdlVG9EYXRhT2JqZWN0KENocm9taXVtRGF0YU9iamVjdCogZGF0 YU9iamVjdCwgRWxlbWVudCogZWxlbQogCiAgICAgZGF0YU9iamVjdC0+c2V0RmlsZUNvbnRlbnQo aW1hZ2VCdWZmZXIpOwogCi0gICAgLy8gRGV0ZXJtaW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZp bGUgY29udGVudHMgb2YgdGhlIGltYWdlLiAgV2UgdHJ5IHRvCi0gICAgLy8gdXNlIHRoZSBhbHQg dGFnIGlmIG9uZSBleGlzdHMsIG90aGVyd2lzZSB3ZSBmYWxsIGJhY2sgb24gdGhlIHN1Z2dlc3Rl ZAotICAgIC8vIGZpbGVuYW1lIGluIHRoZSBodHRwIGhlYWRlciwgYW5kIGZpbmFsbHkgd2UgcmVz b3J0IHRvIHVzaW5nIHRoZSBmaWxlbmFtZQotICAgIC8vIGluIHRoZSBVUkwuCisgICAgLy8gRGV0 ZXJtaW5lIHRoZSBmaWxlbmFtZSBmb3IgdGhlIGZpbGUgY29udGVudHMgb2YgdGhlIGltYWdlLgor ICAgIFN0cmluZyBmaWxlbmFtZSA9IGNhY2hlZEltYWdlLT5yZXNwb25zZSgpLnN1Z2dlc3RlZEZp bGVuYW1lKCk7CisgICAgaWYgKGZpbGVuYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgZmlsZW5hbWUg PSB1cmwubGFzdFBhdGhDb21wb25lbnQoKTsKKyAgICBpZiAoZmlsZW5hbWUuaXNFbXB0eSgpKQor ICAgICAgICBmaWxlbmFtZSA9IGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICBl bHNlIHsKKyAgICAgICAgLy8gU3RyaXAgYW55IGV4aXN0aW5nIGV4dGVuc2lvbi4gQXNzdW1lIHRo YXQgYWx0IHRleHQgaXMgdXN1YWxseSBub3QgYSBmaWxlbmFtZS4KKyAgICAgICAgaW50IGV4dGVu c2lvbkluZGV4ID0gZmlsZW5hbWUucmV2ZXJzZUZpbmQoJy4nKTsKKyAgICAgICAgaWYgKGV4dGVu c2lvbkluZGV4ICE9IC0xKQorICAgICAgICAgICAgZmlsZW5hbWUudHJ1bmNhdGUoZXh0ZW5zaW9u SW5kZXgpOworICAgIH0KKyAgICBmaWxlbmFtZSA9IENsaXBib2FyZENocm9taXVtOjp2YWxpZGF0 ZUZpbGVOYW1lKGZpbGVuYW1lLCBkYXRhT2JqZWN0KTsKKwogICAgIFN0cmluZyBleHRlbnNpb24g PSBNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRQcmVmZXJyZWRFeHRlbnNpb25Gb3JNSU1FVHlwZSgKICAg ICAgICAgY2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkubWltZVR5cGUoKSk7CiAgICAgZGF0YU9iamVj dC0+c2V0RmlsZUV4dGVuc2lvbihleHRlbnNpb24uaXNFbXB0eSgpID8gZW1wdHlTdHJpbmcoKSA6 ICIuIiArIGV4dGVuc2lvbik7Ci0gICAgU3RyaW5nIHRpdGxlID0gZWxlbWVudC0+Z2V0QXR0cmli dXRlKGFsdEF0dHIpOwotICAgIGlmICh0aXRsZS5pc0VtcHR5KCkpCi0gICAgICAgIHRpdGxlID0g Y2FjaGVkSW1hZ2UtPnJlc3BvbnNlKCkuc3VnZ2VzdGVkRmlsZW5hbWUoKTsKIAotICAgIHRpdGxl ID0gQ2xpcGJvYXJkQ2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUodGl0bGUsIGRhdGFPYmplY3Qp OwotICAgIGRhdGFPYmplY3QtPnNldEZpbGVDb250ZW50RmlsZW5hbWUodGl0bGUgKyBkYXRhT2Jq ZWN0LT5maWxlRXh0ZW5zaW9uKCkpOworICAgIGRhdGFPYmplY3QtPnNldEZpbGVDb250ZW50Rmls ZW5hbWUoZmlsZW5hbWUgKyBkYXRhT2JqZWN0LT5maWxlRXh0ZW5zaW9uKCkpOwogfQogCiB2b2lk IENsaXBib2FyZENocm9taXVtOjpkZWNsYXJlQW5kV3JpdGVEcmFnSW1hZ2UoRWxlbWVudCogZWxl bWVudCwgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIHRpdGxlLCBGcmFtZSogZnJhbWUp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9hcmRD aHJvbWl1bU1hYy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9jaHJvbWl1bS9DbGlwYm9h cmRDaHJvbWl1bU1hYy5jcHAKaW5kZXggMmM4OWY2ZThlZTk5OTIwMjkxMmIzZDhkYjliZjViYjc3 MjU3N2E5Ny4uMzgwMjE0MDJlYjkyOWUzY2M2ZTI1MWQyMjNmMDA3NDY2YWRmMmYyNyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vQ2xpcGJvYXJkQ2hyb21pdW1N YWMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0NsaXBib2FyZENo cm9taXVtTWFjLmNwcApAQCAtMjgsMTQgKzI4LDQyIEBACiAjaW5jbHVkZSAiQ2xpcGJvYXJkQ2hy b21pdW0uaCIKIAogI2luY2x1ZGUgIkNocm9taXVtRGF0YU9iamVjdC5oIgotI2luY2x1ZGUgIk5v dEltcGxlbWVudGVkLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICAKKworLy8gRmlsZW5h bWUgbGVuZ3RoIGFuZCBjaGFyYWN0ZXItc2V0IGxpbWl0cyB2YXJ5IGJ5IGZpbGVzeXN0ZW0sIGFu ZCB0aGVyZSdzIG5vCisvLyByZWFsIHdheSB0byB0ZWxsIHdoYXQgZmlsZXN5c3RlbSBpcyBpbiB1 c2UuIFNpbmNlIEhGUysgaXMgYnkgZmFyIHRoZSBtb3N0CisvLyBjb21tb24sIHdlJ2xsIGFiaWRl IGJ5IGl0cyBsaW1pdHMsIHdoaWNoIGFyZSAyNTUgVW5pY29kZSBjaGFyYWN0ZXJzIChzbGlnaHRs eQorLy8gc2ltcGxpZmllZDsgcmVhbGx5IGl0IHVzZXMgTm9ybWFsaXphdGlvbiBGb3JtIEQsIGJ1 dCB0aGUgZGlmZmVyZW5jZXMgYXJlbid0CisvLyByZWFsbHkgd29ydGggZGVhbGluZyB3aXRoIGhl cmUuKQorc3RhdGljIGNvbnN0IHVuc2lnbmVkIE1heEhGU0ZpbGVuYW1lTGVuZ3RoID0gMjU1Owor CisKK3N0YXRpYyBib29sIGlzSW52YWxpZEZpbGVDaGFyYWN0ZXIoVUNoYXIgYykKK3sKKyAgICAv LyBIRlMrIGJhc2ljYWxseSBhbGxvd3MgYW55dGhpbmcgYnV0ICcvJy4gRm9yIHNhbml0eSdzIHNh a2Ugd2UnbGwgZGlzYWxsb3cKKyAgICAvLyBjb250cm9sIGNoYXJhY3RlcnMuCisgICAgcmV0dXJu IGMgPCAnICcgfHwgYyA9PSAweDdGIHx8IGMgPT0gJy8nOworfQogCiBTdHJpbmcgQ2xpcGJvYXJk Q2hyb21pdW06OnZhbGlkYXRlRmlsZU5hbWUoY29uc3QgU3RyaW5nJiB0aXRsZSwgQ2hyb21pdW1E YXRhT2JqZWN0KiBkYXRhT2JqZWN0KQogewotICAgIG5vdEltcGxlbWVudGVkKCk7Ci0gICAgcmV0 dXJuIHRpdGxlOworICAgIC8vIFJlbW92ZSBhbnkgaW52YWxpZCBmaWxlIHN5c3RlbSBjaGFyYWN0 ZXJzLCBlc3BlY2lhbGx5ICIvIi4KKyAgICBTdHJpbmcgcmVzdWx0ID0gdGl0bGUucmVtb3ZlQ2hh cmFjdGVycyhpc0ludmFsaWRGaWxlQ2hhcmFjdGVyKTsKKyAgICBTdHJpbmcgZXh0ZW5zaW9uID0g ZGF0YU9iamVjdC0+ZmlsZUV4dGVuc2lvbigpLnJlbW92ZUNoYXJhY3RlcnMoJmlzSW52YWxpZEZp bGVDaGFyYWN0ZXIpOworCisgICAgLy8gUmVtb3ZlIGEgcmlkaWN1bG91c2x5LWxvbmcgZXh0ZW5z aW9uLgorICAgIGlmIChleHRlbnNpb24ubGVuZ3RoKCkgPj0gTWF4SEZTRmlsZW5hbWVMZW5ndGgp CisgICAgICAgIGV4dGVuc2lvbiA9ICIiOworICAgIAorICAgIC8vIFRydW5jYXRlIGFuIG92ZXJs eS1sb25nIGZpbGVuYW1lLgorICAgIGludCBvdmVyZmxvdyA9IHJlc3VsdC5sZW5ndGgoKSArIGV4 dGVuc2lvbi5sZW5ndGgoKSAtIE1heEhGU0ZpbGVuYW1lTGVuZ3RoOworICAgIGlmIChvdmVyZmxv dyA+IDApIAorICAgICAgICByZXN1bHQucmVtb3ZlKHJlc3VsdC5sZW5ndGgoKSAtIG92ZXJmbG93 LCBvdmVyZmxvdyk7CisgICAgCisgICAgZGF0YU9iamVjdC0+c2V0RmlsZUV4dGVuc2lvbihleHRl bnNpb24pOworICAgIHJldHVybiByZXN1bHQ7CiB9CiAKIH0gIC8vIG5hbWVzcGFjZSBXZWJDb3Jl CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZTQ3 YzlkZWIzNzM5OWRlMjYyMmRiNTlmOTJlMGRkY2I4NzgzOWMzYS4uMTJlODFkM2M2ZTdjZWZiNWE2 ZjFmYTI1YzYyNjE4OGYyYjMwZjVlZiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBi L1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDExLTA1LTMxICBEYW5pZWwgQ2hl bmcgIDxkY2hlbmdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIFtjaHJvbWl1bV0gVXNlIGNvcnJlY3QgZmlsZSBuYW1lIGZvciBk cmFnZ2luZyBvdXQgaW1hZ2VzLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjQ4ODcKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0V2 ZW50U2VuZGVyLmNwcDoKKyAgICAgICAgKEV2ZW50U2VuZGVyOjpFdmVudFNlbmRlcik6CisgICAg ICAgIChFdmVudFNlbmRlcjo6ZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkKToKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5oOgorCiAyMDExLTA1LTMxICBFcmlj IFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZpZCBL aWx6ZXIuCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNl bmRlci5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5jcHAK aW5kZXggOWU1NTU4OTNlOThhN2EwNGRkNDVjNTVjYjAyOWRjMTc1YmY4Y2MwNS4uNzNiZDE0NWM4 Y2UxMTkyZDRiZmI3OTQzNzFiOTFmMzA3M2E1MjVjZCAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJl bmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmNwcApAQCAtMjU5LDYgKzI1OSw3IEBAIEV2ZW50U2Vu ZGVyOjpFdmVudFNlbmRlcihUZXN0U2hlbGwqIHNoZWxsKQogICAgIGJpbmRNZXRob2QoImNvbnRl eHRDbGljayIsICZFdmVudFNlbmRlcjo6Y29udGV4dENsaWNrKTsKICAgICBiaW5kTWV0aG9kKCJj b250aW51b3VzTW91c2VTY3JvbGxCeSIsICZFdmVudFNlbmRlcjo6Y29udGludW91c01vdXNlU2Ny b2xsQnkpOwogICAgIGJpbmRNZXRob2QoImRpc3BhdGNoTWVzc2FnZSIsICZFdmVudFNlbmRlcjo6 ZGlzcGF0Y2hNZXNzYWdlKTsKKyAgICBiaW5kTWV0aG9kKCJkdW1wRmlsZW5hbWVCZWluZ0RyYWdn ZWQiLCAmRXZlbnRTZW5kZXI6OmR1bXBGaWxlbmFtZUJlaW5nRHJhZ2dlZCk7CiAgICAgYmluZE1l dGhvZCgiZW5hYmxlRE9NVUlFdmVudExvZ2dpbmciLCAmRXZlbnRTZW5kZXI6OmVuYWJsZURPTVVJ RXZlbnRMb2dnaW5nKTsKICAgICBiaW5kTWV0aG9kKCJmaXJlS2V5Ym9hcmRFdmVudHNUb0VsZW1l bnQiLCAmRXZlbnRTZW5kZXI6OmZpcmVLZXlib2FyZEV2ZW50c1RvRWxlbWVudCk7CiAgICAgYmlu ZE1ldGhvZCgia2V5RG93biIsICZFdmVudFNlbmRlcjo6a2V5RG93bik7CkBAIC0zNDQsNiArMzQ1 LDExIEBAIHZvaWQgRXZlbnRTZW5kZXI6OmRvRHJhZ0Ryb3AoY29uc3QgV2ViRHJhZ0RhdGEmIGRy YWdEYXRhLCBXZWJEcmFnT3BlcmF0aW9uc01hc2sKICAgICByZXBsYXlTYXZlZEV2ZW50cygpOwog fQogCit2b2lkIEV2ZW50U2VuZGVyOjpkdW1wRmlsZW5hbWVCZWluZ0RyYWdnZWQoY29uc3QgQ3Bw QXJndW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopCit7CisgICAgcHJpbnRmKCJGaWxlbmFtZSBiZWlu ZyBkcmFnZ2VkOiAlc1xuIiwgY3VycmVudERyYWdEYXRhLmZpbGVDb250ZW50RmlsZW5hbWUoKS51 dGY4KCkuZGF0YSgpKTsKK30KKwogV2ViTW91c2VFdmVudDo6QnV0dG9uIEV2ZW50U2VuZGVyOjpn ZXRCdXR0b25UeXBlRnJvbUJ1dHRvbk51bWJlcihpbnQgYnV0dG9uQ29kZSkKIHsKICAgICBpZiAo IWJ1dHRvbkNvZGUpCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9F dmVudFNlbmRlci5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vRXZlbnRTZW5kZXIu aAppbmRleCBkZTFjYTA1NDAzOTEyMjU3N2M5ZDZkYmUzYzlmNmE4NTRhNGM4YTg2Li41NGIwNjUw MzNjNjgxOTJjMzc3MjE4MzY1NTM5ZWM0Nzk4ZjkxYjNiIDEwMDY0NAotLS0gYS9Ub29scy9EdW1w UmVuZGVyVHJlZS9jaHJvbWl1bS9FdmVudFNlbmRlci5oCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJU cmVlL2Nocm9taXVtL0V2ZW50U2VuZGVyLmgKQEAgLTYyLDYgKzYyLDkgQEAgcHVibGljOgogICAg IC8vIFNpbXVsYXRlIGRyYWcmZHJvcCBzeXN0ZW0gY2FsbC4KICAgICB2b2lkIGRvRHJhZ0Ryb3Ao Y29uc3QgV2ViS2l0OjpXZWJEcmFnRGF0YSYsIFdlYktpdDo6V2ViRHJhZ09wZXJhdGlvbnNNYXNr KTsKIAorICAgIC8vIFRlc3QgaGVscGVyIGZvciBkcmFnZ2luZyBvdXQgaW1hZ2VzLgorICAgIHZv aWQgZHVtcEZpbGVuYW1lQmVpbmdEcmFnZ2VkKGNvbnN0IENwcEFyZ3VtZW50TGlzdCYsIENwcFZh cmlhbnQqKTsKKwogICAgIC8vIEpTIGNhbGxiYWNrIG1ldGhvZHMuCiAgICAgdm9pZCBtb3VzZURv d24oY29uc3QgQ3BwQXJndW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopOwogICAgIHZvaWQgbW91c2VV cChjb25zdCBDcHBBcmd1bWVudExpc3QmLCBDcHBWYXJpYW50Kik7Cg==