20013 2008-07-11 16:26:41 -0700 Windows AX heuristics are poor 2009-01-27 19:40:52 -0800 1 1 1 Unclassified WebKit Accessibility 528+ (Nightly build) PC Windows XP RESOLVED LATER P2 Normal --- 1 sankaraditya+bugzilla jhoneycutt alice.barraclough bdakin eric jhoneycutt klinktech sam oldest_to_newest 85826 0 sankaraditya+bugzilla 2008-07-11 16:26:41 -0700 The webkit MSAA support is less than perfect for Windows WebKit. I've made a patch which improves the support somewhat. I'll upload it soon. 86617 1 22417 sankaraditya+bugzilla 2008-07-21 18:30:49 -0700 Created attachment 22417 Patch for enhancing WebKit Accessibility heuristics Webkit accessibility heuristics are not great. When I load a page in safari and invoke Inspect32 tool, proper accessible tree is not exposed. I have enhanced the webkit heuristics to expose relavant accessibile objects equal or better to that of Firefox 2.0.0.14. I have tested this path for nearly 20 web pages. Output is equal to that of Firefox 2.0.0.14. Also, navigating between parent and siblings is not proper in Inspect32. I have fixed those bugs also. 86660 2 22417 eric 2008-07-22 10:04:17 -0700 Comment on attachment 22417 Patch for enhancing WebKit Accessibility heuristics This looks pretty good. A few comments: 1. We use 4 spaces, not tabs in webkit. + virtual AccessibilityObject* accFirstChild() const ; + virtual AccessibilityObject* accLastChild() const ; + + virtual AccessibilityObject* previousAccessibilitySibling() const ; + virtual AccessibilityObject* nextAccessibilitySibling() const ; These aren't consistent. Probably accFirstChild should change to: firstAccessibilityChild() instead. There seem to be some strange uses of "const" in this class... +WTF::HashSet<String> createTextFormattingElementNamesHash() No need to use WTF:: there, I believe using namespace WTF should already have been done at some point in a header for you. Probably better to have createTextFormattingElementNamesHash return a HashSet<String>*, since HashSet does a full deep copy in its copy constructor, so you'd end up with a lot of copying going on during return. + HashSet<String> elementHashSet ; extra space. Extra space: + return elementHashSet; + +} It seems m_accessibilityID is misnamed (not your fault). It should probably be "m_indexInParent". No need for an "else" after return in: + return textFormattingElementNames.contains(m_renderer->element()->nodeName().lower()); + else + return false; The lower() here is not necessary: + return textFormattingElementNames.contains(m_renderer->element()->nodeName().lower()); if you use a case-insensitive hash: HashSet<String, CaseFoldingHash> It also appears that the more common paradigm is not to use a HashSet* as I just said above, but rather to just init the hash in the function. See: http://trac.webkit.org/browser/trunk/WebCore/xml/XMLHttpRequest.cpp#L90 +bool AccessibilityRenderObject::isLinkOrListItemElement() const should probably use a Hash in the same pattern as shown in the link above. Darin Adler once figured out what the break-even point was... I think in terms of code complexity, anything past about 4 items looks cleaner in a Hash. Again, extra space, and no need for "else" after return: + m_renderer->element()->hasTagName(dtTag)) + return true; + else + return false; + +} Extra spaces at end of line: if (!m_renderer) - return String(); + return String(); We have an append() function which takes a Vector and a String, so this: + String elementTitle = childrenVector[i]->title(); + elementText.append(elementTitle.characters(),elementTitle.length()); should just be: append(elementText, elementTitle); Again, no else needed after return: + if (!alt.isNull()) + return alt.string(); + else + return String(); + } No extra space needed before ; + return ariaText.isNull() || ariaText.isEmpty() || !ariaText.stripWhiteSpace().length() ; I believe the WebKit style guides say the outer if here should have { }: + if (isLinkOrListItemElement()) + if (children().size() == 0) + return true; + else + return false; + No spaces needed before ): + if (m_renderer->element() && m_renderer->element()->hasTagName(htmlTag) ) + return true; + + if (m_renderer->element() && m_renderer->element()->hasTagName(bodyTag) ) + return true; Add { } remove use of else after return: + if (m_renderer->isBlockFlow() ) + if (m_renderer->isAnonymousBlock()) + return true; + else + return false; + if (node && (node->hasTagName(tdTag) || + node->hasTagName(thTag) + )) + return CellRole; )) should be on the same line as the rest of it. It can all be on one line I bet. We don't have a strong 80-column limit in WebKit, although most folks try to wrap their text to make it easy to read. Space after if before (, but not before ): + if(node && node->hasTagName(liTag) ) + return ListItemRole; + + if(node && node->hasTagName(hrTag) ) + return SeparatorRole; Besides the strange formatting, this looks fine to me. Jon Honeycutt should really review it for correctness. I'll ask him to do so. 86661 3 22417 eric 2008-07-22 10:05:52 -0700 Comment on attachment 22417 Patch for enhancing WebKit Accessibility heuristics Marking r- because of the issues mentioned above. Jon should still look at this for correctness. We have the ability to make various AX test cases in DumpRenderTree now, although Sam Weinig (weinig in #webkit) would have to explain how that would work here. 86688 4 jhoneycutt 2008-07-22 17:47:39 -0700 Thanks for working on this, Sankar! I am really happy to see you make progress on this. I ran into an issue when testing your patch with a change you made to the roleValue() method: - if (node && node->isLink()) { - if (m_renderer->isImage()) + if (node && node->isLink()) { + if (isImage()) isImage() calls roleValue(), so this leads to infinite recursion. I think you meant to use isNativeImage(). Another issue with a change to addChildren(): } else + obj->setAccessibilityID(childCounter++); + obj->setAccessibleParent(this); m_children.append(obj); You are missing braces around those statements, so only the call to setAccessibilityID() is within the else condition. With these changes, the accessibility tree on Windows looks much better! However, I wonder if your work here leads to changes in the accessibility tree on, for example, the Mac platform. If so, it may be necessary to make some changes to avoid breaking accessibility on the Mac. Have you tried running the accessibility layout tests on a Mac after this patch? None of the accessibility tests will run on Windows currently, but I believe Sam Weinig is working to add support for this. As a last note, your ChangeLog entries should explain any non-obvious changes that have been made to the code. You can look through the other ChangeLog entries to gain an idea of how verbose they should be. Again, thanks! I will CC: our cross-platform accessibility engineers and let them weigh in. 86698 5 22444 sankaraditya+bugzilla 2008-07-22 21:23:57 -0700 Created attachment 22444 This is the latest patch after I have done all the changes as per code review comments. I have made all the changes as per the code review comments. I have updated the patch. I am uploading the new patch. 86699 6 sankaraditya+bugzilla 2008-07-22 21:25:45 -0700 (In reply to comment #5) > Created an attachment (id=22444) [edit] > This is the latest patch after I have done all the changes as per code review > comments. > I have made all the changes as per the code review comments. I have updated the > patch. I am uploading the new patch. Thanks Eric and Jon for your review comments. I have made all the required changes and I have uploaded the newly created patch. Please check it out. 86701 7 22444 eric 2008-07-22 22:05:06 -0700 Comment on attachment 22444 This is the latest patch after I have done all the changes as per code review comments. In general this patch looks fine. There are still a few style issues, and Jon should look again for correctness. I don't know if you have access to a Mac, but I can run the layout tests on mine tomorrow if you can't. Tab: + virtual bool isTextFormattingElement() const; What does + const AccessibilityObject* accessibleParent() { return m_accessibleParent ;} + void setAccessibleParent(const AccessibilityObject* ); accessibleParent mean? I assume you mean accessibilityParent? "accessible" reads "one that I can reach" instead of what I think you mean as "parent of this dom/render object from the perspective of the accessibility interfaces" Tab: + elementHashSet.add(pTag.toString()); No spaces before ; + virtual AccessibilityObject* firstAccessibilityChild() const ; + virtual AccessibilityObject* lastAccessibilityChild() const ; + + virtual AccessibilityObject* previousAccessibilitySibling() const ; + virtual AccessibilityObject* nextAccessibilitySibling() const ; + Wrong (by webkit style) spacing: + const AccessibilityObject* accessibleParent() { return m_accessibleParent ;} + void setAccessibleParent(const AccessibilityObject* ); This looks like it won't work dynamically. m_indexInParent is never updated when the parent's children are changed. Maybe the point of this patch was only to handle static content? I could see this leading to a crash however, if m_indexInParent is set, and then siblings are later removed, then next time nextAccessibilitySibling is called on this object, m_indexInParent + 1 might be much larger than siblingsVector.size(), and thus fail to trigger the: + if (m_indexInParent + 1 == siblingsVector.size()) + return 0; causing a crash in + return siblingsVector[m_indexInParent + 1].get(); Am I right? This line: return ariaText.isNull() || ariaText.isEmpty() || !ariaText.stripWhiteSpace().length() Should just be: return ariaText.isNull() || ariaText.impl()->containsOnlyWhiteSpace(); I'm surprised that containsOnlyWhiteSpace() is only available on StringImpl, it really should be on String as well. You could add: bool containsOnlyWhiteSpace() { return isNull() || m_impl-> containsOnlyWhiteSpace(); } to PlatformString.h if you'd like and then just call: return text().isOnlyWhiteSpace(); Yeah, again, don't use "stripWhiteSpace()" as that's unecessary mallocs: if (textUnderElement().stripWhiteSpace().length() != 0) Looks like you need an addition to String there as well. Or you can manually call the StringImpl method, but it would be better to just add containsOnlyWhiteSpace() to String. No need for the else after the return here: + if (parentObjectUnignored()->ariaRoleAttribute() == MenuItemRole + || parentObjectUnignored()->ariaRoleAttribute() == MenuButtonRole) + return true; + else + return false; This: + if (children().size() == 0) + return true; + else + return false; should be: return children().isEmpty(); Space between for and (, and no space between ) and ; + for(parentObj = m_object->parentObject() ; parentObj && parentObj->accessibilityIsIgnored(); parentObj = parentObj->parentObject()) { } I wonder if this whole clause: + AccessibilityObject* parentObj = m_object->parentObject(); + + for(parentObj = m_object->parentObject() ; parentObj && parentObj->accessibilityIsIgnored(); parentObj = parentObj->parentObject()) { } shouldn't be turned into a function. Like: AccessibilityObject* parentObj = m_object->nonIgnoredParent(); if (parentObj)... or similar. Again, the change looks good (to me, not knowing much about AX), however you're tripping up on WebKit style, and a few nits here and there. This is kinda expected... sadly it take a while to get used to hacking on WebKit. But we're here to help. Happy to answer questions for you in #webkit. Oh, and: +2008-07-21 U-stanguturi\Sankar Tanguturi <set EMAIL_ADDRESS environment variable> the prepare-changeLog script looks at your $USER and $EMAIL_ADDRESS environment variables. looks like yours aren't set to useful things. You should just edit the ChangeLogs manually to fix the name and email line. Jon should look at this patch as well, but this will need one more round of style-cleanup before we can land. 86705 8 sam 2008-07-22 23:55:52 -0700 We would have a much easier time evaluating and reviewing this if you were to break this patch up into small testable chunks. For instance, I would start with just adding support for the DocumentRole and adding a test case for it. Making this large a change, and with many unrelated pieces is something we try to avoid. 86798 9 22459 sankaraditya+bugzilla 2008-07-23 16:59:57 -0700 Created attachment 22459 Latest patch after Jon and Eric reviewed second time Eric, Thanks for the code review comments. I have made all the required changes. Please check it out. 86799 10 sankaraditya+bugzilla 2008-07-23 17:01:49 -0700 Eric, This patch works well for static pages. At no other location, we are modifying (adding/removing) children from m_children variable. So, I don't think, my code will crash at some point. As you specified, I have made all the required changes and uploaded the new patch. Thanks. 86800 11 sankaraditya+bugzilla 2008-07-23 17:04:49 -0700 Sam, Sorry for dumping all the changes in one shot. I have uploaded the modified patch. From next time, I will upload the patches in small chunks as you specified. All the features that are posted in this patch are inter-related. So, I thought I can post it in one shot. ~ Thanks. (In reply to comment #8) > We would have a much easier time evaluating and reviewing this if you were to > break this patch up into small testable chunks. For instance, I would start > with just adding support for the DocumentRole and adding a test case for it. > Making this large a change, and with many unrelated pieces is something we try > to avoid. 86809 12 jhoneycutt 2008-07-23 21:15:20 -0700 Hi, Sankar. Looking good, a few comments: +2008-07-21 U-stanguturi\Sankar Tanguturi sankaraditya@gmail.com I think U-stanguturi is the name of the machine you're working on. You should remove that part of the name field in your ChangeLogs. Also, your ChangeLogs still need to explain the changes you are making, and you should put the URL of this bug at the top of the entry. Check out the other ChangeLog entries to see how this should look. + unsigned indexInParent() { return m_indexInParent; } + const AccessibilityObject* accessibilityParent() { return m_accessibilityParent; } These methods can be const. + elementHashSet.add(bTag.toString()); + elementHashSet.add(bTag.toString()); You added the same string to this HashSet twice. + || m_renderer->element()->hasTagName(tableTag) + || m_renderer->element()->hasTagName(tdTag) + || m_renderer->element()->hasTagName(thTag) I think you could use RenderObject::isTable(), isTableCell(), and isTableRow() instead of hasTagName(). These lines should also be indented 1 more level. +bool AccessibilityRenderObject::isTextFormattingElement() const +{ + HashSet<String, CaseFoldingHash>* textFormattingElementNames = createTextFormattingElementNamesHash(); + + if (m_renderer && m_renderer->element()) + return textFormattingElementNames->contains(m_renderer->element()->nodeName()); + + return false; + +} Does Firefox ignore these items based on their tag name, or whether they are inline? For example, is <i style="display: block">test</i> ignored? >+ if (m_renderer && m_renderer->element()) >+ return m_renderer->element()->isLink() >+ || elementHashSet->contains(m_renderer->element()->nodeName()); Can you use m_renderer->isListItem(), or is the HashSet of list item tag names necessary? What if an element with a different tag name sets its display type to list-item? What does Firefox do in that case? Regarding the use of tag names in general, I wonder how is this affected by ARIA. I think Beth or Alice need to comment here. >+ if (m_renderer->element()->isLink() || isHeading()) { >+ const Vector< RefPtr<AccessibilityObject> >& childrenVector = children(); >+ Vector<UChar> elementText; >+ for (unsigned i = 0; i < childrenVector.size(); ++i) { >+ elementText.append(' '); >+ String elementTitle = childrenVector[i]->title(); >+ append(elementText, elementTitle); >+ } >+ >+ return String::adopt(elementText).stripWhiteSpace(); >+ >+ } You can use the AccessibilityChildrenVector typedef here. Is it possible to use textUnderElement()? If not, textUnderElement() should probably be modified, rather than having this code in title(). >+ Element* elt = static_cast<Element*>(node); >+ const AtomicString& alt = elt->getAttribute(altAttr); >+ if (!alt.isNull()) >+ return alt.string(); >+ return String(); >+ } >+ } Can probably write this as: return static_cast<Element*>(node)->getAttribute(altAttr); > String ariaText = text(); >- return ariaText.isNull() || ariaText.isEmpty(); >+ return ariaText.isNull() || ariaText.containsOnlyWhitespace(); Can probably now write this as: return text().containsOnlyWhitespace(). > if (m_renderer->isText()) { > // static text beneath MenuItems and MenuButtons are just reported along with the menu item, so it's ignored on an individual level >- if (parentObjectUnignored()->ariaRoleAttribute() == MenuItemRole || >- parentObjectUnignored()->ariaRoleAttribute() == MenuButtonRole) >+ if (!textUnderElement().containsOnlyWhitespace()) { >+ if (parentObjectUnignored()->ariaRoleAttribute() == MenuItemRole >+ || parentObjectUnignored()->ariaRoleAttribute() == MenuButtonRole) >+ return true; >+ return false; >+ } else { > return true; >- return m_renderer->isBR() || !static_cast<RenderText*>(m_renderer)->firstTextBox(); >+ } > } Our style is to prefer early return, so this should be written as: if (m_renderer->isText()) { if (textUnderElement().containsOnlyWhitespace()) return true; AccessibilityRole role = parentObjectUnignored()->ariaRoleAttribute(); return role == MenuItemRole || role == MenuButtonRole; } >+ if (isLinkOrListItemElement()) { >+ return children().isEmpty(); >+ } No need for braces around a single-line if. >+ if (m_renderer->isBlockFlow()) { >+ if (m_renderer->isAnonymousBlock()) >+ return true; >+ return false; >+ } Can be written as: if (m_renderer->isBlockFlow()) return m_renderer->isAnonymousBlock(); >+ if (node && node->hasTagName(tableTag)) >+ return TableRole; >+ >+ if (node && (node->hasTagName(tdTag) || node->hasTagName(thTag))) >+ return CellRole; Same as earlier; can use isTable(), isTableCell(). >+ if(node && node->hasTagName(liTag)) >+ return ListItemRole; >+ >+ if(node && node->hasTagName(hrTag)) >+ return SeparatorRole; RenderObject has isListItem(), isHR(). + bool containsOnlyWhitespace() { return isNull() || m_impl->containsOnlyWhitespace(); } Looks like this can be const. You still need to explain the changes in the ChangeLog before this can be r+ed. I don't understand some of the changes or their implications, so I'd like to have Beth or Alice's opinion, also. However, overall, this looks good! 86810 13 22459 jhoneycutt 2008-07-23 21:16:37 -0700 Comment on attachment 22459 Latest patch after Jon and Eric reviewed second time r- for need of proper ChangeLog and for the above comments. 86812 14 jhoneycutt 2008-07-23 21:38:37 -0700 I think Eric is right about the children changing after the tree has been created. When the children of an AccessibilityObject change, childrenChanged() is called. You can use this to update their m_indexInParent and m_accessibilityParent. As Sam said, you should probably break this patch up into smaller patches. Fixing the navigation between elements is definitely distinct from the other changes in this patch. 86832 15 22459 eric 2008-07-24 01:58:02 -0700 Comment on attachment 22459 Latest patch after Jon and Eric reviewed second time Jon gave you plenty of comments already, but here is another: + elementHashSet.add(bTag.toString()); Those shouldn't need an explicit .toString() call: operator const String&() const { return m_string; } Should make AtomicStrings transparently convert. You should just be able to do: + elementHashSet.add(subTag); Of course this is all moot if you find out that you should be testing: element->style()->display() == INLINE instead. And unfortunately this is not an unusual number of reviews for someone's first patch to WebKit to go through. Hopefully you don't find this process too frustrating. Large patches like this are difficult to do as one's "first patch" :) Especially since WebKit has a different style from so much other C++ code. 86833 16 eric 2008-07-24 02:00:12 -0700 (In reply to comment #14) > As Sam said, you should probably break this patch up into smaller patches. > Fixing the navigation between elements is definitely distinct from the other > changes in this patch. If you choose to break this up into smaller patches (which is always encouraged, as reviews for smaller patches go much quicker and are easier to land in parallel while other patches are still under review), you can either attach multiple patches to this bug, or you can file additional bugs and mark this bug as dependent on those bugs. 86924 17 22470 sankaraditya+bugzilla 2008-07-24 19:32:53 -0700 Created attachment 22470 First chunk of patch AS Jon,Eric and Sam suggested, I have broken down the large patch into small chunks. I am uploading the first chunk. This patch contains the changes for addition of roles, filtering of MSAA tree, pouplation of various attributes. 86925 18 22471 sankaraditya+bugzilla 2008-07-24 19:34:26 -0700 Created attachment 22471 Comments for all the changes that I have done This file contains the comments for all the changes that I have done. I couldn't find out how to embed the comments in the changelog. So, I have created a separate file explaining each and every change that I have done. 87305 19 22470 eric 2008-07-29 13:41:58 -0700 Comment on attachment 22470 First chunk of patch I assume Sankar meant to mark this for review. 87306 20 eric 2008-07-29 13:43:10 -0700 (In reply to comment #18) > Created an attachment (id=22471) [edit] > Comments for all the changes that I have done > > This file contains the comments for all the changes that I have done. > I couldn't find out how to embed the comments in the changelog. So, I have > created a separate file explaining each and every change that I have done. The ChangeLog is just a text file. You can just add the comments inline. prepare-ChangeLog is log is just a script which does all the boiler-plate editing to the ChangeLog after you've prepared a patch. You should feel free to edit a ChangeLog by hand. :) 87307 21 22470 eric 2008-07-29 13:47:23 -0700 Comment on attachment 22470 First chunk of patch I still think that: + elementHashSet.add(bTag.toString()); probably don't need the explicit .toString() calls. + elementHashSet.add(bTag); Should "just work". BUt maybe I'm wrong. This: + String elementTitle = childrenVector[i]->title(); + append(elementText, elementTitle); Can be written: + append(elementText, childrenVector[i]->title()); Either way is fine. :) Sad that we have to copy a string here: + return String::adopt(elementText).stripWhiteSpace(); But it should be fine. No { } around single line if clauses: + if (m_renderer->isBlockFlow()) { + return m_renderer->isAnonymousBlock(); + } This change looks great to me! I'll ask Jon to look over it one more time. 87308 22 22470 mrowe 2008-07-29 13:49:19 -0700 Comment on attachment 22470 First chunk of patch The ChangeLog entry here contains only a link to an unrelated changeset in Trac. Please provide information about the purpose of the change, and annotate the changelog with details about specific portions of the change where appropriate. 87309 23 22470 eric 2008-07-29 13:50:04 -0700 Comment on attachment 22470 First chunk of patch I r+'d this with requested changes, thus I'll volunteer to make those edits before I land it. 87310 24 22470 mrowe 2008-07-29 13:53:24 -0700 Comment on attachment 22470 First chunk of patch This patch also still looks to make several unrelated changes. I would think it could be split further into patches that contain only related changes. 87312 25 sam 2008-07-29 14:17:18 -0700 This still needs tests. 87313 26 22470 jhoneycutt 2008-07-29 14:23:15 -0700 Comment on attachment 22470 First chunk of patch r-ing until I have a chance to test this more. 87331 27 jhoneycutt 2008-07-29 15:28:01 -0700 Testing whether an object can be ignored by checking the tag name does not seem to work well. This should be present in the tree as a button: <i role="button">Test.</i> This should be present as a container: <i style="display: block;">Test.</i> This should be present as a list item: <i style="display: list-item;">Test.</i> This can be ignored: <i>Test.</i> This is how these objects are presented by Firefox 3. However, with this patch, the accessibility of the <i> tag is ignored in all of these cases. Smaller issues: + if(m_renderer->isListItem()) + return ListItemRole; + + if(m_renderer->isHR()) + return SeparatorRole; + + if(isListElement(node)) + return ListRole; + Need spaces between if and (. + case WebCore::DocumentRole: + return ROLE_SYSTEM_DOCUMENT; + case WebCore::CellRole: + return ROLE_SYSTEM_CELL; + case WebCore::ListItemRole: + return ROLE_SYSTEM_LISTITEM; + case WebCore::SeparatorRole: + return ROLE_SYSTEM_SEPARATOR; Needs two more spaces of indentation before each return. As Sam and Mark said, this still needs to be broken down; the patch tries to fix issues with list items, tables, links, images, inline elements, text elements, separators, and documents, when each of these is a separate issue. It would be best if you could submit a patch for each of these small items, along with a test. I hope this doesn't put you off of working on this! :) 87410 28 22558 sankaraditya+bugzilla 2008-07-30 11:49:10 -0700 Created attachment 22558 This is patch contains only the changes for adding a new role i.e. DocumentRole. As Eric,Jon,Sam and Mark suggested, I have broken down the entire patch into small patches. This is the first smallest patch. This contains only the changes that have been done to add a new role i.e DocumentRole. 87436 29 22558 jhoneycutt 2008-07-30 15:00:31 -0700 Comment on attachment 22558 This is patch contains only the changes for adding a new role i.e. DocumentRole. Great! Couple of comments: + case DocumentRole: return false; On Firefox, when I view the tree with AccExplorer, the document object's state includes "focusable." Can WebKit document nodes not take focus? + case WebCore::DocumentRole: + return ROLE_SYSTEM_DOCUMENT; I think it would be better to override AccessibleBase::role() in AccessibleDocument to return ROLE_SYSTEM_DOCUMENT. 87445 30 22566 sankaraditya+bugzilla 2008-07-30 16:01:19 -0700 Created attachment 22566 Patch for changes to populate new role i.e separatorRole This patch contains only the changes that are needed to add and populate a new role i.e separatorRole. 87448 31 22568 sankaraditya+bugzilla 2008-07-30 16:27:17 -0700 Created attachment 22568 Patch for adding and poupluating a new role i.e CellRole This patch contains only the changes that are required to add and populate a new role i.e CellRole. ~ Thanks. 87449 32 22569 sankaraditya+bugzilla 2008-07-30 16:56:20 -0700 Created attachment 22569 Patch for changes to populate new role i.e ListItemRole This patch contains only the changes that are required to add an populate a new role i.e ListItemRole in webkit. ~ thanks. 87470 33 22573 sankaraditya+bugzilla 2008-07-30 21:09:42 -0700 Created attachment 22573 Updated patch for DocumentRole. As Jon suggested, Modified the code for populating the document role correctly. Changed code to make document object focusable. Also, made changes in AccessibleDocument to override role() function of AccessibleBase. Obsoleting the previous patch for DocumentRole. ~ Thanks. 87476 34 22574 sankaraditya+bugzilla 2008-07-31 01:17:13 -0700 Created attachment 22574 This patch contains the changes to populate "Name" attribute properly. Enhanced the code to populate "Name" attribute properly in Webkit. This patch contains only those changes. My comments inline in the patch. ~ Thanks. 87477 35 22575 sankaraditya+bugzilla 2008-07-31 01:57:32 -0700 Created attachment 22575 Patch for populating Role Attribute properly WebKit doesn't properly populate the role attributes for the nodes. Made changes to sync up WebKit behaviour with Firefox 2.0.0.14. This patch contains only the changes required for populating role attribute. ~ Thanks. 87511 36 sankaraditya+bugzilla 2008-07-31 11:07:04 -0700 I have checked in Firefox. <i style="display: block;">Test.</i> Though <i> tag is displayed in block fashion, Firefox ignores it. Firefox just considers the text content of <i> tag. I think, webkit should follow that behavior as displayed in Firefox. ~ Thanks. (In reply to comment #27) > Testing whether an object can be ignored by checking the tag name does not seem > to work well. > > This should be present in the tree as a button: > <i role="button">Test.</i> > > This should be present as a container: > <i style="display: block;">Test.</i> > > This should be present as a list item: > <i style="display: list-item;">Test.</i> > > This can be ignored: > <i>Test.</i> > > This is how these objects are presented by Firefox 3. However, with this patch, > the accessibility of the <i> tag is ignored in all of these cases. > > Smaller issues: > + if(m_renderer->isListItem()) > + return ListItemRole; > + > + if(m_renderer->isHR()) > + return SeparatorRole; > + > + if(isListElement(node)) > + return ListRole; > + > Need spaces between if and (. > > + case WebCore::DocumentRole: > + return ROLE_SYSTEM_DOCUMENT; > + case WebCore::CellRole: > + return ROLE_SYSTEM_CELL; > + case WebCore::ListItemRole: > + return ROLE_SYSTEM_LISTITEM; > + case WebCore::SeparatorRole: > + return ROLE_SYSTEM_SEPARATOR; > Needs two more spaces of indentation before each return. > > > As Sam and Mark said, this still needs to be broken down; the patch tries to > fix issues with list items, tables, links, images, inline elements, text > elements, separators, and documents, when each of these is a separate issue. > > It would be best if you could submit a patch for each of these small items, > along with a test. > > I hope this doesn't put you off of working on this! :) > 87515 37 22573 jhoneycutt 2008-07-31 11:41:33 -0700 Comment on attachment 22573 Updated patch for DocumentRole. This is how we usually format our ChangeLog entries: 2008-07-30 Sankar Tanguturi <sankaraditya+bugzilla@gmail.com> Add an accessibility role for document objects. Part of https://bugs.webkit.org/show_bug.cgi?id=20013 Reviewed by NOBODY (OOPS!). * page/AccessibilityObject.h: (WebCore::): Add DocumentRole to the AccessibilityRole enum. * page/AccessibilityRenderObject.cpp: (WebCore::AccessibilityRenderObject::canSetFocusAttribute): Return true for documents, matching Firefox. r=me! 87516 38 22566 jhoneycutt 2008-07-31 11:44:40 -0700 Comment on attachment 22566 Patch for changes to populate new role i.e separatorRole Please put the URL for the bug in the ChangeLog, https://bugs.webkit.org/show_bug.cgi?id=20013. r=me, thanks for the patch! 87519 39 22581 sankaraditya+bugzilla 2008-07-31 13:15:44 -0700 Created attachment 22581 Updated patch for Document Role As Jon suggested, I have updated the patch for adding DocumentRole. ~ Thanks. 87520 40 22582 sankaraditya+bugzilla 2008-07-31 13:29:04 -0700 Created attachment 22582 Update patch for Separator Role As Jon has suggested, I have updated the patch for Separator Role with appropriate comments in the changelog. ~ Thanks. 87521 41 22583 sankaraditya+bugzilla 2008-07-31 13:32:04 -0700 Created attachment 22583 Updated patch for ListItemRole As Jon Suggested, I have updated the patch for ListItem role. I have added all relevant comments in the changelog. ~ Thanks. 87522 42 22584 sankaraditya+bugzilla 2008-07-31 13:37:43 -0700 Created attachment 22584 Updated patch for CellRole As Jon Suggested, I have upadate the patch for CellRole with all my comments. ~ Thanks. 87523 43 22585 sankaraditya+bugzilla 2008-07-31 13:58:09 -0700 Created attachment 22585 Updated patch to populate Name attribute properly. As Jon Suggested, I have update the patch for populating Name attribute, with my comments. Obsoleting the old one. ~ Thanks. 87525 44 22586 sankaraditya+bugzilla 2008-07-31 14:12:12 -0700 Created attachment 22586 Updated patch to populate Role attribute properly As Jon suggested, I have update the patch for populating the role attribute with my comments. So, obseleting the old patch. ~ Thanks. 87531 45 22470 eric 2008-07-31 15:09:28 -0700 Comment on attachment 22470 First chunk of patch I just realized there is another problem with this patch: The "create*Hash" functions are "wrong" because they end up causing the lookup to be against the "prefix:localName" pair. Two elements can have matching qualified names, even if their prefixes are different. All you care about is that their namespaceURIs and localNames match. +static HashSet<String, CaseFoldingHash>* createTextFormattingElementNamesHash() +{ + static HashSet<String, CaseFoldingHash> elementHashSet; + if (elementHashSet.isEmpty()) { For example, this snippet of xhtml: <foobar:p xmlns:foobar="http://www.w3.org/1999/xhtml" /> That is a "p" tag, and should be treated just like <p> in an HTML document or just like <xhtml:p> (if in some other document "xhtml" is bound to the xhtml namespace). The current code would do a lookup comparing "p" against "foobar:p" and fail. That's not what you want. :) A better way to do this lookup would probably be to just inline the hashtable back into the isTextFormattingElement function and do the namespaceURI comparison right before the hash-lookup. Like this: bool AccessibilityRenderObject::isTextFormattingElement() const { if (!m_renderer || !m_renderer->element()) return false; Element* element = m_renderer->element(); if (element->namespaceURI() != HTMLNames::htmlNamespaceURI) return false; static HashSet<String, CaseFoldingHash> formattingElements; if (formattingElements.isEmpty()) { formattingElements.add(bTag.localName()); formattingElements.add(bdoTag.localName()); ... } return formattingElements.contains(element->localName()); } I suggest inlining the hash setup back into the isTextFormattingElement function, because the hash can't really stand alone w/o the namespace lookup. 87546 46 22593 sankaraditya+bugzilla 2008-08-01 00:29:48 -0700 Created attachment 22593 Patch to expose only Relavant Accessible Objects This patch contains only the changes to expose only the relevant accessible objects. Implemented few heuristics to clean MSAA tree. These heuristics have been implemented to sync up the behaviour with Firefox 2.0.0.14. As Jon suggested, updated the patch with all comments inline. ~ Thanks. 87547 47 sankaraditya+bugzilla 2008-08-01 00:41:55 -0700 (In reply to comment #46) Jon, I have created this patch to expose relavant objects. I have created a new function textformattinglements. I have changed the order in heuristics are implemented. According to the new heuristics, This will be present in the tree as a button: <i role="button">Test.</i> This will be present as a list item: <i style="display: list-item;">Test.</i> This will be ignored: <i>Test.</i> This will also be ignored. This is done to match the behavior in firefox 2.0.0.14. <i style="display: block;">Test.</i> ~ Thanks. 87576 48 22599 sankaraditya+bugzilla 2008-08-01 08:39:50 -0700 Created attachment 22599 Patch to navigate between accessibility parent, children and siblings. This patch contains only the changes to navigate properly between accessibility parent, accessibility children and accessibility siblings. As Jon suggested, I have updated the patch with all my comments. ~ Thanks. 87675 49 22581 eric 2008-08-02 01:26:43 -0700 Comment on attachment 22581 Updated patch for Document Role These are all really directed @ Jon Honeycutt for review. Any reviewer should of course feel free to review them, but I'm adding Jon as the Requestee to remove them from the main list. 87733 50 22581 jhoneycutt 2008-08-03 13:44:21 -0700 Comment on attachment 22581 Updated patch for Document Role r=me Thanks, Sankar! 87734 51 22582 jhoneycutt 2008-08-03 14:04:16 -0700 Comment on attachment 22582 Update patch for Separator Role r=me! Some very minor typos: >+ * page/AccessibilityObject.h: >+ (WebCore::):Add Separator Role to AccessibilityRole enum. Missing a space before Add, extra space in SeparatorRole. >+ (WebCore::AccessibilityRenderObject::canSetFocusAttribute): return >+ false for <hr> tags, matching Firefox. Lower case 'r' in return. >+ * win/AccessibleBase.cpp: >+ (MSAARole):return ROLE_SYSTEM_SEPARATOR for Separator roles. Missing space and lower case 'r' in return, "Separator roles" -> SeparatorRole. Thanks for the patch! 87735 52 22583 jhoneycutt 2008-08-03 14:07:01 -0700 Comment on attachment 22583 Updated patch for ListItemRole r=me! Some typos: >+ (WebCore::AccessibilityRenderObject::roleValue): Return >+ listItemRole when rendered object is a list item. listItemRole -> ListItemRole >+ * win/AccessibleBase.cpp: >+ (MSAARole): Return ROLE_SYSTEM_LISTITEM for lisitem role. lisitem role -> ListItemRole Thanks, Sankar! 88467 53 22584 jhoneycutt 2008-08-14 00:07:51 -0700 Comment on attachment 22584 Updated patch for CellRole + if (m_renderer->isTableCell() || (node && node->hasTagName(thTag))) I think TH tags become RenderTableCells, and so the check for the TH tag name isn't necessary. r=me with that condition removed. Thanks for the patch! 88468 54 22585 jhoneycutt 2008-08-14 00:19:36 -0700 Comment on attachment 22585 Updated patch to populate Name attribute properly. + virtual const AccessibilityChildrenVector& children() const{ return m_children; } Missing space between const and {. These changes look good, but as they fix three different, unrelated object types, I think they should be split up: a patch to fix links and headings, a patch for images, and a patch for text objects. r- for this reason, but otherwise looks good, thanks! 88469 55 22586 jhoneycutt 2008-08-14 01:08:34 -0700 Comment on attachment 22586 Updated patch to populate Role attribute properly Looks like the changes related to children made it into your Name and Roles patches; they should be removed from one of them. return WebAreaRole; + if (m_renderer->isTable()) Needs a new line before the if. + if(isListElement(node)) Missing a space between if and (. When I use AccExplorer to look at Firefox 3's tree, label, abbr, acronym, and q tags do not return ROLE_SYSTEM_GROUPING: label returns ROLE_SYSTEM_STATICTEXT, acronym returns the string "acronym," abbr returns the string "abbr," and q returns the string "q." I think you said you were testing Firefox 2, is that right? Maybe this has changed in the newer version. I think we should try to match Firefox 3. Also, like the names patch, this patch changes the behavior of several unrelated objects. I think you should split this into separate patches for each object type: tables, lists, labels, etc. r- for these reasons, but thanks for the patch! :) 88590 56 22820 sankaraditya+bugzilla 2008-08-15 10:41:03 -0700 Created attachment 22820 Patch to populate the role attribute for list elements. As Jon suggested, I have obseleted the patch for populating role attribute. I have broken down the patch into small patches. I am uploading the patch that contains only the changes to populate ListRole for List elements. ~ Thanks. 88598 57 22822 sankaraditya+bugzilla 2008-08-15 12:08:51 -0700 Created attachment 22822 Patch to populate the name attribute for Image Elements As Jon Suggested, I have broken down the patch to populate Name attribute. This patch contains only the changes required to populate the Name attribute for Image elements. ~ Thanks. 88604 58 22825 sankaraditya+bugzilla 2008-08-15 13:06:10 -0700 Created attachment 22825 Patch to populate name attribute for links and headings. As jon suggested, I have broken down the patch to populate the Name attribute of the rendered elements. This patch contains only the changes to populate the Name attribute (In Inspect32) for links and headings. ~ Thanks. 88606 59 22826 sankaraditya+bugzilla 2008-08-15 14:06:45 -0700 Created attachment 22826 Patch to populate Name attribue for Text Elements As Jon suggested, I have broken down the patch to populate the Name attribute into small chunks. As part of that, I am uploading this patch. This patch contains only the changes required to populate the Name attribute of Text elements. (In Inspect32, name attribute for text elements is not populated properly. This patch is done to fix that issue.) 89056 60 22820 eric 2008-08-21 20:18:10 -0700 Comment on attachment 22820 Patch to populate the role attribute for list elements. Looks fine to me (except for not having a layout test), but Jon is our man here. 89057 61 darin 2008-08-21 20:23:26 -0700 We've set things up so you should be able to make layout tests for these kinds of AX tests. The existing tests are in LayoutTests/accessibility. Our usual policy is that we require regression tests for each fix, so you should learn how to add tests! 89058 62 22822 eric 2008-08-21 20:24:22 -0700 Comment on attachment 22822 Patch to populate the name attribute for Image Elements Do we already support the title attribute? Should we add support for such as well? title="foo" is a valid attribute on any HTML tag, I'm not sure if it should be represented via AX or not... In general this looks fine to me. Passing to Jon for final approval. 89061 63 22593 jhoneycutt 2008-08-21 21:52:49 -0700 Comment on attachment 22593 Patch to expose only Relavant Accessible Objects Sankar, thanks for the patch! This patch will be much easier to review if it is split up into smaller patches, and these changes will require layout tests to ensure that the behavior is correct now and will not regress in the future. The layout tests should test, for example, that: <i style="display: block">Test</i> is not ignored and is represented in the tree as a container element, and <i role="button">Test</i> is not ignored and is represented in the tree as a push button. I am not sure that testing objects by tag name is the right method for this, because I think that Firefox 3 only ignores elements based on whether they are inline. This patch also contains your previous patch's changes to the children/addChildren methods. Those should be removed. + virtual bool isTextFormattingElement() const; + virtual bool isLinkOrListItemElement() const; + virtual bool isFormOrTableElement() const; I don't think any of these methods need to be virtual methods on AccessibilityObject. r- 89065 64 22599 jhoneycutt 2008-08-21 22:13:34 -0700 Comment on attachment 22599 Patch to navigate between accessibility parent, children and siblings. + Add functions to navigate properly between the accessibility parent + and accessibility children. I'm not sure that this description gets the point across. The bug is that, currently, calling previousSibling, nextSibling, etc on an accessibility object could return items that shouldn't be exposed because their accessibility is ignored, correct? This should be more explicit in the ChangeLog. This patch contains the previous patch's changes to children/addChildren. These should be removed from this patch. I'm not sure that this patch will work properly if objects in the DOM are moved between parents, or if objects are added or removed. This will need a layout tests that confirm that, after these sorts of DOM operations, navigating between elements gives the expected result. If you find that the behavior is not correct, you might look at how parentObjectUnignored works and follow the same method. I think the name of the new methods should be consistent with the name of the parentObjectUnignored method, so the methods should be renamed nextSiblingUnignored, previousSiblingUnignored, and so on. + AccessibilityObject* parentObj = m_object->parentObjectUnignored(); + + if (parentObj) { + *parent = static_cast<IDispatch*>(wrapper(parentObj)); + (*parent)->AddRef(); + return S_OK; + } + This is a separate bug that could have its own patch. Thanks, Sankar! r- for these issues. 89066 65 22820 jhoneycutt 2008-08-21 22:19:12 -0700 Comment on attachment 22820 Patch to populate the role attribute for list elements. The change looks right, but without the change to expose list elements from your "Patch to expose only Relavant Accessible Objects ", it can't be verified in an accessibility tool that this patch works as expected. I think you should create a "patch to properly expose list elements" patch that exposes list elements, returns the correct role, and includes a short layout test. Thanks! r-, but the behavior looks correct. 89069 66 22822 jhoneycutt 2008-08-21 22:32:16 -0700 Comment on attachment 22822 Patch to populate the name attribute for Image Elements Eric is correct that we should respect the title attribute for image elements. Firefox 3 falls back to the title attribute if it doesn't find an alt attribute. Firefox respects the title attribute for many other elements, though, so I think that should be considered a separate bug. Firefox also ignores the alt attribute on objects that aren't native images, but I believe that's a bug. This change seems good to me, but I think a layout test that tests that both native images and objects with role="img" have their alternative text exposed. r=me, but please add a test. 89072 67 22825 jhoneycutt 2008-08-21 22:38:07 -0700 Comment on attachment 22825 Patch to populate name attribute for links and headings. + Populate Name attribute for links and Headins appropriately. Typos: Name, Headings shouldn't be capitalized, and headings is missing a g. This change looks fine, but it requires that your "Patch to populate Name attribue for Text Elements" be applied to test, so I think you should combine the two patches. r- for that, and please add layout tests. Thanks! 89073 68 22826 jhoneycutt 2008-08-21 22:38:54 -0700 Comment on attachment 22826 Patch to populate Name attribue for Text Elements The change looks good, but it should be combined with the previous patch -- clearing review. 89077 69 22822 eric 2008-08-22 00:05:24 -0700 Comment on attachment 22822 Patch to populate the name attribute for Image Elements Is it even possible to write AX layout tests for webkit on windows yet? My understanding is that Sankar has been doing his development mostly from windows. 89079 70 sankaraditya+bugzilla 2008-08-22 00:14:19 -0700 Jon/Eric, I have been doing the development on Windows Machine only. I have not done any type of development on MAC. It would be great if you can provide some pointers to any documents that specify the steps to create the Accessibility layout tests on Windows. ~ Thanks. (In reply to comment #69) > (From update of attachment 22822 [edit]) > Is it even possible to write AX layout tests for webkit on windows yet? My > understanding is that Sankar has been doing his development mostly from > windows. > 89080 71 eric 2008-08-22 00:25:32 -0700 (In reply to comment #70) > Jon/Eric, > I have been doing the development on Windows Machine only. I have not done any > type of development on MAC. It would be great if you can provide some pointers > to any documents that specify the steps to create the Accessibility layout > tests on Windows. > > ~ Thanks. http://trac.webkit.org/browser/trunk/WebKitTools/DumpRenderTree/AccessibilityController.h http://trac.webkit.org/browser/trunk/WebKitTools/DumpRenderTree/AccessibilityController.cpp http://trac.webkit.org/browser/trunk/WebKitTools/DumpRenderTree/AccessibilityUIElement.h http://trac.webkit.org/browser/trunk/WebKitTools/DumpRenderTree/AccessibilityUIElement.cpp and http://trac.webkit.org/browser/trunk/WebKitTools/DumpRenderTree/mac/AccessibilityControllerMac.mm http://trac.webkit.org/browser/trunk/WebKitTools/DumpRenderTree/mac/AccessibilityUIElementMac.mm Show how we support AX layout tests on mac using AccessibilityController an AccessibilityUIElement. The problem is the windows-specific bits (for tying into Windows AX apis) have not been written yet in: http://trac.webkit.org/browser/trunk/WebKitTools/DumpRenderTree/win (AccessibilityControllerWin.cpp and AccessibilityUIElementWin.cpp don't exist yet) Adding support for such is outside the scope of this bug, but until it's done, it is (as darin and Jon have pointed out), very difficult to assure the correctness of any changes to windows-specific AX support. If you're looking for examples of Accessibility layout tests, they can be found here: http://trac.webkit.org/browser/trunk/LayoutTests/accessibility you can look at the .html files and the -expected.txt files to see how these AccessibilityController and AccessibilityUIElement objects are accessed via these javascript-based tests. But again, those tests are disabled when running "run-webkit-tests" on Windows: http://trac.webkit.org/browser/trunk/LayoutTests/platform/win/Skipped#L409 If you were to use "run-webkit-tests" on a Mac it would correctly run the accessibility tests. Unfortunately that doesn't help you much when you're trying to make windows-specific changes to our AX support. :) When you change common/cross-platform files, however, it is helpful to be able to run-webkit-tests on a mac to see what results have changed for the accessibility tests. 89141 72 jhoneycutt 2008-08-22 14:02:30 -0700 Sankar, I believe most of your changes are cross-platform, and so you should be able to write tests that will run on the Mac (and eventually Windows). 89197 73 jhoneycutt 2008-08-24 06:05:50 -0700 Sankar, I've landed some initial support for accessibility layout tests on Windows; see bug 20497. This should help with the layout tests for some of your patches. 89402 74 23005 sankaraditya+bugzilla 2008-08-26 11:07:38 -0700 Created attachment 23005 Patch to expose list elements and populate role attribute for them correctly. As Jon suggested, I have merged the patches "populate role attribute for list elements" with "patch to expose list elements". Also, I have added as simple atomic layout test for this patch. In short, this patch contains only the changes that expose the list elements and set the role attribute of list elements to "list". ~ Thanks. 89413 75 23006 sankaraditya+bugzilla 2008-08-26 14:34:59 -0700 Created attachment 23006 Patch to populate name attribute for text nodes, links and headings. As jon has suggested, I have merged the two patches i.e "patch to populate name attribute for text elements" and "patch to populate name attribute for links and headings". This patch contains only the required changes to populate the name attribute for text elements, links and headings. Also, this patch contains the atomic test cases for the fix. ~ Thanks. 89416 76 23007 sankaraditya+bugzilla 2008-08-26 15:27:27 -0700 Created attachment 23007 Patch to ignore anonymous block level elements As Jon suggested, I have broken down the patch to expose relavant accessible objects. This is the first patch as part of that process. This patch contains only the atomic changes needed to ignore anonymous block level elements. ~ Thanks. 89417 77 sankaraditya+bugzilla 2008-08-26 15:33:41 -0700 Jon, As per http://webkit.org/blog/115/webcore-rendering-ii-blocks-and-inlines/, webkit creates many intermediate anonymous blocks to satisfy few variants. As specified in that webpage, consider the following block: <i>Italic only <b>italic and bold <div> Wow, a block! </div> <div> Wow, another block! </div> More italic and bold text</b> More italic text</i> This block will be modified into <anonymous pre block> <i>Italic only <b>italic and bold</b></i> </anonymous pre block> <anonymous middle block> <div> Wow, a block! </div> <div> Wow, another block! </div> </anonymous middle block> <anonymous post block> <i><b>More italic and bold text</b> More italic text</i> </anonymous post block> Anonymous blocks create a lot number of intermediate elements of type grouping. This doesn't look nice and also makes the tree a heavy object. I have checked the behavior for the same HTML snippet in Firefox 3. Tree looks clean and simple. To match the behaviour of Firefox3, we shouldn't expose anonymous blocks. I have made the changes for this. Can you please check this. ~ Thanks 89421 78 sankaraditya+bugzilla 2008-08-26 15:47:18 -0700 Jon, I have checked this code for dynamic webpages also. I have written a simple webpage that adds and removes a <div> element when a button is pressed. My changes are working perfectly fine. I will create the layout tests ASAP and upload them. I am referencing m_children variable in the new functions that I have created. So, I need to change the functions i.e addChildren() and children() into const functions. As a part of this, I need to change the m_children variable into a mutable object. Otherwise we will face compilation errors. ~ Thanks. (In reply to comment #64) > (From update of attachment 22599 [edit]) > + Add functions to navigate properly between the accessibility parent > + and accessibility children. > > I'm not sure that this description gets the point across. The bug is that, > currently, calling previousSibling, nextSibling, etc on an accessibility object > could return items that shouldn't be exposed because their accessibility is > ignored, correct? This should be more explicit in the ChangeLog. > > This patch contains the previous patch's changes to children/addChildren. These > should be removed from this patch. > > I'm not sure that this patch will work properly if objects in the DOM are moved > between parents, or if objects are added or removed. This will need a layout > tests that confirm that, after these sorts of DOM operations, navigating > between elements gives the expected result. If you find that the behavior is > not correct, you might look at how parentObjectUnignored works and follow the > same method. > > I think the name of the new methods should be consistent with the name of the > parentObjectUnignored method, so the methods should be renamed > nextSiblingUnignored, previousSiblingUnignored, and so on. > > + AccessibilityObject* parentObj = m_object->parentObjectUnignored(); > + > + if (parentObj) { > + *parent = static_cast<IDispatch*>(wrapper(parentObj)); > + (*parent)->AddRef(); > + return S_OK; > + } > + > This is a separate bug that could have its own patch. > > Thanks, Sankar! r- for these issues. > 89425 79 23005 jhoneycutt 2008-08-26 16:28:28 -0700 Comment on attachment 23005 Patch to expose list elements and populate role attribute for them correctly. Sankar, great! Really happy to see this. +++ LayoutTests/accessibility/listelements-detection-expected.txt Because the role text is going to be different between platforms, I suggest you move the listelements-detection-expected.txt result to LayoutTests/platform/win/accessibility/. We can then put the mac-specific results in platform/mac/accessibility. Also, accessibility tests are currently disabled on Windows. You should edit the LayoutTests/platform/win/Skipped file, remove the lines: # Still need to implement AccessibilityController for DumpRenderTree on Windows accessibility and replace them with, for example: # These tests don't run under Windows or have mac-specific results. https://bugs.webkit.org/show_bug.cgi?id=20497 accessibility/aria-describedby-on-input.html accessibility/aria-labelledby-on-input.html accessibility/aria-range-value.html accessibility/aria-range.html accessibility/aria-roles.html accessibility/aria-slider.html accessibility/aria-spinbutton.html accessibility/bounds-for-range.html accessibility/document-attributes.html accessibility/image-map1.html accessibility/image-map2.html accessibility/internal-link-anchors.html accessibility/internal-link-anchors2.html accessibility/radio-button-checkbox-size.html accessibility/radio-button-group-members.html accessibility/table-attributes.html accessibility/table-cell-spans.html accessibility/table-cells.html accessibility/table-detection.html accessibility/table-sections.html accessibility/table-with-rules.html accessibility/textarea-insertion-point-line-number.html accessibility/textarea-line-for-index.html r=me with this change, and thanks! 89447 80 23006 jhoneycutt 2008-08-26 20:08:06 -0700 Comment on attachment 23006 Patch to populate name attribute for text nodes, links and headings. + if (isLink() || isHeading()) { I tested this in Firefox 3: <h1>heading <div>div</div></h1> <a>anchor <div>div</div></a> The anchor's title was "anchor div" which matches the new results from your patch, but the heading was nameless, so it seems that Firefox doesn't use this same method with a heading. I think the isHeading() check should be moved back where it was before this patch, and the layout tests for headings should be removed. + append(elementText, childrenVector[i]->title()); This doesn't match what Firefox 3 does with: <a title="title">text</a> In WebKit, the name would appear as "title", but in Firefox the name would be "text". I think you should use textUnderElement() instead of title(). Although this helps us to match Firefox, this patch breaks some of the current layout tests on the Mac. I'm going to ask one of our Mac engineers to look at this. It may be necessary to have different behavior for Mac and Windows. r- for the above issues. Thanks for the patch! 89448 81 23007 jhoneycutt 2008-08-26 21:11:42 -0700 Comment on attachment 23007 Patch to ignore anonymous block level elements + Ignore Anonymous blocks. Don't expose them in MSAA tree. Part of This should say, "don't expose them in the accessibility tree," since Mac uses the same tree. This change looks good, but it needs a test. For example, you could test: <div id="outer">A<div>B</div></div> The "outer" element's first child should be a text node. Thanks! r- for missing test. 89449 82 23006 jhoneycutt 2008-08-26 21:12:40 -0700 Comment on attachment 23006 Patch to populate name attribute for text nodes, links and headings. These test results should also be in platform/win/accessibility. 89697 83 23006 jhoneycutt 2008-08-28 15:45:21 -0700 Comment on attachment 23006 Patch to populate name attribute for text nodes, links and headings. Sankar, I verified with an engineer for accessibility on the Mac that RenderText objects should not return textUnderElement() for their name attribute on the Mac, so it would be necessary to have different behavior between the platforms. 90964 84 sankaraditya+bugzilla 2008-09-12 14:41:10 -0700 Jon, I have created few tests for this bug. When I was testing the run-webkit-tests, i have got the following erro: <error> $ WebKit/WebKitTools/Scripts/run-webkit-tests accessibility 10752 [main] perl 1360 C:\cygwin\bin\perl.exe: *** fatal error - unable to rem ap C:\cygwin\lib\perl5\5.10\i686-cygwin\auto\File\Glob\Glob.dll to same address as parent(0x1260000) != 0x1CD0000 5373 [main] perl 9136 fork: child 1360 - died waiting for dll loading, errno 11 5226630 [main] perl 9204 C:\cygwin\bin\perl.exe: *** fatal error - unable to rem ap C:\cygwin\lib\perl5\5.10\i686-cygwin\auto\File\Glob\Glob.dll to same address as parent(0x1260000) != 0x1CD0000 5246988 [main] perl 9136 fork: child 9204 - died waiting for dll loading, errno 11 </error> I browser the bugzilla for the solution. But, I couldn't find one. Can you throw some light on resolving this issue. ~ Thanks. (In reply to comment #83) > (From update of attachment 23006 [edit]) > Sankar, I verified with an engineer for accessibility on the Mac that > RenderText objects should not return textUnderElement() for their name > attribute on the Mac, so it would be necessary to have different behavior > between the platforms. > 91302 85 jhoneycutt 2008-09-15 19:38:26 -0700 (In reply to comment #84) Hi, Sankar! Are you running Windows Vista? If so, look at the last part of step 3 on http://webkit.org/building/tools.html . If you aren't, I'm not sure what would cause that error. 95104 86 darin 2008-10-12 16:54:34 -0700 I tried to land one of these patches and svn-apply couldn't apply it successfully. We need to do something about to get the many review+ patches attached to this bug landed. And also, why are we planning to land all these with no regression tests? 101116 87 mrowe 2008-12-02 16:53:56 -0800 Jon, what's the plan for these? We can't leave them sitting in the commit queue indefinitely. If they can't be landed as-is, they shouldn't be marked as r+. 105450 88 mrowe 2009-01-12 23:38:39 -0800 Jon, please do something to get these out of the commit queue. If they're not ready to be committed they should have the review flag cleared. 107285 89 sankaraditya+bugzilla 2009-01-27 19:40:52 -0800 Discussed with Jon. Closing this bug. Decided to log separate bugs to track each issue. Thanks, Sankar. (In reply to comment #88) > Jon, please do something to get these out of the commit queue. If they're not > ready to be committed they should have the review flag cleared. > 22417 2008-07-21 18:30:49 -0700 2008-07-22 21:23:57 -0700 Patch for enhancing WebKit Accessibility heuristics MyPatch.txt text/plain 24735 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTI4MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDQgQEAKKzIwMDgtMDctMjEgIFUtc3Rhbmd1dHVyaVxTYW5rYXIgVGFuZ3V0dXJp ICA8c2V0IEVNQUlMX0FERFJFU1MgZW52aXJvbm1lbnQgdmFyaWFibGU+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNF UyBBRERFRCBPUiBDSEFOR0VECisKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlPYmplY3Qu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNUZXh0Rm9ybWF0 dGluZ0VsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNM aW5rT3JMaXN0SXRlbUVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9i amVjdDo6aXNGb3JtT3JUYWJsZUVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJp bGl0eU9iamVjdDo6YWNjRmlyc3RDaGlsZCk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmls aXR5T2JqZWN0OjphY2NMYXN0Q2hpbGQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0 eU9iamVjdDo6cHJldmlvdXNBY2Nlc3NpYmlsaXR5U2libGluZyk6CisgICAgICAgIChXZWJDb3Jl OjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmcpOgorICAgICAg ICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6c2V0QWNjZXNzaWJpbGl0eUlEKToKKyAg ICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnNldEFjY2Vzc2libGVQYXJlbnQp OgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4pOgor ICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6 KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmFjY2Vzc2liaWxpdHlJ RCk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphY2Nlc3NpYmxlUGFy ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmNoaWxkcmVuKToK KyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Y3JlYXRlVGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKToKKyAgICAgICAg KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFjY0ZpcnN0Q2hpbGQpOgorICAg ICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWNjTGFzdENoaWxkKToK KyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnByZXZpb3VzQWNj ZXNzaWJpbGl0eVNpYmxpbmcpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdDo6bmV4dEFjY2Vzc2liaWxpdHlTaWJsaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzVGV4dEZvcm1hdHRpbmdFbGVtZW50KToKKyAgICAg ICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzRm9ybU9yVGFibGVFbGVt ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlu a09yTGlzdEl0ZW1FbGVtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmhlbHBUZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRpdGxlKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmVsZW1lbnRSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmFjY2Vzc2liaWxpdHlJc0lnbm9yZWQpOgorICAgICAgICAoV2ViQ29yZTo6QWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cm9sZVZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OkFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNhblNldEZvY3VzQXR0cmlidXRlKToKKyAgICAgICAg KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuKToKKyAgICAgICAg KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkcmVuKToKKyAgICAg ICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKwogMjAwOC0wNy0yMSAgS2V2 aW4gQ2FsaG91biAgPGtjYWxob3VuQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBB ZGVsZS4KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAJKHJldmlzaW9uIDM1 MTk4KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC05NDYsNiArOTQ2LDUxIEBAIEFjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxp dHlPYmplY3QKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojpp c1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0Cit7CisJcmV0dXJuIGZhbHNlOworfQorCiti b29sIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50KCkgY29uc3QK K3sKKwlyZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgQWNjZXNzaWJpbGl0eU9iamVjdDo6aXNGb3Jt T3JUYWJsZUVsZW1lbnQoKSBjb25zdAoreworCXJldHVybiBmYWxzZTsKK30KKworQWNjZXNzaWJp bGl0eU9iamVjdCogQWNjZXNzaWJpbGl0eU9iamVjdDo6YWNjRmlyc3RDaGlsZCgpIGNvbnN0Cit7 CisJcmV0dXJuIDA7Cit9CisKK0FjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlPYmpl Y3Q6OmFjY0xhc3RDaGlsZCgpIGNvbnN0Cit7CisJcmV0dXJuIDA7Cit9CisKK0FjY2Vzc2liaWxp dHlPYmplY3QqIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnByZXZpb3VzQWNjZXNzaWJpbGl0eVNpYmxp bmcoKSBjb25zdAoreworCXJldHVybiAwOworfQorCitBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nl c3NpYmlsaXR5T2JqZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmcoKSBjb25zdAoreworCXJl dHVybiAwOworfQorCit2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnNldEFjY2Vzc2liaWxpdHlJ RCh1bnNpZ25lZCBhY2Nlc3NpYmlsaXR5SUQpCit7CisJbV9hY2Nlc3NpYmlsaXR5SUQgPSBhY2Nl c3NpYmlsaXR5SUQ7Cit9CisKK3ZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6c2V0QWNjZXNzaWJs ZVBhcmVudChjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2Nlc3NpYmxlUGFyZW50KQorewor CW1fYWNjZXNzaWJsZVBhcmVudCA9IGFjY2Vzc2libGVQYXJlbnQ7Cit9CisKIEFjY2Vzc2liaWxp dHlSb2xlIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnJvbGVWYWx1ZSgpIGNvbnN0CiB7CiAgICAgcmV0 dXJuIFVua25vd25Sb2xlOwpAQCAtOTc3LDcgKzEwMjIsNyBAQCB2b2lkIEFjY2Vzc2liaWxpdHlP YmplY3Q6OmNoaWxkcmVuQ2hhbmdlCiAgICAgcmV0dXJuOwogfQogCi12b2lkIEFjY2Vzc2liaWxp dHlPYmplY3Q6OmFkZENoaWxkcmVuKCkKK3ZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hp bGRyZW4oKSBjb25zdAogewogfQogCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9i amVjdC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJ KHJldmlzaW9uIDM1MTk4KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAko d29ya2luZyBjb3B5KQpAQCAtMTQ0LDcgKzE0NCwxMSBAQCBlbnVtIEFjY2Vzc2liaWxpdHlSb2xl IHsKICAgICBXZWJBcmVhUm9sZSwKICAgICBIZWFkaW5nUm9sZSwKICAgICBMaXN0Qm94Um9sZSwK LSAgICBMaXN0Qm94T3B0aW9uUm9sZQorICAgIExpc3RCb3hPcHRpb25Sb2xlLAorICAgIExpc3RJ dGVtUm9sZSwKKyAgICBEb2N1bWVudFJvbGUsCisgICAgQ2VsbFJvbGUsCisgICAgU2VwYXJhdG9y Um9sZQogfTsKIAogc3RydWN0IFZpc2libGVQb3NpdGlvblJhbmdlIHsKQEAgLTI2Miw3ICsyNjYs MjMgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUo KSBjb25zdDsKICAgICB2aXJ0dWFsIEFYT2JqZWN0Q2FjaGUqIGF4T2JqZWN0Q2FjaGUoKSBjb25z dDsKLSAgICAKKworCXZpcnR1YWwgYm9vbCBpc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0 OworICAgIHZpcnR1YWwgYm9vbCBpc0xpbmtPckxpc3RJdGVtRWxlbWVudCgpIGNvbnN0OworICAg IHZpcnR1YWwgYm9vbCBpc0Zvcm1PclRhYmxlRWxlbWVudCgpIGNvbnN0OworCisJdmlydHVhbCBB Y2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NGaXJzdENoaWxkKCkgY29uc3QgOworICAgIHZpcnR1YWwg QWNjZXNzaWJpbGl0eU9iamVjdCogYWNjTGFzdENoaWxkKCkgY29uc3QgOworCisgICAgdmlydHVh bCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBwcmV2aW91c0FjY2Vzc2liaWxpdHlTaWJsaW5nKCkgY29u c3QgOworICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogbmV4dEFjY2Vzc2liaWxpdHlT aWJsaW5nKCkgY29uc3QgOworCisgICAgdW5zaWduZWQgYWNjZXNzaWJpbGl0eUlEKCkgeyByZXR1 cm4gbV9hY2Nlc3NpYmlsaXR5SUQgOyB9CisgICAgdm9pZCBzZXRBY2Nlc3NpYmlsaXR5SUQodW5z aWduZWQpOworCisgICAgY29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjZXNzaWJsZVBhcmVu dCgpIHsgIHJldHVybiBtX2FjY2Vzc2libGVQYXJlbnQgO30KKyAgICB2b2lkIHNldEFjY2Vzc2li bGVQYXJlbnQoY29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdCogKTsKKwogICAgIHZpcnR1YWwgSFRN TEFuY2hvckVsZW1lbnQqIGFuY2hvckVsZW1lbnQoKSBjb25zdDsKICAgICB2aXJ0dWFsIEVsZW1l bnQqIGFjdGlvbkVsZW1lbnQoKSBjb25zdDsKICAgICB2aXJ0dWFsIEludFJlY3QgYm91bmRpbmdC b3hSZWN0KCkgY29uc3Q7CkBAIC0zMDksOCArMzI5LDggQEAgcHVibGljOgogICAgIGJvb2wgcGVy Zm9ybURlZmF1bHRBY3Rpb24oKSBjb25zdCB7IHJldHVybiBwcmVzcygpOyB9CiAgICAgCiAgICAg dmlydHVhbCB2b2lkIGNoaWxkcmVuQ2hhbmdlZCgpOwotICAgIHZpcnR1YWwgY29uc3QgQWNjZXNz aWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbigpIHsgcmV0dXJuIG1fY2hpbGRyZW47IH0K LSAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vz c2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKSBjb25zdCB7IHJldHVybiBtX2NoaWxk cmVuOyB9CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVh bCBib29sIGhhc0NoaWxkcmVuKCkgY29uc3QgeyByZXR1cm4gbV9oYXZlQ2hpbGRyZW47IH07CiAg ICAgdmlydHVhbCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yJik7CiAgICAgdmlydHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hp bGRyZW5WZWN0b3ImKTsKQEAgLTM4Miw5ICs0MDIsMTIgQEAgcHVibGljOgogCiBwcm90ZWN0ZWQ6 CiAgICAgdW5zaWduZWQgbV9pZDsKLSAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbV9j aGlsZHJlbjsKKyAgICBtdXRhYmxlIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2NoaWxk cmVuOwogICAgIG11dGFibGUgYm9vbCBtX2hhdmVDaGlsZHJlbjsKLSAgICAKKworICAgIHVuc2ln bmVkIG1fYWNjZXNzaWJpbGl0eUlEOworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3QqIG1f YWNjZXNzaWJsZVBhcmVudDsKKwkKICAgICB2aXJ0dWFsIHZvaWQgY2xlYXJDaGlsZHJlbigpOwog ICAgIHZpcnR1YWwgdm9pZCByZW1vdmVBWE9iamVjdElEKCk7CiAgICAgdmlydHVhbCBib29sIGlz RGV0YWNoZWQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAzNTE5OCkKKysrIFdlYkNvcmUv cGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTA5 LDYgKzEwOSwzOSBAQCB2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmRldGFjaCgpCiAg ICAgbV9yZW5kZXJlciA9IDA7ICAgIAogfQogCitXVEY6Okhhc2hTZXQ8U3RyaW5nPiBjcmVhdGVU ZXh0Rm9ybWF0dGluZ0VsZW1lbnROYW1lc0hhc2goKSAKK3sKKyAgICBIYXNoU2V0PFN0cmluZz4g ZWxlbWVudEhhc2hTZXQgOworCisgICAgZWxlbWVudEhhc2hTZXQuYWRkKGJUYWcudG9TdHJpbmco KSk7CisgICAgZWxlbWVudEhhc2hTZXQuYWRkKGJUYWcudG9TdHJpbmcoKSk7CisgICAgZWxlbWVu dEhhc2hTZXQuYWRkKGJkb1RhZy50b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQo YmlnVGFnLnRvU3RyaW5nKCkpOworICAgIGVsZW1lbnRIYXNoU2V0LmFkZChjaXRlVGFnLnRvU3Ry aW5nKCkpOworICAgIGVsZW1lbnRIYXNoU2V0LmFkZChkZm5UYWcudG9TdHJpbmcoKSk7CisgICAg ZWxlbWVudEhhc2hTZXQuYWRkKGRlbFRhZy50b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFzaFNl dC5hZGQoaW5zVGFnLnRvU3RyaW5nKCkpOworICAgIGVsZW1lbnRIYXNoU2V0LmFkZChlbVRhZy50 b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQoZm9udFRhZy50b1N0cmluZygpKTsK KyAgICBlbGVtZW50SGFzaFNldC5hZGQoaVRhZy50b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFz aFNldC5hZGQoc1RhZy50b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQoc2FtcFRh Zy50b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQoc3BhblRhZy50b1N0cmluZygp KTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQoc3RyaWtlVGFnLnRvU3RyaW5nKCkpOworICAgIGVs ZW1lbnRIYXNoU2V0LmFkZChzdHJvbmdUYWcudG9TdHJpbmcoKSk7CisgICAgZWxlbWVudEhhc2hT ZXQuYWRkKHN1YlRhZy50b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQoc3VwVGFn LnRvU3RyaW5nKCkpOworICAgIGVsZW1lbnRIYXNoU2V0LmFkZCh0ZXh0YXJlYVRhZy50b1N0cmlu ZygpKTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQodHRUYWcudG9TdHJpbmcoKSk7CisgICAgZWxl bWVudEhhc2hTZXQuYWRkKHVUYWcudG9TdHJpbmcoKSk7CisgICAgZWxlbWVudEhhc2hTZXQuYWRk KHByZVRhZy50b1N0cmluZygpKTsKKyAgICBlbGVtZW50SGFzaFNldC5hZGQoZGl2VGFnLnRvU3Ry aW5nKCkpOworICAgIGVsZW1lbnRIYXNoU2V0LmFkZChjZW50ZXJUYWcudG9TdHJpbmcoKSk7CisK KyAgICByZXR1cm4gZWxlbWVudEhhc2hTZXQ7CisKK30KKwogQWNjZXNzaWJpbGl0eU9iamVjdCog QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Zmlyc3RDaGlsZCgpIGNvbnN0CiB7CiAgICAgaWYg KCFtX3JlbmRlcmVyKQpAQCAtMTU3LDYgKzE5MCw0MiBAQCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBB Y2Nlc3NpYmlsaXR5UmVuZGVyCiAgICAgcmV0dXJuIG1fcmVuZGVyZXItPmRvY3VtZW50KCktPmF4 T2JqZWN0Q2FjaGUoKS0+Z2V0KG5leHRTaWJsaW5nKTsKIH0KIAorQWNjZXNzaWJpbGl0eU9iamVj dCogQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWNjRmlyc3RDaGlsZCgpIGNvbnN0Cit7Cisg ICAgaWYgKG1fY2hpbGRyZW4uaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJl dHVybiBtX2NoaWxkcmVuLmZpcnN0KCkuZ2V0KCk7Cit9CisKK0FjY2Vzc2liaWxpdHlPYmplY3Qq IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFjY0xhc3RDaGlsZCgpIGNvbnN0Cit7CisgICAg aWYgKG1fY2hpbGRyZW4uaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJldHVy biBtX2NoaWxkcmVuLmxhc3QoKS5nZXQoKTsKK30KKworQWNjZXNzaWJpbGl0eU9iamVjdCogQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cHJldmlvdXNBY2Nlc3NpYmlsaXR5U2libGluZygpIGNv bnN0Cit7CisgICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBzaWJsaW5nc1Zl Y3RvciA9IG1fYWNjZXNzaWJsZVBhcmVudC0+Y2hpbGRyZW4oKTsKKworICAgIGlmIChtX2FjY2Vz c2liaWxpdHlJRCA9PSAwKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJldHVybiBzaWJsaW5n c1ZlY3RvclttX2FjY2Vzc2liaWxpdHlJRCAtIDFdLmdldCgpOworfQorCitBY2Nlc3NpYmlsaXR5 T2JqZWN0KiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNpYmxp bmcoKSBjb25zdAoreworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgc2li bGluZ3NWZWN0b3IgPSBtX2FjY2Vzc2libGVQYXJlbnQtPmNoaWxkcmVuKCk7CisKKyAgICBpZiAo bV9hY2Nlc3NpYmlsaXR5SUQgKyAxID09IHNpYmxpbmdzVmVjdG9yLnNpemUoKSkKKyAgICAgICAg cmV0dXJuIDA7CisKKyAgICByZXR1cm4gc2libGluZ3NWZWN0b3JbbV9hY2Nlc3NpYmlsaXR5SUQg KyAxXS5nZXQoKTsKK30KKwogQWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdDo6cGFyZW50T2JqZWN0KCkgY29uc3QKIHsKICAgICBpZiAoIW1fcmVuZGVyZXIpCkBA IC00MDMsNyArNDcyLDUyIEBAIGJvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6aXNIZWFk aW4KIHsKICAgICByZXR1cm4gcm9sZVZhbHVlKCkgPT0gSGVhZGluZ1JvbGU7CiB9CisKK2Jvb2wg QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6aXNUZXh0Rm9ybWF0dGluZ0VsZW1lbnQoKSBjb25z dAoreworICAgIHN0YXRpYyBXVEY6Okhhc2hTZXQ8U3RyaW5nPiB0ZXh0Rm9ybWF0dGluZ0VsZW1l bnROYW1lcyA9IAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY3Jl YXRlVGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKCk7CisgICAgCisgICAgaWYgKG1fcmVu ZGVyZXIgJiYgbV9yZW5kZXJlci0+ZWxlbWVudCgpKQorICAgICAgICByZXR1cm4gdGV4dEZvcm1h dHRpbmdFbGVtZW50TmFtZXMuY29udGFpbnMobV9yZW5kZXJlci0+ZWxlbWVudCgpLT5ub2RlTmFt ZSgpLmxvd2VyKCkpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIAorfQor Citib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzRm9ybU9yVGFibGVFbGVtZW50KCkg Y29uc3QKK3sKKyAgICBpZiAoIW1fcmVuZGVyZXIgfHwgIW1fcmVuZGVyZXItPmVsZW1lbnQoKSkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKG1fcmVuZGVyZXItPmVsZW1lbnQoKS0+ aGFzVGFnTmFtZShmb3JtVGFnKSB8fAorICAgICAgICAgICAgbV9yZW5kZXJlci0+ZWxlbWVudCgp LT5oYXNUYWdOYW1lKHRhYmxlVGFnKSB8fAorICAgICAgICAgICAgbV9yZW5kZXJlci0+ZWxlbWVu dCgpLT5oYXNUYWdOYW1lKHRkVGFnKSB8fAorICAgICAgICAgICAgbV9yZW5kZXJlci0+ZWxlbWVu dCgpLT5oYXNUYWdOYW1lKHRoVGFnKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICByZXR1 cm4gZmFsc2U7CisKK30KKworYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc0xpbmtP ckxpc3RJdGVtRWxlbWVudCgpIGNvbnN0Cit7CisgICAgaWYgKCFtX3JlbmRlcmVyIHx8ICFtX3Jl bmRlcmVyLT5lbGVtZW50KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChtX3Jl bmRlcmVyLT5lbGVtZW50KCktPmlzTGluaygpIHx8CisgICAgICAgICAgICAgICAgIG1fcmVuZGVy ZXItPmVsZW1lbnQoKS0+aGFzVGFnTmFtZShhYmJyVGFnKSB8fAorICAgICAgICAgICAgICAgICBt X3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUoYWNyb255bVRhZykgfHwKKyAgICAgICAg ICAgICAgICAgbV9yZW5kZXJlci0+ZWxlbWVudCgpLT5oYXNUYWdOYW1lKHFUYWcpIHx8CisgICAg ICAgICAgICAgICAgIG1fcmVuZGVyZXItPmVsZW1lbnQoKS0+aGFzVGFnTmFtZShsaVRhZykgfHwK KyAgICAgICAgICAgICAgICAgbV9yZW5kZXJlci0+ZWxlbWVudCgpLT5oYXNUYWdOYW1lKGRkVGFn KSB8fAorICAgICAgICAgICAgICAgICBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUo ZHRUYWcpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICBlbHNlCisgICAgICAgIHJldHVybiBm YWxzZTsKKworfQorCQogYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc0xpbmsoKSBj b25zdAogewogICAgIHJldHVybiByb2xlVmFsdWUoKSA9PSBXZWJDb3JlTGlua1JvbGU7CkBAIC01 NTYsNyArNjcwLDcgQEAgQWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0eVJlbmRlcgog U3RyaW5nIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmhlbHBUZXh0KCkgY29uc3QKIHsKICAg ICBpZiAoIW1fcmVuZGVyZXIpCi0gICAgICAgIHJldHVybiBTdHJpbmcoKTsKKyAgICAgICAgcmV0 dXJuIFN0cmluZygpOyAgICAKICAgICAKICAgICBmb3IgKFJlbmRlck9iamVjdCogY3VyciA9IG1f cmVuZGVyZXI7IGN1cnI7IGN1cnIgPSBjdXJyLT5wYXJlbnQoKSkgewogICAgICAgICBpZiAoY3Vy ci0+ZWxlbWVudCgpICYmIGN1cnItPmVsZW1lbnQoKS0+aXNIVE1MRWxlbWVudCgpKSB7CkBAIC04 MzAsMTcgKzk0NCw0MSBAQCBTdHJpbmcgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6dGl0bGUo CiAgICAgICAgIGlmIChsYWJlbCkKICAgICAgICAgICAgIHJldHVybiBsYWJlbC0+aW5uZXJUZXh0 KCk7CiAgICAgfQotICAgIAorCisgICAgaWYgKG1fcmVuZGVyZXItPmVsZW1lbnQoKS0+aXNMaW5r KCkgfHwgaXNIZWFkaW5nKCkpIHsKKyAgICAgICAgY29uc3QgVmVjdG9yPCBSZWZQdHI8QWNjZXNz aWJpbGl0eU9iamVjdD4gPiYgY2hpbGRyZW5WZWN0b3IgPSBjaGlsZHJlbigpOworICAgICAgICBW ZWN0b3I8VUNoYXI+IGVsZW1lbnRUZXh0OworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBp IDwgY2hpbGRyZW5WZWN0b3Iuc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgICAgIGVsZW1lbnRUZXh0 LmFwcGVuZCgnICcpOworICAgICAgICAgICAgU3RyaW5nIGVsZW1lbnRUaXRsZSA9IGNoaWxkcmVu VmVjdG9yW2ldLT50aXRsZSgpOworICAgICAgICAgICAgZWxlbWVudFRleHQuYXBwZW5kKGVsZW1l bnRUaXRsZS5jaGFyYWN0ZXJzKCksZWxlbWVudFRpdGxlLmxlbmd0aCgpKTsKKyAgICAgICAgfQor CisgICAgICAgIHJldHVybiBTdHJpbmc6OmFkb3B0KGVsZW1lbnRUZXh0KS5zdHJpcFdoaXRlU3Bh Y2UoKTsKKyAgICAgICAgCisgICAgfQorCiAgICAgaWYgKHJvbGVWYWx1ZSgpID09IEJ1dHRvblJv bGUKICAgICAgICAgfHwgYXJpYVJvbGUgPT0gTGlzdEJveE9wdGlvblJvbGUKICAgICAgICAgfHwg YXJpYVJvbGUgPT0gTWVudUl0ZW1Sb2xlCi0gICAgICAgIHx8IGFyaWFSb2xlID09IE1lbnVCdXR0 b25Sb2xlCi0gICAgICAgIHx8IGlzSGVhZGluZygpKQorICAgICAgICB8fCBhcmlhUm9sZSA9PSBN ZW51QnV0dG9uUm9sZSkgICAgICAgIAogICAgICAgICByZXR1cm4gdGV4dFVuZGVyRWxlbWVudCgp OwotICAgIAotICAgIGlmIChpc0xpbmsoKSkKKworCWlmIChpc0ltYWdlKCkpIHsKKyAgICAgICAg Tm9kZSogbm9kZSA9IG1fcmVuZGVyZXItPmVsZW1lbnQoKTsKKyAgICAgICAgaWYgKG5vZGUgJiYg bm9kZS0+aXNFbGVtZW50Tm9kZSgpKSB7CisgICAgICAgICAgICBFbGVtZW50KiBlbHQgPSBzdGF0 aWNfY2FzdDxFbGVtZW50Kj4obm9kZSk7CisgICAgICAgICAgICBjb25zdCBBdG9taWNTdHJpbmcm IGFsdCA9IGVsdC0+Z2V0QXR0cmlidXRlKGFsdEF0dHIpOworICAgICAgICAgICAgaWYgKCFhbHQu aXNOdWxsKCkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGFsdC5zdHJpbmcoKTsKKyAgICAgICAg ICAgIGVsc2UKKyAgICAgICAgICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisgICAgICAgIH0KKyAg ICB9CisJCisgICAgaWYgKG1fcmVuZGVyZXItPmlzVGV4dCgpKQogICAgICAgICByZXR1cm4gdGV4 dFVuZGVyRWxlbWVudCgpOwotICAgIAorCQogICAgIHJldHVybiBTdHJpbmcoKTsKIH0KIApAQCAt OTMyLDYgKzEwNzAsNyBAQCBJbnRSZWN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoZWNr CiAKIEludFJlY3QgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6ZWxlbWVudFJlY3QoKSBjb25z dAogeworICAKICAgICAvLyBhIGNoZWNrYm94IG9yIHJhZGlvIGJ1dHRvbiBzaG91bGQgZW5jb21w YXNzIGl0cyBsYWJlbAogICAgIGlmIChpc0NoZWNrYm94T3JSYWRpbygpKQogICAgICAgICByZXR1 cm4gY2hlY2tib3hPclJhZGlvUmVjdCgpOwpAQCAtMTA3NywyNCArMTIxNiw0NyBAQCBib29sIEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFjY2Vzc2liCiAgICAgQWNjZXNzaWJpbGl0eVJvbGUg YXJpYVJvbGUgPSBhcmlhUm9sZUF0dHJpYnV0ZSgpOwogICAgIGlmIChhcmlhUm9sZSA9PSBUZXh0 QXJlYVJvbGUgfHwgYXJpYVJvbGUgPT0gU3RhdGljVGV4dFJvbGUpIHsKICAgICAgICAgU3RyaW5n IGFyaWFUZXh0ID0gdGV4dCgpOwotICAgICAgICByZXR1cm4gYXJpYVRleHQuaXNOdWxsKCkgfHwg YXJpYVRleHQuaXNFbXB0eSgpOworICAgICAgICByZXR1cm4gYXJpYVRleHQuaXNOdWxsKCkgfHwg YXJpYVRleHQuaXNFbXB0eSgpIHx8ICFhcmlhVGV4dC5zdHJpcFdoaXRlU3BhY2UoKS5sZW5ndGgo KSA7CiAgICAgfSAgICAKICAgICAKLSAgICAvLyBOT1RFOiBCUnMgYWx3YXlzIGhhdmUgdGV4dCBi b3hlcyBub3csIHNvIHRoZSB0ZXh0IGJveCBjaGVjayBoZXJlIGNhbiBiZSByZW1vdmVkCisKICAg ICBpZiAobV9yZW5kZXJlci0+aXNUZXh0KCkpIHsKICAgICAgICAgLy8gc3RhdGljIHRleHQgYmVu ZWF0aCBNZW51SXRlbXMgYW5kIE1lbnVCdXR0b25zIGFyZSBqdXN0IHJlcG9ydGVkIGFsb25nIHdp dGggdGhlIG1lbnUgaXRlbSwgc28gaXQncyBpZ25vcmVkIG9uIGFuIGluZGl2aWR1YWwgbGV2ZWwK LSAgICAgICAgaWYgKHBhcmVudE9iamVjdFVuaWdub3JlZCgpLT5hcmlhUm9sZUF0dHJpYnV0ZSgp ID09IE1lbnVJdGVtUm9sZSB8fAotICAgICAgICAgICAgcGFyZW50T2JqZWN0VW5pZ25vcmVkKCkt PmFyaWFSb2xlQXR0cmlidXRlKCkgPT0gTWVudUJ1dHRvblJvbGUpCisJCWlmICh0ZXh0VW5kZXJF bGVtZW50KCkuc3RyaXBXaGl0ZVNwYWNlKCkubGVuZ3RoKCkgIT0gMCkgIHsKKyAgICAgICAgICAg IGlmIChwYXJlbnRPYmplY3RVbmlnbm9yZWQoKS0+YXJpYVJvbGVBdHRyaWJ1dGUoKSA9PSBNZW51 SXRlbVJvbGUgfHwKKyAgICAgICAgICAgICAgICBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKS0+YXJp YVJvbGVBdHRyaWJ1dGUoKSA9PSBNZW51QnV0dG9uUm9sZSkKKwkJCQlyZXR1cm4gdHJ1ZTsKKwkJ CWVsc2UKKwkJCQlyZXR1cm4gZmFsc2U7CisJCX0gZWxzZSB7CiAgICAgICAgICAgICByZXR1cm4g dHJ1ZTsKLSAgICAgICAgIHJldHVybiBtX3JlbmRlcmVyLT5pc0JSKCkgfHwgIXN0YXRpY19jYXN0 PFJlbmRlclRleHQqPihtX3JlbmRlcmVyKS0+Zmlyc3RUZXh0Qm94KCk7CisJCX0KICAgICB9CiAg ICAgCiAgICAgaWYgKGlzSGVhZGluZygpKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgCi0g ICAgaWYgKGlzTGluaygpKQorCisgICAgaWYgKGlzVGV4dEZvcm1hdHRpbmdFbGVtZW50KCkpCisg ICAgICAgIHJldHVybiB0cnVlOworCisgICAgaWYgKGlzTGlzdEVsZW1lbnQobV9yZW5kZXJlci0+ ZWxlbWVudCgpKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIAorCisgICAgaWYgKGlzRm9y bU9yVGFibGVFbGVtZW50KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwkKKyAgICBpZiAoaXNM aW5rT3JMaXN0SXRlbUVsZW1lbnQoKSkgICAgICAgICAKKyAgICAgICAgaWYgKGNoaWxkcmVuKCku c2l6ZSgpID09IDApCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgZWxzZQorICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKG1fcmVuZGVyZXItPmVsZW1lbnQoKSAm JiBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUoaHRtbFRhZykgKQorICAgICAgICBy ZXR1cm4gdHJ1ZTsKKworICAgIGlmIChtX3JlbmRlcmVyLT5lbGVtZW50KCkgJiYgbV9yZW5kZXJl ci0+ZWxlbWVudCgpLT5oYXNUYWdOYW1lKGJvZHlUYWcpICkKKyAgICAgICAgcmV0dXJuIHRydWU7 CisJCiAgICAgLy8gYWxsIGNvbnRyb2xzIGFyZSBhY2Nlc3NpYmxlCiAgICAgaWYgKGlzQ29udHJv bCgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC0xMTA0LDggKzEyNjYsMTQgQEAgYm9vbCBB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphY2Nlc3NpYgogICAgIGlmIChub2RlICYmIG5vZGUt Pmhhc1RhZ05hbWUobGFiZWxUYWcpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgCi0gICAg aWYgKG1fcmVuZGVyZXItPmlzQmxvY2tGbG93KCkgJiYgbV9yZW5kZXJlci0+Y2hpbGRyZW5Jbmxp bmUoKSkKLSAgICAgICAgcmV0dXJuICFzdGF0aWNfY2FzdDxSZW5kZXJCbG9jayo+KG1fcmVuZGVy ZXIpLT5maXJzdExpbmVCb3goKSAmJiAhbW91c2VCdXR0b25MaXN0ZW5lcigpOworICAgIGlmICht X3JlbmRlcmVyLT5pc0Jsb2NrRmxvdygpICkgIAorICAgICAgaWYgKG1fcmVuZGVyZXItPmlzQW5v bnltb3VzQmxvY2soKSkgICAKKyAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgIGVsc2UgIAor ICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgICAgIAorICAgIGlmIChtX3JlbmRl cmVyLT5pc0lubGluZUZsb3coKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgCiAgICAgLy8g aWdub3JlIGltYWdlcyBzZWVtaW5nbHkgdXNlZCBhcyBzcGFjZXJzCiAgICAgaWYgKGlzSW1hZ2Uo KSkgewpAQCAtMTk5NywxOCArMjE2NSwzMyBAQCBBY2Nlc3NpYmlsaXR5Um9sZSBBY2Nlc3NpYmls aXR5UmVuZGVyT2JqCiAgICAgaWYgKGFyaWFSb2xlICE9IFVua25vd25Sb2xlKQogICAgICAgICBy ZXR1cm4gYXJpYVJvbGU7CiAgICAgCi0gICAgaWYgKG5vZGUgJiYgbm9kZS0+aXNMaW5rKCkpIHsK LSAgICAgICAgaWYgKG1fcmVuZGVyZXItPmlzSW1hZ2UoKSkKKwlpZiAobm9kZSAmJiBub2RlLT5p c0xpbmsoKSkgeworICAgICAgICBpZiAoaXNJbWFnZSgpKQogICAgICAgICAgICAgcmV0dXJuIElt YWdlTWFwUm9sZTsKICAgICAgICAgcmV0dXJuIFdlYkNvcmVMaW5rUm9sZTsKICAgICB9CisKKyAg ICBpZiAobm9kZSAmJiBub2RlLT5pc0RvY3VtZW50Tm9kZSgpKQorICAgICAgICByZXR1cm4gRG9j dW1lbnRSb2xlOworCisgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZSh0YWJsZVRhZykp CisgICAgICAgIHJldHVybiBUYWJsZVJvbGU7CisKKyAgICBpZiAobm9kZSAmJiAobm9kZS0+aGFz VGFnTmFtZSh0ZFRhZykgfHwKKyAgICAgICAgICAgICAgICAgbm9kZS0+aGFzVGFnTmFtZSh0aFRh ZykKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICkpICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgCisgICAgICAgIHJldHVybiBDZWxsUm9sZTsKKwogICAgIGlmIChtX3Jl bmRlcmVyLT5pc0xpc3RNYXJrZXIoKSkKICAgICAgICAgcmV0dXJuIExpc3RNYXJrZXJSb2xlOwot ICAgIGlmIChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUoYnV0dG9uVGFnKSkKKworCWlmIChub2Rl ICYmIG5vZGUtPmhhc1RhZ05hbWUoYnV0dG9uVGFnKSkKICAgICAgICAgcmV0dXJuIEJ1dHRvblJv bGU7Ci0gICAgaWYgKG1fcmVuZGVyZXItPmlzVGV4dCgpKQorCisJaWYgKG1fcmVuZGVyZXItPmlz VGV4dCgpKQogICAgICAgICByZXR1cm4gU3RhdGljVGV4dFJvbGU7Ci0gICAgaWYgKG1fcmVuZGVy ZXItPmlzSW1hZ2UoKSkgeworCisJaWYgKG1fcmVuZGVyZXItPmlzSW1hZ2UoKSkgewogICAgICAg ICBpZiAobm9kZSAmJiBub2RlLT5oYXNUYWdOYW1lKGlucHV0VGFnKSkKICAgICAgICAgICAgIHJl dHVybiBCdXR0b25Sb2xlOwogICAgICAgICByZXR1cm4gSW1hZ2VSb2xlOwpAQCAtMjAzMiw5ICsy MjE1LDYgQEAgQWNjZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0eVJlbmRlck9iagogICAgICAg ICAgICAgcmV0dXJuIEJ1dHRvblJvbGU7CiAgICAgfQogCi0gICAgaWYgKG5vZGUgJiYgbm9kZS0+ aGFzVGFnTmFtZShidXR0b25UYWcpKQotICAgICAgICByZXR1cm4gQnV0dG9uUm9sZTsKLQogICAg IGlmIChpc0ZpbGVVcGxvYWRCdXR0b24oKSkKICAgICAgICAgcmV0dXJuIEJ1dHRvblJvbGU7CiAg ICAgCkBAIC0yMDQ0LDcgKzIyMjQsMjEgQEAgQWNjZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0 eVJlbmRlck9iagogICAgIGlmIChoZWFkaW5nTGV2ZWwobV9yZW5kZXJlci0+ZWxlbWVudCgpKSAh PSAwKQogICAgICAgICByZXR1cm4gSGVhZGluZ1JvbGU7CiAgICAgCi0gICAgaWYgKG1fcmVuZGVy ZXItPmlzQmxvY2tGbG93KCkgfHwgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShsYWJlbFRhZykp KQorICAgIGlmKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShsaVRhZykgKQorICAgICAgICByZXR1 cm4gTGlzdEl0ZW1Sb2xlOworCisgICAgaWYobm9kZSAmJiBub2RlLT5oYXNUYWdOYW1lKGhyVGFn KSApCisgICAgICAgIHJldHVybiBTZXBhcmF0b3JSb2xlOworCisgICAgaWYobm9kZSAmJiAoIG5v ZGUtPmhhc1RhZ05hbWUob2xUYWcpIHx8CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgbm9kZS0+aGFzVGFnTmFtZSh1bFRhZykgfHwgICAgCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgbm9kZS0+aGFzVGFnTmFtZShkbFRhZykgCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICkgKQorICAgICAgICByZXR1cm4gTGlzdFJvbGU7CisKKyAgICBpZiAobV9y ZW5kZXJlci0+aXNCbG9ja0Zsb3coKSB8fCBub2RlLT5oYXNUYWdOYW1lKGFiYnJUYWcpIHx8Cisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbm9kZS0+aGFzVGFnTmFtZShhY3Jv bnltVGFnKSB8fCAgICAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBub2Rl LT5oYXNUYWdOYW1lKHFUYWcpKQogICAgICAgICByZXR1cm4gR3JvdXBSb2xlOwogICAgIAogICAg IHJldHVybiBVbmtub3duUm9sZTsKQEAgLTIwOTAsNiArMjI4NCw4IEBAIGJvb2wgQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6Y2FuU2V0Rm8KICAgICAgICAgY2FzZSBQb3BVcEJ1dHRvblJvbGU6 CiAgICAgICAgIGNhc2UgQ2hlY2tCb3hSb2xlOgogICAgICAgICBjYXNlIFJhZGlvQnV0dG9uUm9s ZToKKwkgICAgY2FzZSBMaXN0SXRlbVJvbGU6CisJCWNhc2UgU2VwYXJhdG9yUm9sZToKICAgICAg ICAgICAgIHJldHVybiB0cnVlOwogICAgICAgICBjYXNlIFVua25vd25Sb2xlOgogICAgICAgICBj YXNlIFNsaWRlclJvbGU6CkBAIC0yMTM4LDYgKzIzMzQsOCBAQCBib29sIEFjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3Q6OmNhblNldEZvCiAgICAgICAgIGNhc2UgSGVhZGluZ1JvbGU6CiAgICAgICAg IGNhc2UgTGlzdEJveFJvbGU6CiAgICAgICAgIGNhc2UgTGlzdEJveE9wdGlvblJvbGU6CisJCWNh c2UgRG9jdW1lbnRSb2xlOgorCQljYXNlIENlbGxSb2xlOgogICAgICAgICAgICAgcmV0dXJuIGZh bHNlOwogICAgIH0KICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKQEAgLTIxNjgsMjAgKzIzNjYs MjIgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGlsZHJlbgogICAgIH0KIH0K IAotY29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9y JiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGlsZHJlbigpCitjb25zdCBBY2Nlc3NpYmls aXR5T2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmNoaWxkcmVuKCkgY29uc3QKIHsKICAgICBpZiAoIW1faGF2ZUNoaWxkcmVuKQog ICAgICAgICBhZGRDaGlsZHJlbigpOwogICAgIHJldHVybiBtX2NoaWxkcmVuOwogfQogCi12b2lk IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkcmVuKCkKK3ZvaWQgQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6YWRkQ2hpbGRyZW4oKSBjb25zdAogewogICAgIC8vIElmIHRoZSBu ZWVkIHRvIGFkZCBtb3JlIGNoaWxkcmVuIGluIGFkZGl0aW9uIHRvIGV4aXN0aW5nIGNoaWxkcmVu IGFyaXNlcywgCiAgICAgLy8gY2hpbGRyZW5DaGFuZ2VkIHNob3VsZCBoYXZlIGJlZW4gY2FsbGVk LCBsZWF2aW5nIHRoZSBvYmplY3Qgd2l0aCBubyBjaGlsZHJlbi4KICAgICBBU1NFUlQoIW1faGF2 ZUNoaWxkcmVuKTsgCi0gICAgCi0gICAgLy8gbm90aGluZyB0byBhZGQgaWYgdGhlcmUgaXMgbm8g UmVuZGVyT2JqZWN0CisKKwl1bnNpZ25lZCBjaGlsZENvdW50ZXIgPSAwOworCisJLy8gbm90aGlu ZyB0byBhZGQgaWYgdGhlcmUgaXMgbm8gUmVuZGVyT2JqZWN0CiAgICAgaWYgKCFtX3JlbmRlcmVy KQogICAgICAgICByZXR1cm47CiAgICAgCkBAIC0yMTk0LDkgKzIzOTQsMTQgQEAgdm9pZCBBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZAogICAgICAgICAgICAgICAgIG9iai0+YWRk Q2hpbGRyZW4oKTsKICAgICAgICAgICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBjaGls ZHJlbiA9IG9iai0+Y2hpbGRyZW4oKTsKICAgICAgICAgICAgIHVuc2lnbmVkIGxlbmd0aCA9IGNo aWxkcmVuLnNpemUoKTsKLSAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsZW5n dGg7ICsraSkKLSAgICAgICAgICAgICAgICBtX2NoaWxkcmVuLmFwcGVuZChjaGlsZHJlbltpXSk7 CisgICAgICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbGVuZ3RoOyArK2kpICB7Cisg ICAgICAgICAgICAgICAgY2hpbGRyZW5baV0tPnNldEFjY2Vzc2liaWxpdHlJRChjaGlsZENvdW50 ZXIrKyk7CisgICAgICAgICAgICAgICAgY2hpbGRyZW5baV0tPnNldEFjY2Vzc2libGVQYXJlbnQo dGhpcyk7CisJCQkJbV9jaGlsZHJlbi5hcHBlbmQoY2hpbGRyZW5baV0pOworCQkJfQogICAgICAg ICB9IGVsc2UKKwkJCW9iai0+c2V0QWNjZXNzaWJpbGl0eUlEKGNoaWxkQ291bnRlcisrKTsKKyAg ICAgICAgICAgIG9iai0+c2V0QWNjZXNzaWJsZVBhcmVudCh0aGlzKTsKICAgICAgICAgICAgIG1f Y2hpbGRyZW4uYXBwZW5kKG9iaik7CiAgICAgfQogICAgIApJbmRleDogV2ViQ29yZS9wYWdlL0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCShyZXZpc2lvbiAzNTE5OCkKKysrIFdlYkNvcmUvcGFn ZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTEzMCw3ICsx MzAsMTUgQEAgcHVibGljOgogICAgIHZvaWQgc2V0QXJpYVJvbGUoKTsKICAgICB2aXJ0dWFsIEFj Y2Vzc2liaWxpdHlSb2xlIHJvbGVWYWx1ZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgQVhPYmplY3RD YWNoZSogYXhPYmplY3RDYWNoZSgpIGNvbnN0OwotICAgIAorCisJdmlydHVhbCBib29sIGlzVGV4 dEZvcm1hdHRpbmdFbGVtZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzTGlua09yTGlz dEl0ZW1FbGVtZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzRm9ybU9yVGFibGVFbGVt ZW50KCkgY29uc3Q7CisJdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NGaXJzdENoaWxk KCkgY29uc3QgOworICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjTGFzdENoaWxk KCkgY29uc3QgOworICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogcHJldmlvdXNBY2Nl c3NpYmlsaXR5U2libGluZygpIGNvbnN0IDsKKyAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmpl Y3QqIG5leHRBY2Nlc3NpYmlsaXR5U2libGluZygpIGNvbnN0IDsKKwkKICAgICB2aXJ0dWFsIEVs ZW1lbnQqIGFjdGlvbkVsZW1lbnQoKSBjb25zdDsKICAgICBFbGVtZW50KiBtb3VzZUJ1dHRvbkxp c3RlbmVyKCkgY29uc3Q7CiAgICAgRnJhbWVWaWV3KiBmcmFtZVZpZXdJZlJlbmRlclZpZXcoKSBj b25zdDsKQEAgLTE3Miw3ICsxODAsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGdldERv Y3VtZW50TGlua3MoQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJikgY29uc3Q7CiAgICAgdmly dHVhbCBGcmFtZVZpZXcqIGRvY3VtZW50RnJhbWVWaWV3KCkgY29uc3Q7CiAgICAgCi0gICAgdmly dHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCk7CisgICAg dmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgY29u c3Q7CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHNldEZvY3VzZWQoYm9vbCk7CiAgICAgdmlydHVh bCB2b2lkIHNldFNlbGVjdGVkVGV4dFJhbmdlKGNvbnN0IFBsYWluVGV4dFJhbmdlJik7CkBAIC0x ODAsNyArMTg4LDcgQEAgcHVibGljOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBkZXRhY2goKTsK ICAgICB2aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCB2b2lkIGFk ZENoaWxkcmVuKCk7CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAg dmlydHVhbCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9y Jik7CiAgICAgdmlydHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRy ZW5WZWN0b3ImKTsKICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkRm9jdXNBY3RpdmVEZXNjZW5kYW50 KCkgY29uc3Q7CkluZGV4OiBXZWJLaXQvd2luL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXQvd2luL0NoYW5nZUxvZwkocmV2aXNpb24gMzUyODApCisrKyBXZWJLaXQvd2luL0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBACisyMDA4LTA3LTIxICBVLXN0YW5ndXR1 cmlcU2Fua2FyIFRhbmd1dHVyaSAgPHNldCBFTUFJTF9BRERSRVNTIGVudmlyb25tZW50IHZhcmlh YmxlPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog QWNjZXNzaWJsZUJhc2UuY3BwOgorICAgICAgICAoQWNjZXNzaWJsZUJhc2U6OmdldF9hY2NQYXJl bnQpOgorICAgICAgICAoQWNjZXNzaWJsZUJhc2U6OmFjY05hdmlnYXRlKToKKyAgICAgICAgKE1T QUFSb2xlKToKKyAgICAgICAgKiBXZWJLaXQudmNwcm9qL2J1aWxkLWdlbmVyYXRlZC1maWxlcy5z aDoKKwogMjAwOC0wNy0xNSAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAg ICAgQWRkIFdlYktpdFtTZXRdU2hvdWxkVXNlRm9udFNtb290aGluZyBmdW5jdGlvbnMKSW5kZXg6 IFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4v QWNjZXNzaWJsZUJhc2UuY3BwCShyZXZpc2lvbiAzNTE5OCkKKysrIFdlYktpdC93aW4vQWNjZXNz aWJsZUJhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMDIsNiArMTAyLDE3IEBAIEhSRVNVTFQg U1RETUVUSE9EQ0FMTFRZUEUgQWNjZXNzaWJsZUJhc2UKICAgICBpZiAoIW1fb2JqZWN0KQogICAg ICAgICByZXR1cm4gRV9GQUlMOwogCisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogcGFyZW50T2Jq ID0gbV9vYmplY3QtPnBhcmVudE9iamVjdCgpOworICAgIAorICAgIGZvcihwYXJlbnRPYmogPSBt X29iamVjdC0+cGFyZW50T2JqZWN0KCkgOyBwYXJlbnRPYmogJiYgcGFyZW50T2JqLT5hY2Nlc3Np YmlsaXR5SXNJZ25vcmVkKCk7IHBhcmVudE9iaiA9IHBhcmVudE9iai0+cGFyZW50T2JqZWN0KCkp IHsgfSAgCisKKyAgICBpZiAocGFyZW50T2JqKSAgeworICAgICAgICAqcGFyZW50ID0gc3RhdGlj X2Nhc3Q8SURpc3BhdGNoKj4od3JhcHBlcihwYXJlbnRPYmopKTsKKyAgICAgICAgKCpwYXJlbnQp LT5BZGRSZWYoKTsKKyAgICAgICAgcmV0dXJuIFNfT0s7CisgICAgfQorCisJCiAgICAgcmV0dXJu IFdlYlZpZXc6OkFjY2Vzc2libGVPYmplY3RGcm9tV2luZG93KG1fb2JqZWN0LT50b3BEb2N1bWVu dEZyYW1lVmlldygpLT5jb250YWluaW5nV2luZG93KCksCiAgICAgICAgIE9CSklEX1dJTkRPVywg X191dWlkb2YoSUFjY2Vzc2libGUpLCByZWludGVycHJldF9jYXN0PHZvaWQqKj4ocGFyZW50KSk7 CiB9CkBAIC00MjQsOSArNDM1LDkgQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBBY2Nlc3Np YmxlQmFzZQogICAgICAgICAgICAgICAgIHJldHVybiBFX0ZBSUw7CiAKICAgICAgICAgICAgIGlm IChkaXJlY3Rpb24gPT0gTkFWRElSX0ZJUlNUQ0hJTEQpCi0gICAgICAgICAgICAgICAgY2hpbGRP YmogPSBtX29iamVjdC0+Zmlyc3RDaGlsZCgpOworICAgICAgICAgICAgICAgIGNoaWxkT2JqID0g bV9vYmplY3QtPmFjY0ZpcnN0Q2hpbGQoKTsKICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAg ICAgICBjaGlsZE9iaiA9IG1fb2JqZWN0LT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgICAgICAgICBj aGlsZE9iaiA9IG1fb2JqZWN0LT5hY2NMYXN0Q2hpbGQoKTsKICAgICAgICAgICAgIGJyZWFrOwog ICAgICAgICBjYXNlIE5BVkRJUl9ORVhUOgogICAgICAgICBjYXNlIE5BVkRJUl9QUkVWSU9VUzog ewpAQCAtNDM2LDkgKzQ0Nyw5IEBAIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgQWNjZXNzaWJs ZUJhc2UKICAgICAgICAgICAgICAgICByZXR1cm4gaHI7CiAKICAgICAgICAgICAgIGlmIChkaXJl Y3Rpb24gPT0gTkFWRElSX05FWFQpCi0gICAgICAgICAgICAgICAgY2hpbGRPYmogPSBjaGlsZE9i ai0+bmV4dFNpYmxpbmcoKTsKKyAgICAgICAgICAgICAgICBjaGlsZE9iaiA9IGNoaWxkT2JqLT5u ZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmcoKTsKICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAg ICAgICBjaGlsZE9iaiA9IGNoaWxkT2JqLT5wcmV2aW91c1NpYmxpbmcoKTsKKyAgICAgICAgICAg ICAgICBjaGlsZE9iaiA9IGNoaWxkT2JqLT5wcmV2aW91c0FjY2Vzc2liaWxpdHlTaWJsaW5nKCk7 CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogICAgICAgICBkZWZhdWx0OgpAQCAtNTYz LDYgKzU3NCwxNCBAQCBzdGF0aWMgbG9uZyBNU0FBUm9sZShBY2Nlc3NpYmlsaXR5Um9sZSByCiAg ICAgICAgIGNhc2UgV2ViQ29yZTo6SW1hZ2VNYXBSb2xlOgogICAgICAgICBjYXNlIFdlYkNvcmU6 OkltYWdlUm9sZToKICAgICAgICAgICAgIHJldHVybiBST0xFX1NZU1RFTV9HUkFQSElDOworICAg ICAgICBjYXNlIFdlYkNvcmU6OkRvY3VtZW50Um9sZToKKyAgICAgICAgICByZXR1cm4gUk9MRV9T WVNURU1fRE9DVU1FTlQ7CisgICAgICAgIGNhc2UgV2ViQ29yZTo6Q2VsbFJvbGU6CisgICAgICAg ICAgcmV0dXJuIFJPTEVfU1lTVEVNX0NFTEw7CisgICAgICAgIGNhc2UgV2ViQ29yZTo6TGlzdEl0 ZW1Sb2xlOgorICAgICAgICAgIHJldHVybiBST0xFX1NZU1RFTV9MSVNUSVRFTTsKKyAgICAgICAg Y2FzZSBXZWJDb3JlOjpTZXBhcmF0b3JSb2xlOgorICAgICAgICAgIHJldHVybiBST0xFX1NZU1RF TV9TRVBBUkFUT1I7CiAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAvLyBUaGlzIGlzIHRo ZSBkZWZhdWx0IHJvbGUgZm9yIE1TQUEuCiAgICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1f Q0xJRU5UOwpJbmRleDogV2ViS2l0L3dpbi9XZWJLaXQudmNwcm9qL2J1aWxkLWdlbmVyYXRlZC1m aWxlcy5zaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYktpdC52Y3Byb2ovYnVpbGQtZ2Vu ZXJhdGVkLWZpbGVzLnNoCShyZXZpc2lvbiAzNTE5OCkKKysrIFdlYktpdC93aW4vV2ViS2l0LnZj cHJvai9idWlsZC1nZW5lcmF0ZWQtZmlsZXMuc2gJKHdvcmtpbmcgY29weSkKQEAgLTYwLDMgKzYw LDQgQEAgZXhwb3J0IFdFQktJVF9PVVRQVVQ9JFhEU1RST09UCiAKIGV4cG9ydCBGRUFUVVJFX0RF RklORVM9IkVOQUJMRV9YUEFUSCBFTkFCTEVfU1ZHIgogbWFrZSAtZiAiJFdFQktJVC9XZWJLaXQu dmNwcm9qL0Rlcml2ZWRTb3VyY2VzLm1ha2UiIC1qICR7TlVNQ1BVU30gfHwgZXhpdCAxCisK 22444 2008-07-22 21:23:57 -0700 2008-07-23 16:59:57 -0700 This is the latest patch after I have done all the changes as per code review comments. MyExcellentPatch.txt text/plain 24524 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTI4MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDQgQEAKKzIwMDgtMDctMjEgIFUtc3Rhbmd1dHVyaVxTYW5rYXIgVGFuZ3V0dXJp ICA8c2V0IEVNQUlMX0FERFJFU1MgZW52aXJvbm1lbnQgdmFyaWFibGU+CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNF UyBBRERFRCBPUiBDSEFOR0VECisKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlPYmplY3Qu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNUZXh0Rm9ybWF0 dGluZ0VsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNM aW5rT3JMaXN0SXRlbUVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9i amVjdDo6aXNGb3JtT3JUYWJsZUVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJp bGl0eU9iamVjdDo6YWNjRmlyc3RDaGlsZCk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmls aXR5T2JqZWN0OjphY2NMYXN0Q2hpbGQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0 eU9iamVjdDo6cHJldmlvdXNBY2Nlc3NpYmlsaXR5U2libGluZyk6CisgICAgICAgIChXZWJDb3Jl OjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmcpOgorICAgICAg ICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6c2V0QWNjZXNzaWJpbGl0eUlEKToKKyAg ICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OnNldEFjY2Vzc2libGVQYXJlbnQp OgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4pOgor ICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6 KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmFjY2Vzc2liaWxpdHlJ RCk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphY2Nlc3NpYmxlUGFy ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmNoaWxkcmVuKToK KyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Y3JlYXRlVGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKToKKyAgICAgICAg KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFjY0ZpcnN0Q2hpbGQpOgorICAg ICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWNjTGFzdENoaWxkKToK KyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnByZXZpb3VzQWNj ZXNzaWJpbGl0eVNpYmxpbmcpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdDo6bmV4dEFjY2Vzc2liaWxpdHlTaWJsaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzVGV4dEZvcm1hdHRpbmdFbGVtZW50KToKKyAgICAg ICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzRm9ybU9yVGFibGVFbGVt ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlu a09yTGlzdEl0ZW1FbGVtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmhlbHBUZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnRpdGxlKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmVsZW1lbnRSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmFjY2Vzc2liaWxpdHlJc0lnbm9yZWQpOgorICAgICAgICAoV2ViQ29yZTo6QWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cm9sZVZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OkFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNhblNldEZvY3VzQXR0cmlidXRlKToKKyAgICAgICAg KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuKToKKyAgICAgICAg KFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkcmVuKToKKyAgICAg ICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKwogMjAwOC0wNy0yMSAgS2V2 aW4gQ2FsaG91biAgPGtjYWxob3VuQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBB ZGVsZS4KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAJKHJldmlzaW9uIDM1 MTk4KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC05NDYsNiArOTQ2LDUxIEBAIEFjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxp dHlPYmplY3QKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojpp c1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQor Citib29sIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50KCkgY29u c3QKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgQWNjZXNzaWJpbGl0eU9iamVjdDo6 aXNGb3JtT3JUYWJsZUVsZW1lbnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKwor QWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0eU9iamVjdDo6Zmlyc3RBY2Nlc3NpYmls aXR5Q2hpbGQoKSBjb25zdAoreworICAgIHJldHVybiAwOworfQorCitBY2Nlc3NpYmlsaXR5T2Jq ZWN0KiBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpsYXN0QWNjZXNzaWJpbGl0eUNoaWxkKCkgY29uc3QK K3sKKyAgICByZXR1cm4gMDsKK30KKworQWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0 eU9iamVjdDo6cHJldmlvdXNBY2Nlc3NpYmlsaXR5U2libGluZygpIGNvbnN0Cit7CisgICAgcmV0 dXJuIDA7Cit9CisKK0FjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlPYmplY3Q6Om5l eHRBY2Nlc3NpYmlsaXR5U2libGluZygpIGNvbnN0Cit7CisgICAgcmV0dXJuIDA7Cit9CisKK3Zv aWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6c2V0SW5kZXhJblBhcmVudCh1bnNpZ25lZCBpbmRleElu UGFyZW50KQoreworICAgIG1faW5kZXhJblBhcmVudCA9IGluZGV4SW5QYXJlbnQ7Cit9CisKK3Zv aWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6c2V0QWNjZXNzaWJsZVBhcmVudChjb25zdCBBY2Nlc3Np YmlsaXR5T2JqZWN0KiBhY2Nlc3NpYmxlUGFyZW50KQoreworICAgIG1fYWNjZXNzaWJsZVBhcmVu dCA9IGFjY2Vzc2libGVQYXJlbnQ7Cit9CisKIEFjY2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxp dHlPYmplY3Q6OnJvbGVWYWx1ZSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIFVua25vd25Sb2xlOwpA QCAtOTc3LDcgKzEwMjIsNyBAQCB2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmNoaWxkcmVuQ2hh bmdlCiAgICAgcmV0dXJuOwogfQogCi12b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxk cmVuKCkKK3ZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4oKSBjb25zdAogewog fQogCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHJldmlzaW9uIDM1MTk4KQor KysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAt MTQ0LDcgKzE0NCwxMSBAQCBlbnVtIEFjY2Vzc2liaWxpdHlSb2xlIHsKICAgICBXZWJBcmVhUm9s ZSwKICAgICBIZWFkaW5nUm9sZSwKICAgICBMaXN0Qm94Um9sZSwKLSAgICBMaXN0Qm94T3B0aW9u Um9sZQorICAgIExpc3RCb3hPcHRpb25Sb2xlLAorICAgIExpc3RJdGVtUm9sZSwKKyAgICBEb2N1 bWVudFJvbGUsCisgICAgQ2VsbFJvbGUsCisgICAgU2VwYXJhdG9yUm9sZQogfTsKIAogc3RydWN0 IFZpc2libGVQb3NpdGlvblJhbmdlIHsKQEAgLTI2Miw3ICsyNjYsMjMgQEAgcHVibGljOgogCiAg ICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdDsKICAgICB2aXJ0 dWFsIEFYT2JqZWN0Q2FjaGUqIGF4T2JqZWN0Q2FjaGUoKSBjb25zdDsKLSAgICAKKworCXZpcnR1 YWwgYm9vbCBpc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9v bCBpc0xpbmtPckxpc3RJdGVtRWxlbWVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc0Zv cm1PclRhYmxlRWxlbWVudCgpIGNvbnN0OworCisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2Jq ZWN0KiBmaXJzdEFjY2Vzc2liaWxpdHlDaGlsZCgpIGNvbnN0IDsKKyAgICB2aXJ0dWFsIEFjY2Vz c2liaWxpdHlPYmplY3QqIGxhc3RBY2Nlc3NpYmlsaXR5Q2hpbGQoKSBjb25zdCA7CisKKyAgICB2 aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3QqIHByZXZpb3VzQWNjZXNzaWJpbGl0eVNpYmxpbmco KSBjb25zdCA7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBuZXh0QWNjZXNzaWJp bGl0eVNpYmxpbmcoKSBjb25zdCA7CisKKyAgICB1bnNpZ25lZCBpbmRleEluUGFyZW50KCkgeyBy ZXR1cm4gbV9pbmRleEluUGFyZW50IDsgfQorICAgIHZvaWQgc2V0SW5kZXhJblBhcmVudCh1bnNp Z25lZCk7CisKKyAgICBjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2Nlc3NpYmxlUGFyZW50 KCkgeyAgcmV0dXJuIG1fYWNjZXNzaWJsZVBhcmVudCA7fQorICAgIHZvaWQgc2V0QWNjZXNzaWJs ZVBhcmVudChjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiApOworCiAgICAgdmlydHVhbCBIVE1M QW5jaG9yRWxlbWVudCogYW5jaG9yRWxlbWVudCgpIGNvbnN0OwogICAgIHZpcnR1YWwgRWxlbWVu dCogYWN0aW9uRWxlbWVudCgpIGNvbnN0OwogICAgIHZpcnR1YWwgSW50UmVjdCBib3VuZGluZ0Jv eFJlY3QoKSBjb25zdDsKQEAgLTMwOSw4ICszMjksOCBAQCBwdWJsaWM6CiAgICAgYm9vbCBwZXJm b3JtRGVmYXVsdEFjdGlvbigpIGNvbnN0IHsgcmV0dXJuIHByZXNzKCk7IH0KICAgICAKICAgICB2 aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCBjb25zdCBBY2Nlc3Np YmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgeyByZXR1cm4gbV9jaGlsZHJlbjsgfQot ICAgIHZpcnR1YWwgdm9pZCBhZGRDaGlsZHJlbigpOworICAgIHZpcnR1YWwgY29uc3QgQWNjZXNz aWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbigpIGNvbnN0IHsgcmV0dXJuIG1fY2hpbGRy ZW47IH0KKyAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKSBjb25zdDsKICAgICB2aXJ0dWFs IGJvb2wgaGFzQ2hpbGRyZW4oKSBjb25zdCB7IHJldHVybiBtX2hhdmVDaGlsZHJlbjsgfTsKICAg ICB2aXJ0dWFsIHZvaWQgc2VsZWN0ZWRDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgdmlzaWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGls ZHJlblZlY3RvciYpOwpAQCAtMzgyLDkgKzQwMiwxMiBAQCBwdWJsaWM6CiAKIHByb3RlY3RlZDoK ICAgICB1bnNpZ25lZCBtX2lkOwotICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2No aWxkcmVuOworICAgIG11dGFibGUgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIG1fY2hpbGRy ZW47CiAgICAgbXV0YWJsZSBib29sIG1faGF2ZUNoaWxkcmVuOwotICAgIAorCisgICAgdW5zaWdu ZWQgbV9pbmRleEluUGFyZW50OworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3QqIG1fYWNj ZXNzaWJsZVBhcmVudDsKKwogICAgIHZpcnR1YWwgdm9pZCBjbGVhckNoaWxkcmVuKCk7CiAgICAg dmlydHVhbCB2b2lkIHJlbW92ZUFYT2JqZWN0SUQoKTsKICAgICB2aXJ0dWFsIGJvb2wgaXNEZXRh Y2hlZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDM1MTk4KQorKysgV2ViQ29yZS9wYWdl L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMDksNiAr MTA5LDU1IEBAIHZvaWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6ZGV0YWNoKCkKICAgICBt X3JlbmRlcmVyID0gMDsgICAgCiB9CiAKK3N0YXRpYyBIYXNoU2V0PFN0cmluZywgQ2FzZUZvbGRp bmdIYXNoPiogY3JlYXRlVGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKCkgCit7CisgICAg c3RhdGljIEhhc2hTZXQ8U3RyaW5nLCBDYXNlRm9sZGluZ0hhc2g+IGVsZW1lbnRIYXNoU2V0Owor CisgICAgaWYgKGVsZW1lbnRIYXNoU2V0LmlzRW1wdHkoKSkgeworICAgICAgICBlbGVtZW50SGFz aFNldC5hZGQoYlRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGJU YWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChiZG9UYWcudG9TdHJp bmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChiaWdUYWcudG9TdHJpbmcoKSk7Cisg ICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChjaXRlVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBl bGVtZW50SGFzaFNldC5hZGQoZGZuVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFz aFNldC5hZGQoZGVsVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQo aW5zVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoZW1UYWcudG9T dHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChmb250VGFnLnRvU3RyaW5nKCkp OworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoaVRhZy50b1N0cmluZygpKTsKKyAgICAgICAg ZWxlbWVudEhhc2hTZXQuYWRkKHNUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNo U2V0LmFkZChzYW1wVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQo c3BhblRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHN0cmlrZVRh Zy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHN0cm9uZ1RhZy50b1N0 cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHN1YlRhZy50b1N0cmluZygpKTsK KyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHN1cFRhZy50b1N0cmluZygpKTsKKyAgICAgICAg ZWxlbWVudEhhc2hTZXQuYWRkKHRleHRhcmVhVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVt ZW50SGFzaFNldC5hZGQodHRUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0 LmFkZCh1VGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQocHJlVGFn LnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoZGl2VGFnLnRvU3RyaW5n KCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoY2VudGVyVGFnLnRvU3RyaW5nKCkpOwor CQllbGVtZW50SGFzaFNldC5hZGQocFRhZy50b1N0cmluZygpKTsKKyAgICB9CisgICAgcmV0dXJu ICZlbGVtZW50SGFzaFNldDsKK30KKworc3RhdGljIEhhc2hTZXQ8U3RyaW5nLCBDYXNlRm9sZGlu Z0hhc2g+KiBjcmVhdGVMaW5rQW5kTGlzdEVsZW1lbnRzSGFzaCgpIAoreworICAgIHN0YXRpYyBI YXNoU2V0PFN0cmluZywgQ2FzZUZvbGRpbmdIYXNoPiBlbGVtZW50SGFzaFNldDsKKworICAgIGlm IChlbGVtZW50SGFzaFNldC5pc0VtcHR5KCkpIHsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRk KGFiYnJUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChhY3Jvbnlt VGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQocVRhZy50b1N0cmlu ZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGxpVGFnLnRvU3RyaW5nKCkpOworICAg ICAgICBlbGVtZW50SGFzaFNldC5hZGQoZGRUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1l bnRIYXNoU2V0LmFkZChkdFRhZy50b1N0cmluZygpKTsJCQorICAgIH0KKyAgICByZXR1cm4gJmVs ZW1lbnRIYXNoU2V0OworfQorCiBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0OjpmaXJzdENoaWxkKCkgY29uc3QKIHsKICAgICBpZiAoIW1fcmVuZGVyZXIpCkBA IC0xNTcsNiArMjA2LDQyIEBAIEFjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlSZW5k ZXIKICAgICByZXR1cm4gbV9yZW5kZXJlci0+ZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5n ZXQobmV4dFNpYmxpbmcpOwogfQogCitBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjpmaXJzdEFjY2Vzc2liaWxpdHlDaGlsZCgpIGNvbnN0Cit7CisgICAgaWYg KG1fY2hpbGRyZW4uaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJldHVybiBt X2NoaWxkcmVuLmZpcnN0KCkuZ2V0KCk7Cit9CisKK0FjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3Q6Omxhc3RBY2Nlc3NpYmlsaXR5Q2hpbGQoKSBjb25zdAorewor ICAgIGlmIChtX2NoaWxkcmVuLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBy ZXR1cm4gbV9jaGlsZHJlbi5sYXN0KCkuZ2V0KCk7Cit9CisKK0FjY2Vzc2liaWxpdHlPYmplY3Qq IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnByZXZpb3VzQWNjZXNzaWJpbGl0eVNpYmxpbmco KSBjb25zdAoreworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgc2libGlu Z3NWZWN0b3IgPSBtX2FjY2Vzc2libGVQYXJlbnQtPmNoaWxkcmVuKCk7CisKKyAgICBpZiAobV9p bmRleEluUGFyZW50ID09IDApCisgICAgICAgIHJldHVybiAwOworCisgICAgcmV0dXJuIHNpYmxp bmdzVmVjdG9yW21faW5kZXhJblBhcmVudCAtIDFdLmdldCgpOworfQorCitBY2Nlc3NpYmlsaXR5 T2JqZWN0KiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNpYmxp bmcoKSBjb25zdAoreworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgc2li bGluZ3NWZWN0b3IgPSBtX2FjY2Vzc2libGVQYXJlbnQtPmNoaWxkcmVuKCk7CisKKyAgICBpZiAo bV9pbmRleEluUGFyZW50ICsgMSA9PSBzaWJsaW5nc1ZlY3Rvci5zaXplKCkpCisgICAgICAgIHJl dHVybiAwOworCisgICAgcmV0dXJuIHNpYmxpbmdzVmVjdG9yW21faW5kZXhJblBhcmVudCArIDFd LmdldCgpOworfQorCiBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0OjpwYXJlbnRPYmplY3QoKSBjb25zdAogewogICAgIGlmICghbV9yZW5kZXJlcikKQEAgLTQw Myw3ICs0ODgsNDUgQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc0hlYWRpbgog ewogICAgIHJldHVybiByb2xlVmFsdWUoKSA9PSBIZWFkaW5nUm9sZTsKIH0KKworYm9vbCBBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0Cit7 CisgICAgSGFzaFNldDxTdHJpbmcsIENhc2VGb2xkaW5nSGFzaD4qIHRleHRGb3JtYXR0aW5nRWxl bWVudE5hbWVzID0gY3JlYXRlVGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKCk7CiAgICAg CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV9yZW5kZXJlci0+ZWxlbWVudCgpKQorICAgICAgICBy ZXR1cm4gdGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXMtPmNvbnRhaW5zKG1fcmVuZGVyZXItPmVs ZW1lbnQoKS0+bm9kZU5hbWUoKSk7CisKKyAgICByZXR1cm4gZmFsc2U7CisgICAgCit9CisKK2Jv b2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6aXNGb3JtT3JUYWJsZUVsZW1lbnQoKSBjb25z dAoreworICAgIGlmICghbV9yZW5kZXJlciB8fCAhbV9yZW5kZXJlci0+ZWxlbWVudCgpKQorICAg ICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxlbWVudCgpLT5oYXNU YWdOYW1lKGZvcm1UYWcpCisgICAgfHwgIG1fcmVuZGVyZXItPmVsZW1lbnQoKS0+aGFzVGFnTmFt ZSh0YWJsZVRhZykKKyAgICB8fCAgbV9yZW5kZXJlci0+ZWxlbWVudCgpLT5oYXNUYWdOYW1lKHRk VGFnKQorICAgIHx8ICBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUodGhUYWcpKQor ICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVybiBmYWxzZTsKKworfQorCitib29sIEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50KCkgY29uc3QK K3sKKyAgICBIYXNoU2V0PFN0cmluZywgQ2FzZUZvbGRpbmdIYXNoPiogZWxlbWVudEhhc2hTZXQg PSBjcmVhdGVMaW5rQW5kTGlzdEVsZW1lbnRzSGFzaCgpOworCisgICAgaWYgKG1fcmVuZGVyZXIg JiYgbV9yZW5kZXJlci0+ZWxlbWVudCgpKQorICAgICAgICByZXR1cm4gbV9yZW5kZXJlci0+ZWxl bWVudCgpLT5pc0xpbmsoKSAKKyAgICAgICAgICAgIHx8IGVsZW1lbnRIYXNoU2V0LT5jb250YWlu cyhtX3JlbmRlcmVyLT5lbGVtZW50KCktPm5vZGVOYW1lKCkpOworCisgICAgICAgIHJldHVybiBm YWxzZTsKKworfQorCiBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGluaygpIGNv bnN0CiB7CiAgICAgcmV0dXJuIHJvbGVWYWx1ZSgpID09IFdlYkNvcmVMaW5rUm9sZTsKQEAgLTgz MCwxNyArOTUzLDQwIEBAIFN0cmluZyBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0aXRsZSgK ICAgICAgICAgaWYgKGxhYmVsKQogICAgICAgICAgICAgcmV0dXJuIGxhYmVsLT5pbm5lclRleHQo KTsKICAgICB9Ci0gICAgCisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxlbWVudCgpLT5pc0xpbmso KSB8fCBpc0hlYWRpbmcoKSkgeworICAgICAgICBjb25zdCBWZWN0b3I8IFJlZlB0cjxBY2Nlc3Np YmlsaXR5T2JqZWN0PiA+JiBjaGlsZHJlblZlY3RvciA9IGNoaWxkcmVuKCk7CisgICAgICAgIFZl Y3RvcjxVQ2hhcj4gZWxlbWVudFRleHQ7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkg PCBjaGlsZHJlblZlY3Rvci5zaXplKCk7ICsraSkgeworICAgICAgICAgICAgZWxlbWVudFRleHQu YXBwZW5kKCcgJyk7CisgICAgICAgICAgICBTdHJpbmcgZWxlbWVudFRpdGxlID0gY2hpbGRyZW5W ZWN0b3JbaV0tPnRpdGxlKCk7CisgICAgICAgICAgICBhcHBlbmQoZWxlbWVudFRleHQsIGVsZW1l bnRUaXRsZSk7CisgICAgICAgIH0KKworICAgICAgICByZXR1cm4gU3RyaW5nOjphZG9wdChlbGVt ZW50VGV4dCkuc3RyaXBXaGl0ZVNwYWNlKCk7CisgICAgICAgIAorICAgIH0KKwogICAgIGlmIChy b2xlVmFsdWUoKSA9PSBCdXR0b25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09IExpc3RCb3hP cHRpb25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09IE1lbnVJdGVtUm9sZQotICAgICAgICB8 fCBhcmlhUm9sZSA9PSBNZW51QnV0dG9uUm9sZQotICAgICAgICB8fCBpc0hlYWRpbmcoKSkKKyAg ICAgICAgfHwgYXJpYVJvbGUgPT0gTWVudUJ1dHRvblJvbGUpICAgICAgICAKICAgICAgICAgcmV0 dXJuIHRleHRVbmRlckVsZW1lbnQoKTsKLSAgICAKLSAgICBpZiAoaXNMaW5rKCkpCisKKyAgICBp ZiAoaXNJbWFnZSgpKSB7CisgICAgICAgIE5vZGUqIG5vZGUgPSBtX3JlbmRlcmVyLT5lbGVtZW50 KCk7CisgICAgICAgIGlmIChub2RlICYmIG5vZGUtPmlzRWxlbWVudE5vZGUoKSkgeworICAgICAg ICAgICAgRWxlbWVudCogZWx0ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG5vZGUpOworICAgICAg ICAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBhbHQgPSBlbHQtPmdldEF0dHJpYnV0ZShhbHRBdHRy KTsKKyAgICAgICAgICAgIGlmICghYWx0LmlzTnVsbCgpKQorICAgICAgICAgICAgICAgIHJldHVy biBhbHQuc3RyaW5nKCk7CisgICAgICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisgICAgICAgIH0K KyAgICB9CisKKyAgICBpZiAobV9yZW5kZXJlci0+aXNUZXh0KCkpCiAgICAgICAgIHJldHVybiB0 ZXh0VW5kZXJFbGVtZW50KCk7Ci0gICAgCisKICAgICByZXR1cm4gU3RyaW5nKCk7CiB9CiAKQEAg LTkzMSw3ICsxMDc3LDcgQEAgSW50UmVjdCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGVj awogfQogCiBJbnRSZWN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmVsZW1lbnRSZWN0KCkg Y29uc3QKLXsKK3sgCiAgICAgLy8gYSBjaGVja2JveCBvciByYWRpbyBidXR0b24gc2hvdWxkIGVu Y29tcGFzcyBpdHMgbGFiZWwKICAgICBpZiAoaXNDaGVja2JveE9yUmFkaW8oKSkKICAgICAgICAg cmV0dXJuIGNoZWNrYm94T3JSYWRpb1JlY3QoKTsKQEAgLTEwNzcsMjQgKzEyMjMsNDggQEAgYm9v bCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphY2Nlc3NpYgogICAgIEFjY2Vzc2liaWxpdHlS b2xlIGFyaWFSb2xlID0gYXJpYVJvbGVBdHRyaWJ1dGUoKTsKICAgICBpZiAoYXJpYVJvbGUgPT0g VGV4dEFyZWFSb2xlIHx8IGFyaWFSb2xlID09IFN0YXRpY1RleHRSb2xlKSB7CiAgICAgICAgIFN0 cmluZyBhcmlhVGV4dCA9IHRleHQoKTsKLSAgICAgICAgcmV0dXJuIGFyaWFUZXh0LmlzTnVsbCgp IHx8IGFyaWFUZXh0LmlzRW1wdHkoKTsKKyAgICAgICAgcmV0dXJuIGFyaWFUZXh0LmlzTnVsbCgp IHx8IGFyaWFUZXh0LmlzRW1wdHkoKSB8fCAhYXJpYVRleHQuc3RyaXBXaGl0ZVNwYWNlKCkubGVu Z3RoKCk7CiAgICAgfSAgICAKICAgICAKLSAgICAvLyBOT1RFOiBCUnMgYWx3YXlzIGhhdmUgdGV4 dCBib3hlcyBub3csIHNvIHRoZSB0ZXh0IGJveCBjaGVjayBoZXJlIGNhbiBiZSByZW1vdmVkCisK ICAgICBpZiAobV9yZW5kZXJlci0+aXNUZXh0KCkpIHsKICAgICAgICAgLy8gc3RhdGljIHRleHQg YmVuZWF0aCBNZW51SXRlbXMgYW5kIE1lbnVCdXR0b25zIGFyZSBqdXN0IHJlcG9ydGVkIGFsb25n IHdpdGggdGhlIG1lbnUgaXRlbSwgc28gaXQncyBpZ25vcmVkIG9uIGFuIGluZGl2aWR1YWwgbGV2 ZWwKLSAgICAgICAgaWYgKHBhcmVudE9iamVjdFVuaWdub3JlZCgpLT5hcmlhUm9sZUF0dHJpYnV0 ZSgpID09IE1lbnVJdGVtUm9sZSB8fAotICAgICAgICAgICAgcGFyZW50T2JqZWN0VW5pZ25vcmVk KCktPmFyaWFSb2xlQXR0cmlidXRlKCkgPT0gTWVudUJ1dHRvblJvbGUpCisgICAgICAgIGlmICh0 ZXh0VW5kZXJFbGVtZW50KCkuc3RyaXBXaGl0ZVNwYWNlKCkubGVuZ3RoKCkgIT0gMCkgIHsKKyAg ICAgICAgICAgIGlmIChwYXJlbnRPYmplY3RVbmlnbm9yZWQoKS0+YXJpYVJvbGVBdHRyaWJ1dGUo KSA9PSBNZW51SXRlbVJvbGUKKyAgICAgICAgICAgICAgICB8fCBwYXJlbnRPYmplY3RVbmlnbm9y ZWQoKS0+YXJpYVJvbGVBdHRyaWJ1dGUoKSA9PSBNZW51QnV0dG9uUm9sZSkKKyAgICAgICAgICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKLSAg ICAgICAgIHJldHVybiBtX3JlbmRlcmVyLT5pc0JSKCkgfHwgIXN0YXRpY19jYXN0PFJlbmRlclRl eHQqPihtX3JlbmRlcmVyKS0+Zmlyc3RUZXh0Qm94KCk7CisgICAgICAgIH0KICAgICB9CiAgICAg CiAgICAgaWYgKGlzSGVhZGluZygpKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgCi0gICAg aWYgKGlzTGluaygpKQorCisgICAgaWYgKGlzVGV4dEZvcm1hdHRpbmdFbGVtZW50KCkpCisgICAg ICAgIHJldHVybiB0cnVlOworCisgICAgaWYgKGlzTGlzdEVsZW1lbnQobV9yZW5kZXJlci0+ZWxl bWVudCgpKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIAorCisgICAgaWYgKGlzRm9ybU9y VGFibGVFbGVtZW50KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChpc0xpbmtP ckxpc3RJdGVtRWxlbWVudCgpKSB7CisgICAgICAgIGlmIChjaGlsZHJlbigpLnNpemUoKSA9PSAw KQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKKyAgICB9CisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxlbWVudCgpICYmIG1f cmVuZGVyZXItPmVsZW1lbnQoKS0+aGFzVGFnTmFtZShodG1sVGFnKSkKKyAgICAgICAgcmV0dXJu IHRydWU7CisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxlbWVudCgpICYmIG1fcmVuZGVyZXItPmVs ZW1lbnQoKS0+aGFzVGFnTmFtZShib2R5VGFnKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKICAg ICAvLyBhbGwgY29udHJvbHMgYXJlIGFjY2Vzc2libGUKICAgICBpZiAoaXNDb250cm9sKCkpCiAg ICAgICAgIHJldHVybiBmYWxzZTsKQEAgLTExMDQsOCArMTI3NCwxNCBAQCBib29sIEFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OmFjY2Vzc2liCiAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFn TmFtZShsYWJlbFRhZykpCiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICAKLSAgICBpZiAobV9y ZW5kZXJlci0+aXNCbG9ja0Zsb3coKSAmJiBtX3JlbmRlcmVyLT5jaGlsZHJlbklubGluZSgpKQot ICAgICAgICByZXR1cm4gIXN0YXRpY19jYXN0PFJlbmRlckJsb2NrKj4obV9yZW5kZXJlciktPmZp cnN0TGluZUJveCgpICYmICFtb3VzZUJ1dHRvbkxpc3RlbmVyKCk7CisgICAgaWYgKG1fcmVuZGVy ZXItPmlzQmxvY2tGbG93KCkpIHsKKyAgICAgICAgaWYgKG1fcmVuZGVyZXItPmlzQW5vbnltb3Vz QmxvY2soKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICByZXR1cm4gZmFsc2U7 CisgICAgfQorCisgICAgaWYgKG1fcmVuZGVyZXItPmlzSW5saW5lRmxvdygpKQorICAgICAgICBy ZXR1cm4gdHJ1ZTsKICAgICAKICAgICAvLyBpZ25vcmUgaW1hZ2VzIHNlZW1pbmdseSB1c2VkIGFz IHNwYWNlcnMKICAgICBpZiAoaXNJbWFnZSgpKSB7CkBAIC0xOTk4LDE2ICsyMTc0LDI5IEBAIEFj Y2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmoKICAgICAgICAgcmV0dXJuIGFy aWFSb2xlOwogICAgIAogICAgIGlmIChub2RlICYmIG5vZGUtPmlzTGluaygpKSB7Ci0gICAgICAg IGlmIChtX3JlbmRlcmVyLT5pc0ltYWdlKCkpCisgICAgICAgIGlmIChpc05hdGl2ZUltYWdlKCkp CiAgICAgICAgICAgICByZXR1cm4gSW1hZ2VNYXBSb2xlOwogICAgICAgICByZXR1cm4gV2ViQ29y ZUxpbmtSb2xlOwogICAgIH0KKworICAgIGlmIChub2RlICYmIG5vZGUtPmlzRG9jdW1lbnROb2Rl KCkpCisgICAgICAgIHJldHVybiBEb2N1bWVudFJvbGU7CisKKyAgICBpZiAobm9kZSAmJiBub2Rl LT5oYXNUYWdOYW1lKHRhYmxlVGFnKSkKKyAgICAgICAgcmV0dXJuIFRhYmxlUm9sZTsKKworICAg IGlmIChub2RlICYmIChub2RlLT5oYXNUYWdOYW1lKHRkVGFnKSB8fCBub2RlLT5oYXNUYWdOYW1l KHRoVGFnKSkpCisgICAgICAgIHJldHVybiBDZWxsUm9sZTsKKwogICAgIGlmIChtX3JlbmRlcmVy LT5pc0xpc3RNYXJrZXIoKSkKICAgICAgICAgcmV0dXJuIExpc3RNYXJrZXJSb2xlOworCiAgICAg aWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShidXR0b25UYWcpKQogICAgICAgICByZXR1cm4g QnV0dG9uUm9sZTsKKwogICAgIGlmIChtX3JlbmRlcmVyLT5pc1RleHQoKSkKICAgICAgICAgcmV0 dXJuIFN0YXRpY1RleHRSb2xlOworCiAgICAgaWYgKG1fcmVuZGVyZXItPmlzSW1hZ2UoKSkgewog ICAgICAgICBpZiAobm9kZSAmJiBub2RlLT5oYXNUYWdOYW1lKGlucHV0VGFnKSkKICAgICAgICAg ICAgIHJldHVybiBCdXR0b25Sb2xlOwpAQCAtMjAzMiw5ICsyMjIxLDYgQEAgQWNjZXNzaWJpbGl0 eVJvbGUgQWNjZXNzaWJpbGl0eVJlbmRlck9iagogICAgICAgICAgICAgcmV0dXJuIEJ1dHRvblJv bGU7CiAgICAgfQogCi0gICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShidXR0b25UYWcp KQotICAgICAgICByZXR1cm4gQnV0dG9uUm9sZTsKLQogICAgIGlmIChpc0ZpbGVVcGxvYWRCdXR0 b24oKSkKICAgICAgICAgcmV0dXJuIEJ1dHRvblJvbGU7CiAgICAgCkBAIC0yMDQ0LDcgKzIyMzAs MTggQEAgQWNjZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0eVJlbmRlck9iagogICAgIGlmICho ZWFkaW5nTGV2ZWwobV9yZW5kZXJlci0+ZWxlbWVudCgpKSAhPSAwKQogICAgICAgICByZXR1cm4g SGVhZGluZ1JvbGU7CiAgICAgCi0gICAgaWYgKG1fcmVuZGVyZXItPmlzQmxvY2tGbG93KCkgfHwg KG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShsYWJlbFRhZykpKQorICAgIGlmKG5vZGUgJiYgbm9k ZS0+aGFzVGFnTmFtZShsaVRhZykpCisgICAgICAgIHJldHVybiBMaXN0SXRlbVJvbGU7CisKKyAg ICBpZihub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUoaHJUYWcpKQorICAgICAgICByZXR1cm4gU2Vw YXJhdG9yUm9sZTsKKworICAgIGlmKG5vZGUgJiYgKG5vZGUtPmhhc1RhZ05hbWUob2xUYWcpIHx8 IG5vZGUtPmhhc1RhZ05hbWUodWxUYWcpIHx8IG5vZGUtPmhhc1RhZ05hbWUoZGxUYWcpKSkKKyAg ICAgICAgcmV0dXJuIExpc3RSb2xlOworCisgICAgaWYgKG1fcmVuZGVyZXItPmlzQmxvY2tGbG93 KCkgfHwgbm9kZS0+aGFzVGFnTmFtZShhYmJyVGFnKQorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHx8IG5vZGUtPmhhc1RhZ05hbWUoYWNyb255bVRhZykgCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfHwgbm9kZS0+aGFzVGFnTmFtZShxVGFnKSkKICAgICAgICAg cmV0dXJuIEdyb3VwUm9sZTsKICAgICAKICAgICByZXR1cm4gVW5rbm93blJvbGU7CkBAIC0yMDkw LDYgKzIyODcsOCBAQCBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNhblNldEZvCiAg ICAgICAgIGNhc2UgUG9wVXBCdXR0b25Sb2xlOgogICAgICAgICBjYXNlIENoZWNrQm94Um9sZToK ICAgICAgICAgY2FzZSBSYWRpb0J1dHRvblJvbGU6CisgICAgICAgIGNhc2UgTGlzdEl0ZW1Sb2xl OgorICAgICAgICBjYXNlIFNlcGFyYXRvclJvbGU6CiAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsK ICAgICAgICAgY2FzZSBVbmtub3duUm9sZToKICAgICAgICAgY2FzZSBTbGlkZXJSb2xlOgpAQCAt MjEzOCw2ICsyMzM3LDggQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjYW5TZXRG bwogICAgICAgICBjYXNlIEhlYWRpbmdSb2xlOgogICAgICAgICBjYXNlIExpc3RCb3hSb2xlOgog ICAgICAgICBjYXNlIExpc3RCb3hPcHRpb25Sb2xlOgorICAgICAgICBjYXNlIERvY3VtZW50Um9s ZToKKyAgICAgICAgY2FzZSBDZWxsUm9sZToKICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKICAg ICB9CiAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CkBAIC0yMTY4LDE5ICsyMzY5LDIxIEBAIHZv aWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4KICAgICB9CiB9CiAKLWNvbnN0 IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4oKQorY29uc3QgQWNjZXNzaWJpbGl0eU9iamVj dDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 OjpjaGlsZHJlbigpIGNvbnN0CiB7CiAgICAgaWYgKCFtX2hhdmVDaGlsZHJlbikKICAgICAgICAg YWRkQ2hpbGRyZW4oKTsKICAgICByZXR1cm4gbV9jaGlsZHJlbjsKIH0KIAotdm9pZCBBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpCit2b2lkIEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QKIHsKICAgICAvLyBJZiB0aGUgbmVlZCB0byBh ZGQgbW9yZSBjaGlsZHJlbiBpbiBhZGRpdGlvbiB0byBleGlzdGluZyBjaGlsZHJlbiBhcmlzZXMs IAogICAgIC8vIGNoaWxkcmVuQ2hhbmdlZCBzaG91bGQgaGF2ZSBiZWVuIGNhbGxlZCwgbGVhdmlu ZyB0aGUgb2JqZWN0IHdpdGggbm8gY2hpbGRyZW4uCiAgICAgQVNTRVJUKCFtX2hhdmVDaGlsZHJl bik7IAotICAgIAorCisgICAgdW5zaWduZWQgY2hpbGRDb3VudGVyID0gMDsKKwogICAgIC8vIG5v dGhpbmcgdG8gYWRkIGlmIHRoZXJlIGlzIG5vIFJlbmRlck9iamVjdAogICAgIGlmICghbV9yZW5k ZXJlcikKICAgICAgICAgcmV0dXJuOwpAQCAtMjE5NCwxMCArMjM5NywxNiBAQCB2b2lkIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkCiAgICAgICAgICAgICAgICAgb2JqLT5hZGRD aGlsZHJlbigpOwogICAgICAgICAgICAgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIGNoaWxk cmVuID0gb2JqLT5jaGlsZHJlbigpOwogICAgICAgICAgICAgdW5zaWduZWQgbGVuZ3RoID0gY2hp bGRyZW4uc2l6ZSgpOwotICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGxlbmd0 aDsgKytpKQorICAgICAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGxlbmd0aDsgKytp KSAgeworICAgICAgICAgICAgICAgIGNoaWxkcmVuW2ldLT5zZXRJbmRleEluUGFyZW50KGNoaWxk Q291bnRlcisrKTsKKyAgICAgICAgICAgICAgICBjaGlsZHJlbltpXS0+c2V0QWNjZXNzaWJsZVBh cmVudCh0aGlzKTsKICAgICAgICAgICAgICAgICBtX2NoaWxkcmVuLmFwcGVuZChjaGlsZHJlbltp XSk7Ci0gICAgICAgIH0gZWxzZQorICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgIHsKKyAg ICAgICAgICAgIG9iai0+c2V0SW5kZXhJblBhcmVudChjaGlsZENvdW50ZXIrKyk7CisgICAgICAg ICAgICBvYmotPnNldEFjY2Vzc2libGVQYXJlbnQodGhpcyk7CiAgICAgICAgICAgICBtX2NoaWxk cmVuLmFwcGVuZChvYmopOworICAgICAgICB9CiAgICAgfQogICAgIAogICAgIC8vIGZvciBhIFJl bmRlckltYWdlLCBhZGQgdGhlIDxhcmVhPiBlbGVtZW50cyBhcyBpbmRpdmlkdWFsIGFjY2Vzc2li aWxpdHkgb2JqZWN0cwpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5oCShyZXZpc2lvbiAzNTE5OCkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTEzMCw3ICsxMzAsMTQgQEAgcHVibGljOgogICAg IHZvaWQgc2V0QXJpYVJvbGUoKTsKICAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlSb2xlIHJvbGVW YWx1ZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgQVhPYmplY3RDYWNoZSogYXhPYmplY3RDYWNoZSgp IGNvbnN0OwotICAgIAorICAgIHZpcnR1YWwgYm9vbCBpc1RleHRGb3JtYXR0aW5nRWxlbWVudCgp IGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc0xpbmtPckxpc3RJdGVtRWxlbWVudCgpIGNvbnN0 OworICAgIHZpcnR1YWwgYm9vbCBpc0Zvcm1PclRhYmxlRWxlbWVudCgpIGNvbnN0OworICAgIHZp cnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogZmlyc3RBY2Nlc3NpYmlsaXR5Q2hpbGQoKSBjb25z dCA7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBsYXN0QWNjZXNzaWJpbGl0eUNo aWxkKCkgY29uc3QgOworICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogcHJldmlvdXNB Y2Nlc3NpYmlsaXR5U2libGluZygpIGNvbnN0IDsKKyAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlP YmplY3QqIG5leHRBY2Nlc3NpYmlsaXR5U2libGluZygpIGNvbnN0IDsKKwogICAgIHZpcnR1YWwg RWxlbWVudCogYWN0aW9uRWxlbWVudCgpIGNvbnN0OwogICAgIEVsZW1lbnQqIG1vdXNlQnV0dG9u TGlzdGVuZXIoKSBjb25zdDsKICAgICBGcmFtZVZpZXcqIGZyYW1lVmlld0lmUmVuZGVyVmlldygp IGNvbnN0OwpAQCAtMTcyLDcgKzE3OSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZ2V0 RG9jdW1lbnRMaW5rcyhBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKSBjb25zdDsKICAgICB2 aXJ0dWFsIEZyYW1lVmlldyogZG9jdW1lbnRGcmFtZVZpZXcoKSBjb25zdDsKICAgICAKLSAgICB2 aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKTsKKyAg ICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKSBj b25zdDsKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgc2V0Rm9jdXNlZChib29sKTsKICAgICB2aXJ0 dWFsIHZvaWQgc2V0U2VsZWN0ZWRUZXh0UmFuZ2UoY29uc3QgUGxhaW5UZXh0UmFuZ2UmKTsKQEAg LTE4MCw3ICsxODcsNyBAQCBwdWJsaWM6CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGRldGFjaCgp OwogICAgIHZpcnR1YWwgdm9pZCBjaGlsZHJlbkNoYW5nZWQoKTsKLSAgICB2aXJ0dWFsIHZvaWQg YWRkQ2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKSBjb25zdDsKICAg ICB2aXJ0dWFsIHZvaWQgc2VsZWN0ZWRDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgdmlzaWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGls ZHJlblZlY3RvciYpOwogICAgIHZpcnR1YWwgYm9vbCBzaG91bGRGb2N1c0FjdGl2ZURlc2NlbmRh bnQoKSBjb25zdDsKSW5kZXg6IFdlYktpdC93aW4vQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YktpdC93aW4vQ2hhbmdlTG9nCShyZXZpc2lvbiAzNTI4MCkKKysrIFdlYktpdC93aW4vQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTMgQEAKKzIwMDgtMDctMjEgIFUtc3Rhbmd1 dHVyaVxTYW5rYXIgVGFuZ3V0dXJpICA8c2V0IEVNQUlMX0FERFJFU1MgZW52aXJvbm1lbnQgdmFy aWFibGU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBBY2Nlc3NpYmxlQmFzZS5jcHA6CisgICAgICAgIChBY2Nlc3NpYmxlQmFzZTo6Z2V0X2FjY1Bh cmVudCk6CisgICAgICAgIChBY2Nlc3NpYmxlQmFzZTo6YWNjTmF2aWdhdGUpOgorICAgICAgICAo TVNBQVJvbGUpOgorICAgICAgICAqIFdlYktpdC52Y3Byb2ovYnVpbGQtZ2VuZXJhdGVkLWZpbGVz LnNoOgorCiAyMDA4LTA3LTE1ICBBZGFtIFJvYmVuICA8YXJvYmVuQGFwcGxlLmNvbT4KIAogICAg ICAgICBBZGQgV2ViS2l0W1NldF1TaG91bGRVc2VGb250U21vb3RoaW5nIGZ1bmN0aW9ucwpJbmRl eDogV2ViS2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dp bi9BY2Nlc3NpYmxlQmFzZS5jcHAJKHJldmlzaW9uIDM1MTk4KQorKysgV2ViS2l0L3dpbi9BY2Nl c3NpYmxlQmFzZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEwMiw2ICsxMDIsMTYgQEAgSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBBY2Nlc3NpYmxlQmFzZQogICAgIGlmICghbV9vYmplY3QpCiAg ICAgICAgIHJldHVybiBFX0ZBSUw7CiAKKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBwYXJlbnRP YmogPSBtX29iamVjdC0+cGFyZW50T2JqZWN0KCk7CisgICAgCisgICAgZm9yKHBhcmVudE9iaiA9 IG1fb2JqZWN0LT5wYXJlbnRPYmplY3QoKSA7IHBhcmVudE9iaiAmJiBwYXJlbnRPYmotPmFjY2Vz c2liaWxpdHlJc0lnbm9yZWQoKTsgcGFyZW50T2JqID0gcGFyZW50T2JqLT5wYXJlbnRPYmplY3Qo KSkgeyB9CisKKyAgICBpZiAocGFyZW50T2JqKSAgeworICAgICAgICAqcGFyZW50ID0gc3RhdGlj X2Nhc3Q8SURpc3BhdGNoKj4od3JhcHBlcihwYXJlbnRPYmopKTsKKyAgICAgICAgKCpwYXJlbnQp LT5BZGRSZWYoKTsKKyAgICAgICAgcmV0dXJuIFNfT0s7CisgICAgfQorCiAgICAgcmV0dXJuIFdl YlZpZXc6OkFjY2Vzc2libGVPYmplY3RGcm9tV2luZG93KG1fb2JqZWN0LT50b3BEb2N1bWVudEZy YW1lVmlldygpLT5jb250YWluaW5nV2luZG93KCksCiAgICAgICAgIE9CSklEX1dJTkRPVywgX191 dWlkb2YoSUFjY2Vzc2libGUpLCByZWludGVycHJldF9jYXN0PHZvaWQqKj4ocGFyZW50KSk7CiB9 CkBAIC00MjQsOSArNDM0LDkgQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBBY2Nlc3NpYmxl QmFzZQogICAgICAgICAgICAgICAgIHJldHVybiBFX0ZBSUw7CiAKICAgICAgICAgICAgIGlmIChk aXJlY3Rpb24gPT0gTkFWRElSX0ZJUlNUQ0hJTEQpCi0gICAgICAgICAgICAgICAgY2hpbGRPYmog PSBtX29iamVjdC0+Zmlyc3RDaGlsZCgpOworICAgICAgICAgICAgICAgIGNoaWxkT2JqID0gbV9v YmplY3QtPmZpcnN0QWNjZXNzaWJpbGl0eUNoaWxkKCk7CiAgICAgICAgICAgICBlbHNlCi0gICAg ICAgICAgICAgICAgY2hpbGRPYmogPSBtX29iamVjdC0+bGFzdENoaWxkKCk7CisgICAgICAgICAg ICAgICAgY2hpbGRPYmogPSBtX29iamVjdC0+bGFzdEFjY2Vzc2liaWxpdHlDaGlsZCgpOwogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgTkFWRElSX05FWFQ6CiAgICAgICAgIGNhc2Ug TkFWRElSX1BSRVZJT1VTOiB7CkBAIC00MzYsOSArNDQ2LDkgQEAgSFJFU1VMVCBTVERNRVRIT0RD QUxMVFlQRSBBY2Nlc3NpYmxlQmFzZQogICAgICAgICAgICAgICAgIHJldHVybiBocjsKIAogICAg ICAgICAgICAgaWYgKGRpcmVjdGlvbiA9PSBOQVZESVJfTkVYVCkKLSAgICAgICAgICAgICAgICBj aGlsZE9iaiA9IGNoaWxkT2JqLT5uZXh0U2libGluZygpOworICAgICAgICAgICAgICAgIGNoaWxk T2JqID0gY2hpbGRPYmotPm5leHRBY2Nlc3NpYmlsaXR5U2libGluZygpOwogICAgICAgICAgICAg ZWxzZQotICAgICAgICAgICAgICAgIGNoaWxkT2JqID0gY2hpbGRPYmotPnByZXZpb3VzU2libGlu ZygpOworICAgICAgICAgICAgICAgIGNoaWxkT2JqID0gY2hpbGRPYmotPnByZXZpb3VzQWNjZXNz aWJpbGl0eVNpYmxpbmcoKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CiAgICAgICAg IGRlZmF1bHQ6CkBAIC01NjMsNiArNTczLDE0IEBAIHN0YXRpYyBsb25nIE1TQUFSb2xlKEFjY2Vz c2liaWxpdHlSb2xlIHIKICAgICAgICAgY2FzZSBXZWJDb3JlOjpJbWFnZU1hcFJvbGU6CiAgICAg ICAgIGNhc2UgV2ViQ29yZTo6SW1hZ2VSb2xlOgogICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lT VEVNX0dSQVBISUM7CisgICAgICAgIGNhc2UgV2ViQ29yZTo6RG9jdW1lbnRSb2xlOgorICAgICAg ICAgIHJldHVybiBST0xFX1NZU1RFTV9ET0NVTUVOVDsKKyAgICAgICAgY2FzZSBXZWJDb3JlOjpD ZWxsUm9sZToKKyAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fQ0VMTDsKKyAgICAgICAgY2Fz ZSBXZWJDb3JlOjpMaXN0SXRlbVJvbGU6CisgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0xJ U1RJVEVNOworICAgICAgICBjYXNlIFdlYkNvcmU6OlNlcGFyYXRvclJvbGU6CisgICAgICAgICAg cmV0dXJuIFJPTEVfU1lTVEVNX1NFUEFSQVRPUjsKICAgICAgICAgZGVmYXVsdDoKICAgICAgICAg ICAgIC8vIFRoaXMgaXMgdGhlIGRlZmF1bHQgcm9sZSBmb3IgTVNBQS4KICAgICAgICAgICAgIHJl dHVybiBST0xFX1NZU1RFTV9DTElFTlQ7CkluZGV4OiBXZWJLaXQvd2luL1dlYktpdC52Y3Byb2ov YnVpbGQtZ2VuZXJhdGVkLWZpbGVzLnNoCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViS2l0 LnZjcHJvai9idWlsZC1nZW5lcmF0ZWQtZmlsZXMuc2gJKHJldmlzaW9uIDM1MTk4KQorKysgV2Vi S2l0L3dpbi9XZWJLaXQudmNwcm9qL2J1aWxkLWdlbmVyYXRlZC1maWxlcy5zaAkod29ya2luZyBj b3B5KQpAQCAtNjAsMyArNjAsNCBAQCBleHBvcnQgV0VCS0lUX09VVFBVVD0kWERTVFJPT1QKIAog ZXhwb3J0IEZFQVRVUkVfREVGSU5FUz0iRU5BQkxFX1hQQVRIIEVOQUJMRV9TVkciCiBtYWtlIC1m ICIkV0VCS0lUL1dlYktpdC52Y3Byb2ovRGVyaXZlZFNvdXJjZXMubWFrZSIgLWogJHtOVU1DUFVT fSB8fCBleGl0IDEKKwo= 22459 2008-07-23 16:59:57 -0700 2008-07-24 19:32:53 -0700 Latest patch after Jon and Eric reviewed second time MyPatch2.txt text/plain 24778 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTI4MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDQgQEAKKzIwMDgtMDctMjEgIFUtc3Rhbmd1dHVyaVxTYW5rYXIgVGFuZ3V0dXJp ICBzYW5rYXJhZGl0eWFAZ21haWwuY29tCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFOR0VE CisKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNUZXh0Rm9ybWF0dGluZ0VsZW1lbnQpOgorICAg ICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNMaW5rT3JMaXN0SXRlbUVsZW1l bnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNGb3JtT3JUYWJs ZUVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6YWNjRmly c3RDaGlsZCk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphY2NMYXN0 Q2hpbGQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6cHJldmlvdXNB Y2Nlc3NpYmlsaXR5U2libGluZyk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2Jq ZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmcpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNz aWJpbGl0eU9iamVjdDo6c2V0QWNjZXNzaWJpbGl0eUlEKToKKyAgICAgICAgKFdlYkNvcmU6OkFj Y2Vzc2liaWxpdHlPYmplY3Q6OnNldEFjY2Vzc2libGVQYXJlbnQpOgorICAgICAgICAoV2ViQ29y ZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4pOgorICAgICAgICAqIHBhZ2UvQWNj ZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6KToKKyAgICAgICAgKFdlYkNv cmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmFjY2Vzc2liaWxpdHlJRCk6CisgICAgICAgIChXZWJD b3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphY2Nlc3NpYmxlUGFyZW50KToKKyAgICAgICAgKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmNoaWxkcmVuKToKKyAgICAgICAgKiBwYWdlL0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlVGV4 dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OmFjY0ZpcnN0Q2hpbGQpOgorICAgICAgICAoV2ViQ29yZTo6QWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWNjTGFzdENoaWxkKToKKyAgICAgICAgKFdlYkNvcmU6 OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnByZXZpb3VzQWNjZXNzaWJpbGl0eVNpYmxpbmcp OgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6bmV4dEFjY2Vz c2liaWxpdHlTaWJsaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmlzVGV4dEZvcm1hdHRpbmdFbGVtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzRm9ybU9yVGFibGVFbGVtZW50KToKKyAgICAgICAgKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50 KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmhlbHBUZXh0 KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRpdGxlKToK KyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmVsZW1lbnRSZWN0 KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFjY2Vzc2li aWxpdHlJc0lnbm9yZWQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdDo6cm9sZVZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmNhblNldEZvY3VzQXR0cmlidXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkcmVuKToKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QuaDoKKwogMjAwOC0wNy0yMSAgS2V2aW4gQ2FsaG91biAgPGtjYWxo b3VuQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGVsZS4KSW5kZXg6IFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3Bh Z2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAJKHJldmlzaW9uIDM1MTk4KQorKysgV2ViQ29yZS9w YWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC05NDYsNiArOTQ2 LDUxIEBAIEFjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlPYmplY3QKICAgICByZXR1 cm4gMDsKIH0KIAorYm9vbCBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppc1RleHRGb3JtYXR0aW5nRWxl bWVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIEFjY2Vzc2liaWxp dHlPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4g ZmFsc2U7Cit9CisKK2Jvb2wgQWNjZXNzaWJpbGl0eU9iamVjdDo6aXNGb3JtT3JUYWJsZUVsZW1l bnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworQWNjZXNzaWJpbGl0eU9iamVj dCogQWNjZXNzaWJpbGl0eU9iamVjdDo6Zmlyc3RBY2Nlc3NpYmlsaXR5Q2hpbGQoKSBjb25zdAor eworICAgIHJldHVybiAwOworfQorCitBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nlc3NpYmlsaXR5 T2JqZWN0OjpsYXN0QWNjZXNzaWJpbGl0eUNoaWxkKCkgY29uc3QKK3sKKyAgICByZXR1cm4gMDsK K30KKworQWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0eU9iamVjdDo6cHJldmlvdXNB Y2Nlc3NpYmlsaXR5U2libGluZygpIGNvbnN0Cit7CisgICAgcmV0dXJuIDA7Cit9CisKK0FjY2Vz c2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlPYmplY3Q6Om5leHRBY2Nlc3NpYmlsaXR5U2li bGluZygpIGNvbnN0Cit7CisgICAgcmV0dXJuIDA7Cit9CisKK3ZvaWQgQWNjZXNzaWJpbGl0eU9i amVjdDo6c2V0SW5kZXhJblBhcmVudCh1bnNpZ25lZCBpbmRleEluUGFyZW50KQoreworICAgIG1f aW5kZXhJblBhcmVudCA9IGluZGV4SW5QYXJlbnQ7Cit9CisKK3ZvaWQgQWNjZXNzaWJpbGl0eU9i amVjdDo6c2V0QWNjZXNzaWJpbGl0eVBhcmVudChjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBh Y2Nlc3NpYmlsaXR5UGFyZW50KQoreworICAgIG1fYWNjZXNzaWJpbGl0eVBhcmVudCA9IGFjY2Vz c2liaWxpdHlQYXJlbnQ7Cit9CisKIEFjY2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlPYmpl Y3Q6OnJvbGVWYWx1ZSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIFVua25vd25Sb2xlOwpAQCAtOTc3 LDcgKzEwMjIsNyBAQCB2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmNoaWxkcmVuQ2hhbmdlCiAg ICAgcmV0dXJuOwogfQogCi12b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKCkK K3ZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4oKSBjb25zdAogewogfQogCklu ZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHJldmlzaW9uIDM1MTk4KQorKysgV2Vi Q29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtMTQ0LDcg KzE0NCwxMSBAQCBlbnVtIEFjY2Vzc2liaWxpdHlSb2xlIHsKICAgICBXZWJBcmVhUm9sZSwKICAg ICBIZWFkaW5nUm9sZSwKICAgICBMaXN0Qm94Um9sZSwKLSAgICBMaXN0Qm94T3B0aW9uUm9sZQor ICAgIExpc3RCb3hPcHRpb25Sb2xlLAorICAgIExpc3RJdGVtUm9sZSwKKyAgICBEb2N1bWVudFJv bGUsCisgICAgQ2VsbFJvbGUsCisgICAgU2VwYXJhdG9yUm9sZQogfTsKIAogc3RydWN0IFZpc2li bGVQb3NpdGlvblJhbmdlIHsKQEAgLTI2Miw3ICsyNjYsMjMgQEAgcHVibGljOgogCiAgICAgdmly dHVhbCBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdDsKICAgICB2aXJ0dWFsIEFY T2JqZWN0Q2FjaGUqIGF4T2JqZWN0Q2FjaGUoKSBjb25zdDsKLSAgICAKKworICAgIHZpcnR1YWwg Ym9vbCBpc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBp c0xpbmtPckxpc3RJdGVtRWxlbWVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc0Zvcm1P clRhYmxlRWxlbWVudCgpIGNvbnN0OworCisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0 KiBmaXJzdEFjY2Vzc2liaWxpdHlDaGlsZCgpIGNvbnN0OworICAgIHZpcnR1YWwgQWNjZXNzaWJp bGl0eU9iamVjdCogbGFzdEFjY2Vzc2liaWxpdHlDaGlsZCgpIGNvbnN0OworCisgICAgdmlydHVh bCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBwcmV2aW91c0FjY2Vzc2liaWxpdHlTaWJsaW5nKCkgY29u c3Q7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBuZXh0QWNjZXNzaWJpbGl0eVNp YmxpbmcoKSBjb25zdDsKKworICAgIHVuc2lnbmVkIGluZGV4SW5QYXJlbnQoKSB7IHJldHVybiBt X2luZGV4SW5QYXJlbnQ7IH0KKyAgICB2b2lkIHNldEluZGV4SW5QYXJlbnQodW5zaWduZWQpOwor CisgICAgY29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjZXNzaWJpbGl0eVBhcmVudCgpIHsg cmV0dXJuIG1fYWNjZXNzaWJpbGl0eVBhcmVudDsgfQorICAgIHZvaWQgc2V0QWNjZXNzaWJpbGl0 eVBhcmVudChjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiApOworCiAgICAgdmlydHVhbCBIVE1M QW5jaG9yRWxlbWVudCogYW5jaG9yRWxlbWVudCgpIGNvbnN0OwogICAgIHZpcnR1YWwgRWxlbWVu dCogYWN0aW9uRWxlbWVudCgpIGNvbnN0OwogICAgIHZpcnR1YWwgSW50UmVjdCBib3VuZGluZ0Jv eFJlY3QoKSBjb25zdDsKQEAgLTMwOSw4ICszMjksOCBAQCBwdWJsaWM6CiAgICAgYm9vbCBwZXJm b3JtRGVmYXVsdEFjdGlvbigpIGNvbnN0IHsgcmV0dXJuIHByZXNzKCk7IH0KICAgICAKICAgICB2 aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCBjb25zdCBBY2Nlc3Np YmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgeyByZXR1cm4gbV9jaGlsZHJlbjsgfQot ICAgIHZpcnR1YWwgdm9pZCBhZGRDaGlsZHJlbigpOworICAgIHZpcnR1YWwgY29uc3QgQWNjZXNz aWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbigpIGNvbnN0IHsgcmV0dXJuIG1fY2hpbGRy ZW47IH0KKyAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKSBjb25zdDsKICAgICB2aXJ0dWFs IGJvb2wgaGFzQ2hpbGRyZW4oKSBjb25zdCB7IHJldHVybiBtX2hhdmVDaGlsZHJlbjsgfTsKICAg ICB2aXJ0dWFsIHZvaWQgc2VsZWN0ZWRDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgdmlzaWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGls ZHJlblZlY3RvciYpOwpAQCAtMzgyLDkgKzQwMiwxMiBAQCBwdWJsaWM6CiAKIHByb3RlY3RlZDoK ICAgICB1bnNpZ25lZCBtX2lkOwotICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2No aWxkcmVuOworICAgIG11dGFibGUgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIG1fY2hpbGRy ZW47CiAgICAgbXV0YWJsZSBib29sIG1faGF2ZUNoaWxkcmVuOwotICAgIAorCisgICAgdW5zaWdu ZWQgbV9pbmRleEluUGFyZW50OworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3QqIG1fYWNj ZXNzaWJpbGl0eVBhcmVudDsKKwogICAgIHZpcnR1YWwgdm9pZCBjbGVhckNoaWxkcmVuKCk7CiAg ICAgdmlydHVhbCB2b2lkIHJlbW92ZUFYT2JqZWN0SUQoKTsKICAgICB2aXJ0dWFsIGJvb2wgaXNE ZXRhY2hlZCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDM1MTk4KQorKysgV2ViQ29yZS9w YWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMDks NiArMTA5LDU0IEBAIHZvaWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6ZGV0YWNoKCkKICAg ICBtX3JlbmRlcmVyID0gMDsgICAgCiB9CiAKK3N0YXRpYyBIYXNoU2V0PFN0cmluZywgQ2FzZUZv bGRpbmdIYXNoPiogY3JlYXRlVGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKCkgCit7Cisg ICAgc3RhdGljIEhhc2hTZXQ8U3RyaW5nLCBDYXNlRm9sZGluZ0hhc2g+IGVsZW1lbnRIYXNoU2V0 OworICAgIGlmIChlbGVtZW50SGFzaFNldC5pc0VtcHR5KCkpIHsKKyAgICAgICAgZWxlbWVudEhh c2hTZXQuYWRkKGJUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChi VGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoYmRvVGFnLnRvU3Ry aW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoYmlnVGFnLnRvU3RyaW5nKCkpOwor ICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoY2l0ZVRhZy50b1N0cmluZygpKTsKKyAgICAgICAg ZWxlbWVudEhhc2hTZXQuYWRkKGRmblRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhh c2hTZXQuYWRkKGRlbFRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRk KGluc1RhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGVtVGFnLnRv U3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoZm9udFRhZy50b1N0cmluZygp KTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGlUYWcudG9TdHJpbmcoKSk7CisgICAgICAg IGVsZW1lbnRIYXNoU2V0LmFkZChzVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFz aFNldC5hZGQoc2FtcFRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRk KHNwYW5UYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChzdHJpa2VU YWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChzdHJvbmdUYWcudG9T dHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChzdWJUYWcudG9TdHJpbmcoKSk7 CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChzdXBUYWcudG9TdHJpbmcoKSk7CisgICAgICAg IGVsZW1lbnRIYXNoU2V0LmFkZCh0ZXh0YXJlYVRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxl bWVudEhhc2hTZXQuYWRkKHR0VGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNl dC5hZGQodVRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHByZVRh Zy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGRpdlRhZy50b1N0cmlu ZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGNlbnRlclRhZy50b1N0cmluZygpKTsK KyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHBUYWcudG9TdHJpbmcoKSk7CisgICAgfQorICAg IHJldHVybiAmZWxlbWVudEhhc2hTZXQ7Cit9CisKK3N0YXRpYyBIYXNoU2V0PFN0cmluZywgQ2Fz ZUZvbGRpbmdIYXNoPiogY3JlYXRlTGlua0FuZExpc3RFbGVtZW50c0hhc2goKSAKK3sKKyAgICBz dGF0aWMgSGFzaFNldDxTdHJpbmcsIENhc2VGb2xkaW5nSGFzaD4gZWxlbWVudEhhc2hTZXQ7CisK KyAgICBpZiAoZWxlbWVudEhhc2hTZXQuaXNFbXB0eSgpKSB7CisgICAgICAgIGVsZW1lbnRIYXNo U2V0LmFkZChhYmJyVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQo YWNyb255bVRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHFUYWcu dG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChsaVRhZy50b1N0cmluZygp KTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGRkVGFnLnRvU3RyaW5nKCkpOworICAgICAg ICBlbGVtZW50SGFzaFNldC5hZGQoZHRUYWcudG9TdHJpbmcoKSk7CisgICAgfQorICAgIHJldHVy biAmZWxlbWVudEhhc2hTZXQ7Cit9CisKIEFjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3Q6OmZpcnN0Q2hpbGQoKSBjb25zdAogewogICAgIGlmICghbV9yZW5kZXJl cikKQEAgLTE1Nyw2ICsyMDUsNDIgQEAgQWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0 eVJlbmRlcgogICAgIHJldHVybiBtX3JlbmRlcmVyLT5kb2N1bWVudCgpLT5heE9iamVjdENhY2hl KCktPmdldChuZXh0U2libGluZyk7CiB9CiAKK0FjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OmZpcnN0QWNjZXNzaWJpbGl0eUNoaWxkKCkgY29uc3QKK3sKKyAg ICBpZiAobV9jaGlsZHJlbi5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiAwOworCisgICAgcmV0 dXJuIG1fY2hpbGRyZW4uZmlyc3QoKS5nZXQoKTsKK30KKworQWNjZXNzaWJpbGl0eU9iamVjdCog QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6bGFzdEFjY2Vzc2liaWxpdHlDaGlsZCgpIGNvbnN0 Cit7CisgICAgaWYgKG1fY2hpbGRyZW4uaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gMDsKKwor ICAgIHJldHVybiBtX2NoaWxkcmVuLmxhc3QoKS5nZXQoKTsKK30KKworQWNjZXNzaWJpbGl0eU9i amVjdCogQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cHJldmlvdXNBY2Nlc3NpYmlsaXR5U2li bGluZygpIGNvbnN0Cit7CisgICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBz aWJsaW5nc1ZlY3RvciA9IG1fYWNjZXNzaWJpbGl0eVBhcmVudC0+Y2hpbGRyZW4oKTsKKworICAg IGlmIChtX2luZGV4SW5QYXJlbnQgPT0gMCkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1 cm4gc2libGluZ3NWZWN0b3JbbV9pbmRleEluUGFyZW50IC0gMV0uZ2V0KCk7Cit9CisKK0FjY2Vz c2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6Om5leHRBY2Nlc3NpYmls aXR5U2libGluZygpIGNvbnN0Cit7CisgICAgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yJiBzaWJsaW5nc1ZlY3RvciA9IG1fYWNjZXNzaWJpbGl0eVBhcmVudC0+Y2hpbGRyZW4oKTsK KworICAgIGlmIChtX2luZGV4SW5QYXJlbnQgKyAxID09IHNpYmxpbmdzVmVjdG9yLnNpemUoKSkK KyAgICAgICAgcmV0dXJuIDA7CisKKyAgICByZXR1cm4gc2libGluZ3NWZWN0b3JbbV9pbmRleElu UGFyZW50ICsgMV0uZ2V0KCk7Cit9CisKIEFjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3Q6OnBhcmVudE9iamVjdCgpIGNvbnN0CiB7CiAgICAgaWYgKCFtX3JlbmRl cmVyKQpAQCAtNDAzLDcgKzQ4Nyw0NSBAQCBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmlzSGVhZGluCiB7CiAgICAgcmV0dXJuIHJvbGVWYWx1ZSgpID09IEhlYWRpbmdSb2xlOwogfQot ICAgIAorCitib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzVGV4dEZvcm1hdHRpbmdF bGVtZW50KCkgY29uc3QKK3sKKyAgICBIYXNoU2V0PFN0cmluZywgQ2FzZUZvbGRpbmdIYXNoPiog dGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXMgPSBjcmVhdGVUZXh0Rm9ybWF0dGluZ0VsZW1lbnRO YW1lc0hhc2goKTsKKworICAgIGlmIChtX3JlbmRlcmVyICYmIG1fcmVuZGVyZXItPmVsZW1lbnQo KSkKKyAgICAgICAgcmV0dXJuIHRleHRGb3JtYXR0aW5nRWxlbWVudE5hbWVzLT5jb250YWlucyht X3JlbmRlcmVyLT5lbGVtZW50KCktPm5vZGVOYW1lKCkpOworCisgICAgcmV0dXJuIGZhbHNlOwor Cit9CisKK2Jvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6aXNGb3JtT3JUYWJsZUVsZW1l bnQoKSBjb25zdAoreworICAgIGlmICghbV9yZW5kZXJlciB8fCAhbV9yZW5kZXJlci0+ZWxlbWVu dCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxlbWVu dCgpLT5oYXNUYWdOYW1lKGZvcm1UYWcpCisgICAgfHwgIG1fcmVuZGVyZXItPmVsZW1lbnQoKS0+ aGFzVGFnTmFtZSh0YWJsZVRhZykKKyAgICB8fCAgbV9yZW5kZXJlci0+ZWxlbWVudCgpLT5oYXNU YWdOYW1lKHRkVGFnKQorICAgIHx8ICBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUo dGhUYWcpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVybiBmYWxzZTsKKworfQor Citib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50 KCkgY29uc3QKK3sKKyAgICBIYXNoU2V0PFN0cmluZywgQ2FzZUZvbGRpbmdIYXNoPiogZWxlbWVu dEhhc2hTZXQgPSBjcmVhdGVMaW5rQW5kTGlzdEVsZW1lbnRzSGFzaCgpOworCisgICAgaWYgKG1f cmVuZGVyZXIgJiYgbV9yZW5kZXJlci0+ZWxlbWVudCgpKQorICAgICAgICByZXR1cm4gbV9yZW5k ZXJlci0+ZWxlbWVudCgpLT5pc0xpbmsoKSAKKyAgICAgICAgICAgIHx8IGVsZW1lbnRIYXNoU2V0 LT5jb250YWlucyhtX3JlbmRlcmVyLT5lbGVtZW50KCktPm5vZGVOYW1lKCkpOworCisgICAgICAg IHJldHVybiBmYWxzZTsKKworfQorCiBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6Omlz TGluaygpIGNvbnN0CiB7CiAgICAgcmV0dXJuIHJvbGVWYWx1ZSgpID09IFdlYkNvcmVMaW5rUm9s ZTsKQEAgLTgzMCwxNyArOTUyLDQwIEBAIFN0cmluZyBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 Ojp0aXRsZSgKICAgICAgICAgaWYgKGxhYmVsKQogICAgICAgICAgICAgcmV0dXJuIGxhYmVsLT5p bm5lclRleHQoKTsKICAgICB9Ci0gICAgCisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxlbWVudCgp LT5pc0xpbmsoKSB8fCBpc0hlYWRpbmcoKSkgeworICAgICAgICBjb25zdCBWZWN0b3I8IFJlZlB0 cjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiA+JiBjaGlsZHJlblZlY3RvciA9IGNoaWxkcmVuKCk7Cisg ICAgICAgIFZlY3RvcjxVQ2hhcj4gZWxlbWVudFRleHQ7CisgICAgICAgIGZvciAodW5zaWduZWQg aSA9IDA7IGkgPCBjaGlsZHJlblZlY3Rvci5zaXplKCk7ICsraSkgeworICAgICAgICAgICAgZWxl bWVudFRleHQuYXBwZW5kKCcgJyk7CisgICAgICAgICAgICBTdHJpbmcgZWxlbWVudFRpdGxlID0g Y2hpbGRyZW5WZWN0b3JbaV0tPnRpdGxlKCk7CisgICAgICAgICAgICBhcHBlbmQoZWxlbWVudFRl eHQsIGVsZW1lbnRUaXRsZSk7CisgICAgICAgIH0KKworICAgICAgICByZXR1cm4gU3RyaW5nOjph ZG9wdChlbGVtZW50VGV4dCkuc3RyaXBXaGl0ZVNwYWNlKCk7CisgICAgICAgIAorICAgIH0KKwog ICAgIGlmIChyb2xlVmFsdWUoKSA9PSBCdXR0b25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09 IExpc3RCb3hPcHRpb25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09IE1lbnVJdGVtUm9sZQot ICAgICAgICB8fCBhcmlhUm9sZSA9PSBNZW51QnV0dG9uUm9sZQotICAgICAgICB8fCBpc0hlYWRp bmcoKSkKKyAgICAgICAgfHwgYXJpYVJvbGUgPT0gTWVudUJ1dHRvblJvbGUpICAgICAgICAKICAg ICAgICAgcmV0dXJuIHRleHRVbmRlckVsZW1lbnQoKTsKLSAgICAKLSAgICBpZiAoaXNMaW5rKCkp CisKKyAgICBpZiAoaXNJbWFnZSgpKSB7CisgICAgICAgIE5vZGUqIG5vZGUgPSBtX3JlbmRlcmVy LT5lbGVtZW50KCk7CisgICAgICAgIGlmIChub2RlICYmIG5vZGUtPmlzRWxlbWVudE5vZGUoKSkg eworICAgICAgICAgICAgRWxlbWVudCogZWx0ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG5vZGUp OworICAgICAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBhbHQgPSBlbHQtPmdldEF0dHJpYnV0 ZShhbHRBdHRyKTsKKyAgICAgICAgICAgIGlmICghYWx0LmlzTnVsbCgpKQorICAgICAgICAgICAg ICAgIHJldHVybiBhbHQuc3RyaW5nKCk7CisgICAgICAgICAgICByZXR1cm4gU3RyaW5nKCk7Cisg ICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAobV9yZW5kZXJlci0+aXNUZXh0KCkpCiAgICAgICAg IHJldHVybiB0ZXh0VW5kZXJFbGVtZW50KCk7Ci0gICAgCisKICAgICByZXR1cm4gU3RyaW5nKCk7 CiB9CiAKQEAgLTkzMSw3ICsxMDc2LDcgQEAgSW50UmVjdCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0OjpjaGVjawogfQogCiBJbnRSZWN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmVsZW1l bnRSZWN0KCkgY29uc3QKLXsKK3sgCiAgICAgLy8gYSBjaGVja2JveCBvciByYWRpbyBidXR0b24g c2hvdWxkIGVuY29tcGFzcyBpdHMgbGFiZWwKICAgICBpZiAoaXNDaGVja2JveE9yUmFkaW8oKSkK ICAgICAgICAgcmV0dXJuIGNoZWNrYm94T3JSYWRpb1JlY3QoKTsKQEAgLTEwNzcsMjQgKzEyMjIs NDQgQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphY2Nlc3NpYgogICAgIEFjY2Vz c2liaWxpdHlSb2xlIGFyaWFSb2xlID0gYXJpYVJvbGVBdHRyaWJ1dGUoKTsKICAgICBpZiAoYXJp YVJvbGUgPT0gVGV4dEFyZWFSb2xlIHx8IGFyaWFSb2xlID09IFN0YXRpY1RleHRSb2xlKSB7CiAg ICAgICAgIFN0cmluZyBhcmlhVGV4dCA9IHRleHQoKTsKLSAgICAgICAgcmV0dXJuIGFyaWFUZXh0 LmlzTnVsbCgpIHx8IGFyaWFUZXh0LmlzRW1wdHkoKTsKKyAgICAgICAgcmV0dXJuIGFyaWFUZXh0 LmlzTnVsbCgpIHx8IGFyaWFUZXh0LmNvbnRhaW5zT25seVdoaXRlc3BhY2UoKTsKICAgICB9ICAg IAogICAgIAotICAgIC8vIE5PVEU6IEJScyBhbHdheXMgaGF2ZSB0ZXh0IGJveGVzIG5vdywgc28g dGhlIHRleHQgYm94IGNoZWNrIGhlcmUgY2FuIGJlIHJlbW92ZWQKKwogICAgIGlmIChtX3JlbmRl cmVyLT5pc1RleHQoKSkgewogICAgICAgICAvLyBzdGF0aWMgdGV4dCBiZW5lYXRoIE1lbnVJdGVt cyBhbmQgTWVudUJ1dHRvbnMgYXJlIGp1c3QgcmVwb3J0ZWQgYWxvbmcgd2l0aCB0aGUgbWVudSBp dGVtLCBzbyBpdCdzIGlnbm9yZWQgb24gYW4gaW5kaXZpZHVhbCBsZXZlbAotICAgICAgICBpZiAo cGFyZW50T2JqZWN0VW5pZ25vcmVkKCktPmFyaWFSb2xlQXR0cmlidXRlKCkgPT0gTWVudUl0ZW1S b2xlIHx8Ci0gICAgICAgICAgICBwYXJlbnRPYmplY3RVbmlnbm9yZWQoKS0+YXJpYVJvbGVBdHRy aWJ1dGUoKSA9PSBNZW51QnV0dG9uUm9sZSkKKyAgICAgICAgaWYgKCF0ZXh0VW5kZXJFbGVtZW50 KCkuY29udGFpbnNPbmx5V2hpdGVzcGFjZSgpKSAgeworICAgICAgICAgICAgaWYgKHBhcmVudE9i amVjdFVuaWdub3JlZCgpLT5hcmlhUm9sZUF0dHJpYnV0ZSgpID09IE1lbnVJdGVtUm9sZQorICAg ICAgICAgICAgICAgIHx8IHBhcmVudE9iamVjdFVuaWdub3JlZCgpLT5hcmlhUm9sZUF0dHJpYnV0 ZSgpID09IE1lbnVCdXR0b25Sb2xlKQorICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgcmV0 dXJuIHRydWU7Ci0gICAgICAgICByZXR1cm4gbV9yZW5kZXJlci0+aXNCUigpIHx8ICFzdGF0aWNf Y2FzdDxSZW5kZXJUZXh0Kj4obV9yZW5kZXJlciktPmZpcnN0VGV4dEJveCgpOworICAgICAgICB9 CiAgICAgfQogICAgIAogICAgIGlmIChpc0hlYWRpbmcoKSkKICAgICAgICAgcmV0dXJuIGZhbHNl OwotICAgIAotICAgIGlmIChpc0xpbmsoKSkKKworICAgIGlmIChpc1RleHRGb3JtYXR0aW5nRWxl bWVudCgpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmIChpc0xpc3RFbGVtZW50KG1f cmVuZGVyZXItPmVsZW1lbnQoKSkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICAKKworICAg IGlmIChpc0Zvcm1PclRhYmxlRWxlbWVudCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAg ICBpZiAoaXNMaW5rT3JMaXN0SXRlbUVsZW1lbnQoKSkgeworICAgICAgICByZXR1cm4gY2hpbGRy ZW4oKS5pc0VtcHR5KCk7CisgICAgfQorCisgICAgaWYgKG1fcmVuZGVyZXItPmVsZW1lbnQoKSAm JiBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUoaHRtbFRhZykpCisgICAgICAgIHJl dHVybiB0cnVlOworCisgICAgaWYgKG1fcmVuZGVyZXItPmVsZW1lbnQoKSAmJiBtX3JlbmRlcmVy LT5lbGVtZW50KCktPmhhc1RhZ05hbWUoYm9keVRhZykpCisgICAgICAgIHJldHVybiB0cnVlOwor CiAgICAgLy8gYWxsIGNvbnRyb2xzIGFyZSBhY2Nlc3NpYmxlCiAgICAgaWYgKGlzQ29udHJvbCgp KQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC0xMTA0LDggKzEyNjksMTQgQEAgYm9vbCBBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphY2Nlc3NpYgogICAgIGlmIChub2RlICYmIG5vZGUtPmhh c1RhZ05hbWUobGFiZWxUYWcpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgCi0gICAgaWYg KG1fcmVuZGVyZXItPmlzQmxvY2tGbG93KCkgJiYgbV9yZW5kZXJlci0+Y2hpbGRyZW5JbmxpbmUo KSkKLSAgICAgICAgcmV0dXJuICFzdGF0aWNfY2FzdDxSZW5kZXJCbG9jayo+KG1fcmVuZGVyZXIp LT5maXJzdExpbmVCb3goKSAmJiAhbW91c2VCdXR0b25MaXN0ZW5lcigpOworICAgIGlmIChtX3Jl bmRlcmVyLT5pc0Jsb2NrRmxvdygpKSB7CisgICAgICAgIGlmIChtX3JlbmRlcmVyLT5pc0Fub255 bW91c0Jsb2NrKCkpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgcmV0dXJuIGZh bHNlOworICAgIH0KKworICAgIGlmIChtX3JlbmRlcmVyLT5pc0lubGluZUZsb3coKSkKKyAgICAg ICAgcmV0dXJuIHRydWU7CiAgICAgCiAgICAgLy8gaWdub3JlIGltYWdlcyBzZWVtaW5nbHkgdXNl ZCBhcyBzcGFjZXJzCiAgICAgaWYgKGlzSW1hZ2UoKSkgewpAQCAtMTk5OCwxNiArMjE2OSwyOSBA QCBBY2Nlc3NpYmlsaXR5Um9sZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgICAgIHJldHVy biBhcmlhUm9sZTsKICAgICAKICAgICBpZiAobm9kZSAmJiBub2RlLT5pc0xpbmsoKSkgewotICAg ICAgICBpZiAobV9yZW5kZXJlci0+aXNJbWFnZSgpKQorICAgICAgICBpZiAoaXNOYXRpdmVJbWFn ZSgpKQogICAgICAgICAgICAgcmV0dXJuIEltYWdlTWFwUm9sZTsKICAgICAgICAgcmV0dXJuIFdl YkNvcmVMaW5rUm9sZTsKICAgICB9CisKKyAgICBpZiAobm9kZSAmJiBub2RlLT5pc0RvY3VtZW50 Tm9kZSgpKQorICAgICAgICByZXR1cm4gRG9jdW1lbnRSb2xlOworCisgICAgaWYgKG5vZGUgJiYg bm9kZS0+aGFzVGFnTmFtZSh0YWJsZVRhZykpCisgICAgICAgIHJldHVybiBUYWJsZVJvbGU7CisK KyAgICBpZiAobm9kZSAmJiAobm9kZS0+aGFzVGFnTmFtZSh0ZFRhZykgfHwgbm9kZS0+aGFzVGFn TmFtZSh0aFRhZykpKQorICAgICAgICByZXR1cm4gQ2VsbFJvbGU7CisKICAgICBpZiAobV9yZW5k ZXJlci0+aXNMaXN0TWFya2VyKCkpCiAgICAgICAgIHJldHVybiBMaXN0TWFya2VyUm9sZTsKKwog ICAgIGlmIChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUoYnV0dG9uVGFnKSkKICAgICAgICAgcmV0 dXJuIEJ1dHRvblJvbGU7CisKICAgICBpZiAobV9yZW5kZXJlci0+aXNUZXh0KCkpCiAgICAgICAg IHJldHVybiBTdGF0aWNUZXh0Um9sZTsKKwogICAgIGlmIChtX3JlbmRlcmVyLT5pc0ltYWdlKCkp IHsKICAgICAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShpbnB1dFRhZykpCiAgICAg ICAgICAgICByZXR1cm4gQnV0dG9uUm9sZTsKQEAgLTIwMzIsOSArMjIxNiw2IEBAIEFjY2Vzc2li aWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmoKICAgICAgICAgICAgIHJldHVybiBCdXR0 b25Sb2xlOwogICAgIH0KIAotICAgIGlmIChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUoYnV0dG9u VGFnKSkKLSAgICAgICAgcmV0dXJuIEJ1dHRvblJvbGU7Ci0KICAgICBpZiAoaXNGaWxlVXBsb2Fk QnV0dG9uKCkpCiAgICAgICAgIHJldHVybiBCdXR0b25Sb2xlOwogICAgIApAQCAtMjA0NCw3ICsy MjI1LDE4IEBAIEFjY2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmoKICAgICBp ZiAoaGVhZGluZ0xldmVsKG1fcmVuZGVyZXItPmVsZW1lbnQoKSkgIT0gMCkKICAgICAgICAgcmV0 dXJuIEhlYWRpbmdSb2xlOwogICAgIAotICAgIGlmIChtX3JlbmRlcmVyLT5pc0Jsb2NrRmxvdygp IHx8IChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUobGFiZWxUYWcpKSkKKyAgICBpZihub2RlICYm IG5vZGUtPmhhc1RhZ05hbWUobGlUYWcpKQorICAgICAgICByZXR1cm4gTGlzdEl0ZW1Sb2xlOwor CisgICAgaWYobm9kZSAmJiBub2RlLT5oYXNUYWdOYW1lKGhyVGFnKSkKKyAgICAgICAgcmV0dXJu IFNlcGFyYXRvclJvbGU7CisKKyAgICBpZihub2RlICYmIChub2RlLT5oYXNUYWdOYW1lKG9sVGFn KSB8fCBub2RlLT5oYXNUYWdOYW1lKHVsVGFnKSB8fCBub2RlLT5oYXNUYWdOYW1lKGRsVGFnKSkp CisgICAgICAgIHJldHVybiBMaXN0Um9sZTsKKworICAgIGlmIChtX3JlbmRlcmVyLT5pc0Jsb2Nr RmxvdygpIHx8IG5vZGUtPmhhc1RhZ05hbWUoYWJiclRhZykKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8fCBub2RlLT5oYXNUYWdOYW1lKGFjcm9ueW1UYWcpIAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHx8IG5vZGUtPmhhc1RhZ05hbWUocVRhZykpCiAgICAg ICAgIHJldHVybiBHcm91cFJvbGU7CiAgICAgCiAgICAgcmV0dXJuIFVua25vd25Sb2xlOwpAQCAt MjA5MCw2ICsyMjgyLDggQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjYW5TZXRG bwogICAgICAgICBjYXNlIFBvcFVwQnV0dG9uUm9sZToKICAgICAgICAgY2FzZSBDaGVja0JveFJv bGU6CiAgICAgICAgIGNhc2UgUmFkaW9CdXR0b25Sb2xlOgorICAgICAgICBjYXNlIExpc3RJdGVt Um9sZToKKyAgICAgICAgY2FzZSBTZXBhcmF0b3JSb2xlOgogICAgICAgICAgICAgcmV0dXJuIHRy dWU7CiAgICAgICAgIGNhc2UgVW5rbm93blJvbGU6CiAgICAgICAgIGNhc2UgU2xpZGVyUm9sZToK QEAgLTIxMzgsNiArMjMzMiw4IEBAIGJvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2Fu U2V0Rm8KICAgICAgICAgY2FzZSBIZWFkaW5nUm9sZToKICAgICAgICAgY2FzZSBMaXN0Qm94Um9s ZToKICAgICAgICAgY2FzZSBMaXN0Qm94T3B0aW9uUm9sZToKKyAgICAgICAgY2FzZSBEb2N1bWVu dFJvbGU6CisgICAgICAgIGNhc2UgQ2VsbFJvbGU6CiAgICAgICAgICAgICByZXR1cm4gZmFsc2U7 CiAgICAgfQogICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwpAQCAtMjE2OCwxOSArMjM2NCwyMSBA QCB2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuCiAgICAgfQogfQogCi1j b25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuKCkKK2NvbnN0IEFjY2Vzc2liaWxpdHlP YmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdDo6Y2hpbGRyZW4oKSBjb25zdAogewogICAgIGlmICghbV9oYXZlQ2hpbGRyZW4pCiAgICAg ICAgIGFkZENoaWxkcmVuKCk7CiAgICAgcmV0dXJuIG1fY2hpbGRyZW47CiB9CiAKLXZvaWQgQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWRkQ2hpbGRyZW4oKQordm9pZCBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpIGNvbnN0CiB7CiAgICAgLy8gSWYgdGhlIG5lZWQg dG8gYWRkIG1vcmUgY2hpbGRyZW4gaW4gYWRkaXRpb24gdG8gZXhpc3RpbmcgY2hpbGRyZW4gYXJp c2VzLCAKICAgICAvLyBjaGlsZHJlbkNoYW5nZWQgc2hvdWxkIGhhdmUgYmVlbiBjYWxsZWQsIGxl YXZpbmcgdGhlIG9iamVjdCB3aXRoIG5vIGNoaWxkcmVuLgogICAgIEFTU0VSVCghbV9oYXZlQ2hp bGRyZW4pOyAKLSAgICAKKworICAgIHVuc2lnbmVkIGNoaWxkQ291bnRlciA9IDA7CisKICAgICAv LyBub3RoaW5nIHRvIGFkZCBpZiB0aGVyZSBpcyBubyBSZW5kZXJPYmplY3QKICAgICBpZiAoIW1f cmVuZGVyZXIpCiAgICAgICAgIHJldHVybjsKQEAgLTIxOTQsMTAgKzIzOTIsMTYgQEAgdm9pZCBB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZAogICAgICAgICAgICAgICAgIG9iai0+ YWRkQ2hpbGRyZW4oKTsKICAgICAgICAgICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBj aGlsZHJlbiA9IG9iai0+Y2hpbGRyZW4oKTsKICAgICAgICAgICAgIHVuc2lnbmVkIGxlbmd0aCA9 IGNoaWxkcmVuLnNpemUoKTsKLSAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBs ZW5ndGg7ICsraSkKKyAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBsZW5ndGg7 ICsraSkgIHsKKyAgICAgICAgICAgICAgICBjaGlsZHJlbltpXS0+c2V0SW5kZXhJblBhcmVudChj aGlsZENvdW50ZXIrKyk7CisgICAgICAgICAgICAgICAgY2hpbGRyZW5baV0tPnNldEFjY2Vzc2li aWxpdHlQYXJlbnQodGhpcyk7CiAgICAgICAgICAgICAgICAgbV9jaGlsZHJlbi5hcHBlbmQoY2hp bGRyZW5baV0pOwotICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNl ICB7CisgICAgICAgICAgICBvYmotPnNldEluZGV4SW5QYXJlbnQoY2hpbGRDb3VudGVyKyspOwor ICAgICAgICAgICAgb2JqLT5zZXRBY2Nlc3NpYmlsaXR5UGFyZW50KHRoaXMpOwogICAgICAgICAg ICAgbV9jaGlsZHJlbi5hcHBlbmQob2JqKTsKKyAgICAgICAgfQogICAgIH0KICAgICAKICAgICAv LyBmb3IgYSBSZW5kZXJJbWFnZSwgYWRkIHRoZSA8YXJlYT4gZWxlbWVudHMgYXMgaW5kaXZpZHVh bCBhY2Nlc3NpYmlsaXR5IG9iamVjdHMKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QuaAkocmV2aXNpb24gMzUxOTgpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMzAsNyArMTMwLDEzIEBAIHB1 YmxpYzoKICAgICB2b2lkIHNldEFyaWFSb2xlKCk7CiAgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5 Um9sZSByb2xlVmFsdWUoKSBjb25zdDsKICAgICB2aXJ0dWFsIEFYT2JqZWN0Q2FjaGUqIGF4T2Jq ZWN0Q2FjaGUoKSBjb25zdDsKLSAgICAKKyAgICB2aXJ0dWFsIGJvb2wgaXNUZXh0Rm9ybWF0dGlu Z0VsZW1lbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNMaW5rT3JMaXN0SXRlbUVsZW1l bnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNGb3JtT3JUYWJsZUVsZW1lbnQoKSBjb25z dDsKKyAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3QqIGZpcnN0QWNjZXNzaWJpbGl0eUNo aWxkKCkgY29uc3Q7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBsYXN0QWNjZXNz aWJpbGl0eUNoaWxkKCkgY29uc3Q7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBw cmV2aW91c0FjY2Vzc2liaWxpdHlTaWJsaW5nKCkgY29uc3Q7CisgICAgdmlydHVhbCBBY2Nlc3Np YmlsaXR5T2JqZWN0KiBuZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmcoKSBjb25zdDsKICAgICB2aXJ0 dWFsIEVsZW1lbnQqIGFjdGlvbkVsZW1lbnQoKSBjb25zdDsKICAgICBFbGVtZW50KiBtb3VzZUJ1 dHRvbkxpc3RlbmVyKCkgY29uc3Q7CiAgICAgRnJhbWVWaWV3KiBmcmFtZVZpZXdJZlJlbmRlclZp ZXcoKSBjb25zdDsKQEAgLTE3Miw3ICsxNzgsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lk IGdldERvY3VtZW50TGlua3MoQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJikgY29uc3Q7CiAg ICAgdmlydHVhbCBGcmFtZVZpZXcqIGRvY3VtZW50RnJhbWVWaWV3KCkgY29uc3Q7CiAgICAgCi0g ICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCk7 CisgICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVu KCkgY29uc3Q7CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHNldEZvY3VzZWQoYm9vbCk7CiAgICAg dmlydHVhbCB2b2lkIHNldFNlbGVjdGVkVGV4dFJhbmdlKGNvbnN0IFBsYWluVGV4dFJhbmdlJik7 CkBAIC0xODAsNyArMTg2LDcgQEAgcHVibGljOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBkZXRh Y2goKTsKICAgICB2aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCB2 b2lkIGFkZENoaWxkcmVuKCk7CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7 CiAgICAgdmlydHVhbCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVu VmVjdG9yJik7CiAgICAgdmlydHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5 Q2hpbGRyZW5WZWN0b3ImKTsKICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkRm9jdXNBY3RpdmVEZXNj ZW5kYW50KCkgY29uc3Q7CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJp bmcuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJpbmcu aAkocmV2aXNpb24gMzUxOTgpCisrKyBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJp bmcuaAkod29ya2luZyBjb3B5KQpAQCAtMTY4LDYgKzE2OCw4IEBAIHB1YmxpYzoKIAogICAgIFN0 cmluZ0ltcGwqIGltcGwoKSBjb25zdCB7IHJldHVybiBtX2ltcGwuZ2V0KCk7IH0KIAorICAgIGJv b2wgY29udGFpbnNPbmx5V2hpdGVzcGFjZSgpIHsgcmV0dXJuIGlzTnVsbCgpIHx8IG1faW1wbC0+ Y29udGFpbnNPbmx5V2hpdGVzcGFjZSgpOyB9CisKICNpZiBQTEFURk9STShDRikKICAgICBTdHJp bmcoQ0ZTdHJpbmdSZWYpOwogICAgIENGU3RyaW5nUmVmIGNyZWF0ZUNGU3RyaW5nKCkgY29uc3Q7 CkluZGV4OiBXZWJLaXQvd2luL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0No YW5nZUxvZwkocmV2aXNpb24gMzUyODApCisrKyBXZWJLaXQvd2luL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBACisyMDA4LTA3LTIxICBVLXN0YW5ndXR1cmlcU2Fua2Fy IFRhbmd1dHVyaSAgPHNldCBFTUFJTF9BRERSRVNTIGVudmlyb25tZW50IHZhcmlhYmxlPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogQWNjZXNzaWJs ZUJhc2UuY3BwOgorICAgICAgICAoQWNjZXNzaWJsZUJhc2U6OmdldF9hY2NQYXJlbnQpOgorICAg ICAgICAoQWNjZXNzaWJsZUJhc2U6OmFjY05hdmlnYXRlKToKKyAgICAgICAgKE1TQUFSb2xlKToK KyAgICAgICAgKiBXZWJLaXQudmNwcm9qL2J1aWxkLWdlbmVyYXRlZC1maWxlcy5zaDoKKwogMjAw OC0wNy0xNSAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAgICAgQWRkIFdl YktpdFtTZXRdU2hvdWxkVXNlRm9udFNtb290aGluZyBmdW5jdGlvbnMKSW5kZXg6IFdlYktpdC93 aW4vQWNjZXNzaWJsZUJhc2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vQWNjZXNzaWJs ZUJhc2UuY3BwCShyZXZpc2lvbiAzNTE5OCkKKysrIFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2Uu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMDIsNiArMTAyLDE0IEBAIEhSRVNVTFQgU1RETUVUSE9E Q0FMTFRZUEUgQWNjZXNzaWJsZUJhc2UKICAgICBpZiAoIW1fb2JqZWN0KQogICAgICAgICByZXR1 cm4gRV9GQUlMOwogCisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogcGFyZW50T2JqID0gbV9vYmpl Y3QtPnBhcmVudE9iamVjdFVuaWdub3JlZCgpOyAgICAKKworICAgIGlmIChwYXJlbnRPYmopICB7 CisgICAgICAgICpwYXJlbnQgPSBzdGF0aWNfY2FzdDxJRGlzcGF0Y2gqPih3cmFwcGVyKHBhcmVu dE9iaikpOworICAgICAgICAoKnBhcmVudCktPkFkZFJlZigpOworICAgICAgICByZXR1cm4gU19P SzsKKyAgICB9CisKICAgICByZXR1cm4gV2ViVmlldzo6QWNjZXNzaWJsZU9iamVjdEZyb21XaW5k b3cobV9vYmplY3QtPnRvcERvY3VtZW50RnJhbWVWaWV3KCktPmNvbnRhaW5pbmdXaW5kb3coKSwK ICAgICAgICAgT0JKSURfV0lORE9XLCBfX3V1aWRvZihJQWNjZXNzaWJsZSksIHJlaW50ZXJwcmV0 X2Nhc3Q8dm9pZCoqPihwYXJlbnQpKTsKIH0KQEAgLTQyNCw5ICs0MzIsOSBAQCBIUkVTVUxUIFNU RE1FVEhPRENBTExUWVBFIEFjY2Vzc2libGVCYXNlCiAgICAgICAgICAgICAgICAgcmV0dXJuIEVf RkFJTDsKIAogICAgICAgICAgICAgaWYgKGRpcmVjdGlvbiA9PSBOQVZESVJfRklSU1RDSElMRCkK LSAgICAgICAgICAgICAgICBjaGlsZE9iaiA9IG1fb2JqZWN0LT5maXJzdENoaWxkKCk7CisgICAg ICAgICAgICAgICAgY2hpbGRPYmogPSBtX29iamVjdC0+Zmlyc3RBY2Nlc3NpYmlsaXR5Q2hpbGQo KTsKICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICBjaGlsZE9iaiA9IG1fb2JqZWN0 LT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgICAgICAgICBjaGlsZE9iaiA9IG1fb2JqZWN0LT5sYXN0 QWNjZXNzaWJpbGl0eUNoaWxkKCk7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBO QVZESVJfTkVYVDoKICAgICAgICAgY2FzZSBOQVZESVJfUFJFVklPVVM6IHsKQEAgLTQzNiw5ICs0 NDQsOSBAQCBIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIEFjY2Vzc2libGVCYXNlCiAgICAgICAg ICAgICAgICAgcmV0dXJuIGhyOwogCiAgICAgICAgICAgICBpZiAoZGlyZWN0aW9uID09IE5BVkRJ Ul9ORVhUKQotICAgICAgICAgICAgICAgIGNoaWxkT2JqID0gY2hpbGRPYmotPm5leHRTaWJsaW5n KCk7CisgICAgICAgICAgICAgICAgY2hpbGRPYmogPSBjaGlsZE9iai0+bmV4dEFjY2Vzc2liaWxp dHlTaWJsaW5nKCk7CiAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAgY2hpbGRPYmog PSBjaGlsZE9iai0+cHJldmlvdXNTaWJsaW5nKCk7CisgICAgICAgICAgICAgICAgY2hpbGRPYmog PSBjaGlsZE9iai0+cHJldmlvdXNBY2Nlc3NpYmlsaXR5U2libGluZygpOwogICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIH0KICAgICAgICAgZGVmYXVsdDoKQEAgLTU2Myw2ICs1NzEsMTQgQEAg c3RhdGljIGxvbmcgTVNBQVJvbGUoQWNjZXNzaWJpbGl0eVJvbGUgcgogICAgICAgICBjYXNlIFdl YkNvcmU6OkltYWdlTWFwUm9sZToKICAgICAgICAgY2FzZSBXZWJDb3JlOjpJbWFnZVJvbGU6CiAg ICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fR1JBUEhJQzsKKyAgICAgICAgY2FzZSBXZWJD b3JlOjpEb2N1bWVudFJvbGU6CisgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0RPQ1VNRU5U OworICAgICAgICBjYXNlIFdlYkNvcmU6OkNlbGxSb2xlOgorICAgICAgICAgIHJldHVybiBST0xF X1NZU1RFTV9DRUxMOworICAgICAgICBjYXNlIFdlYkNvcmU6Okxpc3RJdGVtUm9sZToKKyAgICAg ICAgICByZXR1cm4gUk9MRV9TWVNURU1fTElTVElURU07CisgICAgICAgIGNhc2UgV2ViQ29yZTo6 U2VwYXJhdG9yUm9sZToKKyAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fU0VQQVJBVE9SOwog ICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgLy8gVGhpcyBpcyB0aGUgZGVmYXVsdCByb2xl IGZvciBNU0FBLgogICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0NMSUVOVDsKSW5kZXg6 IFdlYktpdC93aW4vV2ViS2l0LnZjcHJvai9idWlsZC1nZW5lcmF0ZWQtZmlsZXMuc2gKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViS2l0L3dpbi9XZWJLaXQudmNwcm9qL2J1aWxkLWdlbmVyYXRlZC1maWxlcy5z aAkocmV2aXNpb24gMzUxOTgpCisrKyBXZWJLaXQvd2luL1dlYktpdC52Y3Byb2ovYnVpbGQtZ2Vu ZXJhdGVkLWZpbGVzLnNoCSh3b3JraW5nIGNvcHkpCkBAIC02MCwzICs2MCw0IEBAIGV4cG9ydCBX RUJLSVRfT1VUUFVUPSRYRFNUUk9PVAogCiBleHBvcnQgRkVBVFVSRV9ERUZJTkVTPSJFTkFCTEVf WFBBVEggRU5BQkxFX1NWRyIKIG1ha2UgLWYgIiRXRUJLSVQvV2ViS2l0LnZjcHJvai9EZXJpdmVk U291cmNlcy5tYWtlIiAtaiAke05VTUNQVVN9IHx8IGV4aXQgMQorCg== 22470 2008-07-24 19:32:53 -0700 2008-07-29 14:23:15 -0700 First chunk of patch Patch-Chunk1.txt text/plain 18618 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTI4MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDQgQEAKKzIwMDgtMDctMjEgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWFAZ21haWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcvY2hhbmdlc2V0LzM1MjQ0CisKKyAgICAgICAg V0FSTklORzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFOR0VECisKKyAgICAgICAgKiBwYWdl L0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0 eU9iamVjdDo6aXNUZXh0Rm9ybWF0dGluZ0VsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNj ZXNzaWJpbGl0eU9iamVjdDo6aXNMaW5rT3JMaXN0SXRlbUVsZW1lbnQpOgorICAgICAgICAoV2Vi Q29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNGb3JtT3JUYWJsZUVsZW1lbnQpOgorICAgICAg ICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6YWNjRmlyc3RDaGlsZCk6CisgICAgICAg IChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphY2NMYXN0Q2hpbGQpOgorICAgICAgICAo V2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6cHJldmlvdXNBY2Nlc3NpYmlsaXR5U2libGlu Zyk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjpuZXh0QWNjZXNzaWJp bGl0eVNpYmxpbmcpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6c2V0 QWNjZXNzaWJpbGl0eUlEKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6 OnNldEFjY2Vzc2libGVQYXJlbnQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9i amVjdDo6YWRkQ2hpbGRyZW4pOgorICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5o OgorICAgICAgICAoV2ViQ29yZTo6KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlP YmplY3Q6OmFjY2Vzc2liaWxpdHlJRCk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5 T2JqZWN0OjphY2Nlc3NpYmxlUGFyZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxp dHlPYmplY3Q6OmNoaWxkcmVuKToKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlVGV4dEZvcm1hdHRpbmdFbGVtZW50 TmFtZXNIYXNoKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmFjY0ZpcnN0Q2hpbGQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdDo6YWNjTGFzdENoaWxkKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OnByZXZpb3VzQWNjZXNzaWJpbGl0eVNpYmxpbmcpOgorICAgICAgICAoV2ViQ29y ZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6bmV4dEFjY2Vzc2liaWxpdHlTaWJsaW5nKToK KyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzVGV4dEZvcm1h dHRpbmdFbGVtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3Q6OmlzRm9ybU9yVGFibGVFbGVtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50KToKKyAgICAgICAgKFdlYkNv cmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmhlbHBUZXh0KToKKyAgICAgICAgKFdlYkNv cmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRpdGxlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmVsZW1lbnRSZWN0KToKKyAgICAgICAgKFdlYkNv cmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFjY2Vzc2liaWxpdHlJc0lnbm9yZWQpOgor ICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cm9sZVZhbHVlKToK KyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNhblNldEZvY3Vz QXR0cmlidXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmNoaWxkcmVuKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmFkZENoaWxkcmVuKToKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qu aDoKKwogMjAwOC0wNy0yMSAgS2V2aW4gQ2FsaG91biAgPGtjYWxob3VuQGFwcGxlLmNvbT4KIAog ICAgICAgICBSZXZpZXdlZCBieSBBZGVsZS4KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmls aXR5T2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9i amVjdC5jcHAJKHJldmlzaW9uIDM1MTk4KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlP YmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC05NDYsNiArOTQ2LDIxIEBAIEFjY2Vzc2liaWxp dHlPYmplY3QqIEFjY2Vzc2liaWxpdHlPYmplY3QKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBB Y2Nlc3NpYmlsaXR5T2JqZWN0Ojppc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0Cit7Cisg ICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmlzTGlua09y TGlzdEl0ZW1FbGVtZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wg QWNjZXNzaWJpbGl0eU9iamVjdDo6aXNGb3JtT3JUYWJsZUVsZW1lbnQoKSBjb25zdAoreworICAg IHJldHVybiBmYWxzZTsKK30KKwogQWNjZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0eU9iamVj dDo6cm9sZVZhbHVlKCkgY29uc3QKIHsKICAgICByZXR1cm4gVW5rbm93blJvbGU7CkBAIC05Nzcs NyArOTkyLDcgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpjaGlsZHJlbkNoYW5nZQogICAg IHJldHVybjsKIH0KIAotdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGlsZHJlbigpCit2 b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QKIHsKIH0KIApJbmRl eDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCShyZXZpc2lvbiAzNTE5OCkKKysrIFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0NCw3ICsx NDQsMTEgQEAgZW51bSBBY2Nlc3NpYmlsaXR5Um9sZSB7CiAgICAgV2ViQXJlYVJvbGUsCiAgICAg SGVhZGluZ1JvbGUsCiAgICAgTGlzdEJveFJvbGUsCi0gICAgTGlzdEJveE9wdGlvblJvbGUKKyAg ICBMaXN0Qm94T3B0aW9uUm9sZSwKKyAgICBMaXN0SXRlbVJvbGUsCisgICAgRG9jdW1lbnRSb2xl LAorICAgIENlbGxSb2xlLAorICAgIFNlcGFyYXRvclJvbGUKIH07CiAKIHN0cnVjdCBWaXNpYmxl UG9zaXRpb25SYW5nZSB7CkBAIC0yNjIsNyArMjY2LDExIEBAIHB1YmxpYzoKIAogICAgIHZpcnR1 YWwgQWNjZXNzaWJpbGl0eVJvbGUgcm9sZVZhbHVlKCkgY29uc3Q7CiAgICAgdmlydHVhbCBBWE9i amVjdENhY2hlKiBheE9iamVjdENhY2hlKCkgY29uc3Q7Ci0gICAgCisKKyAgICB2aXJ0dWFsIGJv b2wgaXNUZXh0Rm9ybWF0dGluZ0VsZW1lbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNM aW5rT3JMaXN0SXRlbUVsZW1lbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNGb3JtT3JU YWJsZUVsZW1lbnQoKSBjb25zdDsKKwogICAgIHZpcnR1YWwgSFRNTEFuY2hvckVsZW1lbnQqIGFu Y2hvckVsZW1lbnQoKSBjb25zdDsKICAgICB2aXJ0dWFsIEVsZW1lbnQqIGFjdGlvbkVsZW1lbnQo KSBjb25zdDsKICAgICB2aXJ0dWFsIEludFJlY3QgYm91bmRpbmdCb3hSZWN0KCkgY29uc3Q7CkBA IC0zMDksOCArMzE3LDggQEAgcHVibGljOgogICAgIGJvb2wgcGVyZm9ybURlZmF1bHRBY3Rpb24o KSBjb25zdCB7IHJldHVybiBwcmVzcygpOyB9CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGNoaWxk cmVuQ2hhbmdlZCgpOwotICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yJiBjaGlsZHJlbigpIHsgcmV0dXJuIG1fY2hpbGRyZW47IH0KLSAgICB2aXJ0dWFsIHZvaWQg YWRkQ2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZl Y3RvciYgY2hpbGRyZW4oKSBjb25zdCB7IHJldHVybiBtX2NoaWxkcmVuOyB9CisgICAgdmlydHVh bCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIGhhc0NoaWxkcmVu KCkgY29uc3QgeyByZXR1cm4gbV9oYXZlQ2hpbGRyZW47IH07CiAgICAgdmlydHVhbCB2b2lkIHNl bGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAgICAgdmlydHVh bCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsKQEAg LTM4Miw3ICszOTAsNyBAQCBwdWJsaWM6CiAKIHByb3RlY3RlZDoKICAgICB1bnNpZ25lZCBtX2lk OwotICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2NoaWxkcmVuOworICAgIG11dGFi bGUgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIG1fY2hpbGRyZW47CiAgICAgbXV0YWJsZSBi b29sIG1faGF2ZUNoaWxkcmVuOwogICAgIAogICAgIHZpcnR1YWwgdm9pZCBjbGVhckNoaWxkcmVu KCk7CkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCShy ZXZpc2lvbiAzNTE5OCkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTA5LDYgKzEwOSw1NSBAQCB2b2lkIEFjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3Q6OmRldGFjaCgpCiAgICAgbV9yZW5kZXJlciA9IDA7ICAgIAogfQogCitz dGF0aWMgSGFzaFNldDxTdHJpbmcsIENhc2VGb2xkaW5nSGFzaD4qIGNyZWF0ZVRleHRGb3JtYXR0 aW5nRWxlbWVudE5hbWVzSGFzaCgpIAoreworICAgIHN0YXRpYyBIYXNoU2V0PFN0cmluZywgQ2Fz ZUZvbGRpbmdIYXNoPiBlbGVtZW50SGFzaFNldDsKKyAgICBpZiAoZWxlbWVudEhhc2hTZXQuaXNF bXB0eSgpKSB7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChiVGFnLnRvU3RyaW5nKCkpOwor ICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoYmRvVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBl bGVtZW50SGFzaFNldC5hZGQoYmlnVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFz aFNldC5hZGQoY2l0ZVRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRk KGNvZGVUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChkZm5UYWcu dG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChkZWxUYWcudG9TdHJpbmco KSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChpbnNUYWcudG9TdHJpbmcoKSk7CisgICAg ICAgIGVsZW1lbnRIYXNoU2V0LmFkZChlbVRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVu dEhhc2hTZXQuYWRkKGZvbnRUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0 LmFkZChpVGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoc1RhZy50 b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHNhbXBUYWcudG9TdHJpbmco KSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChzbWFsbFRhZy50b1N0cmluZygpKTsKKyAg ICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHNwYW5UYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVs ZW1lbnRIYXNoU2V0LmFkZChzdHJpa2VUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRI YXNoU2V0LmFkZChzdHJvbmdUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0 LmFkZChzdWJUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChzdXBU YWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZCh0ZXh0YXJlYVRhZy50 b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHR0VGFnLnRvU3RyaW5nKCkp OworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQodVRhZy50b1N0cmluZygpKTsKKyAgICAgICAg ZWxlbWVudEhhc2hTZXQuYWRkKHByZVRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhh c2hTZXQuYWRkKGRpdlRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRk KGNlbnRlclRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKHBUYWcu dG9TdHJpbmcoKSk7CisgICAgfQorICAgIHJldHVybiAmZWxlbWVudEhhc2hTZXQ7Cit9CisKK3N0 YXRpYyBIYXNoU2V0PFN0cmluZywgQ2FzZUZvbGRpbmdIYXNoPiogY3JlYXRlTGlua0FuZExpc3RF bGVtZW50c0hhc2goKSAKK3sKKyAgICBzdGF0aWMgSGFzaFNldDxTdHJpbmcsIENhc2VGb2xkaW5n SGFzaD4gZWxlbWVudEhhc2hTZXQ7CisKKyAgICBpZiAoZWxlbWVudEhhc2hTZXQuaXNFbXB0eSgp KSB7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChhYmJyVGFnLnRvU3RyaW5nKCkpOworICAg ICAgICBlbGVtZW50SGFzaFNldC5hZGQoYWNyb255bVRhZy50b1N0cmluZygpKTsKKyAgICAgICAg ZWxlbWVudEhhc2hTZXQuYWRkKHFUYWcudG9TdHJpbmcoKSk7CisgICAgICAgIGVsZW1lbnRIYXNo U2V0LmFkZChsaVRhZy50b1N0cmluZygpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGRk VGFnLnRvU3RyaW5nKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQoZHRUYWcudG9TdHJp bmcoKSk7CisgICAgfQorICAgIHJldHVybiAmZWxlbWVudEhhc2hTZXQ7Cit9CisKIEFjY2Vzc2li aWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmZpcnN0Q2hpbGQoKSBjb25z dAogewogICAgIGlmICghbV9yZW5kZXJlcikKQEAgLTQwMyw3ICs0NTIsNDUgQEAgYm9vbCBBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc0hlYWRpbgogewogICAgIHJldHVybiByb2xlVmFsdWUo KSA9PSBIZWFkaW5nUm9sZTsKIH0KLSAgICAKKworYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0Ojppc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0Cit7CisgICAgSGFzaFNldDxTdHJp bmcsIENhc2VGb2xkaW5nSGFzaD4qIHRleHRGb3JtYXR0aW5nRWxlbWVudE5hbWVzID0gY3JlYXRl VGV4dEZvcm1hdHRpbmdFbGVtZW50TmFtZXNIYXNoKCk7CisKKyAgICBpZiAobV9yZW5kZXJlciAm JiBtX3JlbmRlcmVyLT5lbGVtZW50KCkpCisgICAgICAgIHJldHVybiB0ZXh0Rm9ybWF0dGluZ0Vs ZW1lbnROYW1lcy0+Y29udGFpbnMobV9yZW5kZXJlci0+ZWxlbWVudCgpLT5ub2RlTmFtZSgpKTsK KworICAgIHJldHVybiBmYWxzZTsKKworfQorCitib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3Q6OmlzRm9ybU9yVGFibGVFbGVtZW50KCkgY29uc3QKK3sKKyAgICBpZiAoIW1fcmVuZGVyZXIg fHwgIW1fcmVuZGVyZXItPmVsZW1lbnQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAg aWYgKG1fcmVuZGVyZXItPmVsZW1lbnQoKS0+aGFzVGFnTmFtZShmb3JtVGFnKQorICAgICAgICB8 fCAgbV9yZW5kZXJlci0+aXNUYWJsZSgpCisgICAgICAgIHx8ICBtX3JlbmRlcmVyLT5pc1RhYmxl Q2VsbCgpCisgICAgICAgIHx8ICBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUodGhU YWcpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVybiBmYWxzZTsKKworfQorCiti b29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50KCkg Y29uc3QKK3sKKyAgICBIYXNoU2V0PFN0cmluZywgQ2FzZUZvbGRpbmdIYXNoPiogZWxlbWVudEhh c2hTZXQgPSBjcmVhdGVMaW5rQW5kTGlzdEVsZW1lbnRzSGFzaCgpOworCisgICAgaWYgKG1fcmVu ZGVyZXIgJiYgbV9yZW5kZXJlci0+ZWxlbWVudCgpKQorICAgICAgICByZXR1cm4gbV9yZW5kZXJl ci0+ZWxlbWVudCgpLT5pc0xpbmsoKSAKKyAgICAgICAgICAgIHx8IGVsZW1lbnRIYXNoU2V0LT5j b250YWlucyhtX3JlbmRlcmVyLT5lbGVtZW50KCktPm5vZGVOYW1lKCkpOworCisgICAgICAgIHJl dHVybiBmYWxzZTsKKworfQorCiBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlu aygpIGNvbnN0CiB7CiAgICAgcmV0dXJuIHJvbGVWYWx1ZSgpID09IFdlYkNvcmVMaW5rUm9sZTsK QEAgLTgzMCwxNyArOTE3LDM1IEBAIFN0cmluZyBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0 aXRsZSgKICAgICAgICAgaWYgKGxhYmVsKQogICAgICAgICAgICAgcmV0dXJuIGxhYmVsLT5pbm5l clRleHQoKTsKICAgICB9Ci0gICAgCisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxlbWVudCgpLT5p c0xpbmsoKSB8fCBpc0hlYWRpbmcoKSkgeworICAgICAgICBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hp bGRyZW5WZWN0b3ImIGNoaWxkcmVuVmVjdG9yID0gY2hpbGRyZW4oKTsKKyAgICAgICAgVmVjdG9y PFVDaGFyPiBlbGVtZW50VGV4dDsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGNo aWxkcmVuVmVjdG9yLnNpemUoKTsgKytpKSB7CisgICAgICAgICAgICBlbGVtZW50VGV4dC5hcHBl bmQoJyAnKTsKKyAgICAgICAgICAgIFN0cmluZyBlbGVtZW50VGl0bGUgPSBjaGlsZHJlblZlY3Rv cltpXS0+dGl0bGUoKTsKKyAgICAgICAgICAgIGFwcGVuZChlbGVtZW50VGV4dCwgZWxlbWVudFRp dGxlKTsKKyAgICAgICAgfQorCisgICAgICAgIHJldHVybiBTdHJpbmc6OmFkb3B0KGVsZW1lbnRU ZXh0KS5zdHJpcFdoaXRlU3BhY2UoKTsKKyAgICAgICAgCisgICAgfQorCiAgICAgaWYgKHJvbGVW YWx1ZSgpID09IEJ1dHRvblJvbGUKICAgICAgICAgfHwgYXJpYVJvbGUgPT0gTGlzdEJveE9wdGlv blJvbGUKICAgICAgICAgfHwgYXJpYVJvbGUgPT0gTWVudUl0ZW1Sb2xlCi0gICAgICAgIHx8IGFy aWFSb2xlID09IE1lbnVCdXR0b25Sb2xlCi0gICAgICAgIHx8IGlzSGVhZGluZygpKQorICAgICAg ICB8fCBhcmlhUm9sZSA9PSBNZW51QnV0dG9uUm9sZSkKICAgICAgICAgcmV0dXJuIHRleHRVbmRl ckVsZW1lbnQoKTsKLSAgICAKLSAgICBpZiAoaXNMaW5rKCkpCisKKyAgICBpZiAoaXNJbWFnZSgp KSB7CisgICAgICAgIE5vZGUqIG5vZGUgPSBtX3JlbmRlcmVyLT5lbGVtZW50KCk7CisgICAgICAg IGlmIChub2RlICYmIG5vZGUtPmlzRWxlbWVudE5vZGUoKSkKKyAgICAgICAgICAgIHJldHVybiBz dGF0aWNfY2FzdDxFbGVtZW50Kj4obm9kZSktPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICB9 CisKKyAgICBpZiAobV9yZW5kZXJlci0+aXNUZXh0KCkpCiAgICAgICAgIHJldHVybiB0ZXh0VW5k ZXJFbGVtZW50KCk7Ci0gICAgCisKICAgICByZXR1cm4gU3RyaW5nKCk7CiB9CiAKQEAgLTEwNzYs MjUgKzExODEsMzkgQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphY2Nlc3NpYgog ICAgICAgICAKICAgICBBY2Nlc3NpYmlsaXR5Um9sZSBhcmlhUm9sZSA9IGFyaWFSb2xlQXR0cmli dXRlKCk7CiAgICAgaWYgKGFyaWFSb2xlID09IFRleHRBcmVhUm9sZSB8fCBhcmlhUm9sZSA9PSBT dGF0aWNUZXh0Um9sZSkgewotICAgICAgICBTdHJpbmcgYXJpYVRleHQgPSB0ZXh0KCk7Ci0gICAg ICAgIHJldHVybiBhcmlhVGV4dC5pc051bGwoKSB8fCBhcmlhVGV4dC5pc0VtcHR5KCk7CisgICAg ICAgIHJldHVybiB0ZXh0KCkuY29udGFpbnNPbmx5V2hpdGVzcGFjZSgpOwogICAgIH0gICAgCiAg ICAgCi0gICAgLy8gTk9URTogQlJzIGFsd2F5cyBoYXZlIHRleHQgYm94ZXMgbm93LCBzbyB0aGUg dGV4dCBib3ggY2hlY2sgaGVyZSBjYW4gYmUgcmVtb3ZlZAorCiAgICAgaWYgKG1fcmVuZGVyZXIt PmlzVGV4dCgpKSB7CiAgICAgICAgIC8vIHN0YXRpYyB0ZXh0IGJlbmVhdGggTWVudUl0ZW1zIGFu ZCBNZW51QnV0dG9ucyBhcmUganVzdCByZXBvcnRlZCBhbG9uZyB3aXRoIHRoZSBtZW51IGl0ZW0s IHNvIGl0J3MgaWdub3JlZCBvbiBhbiBpbmRpdmlkdWFsIGxldmVsCi0gICAgICAgIGlmIChwYXJl bnRPYmplY3RVbmlnbm9yZWQoKS0+YXJpYVJvbGVBdHRyaWJ1dGUoKSA9PSBNZW51SXRlbVJvbGUg fHwKLSAgICAgICAgICAgIHBhcmVudE9iamVjdFVuaWdub3JlZCgpLT5hcmlhUm9sZUF0dHJpYnV0 ZSgpID09IE1lbnVCdXR0b25Sb2xlKQorICAgICAgICBpZiAodGV4dFVuZGVyRWxlbWVudCgpLmNv bnRhaW5zT25seVdoaXRlc3BhY2UoKSkKICAgICAgICAgICAgIHJldHVybiB0cnVlOwotICAgICAg ICAgcmV0dXJuIG1fcmVuZGVyZXItPmlzQlIoKSB8fCAhc3RhdGljX2Nhc3Q8UmVuZGVyVGV4dCo+ KG1fcmVuZGVyZXIpLT5maXJzdFRleHRCb3goKTsKKyAgICAgICAgQWNjZXNzaWJpbGl0eVJvbGUg cm9sZSA9IHBhcmVudE9iamVjdFVuaWdub3JlZCgpLT5hcmlhUm9sZUF0dHJpYnV0ZSgpOwkJCisg ICAgICAgIHJldHVybiByb2xlID09IE1lbnVJdGVtUm9sZSB8fCByb2xlID09IE1lbnVCdXR0b25S b2xlOwogICAgIH0KICAgICAKICAgICBpZiAoaXNIZWFkaW5nKCkpCiAgICAgICAgIHJldHVybiBm YWxzZTsKLSAgICAKLSAgICBpZiAoaXNMaW5rKCkpCisKKyAgICBpZiAoaXNUZXh0Rm9ybWF0dGlu Z0VsZW1lbnQoKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBpZiAoaXNMaXN0RWxlbWVu dChtX3JlbmRlcmVyLT5lbGVtZW50KCkpKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgCisK KyAgICBpZiAoaXNGb3JtT3JUYWJsZUVsZW1lbnQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor CisgICAgaWYgKGlzTGlua09yTGlzdEl0ZW1FbGVtZW50KCkpCisgICAgICAgIHJldHVybiBjaGls ZHJlbigpLmlzRW1wdHkoKTsKKworICAgIGlmIChtX3JlbmRlcmVyLT5lbGVtZW50KCkgJiYgbV9y ZW5kZXJlci0+ZWxlbWVudCgpLT5oYXNUYWdOYW1lKGh0bWxUYWcpKQorICAgICAgICByZXR1cm4g dHJ1ZTsKKworICAgIGlmIChtX3JlbmRlcmVyLT5lbGVtZW50KCkgJiYgbV9yZW5kZXJlci0+ZWxl bWVudCgpLT5oYXNUYWdOYW1lKGJvZHlUYWcpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKwogICAg IC8vIGFsbCBjb250cm9scyBhcmUgYWNjZXNzaWJsZQogICAgIGlmIChpc0NvbnRyb2woKSkKICAg ICAgICAgcmV0dXJuIGZhbHNlOwpAQCAtMTEwNCw4ICsxMjIzLDEyIEBAIGJvb2wgQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6YWNjZXNzaWIKICAgICBpZiAobm9kZSAmJiBub2RlLT5oYXNUYWdO YW1lKGxhYmVsVGFnKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIAotICAgIGlmIChtX3Jl bmRlcmVyLT5pc0Jsb2NrRmxvdygpICYmIG1fcmVuZGVyZXItPmNoaWxkcmVuSW5saW5lKCkpCi0g ICAgICAgIHJldHVybiAhc3RhdGljX2Nhc3Q8UmVuZGVyQmxvY2sqPihtX3JlbmRlcmVyKS0+Zmly c3RMaW5lQm94KCkgJiYgIW1vdXNlQnV0dG9uTGlzdGVuZXIoKTsKKyAgICBpZiAobV9yZW5kZXJl ci0+aXNCbG9ja0Zsb3coKSkgeworICAgICAgICByZXR1cm4gbV9yZW5kZXJlci0+aXNBbm9ueW1v dXNCbG9jaygpOworICAgIH0KKworICAgIGlmIChtX3JlbmRlcmVyLT5pc0lubGluZUZsb3coKSkK KyAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgCiAgICAgLy8gaWdub3JlIGltYWdlcyBzZWVtaW5n bHkgdXNlZCBhcyBzcGFjZXJzCiAgICAgaWYgKGlzSW1hZ2UoKSkgewpAQCAtMTk5OCwxMCArMjEy MSwyMCBAQCBBY2Nlc3NpYmlsaXR5Um9sZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgICAg IHJldHVybiBhcmlhUm9sZTsKICAgICAKICAgICBpZiAobm9kZSAmJiBub2RlLT5pc0xpbmsoKSkg ewotICAgICAgICBpZiAobV9yZW5kZXJlci0+aXNJbWFnZSgpKQorICAgICAgICBpZiAoaXNOYXRp dmVJbWFnZSgpKQogICAgICAgICAgICAgcmV0dXJuIEltYWdlTWFwUm9sZTsKICAgICAgICAgcmV0 dXJuIFdlYkNvcmVMaW5rUm9sZTsKICAgICB9CisKKyAgICBpZiAobm9kZSAmJiBub2RlLT5pc0Rv Y3VtZW50Tm9kZSgpKQorICAgICAgICByZXR1cm4gRG9jdW1lbnRSb2xlOworCisgICAgaWYgKG1f cmVuZGVyZXItPmlzVGFibGUoKSkKKyAgICAgICAgcmV0dXJuIFRhYmxlUm9sZTsKKworICAgIGlm IChtX3JlbmRlcmVyLT5pc1RhYmxlQ2VsbCgpIHx8IChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUo dGhUYWcpKSkKKyAgICAgICAgcmV0dXJuIENlbGxSb2xlOworCiAgICAgaWYgKG1fcmVuZGVyZXIt PmlzTGlzdE1hcmtlcigpKQogICAgICAgICByZXR1cm4gTGlzdE1hcmtlclJvbGU7CiAgICAgaWYg KG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShidXR0b25UYWcpKQpAQCAtMjAzMSw3ICsyMTY0LDcg QEAgQWNjZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0eVJlbmRlck9iagogICAgICAgICBpZiAo aW5wdXQtPmlzVGV4dEJ1dHRvbigpKQogICAgICAgICAgICAgcmV0dXJuIEJ1dHRvblJvbGU7CiAg ICAgfQotCisgICAgCiAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShidXR0b25UYWcp KQogICAgICAgICByZXR1cm4gQnV0dG9uUm9sZTsKIApAQCAtMjA0NCw3ICsyMTc3LDE4IEBAIEFj Y2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmoKICAgICBpZiAoaGVhZGluZ0xl dmVsKG1fcmVuZGVyZXItPmVsZW1lbnQoKSkgIT0gMCkKICAgICAgICAgcmV0dXJuIEhlYWRpbmdS b2xlOwogICAgIAotICAgIGlmIChtX3JlbmRlcmVyLT5pc0Jsb2NrRmxvdygpIHx8IChub2RlICYm IG5vZGUtPmhhc1RhZ05hbWUobGFiZWxUYWcpKSkKKyAgICBpZihtX3JlbmRlcmVyLT5pc0xpc3RJ dGVtKCkpCisgICAgICAgIHJldHVybiBMaXN0SXRlbVJvbGU7CisKKyAgICBpZihtX3JlbmRlcmVy LT5pc0hSKCkpCisgICAgICAgIHJldHVybiBTZXBhcmF0b3JSb2xlOworCisgICAgaWYoaXNMaXN0 RWxlbWVudChub2RlKSkKKyAgICAgICAgcmV0dXJuIExpc3RSb2xlOworCisgICAgaWYgKG1fcmVu ZGVyZXItPmlzQmxvY2tGbG93KCkgfHwgbm9kZS0+aGFzVGFnTmFtZShhYmJyVGFnKQorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx8IG5vZGUtPmhhc1RhZ05hbWUoYWNyb255bVRh ZykgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfHwgbm9kZS0+aGFzVGFnTmFt ZShxVGFnKSkKICAgICAgICAgcmV0dXJuIEdyb3VwUm9sZTsKICAgICAKICAgICByZXR1cm4gVW5r bm93blJvbGU7CkBAIC0yMDkwLDYgKzIyMzQsOCBAQCBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmNhblNldEZvCiAgICAgICAgIGNhc2UgUG9wVXBCdXR0b25Sb2xlOgogICAgICAgICBj YXNlIENoZWNrQm94Um9sZToKICAgICAgICAgY2FzZSBSYWRpb0J1dHRvblJvbGU6CisgICAgICAg IGNhc2UgTGlzdEl0ZW1Sb2xlOgorICAgICAgICBjYXNlIFNlcGFyYXRvclJvbGU6CiAgICAgICAg ICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICAgY2FzZSBVbmtub3duUm9sZToKICAgICAgICAgY2Fz ZSBTbGlkZXJSb2xlOgpAQCAtMjEzOCw2ICsyMjg0LDggQEAgYm9vbCBBY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0OjpjYW5TZXRGbwogICAgICAgICBjYXNlIEhlYWRpbmdSb2xlOgogICAgICAgICBj YXNlIExpc3RCb3hSb2xlOgogICAgICAgICBjYXNlIExpc3RCb3hPcHRpb25Sb2xlOgorICAgICAg ICBjYXNlIERvY3VtZW50Um9sZToKKyAgICAgICAgY2FzZSBDZWxsUm9sZToKICAgICAgICAgICAg IHJldHVybiBmYWxzZTsKICAgICB9CiAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CkBAIC0yMTY4 LDE0ICsyMzE2LDE0IEBAIHZvaWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4K ICAgICB9CiB9CiAKLWNvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGls ZHJlblZlY3RvciYgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4oKQorY29uc3Qg QWNjZXNzaWJpbGl0eU9iamVjdDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0OjpjaGlsZHJlbigpIGNvbnN0CiB7CiAgICAgaWYgKCFtX2hhdmVD aGlsZHJlbikKICAgICAgICAgYWRkQ2hpbGRyZW4oKTsKICAgICByZXR1cm4gbV9jaGlsZHJlbjsK IH0KIAotdm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpCit2b2lk IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QKIHsKICAgICAv LyBJZiB0aGUgbmVlZCB0byBhZGQgbW9yZSBjaGlsZHJlbiBpbiBhZGRpdGlvbiB0byBleGlzdGlu ZyBjaGlsZHJlbiBhcmlzZXMsIAogICAgIC8vIGNoaWxkcmVuQ2hhbmdlZCBzaG91bGQgaGF2ZSBi ZWVuIGNhbGxlZCwgbGVhdmluZyB0aGUgb2JqZWN0IHdpdGggbm8gY2hpbGRyZW4uCkluZGV4OiBX ZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgJKHJldmlzaW9uIDM1MTk4KQor KysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAkod29ya2luZyBjb3B5 KQpAQCAtMTMwLDcgKzEzMCw5IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldEFyaWFSb2xlKCk7CiAg ICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdDsKICAgICB2aXJ0 dWFsIEFYT2JqZWN0Q2FjaGUqIGF4T2JqZWN0Q2FjaGUoKSBjb25zdDsKLSAgICAKKyAgICB2aXJ0 dWFsIGJvb2wgaXNUZXh0Rm9ybWF0dGluZ0VsZW1lbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJv b2wgaXNMaW5rT3JMaXN0SXRlbUVsZW1lbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNG b3JtT3JUYWJsZUVsZW1lbnQoKSBjb25zdDsKICAgICB2aXJ0dWFsIEVsZW1lbnQqIGFjdGlvbkVs ZW1lbnQoKSBjb25zdDsKICAgICBFbGVtZW50KiBtb3VzZUJ1dHRvbkxpc3RlbmVyKCkgY29uc3Q7 CiAgICAgRnJhbWVWaWV3KiBmcmFtZVZpZXdJZlJlbmRlclZpZXcoKSBjb25zdDsKQEAgLTE3Miw3 ICsxNzQsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGdldERvY3VtZW50TGlua3MoQWNj ZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJikgY29uc3Q7CiAgICAgdmlydHVhbCBGcmFtZVZpZXcq IGRvY3VtZW50RnJhbWVWaWV3KCkgY29uc3Q7CiAgICAgCi0gICAgdmlydHVhbCBjb25zdCBBY2Nl c3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCk7CisgICAgdmlydHVhbCBjb25zdCBB Y2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgY29uc3Q7CiAgICAgCiAgICAg dmlydHVhbCB2b2lkIHNldEZvY3VzZWQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lkIHNldFNlbGVj dGVkVGV4dFJhbmdlKGNvbnN0IFBsYWluVGV4dFJhbmdlJik7CkBAIC0xODAsNyArMTgyLDcgQEAg cHVibGljOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBkZXRhY2goKTsKICAgICB2aXJ0dWFsIHZv aWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCk7Cisg ICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIHNl bGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAgICAgdmlydHVh bCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsKICAg ICB2aXJ0dWFsIGJvb2wgc2hvdWxkRm9jdXNBY3RpdmVEZXNjZW5kYW50KCkgY29uc3Q7CkluZGV4 OiBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJpbmcuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJpbmcuaAkocmV2aXNpb24gMzUxOTgpCisr KyBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJpbmcuaAkod29ya2luZyBjb3B5KQpA QCAtMTY4LDYgKzE2OCw4IEBAIHB1YmxpYzoKIAogICAgIFN0cmluZ0ltcGwqIGltcGwoKSBjb25z dCB7IHJldHVybiBtX2ltcGwuZ2V0KCk7IH0KIAorICAgIGJvb2wgY29udGFpbnNPbmx5V2hpdGVz cGFjZSgpIGNvbnN0IHsgcmV0dXJuIGlzTnVsbCgpIHx8IG1faW1wbC0+Y29udGFpbnNPbmx5V2hp dGVzcGFjZSgpOyB9CisKICNpZiBQTEFURk9STShDRikKICAgICBTdHJpbmcoQ0ZTdHJpbmdSZWYp OwogICAgIENGU3RyaW5nUmVmIGNyZWF0ZUNGU3RyaW5nKCkgY29uc3Q7CkluZGV4OiBXZWJLaXQv d2luL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0NoYW5nZUxvZwkocmV2aXNp b24gMzUyODApCisrKyBXZWJLaXQvd2luL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDEzIEBACisyMDA4LTA3LTIxICBTYW5rYXIgVGFuZ3V0dXJpICA8c2Fua2FyYWRpdHlhQGdt YWlsLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICAqIEFjY2Vzc2libGVCYXNlLmNwcDoKKyAgICAgICAgKEFjY2Vzc2libGVCYXNlOjpnZXRfYWNj UGFyZW50KToKKyAgICAgICAgKEFjY2Vzc2libGVCYXNlOjphY2NOYXZpZ2F0ZSk6CisgICAgICAg IChNU0FBUm9sZSk6CisgICAgICAgICogV2ViS2l0LnZjcHJvai9idWlsZC1nZW5lcmF0ZWQtZmls ZXMuc2g6CisKIDIwMDgtMDctMTUgIEFkYW0gUm9iZW4gIDxhcm9iZW5AYXBwbGUuY29tPgogCiAg ICAgICAgIEFkZCBXZWJLaXRbU2V0XVNob3VsZFVzZUZvbnRTbW9vdGhpbmcgZnVuY3Rpb25zCklu ZGV4OiBXZWJLaXQvd2luL0FjY2Vzc2libGVCYXNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQv d2luL0FjY2Vzc2libGVCYXNlLmNwcAkocmV2aXNpb24gMzUxOTgpCisrKyBXZWJLaXQvd2luL0Fj Y2Vzc2libGVCYXNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTYzLDYgKzU2MywxNCBAQCBzdGF0 aWMgbG9uZyBNU0FBUm9sZShBY2Nlc3NpYmlsaXR5Um9sZSByCiAgICAgICAgIGNhc2UgV2ViQ29y ZTo6SW1hZ2VNYXBSb2xlOgogICAgICAgICBjYXNlIFdlYkNvcmU6OkltYWdlUm9sZToKICAgICAg ICAgICAgIHJldHVybiBST0xFX1NZU1RFTV9HUkFQSElDOworICAgICAgICBjYXNlIFdlYkNvcmU6 OkRvY3VtZW50Um9sZToKKyAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fRE9DVU1FTlQ7Cisg ICAgICAgIGNhc2UgV2ViQ29yZTo6Q2VsbFJvbGU6CisgICAgICAgICAgcmV0dXJuIFJPTEVfU1lT VEVNX0NFTEw7CisgICAgICAgIGNhc2UgV2ViQ29yZTo6TGlzdEl0ZW1Sb2xlOgorICAgICAgICAg IHJldHVybiBST0xFX1NZU1RFTV9MSVNUSVRFTTsKKyAgICAgICAgY2FzZSBXZWJDb3JlOjpTZXBh cmF0b3JSb2xlOgorICAgICAgICAgIHJldHVybiBST0xFX1NZU1RFTV9TRVBBUkFUT1I7CiAgICAg ICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAvLyBUaGlzIGlzIHRoZSBkZWZhdWx0IHJvbGUgZm9y IE1TQUEuCiAgICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fQ0xJRU5UOwpJbmRleDogV2Vi S2l0L3dpbi9XZWJLaXQudmNwcm9qL2J1aWxkLWdlbmVyYXRlZC1maWxlcy5zaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXQvd2luL1dlYktpdC52Y3Byb2ovYnVpbGQtZ2VuZXJhdGVkLWZpbGVzLnNoCShy ZXZpc2lvbiAzNTE5OCkKKysrIFdlYktpdC93aW4vV2ViS2l0LnZjcHJvai9idWlsZC1nZW5lcmF0 ZWQtZmlsZXMuc2gJKHdvcmtpbmcgY29weSkKQEAgLTYwLDMgKzYwLDQgQEAgZXhwb3J0IFdFQktJ VF9PVVRQVVQ9JFhEU1RST09UCiAKIGV4cG9ydCBGRUFUVVJFX0RFRklORVM9IkVOQUJMRV9YUEFU SCBFTkFCTEVfU1ZHIgogbWFrZSAtZiAiJFdFQktJVC9XZWJLaXQudmNwcm9qL0Rlcml2ZWRTb3Vy Y2VzLm1ha2UiIC1qICR7TlVNQ1BVU30gfHwgZXhpdCAxCisK 22471 2008-07-24 19:34:26 -0700 2008-07-24 19:34:26 -0700 Comments for all the changes that I have done My comments application/octet-stream 6746 sankaraditya+bugzilla Tm90ZTogSSBoYXZlIHdvcmtlZCBvbiBGaXJlZm94IDIuMC4wLjE0LiBJIGhhdmUgZW5oYW5jZWQg d2Via2l0IGhldXJpc3RpY3MgYmV0dGVyIHRoYW4gb3IgZXF1YWwgdG8NCiAgICAgIEZpcmVmb3gg Mi4wLjAuMTQuIEkgaGF2ZSBkb25lIGFsbCB0aGUgY29tcGFyaXNvbnMgd2l0aCByZXNwZWN0IHRv IEZpcmVmb3ggMi4wLjAuMTQgb25seS4NCg0KQWNjZXNzaWJsZUJhc2UuY3BwOg0KLS0tLS0tLS0t LS0tLS0tLS0tLQ0KSW4gRmlyZWZveCAyLjAuMC4xNCwgSSBmb3VuZCBvdXQgZm91ciBpbXBvcnRh bnQgcm9sZXMgdGhhdCBhcmUgbWlzc2luZyBpbiBXZWJraXQuIFRoZXkgYXJlDQogICAgMS4gRG9j dW1lbnQgUm9sZSA6IFdoZW4gYSB3ZWJwYWdlIGlzIG9wZW5lZCBpbiBhIGJyb3dzZXIsIGFuZCBp bnNwZWN0MzIgdG9vbCBpcyB1c2VkIHRvIHZpZXcgdGhlIA0KICAgICAgIEFjY2Vzc2liaWxpdHkg dHJlZSB0aGF0IGlzIGV4cG9zZWQsIHRoZSByb290IGVsZW1lbnQgd2lsbCBoYXZlIHRoZSByb2xl IHZhbHVlIHNldCB0byAiRG9jdW1lbnQiLg0KICAgIDIuIENlbGwgUm9sZSAgICAgOiBJbiBhIHRh YmxlLCBldmVyeSBjZWxsIChub2RlIGNvcnJlc3BvbmRpbmcgdG8gPHRkPiwgPHRoPiB0YWcpIHRo YXQgaXMgZXhwb3NlZCBoYXMgIkNlbGwgUm9sZSIuDQogICAgMy4gTGlzdEl0ZW0gUm9sZSA6IElu IGEgbGlzdCwgZXZlcnkgaXRlbSAobm9kZSBjb3JyZXNwb25kaW5nIHRvIDxsaT4gdGFnKSB0aGF0 IGlzIGV4cG9zZWQgaGFzICJsaXN0IGl0ZW0gUm9sZSIuDQogICAgNC4gU2VwYXJhdG9yIFJvbGU6 IE5vZGUgY29ycmVzcG9uZGluZyB0byA8aHI+IHRhZyBoYXMgIlNlcGFyYXRvciByb2xlIi4NCg0K SSBoYXZlIGFkZGVkIGFsbCB0aGUgZm91ciBhYm92ZSBtZW50aW9uZWQgcm9sZXMgdG8gV2ViS2l0 Lg0KDQpBY2Nlc3NpYmlsaXR5T2JqZWN0LmgsIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoN Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQ0KQWxs IGNoYW5nZXMsIHRoYXQgYXJlIHJlcXVpcmVkIHRvIGRlY2xhcmUvc3VwcG9ydCBhYm92ZSBtZW50 aW9uZWQgZm91ciByb2xlcywgYXJlIGFkZGVkIGluIHRoaXMgZmlsZS4NCg0KQWNjZXNzaWJpbGl0 eU9iamVjdC5jcHA6DQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0NCkkgaGF2ZSBhZGRlZCBmZXcg dmlydHVhbCBmdW5jdGlvbnMuIFNvLCBpIGhhdmUgd3JpdHRlbiBlbXB0eSBib2R5IGZvciB0aGVz ZSBmdW5jdGlvbnMgaW4gdGhpcw0KZmlsZS4gRXhhY3QgaW1wbGVtZW50YWlvbiBvZiB0aGVzZSBm dW5jdGlvbnMgY2FuIGJlIGZvdW5kIGluIEFjY2Vzc2libGl0eVJlbmRlck9iamVjdC5jcHAgZmls ZS4NCg0KQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHA6DQotLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0NCldoZW4gSW5zcGVjdDMyIHRvb2wgaXMgdXNlZCB3aXRoIFdlYmtpdCwgYXR0 cmlidXRlIE5hbWUgZm9yIGNlcnRhaW4gbm9kZXMgaXMgbm90IHByb3Blcmx5IHBvcHVsYXRlZC4N CkkgaGF2ZSBlbmhhbmNlZCB0aGUgbG9naWMgdG8gcHJvcGVybHkgcG91cGxhdGUgdGhhdCBhdHRy aWJ1dGUuDQoNCkVuaGFuY2luZyB0aGUgbmFtZSBhdHRyaWJ1dGU6DQotLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tDQoxLiBGb3IgcHVyZSB0ZXh0IG5vZGVzLCB0aXRsZSgpIHNob3VsZCByZXR1 cm4gdGhlIHJhdyB0ZXh0IGNvbnRlbnQgdGhhdCBpcyBwcmVzZW50IGluIHRoYXQgbm9kZS4NCjIu IEZvciBpbWFnZSBub2RlcywgdGl0bGUoKSBzaG91bGQgcmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUg YWx0IGF0dHJpYnV0ZS4NCg0KPGltZyBzcmM9ImltZy5qcGciIGFsdD0iYWx0SW1hZ2UiIC8+OiBG b3IgdGhlIGFib3ZlIG1lbnRpb25lZCBub2RlLCB0aXRsZSgpIHNob3VsZCByZXR1cm4gImFsdElt YWdlIi4NCg0KMy4gRm9yIGxpbmtzIGFuZCBoZWFkaW5nIG5vZGVzLCB0aXRsZSgpIHNob3VsZCBy ZXR1cm4gdGhlIHN0cmluZyB0aGF0IGlzIGZvcm1lZCBieSBjb25jYXRlbmF0aW5nIHRoZQ0KICAg dGl0bGUoKSB2YWx1ZXMgb2YgYWxsIG9mIGl0cyBjaGlsZHJlbi4NCjxhIGhyZWY9Imh0dHA6Ly93 d3cud2Via2l0Lm9yZyI+V2ViS2l0PC9hPiAtPkZvciB0aGlzIG5vZGUsIHRpdGxlKCkgc2hvdWxk IHJldHVybiAiV2ViS2l0Ig0KDQo8YSBocmVmPSJodHRwOi8vd3d3LndlYmtpdC5vcmciPg0KICAg IFRleHQxDQogICAgPGltZyBzcmM9ImltZy5qcGciIGFsdD0iYWx0X0ltYWdlIiAvPg0KICAgIFRl eHQyDQo8L2E+IC0+IEZvciB0aGlzIG5vZGUsIHRpdGxlKCkgc2hvdWxkIHJldHVybiBUZXh0MSth bHRWYWx1ZSgpK1RleHQyID0+ICJUZXh0MSBhbHRfSW1hZ2UgVGV4dDIiDQoNClRoaXMgbWVjaGFu aXNtIGlzIHZpc2libGUgaW4gRmlyZWZveCAyLjAuMC4xNC4gU28sIEkgaGF2ZSBpbXBsZW1lbnRl ZCB0aGlzIGluIFdlYktpdC4NCg0KU2FtZSBwcmluY2lwbGUgaXMgYXBwbGljYWJsZSBmb3IgSGVh ZGVycyBhbHNvLg0KDQpFbmhhbmNpbmcgcm9sZSBhdHRyaWJ1dGU6DQotLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tDQpJIGhhdmUgbWFkZSBjaGFuZ2VzIHRvIHBvcHVsYXRlIHRoZSByb2xlIGF0dHJp YnV0ZSBhbHNvLg0KMS4gV2ViS2l0IGRvZXNuJ3QgcG9wdWxhdGUgdGhlIHJvbGUgYXR0cmlidXRl IGZvciA8dGFibGU+IHRhZ3MuIEkgaGF2ZSBmaXhlZCB0aGF0Lg0KMi4gSSBoYXZlIGFkZGVkIGEg bmV3IHJvbGUgaS5lIENlbGxSb2xlLiBBbGwgbm9kZXMgY29ycmVzcG9uZGluZyB0byA8dGQ+IGFu ZCA8dGg+IHdpbGwgYmUNCiAgIGFzc2lnbmVkICJDZWxsUm9sZSIuIG1fcmVuZGVyZXItPmlzVGFi bGVDZWxsKCkgcmV0dXJucyB0cnVlIGZvciA8dGQ+IHRhZ3Mgb25seS4gSSBkb24ndCB0aGluaw0K ICAgaXQgcmV0dXJucyB0cnVlIGZvciA8dGg+IHRhZ3MuIEluIGZpcmVmb3gsIDx0aD4gdGFncyBh bHNvIGhhdmUgQ2VsbFJvbGUuIFNvLCBpIGhhdmUgdXNlZA0KICAgaGFzaFRhZ05hbWUoKSBmdW5j dGlvbiB0byBjaGVjayBpZiB0aGUgbm9kZSB0YWcgaXMgPHRoPiBvciBub3QuDQozLiBJIGhhdmUg YWRkZWQgImxpc3RJdGVtUm9sZSIuIFRoaXMgcm9sZSBpcyBhc3NpZ25lZCB0byBhbGwgbm9kZXMg dGhhdCBjb3JyZXNwb25kIHRvIDxsaT4gdGFnLg0KICAgRmlyZWZveCBhc3NpZ25zIHRoaXMgcm9s ZSBwcm9wZXJseS4gSSBoYXZlIGFkZGVkIGNvZGUgdG8gaGFuZGxlIHRoaXMgcm9sZS4NCjQuIFNp bWlsYXJseSwgInNlcGFyYXRvclJvbGUiIGlzIGFkZGVkIHRoYXQgaXMgYXNzaWduZWQgdG8gPGhy PiB0YWcuIEZpcmVmb3ggYXNzaWducyB0aGlzIHJvbGUsIGJ1dA0KICAgV2ViS2l0IGRvZXNuJ3Qu IENoYW5nZXMgdG8gaGFuZGxlIHRoaXMgcm9sZSBoYXZlIGJlZW4gZG9uZS4NCjUuIExpc3RSb2xl IGlzIGFscmVhZHkgcHJlc2VudCBpbiBXZWJLaXQuIEJ1dCwgaXQgaXMgbm90IHByb3Blcmx5IGFz c2lnbmVkIHRvIG5vZGVzLiBJZGVhbGx5LCBhbGwgbm9kZXMNCiAgIHRoYXQgY29ycmVzcG9uZCB0 byA8bGk+LDxvbD4gYW5kIDxkbD4gdGFncyBzaG91bGQgYmUgYXNzaWduZWQgdGhpcyByb2xlLiBJ IGhhdmUgYWRkZWQgdGhlIGNvZGUgdG8NCiAgIHByb3Blcmx5IGFzc2lnbiB0aGlzIHJvbGUgdG8g dGhlIHZhbGlkIG5vZGVzLg0KNi4gSW4gRmlyZWZveCwgYWJiciwgYWNyb255bSBhbmQgcSB0YWdz IGFyZSBoYW5kbGVkIHNwZWNpYWxseS4gVGhleSBhcmUgdHJlYXRlZCBhcyBncm91cGluZyBpcnJl c3BlY3RpdmUNCiAgIG9mIHRoZWlyIGRpc3BsYXkgcHJvcGVydGllcy4gVGhvc2UgdGFncyBhcmUg YXNzZ2luZWQgZ3JvdXByb2xlLiBCdXQsIHdlYmtpdCBhc3NpZ25zIGNsaWVudCByb2xlIHRvIHRo b3NlDQogICB0YWdzLiBTbywgSSBoYXZlIG1hZGUgY2hhbmdlcyB0byBzeW5jIHVwIHdlYmtpdCBi ZWhhdmlvdXIgd2l0aCBGaXJlZm94IDIuMC4wLjE0Lg0KDQpNYWRlIGNoYW5nZXMgdG8gcHJvcGVy bHkgc2V0IGZvY3VzIGF0dHJpYnV0ZSB0byB0aGUgZm91ciBuZXdseSBpbnRyb2R1Y2VkIHJvbGVz Lg0KDQpGaWx0ZXJpbmcgdGhlIE1TQUEgdHJlZSBhbmQgZXhwb3NpbmcgcmVsYXZhbnQgYWNjZXNz aWJsZSBlbGVtZW50czoNCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQ0KUnVsZSAxOiBBIHRleHQgbm9kZSBzaG91bGQgYmUg ZXhwb3NlZCBvbmx5IGlmIGl0IGhhcyBzb21lIGNvbnRlbnQuIElmIHRoaXMgcm9sZSBpcyBpbXBs ZW1lbnRlZCwgdGhlbiBtYW55IA0KICAgICAgICBlbXB0eSBkdW1teSB0ZXh0IG5vZGVzIGxpa2Ug IiIsICIgICAiIHdpbGwgYmUgZWxpbWluYXRlZCBhbmQgTVNBQSB0cmVlIGxvb2tzIGNsZWFuLiBT bywgSSBoYXZlIGltcGxlbWVudGVkDQogICAgICAgIHRoaXMgcnVsZS4NClJ1bGUgMjogSSBoYXZl IHByZXBhcmVkIGRpZmZlcmVudCB3ZWIgcGFnZXMgYW5kIHRlc3RlZCB3aXRoIEZpcmVmb3ggMi4w LjAuMTQuIEkgZm91bmQgdGhhdCBmZXcgdGFncyBhcmUgaWdub3JlZA0KICAgICAgICBieSBmaXJl Zm94IGlycmVzcGVjdGl2ZSBvZiB0aGVpciBkaXNwbGF5IHByb3BlcnRpZXMgaS5lIGlubGluZSwg YmxvY2suIFRoZXkgYXJlOg0KICAgICAgICA8Yj4sPGJkbz4sPGJpZz4sPGNpdGU+LDxjb2RlPiw8 ZGZuPiw8ZGVsPiw8aW5zPiw8ZW0+LDxmb250Piw8aT4sPGtiZD4sPGxhYmVsPiw8cz4sPHNhbXA+ LDxzbWFsbD4sPHNwYW4+LA0KICAgICAgICA8c3RyaWtlPiw8c3Ryb25nPiw8c3ViPiw8c3VwPiw8 dGV4dGFyZWE+LDx0dD4sPHU+LDxwcmU+LDxhZGRyZXNzPiw8Y2VudGVyPiw8ZGl2Piw8bWVudT4g YW5kIDxwPi4gRXZlbiBpZiB0aGVzZSB0YWdzDQogICAgICAgIGFyZSBkaXNwbGF5ZWQgaW4gYmxv Y2sgc3R5bGUsIHRoZXkgYXJlIGlnbm9yZWQgYnkgRmlyZWZveC4gU28sIEkgaGF2ZSB3cml0dGVu IGEgZnVuY3Rpb24gdG8gY2hlY2sgaWYgdGhlIHRhZw0KICAgICAgICBmYWxscyBpbiB0aGlzIGNh dGVnb3J5IGFuZCBpZ25vcmUgdGhhdCBpZiBuZWVkZWQuIFRoaXMgaW1wbGVtZW50YXRpb24gaXMg ZG9uZSBpbiBpc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGZ1bmN0aW9uLg0KUnVsZSAzOiBGaXJl Zm94IGRvZXNuJ3QgaWdub3JlIDx1bD4sPG9sPiBhbmQgPGRsPiB0YWdzLiBUaGV5IGFyZSBleHBv c2VkIGlycmVzcGVjdGl2ZSBvZiB0aGVpciBkaXNwbGF5IHByb3BlcnR5LiBJbXBsZW1lbnRlZA0K ICAgICAgICB0aGlzIHJ1bGUgaW4gV2ViS2l0Lg0KUnVsZSA0OiBTaW1pbGFybHksIGZldyB0YWdz IGkuZSA8Zm9ybT4sPHRhYmxlPiw8dGQ+LDx0aD4gYXJlIG5vdCBpZ25vcmVkIGF0IGFsbC4gU28s IEkgaGF2ZSBpbXBsZW1lbnRlZCB0aGlzIHJ1bGUNCiAgICAgICAgaW4gV2ViS2l0LiBUaGlzIGlt cGxlbWVudGF0aW9uIGlzIGRvbmUgaW4gaXNGb3JtT3JUYWJsZUVsZW1lbnQoKSBmdW5jdGlvbi4g QXMgc3BlY2lmaWVkIGFib3ZlLCBpc1RhYmxlQ2VsbCgpIGZ1bmN0aW9uDQogICAgICAgIHJldHVy bnMgdHJ1ZSBvbmx5IGZvciA8dGQ+IHRhZ3MuIEl0IGRvZXNuJ3QgcmV0dXJuIHRydWUgZm9yIDx0 aD4gdGFnLiBTbywgSSBoYXZlIHVzZWQgaGFzaFRhZ05hbWUodGhUYWcpIGluIHRoYXQgZnVuY3Rp b24uDQpSdWxlIDU6IFRoZXJlIGFyZSBmZXcgdGFncyB0aGF0IGFyZSBzcGVjaWFsbHkgaGFuZGxl ZCBieSBGaXJlZm94LiBUaGV5IGFyZSA8YWJicj4sPGFjcm9ueW0+IGFuZCA8cT4gdGFncy4gVGhl eSBhcmUgZXhwb3NlZA0KICAgICAgICBieSBmaXJlZm94IGFuZCB0aG9zZSBub2RlcyBhcmUgYXNz aWduZWQgZ3JvdXByb2xlLiBUaGlzIGlzIG5vdCBpbXBsZW1lbnRlZCBpbiBXZWJraXQuIEkgaGF2 ZSBhZGRlZCB0aGlzIG5ldyBsb2dpYy4NCiAgICAgICAgRm9yIHRoZXNlIHRhZ3MsIGZpcmVmb3gg c2ltcGx5IGV4cG9zZXMgdGhlIG5vZGVzIGV2ZW4gaWYgdGhleSBhcmUgZW1wdHkuIEkgZG9uJ3Qg ZmVlbCB0aGlzIGlzIGdvb2QuIEluIG15IHZpZXcsIA0KICAgICAgICBpZiB0aGVzZSB0YWdzIGFy ZSBlbXB0eSAoaS5lIGF0b21pYyBub2RlcyBjb250YWluaW5nIG5vIGNoaWxkcmVuKSwgdGhlbiB0 aGV5IHNob3VsZCBub3QgYmUgZXhwb3NlZC4gU28sIEkgaGF2ZSBhZGRlZA0KICAgICAgICBhIGNv bmRpdGlvbiB0byBjaGVjayBpZiB0aGV5IGhhdmUgYW55IHZhbGlkIGNoaWxkcmVuLiBJZiB0aGV5 IGhhdmUsIHRoZW4gdGhleSB3aWxsIGJlIGV4cG9zZWQuIElmIG5vdCwgdGhleSB3aWxsIG5vdA0K ICAgICAgICBiZSBleHBvc2VkLiBJIGhhdmUgaW1wbGVtZW50ZWQgdGhlIHNpbWlsYXIgbG9naWMg Zm9yIDxsaT4sPGR0PiwgPGRkPiBlbGVtZW50cyBhbHNvLiBJIGZlZWwgdGhlc2UgdGhyZWUgZWxl bWVudHMgYWxzbw0KICAgICAgICBzaG91bGQgYmUgaGFuZGxlZCBpbiBhIHNpbWlsYXIgZmFzaGlv bi4NClJ1bGUgNjogTWFqb3IgdGFncyBpLmUgPGh0bWw+IGFuZCA8Ym9keT4gc2hvdWxkIGJlIGln bm9yZWQuIEZpcmVmb3ggaWdub3JlcyB0aGVtLg0KUnVsZSA3OiBBbG1vc3QgYWxsIHRhZ3MgYXJl IGhhbmRsZWQgaW4gdGhlIGFib3ZlIHJ1bGVzLiBCZXNpZGVzIHRoYXQsIGlmIGEgbm9kZSBpcyBk aXNwbGF5ZWQgaW4gYmxvY2sgbGF5b3V0LCB3ZSBoYXZlIHRvIGV4cG9zZQ0KICAgICAgICBvbmx5 IGlmIGl0IGlzIG5vdCBhbiBhbm9ueW1vdXMgYmxvY2suDQpSdWxlIDg6IFNpbXBseSBpZ25vcmUg YWxsIGlubGluZSBlbGVtZW50cy4= 22558 2008-07-30 11:49:10 -0700 2008-07-30 21:09:42 -0700 This is patch contains only the changes for adding a new role i.e. DocumentRole. DocumentRole-patch.txt text/plain 2835 sankaraditya+bugzilla SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDM1NDU1 KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDgtMDct MzAgIHN0YW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21haWwuY29tPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMDAxMworCisgICAgICAgIEFkZGVkIGEgbmV3IHJvbGUgaS5lLiBE b2N1bWVudFJvbGUuCisgICAgICAgIFdoZW4gYSB3ZWJwYWdlIGlzIG9wZW5lZCBpbiBGaXJlZm94 IGFuZCBpbnNwZWN0MzIgdG9vbCBpcyBpbnZva2VkLAorICAgICAgICB0aGUgTVNBQSB0cmVlIHRo YXQgaXMgZXhwb3NlZCBpcyBhc3NpZ25lZCBEb2N1bWVudFJvbGUuIEluIFdlYmtpdCwKKyAgICAg ICAgaXQgaXMgYXNzaWduZWQgQ2xpZW50IHJvbGUuIEkgaGF2ZSBtYWRlIG5lY2Vzc2FyeSBjaGFu Z2VzIHRvIHBvcHVsYXRlCisgICAgICAgIHRoZSByb2xlIGF0dHJpYnV0ZSBjb3JyZWN0bHkgd2l0 aCBEb2N1bWVudFJvbGUuCisKKworICAgICAgICAqIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 T2JqZWN0Lmg6CisgICAgICAgIChXZWJDb3JlOjopOgorICAgICAgICAqIFdlYkNvcmUvcGFnZS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OnJvbGVWYWx1ZSk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0OjpjYW5TZXRGb2N1c0F0dHJpYnV0ZSk6CisgICAgICAgICogV2Vi S2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5jcHA6CisgICAgICAgIChNU0FBUm9sZSk6CisKIDIwMDgt MDctMzAgIE1hcmNvIEJhcmlzaW9uZSAgPG1hcmNvLmJhcmlzaW9uZUBjb2xsYWJvcmEuY28udWs+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2VyLgpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vz c2liaWxpdHlPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0 eU9iamVjdC5oCShyZXZpc2lvbiAzNTQzMykKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 T2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0NCw3ICsxNDQsOCBAQCBlbnVtIEFjY2Vzc2li aWxpdHlSb2xlIHsKICAgICBXZWJBcmVhUm9sZSwKICAgICBIZWFkaW5nUm9sZSwKICAgICBMaXN0 Qm94Um9sZSwKLSAgICBMaXN0Qm94T3B0aW9uUm9sZQorICAgIExpc3RCb3hPcHRpb25Sb2xlLAor ICAgIERvY3VtZW50Um9sZQogfTsKIAogc3RydWN0IFZpc2libGVQb3NpdGlvblJhbmdlIHsKSW5k ZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJldmlzaW9u IDM1NDMzKQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0yMDAxLDYgKzIwMDEsOSBAQCBBY2Nlc3NpYmlsaXR5Um9sZSBBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgaWYgKGFyaWFSb2xlICE9IFVua25vd25Sb2xlKQogICAg ICAgICByZXR1cm4gYXJpYVJvbGU7CiAgICAgCisgICAgaWYgKG5vZGUgJiYgbm9kZS0+aXNEb2N1 bWVudE5vZGUoKSkKKyAgICAgICAgcmV0dXJuIERvY3VtZW50Um9sZTsKKwogICAgIGlmIChub2Rl ICYmIG5vZGUtPmlzTGluaygpKSB7CiAgICAgICAgIGlmIChtX3JlbmRlcmVyLT5pc0ltYWdlKCkp CiAgICAgICAgICAgICByZXR1cm4gSW1hZ2VNYXBSb2xlOwpAQCAtMjE0Miw2ICsyMTQ1LDcgQEAg Ym9vbCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjYW5TZXRGbwogICAgICAgICBjYXNlIEhl YWRpbmdSb2xlOgogICAgICAgICBjYXNlIExpc3RCb3hSb2xlOgogICAgICAgICBjYXNlIExpc3RC b3hPcHRpb25Sb2xlOgorICAgICAgICBjYXNlIERvY3VtZW50Um9sZToKICAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKICAgICB9CiAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CkluZGV4OiBXZWJL aXQvd2luL0FjY2Vzc2libGVCYXNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0FjY2Vz c2libGVCYXNlLmNwcAkocmV2aXNpb24gMzU0MzMpCisrKyBXZWJLaXQvd2luL0FjY2Vzc2libGVC YXNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTYzLDYgKzU2Myw4IEBAIHN0YXRpYyBsb25nIE1T QUFSb2xlKEFjY2Vzc2liaWxpdHlSb2xlIHIKICAgICAgICAgY2FzZSBXZWJDb3JlOjpJbWFnZU1h cFJvbGU6CiAgICAgICAgIGNhc2UgV2ViQ29yZTo6SW1hZ2VSb2xlOgogICAgICAgICAgICAgcmV0 dXJuIFJPTEVfU1lTVEVNX0dSQVBISUM7CisgICAgICAgIGNhc2UgV2ViQ29yZTo6RG9jdW1lbnRS b2xlOgorICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0RPQ1VNRU5UOwogICAgICAgICBk ZWZhdWx0OgogICAgICAgICAgICAgLy8gVGhpcyBpcyB0aGUgZGVmYXVsdCByb2xlIGZvciBNU0FB LgogICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0NMSUVOVDsK 22566 2008-07-30 16:01:19 -0700 2008-07-31 13:29:04 -0700 Patch for changes to populate new role i.e separatorRole SeparatorRole_patch.txt text/plain 3240 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ2MykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUgQEAKKzIwMDgtMDctMzAgIHN0YW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21h aWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFkZGVkIGEgbmV3IHJvbGUgaS5lLiBTZXBhcmF0b3JSb2xlLiBJbiBGaXJlZm94LCBub2RlCisg ICAgICAgIGNvcnJlc3BvbmRpbmcgdG8gPGhyLz4gdGFnIGlzIGFzc2lnbmVkIFNlcGFyYXRvclJv bGUuIE1hZGUKKyAgICAgICAgY2hhbmdlcyB0byBhc3NpZ24gU2VwYXJhdG9yUm9sZSBwcm9wZXJs eSBpbiBXZWJLaXQuCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBD SEFOR0VECisKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaDoKKyAgICAgICAg KFdlYkNvcmU6Oik6CisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnJvbGVWYWx1 ZSk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjYW5TZXRG b2N1c0F0dHJpYnV0ZSk6CisKIDIwMDgtMDctMzAgIENocmlzdGlhbiBEeXdhbiAgPGNocmlzdGlh bkB0d290b2FzdHMuZGU+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFyay4KSW5kZXg6IFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdl L0FjY2Vzc2liaWxpdHlPYmplY3QuaAkocmV2aXNpb24gMzU0NjMpCisrKyBXZWJDb3JlL3BhZ2Uv QWNjZXNzaWJpbGl0eU9iamVjdC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNDQsNyArMTQ0LDggQEAg ZW51bSBBY2Nlc3NpYmlsaXR5Um9sZSB7CiAgICAgV2ViQXJlYVJvbGUsCiAgICAgSGVhZGluZ1Jv bGUsCiAgICAgTGlzdEJveFJvbGUsCi0gICAgTGlzdEJveE9wdGlvblJvbGUKKyAgICBMaXN0Qm94 T3B0aW9uUm9sZSwKKyAgICBTZXBhcmF0b3JSb2xlCiB9OwogCiBzdHJ1Y3QgVmlzaWJsZVBvc2l0 aW9uUmFuZ2UgewpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcAkocmV2aXNpb24gMzU0NjMpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIwMDYsNiArMjAwNiw4IEBAIEFjY2Vzc2li aWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmoKICAgICAgICAgICAgIHJldHVybiBJbWFn ZU1hcFJvbGU7CiAgICAgICAgIHJldHVybiBXZWJDb3JlTGlua1JvbGU7CiAgICAgfQorICAgIGlm IChtX3JlbmRlcmVyLT5pc0hSKCkpCisgICAgICAgIHJldHVybiBTZXBhcmF0b3JSb2xlOwogICAg IGlmIChtX3JlbmRlcmVyLT5pc0xpc3RNYXJrZXIoKSkKICAgICAgICAgcmV0dXJuIExpc3RNYXJr ZXJSb2xlOwogICAgIGlmIChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUoYnV0dG9uVGFnKSkKQEAg LTIxNDIsNiArMjE0NCw3IEBAIGJvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2FuU2V0 Rm8KICAgICAgICAgY2FzZSBIZWFkaW5nUm9sZToKICAgICAgICAgY2FzZSBMaXN0Qm94Um9sZToK ICAgICAgICAgY2FzZSBMaXN0Qm94T3B0aW9uUm9sZToKKyAgICAgICAgY2FzZSBTZXBhcmF0b3JS b2xlOgogICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KICAgICBBU1NFUlRfTk9UX1JF QUNIRUQoKTsKSW5kZXg6IFdlYktpdC9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L0No YW5nZUxvZwkocmV2aXNpb24gMzU0NjMpCisrKyBXZWJLaXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNv cHkpCkBAIC0xLDMgKzEsMTAgQEAKKzIwMDgtMDctMzAgIHN0YW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWFAZ21haWwuY29tPgorCisgICAgICAgIEFkZGVkIGEgbmV3IHJvbGUgaS5lLiBTZXBhcmF0b3JS b2xlLiBJbiBGaXJlZm94LCBub2RlCisgICAgICAgIGNvcnJlc3BvbmRpbmcgdG8gPGhyLz4gdGFn IGlzIGFzc2lnbmVkIFNlcGFyYXRvclJvbGUuIE1hZGUKKyAgICAgICAgY2hhbmdlcyB0byBhc3Np Z24gU2VwYXJhdG9yUm9sZSBwcm9wZXJseSBpbiBXZWJLaXQuCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiB3aW4vQWNjZXNzaWJsZUJhc2UuY3BwOgor ICAgICAgICAoTVNBQVJvbGUpOgorCiAyMDA4LTA3LTExICBTdGVwaGFuaWUgTGV3aXMgIDxzbGV3 aXNAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRleDog V2ViS2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9B Y2Nlc3NpYmxlQmFzZS5jcHAJKHJldmlzaW9uIDM1NDYzKQorKysgV2ViS2l0L3dpbi9BY2Nlc3Np YmxlQmFzZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU2NSw2ICs1NjUsOCBAQCBzdGF0aWMgbG9u ZyBNU0FBUm9sZShBY2Nlc3NpYmlsaXR5Um9sZSByCiAgICAgICAgIGNhc2UgV2ViQ29yZTo6SW1h Z2VNYXBSb2xlOgogICAgICAgICBjYXNlIFdlYkNvcmU6OkltYWdlUm9sZToKICAgICAgICAgICAg IHJldHVybiBST0xFX1NZU1RFTV9HUkFQSElDOworICAgICAgICBjYXNlIFdlYkNvcmU6OlNlcGFy YXRvclJvbGU6CisgICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fU0VQQVJBVE9SOwogICAg ICAgICBkZWZhdWx0OgogICAgICAgICAgICAgLy8gVGhpcyBpcyB0aGUgZGVmYXVsdCByb2xlIGZv ciBNU0FBLgogICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0NMSUVOVDsK 22568 2008-07-30 16:27:17 -0700 2008-07-31 13:37:43 -0700 Patch for adding and poupluating a new role i.e CellRole CellRole_patch.txt text/plain 3435 sankaraditya+bugzilla SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDM1NDY2 KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDgtMDct MzAgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21haWwuY29tPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDAxMworCisgICAgICAgIEFkZGVkIGEgbmV3IHJvbGUg aS5lIENlbGxSb2xlLiBJbiBmaXJlZm94LCBub2RlcyBjb3JyZXNwb25kaW5nIHRvCisgICAgICAg IDx0ZD4gYW5kIDx0aD4gdGFncyBhcmUgYXNzaWduZWQgQ2VsbFJvbGUuIE1hZGUgY2hhbmdlcyB0 byBhc3NpZ24KKyAgICAgICAgdGhhdCByb2xlIHByb3Blcmx5IGluIFdlYmtpdCBhbHNvLgorCisg ICAgICAgICogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaDoKKyAgICAgICAgKFdl YkNvcmU6Oik6CisgICAgICAgICogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cm9s ZVZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNh blNldEZvY3VzQXR0cmlidXRlKToKKwogMjAwOC0wNy0zMCAgTWFyY28gQmFyaXNpb25lICA8bWFy Y28uYmFyaXNpb25lQGNvbGxhYm9yYS5jby51az4KIAogICAgICAgICBSZXZpZXdlZCBieSBIb2xn ZXIuCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHJldmlzaW9uIDM1NDYwKQor KysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAt MTQ0LDcgKzE0NCw4IEBAIGVudW0gQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIFdlYkFyZWFSb2xl LAogICAgIEhlYWRpbmdSb2xlLAogICAgIExpc3RCb3hSb2xlLAotICAgIExpc3RCb3hPcHRpb25S b2xlCisgICAgTGlzdEJveE9wdGlvblJvbGUsCisgICAgQ2VsbFJvbGUKIH07CiAKIHN0cnVjdCBW aXNpYmxlUG9zaXRpb25SYW5nZSB7CkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAzNTQ2MCkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjAyNiw2ICsyMDI2LDkg QEAgQWNjZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0eVJlbmRlck9iagogICAgIGlmIChtX3Jl bmRlcmVyLT5pc1RleHRBcmVhKCkpCiAgICAgICAgIHJldHVybiBUZXh0QXJlYVJvbGU7CiAgICAg CisgICAgaWYgKG1fcmVuZGVyZXItPmlzVGFibGVDZWxsKCkgfHwgKG5vZGUgJiYgbm9kZS0+aGFz VGFnTmFtZSh0aFRhZykpKQorICAgICAgICByZXR1cm4gQ2VsbFJvbGU7CisKICAgICBpZiAobm9k ZSAmJiBub2RlLT5oYXNUYWdOYW1lKGlucHV0VGFnKSkgewogICAgICAgICBIVE1MSW5wdXRFbGVt ZW50KiBpbnB1dCA9IHN0YXRpY19jYXN0PEhUTUxJbnB1dEVsZW1lbnQqPihub2RlKTsKICAgICAg ICAgaWYgKGlucHV0LT5pbnB1dFR5cGUoKSA9PSBIVE1MSW5wdXRFbGVtZW50OjpDSEVDS0JPWCkK QEAgLTIwOTQsNiArMjA5Nyw3IEBAIGJvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2Fu U2V0Rm8KICAgICAgICAgY2FzZSBQb3BVcEJ1dHRvblJvbGU6CiAgICAgICAgIGNhc2UgQ2hlY2tC b3hSb2xlOgogICAgICAgICBjYXNlIFJhZGlvQnV0dG9uUm9sZToKKyAgICAgICAgY2FzZSBDZWxs Um9sZTogICAgICAgIAogICAgICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgICAgIGNhc2UgVW5r bm93blJvbGU6CiAgICAgICAgIGNhc2UgU2xpZGVyUm9sZToKSW5kZXg6IFdlYktpdC9DaGFuZ2VM b2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViS2l0L0NoYW5nZUxvZwkocmV2aXNpb24gMzU0NjYpCisrKyBX ZWJLaXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTEgQEAKKzIwMDgtMDct MzAgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21haWwuY29tPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDAxMworCisgICAgICAgIEFkZGVkIGEgbmV3IHJvbGUg aS5lIENlbGxSb2xlLiBJbiBmaXJlZm94LCBub2RlcyBjb3JyZXNwb25kaW5nIHRvCisgICAgICAg IDx0ZD4gYW5kIDx0aD4gdGFncyBhcmUgYXNzaWduZWQgQ2VsbFJvbGUuIE1hZGUgY2hhbmdlcyB0 byBhc3NpZ24KKyAgICAgICAgdGhhdCByb2xlIHByb3Blcmx5IGluIFdlYmtpdCBhbHNvLgorCisg ICAgICAgICogd2luL0FjY2Vzc2libGVCYXNlLmNwcDoKKyAgICAgICAgKE1TQUFSb2xlKToKKwog MjAwOC0wNy0xMSAgU3RlcGhhbmllIExld2lzICA8c2xld2lzQGFwcGxlLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KSW5kZXg6IFdlYktpdC93aW4vQWNjZXNzaWJsZUJh c2UuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCShyZXZp c2lvbiAzNTQ2MCkKKysrIFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC01NjUsNiArNTY1LDggQEAgc3RhdGljIGxvbmcgTVNBQVJvbGUoQWNjZXNzaWJpbGl0 eVJvbGUgcgogICAgICAgICBjYXNlIFdlYkNvcmU6OkltYWdlTWFwUm9sZToKICAgICAgICAgY2Fz ZSBXZWJDb3JlOjpJbWFnZVJvbGU6CiAgICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fR1JB UEhJQzsKKyAgICAgICAgY2FzZSBXZWJDb3JlOjpDZWxsUm9sZToKKyAgICAgICAgICAgIHJldHVy biBST0xFX1NZU1RFTV9DRUxMOwogICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgLy8gVGhp cyBpcyB0aGUgZGVmYXVsdCByb2xlIGZvciBNU0FBLgogICAgICAgICAgICAgcmV0dXJuIFJPTEVf U1lTVEVNX0NMSUVOVDsK 22569 2008-07-30 16:56:20 -0700 2008-07-31 13:32:04 -0700 Patch for changes to populate new role i.e ListItemRole ListItemRole_Patch.txt text/plain 3508 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ2MykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUgQEAKKzIwMDgtMDctMzAgIHN0YW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21h aWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEzCisKKyAgICAgICAg QWRkZWQgYSBuZXcgcm9sZSBpLmUgTGlzdEl0ZW1Sb2xlLiBJbiBGaXJlZm94LCBhbGwgbm9kZXMg CisgICAgICAgIGNvcnJlc3BvbmRpbmcgdG8gPGxpPiB0YWdzIGFuZCB3aXRoIGRpc3BsYXkgc2V0 IHRvIExpc3QtSXRlbQorICAgICAgICBhcmUgYXNzaWduZWQgdGhpcyByb2xlLiBNYWRlIGNoYW5n ZXMgdG8gcG91cGxhdGUgdGhpcyByb2xlCisgICAgICAgIHByb3Blcmx5IHRvIHRoZSByZXNwZWN0 aXZlIG5vZGVzIGluIFdlYmtpdC4KKworICAgICAgICBXQVJOSU5HOiBOTyBURVNUIENBU0VTIEFE REVEIE9SIENIQU5HRUQKKworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oOgor ICAgICAgICAoV2ViQ29yZTo6KToKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6 cm9sZVZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmNhblNldEZvY3VzQXR0cmlidXRlKToKKwogMjAwOC0wNy0zMCAgQ2hyaXN0aWFuIER5d2FuICA8 Y2hyaXN0aWFuQHR3b3RvYXN0cy5kZT4KIAogICAgICAgICBSZXZpZXdlZCBieSBNYXJrLgpJbmRl eDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCShyZXZpc2lvbiAzNTQ2MykKKysrIFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0NCw3ICsx NDQsOCBAQCBlbnVtIEFjY2Vzc2liaWxpdHlSb2xlIHsKICAgICBXZWJBcmVhUm9sZSwKICAgICBI ZWFkaW5nUm9sZSwKICAgICBMaXN0Qm94Um9sZSwKLSAgICBMaXN0Qm94T3B0aW9uUm9sZQorICAg IExpc3RCb3hPcHRpb25Sb2xlLAorICAgIExpc3RJdGVtUm9sZQogfTsKIAogc3RydWN0IFZpc2li bGVQb3NpdGlvblJhbmdlIHsKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5jcHAJKHJldmlzaW9uIDM1NDYzKQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMDA2LDYgKzIwMDYsOCBAQCBB Y2Nlc3NpYmlsaXR5Um9sZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgICAgICAgICByZXR1 cm4gSW1hZ2VNYXBSb2xlOwogICAgICAgICByZXR1cm4gV2ViQ29yZUxpbmtSb2xlOwogICAgIH0K KyAgICBpZiAobV9yZW5kZXJlci0+aXNMaXN0SXRlbSgpKQorICAgICAgICByZXR1cm4gTGlzdEl0 ZW1Sb2xlOwogICAgIGlmIChtX3JlbmRlcmVyLT5pc0xpc3RNYXJrZXIoKSkKICAgICAgICAgcmV0 dXJuIExpc3RNYXJrZXJSb2xlOwogICAgIGlmIChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUoYnV0 dG9uVGFnKSkKQEAgLTIwOTQsNiArMjA5Niw3IEBAIGJvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdDo6Y2FuU2V0Rm8KICAgICAgICAgY2FzZSBQb3BVcEJ1dHRvblJvbGU6CiAgICAgICAgIGNh c2UgQ2hlY2tCb3hSb2xlOgogICAgICAgICBjYXNlIFJhZGlvQnV0dG9uUm9sZToKKyAgICAgICAg Y2FzZSBMaXN0SXRlbVJvbGU6CiAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICAgY2Fz ZSBVbmtub3duUm9sZToKICAgICAgICAgY2FzZSBTbGlkZXJSb2xlOgpJbmRleDogV2ViS2l0L0No YW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvQ2hhbmdlTG9nCShyZXZpc2lvbiAzNTQ2MykK KysrIFdlYktpdC9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxMCBAQAorMjAw OC0wNy0zMCAgc3Rhbmd1dHVyaSAgPHNhbmthcmFkaXR5YUBnbWFpbC5jb20+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cDovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAwMTMKKworICAgICAgICBBZGRlZCBhIG5ldyByb2xlIGku ZSBMaXN0SXRlbVJvbGUuIEluIEZpcmVmb3gsIGFsbCBub2RlcyAKKyAgICAgICAgY29ycmVzcG9u ZGluZyB0byA8bGk+IHRhZ3MgYW5kIHdpdGggZGlzcGxheSBzZXQgdG8gTGlzdC1JdGVtCisgICAg ICAgIGFyZSBhc3NpZ25lZCB0aGlzIHJvbGUuIE1hZGUgY2hhbmdlcyB0byBwb3VwbGF0ZSB0aGlz IHJvbGUKKyAgICAgICAgcHJvcGVybHkgdG8gdGhlIHJlc3BlY3RpdmUgbm9kZXMgaW4gV2Via2l0 LgorCisKKyAgICAgICAgKiB3aW4vQWNjZXNzaWJsZUJhc2UuY3BwOgorICAgICAgICAoTVNBQVJv bGUpOgorCiAyMDA4LTA3LTExICBTdGVwaGFuaWUgTGV3aXMgIDxzbGV3aXNAYXBwbGUuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRleDogV2ViS2l0L3dpbi9BY2Nl c3NpYmxlQmFzZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5j cHAJKHJldmlzaW9uIDM1NDYzKQorKysgV2ViS2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTU2NSw2ICs1NjUsOCBAQCBzdGF0aWMgbG9uZyBNU0FBUm9sZShBY2Nl c3NpYmlsaXR5Um9sZSByCiAgICAgICAgIGNhc2UgV2ViQ29yZTo6SW1hZ2VNYXBSb2xlOgogICAg ICAgICBjYXNlIFdlYkNvcmU6OkltYWdlUm9sZToKICAgICAgICAgICAgIHJldHVybiBST0xFX1NZ U1RFTV9HUkFQSElDOworICAgICAgICBjYXNlIFdlYkNvcmU6Okxpc3RJdGVtUm9sZToKKyAgICAg ICAgICAgIHJldHVybiBST0xFX1NZU1RFTV9MSVNUSVRFTTsKICAgICAgICAgZGVmYXVsdDoKICAg ICAgICAgICAgIC8vIFRoaXMgaXMgdGhlIGRlZmF1bHQgcm9sZSBmb3IgTVNBQS4KICAgICAgICAg ICAgIHJldHVybiBST0xFX1NZU1RFTV9DTElFTlQ7Cg== 22573 2008-07-30 21:09:42 -0700 2008-07-31 13:15:44 -0700 Updated patch for DocumentRole. DocumentRole2_patch.txt text/plain 3549 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ3MSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTQgQEAKKzIwMDgtMDctMzAgIHN0YW5ndXR1cmkgIDxzZXQgRU1BSUxfQUREUkVT UyBlbnZpcm9ubWVudCB2YXJpYWJsZT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBXQVJOSU5HOiBOTyBURVNUIENBU0VTIEFEREVEIE9SIENIQU5HRUQK KworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAoV2ViQ29y ZTo6KToKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2FuU2V0Rm9jdXNBdHRy aWJ1dGUpOgorCiAyMDA4LTA3LTMwICBBbGljZSBMaXUgIDxhbGljZS5saXVAYXBwbGUuY29tPgog CiAgICAgICAgIEltcGxlbWVudCB1c2VySWRsZVRpbWUoKSBmb3IgV2luZG93cywgYW5kIHBsYWNl IGEgYmFuZC1haWQgb3ZlciBvdGhlcgpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlP YmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5o CShyZXZpc2lvbiAzNTQ3MSkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJ KHdvcmtpbmcgY29weSkKQEAgLTE0NCw3ICsxNDQsOCBAQCBlbnVtIEFjY2Vzc2liaWxpdHlSb2xl IHsKICAgICBXZWJBcmVhUm9sZSwKICAgICBIZWFkaW5nUm9sZSwKICAgICBMaXN0Qm94Um9sZSwK LSAgICBMaXN0Qm94T3B0aW9uUm9sZQorICAgIExpc3RCb3hPcHRpb25Sb2xlLAorICAgIERvY3Vt ZW50Um9sZQogfTsKIAogc3RydWN0IFZpc2libGVQb3NpdGlvblJhbmdlIHsKSW5kZXg6IFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDM1NDcxKQor KysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0yMDk0LDYgKzIwOTQsNyBAQCBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmNhblNldEZvCiAgICAgICAgIGNhc2UgUG9wVXBCdXR0b25Sb2xlOgogICAgICAgICBjYXNlIENo ZWNrQm94Um9sZToKICAgICAgICAgY2FzZSBSYWRpb0J1dHRvblJvbGU6CisgICAgICAgIGNhc2Ug RG9jdW1lbnRSb2xlOiAgICAgICAgCiAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICAg Y2FzZSBVbmtub3duUm9sZToKICAgICAgICAgY2FzZSBTbGlkZXJSb2xlOgpJbmRleDogV2ViS2l0 L3dpbi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlz aW9uIDM1NDcxKQorKysgV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEs MyArMSwxMyBAQAorMjAwOC0wNy0zMCAgc3Rhbmd1dHVyaSAgPHNldCBFTUFJTF9BRERSRVNTIGVu dmlyb25tZW50IHZhcmlhYmxlPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgICogQWNjZXNzaWJsZUJhc2UuY3BwOgorICAgICAgICAoTVNBQVJvbGUpOgor ICAgICAgICAqIEFjY2Vzc2libGVEb2N1bWVudC5jcHA6CisgICAgICAgIChBY2Nlc3NpYmxlRG9j dW1lbnQ6OnJvbGUpOgorICAgICAgICAqIEFjY2Vzc2libGVEb2N1bWVudC5oOgorCiAyMDA4LTA3 LTMwICBBbmRlcnMgQ2FybHNzb24gIDxhbmRlcnNjYUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgTWl0ei4KSW5kZXg6IFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCShyZXZpc2lvbiAzNTQ3MSkK KysrIFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NjUs NiArNTY1LDggQEAgc3RhdGljIGxvbmcgTVNBQVJvbGUoQWNjZXNzaWJpbGl0eVJvbGUgcgogICAg ICAgICBjYXNlIFdlYkNvcmU6OkltYWdlTWFwUm9sZToKICAgICAgICAgY2FzZSBXZWJDb3JlOjpJ bWFnZVJvbGU6CiAgICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fR1JBUEhJQzsKKyAgICAg ICAgY2FzZSBXZWJDb3JlOjpEb2N1bWVudFJvbGU6CisgICAgICAgICAgICByZXR1cm4gUk9MRV9T WVNURU1fRE9DVU1FTlQ7CiAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAvLyBUaGlzIGlz IHRoZSBkZWZhdWx0IHJvbGUgZm9yIE1TQUEuCiAgICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNU RU1fQ0xJRU5UOwpJbmRleDogV2ViS2l0L3dpbi9BY2Nlc3NpYmxlRG9jdW1lbnQuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdC93aW4vQWNjZXNzaWJsZURvY3VtZW50LmNwcAkocmV2aXNpb24gMzU0 NzEpCisrKyBXZWJLaXQvd2luL0FjY2Vzc2libGVEb2N1bWVudC5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTM4LDYgKzM4LDEwIEBAIEFjY2Vzc2libGVEb2N1bWVudDo6QWNjZXNzaWJsZURvY3VtZW50 KEQKIHsKIH0KIAorbG9uZyBBY2Nlc3NpYmxlRG9jdW1lbnQ6OnJvbGUoKSBjb25zdAoreworICAg IHJldHVybiBST0xFX1NZU1RFTV9ET0NVTUVOVDsKK30KIERvY3VtZW50KiBBY2Nlc3NpYmxlRG9j dW1lbnQ6OmRvY3VtZW50KCkgY29uc3QKIHsKICAgICBpZiAoIW1fb2JqZWN0KQpJbmRleDogV2Vi S2l0L3dpbi9BY2Nlc3NpYmxlRG9jdW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0Fj Y2Vzc2libGVEb2N1bWVudC5oCShyZXZpc2lvbiAzNTQ3MSkKKysrIFdlYktpdC93aW4vQWNjZXNz aWJsZURvY3VtZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTM1LDYgKzM1LDkgQEAgY2xhc3MgQWNj ZXNzaWJsZURvY3VtZW50IDogcHVibGljIEFjY2VzcwogcHVibGljOgogICAgIEFjY2Vzc2libGVE b2N1bWVudChEb2N1bWVudCopOwogICAgIERvY3VtZW50KiBkb2N1bWVudCgpIGNvbnN0OworCitw cm90ZWN0ZWQ6CisgICAgbG9uZyByb2xlKCkgY29uc3Q7CiB9OwogCiAjZW5kaWYgLy8gQWNjZXNz aWJsZURvY3VtZW50X2gK 22574 2008-07-31 01:17:13 -0700 2008-07-31 13:58:09 -0700 This patch contains the changes to populate "Name" attribute properly. TitleAttribute_patch.txt text/plain 6457 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ3NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTkgQEAKKzIwMDgtMDctMzEgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWFAZ21haWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEzCisKKyAg ICBXaGVuIEluc3BlY3QzMiB0b29sIGlzIHVzZWQgd2l0aCBXZWJraXQsIE5hbWUgYXR0cmlidXRl IGZvciAKKyAgICBjZXJ0YWluIG5vZGVzIGlzIG5vdCBwcm9wZXJseSBwb3B1bGF0ZWQuIEVuaGFu Y2VkIHRoZSAKKyAgICBsb2dpYyB0byBwcm9wZXJseSBwb3VwbGF0ZSB0aGF0IGF0dHJpYnV0ZSB1 c2luZyB0aGUgZm9sbG93aW5nIHJ1bGVzLgorCisgICAgMS4gRm9yIHB1cmUgdGV4dCBub2Rlcywg dGl0bGUoKSBzaG91bGQgcmV0dXJuIHRoZSByYXcgdGV4dCAKKyAgICBjb250ZW50IHRoYXQgaXMg cHJlc2VudCBpbiB0aGF0IG5vZGUuCisgICAgMi4gRm9yIGltYWdlIG5vZGVzLCB0aXRsZSgpIHNo b3VsZCByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSAKKyAgICBhbHQgYXR0cmlidXRlLgorCisgICAg PGltZyBzcmM9ImltZy5qcGciIGFsdD0iYWx0SW1hZ2UiIC8+OiBGb3IgdGhlIGFib3ZlIG1lbnRp b25lZCBub2RlLAorICAgIHRpdGxlKCkgc2hvdWxkIHJldHVybiAiYWx0SW1hZ2UiLgorCisgICAg My4gRm9yIGxpbmtzIGFuZCBoZWFkaW5nIG5vZGVzLCB0aXRsZSgpIHNob3VsZCByZXR1cm4gdGhl IHN0cmluZyB0aGF0IAorICAgIGlzIGZvcm1lZCBieSBjb25jYXRlbmF0aW5nIHRoZSB0aXRsZSgp IHZhbHVlcyBvZiBhbGwgb2YgaXRzIGNoaWxkcmVuLgorICAgIDxhIGhyZWY9Imh0dHA6Ly93d3cu d2Via2l0Lm9yZyI+V2ViS2l0PC9hPiAtPkZvciB0aGlzIG5vZGUsIAorICAgIHRpdGxlKCkgc2hv dWxkIHJldHVybiAiV2ViS2l0IgorCisgICAgPGEgaHJlZj0iaHR0cDovL3d3dy53ZWJraXQub3Jn Ij4KKyAgICBUZXh0MQorICAgIDxpbWcgc3JjPSJpbWcuanBnIiBhbHQ9ImFsdF9JbWFnZSIgLz4K KyAgICBUZXh0MgorICAgIDwvYT4gLT4gRm9yIHRoaXMgbm9kZSwgdGl0bGUoKSBzaG91bGQgcmV0 dXJuIAorICAgIFRleHQxK2FsdFZhbHVlKCkrVGV4dDIgPT4gIlRleHQxIGFsdF9JbWFnZSBUZXh0 MiIKKworICAgIFRoaXMgbWVjaGFuaXNtIGlzIHZpc2libGUgaW4gRmlyZWZveCAyLjAuMC4xNC4g U28sIHRoZSBzYW1lIGxvZ2ljIGhhcyAKKyAgICBiZWVuIGltcGxlbWVudGVkIHRoaXMgaW4gV2Vi S2l0LgorCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFOR0VE CisKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4pOgorICAgICAgICAqIHBhZ2Uv QWNjZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9i amVjdDo6Y2hpbGRyZW4pOgorICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0aXRs ZSk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGlsZHJl bik6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGls ZHJlbik6CisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Lmg6CisKIDIw MDgtMDctMzAgIFRpbW90aHkgSGF0Y2hlciAgPHRpbW90aHlAYXBwbGUuY29tPgogCiAgICAgICAg IEZpeCB2YXJpb3VzIG1pbm9yIGJ1Z3Mgd2l0aCBzdHlsZSBlZGl0aW5nIGluIHRoZSBJbnNwZWN0 b3IuCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCShyZXZpc2lvbiAzNTQ3 NSkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtOTc3LDcgKzk3Nyw3IEBAIHZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6Y2hpbGRyZW5D aGFuZ2UKICAgICByZXR1cm47CiB9CiAKLXZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hp bGRyZW4oKQordm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGlsZHJlbigpIGNvbnN0CiB7 CiB9CiAKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAkocmV2aXNpb24gMzU0NzUp CisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCSh3b3JraW5nIGNvcHkpCkBA IC0zMDksOCArMzA5LDggQEAgcHVibGljOgogICAgIGJvb2wgcGVyZm9ybURlZmF1bHRBY3Rpb24o KSBjb25zdCB7IHJldHVybiBwcmVzcygpOyB9CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGNoaWxk cmVuQ2hhbmdlZCgpOwotICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yJiBjaGlsZHJlbigpIHsgcmV0dXJuIG1fY2hpbGRyZW47IH0KLSAgICB2aXJ0dWFsIHZvaWQg YWRkQ2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZl Y3RvciYgY2hpbGRyZW4oKSBjb25zdHsgcmV0dXJuIG1fY2hpbGRyZW47IH0KKyAgICB2aXJ0dWFs IHZvaWQgYWRkQ2hpbGRyZW4oKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaGFzQ2hpbGRyZW4o KSBjb25zdCB7IHJldHVybiBtX2hhdmVDaGlsZHJlbjsgfTsKICAgICB2aXJ0dWFsIHZvaWQgc2Vs ZWN0ZWRDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsKICAgICB2aXJ0dWFs IHZvaWQgdmlzaWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYpOwpAQCAt MzgyLDcgKzM4Miw3IEBAIHB1YmxpYzoKIAogcHJvdGVjdGVkOgogICAgIHVuc2lnbmVkIG1faWQ7 Ci0gICAgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIG1fY2hpbGRyZW47CisgICAgbXV0YWJs ZSBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbV9jaGlsZHJlbjsKICAgICBtdXRhYmxlIGJv b2wgbV9oYXZlQ2hpbGRyZW47CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGNsZWFyQ2hpbGRyZW4o KTsKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJl dmlzaW9uIDM1NDc1KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC04MzAsMTUgKzgzMCwzMCBAQCBTdHJpbmcgQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6dGl0bGUoCiAgICAgICAgIGlmIChsYWJlbCkKICAgICAgICAgICAg IHJldHVybiBsYWJlbC0+aW5uZXJUZXh0KCk7CiAgICAgfQorCisgICAgaWYgKG1fcmVuZGVyZXIt PmVsZW1lbnQoKS0+aXNMaW5rKCkgfHwgaXNIZWFkaW5nKCkpIHsKKyAgICAgICAgY29uc3QgQWNj ZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlblZlY3RvciA9IGNoaWxkcmVuKCk7Cisg ICAgICAgIFZlY3RvcjxVQ2hhcj4gZWxlbWVudFRleHQ7CisgICAgICAgIGZvciAodW5zaWduZWQg aSA9IDA7IGkgPCBjaGlsZHJlblZlY3Rvci5zaXplKCk7ICsraSkgeworICAgICAgICAgICAgZWxl bWVudFRleHQuYXBwZW5kKCcgJyk7CisgICAgICAgICAgICBhcHBlbmQoZWxlbWVudFRleHQsIGNo aWxkcmVuVmVjdG9yW2ldLT50aXRsZSgpKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gU3Ry aW5nOjphZG9wdChlbGVtZW50VGV4dCkuc3RyaXBXaGl0ZVNwYWNlKCk7CisgICAgfQogICAgIAog ICAgIGlmIChyb2xlVmFsdWUoKSA9PSBCdXR0b25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09 IExpc3RCb3hPcHRpb25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09IE1lbnVJdGVtUm9sZQot ICAgICAgICB8fCBhcmlhUm9sZSA9PSBNZW51QnV0dG9uUm9sZQotICAgICAgICB8fCBpc0hlYWRp bmcoKSkKKyAgICAgICAgfHwgYXJpYVJvbGUgPT0gTWVudUJ1dHRvblJvbGUpCiAgICAgICAgIHJl dHVybiB0ZXh0VW5kZXJFbGVtZW50KCk7CiAgICAgCi0gICAgaWYgKGlzTGluaygpKQorICAgIGlm IChpc0ltYWdlKCkpIHsKKyAgICAgICAgTm9kZSogbm9kZSA9IG1fcmVuZGVyZXItPmVsZW1lbnQo KTsKKyAgICAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aXNFbGVtZW50Tm9kZSgpKQorICAgICAgICAg ICAgcmV0dXJuIHN0YXRpY19jYXN0PEVsZW1lbnQqPihub2RlKS0+Z2V0QXR0cmlidXRlKGFsdEF0 dHIpOworICAgIH0gICAKKworICAgIGlmIChtX3JlbmRlcmVyLT5pc1RleHQoKSkgICAgCiAgICAg ICAgIHJldHVybiB0ZXh0VW5kZXJFbGVtZW50KCk7CiAgICAgCiAgICAgcmV0dXJuIFN0cmluZygp OwpAQCAtMjE3MiwxNCArMjE4NywxNCBAQCB2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmNoaWxkcmVuCiAgICAgfQogfQogCi1jb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpBY2Nlc3Np YmlsaXR5Q2hpbGRyZW5WZWN0b3ImIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVu KCkKK2NvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3Rv ciYgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4oKSBjb25zdAogewogICAgIGlm ICghbV9oYXZlQ2hpbGRyZW4pCiAgICAgICAgIGFkZENoaWxkcmVuKCk7CiAgICAgcmV0dXJuIG1f Y2hpbGRyZW47CiB9CiAKLXZvaWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWRkQ2hpbGRy ZW4oKQordm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpIGNvbnN0 CiB7CiAgICAgLy8gSWYgdGhlIG5lZWQgdG8gYWRkIG1vcmUgY2hpbGRyZW4gaW4gYWRkaXRpb24g dG8gZXhpc3RpbmcgY2hpbGRyZW4gYXJpc2VzLCAKICAgICAvLyBjaGlsZHJlbkNoYW5nZWQgc2hv dWxkIGhhdmUgYmVlbiBjYWxsZWQsIGxlYXZpbmcgdGhlIG9iamVjdCB3aXRoIG5vIGNoaWxkcmVu LgpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCShyZXZpc2lv biAzNTQ3NSkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgJKHdv cmtpbmcgY29weSkKQEAgLTE3Miw3ICsxNzIsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lk IGdldERvY3VtZW50TGlua3MoQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJikgY29uc3Q7CiAg ICAgdmlydHVhbCBGcmFtZVZpZXcqIGRvY3VtZW50RnJhbWVWaWV3KCkgY29uc3Q7CiAgICAgCi0g ICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCk7 CisgICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVu KCkgY29uc3Q7CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHNldEZvY3VzZWQoYm9vbCk7CiAgICAg dmlydHVhbCB2b2lkIHNldFNlbGVjdGVkVGV4dFJhbmdlKGNvbnN0IFBsYWluVGV4dFJhbmdlJik7 CkBAIC0xODAsNyArMTgwLDcgQEAgcHVibGljOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBkZXRh Y2goKTsKICAgICB2aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCB2 b2lkIGFkZENoaWxkcmVuKCk7CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7 CiAgICAgdmlydHVhbCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVu VmVjdG9yJik7CiAgICAgdmlydHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5 Q2hpbGRyZW5WZWN0b3ImKTsKICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkRm9jdXNBY3RpdmVEZXNj ZW5kYW50KCkgY29uc3Q7Cg== 22575 2008-07-31 01:57:32 -0700 2008-07-31 14:12:12 -0700 Patch for populating Role Attribute properly RoleAttribute_patch.txt text/plain 6198 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ3NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTkgQEAKKzIwMDgtMDctMzEgU2Fua2FyIFRhbmd1dHVyaSAgPHNhbmthcmFkaXR5 YUBnbWFpbC5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAg ICAgIGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEzCisKKyAgIEVu aGFuY2luZyByb2xlIGF0dHJpYnV0ZToKKyAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAg IE1hZGUgY2hhbmdlcyB0byBwb3B1bGF0ZSB0aGUgcm9sZSBhdHRyaWJ1dGUgYWxzby4KKyAgIDEu IFdlYktpdCBkb2Vzbid0IHBvcHVsYXRlIHRoZSByb2xlIGF0dHJpYnV0ZSBmb3IgPHRhYmxlPiB0 YWdzLkZpeGVkIHRoYXQuCisgICAyLiBMaXN0Um9sZSBpcyBhbHJlYWR5IHByZXNlbnQgaW4gV2Vi S2l0LiBCdXQsIGl0IGlzIG5vdCBwcm9wZXJseSAKKyAgIGFzc2lnbmVkIHRvIG5vZGVzLiBJZGVh bGx5LCBhbGwgbm9kZXMgdGhhdCBjb3JyZXNwb25kIHRvIDxsaT4sPG9sPiAKKyAgIGFuZCA8ZGw+ IHRhZ3Mgc2hvdWxkIGJlIGFzc2lnbmVkIHRoaXMgcm9sZS4gQWRkZWQgdGhlIGNvZGUgdG8KKyAg IHByb3Blcmx5IGFzc2lnbiB0aGlzIHJvbGUgdG8gdGhlIHZhbGlkIG5vZGVzLgorICAgMy4gSW4g RmlyZWZveCwgYWJiciwgYWNyb255bSBhbmQgcSB0YWdzIGFyZSBoYW5kbGVkIHNwZWNpYWxseS4g VGhleSBhcmUKKyAgIHRyZWF0ZWQgYXMgZ3JvdXBpbmcgaXJyZXNwZWN0aXZlIG9mIHRoZWlyIGRp c3BsYXkgcHJvcGVydGllcy4gVGhvc2UgCisgICB0YWdzIGFyZSBhc3NnaW5lZCBncm91cHJvbGUu IEJ1dCwgd2Via2l0IGFzc2lnbnMgY2xpZW50IHJvbGUgdG8gdGhvc2UKKyAgIHRhZ3MuIFNvLCBN YWRlIGNoYW5nZXMgdG8gc3luYyB1cCB3ZWJraXQgYmVoYXZpb3VyIHdpdGggRmlyZWZveCAyLjAu MC4xNC4KKworICAgICAgICBXQVJOSU5HOiBOTyBURVNUIENBU0VTIEFEREVEIE9SIENIQU5HRUQK KworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGlsZHJlbik6CisgICAgICAgICogcGFnZS9B Y2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2Jq ZWN0OjpjaGlsZHJlbik6CisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRpdGxl KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVu KToKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxk cmVuKToKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKwogMjAw OC0wNy0zMCAgVGltb3RoeSBIYXRjaGVyICA8dGltb3RoeUBhcHBsZS5jb20+CiAKICAgICAgICAg Rml4IHZhcmlvdXMgbWlub3IgYnVncyB3aXRoIHN0eWxlIGVkaXRpbmcgaW4gdGhlIEluc3BlY3Rv ci4KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAJKHJldmlzaW9uIDM1NDc1 KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkp CkBAIC05NzcsNyArOTc3LDcgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpjaGlsZHJlbkNo YW5nZQogICAgIHJldHVybjsKIH0KIAotdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGls ZHJlbigpCit2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QKIHsK IH0KIApJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCShyZXZpc2lvbiAzNTQ3NSkK KysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAg LTMwOSw4ICszMDksOCBAQCBwdWJsaWM6CiAgICAgYm9vbCBwZXJmb3JtRGVmYXVsdEFjdGlvbigp IGNvbnN0IHsgcmV0dXJuIHByZXNzKCk7IH0KICAgICAKICAgICB2aXJ0dWFsIHZvaWQgY2hpbGRy ZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImIGNoaWxkcmVuKCkgeyByZXR1cm4gbV9jaGlsZHJlbjsgfQotICAgIHZpcnR1YWwgdm9pZCBh ZGRDaGlsZHJlbigpOworICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yJiBjaGlsZHJlbigpIGNvbnN0eyByZXR1cm4gbV9jaGlsZHJlbjsgfQorICAgIHZpcnR1YWwg dm9pZCBhZGRDaGlsZHJlbigpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBoYXNDaGlsZHJlbigp IGNvbnN0IHsgcmV0dXJuIG1faGF2ZUNoaWxkcmVuOyB9OwogICAgIHZpcnR1YWwgdm9pZCBzZWxl Y3RlZENoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYpOwogICAgIHZpcnR1YWwg dm9pZCB2aXNpYmxlQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CkBAIC0z ODIsNyArMzgyLDcgQEAgcHVibGljOgogCiBwcm90ZWN0ZWQ6CiAgICAgdW5zaWduZWQgbV9pZDsK LSAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbV9jaGlsZHJlbjsKKyAgICBtdXRhYmxl IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2NoaWxkcmVuOwogICAgIG11dGFibGUgYm9v bCBtX2hhdmVDaGlsZHJlbjsKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgY2xlYXJDaGlsZHJlbigp OwpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkocmV2 aXNpb24gMzU0NzUpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTIwMDIsNyArMjAwMiw3IEBAIEFjY2Vzc2liaWxpdHlSb2xl IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmoKICAgICAgICAgcmV0dXJuIGFyaWFSb2xlOwogICAgIAog ICAgIGlmIChub2RlICYmIG5vZGUtPmlzTGluaygpKSB7Ci0gICAgICAgIGlmIChtX3JlbmRlcmVy LT5pc0ltYWdlKCkpCisgICAgICAgIGlmIChpc05hdGl2ZUltYWdlKCkpCiAgICAgICAgICAgICBy ZXR1cm4gSW1hZ2VNYXBSb2xlOwogICAgICAgICByZXR1cm4gV2ViQ29yZUxpbmtSb2xlOwogICAg IH0KQEAgLTIwMTksNiArMjAxOSw4IEBAIEFjY2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlS ZW5kZXJPYmoKICAgICB9CiAgICAgaWYgKG1fcmVuZGVyZXItPmlzUmVuZGVyVmlldygpKQogICAg ICAgICByZXR1cm4gV2ViQXJlYVJvbGU7CisgICAgaWYgKG1fcmVuZGVyZXItPmlzVGFibGUoKSkK KyAgICAgICAgcmV0dXJuIFRhYmxlUm9sZTsKICAgICAKICAgICBpZiAobV9yZW5kZXJlci0+aXNU ZXh0RmllbGQoKSkKICAgICAgICAgcmV0dXJuIFRleHRGaWVsZFJvbGU7CkBAIC0yMDQ3LDggKzIw NDksMTQgQEAgQWNjZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0eVJlbmRlck9iagogICAgIAog ICAgIGlmIChoZWFkaW5nTGV2ZWwobV9yZW5kZXJlci0+ZWxlbWVudCgpKSAhPSAwKQogICAgICAg ICByZXR1cm4gSGVhZGluZ1JvbGU7Ci0gICAgCi0gICAgaWYgKG1fcmVuZGVyZXItPmlzQmxvY2tG bG93KCkgfHwgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShsYWJlbFRhZykpKQorCisgICAgaWYo aXNMaXN0RWxlbWVudChub2RlKSkKKyAgICAgICAgcmV0dXJuIExpc3RSb2xlOworICAgICAgICAK KyAgICBpZiAobV9yZW5kZXJlci0+aXNCbG9ja0Zsb3coKSB8fCAobm9kZSAmJiAobm9kZS0+aGFz VGFnTmFtZShsYWJlbFRhZykKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHx8IG5vZGUtPmhhc1RhZ05hbWUoYWJiclRhZykKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx8IG5vZGUtPmhhc1RhZ05hbWUoYWNyb255 bVRhZykKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx8 IG5vZGUtPmhhc1RhZ05hbWUocVRhZykpKSkKICAgICAgICAgcmV0dXJuIEdyb3VwUm9sZTsKICAg ICAKICAgICByZXR1cm4gVW5rbm93blJvbGU7CkBAIC0yMTcyLDE0ICsyMTgwLDE0IEBAIHZvaWQg QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4KICAgICB9CiB9CiAKLWNvbnN0IEFj Y2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4oKQorY29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdDo6 QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojpj aGlsZHJlbigpIGNvbnN0CiB7CiAgICAgaWYgKCFtX2hhdmVDaGlsZHJlbikKICAgICAgICAgYWRk Q2hpbGRyZW4oKTsKICAgICByZXR1cm4gbV9jaGlsZHJlbjsKIH0KIAotdm9pZCBBY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpCit2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QKIHsKICAgICAvLyBJZiB0aGUgbmVlZCB0byBhZGQg bW9yZSBjaGlsZHJlbiBpbiBhZGRpdGlvbiB0byBleGlzdGluZyBjaGlsZHJlbiBhcmlzZXMsIAog ICAgIC8vIGNoaWxkcmVuQ2hhbmdlZCBzaG91bGQgaGF2ZSBiZWVuIGNhbGxlZCwgbGVhdmluZyB0 aGUgb2JqZWN0IHdpdGggbm8gY2hpbGRyZW4uCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0LmgJKHJldmlzaW9uIDM1NDc1KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtMTcyLDcgKzE3Miw3IEBA IHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZ2V0RG9jdW1lbnRMaW5rcyhBY2Nlc3NpYmlsaXR5 Q2hpbGRyZW5WZWN0b3ImKSBjb25zdDsKICAgICB2aXJ0dWFsIEZyYW1lVmlldyogZG9jdW1lbnRG cmFtZVZpZXcoKSBjb25zdDsKICAgICAKLSAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlD aGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxp dHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKSBjb25zdDsKICAgICAKICAgICB2aXJ0dWFsIHZv aWQgc2V0Rm9jdXNlZChib29sKTsKICAgICB2aXJ0dWFsIHZvaWQgc2V0U2VsZWN0ZWRUZXh0UmFu Z2UoY29uc3QgUGxhaW5UZXh0UmFuZ2UmKTsKQEAgLTE4MCw3ICsxODAsNyBAQCBwdWJsaWM6CiAg ICAgCiAgICAgdmlydHVhbCB2b2lkIGRldGFjaCgpOwogICAgIHZpcnR1YWwgdm9pZCBjaGlsZHJl bkNoYW5nZWQoKTsKLSAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFs IHZvaWQgYWRkQ2hpbGRyZW4oKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgc2VsZWN0ZWRDaGls ZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgdmlz aWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYpOwogICAgIHZpcnR1YWwg Ym9vbCBzaG91bGRGb2N1c0FjdGl2ZURlc2NlbmRhbnQoKSBjb25zdDsK 22581 2008-07-31 13:15:44 -0700 2008-08-03 13:44:21 -0700 Updated patch for Document Role DocumentRole3_patch.txt text/plain 3423 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ4OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTQgQEAKKzIwMDgtMDctMzEgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWErYnVnemlsbGFAZ21haWwuY29tPgorCisgICAgICAgIEFkZCBhbiBhY2Nlc3NpYmlsaXR5IHJv bGUgZm9yIGRvY3VtZW50IG9iamVjdHMuIFBhcnQgb2YKKyAgICAgICAgaHR0cDovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAwMTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBXQVJOSU5HOiBOTyBURVNUIENBU0VTIEFEREVEIE9SIENI QU5HRUQKKworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAo V2ViQ29yZTo6KTogQWRkIERvY3VtZW50Um9sZSB0byBBY2Nlc3NpYmlsaXR5Um9sZSBlbnVtCisg ICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDogCisgICAgICAgIChX ZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjYW5TZXRGb2N1c0F0dHJpYnV0ZSk6 IFJldHVybgorICAgICAgICB0cnVlIGZvciBEb2N1bWVudHMsIG1hdGNoaW5nIEZpcmVmb3guCisK IO+7vzIwMDgtMDctMzEgIEtldmluIE9sbGl2aWVyIDxrZXZpbm9AdGhlb2xsaXZpZXJzLmNvbT4K IAogICAgICAgICBTZWNvbmQgYXR0ZW1wdCBhdCBXaW5kb3dzL3d4IGJ1aWxkIGZpeC4gSW5zdGVh ZCBvZiBhdm9pZGluZyBpbmNsdXNpb24gb2Ygd2luZG93cy5oLApJbmRleDogV2ViQ29yZS9wYWdl L0FjY2Vzc2liaWxpdHlPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNz aWJpbGl0eU9iamVjdC5oCShyZXZpc2lvbiAzNTQ4NykKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3Np YmlsaXR5T2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0NCw3ICsxNDQsOCBAQCBlbnVtIEFj Y2Vzc2liaWxpdHlSb2xlIHsKICAgICBXZWJBcmVhUm9sZSwKICAgICBIZWFkaW5nUm9sZSwKICAg ICBMaXN0Qm94Um9sZSwKLSAgICBMaXN0Qm94T3B0aW9uUm9sZQorICAgIExpc3RCb3hPcHRpb25S b2xlLAorICAgIERvY3VtZW50Um9sZQogfTsKIAogc3RydWN0IFZpc2libGVQb3NpdGlvblJhbmdl IHsKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJl dmlzaW9uIDM1NDg3KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMDk0LDYgKzIwOTQsNyBAQCBib29sIEFjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3Q6OmNhblNldEZvCiAgICAgICAgIGNhc2UgUG9wVXBCdXR0b25Sb2xlOgog ICAgICAgICBjYXNlIENoZWNrQm94Um9sZToKICAgICAgICAgY2FzZSBSYWRpb0J1dHRvblJvbGU6 CisgICAgICAgIGNhc2UgRG9jdW1lbnRSb2xlOiAgICAgICAgCiAgICAgICAgICAgICByZXR1cm4g dHJ1ZTsKICAgICAgICAgY2FzZSBVbmtub3duUm9sZToKICAgICAgICAgY2FzZSBTbGlkZXJSb2xl OgpJbmRleDogV2ViS2l0L3dpbi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9D aGFuZ2VMb2cJKHJldmlzaW9uIDM1NDg5KQorKysgV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtp bmcgY29weSkKQEAgLTEsMyArMSwxMSBAQAorMjAwOC0wNy0zMSAgU2Fua2FyIFRhbmd1dHVyaSAg PHNhbmthcmFkaXR5YStidWd6aWxsYUBnbWFpbC5jb20+CisKKyAgICAgICAgQWRkIGFuIGFjY2Vz c2liaWxpdHkgcm9sZSBmb3IgRG9jdW1lbnQgb2JqZWN0cy4gUGFydCBvZgorICAgICAgICBodHRw Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDAxMworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIEFjY2Vzc2libGVEb2N1bWVudC5jcHA6 CisgICAgICAgIChBY2Nlc3NpYmxlRG9jdW1lbnQ6OnJvbGUpOiBPdmVycmlkZSByb2xlKCkgZnVu Y3Rpb24gb2YgCisgICAgICAgIEFjY2Vzc2libGVCYXNlLmNwcCBmaWxlLgorICAgICAgICAqIEFj Y2Vzc2libGVEb2N1bWVudC5oOiBJbmNsdWRlIHJvbGUoKSBmdW5jdGlvbiBzaWduYXR1cmUgaW4K KyAgICAgICAgaGVhZGVyIGZpbGUuCisKIDIwMDgtMDctMzEgIEFsZXhleSBQcm9za3VyeWFrb3Yg IDxhcEB3ZWJraXQub3JnPgogCiAgICAgICAgIFJ1YmJlci1zdGFtcGVkIGJ5IE1hY2llai4KSW5k ZXg6IFdlYktpdC93aW4vQWNjZXNzaWJsZURvY3VtZW50LmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXQvd2luL0FjY2Vzc2libGVEb2N1bWVudC5jcHAJKHJldmlzaW9uIDM1NDg3KQorKysgV2ViS2l0 L3dpbi9BY2Nlc3NpYmxlRG9jdW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCwx MSBAQCBBY2Nlc3NpYmxlRG9jdW1lbnQ6OkFjY2Vzc2libGVEb2N1bWVudChECiB7CiB9CiAKK2xv bmcgQWNjZXNzaWJsZURvY3VtZW50Ojpyb2xlKCkgY29uc3QKK3sKKyAgICByZXR1cm4gUk9MRV9T WVNURU1fRE9DVU1FTlQ7Cit9CisKIERvY3VtZW50KiBBY2Nlc3NpYmxlRG9jdW1lbnQ6OmRvY3Vt ZW50KCkgY29uc3QKIHsKICAgICBpZiAoIW1fb2JqZWN0KQpJbmRleDogV2ViS2l0L3dpbi9BY2Nl c3NpYmxlRG9jdW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0FjY2Vzc2libGVEb2N1 bWVudC5oCShyZXZpc2lvbiAzNTQ4NykKKysrIFdlYktpdC93aW4vQWNjZXNzaWJsZURvY3VtZW50 LmgJKHdvcmtpbmcgY29weSkKQEAgLTM1LDYgKzM1LDkgQEAgY2xhc3MgQWNjZXNzaWJsZURvY3Vt ZW50IDogcHVibGljIEFjY2VzcwogcHVibGljOgogICAgIEFjY2Vzc2libGVEb2N1bWVudChEb2N1 bWVudCopOwogICAgIERvY3VtZW50KiBkb2N1bWVudCgpIGNvbnN0OworCitwcm90ZWN0ZWQ6Cisg ICAgbG9uZyByb2xlKCkgY29uc3Q7CiB9OwogCiAjZW5kaWYgLy8gQWNjZXNzaWJsZURvY3VtZW50 X2gK 22582 2008-07-31 13:29:04 -0700 2008-08-03 14:04:16 -0700 Update patch for Separator Role SeparatorRole_patch.txt text/plain 3296 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ2MykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUgQEAKKzIwMDgtMDctMzAgIHN0YW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21h aWwuY29tPgorCisgICAgICAgIEFkZCBhbiBhY2Nlc3NpYmlsaXR5IHJvbGUgZm9yIDxocj4gdGFn cy4gUGFydCBvZgorICAgICAgICBodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMDAxMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURERUQgT1IgQ0hBTkdFRAorCisgICAgICAgICogcGFn ZS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CisgICAgICAgIChXZWJDb3JlOjopOkFkZCBTZXBhcmF0 b3IgUm9sZSB0byBBY2Nlc3NpYmlsaXR5Um9sZSBlbnVtLgorICAgICAgICAqIHBhZ2UvQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0Ojpyb2xlVmFsdWUpOiBSZXR1cm4gU2VwYXJhdG9yCisgICAgICAgIHJvbGUg aWYgcmVuZGVyZWQgb2JqZWN0IGhhcyA8aHI+IHRhZy4KKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3Q6OmNhblNldEZvY3VzQXR0cmlidXRlKTogcmV0dXJuCisgICAg ICAgIGZhbHNlIGZvciA8aHI+IHRhZ3MsIG1hdGNoaW5nIEZpcmVmb3guCisKIDIwMDgtMDctMzAg IENocmlzdGlhbiBEeXdhbiAgPGNocmlzdGlhbkB0d290b2FzdHMuZGU+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgTWFyay4KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAkocmV2aXNp b24gMzU0NjMpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCSh3b3JraW5n IGNvcHkpCkBAIC0xNDQsNyArMTQ0LDggQEAgZW51bSBBY2Nlc3NpYmlsaXR5Um9sZSB7CiAgICAg V2ViQXJlYVJvbGUsCiAgICAgSGVhZGluZ1JvbGUsCiAgICAgTGlzdEJveFJvbGUsCi0gICAgTGlz dEJveE9wdGlvblJvbGUKKyAgICBMaXN0Qm94T3B0aW9uUm9sZSwKKyAgICBTZXBhcmF0b3JSb2xl CiB9OwogCiBzdHJ1Y3QgVmlzaWJsZVBvc2l0aW9uUmFuZ2UgewpJbmRleDogV2ViQ29yZS9wYWdl L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFn ZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkocmV2aXNpb24gMzU0NjMpCisrKyBXZWJD b3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTIwMDYsNiArMjAwNiw4IEBAIEFjY2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxpdHlSZW5kZXJP YmoKICAgICAgICAgICAgIHJldHVybiBJbWFnZU1hcFJvbGU7CiAgICAgICAgIHJldHVybiBXZWJD b3JlTGlua1JvbGU7CiAgICAgfQorICAgIGlmIChtX3JlbmRlcmVyLT5pc0hSKCkpCisgICAgICAg IHJldHVybiBTZXBhcmF0b3JSb2xlOwogICAgIGlmIChtX3JlbmRlcmVyLT5pc0xpc3RNYXJrZXIo KSkKICAgICAgICAgcmV0dXJuIExpc3RNYXJrZXJSb2xlOwogICAgIGlmIChub2RlICYmIG5vZGUt Pmhhc1RhZ05hbWUoYnV0dG9uVGFnKSkKQEAgLTIxNDIsNiArMjE0NCw3IEBAIGJvb2wgQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdDo6Y2FuU2V0Rm8KICAgICAgICAgY2FzZSBIZWFkaW5nUm9sZToK ICAgICAgICAgY2FzZSBMaXN0Qm94Um9sZToKICAgICAgICAgY2FzZSBMaXN0Qm94T3B0aW9uUm9s ZToKKyAgICAgICAgY2FzZSBTZXBhcmF0b3JSb2xlOgogICAgICAgICAgICAgcmV0dXJuIGZhbHNl OwogICAgIH0KICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKSW5kZXg6IFdlYktpdC9DaGFuZ2VM b2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViS2l0L0NoYW5nZUxvZwkocmV2aXNpb24gMzU0NjMpCisrKyBX ZWJLaXQvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTAgQEAKKzIwMDgtMDct MzAgIHN0YW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21haWwuY29tPgorCisgICAgICAgIEFkZCBh IG5ldyBhY2Nlc3NpYmlsaXR5IHJvbGUgZm9yIDxocj4gdGFncy4gUGFydCBvZgorICAgICAgICBo dHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDAxMworCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogd2luL0FjY2Vzc2libGVCYXNl LmNwcDoKKyAgICAgICAgKE1TQUFSb2xlKTpyZXR1cm4gUk9MRV9TWVNURU1fU0VQQVJBVE9SIGZv ciBTZXBhcmF0b3Igcm9sZXMuCisKIDIwMDgtMDctMTEgIFN0ZXBoYW5pZSBMZXdpcyAgPHNsZXdp c0BhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4OiBX ZWJLaXQvd2luL0FjY2Vzc2libGVCYXNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0Fj Y2Vzc2libGVCYXNlLmNwcAkocmV2aXNpb24gMzU0NjMpCisrKyBXZWJLaXQvd2luL0FjY2Vzc2li bGVCYXNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTY1LDYgKzU2NSw4IEBAIHN0YXRpYyBsb25n IE1TQUFSb2xlKEFjY2Vzc2liaWxpdHlSb2xlIHIKICAgICAgICAgY2FzZSBXZWJDb3JlOjpJbWFn ZU1hcFJvbGU6CiAgICAgICAgIGNhc2UgV2ViQ29yZTo6SW1hZ2VSb2xlOgogICAgICAgICAgICAg cmV0dXJuIFJPTEVfU1lTVEVNX0dSQVBISUM7CisgICAgICAgIGNhc2UgV2ViQ29yZTo6U2VwYXJh dG9yUm9sZToKKyAgICAgICAgICAgIHJldHVybiBST0xFX1NZU1RFTV9TRVBBUkFUT1I7CiAgICAg ICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAvLyBUaGlzIGlzIHRoZSBkZWZhdWx0IHJvbGUgZm9y IE1TQUEuCiAgICAgICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fQ0xJRU5UOwo= 22583 2008-07-31 13:32:04 -0700 2008-08-03 14:07:01 -0700 Updated patch for ListItemRole ListItemRole_Patch.txt text/plain 3318 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ2MykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUgQEAKKzIwMDgtMDctMzAgIHN0YW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21h aWwuY29tPgorICAgICAgICBBZGQgYSBuZXcgYWNjZXNzaWJpbGl0eSByb2xlIGZvciBsaXN0IGl0 ZW1zLiBQYXJ0IG9mCisgICAgICAgIGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwMDEzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgV0FSTklORzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFOR0VECisKKyAgICAgICAgKiBw YWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaDoKKyAgICAgICAgKFdlYkNvcmU6Oik6IEFkZCBMaXN0 SXRlbVJvbGUgdG8gYWNjZXNzaWJpbGl0eVJvbGUgZW51bS4KKyAgICAgICAgKiBwYWdlL0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdDo6cm9sZVZhbHVlKTogUmV0dXJuCisgICAgICAgIGxpc3RJdGVtUm9sZSB3 aGVuIHJlbmRlcmVkIG9iamVjdCBpcyBhIGxpc3QgaXRlbS4KKyAgICAgICAgKFdlYkNvcmU6OkFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNhblNldEZvY3VzQXR0cmlidXRlKTogUmV0dXJuCisg ICAgICAgIHRydWUgZm9yIExpc3RJdGVtUm9sZSwgbWF0Y2hpbmcgZmlyZWZveC4KKwogMjAwOC0w Ny0zMCAgQ2hyaXN0aWFuIER5d2FuICA8Y2hyaXN0aWFuQHR3b3RvYXN0cy5kZT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBNYXJrLgpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmpl Y3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCShy ZXZpc2lvbiAzNTQ2MykKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHdv cmtpbmcgY29weSkKQEAgLTE0NCw3ICsxNDQsOCBAQCBlbnVtIEFjY2Vzc2liaWxpdHlSb2xlIHsK ICAgICBXZWJBcmVhUm9sZSwKICAgICBIZWFkaW5nUm9sZSwKICAgICBMaXN0Qm94Um9sZSwKLSAg ICBMaXN0Qm94T3B0aW9uUm9sZQorICAgIExpc3RCb3hPcHRpb25Sb2xlLAorICAgIExpc3RJdGVt Um9sZQogfTsKIAogc3RydWN0IFZpc2libGVQb3NpdGlvblJhbmdlIHsKSW5kZXg6IFdlYkNvcmUv cGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDM1NDYzKQorKysg V2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkp CkBAIC0yMDA2LDYgKzIwMDYsOCBAQCBBY2Nlc3NpYmlsaXR5Um9sZSBBY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqCiAgICAgICAgICAgICByZXR1cm4gSW1hZ2VNYXBSb2xlOwogICAgICAgICByZXR1cm4g V2ViQ29yZUxpbmtSb2xlOwogICAgIH0KKyAgICBpZiAobV9yZW5kZXJlci0+aXNMaXN0SXRlbSgp KQorICAgICAgICByZXR1cm4gTGlzdEl0ZW1Sb2xlOwogICAgIGlmIChtX3JlbmRlcmVyLT5pc0xp c3RNYXJrZXIoKSkKICAgICAgICAgcmV0dXJuIExpc3RNYXJrZXJSb2xlOwogICAgIGlmIChub2Rl ICYmIG5vZGUtPmhhc1RhZ05hbWUoYnV0dG9uVGFnKSkKQEAgLTIwOTQsNiArMjA5Niw3IEBAIGJv b2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2FuU2V0Rm8KICAgICAgICAgY2FzZSBQb3BV cEJ1dHRvblJvbGU6CiAgICAgICAgIGNhc2UgQ2hlY2tCb3hSb2xlOgogICAgICAgICBjYXNlIFJh ZGlvQnV0dG9uUm9sZToKKyAgICAgICAgY2FzZSBMaXN0SXRlbVJvbGU6CiAgICAgICAgICAgICBy ZXR1cm4gdHJ1ZTsKICAgICAgICAgY2FzZSBVbmtub3duUm9sZToKICAgICAgICAgY2FzZSBTbGlk ZXJSb2xlOgpJbmRleDogV2ViS2l0L0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNTQ2MykKKysrIFdlYktpdC9DaGFuZ2VMb2cJKHdvcmtpbmcgY29w eSkKQEAgLTEsMyArMSwxMCBAQAorMjAwOC0wNy0zMCAgc3Rhbmd1dHVyaSAgPHNhbmthcmFkaXR5 YUBnbWFpbC5jb20+CisgICAgICAgIEFkZCBhIG5ldyBhY2Nlc3NpYmlsaXR5IHJvbGUgZm9yIGxp c3QgaXRlbXMuIFBhcnQgb2YKKyAgICAgICAgaHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2lk LmNnaT9pZD0yMDAxMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgICogd2luL0FjY2Vzc2libGVCYXNlLmNwcDoKKyAgICAgICAgKE1TQUFSb2xlKTogUmV0 dXJuIFJPTEVfU1lTVEVNX0xJU1RJVEVNIGZvciBsaXNpdGVtIHJvbGUuCisKIDIwMDgtMDctMTEg IFN0ZXBoYW5pZSBMZXdpcyAgPHNsZXdpc0BhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRGFyaW4gQWRsZXIuCkluZGV4OiBXZWJLaXQvd2luL0FjY2Vzc2libGVCYXNlLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvd2luL0FjY2Vzc2libGVCYXNlLmNwcAkocmV2aXNpb24gMzU0NjMp CisrKyBXZWJLaXQvd2luL0FjY2Vzc2libGVCYXNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTY1 LDYgKzU2NSw4IEBAIHN0YXRpYyBsb25nIE1TQUFSb2xlKEFjY2Vzc2liaWxpdHlSb2xlIHIKICAg ICAgICAgY2FzZSBXZWJDb3JlOjpJbWFnZU1hcFJvbGU6CiAgICAgICAgIGNhc2UgV2ViQ29yZTo6 SW1hZ2VSb2xlOgogICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0dSQVBISUM7CisgICAg ICAgIGNhc2UgV2ViQ29yZTo6TGlzdEl0ZW1Sb2xlOgorICAgICAgICAgICAgcmV0dXJuIFJPTEVf U1lTVEVNX0xJU1RJVEVNOwogICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgLy8gVGhpcyBp cyB0aGUgZGVmYXVsdCByb2xlIGZvciBNU0FBLgogICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lT VEVNX0NMSUVOVDsK 22584 2008-07-31 13:37:43 -0700 2008-08-14 00:20:00 -0700 Updated patch for CellRole CellRole_patch.txt text/plain 3408 sankaraditya+bugzilla SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDM1NDY2 KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDgtMDct MzAgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21haWwuY29tPgorCisgICAgICAg IEFkZCBhIG5ldyBhY2Nlc3NpYmlsaXR5IHJvbGUgaS5lIENlbGxSb2xlIGZvciA8dGQ+LDx0aD4g dGFncy4KKyAgICAgICAgUGFydCBvZiBodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMDAxMworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgICogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaDoKKyAgICAgICAgKFdlYkNv cmU6Oik6QWRkIENlbGxSb2xlIHRvIEFjY2Vzc2liaWxpdHlSb2xlIGVudW0uCisgICAgICAgICog V2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cm9sZVZhbHVlKTpSZXR1cm4gQ2VsbFJv bGUKKyAgICAgICAgaWYgdGhlIHJlbmRlcmVkb2JqZWN0IGlzIGEgdGFibGUgY2VsbCBvciBpZiBp dCBjb250YWlucyA8dGg+IHRhZ25hbWUuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjpjYW5TZXRGb2N1c0F0dHJpYnV0ZSk6IFJldHVybgorICAgICAgICB0cnVl IGZvciBDZWxsUm9sZS4KKwogMjAwOC0wNy0zMCAgTWFyY28gQmFyaXNpb25lICA8bWFyY28uYmFy aXNpb25lQGNvbGxhYm9yYS5jby51az4KIAogICAgICAgICBSZXZpZXdlZCBieSBIb2xnZXIuCklu ZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHJldmlzaW9uIDM1NDYwKQorKysgV2Vi Q29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtMTQ0LDcg KzE0NCw4IEBAIGVudW0gQWNjZXNzaWJpbGl0eVJvbGUgewogICAgIFdlYkFyZWFSb2xlLAogICAg IEhlYWRpbmdSb2xlLAogICAgIExpc3RCb3hSb2xlLAotICAgIExpc3RCb3hPcHRpb25Sb2xlCisg ICAgTGlzdEJveE9wdGlvblJvbGUsCisgICAgQ2VsbFJvbGUKIH07CiAKIHN0cnVjdCBWaXNpYmxl UG9zaXRpb25SYW5nZSB7CkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuY3BwCShyZXZpc2lvbiAzNTQ2MCkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjAyNiw2ICsyMDI2LDkgQEAgQWNj ZXNzaWJpbGl0eVJvbGUgQWNjZXNzaWJpbGl0eVJlbmRlck9iagogICAgIGlmIChtX3JlbmRlcmVy LT5pc1RleHRBcmVhKCkpCiAgICAgICAgIHJldHVybiBUZXh0QXJlYVJvbGU7CiAgICAgCisgICAg aWYgKG1fcmVuZGVyZXItPmlzVGFibGVDZWxsKCkgfHwgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFt ZSh0aFRhZykpKQorICAgICAgICByZXR1cm4gQ2VsbFJvbGU7CisKICAgICBpZiAobm9kZSAmJiBu b2RlLT5oYXNUYWdOYW1lKGlucHV0VGFnKSkgewogICAgICAgICBIVE1MSW5wdXRFbGVtZW50KiBp bnB1dCA9IHN0YXRpY19jYXN0PEhUTUxJbnB1dEVsZW1lbnQqPihub2RlKTsKICAgICAgICAgaWYg KGlucHV0LT5pbnB1dFR5cGUoKSA9PSBIVE1MSW5wdXRFbGVtZW50OjpDSEVDS0JPWCkKQEAgLTIw OTQsNiArMjA5Nyw3IEBAIGJvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2FuU2V0Rm8K ICAgICAgICAgY2FzZSBQb3BVcEJ1dHRvblJvbGU6CiAgICAgICAgIGNhc2UgQ2hlY2tCb3hSb2xl OgogICAgICAgICBjYXNlIFJhZGlvQnV0dG9uUm9sZToKKyAgICAgICAgY2FzZSBDZWxsUm9sZTog ICAgICAgIAogICAgICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgICAgIGNhc2UgVW5rbm93blJv bGU6CiAgICAgICAgIGNhc2UgU2xpZGVyUm9sZToKSW5kZXg6IFdlYktpdC9DaGFuZ2VMb2cKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0L0NoYW5nZUxvZwkocmV2aXNpb24gMzU0NjYpCisrKyBXZWJLaXQv Q2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTEgQEAKKzIwMDgtMDctMzAgIFNh bmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0eWFAZ21haWwuY29tPgorCisgICAgICAgIEFkZCBh IG5ldyBhY2Nlc3NpYmxlIHJvbGUgaS5lIENlbGxSb2xlIGZvciA8dGQ+IGFuZCA8dGg+IHRhZ3Mu CisgICAgICAgIFBhcnQgb2YgaHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjAwMTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IHdpbi9BY2Nlc3NpYmxlQmFzZS5jcHA6CisgICAgICAgIChNU0FBUm9sZSk6IFJldHVybiBST0xF X1NZU1RFTV9DRUxMIGZvciBjZWxscm9sZS4KKwogMjAwOC0wNy0xMSAgU3RlcGhhbmllIExld2lz ICA8c2xld2lzQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4K SW5kZXg6IFdlYktpdC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktp dC93aW4vQWNjZXNzaWJsZUJhc2UuY3BwCShyZXZpc2lvbiAzNTQ2MCkKKysrIFdlYktpdC93aW4v QWNjZXNzaWJsZUJhc2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01NjUsNiArNTY1LDggQEAgc3Rh dGljIGxvbmcgTVNBQVJvbGUoQWNjZXNzaWJpbGl0eVJvbGUgcgogICAgICAgICBjYXNlIFdlYkNv cmU6OkltYWdlTWFwUm9sZToKICAgICAgICAgY2FzZSBXZWJDb3JlOjpJbWFnZVJvbGU6CiAgICAg ICAgICAgICByZXR1cm4gUk9MRV9TWVNURU1fR1JBUEhJQzsKKyAgICAgICAgY2FzZSBXZWJDb3Jl OjpDZWxsUm9sZToKKyAgICAgICAgICAgIHJldHVybiBST0xFX1NZU1RFTV9DRUxMOwogICAgICAg ICBkZWZhdWx0OgogICAgICAgICAgICAgLy8gVGhpcyBpcyB0aGUgZGVmYXVsdCByb2xlIGZvciBN U0FBLgogICAgICAgICAgICAgcmV0dXJuIFJPTEVfU1lTVEVNX0NMSUVOVDsK 22585 2008-07-31 13:58:09 -0700 2008-08-15 12:08:51 -0700 Updated patch to populate Name attribute properly. TitleAttribute_patch.txt text/plain 6225 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ3NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTkgQEAKKzIwMDgtMDctMzEgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWFAZ21haWwuY29tPgorCisgICAgICAgIFBvcHVsYXRlIE5hbWUgYXR0cmlidXRlIG9mIHRoZSBy ZW5kZXJlZCBvYmplY3RzIGNvcnJlY3RseS4gUGFydCBvZgorICAgICAgICBodHRwOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDAxMworCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURERUQgT1Ig Q0hBTkdFRAorCisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKTogQ2hhbmdlIHRo ZSBtZW1iZXIgCisgICAgICAgIGZ1bmN0aW9uIGkuZSBhZGRDaGlsZHJlbigpIHRvIGEgY29uc3Qg ZnVuY3Rpb24uCisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CisgICAgICAg IE1ha2UgbV9jaGlsZHJlbiB2YXJpYWJsZSBhcyBtdXRhYmxlLgorICAgICAgICAoV2ViQ29yZTo6 QWNjZXNzaWJpbGl0eU9iamVjdDo6Y2hpbGRyZW4pOiBDaGFuZ2UgdGhlIG1lbWJlciBmdW5jdGlv bgorICAgICAgICBpLmUgY2hpbGRyZW4oKSB0byBhIGNvbnN0IGZ1bmN0aW9uLiAKKyAgICAgICAg KiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6dGl0bGUpOiBQb3B1bGF0ZSB0aGUgTmFtZQorICAg ICAgICBhdHRyaWJ1dGUgb2YgcmVuZGVyZWQgb2JqZWN0cyBwcm9wZXJseSwgbWF0Y2hpbmcgRmly ZWZveC4KKyAgICAgICAgMS4gRm9yIHRleHQgbm9kZXMsIHJldHVybiByYXcgdGV4dCBjb250ZW50 IHByZXNlbnQgdW5kZXIgdGhlIG5vZGUuCisgICAgICAgIDIuIEZvciBpbWFnZSBub2RlcywgcmV0 dXJuIHRoZSB2YWx1ZSBvZiBhbHQgYXR0cmlidXRlLgorICAgICAgICAzLiBGb3IgbGlua3MgYW5k IGhlYWRpbmcgbm9kZXMsIHJldHVybiBzdHJpbmcgdGhhdCBpcyBmb3JtZWQgYnkKKyAgICAgICAg ICAgY29uY2F0ZW5hdGluZyB0aGUgdGl0bGUoKSB2YWx1ZXMgb2YgYWxsIG9mIGl0cyBjaGlsZHJl bi4KKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVu KTogQ2hhbmdlIHRoZSBtZW1iZXIgCisgICAgICAgIGZ1bmN0aW9uIGkuZSBjaGlsZHJlbigpIHRv IGEgY29uc3QgZnVuY3Rpb24uCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0OjphZGRDaGlsZHJlbik6IENoYW5nZSB0aGUgbWVtYmVyCisgICAgICAgIGZ1bmN0aW9u IGkuZSBhZGRDaGlsZHJlbigpIHRvIGEgY29uc3QgZnVuY3Rpb24uCisgICAgICAgICogcGFnZS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Lmg6IENoYW5nZSBhZGRDaGlsZHJlbigpIGFuZAorICAg ICAgICBjaGlsZHJlbigpIGZ1bmN0aW9ucyBpbnRvIGNvbnN0IGZ1bmN0aW9ucy4KKwogMjAwOC0w Ny0zMCAgVGltb3RoeSBIYXRjaGVyICA8dGltb3RoeUBhcHBsZS5jb20+CiAKICAgICAgICAgRml4 IHZhcmlvdXMgbWlub3IgYnVncyB3aXRoIHN0eWxlIGVkaXRpbmcgaW4gdGhlIEluc3BlY3Rvci4K SW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAJKHJldmlzaW9uIDM1NDc1KQor KysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC05NzcsNyArOTc3LDcgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpjaGlsZHJlbkNoYW5n ZQogICAgIHJldHVybjsKIH0KIAotdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGlsZHJl bigpCit2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QKIHsKIH0K IApJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCShyZXZpc2lvbiAzNTQ3NSkKKysr IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTMw OSw4ICszMDksOCBAQCBwdWJsaWM6CiAgICAgYm9vbCBwZXJmb3JtRGVmYXVsdEFjdGlvbigpIGNv bnN0IHsgcmV0dXJuIHByZXNzKCk7IH0KICAgICAKICAgICB2aXJ0dWFsIHZvaWQgY2hpbGRyZW5D aGFuZ2VkKCk7Ci0gICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3Im IGNoaWxkcmVuKCkgeyByZXR1cm4gbV9jaGlsZHJlbjsgfQotICAgIHZpcnR1YWwgdm9pZCBhZGRD aGlsZHJlbigpOworICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9y JiBjaGlsZHJlbigpIGNvbnN0eyByZXR1cm4gbV9jaGlsZHJlbjsgfQorICAgIHZpcnR1YWwgdm9p ZCBhZGRDaGlsZHJlbigpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBoYXNDaGlsZHJlbigpIGNv bnN0IHsgcmV0dXJuIG1faGF2ZUNoaWxkcmVuOyB9OwogICAgIHZpcnR1YWwgdm9pZCBzZWxlY3Rl ZENoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYpOwogICAgIHZpcnR1YWwgdm9p ZCB2aXNpYmxlQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CkBAIC0zODIs NyArMzgyLDcgQEAgcHVibGljOgogCiBwcm90ZWN0ZWQ6CiAgICAgdW5zaWduZWQgbV9pZDsKLSAg ICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbV9jaGlsZHJlbjsKKyAgICBtdXRhYmxlIEFj Y2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2NoaWxkcmVuOwogICAgIG11dGFibGUgYm9vbCBt X2hhdmVDaGlsZHJlbjsKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgY2xlYXJDaGlsZHJlbigpOwpJ bmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkocmV2aXNp b24gMzU0NzUpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTgzMCwxNSArODMwLDMwIEBAIFN0cmluZyBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0Ojp0aXRsZSgKICAgICAgICAgaWYgKGxhYmVsKQogICAgICAgICAgICAgcmV0 dXJuIGxhYmVsLT5pbm5lclRleHQoKTsKICAgICB9CisKKyAgICBpZiAobV9yZW5kZXJlci0+ZWxl bWVudCgpLT5pc0xpbmsoKSB8fCBpc0hlYWRpbmcoKSkgeworICAgICAgICBjb25zdCBBY2Nlc3Np YmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuVmVjdG9yID0gY2hpbGRyZW4oKTsKKyAgICAg ICAgVmVjdG9yPFVDaGFyPiBlbGVtZW50VGV4dDsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0g MDsgaSA8IGNoaWxkcmVuVmVjdG9yLnNpemUoKTsgKytpKSB7CisgICAgICAgICAgICBlbGVtZW50 VGV4dC5hcHBlbmQoJyAnKTsKKyAgICAgICAgICAgIGFwcGVuZChlbGVtZW50VGV4dCwgY2hpbGRy ZW5WZWN0b3JbaV0tPnRpdGxlKCkpOworICAgICAgICB9CisgICAgICAgIHJldHVybiBTdHJpbmc6 OmFkb3B0KGVsZW1lbnRUZXh0KS5zdHJpcFdoaXRlU3BhY2UoKTsKKyAgICB9CiAgICAgCiAgICAg aWYgKHJvbGVWYWx1ZSgpID09IEJ1dHRvblJvbGUKICAgICAgICAgfHwgYXJpYVJvbGUgPT0gTGlz dEJveE9wdGlvblJvbGUKICAgICAgICAgfHwgYXJpYVJvbGUgPT0gTWVudUl0ZW1Sb2xlCi0gICAg ICAgIHx8IGFyaWFSb2xlID09IE1lbnVCdXR0b25Sb2xlCi0gICAgICAgIHx8IGlzSGVhZGluZygp KQorICAgICAgICB8fCBhcmlhUm9sZSA9PSBNZW51QnV0dG9uUm9sZSkKICAgICAgICAgcmV0dXJu IHRleHRVbmRlckVsZW1lbnQoKTsKICAgICAKLSAgICBpZiAoaXNMaW5rKCkpCisgICAgaWYgKGlz SW1hZ2UoKSkgeworICAgICAgICBOb2RlKiBub2RlID0gbV9yZW5kZXJlci0+ZWxlbWVudCgpOwor ICAgICAgICBpZiAobm9kZSAmJiBub2RlLT5pc0VsZW1lbnROb2RlKCkpCisgICAgICAgICAgICBy ZXR1cm4gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG5vZGUpLT5nZXRBdHRyaWJ1dGUoYWx0QXR0cik7 CisgICAgfSAgIAorCisgICAgaWYgKG1fcmVuZGVyZXItPmlzVGV4dCgpKSAgICAKICAgICAgICAg cmV0dXJuIHRleHRVbmRlckVsZW1lbnQoKTsKICAgICAKICAgICByZXR1cm4gU3RyaW5nKCk7CkBA IC0yMTcyLDE0ICsyMTg3LDE0IEBAIHZvaWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hp bGRyZW4KICAgICB9CiB9CiAKLWNvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxp dHlDaGlsZHJlblZlY3RvciYgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4oKQor Y29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGlsZHJlbigpIGNvbnN0CiB7CiAgICAgaWYgKCFt X2hhdmVDaGlsZHJlbikKICAgICAgICAgYWRkQ2hpbGRyZW4oKTsKICAgICByZXR1cm4gbV9jaGls ZHJlbjsKIH0KIAotdm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigp Cit2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QKIHsK ICAgICAvLyBJZiB0aGUgbmVlZCB0byBhZGQgbW9yZSBjaGlsZHJlbiBpbiBhZGRpdGlvbiB0byBl eGlzdGluZyBjaGlsZHJlbiBhcmlzZXMsIAogICAgIC8vIGNoaWxkcmVuQ2hhbmdlZCBzaG91bGQg aGF2ZSBiZWVuIGNhbGxlZCwgbGVhdmluZyB0aGUgb2JqZWN0IHdpdGggbm8gY2hpbGRyZW4uCklu ZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgJKHJldmlzaW9uIDM1 NDc1KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAkod29ya2lu ZyBjb3B5KQpAQCAtMTcyLDcgKzE3Miw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZ2V0 RG9jdW1lbnRMaW5rcyhBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKSBjb25zdDsKICAgICB2 aXJ0dWFsIEZyYW1lVmlldyogZG9jdW1lbnRGcmFtZVZpZXcoKSBjb25zdDsKICAgICAKLSAgICB2 aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKTsKKyAg ICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKSBj b25zdDsKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgc2V0Rm9jdXNlZChib29sKTsKICAgICB2aXJ0 dWFsIHZvaWQgc2V0U2VsZWN0ZWRUZXh0UmFuZ2UoY29uc3QgUGxhaW5UZXh0UmFuZ2UmKTsKQEAg LTE4MCw3ICsxODAsNyBAQCBwdWJsaWM6CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGRldGFjaCgp OwogICAgIHZpcnR1YWwgdm9pZCBjaGlsZHJlbkNoYW5nZWQoKTsKLSAgICB2aXJ0dWFsIHZvaWQg YWRkQ2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKSBjb25zdDsKICAg ICB2aXJ0dWFsIHZvaWQgc2VsZWN0ZWRDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgdmlzaWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGls ZHJlblZlY3RvciYpOwogICAgIHZpcnR1YWwgYm9vbCBzaG91bGRGb2N1c0FjdGl2ZURlc2NlbmRh bnQoKSBjb25zdDsK 22586 2008-07-31 14:12:12 -0700 2008-08-15 10:41:03 -0700 Updated patch to populate Role attribute properly RoleAttribute_patch.txt text/plain 6217 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTQ3NSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTkgQEAKKzIwMDgtMDctMzEgU2Fua2FyIFRhbmd1dHVyaSAgPHNhbmthcmFkaXR5 YUBnbWFpbC5jb20+CisKKyAgICAgICAgUG9wdWxhdGUgUm9sZSBhdHRyaWJ1dGUgb2YgdGhlIHJl bmRlcmVkIG9iamVjdHMgcHJvcGVybHkuIFBhcnQgb2YKKyAgICAgICAgaHR0cDovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAwMTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBXQVJOSU5HOiBOTyBURVNUIENBU0VTIEFEREVEIE9SIENI QU5HRUQKKworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGlsZHJlbik6IENoYW5nZSB0aGUg c2lnbmF0dXJlcyBvZgorICAgICAgICBtZW1iZXIgZnVuY3Rpb25zIGkuZS4gYWRkY2hpbGRyZW4o KSB0byBjb25zdCBmdW5jdGlvbnMuCisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0 Lmg6CisgICAgICAgIENoYW5nZSB0aGUgbV9jaGlsZHJlbiB2YXJpYWJsZSB0byBtdXRhYmxlIHZh cmlhYmxlLgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6Y2hpbGRyZW4p OiBDaGFuZ2UgdGhlIG1lbWJlciBmdW5jdGlvbnMKKyAgICAgICAgaS5lIGFkZGNoaWxkcmVuKCkg YW5kIGNoaWxkcmVuKCkgdG8gY29uc3QgZnVuY3Rpb25zLgorICAgICAgICAqIHBhZ2UvQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0Ojp0aXRsZSk6IFJldHVybiBUYWJsZVJvbGUgaWYgdGhlCisgICAgICAgIHJl bmRlcmVkIG9iamVjdCBpcyBhIHRhYmxlLiBSZXR1cm4gTGlzdFJvbGUgaWYgdGhlIHJlbmRlcmVk IG9iamVjdAorICAgICAgICBpcyBhIGxpc3QgZWxlbWVudC4gUmV0dXJuIGdyb3VwIHJvbGUgaWYg dGhlIHJlbmRlcmVkIG9iamVjdCBoYXMKKyAgICAgICAgYWJiciwgYWNyb255bSBhbmQgcSB0YWdz LCBtYXRjaGluZyBGaXJlZm94LgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdDo6Y2hpbGRyZW4pOiBDaGFuZ2UgY2hpbGRyZW4oKSAKKyAgICAgICAgZnVuY3Rpb24g aW50byBhIGNvbnN0IGZ1bmN0aW9uLgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdDo6YWRkQ2hpbGRyZW4pOiBDaGFuZ2UgYWRkY2hpbGRyZW4oKQorICAgICAgICBm dW5jdGlvbiBpbnRvIGEgY29uc3QgZnVuY3Rpb24uCisgICAgICAgICogcGFnZS9BY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0Lmg6IENoYW5nZSB0aGUgc2lnbnVhdHVyZXMgb2YgCisgICAgICAgIGFk ZGNoaWxkcmVuKCkgYW5kIGNoaWxkcmVuKCkgZnVuY3Rpb25zLiBDaGFuZ2UgdGhlbSB0byBjb25z dCBmdW5jdGlvbnMuCisKIDIwMDgtMDctMzAgIFRpbW90aHkgSGF0Y2hlciAgPHRpbW90aHlAYXBw bGUuY29tPgogCiAgICAgICAgIEZpeCB2YXJpb3VzIG1pbm9yIGJ1Z3Mgd2l0aCBzdHlsZSBlZGl0 aW5nIGluIHRoZSBJbnNwZWN0b3IuCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9i amVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3Qu Y3BwCShyZXZpc2lvbiAzNTQ3NSkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0 LmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTc3LDcgKzk3Nyw3IEBAIHZvaWQgQWNjZXNzaWJpbGl0 eU9iamVjdDo6Y2hpbGRyZW5DaGFuZ2UKICAgICByZXR1cm47CiB9CiAKLXZvaWQgQWNjZXNzaWJp bGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4oKQordm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRD aGlsZHJlbigpIGNvbnN0CiB7CiB9CiAKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 T2JqZWN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3Qu aAkocmV2aXNpb24gMzU0NzUpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5o CSh3b3JraW5nIGNvcHkpCkBAIC0zMDksOCArMzA5LDggQEAgcHVibGljOgogICAgIGJvb2wgcGVy Zm9ybURlZmF1bHRBY3Rpb24oKSBjb25zdCB7IHJldHVybiBwcmVzcygpOyB9CiAgICAgCiAgICAg dmlydHVhbCB2b2lkIGNoaWxkcmVuQ2hhbmdlZCgpOwotICAgIHZpcnR1YWwgY29uc3QgQWNjZXNz aWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbigpIHsgcmV0dXJuIG1fY2hpbGRyZW47IH0K LSAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKTsKKyAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vz c2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKSBjb25zdHsgcmV0dXJuIG1fY2hpbGRy ZW47IH0KKyAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKSBjb25zdDsKICAgICB2aXJ0dWFs IGJvb2wgaGFzQ2hpbGRyZW4oKSBjb25zdCB7IHJldHVybiBtX2hhdmVDaGlsZHJlbjsgfTsKICAg ICB2aXJ0dWFsIHZvaWQgc2VsZWN0ZWRDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgdmlzaWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGls ZHJlblZlY3RvciYpOwpAQCAtMzgyLDcgKzM4Miw3IEBAIHB1YmxpYzoKIAogcHJvdGVjdGVkOgog ICAgIHVuc2lnbmVkIG1faWQ7Ci0gICAgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIG1fY2hp bGRyZW47CisgICAgbXV0YWJsZSBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbV9jaGlsZHJl bjsKICAgICBtdXRhYmxlIGJvb2wgbV9oYXZlQ2hpbGRyZW47CiAgICAgCiAgICAgdmlydHVhbCB2 b2lkIGNsZWFyQ2hpbGRyZW4oKTsKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDM1NDc1KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMDAyLDcgKzIwMDIsNyBA QCBBY2Nlc3NpYmlsaXR5Um9sZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgICAgIHJldHVy biBhcmlhUm9sZTsKICAgICAKICAgICBpZiAobm9kZSAmJiBub2RlLT5pc0xpbmsoKSkgewotICAg ICAgICBpZiAobV9yZW5kZXJlci0+aXNJbWFnZSgpKQorICAgICAgICBpZiAoaXNOYXRpdmVJbWFn ZSgpKQogICAgICAgICAgICAgcmV0dXJuIEltYWdlTWFwUm9sZTsKICAgICAgICAgcmV0dXJuIFdl YkNvcmVMaW5rUm9sZTsKICAgICB9CkBAIC0yMDE5LDYgKzIwMTksOCBAQCBBY2Nlc3NpYmlsaXR5 Um9sZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgfQogICAgIGlmIChtX3JlbmRlcmVyLT5p c1JlbmRlclZpZXcoKSkKICAgICAgICAgcmV0dXJuIFdlYkFyZWFSb2xlOworICAgIGlmIChtX3Jl bmRlcmVyLT5pc1RhYmxlKCkpCisgICAgICAgIHJldHVybiBUYWJsZVJvbGU7CiAgICAgCiAgICAg aWYgKG1fcmVuZGVyZXItPmlzVGV4dEZpZWxkKCkpCiAgICAgICAgIHJldHVybiBUZXh0RmllbGRS b2xlOwpAQCAtMjA0Nyw4ICsyMDQ5LDE0IEBAIEFjY2Vzc2liaWxpdHlSb2xlIEFjY2Vzc2liaWxp dHlSZW5kZXJPYmoKICAgICAKICAgICBpZiAoaGVhZGluZ0xldmVsKG1fcmVuZGVyZXItPmVsZW1l bnQoKSkgIT0gMCkKICAgICAgICAgcmV0dXJuIEhlYWRpbmdSb2xlOwotICAgIAotICAgIGlmICht X3JlbmRlcmVyLT5pc0Jsb2NrRmxvdygpIHx8IChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUobGFi ZWxUYWcpKSkKKworICAgIGlmKGlzTGlzdEVsZW1lbnQobm9kZSkpCisgICAgICAgIHJldHVybiBM aXN0Um9sZTsKKyAgICAgICAgCisgICAgaWYgKG1fcmVuZGVyZXItPmlzQmxvY2tGbG93KCkgfHwg KG5vZGUgJiYgKG5vZGUtPmhhc1RhZ05hbWUobGFiZWxUYWcpCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8fCBub2RlLT5oYXNUYWdOYW1lKGFiYnJUYWcp CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8fCBub2Rl LT5oYXNUYWdOYW1lKGFjcm9ueW1UYWcpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8fCBub2RlLT5oYXNUYWdOYW1lKHFUYWcpKSkpCiAgICAgICAgIHJl dHVybiBHcm91cFJvbGU7CiAgICAgCiAgICAgcmV0dXJuIFVua25vd25Sb2xlOwpAQCAtMjE3Miwx NCArMjE4MCwxNCBAQCB2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuCiAg ICAgfQogfQogCi1jb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRy ZW5WZWN0b3ImIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuKCkKK2NvbnN0IEFj Y2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4oKSBjb25zdAogewogICAgIGlmICghbV9oYXZlQ2hp bGRyZW4pCiAgICAgICAgIGFkZENoaWxkcmVuKCk7CiAgICAgcmV0dXJuIG1fY2hpbGRyZW47CiB9 CiAKLXZvaWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWRkQ2hpbGRyZW4oKQordm9pZCBB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpIGNvbnN0CiB7CiAgICAgLy8g SWYgdGhlIG5lZWQgdG8gYWRkIG1vcmUgY2hpbGRyZW4gaW4gYWRkaXRpb24gdG8gZXhpc3Rpbmcg Y2hpbGRyZW4gYXJpc2VzLCAKICAgICAvLyBjaGlsZHJlbkNoYW5nZWQgc2hvdWxkIGhhdmUgYmVl biBjYWxsZWQsIGxlYXZpbmcgdGhlIG9iamVjdCB3aXRoIG5vIGNoaWxkcmVuLgpJbmRleDogV2Vi Q29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCShyZXZpc2lvbiAzNTQ3NSkKKysr IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgJKHdvcmtpbmcgY29weSkK QEAgLTE3Miw3ICsxNzIsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGdldERvY3VtZW50 TGlua3MoQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJikgY29uc3Q7CiAgICAgdmlydHVhbCBG cmFtZVZpZXcqIGRvY3VtZW50RnJhbWVWaWV3KCkgY29uc3Q7CiAgICAgCi0gICAgdmlydHVhbCBj b25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCk7CisgICAgdmlydHVh bCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgY29uc3Q7CiAg ICAgCiAgICAgdmlydHVhbCB2b2lkIHNldEZvY3VzZWQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lk IHNldFNlbGVjdGVkVGV4dFJhbmdlKGNvbnN0IFBsYWluVGV4dFJhbmdlJik7CkBAIC0xODAsNyAr MTgwLDcgQEAgcHVibGljOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBkZXRhY2goKTsKICAgICB2 aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCB2b2lkIGFkZENoaWxk cmVuKCk7CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVh bCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAg ICAgdmlydHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImKTsKICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkRm9jdXNBY3RpdmVEZXNjZW5kYW50KCkgY29u c3Q7Cg== 22593 2008-08-01 00:29:48 -0700 2008-08-21 21:52:49 -0700 Patch to expose only Relavant Accessible Objects ExposeRelevantAccessibleObjects_patch.txt text/plain 13944 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTUwNykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjggQEAKKzIwMDgtMDctMzEgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWFAZ21haWwuY29tPgorCisgICAgICAgIEV4cG9zZSBvbmx5IFJlbGV2YW50IEFjY2Vzc2libGUg b2JqZWN0cyBpbiBNU0FBIHRyZWUuIFBhcnQgb2YKKyAgICAgICAgaHR0cDovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAwMTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBXQVJOSU5HOiBOTyBURVNUIENBU0VTIEFEREVEIE9SIENIQU5H RUQKKworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppc1RleHRGb3JtYXR0aW5nRWxlbWVudCk6Q3Jl YXRlIGEgbmV3CisgICAgICAgIGZ1bmN0aW9uIHRvIGRldGVybWluZSBpZiB0aGUgcmVuZGVyZWQg b2JqZWN0IGlzIGEgdGV4dCBmb3JtYXR0aW5nCisgICAgICAgIGVsZW1lbnQgb3Igbm90LiBpLGJp ZyxzbWFsbCxiZG8sc3RyaWtlLCBzcGFuIGV0Yy4gYXJlIHRyZWF0ZWQgYXMKKyAgICAgICAgdGV4 dCBmb3JtYXR0aW5nIGVsZW1lbnRzLgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9i amVjdDo6aXNMaW5rT3JMaXN0SXRlbUVsZW1lbnQpOkNyZWF0ZSBhIG5ldworICAgICAgICBmdW5j dGlvbiB0byBkZXRlcm1pbmUgaWYgdGhlIHJlbmRlcmVkIG9iamVjdCBpcyBhIGxpbmssIGxpc3Qg aXRlbSAKKyAgICAgICAgZWxlbWVudCBvciBhYmJyLGFjcm9ueW0gb3IgcSB0YWcuCisgICAgICAg IChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojppc0Zvcm1PclRhYmxlRWxlbWVudCk6IENy ZWF0ZSBhIG5ldworICAgICAgICBmdW5jdGlvbiB0byBkZXRlcm1pbmUgaWYgdGhlIHJlbmRlcmVk IG9iamVjdCBpcyBmb3JtIG9yIGEgdGFibGUKKyAgICAgICAgZWxlbWVudC4KKyAgICAgICAgKFdl YkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKTpDb252ZXJ0IGFkZENoaWxk cmVuCisgICAgICAgIGZ1bmN0aW9uIGludG8gYSBjb25zdCBmdW5jdGlvbi4KKyAgICAgICAgKiBw YWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaDogTWFrZSBtX2NoaWxkcmVuIHZhcmlhYmxlIGEgbXV0 YWJsZSAKKyAgICAgICAgdmFyaWFibGUuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5 T2JqZWN0OjpjaGlsZHJlbik6Q29udmVydCBjaGlsZHJlbiBmdW5jdGlvbiBpbnRvCisgICAgICAg IGNvbnN0IGZ1bmN0aW9uLgorICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphY2Nl c3NpYmlsaXR5SXNJZ25vcmVkKTogTWFrZQorICAgICAgICBjaGFuZ2VzIHRvIGV4cG9zZSBvbmx5 IHJlbGV2YW50IGFjY2Vzc2libGUgb2JqZWN0cyBpbiBNU0FBIHRyZWUuCisgICAgICAgIFJ1bGUg MTogRXhwb3NlIHRleHQgZWxlbWVudHMgb25seSBpZiB0aGV5IGhhdmUgc29tZSB2YWxpZCB0ZXh0 IAorICAgICAgICBjb250ZW50LgorICAgICAgICBSdWxlIDI6IEFsbCByZW5kZXJlZCBvYmplY3Rz IGNvcnJlc3BvbmRpbmcgdG8gPGxpPiw8b2w+IGFuZCA8ZGw+IHRhZ3MKKyAgICAgICAgc2hvdWxk IGJlIGV4cG9zZWQuCisgICAgICAgIFJ1bGUgMzogUmVuZGVyZWQgb2JqZWN0cyBjb3JyZXNwb25k aW5nIHRvIDxmb3JtPiw8dGFibGU+LDx0ZD4gYW5kIDx0aD4KKyAgICAgICAgdGFncyBzaG91bGQg YmUgZXhwb3NlZC4KKyAgICAgICAgUnVsZSA0OiBBbGwgbGlzdCBpdGVtIGVsZW1lbnRzIGkuZSA8 bGk+LDxkZD4sPGR0PiBhbmQgPGFiYnI+LDxhY3JvbnltPgorICAgICAgICA8cT4gdGFncyBzaG91 bGQgYmUgZXhwb3NlZCBvbmx5IGlmIHRoZXkgaGF2ZSB2YWxpZCBjaGlsZHJlbi4KKyAgICAgICAg UnVsZSA1OiBGZXcgdGFncyBmYWxsIGluIFRleHRGb3JtYXR0aW5nRWxlbWVudHMgY2F0ZWdvcnku IEFsbCB0aG9zZQorICAgICAgICB0YWdzIHNob3VsZCBiZSBleHBvc2VkLgorICAgICAgICBSdWxl IDY6IEFsbCBpbmxpbmUgZWxlbWVudHMgc2hvdWxkIGJlIGlnbm9yZWQuCisgICAgICAgIFJ1bGUg NzogQmxvY2sgZWxlbWVudHMgc2hvdWxkIGJlIGV4cG9zZWQgb25seSBpZiB0aGV5IGFyZSBub3QK KyAgICAgICAgYW5vbnltb3VzIGJsb2Nrcy4KKyAgICAgICAgSW1wbGVtZW50IHRoZXNlIHJ1bGVz IHRvIG1hdGNoIHRoZSBiZWhhdmlvdXIgaW4gRmlyZWZveC4KKyAgICAgICAgKFdlYkNvcmU6OkFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzVGV4dEZvcm1hdHRpbmdFbGVtZW50KTpGZXcKKyAg ICAgICAgcmVuZGVyZWQgb2JqZWN0cyBiZWxvbmcgdG8gVGV4dEZvcm1hdHRpbmdFbGVtZW50cyBj YXRlZ29yeS4gQ3JlYXRlIGEKKyAgICAgICAgZnVuY3Rpb24gdG8gdGVzdCBpZiB0aGUgcmVuZGVy ZWQgb2JqZWN0IGZhbGxzIGluIHRoaXMgY2F0ZWdvcnkuCisgICAgICAgIChXZWJDb3JlOjpBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojppc0xpbmtPckxpc3RJdGVtRWxlbWVudCk6Q3JlYXRlCisg ICAgICAgIGEgZnVuY3Rpb24gdG8gcmV0dXJuIHRydWUgaWYgdGhlIHJlbmRlcmVkIG9iamVjdCBp cyBhIGxpbmsgb3IgYSBsaXN0CisgICAgICAgIGl0ZW0gZWxlbWVudCBvciBhYmJyLGFjcm9ueW0s IHEgdGFnLgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6aXNG b3JtT3JUYWJsZUVsZW1lbnQpOkNyZWF0ZQorICAgICAgICBmdW5jdGlvbiB0byByZXR1cm4gdHJ1 ZSBpZiB0aGUgcmVuZGVyZWQgb2JqZWN0IGlzIGEgZm9ybSBvciBhIHRhYmxlCisgICAgICAgIGVs ZW1lbnQuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGls ZHJlbik6Q29udmVydCB0aGUKKyAgICAgICAgY2hpbGRyZW4oKSBmdW5jdGlvbiBpbnRvIGEgY29u c3QgZnVuY3Rpb24uCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 OjphZGRDaGlsZHJlbik6Q29udmVydCB0aGUgCisgICAgICAgIGFkZGNoaWxkcmVuIGZ1bmN0aW9u IGludG8gYSBjb25zdCBmdW5jdGlvbi4KKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuaDpBZGQgdGhlIGZ1bmN0aW9uIHNpZ25hdHVyZXMgZm9yCisgICAgICAgIG5ld2x5 IGNyZWF0ZWQgZnVuY3Rpb25zLgorICAgICAgICAqIHBsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJp bmcuaDoKKyAgICAgICAgKFdlYkNvcmU6OlN0cmluZzo6Y29udGFpbnNPbmx5V2hpdGVzcGFjZSk6 QWRkIGEgbmV3IGZ1bmN0aW9uIHRvIGNoZWNrCisgICAgICAgIGlmIHRoZSBzdHJpbmcgb2JqZWN0 IGNvbnRhaW5zIG9ubHkgd2hpdGUgc3BhY2Ugb3Igbm90LiAKKwogMjAwOC0wNy0zMSAgSm9obiBT dWxsaXZhbiAgPHN1bGxpdmFuQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWJDb3JlIHBhcnQgb2Yg PHJkYXI6Ly9wcm9ibGVtLzYxMTY2NTA+IFRleHQtb25seSB6b29tIHNldHRpbmcgc2hvdWxkIGJl IHN0b3JlZCBpbiBXZWJLaXQgcHJlZnMKSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 T2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVj dC5jcHAJKHJldmlzaW9uIDM1NDg0KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmpl Y3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMDEsNiArMzAxLDIxIEBAIEFYT2JqZWN0Q2FjaGUq IEFjY2Vzc2liaWxpdHlPYmplY3Q6OmF4T2IKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBBY2Nl c3NpYmlsaXR5T2JqZWN0Ojppc1RleHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0Cit7CisgICAg cmV0dXJuIGZhbHNlOworfQorCitib29sIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmlzTGlua09yTGlz dEl0ZW1FbGVtZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgQWNj ZXNzaWJpbGl0eU9iamVjdDo6aXNGb3JtT3JUYWJsZUVsZW1lbnQoKSBjb25zdAoreworICAgIHJl dHVybiBmYWxzZTsKK30KKwogdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpnZXREb2N1bWVudExp bmtzKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgcmVzdWx0KSBjb25zdAogewogfQpAQCAt OTc3LDcgKzk5Miw3IEBAIHZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6Y2hpbGRyZW5DaGFuZ2UK ICAgICByZXR1cm47CiB9CiAKLXZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6YWRkQ2hpbGRyZW4o KQordm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGlsZHJlbigpIGNvbnN0CiB7CiB9CiAK SW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAkocmV2aXNpb24gMzU0ODQpCisrKyBX ZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCSh3b3JraW5nIGNvcHkpCkBAIC0yNjIs NiArMjYyLDEwIEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eVJvbGUgcm9s ZVZhbHVlKCkgY29uc3Q7CiAgICAgdmlydHVhbCBBWE9iamVjdENhY2hlKiBheE9iamVjdENhY2hl KCkgY29uc3Q7CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNUZXh0Rm9ybWF0dGluZ0VsZW1lbnQoKSBj b25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNMaW5rT3JMaXN0SXRlbUVsZW1lbnQoKSBjb25zdDsK KyAgICB2aXJ0dWFsIGJvb2wgaXNGb3JtT3JUYWJsZUVsZW1lbnQoKSBjb25zdDsKICAgICAKICAg ICB2aXJ0dWFsIEhUTUxBbmNob3JFbGVtZW50KiBhbmNob3JFbGVtZW50KCkgY29uc3Q7CiAgICAg dmlydHVhbCBFbGVtZW50KiBhY3Rpb25FbGVtZW50KCkgY29uc3Q7CkBAIC0zMDksOCArMzEzLDgg QEAgcHVibGljOgogICAgIGJvb2wgcGVyZm9ybURlZmF1bHRBY3Rpb24oKSBjb25zdCB7IHJldHVy biBwcmVzcygpOyB9CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGNoaWxkcmVuQ2hhbmdlZCgpOwot ICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlbigp IHsgcmV0dXJuIG1fY2hpbGRyZW47IH0KLSAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRyZW4oKTsK KyAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4o KSBjb25zdCB7IHJldHVybiBtX2NoaWxkcmVuOyB9CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxk cmVuKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIGhhc0NoaWxkcmVuKCkgY29uc3QgeyByZXR1 cm4gbV9oYXZlQ2hpbGRyZW47IH07CiAgICAgdmlydHVhbCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4o QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAgICAgdmlydHVhbCB2b2lkIHZpc2libGVD aGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsKQEAgLTM4Miw3ICszODYsNyBA QCBwdWJsaWM6CiAKIHByb3RlY3RlZDoKICAgICB1bnNpZ25lZCBtX2lkOwotICAgIEFjY2Vzc2li aWxpdHlDaGlsZHJlblZlY3RvciBtX2NoaWxkcmVuOworICAgIG11dGFibGUgQWNjZXNzaWJpbGl0 eUNoaWxkcmVuVmVjdG9yIG1fY2hpbGRyZW47CiAgICAgbXV0YWJsZSBib29sIG1faGF2ZUNoaWxk cmVuOwogICAgIAogICAgIHZpcnR1YWwgdm9pZCBjbGVhckNoaWxkcmVuKCk7CkluZGV4OiBXZWJD b3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAzNTQ4NCkK KysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBj b3B5KQpAQCAtMTA3OSwxOCArMTA3OSwxNyBAQCBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3Q6OmFjY2Vzc2liCiAgICAgfQogICAgICAgICAKICAgICBBY2Nlc3NpYmlsaXR5Um9sZSBhcmlh Um9sZSA9IGFyaWFSb2xlQXR0cmlidXRlKCk7Ci0gICAgaWYgKGFyaWFSb2xlID09IFRleHRBcmVh Um9sZSB8fCBhcmlhUm9sZSA9PSBTdGF0aWNUZXh0Um9sZSkgewotICAgICAgICBTdHJpbmcgYXJp YVRleHQgPSB0ZXh0KCk7Ci0gICAgICAgIHJldHVybiBhcmlhVGV4dC5pc051bGwoKSB8fCBhcmlh VGV4dC5pc0VtcHR5KCk7Ci0gICAgfSAgICAKKyAgICBpZiAoYXJpYVJvbGUgPT0gVGV4dEFyZWFS b2xlIHx8IGFyaWFSb2xlID09IFN0YXRpY1RleHRSb2xlKQorICAgICAgICByZXR1cm4gdGV4dCgp LmNvbnRhaW5zT25seVdoaXRlc3BhY2UoKTsKICAgICAKICAgICAvLyBOT1RFOiBCUnMgYWx3YXlz IGhhdmUgdGV4dCBib3hlcyBub3csIHNvIHRoZSB0ZXh0IGJveCBjaGVjayBoZXJlIGNhbiBiZSBy ZW1vdmVkCiAgICAgaWYgKG1fcmVuZGVyZXItPmlzVGV4dCgpKSB7CiAgICAgICAgIC8vIHN0YXRp YyB0ZXh0IGJlbmVhdGggTWVudUl0ZW1zIGFuZCBNZW51QnV0dG9ucyBhcmUganVzdCByZXBvcnRl ZCBhbG9uZyB3aXRoIHRoZSBtZW51IGl0ZW0sIHNvIGl0J3MgaWdub3JlZCBvbiBhbiBpbmRpdmlk dWFsIGxldmVsCi0gICAgICAgIGlmIChwYXJlbnRPYmplY3RVbmlnbm9yZWQoKS0+YXJpYVJvbGVB dHRyaWJ1dGUoKSA9PSBNZW51SXRlbVJvbGUgfHwKLSAgICAgICAgICAgIHBhcmVudE9iamVjdFVu aWdub3JlZCgpLT5hcmlhUm9sZUF0dHJpYnV0ZSgpID09IE1lbnVCdXR0b25Sb2xlKQorICAgICAg ICBpZiAodGV4dFVuZGVyRWxlbWVudCgpLmNvbnRhaW5zT25seVdoaXRlc3BhY2UoKSkKICAgICAg ICAgICAgIHJldHVybiB0cnVlOwotICAgICAgICAgcmV0dXJuIG1fcmVuZGVyZXItPmlzQlIoKSB8 fCAhc3RhdGljX2Nhc3Q8UmVuZGVyVGV4dCo+KG1fcmVuZGVyZXIpLT5maXJzdFRleHRCb3goKTsK KworICAgICAgICBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlID0gcGFyZW50T2JqZWN0VW5pZ25vcmVk KCktPmFyaWFSb2xlQXR0cmlidXRlKCk7CQkKKyAgICAgICAgICAgIHJldHVybiByb2xlID09IE1l bnVJdGVtUm9sZSB8fCByb2xlID09IE1lbnVCdXR0b25Sb2xlOwogICAgIH0KICAgICAKICAgICBp ZiAoaXNIZWFkaW5nKCkpCkBAIC0xMTA3LDkgKzExMDYsMjQgQEAgYm9vbCBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjphY2Nlc3NpYgogICAgIE5vZGUqIG5vZGUgPSBtX3JlbmRlcmVyLT5lbGVt ZW50KCk7CiAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShsYWJlbFRhZykpCiAgICAg ICAgIHJldHVybiBmYWxzZTsKLSAgICAKKyAKKyAgICBpZiAoaXNMaXN0RWxlbWVudChub2RlKSkK KyAgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmIChpc0Zvcm1PclRhYmxlRWxlbWVudCgp KQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAoaXNMaW5rT3JMaXN0SXRlbUVsZW1l bnQoKSkKKyAgICAgICAgcmV0dXJuIGNoaWxkcmVuKCkuaXNFbXB0eSgpOworCisgICAgaWYgKGlz VGV4dEZvcm1hdHRpbmdFbGVtZW50KCkpCisgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAK ICAgICBpZiAobV9yZW5kZXJlci0+aXNCbG9ja0Zsb3coKSAmJiBtX3JlbmRlcmVyLT5jaGlsZHJl bklubGluZSgpKQotICAgICAgICByZXR1cm4gIXN0YXRpY19jYXN0PFJlbmRlckJsb2NrKj4obV9y ZW5kZXJlciktPmZpcnN0TGluZUJveCgpICYmICFtb3VzZUJ1dHRvbkxpc3RlbmVyKCk7CisgICAg ICAgIHJldHVybiBtX3JlbmRlcmVyLT5pc0Fub255bW91c0Jsb2NrKCk7CisgICAgCisgICAgaWYg KG1fcmVuZGVyZXItPmlzSW5saW5lRmxvdygpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAK ICAgICAvLyBpZ25vcmUgaW1hZ2VzIHNlZW1pbmdseSB1c2VkIGFzIHNwYWNlcnMKICAgICBpZiAo aXNJbWFnZSgpKSB7CkBAIC0xNDA5LDYgKzE0MjMsNzkgQEAgQVhPYmplY3RDYWNoZSogQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdAogICAgIHJldHVybiBtX3JlbmRlcmVyLT5kb2N1bWVudCgpLT5h eE9iamVjdENhY2hlKCk7CiB9CiAKK2Jvb2wgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6aXNU ZXh0Rm9ybWF0dGluZ0VsZW1lbnQoKSBjb25zdAoreworICAgIGlmICghbV9yZW5kZXJlciB8fCAh bV9yZW5kZXJlci0+ZWxlbWVudCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgCisgICAg Tm9kZSogbm9kZSA9IG1fcmVuZGVyZXItPmVsZW1lbnQoKTsKKyAgICBpZiAobm9kZS0+bmFtZXNw YWNlVVJJKCkgIT0gSFRNTE5hbWVzOjp4aHRtbE5hbWVzcGFjZVVSSSkKKyAgICAgICAgcmV0dXJu IGZhbHNlOworICAgICAgICAKKyAgICBzdGF0aWMgSGFzaFNldDxTdHJpbmcsIENhc2VGb2xkaW5n SGFzaD4gZm9ybWF0dGluZ0VsZW1lbnRzOworICAgIGlmIChmb3JtYXR0aW5nRWxlbWVudHMuaXNF bXB0eSgpKSB7CisgICAgICAgIGZvcm1hdHRpbmdFbGVtZW50cy5hZGQoYlRhZy5sb2NhbE5hbWUo KSk7CisgICAgICAgIGZvcm1hdHRpbmdFbGVtZW50cy5hZGQoYmRvVGFnLmxvY2FsTmFtZSgpKTsK KyAgICAgICAgZm9ybWF0dGluZ0VsZW1lbnRzLmFkZChiaWdUYWcubG9jYWxOYW1lKCkpOworICAg ICAgICBmb3JtYXR0aW5nRWxlbWVudHMuYWRkKGNpdGVUYWcubG9jYWxOYW1lKCkpOworICAgICAg ICBmb3JtYXR0aW5nRWxlbWVudHMuYWRkKGNvZGVUYWcubG9jYWxOYW1lKCkpOworICAgICAgICBm b3JtYXR0aW5nRWxlbWVudHMuYWRkKGRmblRhZy5sb2NhbE5hbWUoKSk7CisgICAgICAgIGZvcm1h dHRpbmdFbGVtZW50cy5hZGQoZGVsVGFnLmxvY2FsTmFtZSgpKTsKKyAgICAgICAgZm9ybWF0dGlu Z0VsZW1lbnRzLmFkZChpbnNUYWcubG9jYWxOYW1lKCkpOworICAgICAgICBmb3JtYXR0aW5nRWxl bWVudHMuYWRkKGVtVGFnLmxvY2FsTmFtZSgpKTsKKyAgICAgICAgZm9ybWF0dGluZ0VsZW1lbnRz LmFkZChmb250VGFnLmxvY2FsTmFtZSgpKTsKKyAgICAgICAgZm9ybWF0dGluZ0VsZW1lbnRzLmFk ZChpVGFnLmxvY2FsTmFtZSgpKTsKKyAgICAgICAgZm9ybWF0dGluZ0VsZW1lbnRzLmFkZChzVGFn LmxvY2FsTmFtZSgpKTsKKyAgICAgICAgZm9ybWF0dGluZ0VsZW1lbnRzLmFkZChzYW1wVGFnLmxv Y2FsTmFtZSgpKTsKKyAgICAgICAgZm9ybWF0dGluZ0VsZW1lbnRzLmFkZChzbWFsbFRhZy5sb2Nh bE5hbWUoKSk7CisgICAgICAgIGZvcm1hdHRpbmdFbGVtZW50cy5hZGQoc3BhblRhZy5sb2NhbE5h bWUoKSk7CisgICAgICAgIGZvcm1hdHRpbmdFbGVtZW50cy5hZGQoc3RyaWtlVGFnLmxvY2FsTmFt ZSgpKTsKKyAgICAgICAgZm9ybWF0dGluZ0VsZW1lbnRzLmFkZChzdHJvbmdUYWcubG9jYWxOYW1l KCkpOworICAgICAgICBmb3JtYXR0aW5nRWxlbWVudHMuYWRkKHN1YlRhZy5sb2NhbE5hbWUoKSk7 CisgICAgICAgIGZvcm1hdHRpbmdFbGVtZW50cy5hZGQoc3VwVGFnLmxvY2FsTmFtZSgpKTsKKyAg ICAgICAgZm9ybWF0dGluZ0VsZW1lbnRzLmFkZCh0ZXh0YXJlYVRhZy5sb2NhbE5hbWUoKSk7Cisg ICAgICAgIGZvcm1hdHRpbmdFbGVtZW50cy5hZGQodHRUYWcubG9jYWxOYW1lKCkpOworICAgICAg ICBmb3JtYXR0aW5nRWxlbWVudHMuYWRkKHVUYWcubG9jYWxOYW1lKCkpOworICAgICAgICBmb3Jt YXR0aW5nRWxlbWVudHMuYWRkKHByZVRhZy5sb2NhbE5hbWUoKSk7CisgICAgICAgIGZvcm1hdHRp bmdFbGVtZW50cy5hZGQoZGl2VGFnLmxvY2FsTmFtZSgpKTsKKyAgICAgICAgZm9ybWF0dGluZ0Vs ZW1lbnRzLmFkZChjZW50ZXJUYWcubG9jYWxOYW1lKCkpOworICAgICAgICBmb3JtYXR0aW5nRWxl bWVudHMuYWRkKHBUYWcubG9jYWxOYW1lKCkpOworICAgIH0KKworICAgIHJldHVybiBmb3JtYXR0 aW5nRWxlbWVudHMuY29udGFpbnMobm9kZS0+bG9jYWxOYW1lKCkpOworfQorCitib29sIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzTGlua09yTGlzdEl0ZW1FbGVtZW50KCkgY29uc3QKK3sK KyAgICBpZiAoIW1fcmVuZGVyZXIgfHwgIW1fcmVuZGVyZXItPmVsZW1lbnQoKSkKKyAgICAgICAg cmV0dXJuIGZhbHNlOworICAgIAorICAgIE5vZGUqIG5vZGUgPSBtX3JlbmRlcmVyLT5lbGVtZW50 KCk7CisgICAgaWYgKG5vZGUtPm5hbWVzcGFjZVVSSSgpICE9IEhUTUxOYW1lczo6eGh0bWxOYW1l c3BhY2VVUkkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgCisgICAgc3RhdGljIEhh c2hTZXQ8U3RyaW5nLCBDYXNlRm9sZGluZ0hhc2g+IGVsZW1lbnRIYXNoU2V0OworICAgIGlmIChl bGVtZW50SGFzaFNldC5pc0VtcHR5KCkpIHsgICAgCisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFk ZChhYmJyVGFnLmxvY2FsTmFtZSgpKTsKKyAgICAgICAgZWxlbWVudEhhc2hTZXQuYWRkKGFjcm9u eW1UYWcubG9jYWxOYW1lKCkpOworICAgICAgICBlbGVtZW50SGFzaFNldC5hZGQocVRhZy5sb2Nh bE5hbWUoKSk7CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChsaVRhZy5sb2NhbE5hbWUoKSk7 CisgICAgICAgIGVsZW1lbnRIYXNoU2V0LmFkZChkZFRhZy5sb2NhbE5hbWUoKSk7CisgICAgICAg IGVsZW1lbnRIYXNoU2V0LmFkZChkdFRhZy5sb2NhbE5hbWUoKSk7CisgICAgfQorICAgIAorICAg IHJldHVybiBlbGVtZW50SGFzaFNldC5jb250YWlucyhub2RlLT5sb2NhbE5hbWUoKSkgfHwgbV9y ZW5kZXJlci0+aXNMaXN0SXRlbSgpOworfSAgIAorCitib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmlzRm9ybU9yVGFibGVFbGVtZW50KCkgY29uc3QKK3sKKyAgICBpZiAoIW1fcmVuZGVy ZXIgfHwgIW1fcmVuZGVyZXItPmVsZW1lbnQoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IAorICAgIHJldHVybiBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUoZm9ybVRhZykg fHwgbV9yZW5kZXJlci0+aXNUYWJsZSgpCisgICAgICAgICAgICAgICAgfHwgbV9yZW5kZXJlci0+ aXNUYWJsZUNlbGwoKSB8fCBtX3JlbmRlcmVyLT5lbGVtZW50KCktPmhhc1RhZ05hbWUodGhUYWcp OworfQorCiB2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmdldERvY3VtZW50TGlua3Mo QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiByZXN1bHQpIGNvbnN0CiB7CiAgICAgRG9jdW1l bnQqIGRvY3VtZW50ID0gbV9yZW5kZXJlci0+ZG9jdW1lbnQoKTsKQEAgLTIxNzIsMTQgKzIyNTks MTQgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGlsZHJlbgogICAgIH0KIH0K IAotY29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9y JiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpjaGlsZHJlbigpCitjb25zdCBBY2Nlc3NpYmls aXR5T2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmNoaWxkcmVuKCkgY29uc3QKIHsKICAgICBpZiAoIW1faGF2ZUNoaWxkcmVuKQog ICAgICAgICBhZGRDaGlsZHJlbigpOwogICAgIHJldHVybiBtX2NoaWxkcmVuOwogfQogCi12b2lk IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFkZENoaWxkcmVuKCkKK3ZvaWQgQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdDo6YWRkQ2hpbGRyZW4oKSBjb25zdAogewogICAgIC8vIElmIHRoZSBu ZWVkIHRvIGFkZCBtb3JlIGNoaWxkcmVuIGluIGFkZGl0aW9uIHRvIGV4aXN0aW5nIGNoaWxkcmVu IGFyaXNlcywgCiAgICAgLy8gY2hpbGRyZW5DaGFuZ2VkIHNob3VsZCBoYXZlIGJlZW4gY2FsbGVk LCBsZWF2aW5nIHRoZSBvYmplY3Qgd2l0aCBubyBjaGlsZHJlbi4KSW5kZXg6IFdlYkNvcmUvcGFn ZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdl L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAkocmV2aXNpb24gMzU0ODQpCisrKyBXZWJDb3Jl L3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMzAs NiArMTMwLDEwIEBAIHB1YmxpYzoKICAgICB2b2lkIHNldEFyaWFSb2xlKCk7CiAgICAgdmlydHVh bCBBY2Nlc3NpYmlsaXR5Um9sZSByb2xlVmFsdWUoKSBjb25zdDsKICAgICB2aXJ0dWFsIEFYT2Jq ZWN0Q2FjaGUqIGF4T2JqZWN0Q2FjaGUoKSBjb25zdDsKKworICAgIHZpcnR1YWwgYm9vbCBpc1Rl eHRGb3JtYXR0aW5nRWxlbWVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc0xpbmtPckxp c3RJdGVtRWxlbWVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc0Zvcm1PclRhYmxlRWxl bWVudCgpIGNvbnN0OwogICAgIAogICAgIHZpcnR1YWwgRWxlbWVudCogYWN0aW9uRWxlbWVudCgp IGNvbnN0OwogICAgIEVsZW1lbnQqIG1vdXNlQnV0dG9uTGlzdGVuZXIoKSBjb25zdDsKQEAgLTE3 Miw3ICsxNzYsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGdldERvY3VtZW50TGlua3Mo QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJikgY29uc3Q7CiAgICAgdmlydHVhbCBGcmFtZVZp ZXcqIGRvY3VtZW50RnJhbWVWaWV3KCkgY29uc3Q7CiAgICAgCi0gICAgdmlydHVhbCBjb25zdCBB Y2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCk7CisgICAgdmlydHVhbCBjb25z dCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgY29uc3Q7CiAgICAgCiAg ICAgdmlydHVhbCB2b2lkIHNldEZvY3VzZWQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lkIHNldFNl bGVjdGVkVGV4dFJhbmdlKGNvbnN0IFBsYWluVGV4dFJhbmdlJik7CkBAIC0xODAsNyArMTg0LDcg QEAgcHVibGljOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBkZXRhY2goKTsKICAgICB2aXJ0dWFs IHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCk7 CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lk IHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAgICAgdmly dHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsK ICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkRm9jdXNBY3RpdmVEZXNjZW5kYW50KCkgY29uc3Q7Cklu ZGV4OiBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJpbmcuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJpbmcuaAkocmV2aXNpb24gMzU0ODQp CisrKyBXZWJDb3JlL3BsYXRmb3JtL3RleHQvUGxhdGZvcm1TdHJpbmcuaAkod29ya2luZyBjb3B5 KQpAQCAtMTY3LDYgKzE2Nyw4IEBAIHB1YmxpYzoKICAgICBib29sIGlzRW1wdHkoKSBjb25zdDsK IAogICAgIFN0cmluZ0ltcGwqIGltcGwoKSBjb25zdCB7IHJldHVybiBtX2ltcGwuZ2V0KCk7IH0K KyAgICAKKyAgICBib29sIGNvbnRhaW5zT25seVdoaXRlc3BhY2UoKSBjb25zdCB7IHJldHVybiBp c051bGwoKSB8fCBtX2ltcGwtPmNvbnRhaW5zT25seVdoaXRlc3BhY2UoKTsgfQogCiAjaWYgUExB VEZPUk0oQ0YpCiAgICAgU3RyaW5nKENGU3RyaW5nUmVmKTsK 22599 2008-08-01 08:39:50 -0700 2008-08-21 22:13:34 -0700 Patch to navigate between accessibility parent, children and siblings. Navigation-patch.txt text/plain 14818 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTUxMSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzAgQEAKKzIwMDgtMDgtMDEgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWFAZ21haWwuY29tPgorCisgICAgICAgIEFkZCBmdW5jdGlvbnMgdG8gbmF2aWdhdGUgcHJvcGVy bHkgYmV0d2VlbiB0aGUgYWNjZXNzaWJpbGl0eSBwYXJlbnQKKyAgICAgICAgYW5kIGFjY2Vzc2li aWxpdHkgY2hpbGRyZW4uIFBhcnQgb2YKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIwMDEzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFOR0VECisK KyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6Zmlyc3RBY2Nlc3NpYmlsaXR5Q2hpbGQpOkFkZCBuZXcg CisgICAgICAgIGZ1bmN0aW9uIHRvIG5hdmlnYXRlIHRvIGZpcnN0IGFjY2Vzc2liaWxpdHkgY2hp bGQuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjpsYXN0QWNjZXNzaWJp bGl0eUNoaWxkKTpBZGQgbmV3IAorICAgICAgICBmdW5jdGlvbiB0byBuYXZpZ2F0ZSB0byBsYXN0 IGFjY2Vzc2liaWxpdHkgY2hpbGQuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2Jq ZWN0OjpwcmV2aW91c0FjY2Vzc2liaWxpdHlTaWJsaW5nKTpBZGQgbmV3CisgICAgICAgIGZ1bmN0 aW9uIHRvIG5hdmlnYXRlIHRvIHByZXZpb3VzIGFjY2Vzc2liaWxpdHkgc2libGluZy4KKyAgICAg ICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6Om5leHRBY2Nlc3NpYmlsaXR5U2libGlu Zyk6IEFkZCBuZXcKKyAgICAgICAgZnVuY3Rpb24gdG8gbmF2aWdhdGUgdG8gbGFzdCBhY2Nlc3Np YmlsaXR5IHNpYmxpbmcuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0Ojph ZGRDaGlsZHJlbik6QWRkIGxvZ2ljIHRvIHBvcHVsYXRlCisgICAgICAgIHRoZSBtZW1iZXIgdmFy aWFibGVzIGkuZSBpbmRleEluUGFyZW50IGFuZCBhY2Nlc3NpYmlsaXR5UGFyZW50IG9mCisgICAg ICAgIG9mIGFjY2Vzc2liaWxpdHkgb2JqZWN0IHByb3Blcmx5LgorICAgICAgICAqIHBhZ2UvQWNj ZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVj dDo6Y2hpbGRyZW4pOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6aW5k ZXhJblBhcmVudCk6QWRkIG5ldyBtZW1iZXIgdmFyaWFibGUKKyAgICAgICAgaW5kZXhJblBhcmVu dCB0byBBY2Nlc3NpYmlsaXR5T2JqZWN0LlRoaXMgdmFyaWFibGUgaG9sZHMgdGhlIGluZGV4Cisg ICAgICAgIG9mIHRoZSByZW5kZXJlZCBvYmplY3QgYW1vbmcgaXRzIHBhcmVudHMgY2hpbGRyZW4u CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjpzZXRJbmRleEluUGFyZW50 KTpBZGQgYSBzZXR0ZXIgYW5kIAorICAgICAgICBnZXR0ZXIgbWV0aG9kcyBmb3IgaW5kZXhJblBh cmVudCBtZW1iZXIgZmllbGQuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0 OjphY2Nlc3NpYmlsaXR5UGFyZW50KTpBZGQgYSBuZXcgbWVtYmVyCisgICAgICAgIGZpZWxkIGku ZSBBY2Nlc3NpYmlsaXR5UGFyZW50LiBUaGlzIHZhcmlhYmxlIGtlZXBzIHRyYWNrIG9mIHRoZQor ICAgICAgICBhY2Nlc3NpYmlsaXR5IHBhcmVudCBvZiB0aGUgcmVuZGVyZWQgb2JqZWN0LiBBZGQg c2V0dGVyIGFuZAorICAgICAgICBnZXR0ZXIgbWV0aG9kcyBmb3IgYWNjZXNzaWJpbGl0eVBhcmVu dCBtZW1iZXIgZmllbGQuIAorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6 c2V0QWNjZXNzaWJpbGl0eVBhcmVudCk6CisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0LmNwcDpDcmVhdGUgZm91ciBuZXcgZnVuY3Rpb25zCisgICAgICAgIHRvIG5hdmln YXRlIHByb3Blcmx5IHRvIGZpcnN0LGxhc3QgYWNjZXNzaWJpbGl0eSBjaGlsZHJlbiBhbmQKKyAg ICAgICAgbmV4dCwgcHJldmlvdXMgYWNjZXNzaWJpbGl0eSBzaWJsaW5ncy4gVGhlc2UgYXJlIHZp cnR1YWwgZnVuY3Rpb25zLgorICAgICAgICBPdmVycmlkZSB0aG9zZSBmdW5jdGlvbnMgYW5kIGlt cGxlbWVudCB0aGVtIGluIAorICAgICAgICBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcCBm aWxlLgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Zmlyc3RB Y2Nlc3NpYmlsaXR5Q2hpbGQpOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdDo6bGFzdEFjY2Vzc2liaWxpdHlDaGlsZCk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpwcmV2aW91c0FjY2Vzc2liaWxpdHlTaWJsaW5nKToKKyAg ICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6Om5leHRBY2Nlc3NpYmls aXR5U2libGluZyk6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 OjpjaGlsZHJlbik6TWFrZSBjaGlsZHJlbigpIAorICAgICAgICBhbmQgYWRkQ2hpbGRyZW4oKSBm dW5jdGlvbnMgaW50byBjb25zdCBmdW5jdGlvbnMuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbik6CisgICAgICAgICogcGFnZS9BY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0Lmg6CisKIDIwMDgtMDctMzEgIEpvaG4gU3VsbGl2YW4gIDxzdWxs aXZhbkBhcHBsZS5jb20+CiAKICAgICAgICAgV2ViQ29yZSBwYXJ0IG9mIDxyZGFyOi8vcHJvYmxl bS82MTE2NjUwPiBUZXh0LW9ubHkgem9vbSBzZXR0aW5nIHNob3VsZCBiZSBzdG9yZWQgaW4gV2Vi S2l0IHByZWZzCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCShyZXZpc2lv biAzNTUwNykKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMTA3LDYgKzEwNywyNiBAQCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nlc3Np YmlsaXR5T2JqZWN0CiAgICAgcmV0dXJuIDA7CiB9CiAKK0FjY2Vzc2liaWxpdHlPYmplY3QqIEFj Y2Vzc2liaWxpdHlPYmplY3Q6OmZpcnN0QWNjZXNzaWJpbGl0eUNoaWxkKCkgY29uc3QKK3sKKyAg ICByZXR1cm4gMDsKK30KKworQWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0eU9iamVj dDo6bGFzdEFjY2Vzc2liaWxpdHlDaGlsZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIDA7Cit9CisK K0FjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vzc2liaWxpdHlPYmplY3Q6OnByZXZpb3VzQWNjZXNz aWJpbGl0eVNpYmxpbmcoKSBjb25zdAoreworICAgIHJldHVybiAwOworfQorCitBY2Nlc3NpYmls aXR5T2JqZWN0KiBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmco KSBjb25zdAoreworICAgIHJldHVybiAwOworfQorCiBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nl c3NpYmlsaXR5T2JqZWN0OjpwYXJlbnRPYmplY3RVbmlnbm9yZWQoKSBjb25zdAogewogICAgIEFj Y2Vzc2liaWxpdHlPYmplY3QqIHBhcmVudDsKQEAgLTk3Nyw3ICs5OTcsNyBAQCB2b2lkIEFjY2Vz c2liaWxpdHlPYmplY3Q6OmNoaWxkcmVuQ2hhbmdlCiAgICAgcmV0dXJuOwogfQogCi12b2lkIEFj Y2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKCkKK3ZvaWQgQWNjZXNzaWJpbGl0eU9iamVj dDo6YWRkQ2hpbGRyZW4oKSBjb25zdAogewogfQogCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNz aWJpbGl0eU9iamVjdC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 T2JqZWN0LmgJKHJldmlzaW9uIDM1NTA3KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlP YmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtMjUyLDYgKzI1MiwxMCBAQCBwdWJsaWM6CiAgICAg dmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBwcmV2aW91c1NpYmxpbmcoKSBjb25zdDsKICAg ICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3QqIG5leHRTaWJsaW5nKCkgY29uc3Q7CiAgICAg dmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBwYXJlbnRPYmplY3QoKSBjb25zdDsKKyAgICB2 aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3QqIGZpcnN0QWNjZXNzaWJpbGl0eUNoaWxkKCkgY29u c3QgOworICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogbGFzdEFjY2Vzc2liaWxpdHlD aGlsZCgpIGNvbnN0IDsKKyAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3QqIHByZXZpb3Vz QWNjZXNzaWJpbGl0eVNpYmxpbmcoKSBjb25zdCA7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5 T2JqZWN0KiBuZXh0QWNjZXNzaWJpbGl0eVNpYmxpbmcoKSBjb25zdCA7ICAgIAogICAgIHZpcnR1 YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogcGFyZW50T2JqZWN0VW5pZ25vcmVkKCkgY29uc3Q7CiAg ICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYnNlcnZhYmxlT2JqZWN0KCkgY29uc3Q7 CiAgICAgdmlydHVhbCB2b2lkIGxpbmtlZFVJRWxlbWVudHMoQWNjZXNzaWJpbGl0eUNoaWxkcmVu VmVjdG9yJikgY29uc3Q7CkBAIC0yNTksNyArMjYzLDYgQEAgcHVibGljOgogICAgIHZpcnR1YWwg QWNjZXNzaWJpbGl0eVJvbGUgYXJpYVJvbGVBdHRyaWJ1dGUoKSBjb25zdDsKICAgICB2aXJ0dWFs IGJvb2wgaXNQcmVzZW50YXRpb25hbENoaWxkT2ZBcmlhUm9sZSgpIGNvbnN0OwogICAgIHZpcnR1 YWwgYm9vbCBhcmlhUm9sZUhhc1ByZXNlbnRhdGlvbmFsQ2hpbGRyZW4oKSBjb25zdDsKLQogICAg IHZpcnR1YWwgQWNjZXNzaWJpbGl0eVJvbGUgcm9sZVZhbHVlKCkgY29uc3Q7CiAgICAgdmlydHVh bCBBWE9iamVjdENhY2hlKiBheE9iamVjdENhY2hlKCkgY29uc3Q7CiAgICAgCkBAIC0zMDksOCAr MzEyLDggQEAgcHVibGljOgogICAgIGJvb2wgcGVyZm9ybURlZmF1bHRBY3Rpb24oKSBjb25zdCB7 IHJldHVybiBwcmVzcygpOyB9CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGNoaWxkcmVuQ2hhbmdl ZCgpOwotICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGls ZHJlbigpIHsgcmV0dXJuIG1fY2hpbGRyZW47IH0KLSAgICB2aXJ0dWFsIHZvaWQgYWRkQ2hpbGRy ZW4oKTsKKyAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hp bGRyZW4oKSBjb25zdHsgcmV0dXJuIG1fY2hpbGRyZW47IH0KKyAgICB2aXJ0dWFsIHZvaWQgYWRk Q2hpbGRyZW4oKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaGFzQ2hpbGRyZW4oKSBjb25zdCB7 IHJldHVybiBtX2hhdmVDaGlsZHJlbjsgfTsKICAgICB2aXJ0dWFsIHZvaWQgc2VsZWN0ZWRDaGls ZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsKICAgICB2aXJ0dWFsIHZvaWQgdmlz aWJsZUNoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYpOwpAQCAtMzY2LDcgKzM2 OSwxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBJbnRSZWN0IGRvQVhCb3VuZHNGb3JSYW5nZShj b25zdCBQbGFpblRleHRSYW5nZSYpIGNvbnN0OwogCiAgICAgdW5zaWduZWQgZG9BWExpbmVGb3JJ bmRleCh1bnNpZ25lZCk7Ci0KKyAgICB1bnNpZ25lZCBpbmRleEluUGFyZW50KCkgY29uc3QgeyBy ZXR1cm4gbV9pbmRleEluUGFyZW50OyB9CisgICAgdm9pZCBzZXRJbmRleEluUGFyZW50KHVuc2ln bmVkIGluZGV4SW5QYXJlbnQpIHsgbV9pbmRleEluUGFyZW50ID0gaW5kZXhJblBhcmVudDsgfQor ICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3QqIGFjY2Vzc2liaWxpdHlQYXJlbnQoKSB7IHJl dHVybiBtX2FjY2Vzc2liaWxpdHlQYXJlbnQ7IH0KKyAgICB2b2lkIHNldEFjY2Vzc2liaWxpdHlQ YXJlbnQoY29uc3QgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjZXNzaWJpbGl0eVBhcmVudCkgeyBt X2FjY2Vzc2liaWxpdHlQYXJlbnQgPSBhY2Nlc3NpYmlsaXR5UGFyZW50OyB9CiAjaWYgSEFWRShB Q0NFU1NJQklMSVRZKQogI2lmIFBMQVRGT1JNKEdUSykKICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0 V3JhcHBlciogd3JhcHBlcigpIGNvbnN0OwpAQCAtMzgyLDggKzM4OCwxMCBAQCBwdWJsaWM6CiAK IHByb3RlY3RlZDoKICAgICB1bnNpZ25lZCBtX2lkOwotICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJl blZlY3RvciBtX2NoaWxkcmVuOworICAgIG11dGFibGUgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yIG1fY2hpbGRyZW47CiAgICAgbXV0YWJsZSBib29sIG1faGF2ZUNoaWxkcmVuOworICAgIHVu c2lnbmVkIG1faW5kZXhJblBhcmVudDsKKyAgICBjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBt X2FjY2Vzc2liaWxpdHlQYXJlbnQ7CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGNsZWFyQ2hpbGRy ZW4oKTsKICAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlQVhPYmplY3RJRCgpOwpJbmRleDogV2ViQ29y ZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkocmV2aXNpb24gMzU1MDcpCisr KyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTE3OSw2ICsxNzksNDIgQEAgQWNjZXNzaWJpbGl0eU9iamVjdCogQWNjZXNzaWJpbGl0 eVJlbmRlcgogICAgIHJldHVybiBtX3JlbmRlcmVyLT5kb2N1bWVudCgpLT5heE9iamVjdENhY2hl KCktPmdldChwYXJlbnQpOwogfQogCitBY2Nlc3NpYmlsaXR5T2JqZWN0KiBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjpmaXJzdEFjY2Vzc2liaWxpdHlDaGlsZCgpIGNvbnN0Cit7CisgICAgaWYg KG1fY2hpbGRyZW4uaXNFbXB0eSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHJldHVybiBt X2NoaWxkcmVuLmZpcnN0KCkuZ2V0KCk7Cit9CisKK0FjY2Vzc2liaWxpdHlPYmplY3QqIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3Q6Omxhc3RBY2Nlc3NpYmlsaXR5Q2hpbGQoKSBjb25zdAorewor ICAgIGlmIChtX2NoaWxkcmVuLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBy ZXR1cm4gbV9jaGlsZHJlbi5sYXN0KCkuZ2V0KCk7Cit9CisKK0FjY2Vzc2liaWxpdHlPYmplY3Qq IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnByZXZpb3VzQWNjZXNzaWJpbGl0eVNpYmxpbmco KSBjb25zdAoreworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgc2libGlu Z3NWZWN0b3IgPSBtX2FjY2Vzc2liaWxpdHlQYXJlbnQtPmNoaWxkcmVuKCk7CisKKyAgICBpZiAo bV9pbmRleEluUGFyZW50ID09IDApCisgICAgICAgIHJldHVybiAwOworCisgICAgcmV0dXJuIHNp YmxpbmdzVmVjdG9yW21faW5kZXhJblBhcmVudCAtIDFdLmdldCgpOworfQorCitBY2Nlc3NpYmls aXR5T2JqZWN0KiBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpuZXh0QWNjZXNzaWJpbGl0eVNp YmxpbmcoKSBjb25zdAoreworICAgIGNvbnN0IEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYg c2libGluZ3NWZWN0b3IgPSBtX2FjY2Vzc2liaWxpdHlQYXJlbnQtPmNoaWxkcmVuKCk7CisKKyAg ICBpZiAobV9pbmRleEluUGFyZW50ICsgMSA9PSBzaWJsaW5nc1ZlY3Rvci5zaXplKCkpCisgICAg ICAgIHJldHVybiAwOworCisgICAgcmV0dXJuIHNpYmxpbmdzVmVjdG9yW21faW5kZXhJblBhcmVu dCArIDFdLmdldCgpOworfQorCiBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmlzV2Vi QXJlYSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIHJvbGVWYWx1ZSgpID09IFdlYkFyZWFSb2xlOwpA QCAtMjE3NSwxNCArMjIxMSwxNCBAQCB2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNo aWxkcmVuCiAgICAgfQogfQogCi1jb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpBY2Nlc3NpYmls aXR5Q2hpbGRyZW5WZWN0b3ImIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuKCkK K2NvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYg QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4oKSBjb25zdAogewogICAgIGlmICgh bV9oYXZlQ2hpbGRyZW4pCiAgICAgICAgIGFkZENoaWxkcmVuKCk7CiAgICAgcmV0dXJuIG1fY2hp bGRyZW47CiB9CiAKLXZvaWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWRkQ2hpbGRyZW4o KQordm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpIGNvbnN0CiB7 CiAgICAgLy8gSWYgdGhlIG5lZWQgdG8gYWRkIG1vcmUgY2hpbGRyZW4gaW4gYWRkaXRpb24gdG8g ZXhpc3RpbmcgY2hpbGRyZW4gYXJpc2VzLCAKICAgICAvLyBjaGlsZHJlbkNoYW5nZWQgc2hvdWxk IGhhdmUgYmVlbiBjYWxsZWQsIGxlYXZpbmcgdGhlIG9iamVjdCB3aXRoIG5vIGNoaWxkcmVuLgpA QCAtMjE5Myw3ICsyMjI5LDcgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRD aGlsZAogICAgICAgICByZXR1cm47CiAgICAgCiAgICAgbV9oYXZlQ2hpbGRyZW4gPSB0cnVlOwot ICAgIAorICAgIHVuc2lnbmVkIGNoaWxkQ291bnRlciA9IDA7CiAgICAgLy8gYWRkIGFsbCB1bmln bm9yZWQgYWNjIGNoaWxkcmVuCiAgICAgZm9yIChSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4g b2JqID0gZmlyc3RDaGlsZCgpOyBvYmo7IG9iaiA9IG9iai0+bmV4dFNpYmxpbmcoKSkgewogICAg ICAgICBpZiAob2JqLT5hY2Nlc3NpYmlsaXR5SXNJZ25vcmVkKCkpIHsKQEAgLTIyMDEsMTAgKzIy MzcsMTYgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZAogICAgICAg ICAgICAgICAgIG9iai0+YWRkQ2hpbGRyZW4oKTsKICAgICAgICAgICAgIEFjY2Vzc2liaWxpdHlD aGlsZHJlblZlY3RvciBjaGlsZHJlbiA9IG9iai0+Y2hpbGRyZW4oKTsKICAgICAgICAgICAgIHVu c2lnbmVkIGxlbmd0aCA9IGNoaWxkcmVuLnNpemUoKTsKLSAgICAgICAgICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBsZW5ndGg7ICsraSkKKyAgICAgICAgICAgIGZvciAodW5zaWduZWQgaSA9 IDA7IGkgPCBsZW5ndGg7ICsraSkgeworICAgICAgICAgICAgICAgIGNoaWxkcmVuW2ldLT5zZXRJ bmRleEluUGFyZW50KGNoaWxkQ291bnRlcisrKTsKKyAgICAgICAgICAgICAgICBjaGlsZHJlbltp XS0+c2V0QWNjZXNzaWJpbGl0eVBhcmVudCh0aGlzKTsKICAgICAgICAgICAgICAgICBtX2NoaWxk cmVuLmFwcGVuZChjaGlsZHJlbltpXSk7Ci0gICAgICAgIH0gZWxzZQotICAgICAgICAgICAgbV9j aGlsZHJlbi5hcHBlbmQob2JqKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAg ICAgICAgICAgIG9iai0+c2V0SW5kZXhJblBhcmVudChjaGlsZENvdW50ZXIrKyk7CisgICAgICAg ICAgICBvYmotPnNldEFjY2Vzc2liaWxpdHlQYXJlbnQodGhpcyk7CisgICAgICAgICAgICBtX2No aWxkcmVuLmFwcGVuZChvYmopOyAgICAgICAgICAgIAorICAgICAgICB9CiAgICAgfQogICAgIAog ICAgIC8vIGZvciBhIFJlbmRlckltYWdlLCBhZGQgdGhlIDxhcmVhPiBlbGVtZW50cyBhcyBpbmRp dmlkdWFsIGFjY2Vzc2liaWxpdHkgb2JqZWN0cwpAQCAtMjIxOSw2ICsyMjYxLDggQEAgdm9pZCBB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZAogICAgICAgICAgICAgICAgICAgICBz dGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5SW1hZ2VNYXBMaW5rKj4oYXJlYU9iamVjdCktPnNldEhU TUxBcmVhRWxlbWVudChzdGF0aWNfY2FzdDxIVE1MQXJlYUVsZW1lbnQqPihjdXJyZW50KSk7CiAg ICAgICAgICAgICAgICAgICAgIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlJbWFnZU1hcExpbmsq PihhcmVhT2JqZWN0KS0+c2V0SFRNTE1hcEVsZW1lbnQobWFwKTsKIAorICAgICAgICAgICAgICAg ICAgICBhcmVhT2JqZWN0LT5zZXRJbmRleEluUGFyZW50KGNoaWxkQ291bnRlcisrKTsKKyAgICAg ICAgICAgICAgICAgICAgYXJlYU9iamVjdC0+c2V0QWNjZXNzaWJpbGl0eVBhcmVudCh0aGlzKTsK ICAgICAgICAgICAgICAgICAgICAgbV9jaGlsZHJlbi5hcHBlbmQoYXJlYU9iamVjdCk7CiAgICAg ICAgICAgICAgICAgfQogICAgICAgICAgICAgfQpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdC5oCShyZXZpc2lvbiAzNTUwNykKKysrIFdlYkNvcmUvcGFnZS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTEyMSw2ICsxMjEsMTAg QEAgcHVibGljOgogICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogcHJldmlvdXNTaWJs aW5nKCkgY29uc3Q7CiAgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBuZXh0U2libGlu ZygpIGNvbnN0OwogICAgIHZpcnR1YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogcGFyZW50T2JqZWN0 KCkgY29uc3Q7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBmaXJzdEFjY2Vzc2li aWxpdHlDaGlsZCgpIGNvbnN0IDsKKyAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3QqIGxh c3RBY2Nlc3NpYmlsaXR5Q2hpbGQoKSBjb25zdCA7CisgICAgdmlydHVhbCBBY2Nlc3NpYmlsaXR5 T2JqZWN0KiBwcmV2aW91c0FjY2Vzc2liaWxpdHlTaWJsaW5nKCkgY29uc3QgOworICAgIHZpcnR1 YWwgQWNjZXNzaWJpbGl0eU9iamVjdCogbmV4dEFjY2Vzc2liaWxpdHlTaWJsaW5nKCkgY29uc3Qg OyAgICAKICAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3QqIG9ic2VydmFibGVPYmplY3Qo KSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgbGlua2VkVUlFbGVtZW50cyhBY2Nlc3NpYmlsaXR5 Q2hpbGRyZW5WZWN0b3ImKSBjb25zdDsKICAgICB2aXJ0dWFsIEFjY2Vzc2liaWxpdHlPYmplY3Qq IHRpdGxlVUlFbGVtZW50KCkgY29uc3Q7CkBAIC0xNzIsNyArMTc2LDcgQEAgcHVibGljOgogICAg IHZpcnR1YWwgdm9pZCBnZXREb2N1bWVudExpbmtzKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3Rv ciYpIGNvbnN0OwogICAgIHZpcnR1YWwgRnJhbWVWaWV3KiBkb2N1bWVudEZyYW1lVmlldygpIGNv bnN0OwogICAgIAotICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9y JiBjaGlsZHJlbigpOworICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yJiBjaGlsZHJlbigpIGNvbnN0OwogICAgIAogICAgIHZpcnR1YWwgdm9pZCBzZXRGb2N1c2Vk KGJvb2wpOwogICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxlY3RlZFRleHRSYW5nZShjb25zdCBQbGFp blRleHRSYW5nZSYpOwpAQCAtMTgwLDcgKzE4NCw3IEBAIHB1YmxpYzoKICAgICAKICAgICB2aXJ0 dWFsIHZvaWQgZGV0YWNoKCk7CiAgICAgdmlydHVhbCB2b2lkIGNoaWxkcmVuQ2hhbmdlZCgpOwot ICAgIHZpcnR1YWwgdm9pZCBhZGRDaGlsZHJlbigpOworICAgIHZpcnR1YWwgdm9pZCBhZGRDaGls ZHJlbigpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBzZWxlY3RlZENoaWxkcmVuKEFjY2Vzc2li aWxpdHlDaGlsZHJlblZlY3RvciYpOwogICAgIHZpcnR1YWwgdm9pZCB2aXNpYmxlQ2hpbGRyZW4o QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAgICAgdmlydHVhbCBib29sIHNob3VsZEZv Y3VzQWN0aXZlRGVzY2VuZGFudCgpIGNvbnN0OwpJbmRleDogV2ViS2l0L0NoYW5nZUxvZwo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvQ2hhbmdlTG9nCShyZXZpc2lvbiAzNTUxMSkKKysrIFdlYktpdC9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxMiBAQAorMjAwOC0wOC0wMSAgU2Fu a2FyIFRhbmd1dHVyaSAgPHNhbmthcmFkaXR5YUBnbWFpbC5jb20+CisKKyAgICAgICAgTmF2aWdh dGUgcHJvcGVybHkgdG8gYWNjZXNzaWJpbGl0eSBzaWJsaW5ncywgY2hpbGRyZW4gYW5kIHBhcmVu dC4KKyAgICAgICAgcGFydCBvZiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjAwMTMKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiB3aW4vQWNjZXNzaWJsZUJhc2UuY3BwOgorICAgICAgICAoQWNjZXNzaWJsZUJhc2U6OmdldF9h Y2NQYXJlbnQpOkNoYW5nZSBjb2RlIHRvIGdldCB0aGUgcGFyZW50IG9iamVjdAorICAgICAgICB0 aGF0IGlzIGV4cG9zZWQuCisgICAgICAgIChBY2Nlc3NpYmxlQmFzZTo6YWNjTmF2aWdhdGUpOk5h dmlnYXRlIHByb3Blcmx5IHRvIAorICAgICAgICBmaXJzdEFjY2Vzc2liaWxpdHlDaGlsZCBpbnN0 ZWFkIG9mIGZpcnN0Q2hpbGQoKS4gTmF2aWdhdGUgcHJvcGVybHkgdG8KKyAgICAgICAgbGFzdEFj Y2Vzc2liaWxpdHlDaGlsZCBpbnN0ZWFkIG9mIGxhc3RDaGlsZCgpLiBTaW1pbGFybHkgZm9yCisg ICAgICAgIG5leHQgYW5kIGxhc3Qgc2libGluZ3MoKS4gTWF0Y2hpbmcgRmlyZWZveC4KKwogMjAw OC0wNy0zMSAgRGF2aWQgRC4gS2lsemVyICA8ZGRraWx6ZXJAd2Via2l0Lm9yZz4KIAogICAgICAg ICBGaXggbGF5b3V0IHRlc3QgcmVzdWx0cyBmb3Igd2ViYXJjaGl2ZS90ZXN0LXhtbC1zdHlsZXNo ZWV0LnhtbApJbmRleDogV2ViS2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5jcHAJKHJldmlzaW9uIDM1NDg0KQorKysgV2Vi S2l0L3dpbi9BY2Nlc3NpYmxlQmFzZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEwNCw2ICsxMDQs MTQgQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBBY2Nlc3NpYmxlQmFzZQogICAgIGlmICgh bV9vYmplY3QpCiAgICAgICAgIHJldHVybiBFX0ZBSUw7CiAKKyAgICBBY2Nlc3NpYmlsaXR5T2Jq ZWN0KiBwYXJlbnRPYmogPSBtX29iamVjdC0+cGFyZW50T2JqZWN0VW5pZ25vcmVkKCk7CisKKyAg ICBpZiAocGFyZW50T2JqKSAgeworICAgICAgICAqcGFyZW50ID0gc3RhdGljX2Nhc3Q8SURpc3Bh dGNoKj4od3JhcHBlcihwYXJlbnRPYmopKTsKKyAgICAgICAgKCpwYXJlbnQpLT5BZGRSZWYoKTsK KyAgICAgICAgcmV0dXJuIFNfT0s7CisgICAgfQorCiAgICAgcmV0dXJuIFdlYlZpZXc6OkFjY2Vz c2libGVPYmplY3RGcm9tV2luZG93KG1fb2JqZWN0LT50b3BEb2N1bWVudEZyYW1lVmlldygpLT5j b250YWluaW5nV2luZG93KCksCiAgICAgICAgIE9CSklEX1dJTkRPVywgX191dWlkb2YoSUFjY2Vz c2libGUpLCByZWludGVycHJldF9jYXN0PHZvaWQqKj4ocGFyZW50KSk7CiB9CkBAIC00MjYsOSAr NDM0LDkgQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBBY2Nlc3NpYmxlQmFzZQogICAgICAg ICAgICAgICAgIHJldHVybiBFX0ZBSUw7CiAKICAgICAgICAgICAgIGlmIChkaXJlY3Rpb24gPT0g TkFWRElSX0ZJUlNUQ0hJTEQpCi0gICAgICAgICAgICAgICAgY2hpbGRPYmogPSBtX29iamVjdC0+ Zmlyc3RDaGlsZCgpOworICAgICAgICAgICAgICAgIGNoaWxkT2JqID0gbV9vYmplY3QtPmZpcnN0 QWNjZXNzaWJpbGl0eUNoaWxkKCk7CiAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAg Y2hpbGRPYmogPSBtX29iamVjdC0+bGFzdENoaWxkKCk7CisgICAgICAgICAgICAgICAgY2hpbGRP YmogPSBtX29iamVjdC0+bGFzdEFjY2Vzc2liaWxpdHlDaGlsZCgpOwogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIGNhc2UgTkFWRElSX05FWFQ6CiAgICAgICAgIGNhc2UgTkFWRElSX1BSRVZJ T1VTOiB7CkBAIC00MzgsOSArNDQ2LDkgQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBBY2Nl c3NpYmxlQmFzZQogICAgICAgICAgICAgICAgIHJldHVybiBocjsKIAogICAgICAgICAgICAgaWYg KGRpcmVjdGlvbiA9PSBOQVZESVJfTkVYVCkKLSAgICAgICAgICAgICAgICBjaGlsZE9iaiA9IGNo aWxkT2JqLT5uZXh0U2libGluZygpOworICAgICAgICAgICAgICAgIGNoaWxkT2JqID0gY2hpbGRP YmotPm5leHRBY2Nlc3NpYmlsaXR5U2libGluZygpOwogICAgICAgICAgICAgZWxzZQotICAgICAg ICAgICAgICAgIGNoaWxkT2JqID0gY2hpbGRPYmotPnByZXZpb3VzU2libGluZygpOworICAgICAg ICAgICAgICAgIGNoaWxkT2JqID0gY2hpbGRPYmotPnByZXZpb3VzQWNjZXNzaWJpbGl0eVNpYmxp bmcoKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CiAgICAgICAgIGRlZmF1bHQ6Cg== 22820 2008-08-15 10:41:03 -0700 2008-08-26 11:07:38 -0700 Patch to populate the role attribute for list elements. ListRole_patch.txt text/plain 1247 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTc4NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTIgQEAKKzIwMDgtMDgtMTUgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWErYnVnemlsbGFAZ21haWwuY29tPgorCisgICAgICAgIFBvcHVsYXRlIHJvbGUgYXR0cmlidXRl IGZvciBsaXN0IGVsZW1lbnRzIGFwcHJvcHJpYXRlbHkuIFBhcnQgb2YKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEzCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNFUyBB RERFRCBPUiBDSEFOR0VECisKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6cm9s ZVZhbHVlKTpSZXR1cm4gTGlzdFJvbGUgZm9yCisgICAgICAgIGxpc3QgZWxlbWVudHMuCisKIDIw MDgtMDgtMTUgIEtlaXNoaSBIYXR0b3JpICA8Y2FzZXkuaGF0dG9yaUBnbWFpbC5jb20+CiAKICAg ICAgICAgQWRkcyBzdXBwb3J0IGZvciBjbGVhcigpIGluIHRoZSBJbnNwZWN0b3IgY29uc29sZS4K SW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHJldmlz aW9uIDM1NzgzKQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0yMDQyLDYgKzIwNDIsOSBAQCBBY2Nlc3NpYmlsaXR5Um9sZSBB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShi dXR0b25UYWcpKQogICAgICAgICByZXR1cm4gQnV0dG9uUm9sZTsKIAorICAgIGlmIChpc0xpc3RF bGVtZW50KG5vZGUpKQorICAgICAgICByZXR1cm4gTGlzdFJvbGU7CisKICAgICBpZiAoaXNGaWxl VXBsb2FkQnV0dG9uKCkpCiAgICAgICAgIHJldHVybiBCdXR0b25Sb2xlOwogICAgIAo= 22822 2008-08-15 12:08:51 -0700 2008-08-21 22:32:16 -0700 Patch to populate the name attribute for Image Elements TitleAttribute_Images_patch.txt text/plain 1381 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTc5OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTIgQEAKKzIwMDgtMDgtMTUgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWErYnVnemlsbGFAZ21haWwuY29tPgorCisgICAgICAgIFBvcHVsYXRlIG5hbWUgYXR0cmlidXRl IGZvciBpbWFnZSBlbGVtZW50cyBhcHByb3ByaWF0ZWx5LiBQYXJ0IG9mCisgICAgICAgIGh0dHA6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEzCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURE RUQgT1IgQ0hBTkdFRAorCisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRpdGxl KTpSZXR1cm4gdGhlIHZhbHVlIG9mCisgICAgICAgICJhbHQiIGF0dHJpYnV0ZSBmb3IgSW1hZ2Ug ZWxlbWVudHMuIE1hdGNoaW5nIEZpcmVmb3guCisKIDIwMDgtMDgtMTUgIFRpbW90aHkgSGF0Y2hl ciAgPHRpbW90aHlAYXBwbGUuY29tPgogCiAgICAgICAgIERldGFjaCB0aGUgc2NyaXB0IGRlYnVn Z2VyIHdoZW4gdGhlIFdlYiBJbnNwZWN0b3IncyB3aW5kb3cgY2xvc2VzLgpJbmRleDogV2ViQ29y ZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkocmV2aXNpb24gMzU3OTgpCisr KyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTg0MCw3ICs4NDAsMTMgQEAgU3RyaW5nIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OnRpdGxlKAogICAgIAogICAgIGlmIChpc0xpbmsoKSkKICAgICAgICAgcmV0dXJuIHRleHRVbmRl ckVsZW1lbnQoKTsKLSAgICAKKyAKKyAgICBpZiAoaXNJbWFnZSgpKSB7CisgICAgICAgIE5vZGUq IG5vZGUgPSBtX3JlbmRlcmVyLT5lbGVtZW50KCk7CisgICAgICAgIGlmIChub2RlICYmIG5vZGUt PmlzRWxlbWVudE5vZGUoKSkKKyAgICAgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxFbGVtZW50 Kj4obm9kZSktPmdldEF0dHJpYnV0ZShhbHRBdHRyKTsKKyAgICB9CisgCiAgICAgcmV0dXJuIFN0 cmluZygpOwogfQogCg== 22825 2008-08-15 13:06:10 -0700 2008-08-26 14:34:59 -0700 Patch to populate name attribute for links and headings. TitleAttribute_Linksheadings_patch.txt text/plain 5734 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTc5OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTkgQEAKKzIwMDgtMDgtMTUgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWErYnVnemlsbGFAZ21haWwuY29tPgorCisgICAgICAgIFBvcHVsYXRlIE5hbWUgYXR0cmlidXRl IGZvciBsaW5rcyBhbmQgSGVhZGlucyBhcHByb3ByaWF0ZWx5LiBQYXJ0IG9mCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDAxMworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXQVJOSU5HOiBOTyBURVNUIENBU0VT IEFEREVEIE9SIENIQU5HRUQKKworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRDaGlsZHJlbik6 Q2hhbmdlIGFkZENoaWxkcmVuKCkKKyAgICAgICAgZnVuY3Rpb24gaW50byBhIGNvbnN0IGZ1bmN0 aW9uLgorICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oOgorICAgICAgICAoV2Vi Q29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6Y2hpbGRyZW4pOkNoYW5nZSBhZGRDaGlsZHJlbigp IGFuZAorICAgICAgICBjaGlsZHJlbigpIGZ1bmN0aW9ucyBpbnRvIGNvbnN0IGZ1bmN0aW9ucy4g TWFrZSBtX2NoaWxkcmVuIHZhcmlhYmxlCisgICAgICAgIGludG8gYSBtdXRhYmxlIG9iamVjdC4K KyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAo V2ViQ29yZTo6QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6dGl0bGUpOkZvciBsaW5rcyBhbmQg aGVhZGluZ3MsCisgICAgICAgIHJldHVybiB0aGUgc3RyaW5nIHRoYXQgaXMgZm9ybWVkIGJ5IGNv bmNhdGVuYXRpbmcgdGhlIHRpdGxlKCkgdmFsdWVzCisgICAgICAgIG9mIGl0cyBjaGlsZHJlbi4g TWF0Y2hpbmcgRmlyZWZveC4KKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3Q6OmNoaWxkcmVuKTpDaGFuZ2UgY2hpbGRyZW4oKQorICAgICAgICBhbmQgYWRkQ2hpbGRy ZW4oKSBmdW5jdGlvbnMgaW50byBjb25zdCBmdW5jdGlvbnMuCisgICAgICAgIChXZWJDb3JlOjpB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbik6Q2hhbmdlIGNoaWxkcmVuKCkK KyAgICAgICAgYW5kIGFkZENoaWxkcmVuKCkgZnVuY3Rpb25zIGludG8gY29uc3QgZnVuY3Rpb25z LgorICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oOgorCiAyMDA4LTA4 LTE1ICBUaW1vdGh5IEhhdGNoZXIgIDx0aW1vdGh5QGFwcGxlLmNvbT4KIAogICAgICAgICBEZXRh Y2ggdGhlIHNjcmlwdCBkZWJ1Z2dlciB3aGVuIHRoZSBXZWIgSW5zcGVjdG9yJ3Mgd2luZG93IGNs b3Nlcy4KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5jcHAJKHJldmlzaW9uIDM1 Nzk4KQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC05NzcsNyArOTc3LDcgQEAgdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpjaGlsZHJl bkNoYW5nZQogICAgIHJldHVybjsKIH0KIAotdm9pZCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjphZGRD aGlsZHJlbigpCit2b2lkIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKCkgY29uc3QK IHsKIH0KIApJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVjdC5oCShyZXZpc2lvbiAzNTc5 OCkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgJKHdvcmtpbmcgY29weSkK QEAgLTMwOSw4ICszMDksOCBAQCBwdWJsaWM6CiAgICAgYm9vbCBwZXJmb3JtRGVmYXVsdEFjdGlv bigpIGNvbnN0IHsgcmV0dXJuIHByZXNzKCk7IH0KICAgICAKICAgICB2aXJ0dWFsIHZvaWQgY2hp bGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5W ZWN0b3ImIGNoaWxkcmVuKCkgeyByZXR1cm4gbV9jaGlsZHJlbjsgfQotICAgIHZpcnR1YWwgdm9p ZCBhZGRDaGlsZHJlbigpOworICAgIHZpcnR1YWwgY29uc3QgQWNjZXNzaWJpbGl0eUNoaWxkcmVu VmVjdG9yJiBjaGlsZHJlbigpIGNvbnN0eyByZXR1cm4gbV9jaGlsZHJlbjsgfQorICAgIHZpcnR1 YWwgdm9pZCBhZGRDaGlsZHJlbigpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBoYXNDaGlsZHJl bigpIGNvbnN0IHsgcmV0dXJuIG1faGF2ZUNoaWxkcmVuOyB9OwogICAgIHZpcnR1YWwgdm9pZCBz ZWxlY3RlZENoaWxkcmVuKEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYpOwogICAgIHZpcnR1 YWwgdm9pZCB2aXNpYmxlQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CkBA IC0zODIsNyArMzgyLDcgQEAgcHVibGljOgogCiBwcm90ZWN0ZWQ6CiAgICAgdW5zaWduZWQgbV9p ZDsKLSAgICBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgbV9jaGlsZHJlbjsKKyAgICBtdXRh YmxlIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2NoaWxkcmVuOwogICAgIG11dGFibGUg Ym9vbCBtX2hhdmVDaGlsZHJlbjsKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgY2xlYXJDaGlsZHJl bigpOwpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAko cmV2aXNpb24gMzU3OTgpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTgzMCwxNyArODMwLDI0IEBAIFN0cmluZyBBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0Ojp0aXRsZSgKICAgICAgICAgaWYgKGxhYmVsKQogICAgICAgICAg ICAgcmV0dXJuIGxhYmVsLT5pbm5lclRleHQoKTsKICAgICB9Ci0gICAgCisKKyAgICBpZiAobV9y ZW5kZXJlci0+ZWxlbWVudCgpLT5pc0xpbmsoKSB8fCBpc0hlYWRpbmcoKSkgeworICAgICAgICBj b25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuVmVjdG9yID0gY2hpbGRy ZW4oKTsKKyAgICAgICAgVmVjdG9yPFVDaGFyPiBlbGVtZW50VGV4dDsKKyAgICAgICAgZm9yICh1 bnNpZ25lZCBpID0gMDsgaSA8IGNoaWxkcmVuVmVjdG9yLnNpemUoKTsgKytpKSB7CisgICAgICAg ICAgICBlbGVtZW50VGV4dC5hcHBlbmQoJyAnKTsKKyAgICAgICAgICAgIGFwcGVuZChlbGVtZW50 VGV4dCwgY2hpbGRyZW5WZWN0b3JbaV0tPnRpdGxlKCkpOworICAgICAgICB9CisgICAgICAgIHJl dHVybiBTdHJpbmc6OmFkb3B0KGVsZW1lbnRUZXh0KS5zdHJpcFdoaXRlU3BhY2UoKTsKKyAgICB9 CisgCiAgICAgaWYgKHJvbGVWYWx1ZSgpID09IEJ1dHRvblJvbGUKICAgICAgICAgfHwgYXJpYVJv bGUgPT0gTGlzdEJveE9wdGlvblJvbGUKICAgICAgICAgfHwgYXJpYVJvbGUgPT0gTWVudUl0ZW1S b2xlCi0gICAgICAgIHx8IGFyaWFSb2xlID09IE1lbnVCdXR0b25Sb2xlCi0gICAgICAgIHx8IGlz SGVhZGluZygpKQorICAgICAgICB8fCBhcmlhUm9sZSA9PSBNZW51QnV0dG9uUm9sZSkKICAgICAg ICAgcmV0dXJuIHRleHRVbmRlckVsZW1lbnQoKTsKLSAgICAKLSAgICBpZiAoaXNMaW5rKCkpCi0g ICAgICAgIHJldHVybiB0ZXh0VW5kZXJFbGVtZW50KCk7Ci0gICAgCisgICAgICAgIAogICAgIHJl dHVybiBTdHJpbmcoKTsKIH0KIApAQCAtMjE3NSwxNCArMjE4MiwxNCBAQCB2b2lkIEFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuCiAgICAgfQogfQogCi1jb25zdCBBY2Nlc3NpYmls aXR5T2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3Q6OmNoaWxkcmVuKCkKK2NvbnN0IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2li aWxpdHlDaGlsZHJlblZlY3RvciYgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6Y2hpbGRyZW4o KSBjb25zdAogewogICAgIGlmICghbV9oYXZlQ2hpbGRyZW4pCiAgICAgICAgIGFkZENoaWxkcmVu KCk7CiAgICAgcmV0dXJuIG1fY2hpbGRyZW47CiB9CiAKLXZvaWQgQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdDo6YWRkQ2hpbGRyZW4oKQordm9pZCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojph ZGRDaGlsZHJlbigpIGNvbnN0CiB7CiAgICAgLy8gSWYgdGhlIG5lZWQgdG8gYWRkIG1vcmUgY2hp bGRyZW4gaW4gYWRkaXRpb24gdG8gZXhpc3RpbmcgY2hpbGRyZW4gYXJpc2VzLCAKICAgICAvLyBj aGlsZHJlbkNoYW5nZWQgc2hvdWxkIGhhdmUgYmVlbiBjYWxsZWQsIGxlYXZpbmcgdGhlIG9iamVj dCB3aXRoIG5vIGNoaWxkcmVuLgpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5oCShyZXZpc2lvbiAzNTc5OCkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE3Miw3ICsxNzIsNyBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCB2b2lkIGdldERvY3VtZW50TGlua3MoQWNjZXNzaWJpbGl0eUNoaWxkcmVu VmVjdG9yJikgY29uc3Q7CiAgICAgdmlydHVhbCBGcmFtZVZpZXcqIGRvY3VtZW50RnJhbWVWaWV3 KCkgY29uc3Q7CiAgICAgCi0gICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5W ZWN0b3ImIGNoaWxkcmVuKCk7CisgICAgdmlydHVhbCBjb25zdCBBY2Nlc3NpYmlsaXR5Q2hpbGRy ZW5WZWN0b3ImIGNoaWxkcmVuKCkgY29uc3Q7CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIHNldEZv Y3VzZWQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lkIHNldFNlbGVjdGVkVGV4dFJhbmdlKGNvbnN0 IFBsYWluVGV4dFJhbmdlJik7CkBAIC0xODAsNyArMTgwLDcgQEAgcHVibGljOgogICAgIAogICAg IHZpcnR1YWwgdm9pZCBkZXRhY2goKTsKICAgICB2aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2Vk KCk7Ci0gICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCk7CisgICAgdmlydHVhbCB2b2lkIGFk ZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4oQWNj ZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAgICAgdmlydHVhbCB2b2lkIHZpc2libGVDaGls ZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsKICAgICB2aXJ0dWFsIGJvb2wgc2hv dWxkRm9jdXNBY3RpdmVEZXNjZW5kYW50KCkgY29uc3Q7Cg== 22826 2008-08-15 14:06:45 -0700 2008-08-26 14:34:59 -0700 Patch to populate Name attribue for Text Elements NameAttribute_TextElements.txt text/plain 1231 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTc5OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzIgQEAKKzIwMDgtMDgtMTUgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWErYnVnemlsbGFAZ21haWwuY29tPgorCisgICAgICAgIFBvcHVsYXRlIG5hbWUgYXR0cmlidXRl IGZvciBUZXh0IGVsZW1lbnRzIGFwcHJvcHJpYXRlbHkuIFBhcnQgb2YKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEzCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURE RUQgT1IgQ0hBTkdFRAorCisgICAgICAgICogQ2hhbmdlTG9nOgorICAgICAgICAqIHBhZ2UvQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0Ojp0aXRsZSk6UmV0dXJuIHRleHQgY29udGVudAorICAgICAgICBwcmVz ZW50IHVuZGVyIHRoZSBub2RlIGZvciBUZXh0RWxlbWVudHMuIE1hdGNoaW5nIEZpcmVmb3guCisK IDIwMDgtMDgtMTUgIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUuY29tPgogCiAgICAgICAg IFJldmlld2VkIGJ5IE9saXZlci4KSW5kZXg6IFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDM1NzcyKQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04NDAsNyArODQwLDEwIEBA IFN0cmluZyBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojp0aXRsZSgKICAgICAKICAgICBpZiAo aXNMaW5rKCkpCiAgICAgICAgIHJldHVybiB0ZXh0VW5kZXJFbGVtZW50KCk7Ci0gICAgCisKKyAg ICBpZiAobV9yZW5kZXJlci0+aXNUZXh0KCkpCisgICAgICAgIHJldHVybiB0ZXh0VW5kZXJFbGVt ZW50KCk7CisKICAgICByZXR1cm4gU3RyaW5nKCk7CiB9Cg== 23005 2008-08-26 11:07:38 -0700 2008-08-26 16:28:28 -0700 Patch to expose list elements and populate role attribute for them correctly. Expose_PopulateRole_ListElement.txt text/plain 5114 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTkzMykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTMgQEAKKzIwMDgtMDgtMjYgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWErYnVnemlsbGFAZ21haWwuY29tPgorCisgICAgICAgIEV4cG9zZSBsaXN0IGVsZW1lbnRzLiBB bHNvLCBwb3B1bGF0ZSByb2xlIGF0dHJpYnV0ZSBmb3IgbGlzdAorICAgICAgICBlbGVtZW50cyBh cHByb3ByaWF0ZWx5LiBQYXJ0IG9mIAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjAwMTMKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgVGVzdDogYWNjZXNzaWJpbGl0eS9saXN0ZWxlbWVudHMtZGV0ZWN0aW9uLmh0 bWwKKworICAgICAgICAqIHBhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjphY2Nlc3NpYmlsaXR5SXNJ Z25vcmVkKTpSZXR1cm4KKyAgICAgICAgZmFsc2UgZm9yIGxpc3QgZWxlbWVudHMuCisgICAgICAg IChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Ojpyb2xlVmFsdWUpOlJldHVybiBM aXN0Um9sZSBmb3IKKyAgICAgICAgbGlzdCBlbGVtZW50cy4KKwogMjAwOC0wOC0yNiAgTWF4aW1l IEJyaXR0byAgPGJyaXR0b0BhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRlbGUu CkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCShyZXZp c2lvbiAzNTkyNSkKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNw cAkod29ya2luZyBjb3B5KQpAQCAtMTEwNyw3ICsxMTA3LDEwIEBAIGJvb2wgQWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdDo6YWNjZXNzaWIKICAgICBOb2RlKiBub2RlID0gbV9yZW5kZXJlci0+ZWxl bWVudCgpOwogICAgIGlmIChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUobGFiZWxUYWcpKQogICAg ICAgICByZXR1cm4gZmFsc2U7Ci0gICAgCisKKyAgICBpZiAoaXNMaXN0RWxlbWVudChub2RlKSkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAKICAgICBpZiAobV9yZW5kZXJlci0+aXNC bG9ja0Zsb3coKSAmJiBtX3JlbmRlcmVyLT5jaGlsZHJlbklubGluZSgpKQogICAgICAgICByZXR1 cm4gIXN0YXRpY19jYXN0PFJlbmRlckJsb2NrKj4obV9yZW5kZXJlciktPmZpcnN0TGluZUJveCgp ICYmICFtb3VzZUJ1dHRvbkxpc3RlbmVyKCk7CiAgICAgCkBAIC0yMDQyLDYgKzIwNDUsOSBAQCBB Y2Nlc3NpYmlsaXR5Um9sZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqCiAgICAgaWYgKG5vZGUgJiYg bm9kZS0+aGFzVGFnTmFtZShidXR0b25UYWcpKQogICAgICAgICByZXR1cm4gQnV0dG9uUm9sZTsK IAorICAgIGlmIChpc0xpc3RFbGVtZW50KG5vZGUpKQorICAgICAgICByZXR1cm4gTGlzdFJvbGU7 CisKICAgICBpZiAoaXNGaWxlVXBsb2FkQnV0dG9uKCkpCiAgICAgICAgIHJldHVybiBCdXR0b25S b2xlOwogICAgIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gMzU5MzMpCisrKyBMYXlvdXRUZXN0cy9DaGFu Z2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxMSBAQAorMjAwOC0wOC0yNiAgU2Fua2Fy IFRhbmd1dHVyaSAgPHNhbmthcmFkaXR5YStidWd6aWxsYUBnbWFpbC5jb20+CisKKyAgICAgICAg QWRkIGxheW91dCB0ZXN0cyBmb3IgZGV0ZWN0aW5nIGFuZCBwb3B1bGF0aW5nIHJvbGUgYXR0cmli dXRlIGZvcgorICAgICAgICBsaXN0IGVsZW1lbnRzLgorICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvbGlzdGVsZW1lbnRzLWRldGVj dGlvbi1leHBlY3RlZC50eHQ6IEFkZGVkLiBUaGlzCisgICAgICAgIGZpbGUgY29udGFpbnMgdGhl IGV4cGVjdGVkIG91dHB1dCBmb3IgdGhlIGxheW91dCB0ZXN0IHRoYXQgaXMgYWRkZWQuIAorICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvbGlzdGVsZW1lbnRzLWRldGVjdGlvbi5odG1sOiBBZGRlZC5U aGlzIHRlc3QgaXMKKyAgICAgICAgZGV2ZWxvcGVkIHRvIHRlc3Qgd2hldGhlciB0aGUgcm9sZSBh dHRyaWJ1dGUgb2YgbGlzdCBlbGVtZW50cyBpcworICAgICAgICBwb3B1bGF0ZWQgY29ycmVjdGx5 IGFzICJsaXN0IiBvciBub3QuIEFsc28sIHRoaXMgdGVzdCBjaGVja3MgaWYgCisgICAgICAgIGxp c3QgZWxlbWVudHMgYXJlIGV4cG9zZWQuCisKIDIwMDgtMDgtMjUgIEp1bGllbiBDaGFmZnJhaXgg IDxqY2hhZmZyYWl4QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4uCklu ZGV4OiBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L2xpc3RlbGVtZW50cy1kZXRlY3Rpb24tZXhw ZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbGlzdGVs ZW1lbnRzLWRldGVjdGlvbi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9hY2Nlc3NpYmlsaXR5L2xpc3RlbGVtZW50cy1kZXRlY3Rpb24tZXhwZWN0ZWQudHh0CShyZXZp c2lvbiAwKQpAQCAtMCwwICsxLDE1IEBACitUaGlzIGlzIGFuIE9yZGVyZWQgTGlzdAorT3B0aW9u IEl0ZW0gMSBpbiBPcmRlcmVkIExpc3QKK09wdGlvbiBJdGVtIDIgaW4gT3JkZXJlZCBMaXN0CitU aGlzIGlzIGFuIFVub3JkZXJlZCBMaXN0CitGaXJzdCBJdGVtIGluIHVuLW9yZGVyZWQgbGlzdAor U2Vjb25kIEl0ZW0gaW4gdW4tb3JkZXJlZCBsaXN0CitUaGlzIGlzIGEgZGlyZWN0b3J5IExpc3QK KyBGaXJzdCBJdGVtIGluIERpcmVjdG9yeSBMaXN0CisgU2Vjb25kIEl0ZW0gaW4gRGlyZWN0b3J5 IExpc3QKK1Rlc3QgZm9yIHJvbGUgYXR0cmlidXRlcyBvZiBsaXN0IGVsZW1lbnRzIAorLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gCityb2xlIG9mIG9yZGVyZWQgbGlzdCA6 IGxpc3QKK3JvbGUgb2YgdW4tb3JkZXJlZCBsaXN0IDogbGlzdAorcm9sZSBvZiBkaXJlY3Rvcnkg bGlzdCA6IGxpc3QKKwpJbmRleDogTGF5b3V0VGVzdHMvYWNjZXNzaWJpbGl0eS9saXN0ZWxlbWVu dHMtZGV0ZWN0aW9uLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvYWNjZXNzaWJpbGl0 eS9saXN0ZWxlbWVudHMtZGV0ZWN0aW9uLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9hY2Nlc3NpYmlsaXR5L2xpc3RlbGVtZW50cy1kZXRlY3Rpb24uaHRtbAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSw0NyBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KTsKKzwvc2NyaXB0PgorPGJvZHkgaWQ9ImJvZHkiPgorCis8b2wgaWQ9Imxpc3QiPiBUaGlzIGlz IGFuIE9yZGVyZWQgTGlzdAorPGxpPiBPcHRpb24gSXRlbSAxIGluIE9yZGVyZWQgTGlzdCA8L2xp PgorPGxpPiBPcHRpb24gSXRlbSAyIGluIE9yZGVyZWQgTGlzdCA8L2xpPgorPC9vbD4KKworPHVs PiBUaGlzIGlzIGFuIFVub3JkZXJlZCBMaXN0Cis8bGk+IEZpcnN0IEl0ZW0gaW4gdW4tb3JkZXJl ZCBsaXN0IDwvbGk+Cis8bGk+IFNlY29uZCBJdGVtIGluIHVuLW9yZGVyZWQgbGlzdCA8L2xpPgor PC91bD4KKworPGRsPiBUaGlzIGlzIGEgZGlyZWN0b3J5IExpc3QKKzxsaT4gRmlyc3QgSXRlbSBp biBEaXJlY3RvcnkgTGlzdCA8L2xpPgorPGxpPiBTZWNvbmQgSXRlbSBpbiBEaXJlY3RvcnkgTGlz dCA8L2xpPgorPC9kbD4KKworPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKworPHNjcmlwdD4KKyAg ICBpZiAod2luZG93LmFjY2Vzc2liaWxpdHlDb250cm9sbGVyKSB7CisgICAgICAgIHZhciByZXN1 bHQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0Iik7CisKKyAgICAgICAgdmFyIGJv ZHkgICA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJib2R5Iik7CisgICAgICAgIGJvZHkuZm9j dXMoKTsKKworICAgICAgICB2YXIgbGlzdCA9IGFjY2Vzc2liaWxpdHlDb250cm9sbGVyLmZvY3Vz ZWRFbGVtZW50LmNoaWxkQXRJbmRleCgwKTsKKworICAgICAgICByZXN1bHQuaW5uZXJUZXh0ICs9 ICJUZXN0IGZvciByb2xlIGF0dHJpYnV0ZXMgb2YgbGlzdCBlbGVtZW50cyBcbiI7CisgICAgICAg IHJlc3VsdC5pbm5lclRleHQgKz0gIi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tIFxuIjsKKyAgICAgICAgcmVzdWx0LmlubmVyVGV4dCArPSAicm9sZSBvZiBvcmRlcmVkIGxp c3QgICAgOiAiICsgbGlzdC5yb2xlICsgIlxuIiA7CisKKyAgICAgICAgdmFyIGxpc3QgPSBhY2Nl c3NpYmlsaXR5Q29udHJvbGxlci5mb2N1c2VkRWxlbWVudC5jaGlsZEF0SW5kZXgoMSk7CisgICAg ICAgIHJlc3VsdC5pbm5lclRleHQgKz0gInJvbGUgb2YgdW4tb3JkZXJlZCBsaXN0IDogIiArIGxp c3Qucm9sZSArICJcbiIgOworCisgICAgICAgIHZhciBsaXN0ID0gYWNjZXNzaWJpbGl0eUNvbnRy b2xsZXIuZm9jdXNlZEVsZW1lbnQuY2hpbGRBdEluZGV4KDIpOworICAgICAgICByZXN1bHQuaW5u ZXJUZXh0ICs9ICJyb2xlIG9mIGRpcmVjdG9yeSBsaXN0ICA6ICIgKyBsaXN0LnJvbGUgKyAiXG4i IDsKKyAgICB9CisKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 23006 2008-08-26 14:34:59 -0700 2008-08-26 20:08:21 -0700 Patch to populate name attribute for text nodes, links and headings. NameAttribute_LinksHeadings_TextElements.txt text/plain 11637 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTkzNSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjEgQEAKKzIwMDgtMDgtMjYgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZHRp eWErYnVnemlsbGFAZ21haWwuY29tPgorICAgICAgICBQb3B1bGF0ZSBuYW1lIGF0dHJpYnV0ZSBm b3IgbGlua3MsIGhlYWRpbmdzIGFuZCB0ZXh0IGVsZW1lbnRzCisgICAgICAgIGFwcHJvcHJpYXRl bHkuIFBhcnQgb2YgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEz CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3RzOiBh Y2Nlc3NpYmlsaXR5L2hlYWRpbmdlbGVtZW50LXRpdGxlLmh0bWwKKyAgICAgICAgICAgICAgIGFj Y2Vzc2liaWxpdHkvbGlua2VsZW1lbnQtdGl0bGUuaHRtbAorICAgICAgICAgICAgICAgYWNjZXNz aWJpbGl0eS90ZXh0ZWxlbWVudC10aXRsZS5odG1sCisKKyAgICAgICAgKiBwYWdlL0FjY2Vzc2li aWxpdHlPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QWNjZXNzaWJpbGl0eU9iamVjdDo6 YWRkQ2hpbGRyZW4pOkNoYW5nZSBjaGlsZHJlbigpIGZ1bmN0aW9uCisgICAgICAgIGludG8gYSBj b25zdCBmdW5jdGlvbi4KKyAgICAgICAgKiBwYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaDoKKyAg ICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlPYmplY3Q6OmNoaWxkcmVuKTpDaGFuZ2UgYWRk Q2hpbGRyZW4oKSBhbmQKKyAgICAgICAgY2hpbGRyZW4oKSBmdW5jdGlvbnMgaW50byBjb25zdCBm dW5jdGlvbnMuIE1ha2UgbV9jaGlsZHJlbiB2YXJpYWJsZQorICAgICAgICBpbnRvIGEgbXV0YWJs ZSBvYmplY3QuCisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRpdGxlKTpSZXR1 cm4gdGhlIHJhdyB0ZXh0CisgICAgICAgIGNvbnRlbnQgZm9yIHRleHQgbm9kZXMuIEZvciBsaW5r cyBhbmQgaGVhZGluZ3MsIHJldHVybiB0aGUgc3RyaW5nIAorICAgICAgICB0aGF0IGlzIGZvcm1l ZCBieSBjb25jYXRlbmF0aW5nIHRoZSB0aXRsZSgpIHZhbHVlcyBvZiBpdHMgY2hpbGRyZW4uCisg ICAgICAgIE1hdGNoaW5nIEZpcmVmb3guCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjpjaGlsZHJlbik6Q2hhbmdlIGNoaWxkcmVuKCkKKyAgICAgICAgZnVuY3Rp b24gaW50byBjb25zdCBmdW5jdGlvbnMuCisgICAgICAgIChXZWJDb3JlOjpBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbik6Q2hhbmdlIGFkZENoaWxkcmVuKCkKKyAgICAgICAg ZnVuY3Rpb24gaW50byBhIGNvbnN0IGZ1bmN0aW9uLgorICAgICAgICAqIHBhZ2UvQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdC5oOkNoYW5nZSB0aGUgc2lnbmF0dXJlcyBvZiBjaGlsZHJlbigpCisg ICAgICAgIGFuZCBhZGRDaGlsZHJlbigpIGZ1bmN0aW9ucyBpbnRvIGNvbnN0IGZ1bmN0aW9uLnMK KwogMjAwOC0wOC0yNiAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IE9saXZlciBIdW50LgpJbmRleDogV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlP YmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0 LmNwcAkocmV2aXNpb24gMzU5MzMpCisrKyBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVj dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTk3Nyw3ICs5NzcsNyBAQCB2b2lkIEFjY2Vzc2liaWxp dHlPYmplY3Q6OmNoaWxkcmVuQ2hhbmdlCiAgICAgcmV0dXJuOwogfQogCi12b2lkIEFjY2Vzc2li aWxpdHlPYmplY3Q6OmFkZENoaWxkcmVuKCkKK3ZvaWQgQWNjZXNzaWJpbGl0eU9iamVjdDo6YWRk Q2hpbGRyZW4oKSBjb25zdAogewogfQogCkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0 eU9iamVjdC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0 LmgJKHJldmlzaW9uIDM1OTMzKQorKysgV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3Qu aAkod29ya2luZyBjb3B5KQpAQCAtMzE0LDggKzMxNCw4IEBAIHB1YmxpYzoKICAgICBib29sIHBl cmZvcm1EZWZhdWx0QWN0aW9uKCkgY29uc3QgeyByZXR1cm4gcHJlc3MoKTsgfQogICAgIAogICAg IHZpcnR1YWwgdm9pZCBjaGlsZHJlbkNoYW5nZWQoKTsKLSAgICB2aXJ0dWFsIGNvbnN0IEFjY2Vz c2liaWxpdHlDaGlsZHJlblZlY3RvciYgY2hpbGRyZW4oKSB7IHJldHVybiBtX2NoaWxkcmVuOyB9 Ci0gICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCk7CisgICAgdmlydHVhbCBjb25zdCBBY2Nl c3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgY29uc3R7IHJldHVybiBtX2NoaWxk cmVuOyB9CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVh bCBib29sIGhhc0NoaWxkcmVuKCkgY29uc3QgeyByZXR1cm4gbV9oYXZlQ2hpbGRyZW47IH07CiAg ICAgdmlydHVhbCB2b2lkIHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVj dG9yJik7CiAgICAgdmlydHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hp bGRyZW5WZWN0b3ImKTsKQEAgLTM4Nyw3ICszODcsNyBAQCBwdWJsaWM6CiAKIHByb3RlY3RlZDoK ICAgICB1bnNpZ25lZCBtX2lkOwotICAgIEFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBtX2No aWxkcmVuOworICAgIG11dGFibGUgQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIG1fY2hpbGRy ZW47CiAgICAgbXV0YWJsZSBib29sIG1faGF2ZUNoaWxkcmVuOwogICAgIAogICAgIHZpcnR1YWwg dm9pZCBjbGVhckNoaWxkcmVuKCk7CkluZGV4OiBXZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAzNTkzMykKKysrIFdlYkNvcmUvcGFnZS9BY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtODMwLDE3ICs4MzAsMjYg QEAgU3RyaW5nIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OnRpdGxlKAogICAgICAgICBpZiAo bGFiZWwpCiAgICAgICAgICAgICByZXR1cm4gbGFiZWwtPmlubmVyVGV4dCgpOwogICAgIH0KLSAg ICAKKyAKKyAgICBpZiAoaXNMaW5rKCkgfHwgaXNIZWFkaW5nKCkpIHsKKyAgICAgICAgY29uc3Qg QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJiBjaGlsZHJlblZlY3RvciA9IGNoaWxkcmVuKCk7 CisgICAgICAgIFZlY3RvcjxVQ2hhcj4gZWxlbWVudFRleHQ7CisgICAgICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBjaGlsZHJlblZlY3Rvci5zaXplKCk7ICsraSkgeworICAgICAgICAgICAg ZWxlbWVudFRleHQuYXBwZW5kKCcgJyk7CisgICAgICAgICAgICBhcHBlbmQoZWxlbWVudFRleHQs IGNoaWxkcmVuVmVjdG9yW2ldLT50aXRsZSgpKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4g U3RyaW5nOjphZG9wdChlbGVtZW50VGV4dCkuc3RyaXBXaGl0ZVNwYWNlKCk7CisgICAgfQorIAog ICAgIGlmIChyb2xlVmFsdWUoKSA9PSBCdXR0b25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09 IExpc3RCb3hPcHRpb25Sb2xlCiAgICAgICAgIHx8IGFyaWFSb2xlID09IE1lbnVJdGVtUm9sZQot ICAgICAgICB8fCBhcmlhUm9sZSA9PSBNZW51QnV0dG9uUm9sZQotICAgICAgICB8fCBpc0hlYWRp bmcoKSkKKyAgICAgICAgfHwgYXJpYVJvbGUgPT0gTWVudUJ1dHRvblJvbGUpCiAgICAgICAgIHJl dHVybiB0ZXh0VW5kZXJFbGVtZW50KCk7CiAgICAgCi0gICAgaWYgKGlzTGluaygpKQorICAgIGlm IChtX3JlbmRlcmVyLT5pc1RleHQoKSkKICAgICAgICAgcmV0dXJuIHRleHRVbmRlckVsZW1lbnQo KTsKLSAgICAKKyAgIAogICAgIHJldHVybiBTdHJpbmcoKTsKIH0KIApAQCAtMjEyNywxNCArMjEz NiwxNCBAQCB2b2lkIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuCiAgICAgfQog fQogCi1jb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0 b3ImIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmNoaWxkcmVuKCkKK2NvbnN0IEFjY2Vzc2li aWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciYgQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdDo6Y2hpbGRyZW4oKSBjb25zdAogewogICAgIGlmICghbV9oYXZlQ2hpbGRyZW4p CiAgICAgICAgIGFkZENoaWxkcmVuKCk7CiAgICAgcmV0dXJuIG1fY2hpbGRyZW47CiB9CiAKLXZv aWQgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6YWRkQ2hpbGRyZW4oKQordm9pZCBBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0OjphZGRDaGlsZHJlbigpIGNvbnN0CiB7CiAgICAgLy8gSWYgdGhl IG5lZWQgdG8gYWRkIG1vcmUgY2hpbGRyZW4gaW4gYWRkaXRpb24gdG8gZXhpc3RpbmcgY2hpbGRy ZW4gYXJpc2VzLCAKICAgICAvLyBjaGlsZHJlbkNoYW5nZWQgc2hvdWxkIGhhdmUgYmVlbiBjYWxs ZWQsIGxlYXZpbmcgdGhlIG9iamVjdCB3aXRoIG5vIGNoaWxkcmVuLgpJbmRleDogV2ViQ29yZS9w YWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3Bh Z2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCShyZXZpc2lvbiAzNTkzMykKKysrIFdlYkNv cmUvcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE3 Miw3ICsxNzIsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGdldERvY3VtZW50TGlua3Mo QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJikgY29uc3Q7CiAgICAgdmlydHVhbCBGcmFtZVZp ZXcqIGRvY3VtZW50RnJhbWVWaWV3KCkgY29uc3Q7CiAgICAgCi0gICAgdmlydHVhbCBjb25zdCBB Y2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCk7CisgICAgdmlydHVhbCBjb25z dCBBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImIGNoaWxkcmVuKCkgY29uc3Q7CiAgICAgCiAg ICAgdmlydHVhbCB2b2lkIHNldEZvY3VzZWQoYm9vbCk7CiAgICAgdmlydHVhbCB2b2lkIHNldFNl bGVjdGVkVGV4dFJhbmdlKGNvbnN0IFBsYWluVGV4dFJhbmdlJik7CkBAIC0xODAsNyArMTgwLDcg QEAgcHVibGljOgogICAgIAogICAgIHZpcnR1YWwgdm9pZCBkZXRhY2goKTsKICAgICB2aXJ0dWFs IHZvaWQgY2hpbGRyZW5DaGFuZ2VkKCk7Ci0gICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCk7 CisgICAgdmlydHVhbCB2b2lkIGFkZENoaWxkcmVuKCkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lk IHNlbGVjdGVkQ2hpbGRyZW4oQWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yJik7CiAgICAgdmly dHVhbCB2b2lkIHZpc2libGVDaGlsZHJlbihBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3ImKTsK ICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkRm9jdXNBY3RpdmVEZXNjZW5kYW50KCkgY29uc3Q7Cklu ZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNTkzNSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDI0IEBACisyMDA4LTA4LTI2ICBTYW5rYXIgVGFuZ3V0dXJpICA8 c2Fua2FyYWR0aXlhK2J1Z3ppbGxhQGdtYWlsLmNvbT4KKworICAgICAgICBBZGQgdGVzdGNhc2Vz IHRvIGNoZWNrIGlmIHRoZSBuYW1lIGF0dHJpYnV0ZSBpcyBwb3B1bGF0ZWQKKyAgICAgICAgYXBw cm9wcmlhdGVseSBmb3IgdGV4dCBlbGVtZW50cywgbGluayBlbGVtZW50cyBhbmQgaGVhZGluZwor ICAgICAgICBlbGVtZW50cy4KKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiBDaGFuZ2VMb2c6CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9oZWFkaW5nZWxl bWVudC10aXRsZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGFjY2Vzc2liaWxpdHkv aGVhZGluZ2VsZW1lbnQtdGl0bGUuaHRtbDogQWRkZWQuIFRoaXMgdGVzdCBpcyBhZGRlZAorICAg ICAgICB0byBjaGVjayBpZiB0aGUgbmFtZSBhdHRyaWJ1dGUgZm9yIGhlYWRpbmcgZWxlbWVudHMg aXMgcG9wdWxhdGVkCisgICAgICAgIGFwcHJvcHJpYXRlbHkgb3Igbm90LgorICAgICAgICAqIGFj Y2Vzc2liaWxpdHkvbGlua2VsZW1lbnQtdGl0bGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBhY2Nlc3NpYmlsaXR5L2xpbmtlbGVtZW50LXRpdGxlLmh0bWw6IEFkZGVkLiBUaGlzIHRl c3QgaXMgYWRkZWQKKyAgICAgICAgdG8gZW5zdXJlIHRoYXQgbmFtZSBhdHRyaWJ1dGUgZm9yIGxp bmsgZWxlbWVudCBpcyBwb3B1bGF0ZWQKKyAgICAgICAgYXBwcm9wcmlhdGVseS4KKyAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L3RleHRlbGVtZW50LXRpdGxlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogYWNjZXNzaWJpbGl0eS90ZXh0ZWxlbWVudC10aXRsZS5odG1sOiBBZGRlZC4gVGhp cyB0ZXN0IGlzIGFkZGVkCisgICAgICAgIHRvIGNoZWNrIHdoZXRoZXIgdGhlIG5hbWUgYXR0cmli dXRlIGZvciB0aGUgdGV4dCBub2RlcyBpcyAKKyAgICAgICAgcG9wdWxhdGVkIGFwcHJvcHJpYXRl bHkgb3Igbm90LgorCiAyMDA4LTA4LTI2ICBTYW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgT2xpdmVyIEh1bnQuCkluZGV4OiBMYXlvdXRUZXN0cy9hY2Nl c3NpYmlsaXR5L2hlYWRpbmdlbGVtZW50LXRpdGxlLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L2hlYWRpbmdlbGVtZW50LXRpdGxlLWV4cGVjdGVk LnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvaGVhZGluZ2Vs ZW1lbnQtdGl0bGUtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYgQEAKK1Ro aXMgaXMgYSBoZWFkaW5nIG5vZGUKKworaGVhZGluZyBlbGVtZW50IC0gVGVzdCBmb3IgbmFtZSBh dHRyaWJ1dGUgCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAKK25hbWUg YXR0cmlidXRlIDogVGhpcyBpcyBhIGhlYWRpbmcgbm9kZSAKKwpJbmRleDogTGF5b3V0VGVzdHMv YWNjZXNzaWJpbGl0eS9oZWFkaW5nZWxlbWVudC10aXRsZS5odG1sCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvaGVhZGluZ2VsZW1lbnQtdGl0bGUuaHRtbAkocmV2aXNp b24gMCkKKysrIExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvaGVhZGluZ2VsZW1lbnQtdGl0bGUu aHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMyBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAg IGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLmR1bXBBc1RleHQoKTsKKzwvc2NyaXB0PgorPGJvZHkgaWQ9ImJvZHkiPgorPGgxPlRo aXMgaXMgYSBoZWFkaW5nIG5vZGUgPC9oMT4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8c2Ny aXB0PgorICAgIGlmICh3aW5kb3cuYWNjZXNzaWJpbGl0eUNvbnRyb2xsZXIpIHsKKyAgICAgICAg dmFyIHJlc3VsdCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHQiKTsKKworICAgICAg ICB2YXIgYm9keSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJib2R5Iik7CisgICAgICAgIGJv ZHkuZm9jdXMoKTsKKyAgICAgICAgdmFyIGhlYWRpbmcgPSBhY2Nlc3NpYmlsaXR5Q29udHJvbGxl ci5mb2N1c2VkRWxlbWVudC5jaGlsZEF0SW5kZXgoMCk7CisgICAgICAgIGhlYWRpbmcgPSBoZWFk aW5nLmNoaWxkQXRJbmRleCgwKTsKKyAgICAgICAgcmVzdWx0LmlubmVyVGV4dCArPSAiIGhlYWRp bmcgZWxlbWVudCAtIFRlc3QgZm9yIG5hbWUgYXR0cmlidXRlIFxuIjsKKyAgICAgICAgcmVzdWx0 LmlubmVyVGV4dCArPSAiIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIFxu IjsKKyAgICAgICAgcmVzdWx0LmlubmVyVGV4dCArPSAiIG5hbWUgYXR0cmlidXRlIDogIiArIGhl YWRpbmcudGl0bGUgKyAiICBcbiI7CisgICAgfQorPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+ CkluZGV4OiBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L2xpbmtlbGVtZW50LXRpdGxlLWV4cGVj dGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L2xpbmtlbGVt ZW50LXRpdGxlLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2FjY2Vz c2liaWxpdHkvbGlua2VsZW1lbnQtdGl0bGUtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDUgQEAKK0xpbmsgdG8gV2ViS2l0CitsaW5rIGVsZW1lbnQgLSBUZXN0IGZvciBuYW1l IGF0dHJpYnV0ZSAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIAorbmFt ZSBhdHRyaWJ1dGUgOiBMaW5rIHRvIFdlYktpdCAKKwpJbmRleDogTGF5b3V0VGVzdHMvYWNjZXNz aWJpbGl0eS9saW5rZWxlbWVudC10aXRsZS5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3Rz L2FjY2Vzc2liaWxpdHkvbGlua2VsZW1lbnQtdGl0bGUuaHRtbAkocmV2aXNpb24gMCkKKysrIExh eW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbGlua2VsZW1lbnQtdGl0bGUuaHRtbAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSwyMyBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKzwvc2NyaXB0PgorPGJvZHkgaWQ9ImJvZHkiPgorPGEgaHJlZj0iaHR0cDovL3dlYmtp dC5vcmciPkxpbmsgdG8gV2ViS2l0PC9hPgorPGRpdiBpZD0icmVzdWx0Ij48L2Rpdj4KKzxzY3Jp cHQ+CisgICAgaWYgKHdpbmRvdy5hY2Nlc3NpYmlsaXR5Q29udHJvbGxlcikgeworICAgICAgICB2 YXIgcmVzdWx0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdCIpOworCisgICAgICAg IHZhciBib2R5ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImJvZHkiKTsKKyAgICAgICAgYm9k eS5mb2N1cygpOworICAgICAgICB2YXIgbGluayA9IGFjY2Vzc2liaWxpdHlDb250cm9sbGVyLmZv Y3VzZWRFbGVtZW50LmNoaWxkQXRJbmRleCgwKTsKKyAgICAgICAgbGluayA9IGxpbmsuY2hpbGRB dEluZGV4KDApOworICAgICAgICByZXN1bHQuaW5uZXJUZXh0ICs9ICIgbGluayBlbGVtZW50IC0g VGVzdCBmb3IgbmFtZSBhdHRyaWJ1dGUgXG4iOworICAgICAgICByZXN1bHQuaW5uZXJUZXh0ICs9 ICIgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gXG4iOworICAgICAgICBy ZXN1bHQuaW5uZXJUZXh0ICs9ICIgbmFtZSBhdHRyaWJ1dGUgOiAiICsgbGluay50aXRsZSArICIg IFxuIjsKKyAgICB9Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRl c3RzL2FjY2Vzc2liaWxpdHkvdGV4dGVsZW1lbnQtdGl0bGUtZXhwZWN0ZWQudHh0Cj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvdGV4dGVsZW1lbnQtdGl0bGUtZXhwZWN0 ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvYWNjZXNzaWJpbGl0eS90ZXh0ZWxl bWVudC10aXRsZS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNSBAQAorVGhp cyBpcyBhIHRleHQgbm9kZQordGV4dCBlbGVtZW50IC0gVGVzdCBmb3IgbmFtZSBhdHRyaWJ1dGUg CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAKK25hbWUgYXR0cmlidXRl IDogVGhpcyBpcyBhIHRleHQgbm9kZSAKKwpJbmRleDogTGF5b3V0VGVzdHMvYWNjZXNzaWJpbGl0 eS90ZXh0ZWxlbWVudC10aXRsZS5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2FjY2Vz c2liaWxpdHkvdGV4dGVsZW1lbnQtdGl0bGUuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRl c3RzL2FjY2Vzc2liaWxpdHkvdGV4dGVsZW1lbnQtdGl0bGUuaHRtbAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSwyMyBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlmICh3aW5kb3cubGF5b3V0VGVz dENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK Kzwvc2NyaXB0PgorPGJvZHkgaWQ9ImJvZHkiPgorVGhpcyBpcyBhIHRleHQgbm9kZQorPGRpdiBp ZD0icmVzdWx0Ij48L2Rpdj4KKzxzY3JpcHQ+CisgICAgaWYgKHdpbmRvdy5hY2Nlc3NpYmlsaXR5 Q29udHJvbGxlcikgeworICAgICAgICB2YXIgcmVzdWx0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInJlc3VsdCIpOworCisgICAgICAgIHZhciBib2R5ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoImJvZHkiKTsKKyAgICAgICAgYm9keS5mb2N1cygpOworICAgICAgICB2YXIgdGV4dCA9IGFj Y2Vzc2liaWxpdHlDb250cm9sbGVyLmZvY3VzZWRFbGVtZW50LmNoaWxkQXRJbmRleCgwKTsKKyAg ICAgICAgdGV4dCA9IHRleHQuY2hpbGRBdEluZGV4KDApOworICAgICAgICByZXN1bHQuaW5uZXJU ZXh0ICs9ICIgdGV4dCBlbGVtZW50IC0gVGVzdCBmb3IgbmFtZSBhdHRyaWJ1dGUgXG4iOworICAg ICAgICByZXN1bHQuaW5uZXJUZXh0ICs9ICIgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0gXG4iOworICAgICAgICByZXN1bHQuaW5uZXJUZXh0ICs9ICIgbmFtZSBhdHRyaWJ1 dGUgOiAiICsgdGV4dC50aXRsZSArICIgIFxuIjsKKyAgICB9Cis8L3NjcmlwdD4KKzwvYm9keT4K KzwvaHRtbD4K 23007 2008-08-26 15:27:27 -0700 2008-08-26 21:11:42 -0700 Patch to ignore anonymous block level elements IgnoreAnonymousBlocks-patch.txt text/plain 1330 sankaraditya+bugzilla SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNTkzNikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTAgQEAKKzIwMDgtMDgtMjYgIFNhbmthciBUYW5ndXR1cmkgIDxzYW5rYXJhZGl0 eWErYnVnemlsbGFAZ21haWwuY29tPgorICAgICAgICBJZ25vcmUgQW5vbnltb3VzIGJsb2Nrcy4g RG9uJ3QgZXhwb3NlIHRoZW0gaW4gTVNBQSB0cmVlLiBQYXJ0IG9mCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDAxMworCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6 OmFjY2Vzc2liaWxpdHlJc0lnbm9yZWQpOlJldHVybgorICAgICAgICB0cnVlIGZvciBhbm9ueW1v dXMgYmxvY2sgZWxlbWVudHMuCisKIDIwMDgtMDgtMjYgIFNhbSBXZWluaWcgIDxzYW1Ad2Via2l0 Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBCZXRoIERha2luLgpJbmRleDogV2ViQ29yZS9w YWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv cGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAkocmV2aXNpb24gMzU5MzYpCisrKyBX ZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTExMDcsNyArMTEwNywxMCBAQCBib29sIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Q6OmFj Y2Vzc2liCiAgICAgTm9kZSogbm9kZSA9IG1fcmVuZGVyZXItPmVsZW1lbnQoKTsKICAgICBpZiAo bm9kZSAmJiBub2RlLT5oYXNUYWdOYW1lKGxhYmVsVGFnKSkKICAgICAgICAgcmV0dXJuIGZhbHNl OwotICAgIAorCisgICAgaWYgKG1fcmVuZGVyZXItPmlzQW5vbnltb3VzQmxvY2soKSkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisKICAgICBpZiAobV9yZW5kZXJlci0+aXNCbG9ja0Zsb3coKSAmJiBt X3JlbmRlcmVyLT5jaGlsZHJlbklubGluZSgpKQogICAgICAgICByZXR1cm4gIXN0YXRpY19jYXN0 PFJlbmRlckJsb2NrKj4obV9yZW5kZXJlciktPmZpcnN0TGluZUJveCgpICYmICFtb3VzZUJ1dHRv bkxpc3RlbmVyKCk7CiAgICAgCg==