62459 2011-06-10 07:53:41 -0700 Local files cannot load icons. 2011-08-05 13:25:37 -0700 1 1 1 Unclassified WebKit WebKit API 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 1 rafael.lobo rafael.lobo abarth ademar cmarcelo darin dglazkov kling laszlo.gombos luiz sam tonikitoo webkit.review.bot oldest_to_newest 418707 0 96745 rafael.lobo 2011-06-10 07:53:41 -0700 Created attachment 96745 You cannot see this page's icon if you load it locally. WebKit currently defines that only pages whose protocol is in HTTP family (HTTP or HTTPS) can have icons. So if you're designing a page like the one I've attached and want to preview it offline, you won't see any icon displayed. If you upload it to somewhere else, like dropbox, you'll be able to see it correctly. This behavior looks unintuitive for me, so I would like to discuss why local files can't load icons too, as it can load anything else. Before looking into the code, I've searched examples with working icons because my first thought was that I could be using the icon keyword in the wrong way. I was puzzled because I couldn't reproduce it with my local file, but every page I've visited had an icon displayed. I didn't see anything explaining this on HTML5 specs. The closest thing I've found there was this: "In the absence of a link with the icon keyword, for Documents obtained over HTTP or HTTPS, user agents may instead attempt to fetch and use an icon with the absolute URL obtained by resolving the URL "/favicon.ico" against the document's address, as if the page had declared that icon using the icon keyword." Please share your thoughts about it. :) 418712 1 ademar 2011-06-10 08:10:10 -0700 FYI, I know that at least firefox (3.6) does load favicons from local addresses. Would be nice to see what other popular browsers do (IE, Opera, Firefox4). 418768 2 abarth 2011-06-10 10:30:04 -0700 Seems reasonable. 419747 3 rafael.lobo 2011-06-13 11:56:34 -0700 Firefox4: icon is loaded and displayed correctly. Opera 11.10: idem. IE 8.0.7600.16385: doesn't work. It may crash or display this warning: "To help protect your security, Internet Explorer has restricted this webpage from running scripts or ActiveX controls that could access your computer." Do we really have any protocol that we should not allow loading icons? I may be wrong but I don't see any problem to allow any page to load its own icon. Perhaps "about:blank" (as it should work just like an empty url)? 419755 4 abarth 2011-06-13 12:10:04 -0700 Yeah, only the "/favicon.ico" part should be HTTP/HTTPS specific. 420111 5 97048 rafael.lobo 2011-06-13 17:52:33 -0700 Created attachment 97048 Changed pageCanHaveIcon to allow icons to pages whose url is not empty and not "about:blank" I had to eliminate the code that checks whether it was part of HTTP family as it wasn't used anywhere else. I didn't add any test to webkit for now because I currently don't know very well how to do it. I was checking the changes on IconDatabase.cpp and I couldn't find any patch there that changed or added new tests. It seems it has been "ok" to not add new tests. When I was examining the current layout tests, I've found many of them checking if icons could be loaded as images, but it wouldn't help in this patch. The most promising layout test I've found was "/http/tests/misc/favicon-loads-with-images-disabled.html". I'm currently having some trouble trying to make http layout tests run here. As far as I've read on http://www.chromium.org/developers/testing/webkit-layout-tests, files are accessed via http on those tests, so adding a new test there probably won't help to catch this bug. As I will be quite busy with college the next few days, I won't be able to make any progress for a while. So I'm uploading my current patch to get any feedback about it. I would appreciate some help to get into layout tests and create a good one for this, if a new test is needed. :) 420129 6 97048 abarth 2011-06-13 18:09:46 -0700 Comment on attachment 97048 Changed pageCanHaveIcon to allow icons to pages whose url is not empty and not "about:blank" View in context: https://bugs.webkit.org/attachment.cgi?id=97048&action=review We definitely need a test for this change. Thanks for looking into writing a test. When you have some more time, find me on IRC again and I'll give you some more concrete help in finding an example test. In the meantime, you can look at how the tests in LayoutTests/fast/preloader detect otherwise invisible loads. Another option is to try calling layoutTestController.dumpResourceLoadCallbacks() to see if the icon load shows up there. > Source/WebCore/loader/icon/IconDatabase.cpp:105 > static inline bool pageCanHaveIcon(const String& pageURL) > { > - return protocolIsInHTTPFamily(pageURL); > + return !pageURL.isEmpty() && pageURL != blankURL(); > } Comparison against blankURL is almost always wrong. I'd check that the URL is non-empty (and I'd get rid of this function and just make that check wherever this function is called. 420500 7 darin 2011-06-14 09:43:18 -0700 (In reply to comment #6) > > Source/WebCore/loader/icon/IconDatabase.cpp:105 > > static inline bool pageCanHaveIcon(const String& pageURL) > > { > > - return protocolIsInHTTPFamily(pageURL); > > + return !pageURL.isEmpty() && pageURL != blankURL(); > > } > > Comparison against blankURL is almost always wrong. I'd check that the URL is non-empty (and I'd get rid of this function and just make that check wherever this function is called. Checking against blankURL specifically is a bad idea no matter where we put the code. For one thing the code here is a case sensitive check, and would not work for "ABOUT:BLANK". If we want to limit this and allow protocols such as "file" then I could imagine checking for the "about" scheme with the protocolIs function. This should check the protocol, not the entire URL. Getting rid of this function and doing the check wherever this function is called is a bad idea. The point of this function is to make clear the purpose of the check. Inside the function is the appropriate place to add comments and explain the logic. Inlining the check at call sites would be a significant step backwards in clarity. 420501 8 abarth 2011-06-14 09:45:35 -0700 > Getting rid of this function and doing the check wherever this function is called is a bad idea. The point of this function is to make clear the purpose of the check. Inside the function is the appropriate place to add comments and explain the logic. Inlining the check at call sites would be a significant step backwards in clarity. Fair enough. :) 422614 9 rafael.lobo 2011-06-17 07:45:44 -0700 I was also afraid of that blankURL() I've added, thanks for the feedback. I've decided to follow Darin suggestion and check for the protocol instead. I was also concerned about removing those parts of code, but it felt right for me to remove something that is not being used anymore. If there's a problem let me know. About the tests, I've finally got something running, and then I've realized "layoutTestController.dumpResourceLoadCallbacks()" doesn't detect icon load. It might be related to the fact that icons are loaded after the load of main resources. On those tests, they use "layoutTestController.dumpResourceResponseMIMETypes();" to display MIME types of loaded resources, and it also fails for icons. :( I'll be poking you again soon. Thanks for the all the help. :) 422662 10 rafael.lobo 2011-06-17 09:34:07 -0700 I was running a layout test with the following settings: layoutTestController.dumpAsText(); layoutTestController.dumpResourceResponseMIMETypes(); layoutTestController.dumpResourceLoadCallbacks(); layoutTestController.waitUntilDone(); setTimeout("layoutTestController.notifyDone()",10000); Even with this waiting time of 10 seconds, I couldn't track the icon being loaded. 424218 11 rafael.lobo 2011-06-20 20:22:17 -0700 I've realized that icons are being loaded in any case. The only problem is to decide whether they'll be stored or not into the IconDatabase. So when someone wants to make sure the icon loaded was properly stored there and it's available for use, then he should wait for the FrameLoaderClient::dispatchDidReceiveIcon. This might be a waste in the process, as it invests processing time to download a resource that won't be stored and won't be used. So when I was doing my layout test using dumpResourceLoadCallbacks, I could see the icon being loaded in any case. So I have two proposals to solve this, one of them is to add the check pageCanHaveIcon right at FrameLoader::startIconLoader and it would avoid to proceed in case we can't have any icon for that page. That would probably make the resource to not be downloaded, thus failing at my layout test. The second option is to modify FrameLoaderClient::dispatchDidReceiveIcon to print anything meaningful about this event whenever we've activated dumpFrameLoadCallbacks. This last option would probably require a port-specific change to every FrameLoaderClient implementation, and I was trying to avoid to create port-specific layout tests. What you guys think? 424481 12 darin 2011-06-21 08:58:33 -0700 I think it makes sense for IconController::startLoader or IconLoader::startLoading or both to decide not to load an icon based on the same kind of pageCanHaveIcon logic that's currently in IconDatabase.cpp. To do that we'd have to make that function accessible somewhere they could share it. 424483 13 darin 2011-06-21 08:59:36 -0700 But I don’t think it’s really all that valuable. This rule affects very few loads, so there’s no reason to spread it out in even more code. It’s not great in theory to do a load and then throw away the result, but the actual case is rare. 424858 14 98076 rafael.lobo 2011-06-21 16:32:34 -0700 Created attachment 98076 Modified constraint to what has been suggested, moved it to IconDatabase class, and added that check to IconController I've moved it to IconDatabase class because it is mainly used there, so the code wouldn't need to change. This move make it visible for IconController, so I added the pageCanHaveIcon there, and in case it can't, I just don't download any resource. With this change, if we ever change the constraint again and make local files to not have their favicons, this new layout test won't get the resource callback, thus failing. I'm looking forward for feedback on this. Thanks! 424879 15 98076 webkit.review.bot 2011-06-21 16:55:02 -0700 Comment on attachment 98076 Modified constraint to what has been suggested, moved it to IconDatabase class, and added that check to IconController Attachment 98076 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/8924091 424902 16 98076 tonikitoo 2011-06-21 17:31:04 -0700 Comment on attachment 98076 Modified constraint to what has been suggested, moved it to IconDatabase class, and added that check to IconController View in context: https://bugs.webkit.org/attachment.cgi?id=98076&action=review > LayoutTests/fast/preloader/favicon.html:12 > + setTimeout("layoutTestController.notifyDone()",2000); is not it too high value? and flaky-prone? > Source/WebCore/loader/icon/IconDatabase.h:141 > + static inline bool pageCanHaveIcon(const String& pageURL) not sure if 'inline' is needed here. > Source/WebCore/platform/KURL.cpp:1973 > -bool protocolIsInHTTPFamily(const String& url) > -{ > - unsigned length = url.length(); > - const UChar* characters = url.characters(); > - return length > 4 > - && isLetterMatchIgnoringCase(characters[0], 'h') > - && isLetterMatchIgnoringCase(characters[1], 't') > - && isLetterMatchIgnoringCase(characters[2], 't') > - && isLetterMatchIgnoringCase(characters[3], 'p') > - && (characters[4] == ':' > - || (isLetterMatchIgnoringCase(characters[4], 's') && length > 5 && characters[5] == ':')); > -} > - > } Unrelated change, and should go to a separeted patch. 425232 17 rafael.lobo 2011-06-22 07:54:50 -0700 It may be too high indeed, it was more relevant when I was testing some LayoutTestController features. In "http/tests/misc/favicon-loads-with-images-disabled.html", I see the use of "queueReload" after everything was setup, maybe this one would be better; as I don't know exactly the minimum amount of time I should wait for the icon (and if I don't it won't show up), I'll follow what I've seen in other tests. So instead of changing KURL right here, should I create a bug report as soon as this patch lands and remove that unused function? 425346 18 rafael.lobo 2011-06-22 10:38:48 -0700 > > Source/WebCore/platform/KURL.cpp:1973 > > -bool protocolIsInHTTPFamily(const String& url) > > -{ > > - unsigned length = url.length(); > > - const UChar* characters = url.characters(); > > - return length > 4 > > - && isLetterMatchIgnoringCase(characters[0], 'h') > > - && isLetterMatchIgnoringCase(characters[1], 't') > > - && isLetterMatchIgnoringCase(characters[2], 't') > > - && isLetterMatchIgnoringCase(characters[3], 'p') > > - && (characters[4] == ':' > > - || (isLetterMatchIgnoringCase(characters[4], 's') && length > 5 && characters[5] == ':')); > > -} > > - > > } > > Unrelated change, and should go to a separeted patch. As I've removed this function protocolIsInHTTPFamily from pageCanHaveIcon, it became dead code, so this would make this change related to this patch, doesn't? 425410 19 98206 rafael.lobo 2011-06-22 11:28:31 -0700 Created attachment 98206 Modified layout test to use queueReload instead, and did not change KURL in this patch. I've modified as you've suggested, and for now KURL is not changed, but it's important to remember that protocolIsInHTTPFamily became dead code (and could be easily fixed as soon as this lands). 425433 20 98206 webkit.review.bot 2011-06-22 11:48:09 -0700 Comment on attachment 98206 Modified layout test to use queueReload instead, and did not change KURL in this patch. Attachment 98206 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/8918691 425456 21 tonikitoo 2011-06-22 12:23:08 -0700 > I've modified as you've suggested, and for now KURL is not changed, but it's important to remember that protocolIsInHTTPFamily became dead code (and could be easily fixed as soon as this lands). I trust you to remove it afterwards:) 425459 22 rafael.lobo 2011-06-22 12:25:08 -0700 (In reply to comment #21) > > I've modified as you've suggested, and for now KURL is not changed, but it's important to remember that protocolIsInHTTPFamily became dead code (and could be easily fixed as soon as this lands). > > I trust you to remove it afterwards:) :) Do you know why it is failing on chromium-ews? It looks like it's using another IconDatabase.h, I don't get it. 428133 23 98206 abarth 2011-06-27 11:31:27 -0700 Comment on attachment 98206 Modified layout test to use queueReload instead, and did not change KURL in this patch. View in context: https://bugs.webkit.org/attachment.cgi?id=98206&action=review > Source/WebCore/loader/icon/IconController.cpp:118 > + String pageURL = m_frame->document()->url(); > + if (!IconDatabase::pageCanHaveIcon(pageURL)) > + return; This is not the pageURL. It's the document's URL. In any case, I'd just remove the temporary. > Source/WebCore/loader/icon/IconDatabase.h:141 > + static bool pageCanHaveIcon(const String& pageURL) Does this really need to be the page's URL, or is the document URL sufficient? I'm not sure. 428144 24 darin 2011-06-27 11:38:22 -0700 (In reply to comment #23) > > Source/WebCore/loader/icon/IconDatabase.h:141 > > + static bool pageCanHaveIcon(const String& pageURL) > > Does this really need to be the page's URL, or is the document URL sufficient? I'm not sure. What is “the page’s URL”? 428149 25 abarth 2011-06-27 11:42:03 -0700 > What is “the page’s URL”? I'm not sure. Maybe the URL of the document of the main frame of the page? 428184 26 rafael.lobo 2011-06-27 12:30:18 -0700 (In reply to comment #23) > > Source/WebCore/loader/icon/IconDatabase.h:141 > > + static bool pageCanHaveIcon(const String& pageURL) > > Does this really need to be the page's URL, or is the document URL sufficient? I'm not sure. When no favicon is specified, according to the specs, it'll look for the absolute URL obtained by resolving the URL "/favicon.ico" against the document's address (when its protocol is HTTP or HTTPS). At least at that point, the document's URL is sufficient. Now that you've pointed that out, I've seen another URL that is constantly used with the document's URL: the initial request's url. You can see it being used, for example, in IconController::commitToDatabase. The same iconURL is attached to both of them, so if we start to evaluate both urls at the same time at the pageCanHaveIcon check, what would be the preferred behavior? To not load an icon if any of them cannot have one, or to load an icon if any of them can have it? 428278 27 abarth 2011-06-27 14:11:23 -0700 > When no favicon is specified, according to the specs, it'll look for the absolute URL obtained by resolving the URL "/favicon.ico" against the document's address (when its protocol is HTTP or HTTPS). At least at that point, the document's URL is sufficient. The question is whether we're interested in the main frame's document or whether any frame is sufficient. Presumably we only care about the icon for the main frame. As Darin points out, there is not such thing as a "pageURL". Pages don't have URLs. We probably should get rid of all references to that name. (This is likely just a naming issue, not an actually observable bug.) > Now that you've pointed that out, I've seen another URL that is constantly used with the document's URL: the initial request's url. You can see it being used, for example, in IconController::commitToDatabase. The same iconURL is attached to both of them, so if we start to evaluate both urls at the same time at the pageCanHaveIcon check, what would be the preferred behavior? To not load an icon if any of them cannot have one, or to load an icon if any of them can have it? The initial request URL is really dangerous to use. That probably lets an attacker inject a favicon into someone else's web site! That's somewhat orthogonal to what you're trying to do here, but you probably won't want to do very much with that URl. 428472 28 98823 rafael.lobo 2011-06-27 17:23:17 -0700 Created attachment 98823 Removing temporary variable and changing variable's name from pageURL to documentURL I don't know if there's much to add about this, it's quite the same as the last one. I've built this on linux and it's working. If chromium-ews fails again and everything is ok, as I don't know why it is failing to build there, I think we should take the risk. 428499 29 98823 webkit.review.bot 2011-06-27 17:44:55 -0700 Comment on attachment 98823 Removing temporary variable and changing variable's name from pageURL to documentURL Attachment 98823 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/8945585 430473 30 98823 abarth 2011-06-30 09:30:46 -0700 Comment on attachment 98823 Removing temporary variable and changing variable's name from pageURL to documentURL View in context: https://bugs.webkit.org/attachment.cgi?id=98823&action=review > Source/WebCore/loader/icon/IconDatabase.h:141 > + static bool pageCanHaveIcon(const String& documentURL) Why is this called "pageCanHaveIcon" when it takes a documentURL? Maybe it should be called documentCanHaveIcon? Also, why is this function inline? It probably should be out-of-line. 430525 31 99329 abarth 2011-06-30 10:27:54 -0700 Created attachment 99329 Patch with ??? 430529 32 abarth 2011-06-30 10:32:18 -0700 To capture the discussion with Rafael: 1) The build failure was real. 2) I've uploaded a new patch that fixes the problem. 3) There's a ??? in the patch where I wasn't sure what to do. 4) I've added an ASSERT that we're always dealing with the main frame (so that the frame's document's url really is the URL of the page). I'm not 100% sure the ASSERT is correct, but the tests will tell us. I've put the ball back into Rafael's court. 432344 33 rafael.lobo 2011-07-05 11:12:55 -0700 (In reply to comment #32) > To capture the discussion with Rafael: > > 1) The build failure was real. Thanks Adam for showing me why it was not building. I'll pay more attention next time. :) > 3) There's a ??? in the patch where I wasn't sure what to do. I believe that if we don't have IconDatabase available to store icons, it seems pointless to allow pages to have icons as we won't be able to keep them anyway. But, by returning false for all of them, I wouldn't be able to keep the same layout test for every platform as I wanted, because now downloading or not that resource will depend on IconDatabase being enabled or not. If I keep the same behavior for pageCanHaveIcon, we would waste time downloading the icon and wouldn't be able to use it, but at least we should see the same result everywhere. I feel more inclined to try this option, because I don't understand much why IconDatabase would be kept disabled (is there any other way to store icons that I'm missing?). 432374 34 rafael.lobo 2011-07-05 13:00:34 -0700 (In reply to comment #27) > As Darin points out, there is not such thing as a "pageURL". Pages don't have URLs. We probably should get rid of all references to that name. (This is likely just a naming issue, not an actually observable bug.) Can't we assume that pageURL is a synonym for documentURL? I'm suggesting this because many functions on IconDatabase, IconDatabaseBase and IconDatabaseClient use this "PageURL", and to change all of them would require changing stuff on many different ports at once. If we don't change the function names, but only the variable names, it will look awkward, like pageCanHaveIcon(String documentURL). Is this naming issue that much valuable? Maybe a comment in the code could make "pageURL" more clear, and we could keep them for now. 438848 35 101240 rafael.lobo 2011-07-18 17:15:08 -0700 Created attachment 101240 Layout test should be skipped for platforms with IconDatabase disabled, and using the test with timeout. The problem with chromium-ews has shown to me that it would be impossible to make a single layout test for all platforms. So I gave up, and for now I've marked this test as skipped on chromium (and hopefully did this correctly). I've decided to use the timeout version of the test because it seems more stable right now. I've done many tests with the previous setting and I've noticed one test case that failed among many (flaky test). I've done many tests with this new one too but didn't see it failing anytime yet (so it doesn't mean it's 100% safe neither). The problem with favicons instability in tests is probably related to the fact that the icon may be requested at a time that IconDatabase's thread can't read from I/O to find out for sure if it already has the icon data or not, so it leaves the favicon load decision for "later". I think 400 ms for timeout is reasonably good. Another reason for this change is that the previous test setting is not working anymore for some reason. Hopefully we'll find a good solution for this. It seems more reasonable to leave the test running for all platforms that I don't know yet the output so I can see them failing and then fixing it later. 438850 36 webkit.review.bot 2011-07-18 17:17:30 -0700 Attachment 101240 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/fast..." exit_code: 1 Source/WebCore/loader/icon/IconDatabase.cpp:576: Should have a space between // and comment [whitespace/comments] [4] Source/WebCore/loader/icon/IconDatabase.cpp:578: Should have a space between // and comment [whitespace/comments] [4] ERROR: FAILURES FOR <lucid, x86_64, release, cpu> ERROR: Line:3833 More specific entry on line 2360 overrides line 3833 fast/blockflow/broken-ideograph-small-caps.html LayoutTests/platform/chromium/test_expectations.txt:3833: More specific entry on line 2360 overrides line 3833 fast/blockflow/broken-ideograph-small-caps.html [test/expectations] [5] Total errors found: 3 in 9 files If any of these errors are false positives, please file a bug against check-webkit-style. 439370 37 101240 abarth 2011-07-19 12:35:46 -0700 Comment on attachment 101240 Layout test should be skipped for platforms with IconDatabase disabled, and using the test with timeout. View in context: https://bugs.webkit.org/attachment.cgi?id=101240&action=review This looks fine except for the test. I don't have any great suggestions for how to improve the test. :( Another option is to make this a manual-test, but that's somewhat like defeat. > LayoutTests/fast/preloader/favicon.html:4 > +<link type="image/png" href="resources/basic.png" sizes="64x64" rel="icon" /> This test probably shouldn't be in the preloader directory. It's not about the preloader. It's about icon loading, right? > LayoutTests/fast/preloader/favicon.html:12 > + setTimeout("layoutTestController.notifyDone()",400); setTimeout in situations like this is frowns. It leads to slow, flaky tests. I'm not sure how else to write this test, though, given that there's no event that's generated when the icon load completes. > LayoutTests/platform/chromium/test_expectations.txt:2989 > +BUGWK62459 : fast/preloader/favicon.html = FAIL PASS So, it's already being marked as flaky? That's not super promising. >> Source/WebCore/loader/icon/IconDatabase.cpp:576 >> + //printf("setIconURLForPageURL %s - %s\n", iconURLOriginal.utf8().data(), pageURLOriginal.utf8().data()); > > Should have a space between // and comment [whitespace/comments] [4] This code should probably be removed before landing. :) 440075 38 rafael.lobo 2011-07-20 15:53:11 -0700 (In reply to comment #37) > (From update of attachment 101240 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=101240&action=review > > This looks fine except for the test. I don't have any great suggestions for how to improve the test. :( > > Another option is to make this a manual-test, but that's somewhat like defeat. I didn't understand how bad it was until I actually see what a manual-test is... ugh. I don't want that. :/ I'm quite surprised how in some platforms tests like favicon-loads-with-icon-loading-override are not marked as flaky. I've tried something exactly like that, but got another flaky test as well.The whole problem is the decision IconLoadUnknown which brings instability. For testing purposes, I guess we could get rid of that decision - so I'm planning to add a new function to LayoutTestController to ignore it and then we would safely detect at least the load request of favicon in layout tests. What do you think of it? Another option would be to add event listener on those HTMLLinkElements so we could detect "load", as I've seen in other kinds of layout tests. But those target web developers, and I don't see how this event would benefit them, so it already sounds like a bad idea. Any thoughts on that approach? I'm running out of ideas by now. :( I'll soon submit a patch to show how I'm planning to use it. > > LayoutTests/fast/preloader/favicon.html:4 > > +<link type="image/png" href="resources/basic.png" sizes="64x64" rel="icon" /> > > This test probably shouldn't be in the preloader directory. It's not about the preloader. It's about icon loading, right? Sure. Favicon tests are usually inside a misc directory, maybe I should create a misc folder here as well. Do you have any suggestion on that? > > > LayoutTests/fast/preloader/favicon.html:12 > > + setTimeout("layoutTestController.notifyDone()",400); > > setTimeout in situations like this is frowns. It leads to slow, flaky tests. I'm not sure how else to write this test, though, given that there's no event that's generated when the icon load completes. > > > LayoutTests/platform/chromium/test_expectations.txt:2989 > > +BUGWK62459 : fast/preloader/favicon.html = FAIL PASS > > So, it's already being marked as flaky? That's not super promising. I should have marked it as fail instead, as chromium doesn't have IconDatabase enabled. I did that because another icon test, just beside that one, had the same description. > > >> Source/WebCore/loader/icon/IconDatabase.cpp:576 > >> + //printf("setIconURLForPageURL %s - %s\n", iconURLOriginal.utf8().data(), pageURLOriginal.utf8().data()); > > > > Should have a space between // and comment [whitespace/comments] [4] > > This code should probably be removed before landing. :) Actually I think that's quite relevant! :D 440127 39 rafael.lobo 2011-07-20 17:19:02 -0700 Just did more tests, and then figured out it is more complicated than I've thought. Every test I did, I've got to decide what to do with IconLoad twice, one in the very beginning, and one in the very end. There's two different behaviors happening here: the most usual is to get initially an IconLoadUnknown, and then an IconLoadYes (and we get track of it starting to be loaded). The other is to get IconLoadNo initially (because we don't have the icon URL yet), and then IconLoadUnknown. Even if my approach does work, I'll get myself into another problem: the order of the dump resource callbacks will not be fixed, so we still get a flaky test when we rely on a text diff. I could stop dumping resource callbacks, and also add to LayoutTestController something like dumpIconLoadCallbacks so we would only print them... seriously, is there any better way to do it? :/ Is this at least a good enough idea worth trying? :P If not, then I believe it's time for a manual-test (or no test). :( 440471 40 abarth 2011-07-21 10:19:32 -0700 Sigh. Thanks for looking into the testing side of this bug. As much as it makes me sad, I think we should go with a manual test for this bug. :( 440532 41 101620 rafael.lobo 2011-07-21 11:46:23 -0700 Created attachment 101620 Just added the manual-test and removed the unrelated comments on the code. 440752 42 101620 webkit.review.bot 2011-07-21 17:40:43 -0700 Comment on attachment 101620 Just added the manual-test and removed the unrelated comments on the code. Clearing flags on attachment: 101620 Committed r91540: <http://trac.webkit.org/changeset/91540> 440753 43 webkit.review.bot 2011-07-21 17:40:50 -0700 All reviewed patches have been landed. Closing bug. 447387 44 ap 2011-08-05 13:25:37 -0700 This appears to have broken favicon loading completely, see bug 65692. 96745 2011-06-10 07:53:41 -0700 2011-07-18 17:15:08 -0700 You cannot see this page's icon if you load it locally. iconload.zip application/zip 4628 rafael.lobo UEsDBAoAAAAAABdYyj4AAAAAAAAAAAAAAAAJABwAaWNvbmxvYWQvVVQJAAOOI/JNfSjyTXV4CwAB BOkDAAAEZAAAAFBLAwQUAAAACAAXWMo+5n/avKkAAAD3AAAAEwAcAGljb25sb2FkL2luZGV4Lmh0 bWxVVAkAA44j8k2OI/JNdXgLAAEE6QMAAARkAAAAPY8xDoMwDEV3TmHlAGRBTMDeI3QMwZCoIY4S IzU9fa1QdfLX/9bz9+T4DEs3OTSbDPYccHlYiuALRGIIZDYfj37Sd9ZNwccXcE04K3+aA3WKhwKX cZ/Vaoq3fTOK/2CZ1Ti8x0FBxiDrwlWghVG4Npb+i1+Blba6dE+6wJoIFEOFggjspI5vtXaoklLC eLtJKojKdB0OHHMCym1KlInJUuiFf4PlTvv3C1BLAwQKAAAAAABZor8+i5ju6HkPAAB5DwAAEgAc AGljb25sb2FkL2Jhc2ljLnBuZ1VUCQADWXflTcAi8k11eAsAAQTpAwAABGQAAACJUE5HDQoaCgAA AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAGYktHRAD+AP4A/usY1IIAAAAJcEhZcwAAAEgAAABI AEbJaz4AAAAJdnBBZwAAADAAAAAwAM7ujFcAAA6iSURBVGje1ZprkBxXdcd/997unvfO7Hu18sqS LQkJPYwJsoMRONiAzSM4xZsUJolTQEHiil0Gk5BQoSAhrlQ+5GECgcJJsEPxwQWGGEggxqCyeTiO LFsCydJKsrxa7Wrfu7Mz0697bz50z+zsQ9YK/IVTdap7enp6/v97/ufc26dbWGv5dTbnxbqQEEI0 d1ds2822b+2LMHriV7lGG2iZApZt++3eBN10k3pz3/6yZH4pAinwdsBO07OdG4qiXBl0srleE8b1 aHFmMpw4O9sG2gAaiFNv7hvAXCqRSyaQglepu6UdL9vrlnrfJb3sW60VHcrxhMwUjHCKSseBNWEN HfvC6khbo4/YhfFvNEaOH4hqtQUgXOFNQusmsm4CbaPuUKnke7bvu1O62Q91dG/wejZdVe7o2SIR DkGkCeKYIIoJwphGmOw3ggjrz+DURhvKHwtNFJwQc+P3RPPjJ+qTM7UgmK8BjZRIlJIwLwqBFLwE 3K5rbnifmyl9ZttLX1neumt/DukSxTF+pAlCnQCPIvwoxg9j/DCiEUb4QfIZwGCQwTS5hSMLMg5+ lq3V7w3qM2dnx47N+nNzi21E4ouRuGgVakomt+2q/nL/pu8UnNzOcjnrduWKlAoFgtiASLPTWoyV aOvgGIujDI5SONLgKINSgkgbrAXt9bDY/Vsdjj96o1XH9jme/Keh7CsfGXv+FxOL02fmgRrgCyHi F5KUsx7w5T3XXpUt9j3clXP7O/rPCu3nyeWLZFwHhEZgE1AatGPRxqCVRCtFrAyuI4m0RClJpJMB tdYijY8XVmWt89pKfu7QHTW1cKWw8b3p36s06o1UUvqSCDTB9/zG627KlsoPDFSylWLPaSwWzG52 Xn0dYaxbI6+tJdYS1ySgmyOulETKBLySEolAp9NBcfr/6CoepDEziK8uK9Uz3beweccQM6MfSwmI Njx2LTnJFwiALOy+dle22PHApt5ipWvwLI4rkcKhf3ArGVfhOQq36UrhqgRoIhuZuBA4UqJE6qrt LwV4hYjywBm6SwfILBwv4FT2Ffe+5k+AAtABFIEs4Agh5LoICCFkYdeu3o5y73c39RYr5Q1ncByB 4yisdujt34jrOC3gjpQ4SqLSfSUFsjnyUiKlQKW+NPdB7HRgtQvWB7VI99AJuvPHsllp3pHf/vKb UxKldJsBlGi/wFoEmtKpdG/75kAlN9A5+DzKkS33cnBm+BkcJZMRdxLgqgm8BTYBLqRAigS4EMn3 TYvcLqJGiLUxUkmEEOQ6Z8nk6q6qbLgzu+HyrSn4IpAH3JWY14qArFz92jcWPe+q/k1zQjlqaXQd RSYrCOzjfOs//pajhx7DEcuBSylbgKWQbeBZcsBiqYs8C9PlVn4k+WLJl6ewTlfZ3fiSP0tBF1Jf JSW5xug7xXL5Hzb2FzKZnE0uriSOk7hSikwxwu18mpPD9/ODb36JOAoToAikAIRIFkTpfgI8JQJY C0EYEqscU/nrWWySSGXn5EJK8WlwyptyW176ilQ+eSC3MgorIyB7XvmG3+vr6B3MlseS8KtEz4mE FI4jEskogVes0TAHOHbwR4i2RWi7SMWKY3Ec44cBzbIee51gVZIzbVWro/c0XjRbcnuG7kpx5lJf lgstAs3ZNpftuKOYizw3E6WyaFaWxKVSCCkQMtGsmzVMjZ9Iyiuk4lhpFmstfhgSxvGyb/L1k3R0 1ZYioNLccWIKxbOA153duPnKdOSbBJwm9vYIiPyOl/cQBJvy5fGWbkn1LR2FclVSBq2kPu/iVzP4 ixmqczMEfh2bTmjY9rWzJYxj6kGANnoZRRkt0slRsiVaIy+bFUxJsqU5XL1YcHo2vT7F6qUEXEAK IUT7RCZy+fLbKgWZd3IhCNnSLEKgRFJRgthQPXcV+657I6E2BGFMpqMT3CxhGGOsxVqDsYYoiqn5 AWEUpcebnvxh1+xP2bhzAillqjWZTIraJNVKGjLePFHceyPwLynwZRFYRsArVN5Xqqx1J5X8qbUW x7UYW6XSNwAqky7aIvwoQmuDNgbReIxMeB6hY/KOJspqItcQ5wyx1sTagLV0dJylXHESSQLGgtES oxXauOjYEHdWCcNMd9fLtt/uSF1Xjgy9rKzPTYZf+/b9p5902vUvJBtzmQ6snUtk0BwxA1porAFj LKUNJ3n04X9n/1v+MAWkCSONH4QsNnz6M4/zm6+d5OLmAuV1nGc86HxX81OjZjnw8JwPPLMsApmM l0M4WAvGWoQBaSzGGLASK9LwKkPNH6PuRzTCkFoQpMvlKFmsKcjk5DqA/XKmtcFvxCUgt0Sgp8eL tBEnnx8lt3CMXD5LJpvBc50keaXEWE0cR4RhxMxMwOT0NMLLEIaaME480hpziXepWluUEpf2m9h6 gGoRKHdd0eNlCgbjE+sYP/AxNiaKFU6kktImEglpbbBqmumJcTr6NhLEMWEcE8WaKNZc7CYpjiyP fXuSn//vAqePLnL+rE8urxjalmfrniL739TL0Nb8eni0VaHg/FzgXy47i5exGDgox6C1aS2+kjWM aFUJa0IaDR8vSsAnt5JJLrwQgeeO1fjHPz3O+RF/2fFaNebYwQWOHVzgO/ePcdN7BnjvHZdfODI2 6Xi0hDp/5kwjjkK749XvQunX0pjZTXWql9C3xJFOPE5cxxqtDWFagYL0vjdMyVyIwENfHuWTtx5e BX6lGWP57lfHuPsdh5gaDy4w9snGWf5DE4WRZu8bPoiSgvrcNIcf/VdK/U+hgwJBfQdCnCdbHiEM OpH5En6USCeMdBqJeM0cOPrkAg9+/vnWHCCEYOueIlfsKrJlZ4HafMzpozWe/sks1dlkth5/3ufv P3qcv3pgz9oxAOssOyDEubn5mQ35YiWZ2gtldt34QQ7/z+fxCsP0bH4VlYEtPH/4AJXBTsgU8IOI SKcJnHYkVkYgaBju/YvjLfClTpe3vH+Q179zYFm10tqyOBfzhb8c5pmfzAFw+ugi//lvo/z2729c k0R7rbNxsPjg1LlnYz9M2iD1IEIrjyv3/wF+dQvjJ5/EeAUGr76Zziv30QiitPOQtFD8KInASgJf /+IIc5MRAEoJ3nv7Jt7y/sFl4M+P+Nz51oM8+9QCH793J9v3lpZ+/6Wz1BaWr6GESCIgodWjNPH8 xEPT534x74cR9SBMSYRoJ8vl+z9A5/brk2Npq6TpfpsH6XKi3Y48Md/a33tdhf1v7l32/fkRn0/d doTp8ZB7P3GCn35/ij/67HZcLyEY+oanfzy3IgeEWRWB6vEjI1GjulCr12gEEY0gpB5ENIKI0Eqc cn8CPiXXBJ8QSftA0XIC1sDo6Ubr87Wv60Y5YhX4hZkkQtbCiacX6dngsXFLrnXe8OHFC0egLSm0 ifyvTI8c8hthnIJPSNRbZBLwC5PPUZ18joYftmZhP0oItUvo3JkGUWBa8tm6p3RB8ELADW/r4923 bwJg845C69yR4fpyAmmH21lJYO7YkX8WTuZDsrJ9QDje0oo0PcFYSzD+JLL6E5SqUYu3YTbcTGwh 0iadyJYu6nlLY2QteBmxJvjm91pbvMw6liErI9DMAxbHa7o+f09t9Ila0JbM9SBkceoUtRNfJx// kP4NY/T2V+nvPowYfRjfrxPFq3tPvRszZPMKSOr7s4eqzM9Eq0a+aY9+Y4L7/uYUAKeO1lrHV8/M 6QS74qgBooVnHrvfLIycr1fHE60vnCc69TUKtQcZGjhIX3+VQiFDoZChs1OweegYHTP/jYgbrGWD m5e0/Ph3pyhVXDalgKQU7H9zL119XuucRx48z+f+/ASjp5Zkc+WuwrJrpjmwnEAaBQ0E0dTJ98ix x2aC+jxq4nv0dR2ms2uWbFaRybrk8hkKxSz5QoZSSXLF5mHK899H2GgVgV3XLC2Zn358licemebu e3ey+5oyN7ytj9s+cQWf/PLuZSR+/F9T6DjRYqHksLWtrLbbWmIzQFg/dfy4WRj/cHbqx3OWHHFc QArRuvF2XUUu7+Gkt5muC4P9w+Tnf7bqgu/88BB9g5l0kOCLnxrmhw9N8PHP7eR9d23Gy0j6BjN8 8su7qfR4q35/03sH6L8suyaBVb1Ra60VQmggWDx68JHi3uLfke/52Lh/fXm+9hwbekdRjiYMRbo2 ssRxsvBTKsKNJ0namkumHMFH/nobn/nAz9GxJfAN9332FI88eJ5d13Sw/aoO5qZDnn2qSmMxXgVy djLkQrZmc9daa9K2dmPxmQNfKu14+YRjN9xT7b6hy585TX5qmMsGx3Bcw/CpzRg8yvlzZLxJYlEk aSgvt217S7z7jzfx4BdGCP2krJ45XuPM8RrfeWCMF7JHvzFBJqu49aOb1yWhpmmShwz16rGD39Ln hn83O/XYWCQ7otnyWxk+9wpOnhigmtvHfNfNjPF6RudfRb183QUv+OZbB/nUfbuX1fe1LJtXXH9L XysnHFdSrLjrj8BKKQHURp495M1M3JTZ2rhTLB7/Hb+yp9woXy2tcBFAlB0iyg5xMbv8JQU+/ZU9 /PChCY4fqjL6XIPZiZBsXtIzkGFoa56rX93JS/eVmRwLuOcjv2D/m3q55bbBSyPQRqIpShvWZnX4 9I8+7XT23pfb0rhbuPlXRfmNns4PFY3XCTbp+IiL3B0qJbjx7f3c+PZ+AOrVGKlEa75oWt9ghs9+ dS9eVi5rCq+bwAoSzWe6Op6djKqzP7jLzecr3uAVr3HKA7cI5e6yKot18kLqegcrM/kFLF+6MIyV pFbCW9eT+jY5NUlEQBDV6340fORbcOR7gOeUu7qdYnkg/7rSp6Fw+XoJ/Cq27lcNmpOcEKI52cUk +dFs92Xi+ZlqPD8z6ldfMnzg27phjHXSe9fEkj0L6UwqsAKRbjHptv3cVTAArEE16noEMC/Gk3pF 25P61LNAhaSn36x0rdcKWP6Evv1JffOcC45j29YHZl+MdyVWvnawkpRk7fckVr0vcQl/3crHX4nA GmRoI3Sxt1VelDdW/h9JkKa/ivGK0QAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMC0wNVQxNjoy NTowMisxMDowMBo0fvkAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTAtMDVUMTY6MjU6MDIrMTA6 MDBFhQjNAAAAAElFTkSuQmCCUEsBAh4DCgAAAAAAF1jKPgAAAAAAAAAAAAAAAAkAGAAAAAAAAAAQ AO1BAAAAAGljb25sb2FkL1VUBQADjiPyTXV4CwABBOkDAAAEZAAAAFBLAQIeAxQAAAAIABdYyj7m f9q8qQAAAPcAAAATABgAAAAAAAEAAACkgUMAAABpY29ubG9hZC9pbmRleC5odG1sVVQFAAOOI/JN dXgLAAEE6QMAAARkAAAAUEsBAh4DCgAAAAAAWaK/PouY7uh5DwAAeQ8AABIAGAAAAAAAAAAAAKSB OQEAAGljb25sb2FkL2Jhc2ljLnBuZ1VUBQADWXflTXV4CwABBOkDAAAEZAAAAFBLBQYAAAAAAwAD AAABAAD+EAAAAAA= 97048 2011-06-13 17:52:33 -0700 2011-06-21 16:32:34 -0700 Changed pageCanHaveIcon to allow icons to pages whose url is not empty and not "about:blank" icon-loading-webkit.diff text/plain 2689 rafael.lobo ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBlZWQxMzAwLi5lZTYwMjFiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTgg QEAKKzIwMTEtMDYtMTMgIFJhZmFlbCBCcmFuZGFvICA8cmFmYWVsLmxvYm9Ab3BlbmJvc3NhLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMb2Nh bCBmaWxlcyBjYW5ub3QgbG9hZCBpY29ucy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTYyNDU5CisKKyAgICAgICAgUHJldmlvdXMgcG9saWN5IGRldGVy bWluZWQgdGhhdCBvbmx5IHVybHMgd2hvc2UgcHJvdG9jb2wgd2FzIHBhcnQgb2YgSFRUUCBmYW1p bHkgY291bGQKKyAgICAgICAgaGF2ZSBpY29ucy4gQ2hhbmdlZCB0byBhbGxvdyB0aGF0IHRvIGFu eSB1cmwgdGhhdCdzIG5vdCBlbXB0eSBhbmQgbm90ICJhYm91dDpibGFuayIuCisKKyAgICAgICAg KiBsb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6cGFnZUNh bkhhdmVJY29uKToKKyAgICAgICAgKiBwbGF0Zm9ybS9LVVJMLmNwcDoKKyAgICAgICAgKiBwbGF0 Zm9ybS9LVVJMLmg6CisKIDIwMTEtMDYtMTMgIE5vYW0gUm9zZW50aGFsICA8bm9hbS5yb3NlbnRo YWxAbm9raWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0 aWFuc2VuLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFi YXNlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAKaW5k ZXggMzlkYjA2Ny4uMDFlYjMzZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL2lj b24vSWNvbkRhdGFiYXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29u RGF0YWJhc2UuY3BwCkBAIC0xMDEsNyArMTAxLDcgQEAgc3RhdGljIEljb25EYXRhYmFzZUNsaWVu dCogZGVmYXVsdENsaWVudCgpCiAKIHN0YXRpYyBpbmxpbmUgYm9vbCBwYWdlQ2FuSGF2ZUljb24o Y29uc3QgU3RyaW5nJiBwYWdlVVJMKQogewotICAgIHJldHVybiBwcm90b2NvbElzSW5IVFRQRmFt aWx5KHBhZ2VVUkwpOworICAgIHJldHVybiAhcGFnZVVSTC5pc0VtcHR5KCkgJiYgcGFnZVVSTCAh PSBibGFua1VSTCgpOwogfQogCiAvLyAqKioqKioqKioqKioqKioqKioqKioqKioKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0tVUkwuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vS1VSTC5jcHAKaW5kZXggODYxMWVkMS4uMWYyYzI4OSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vS1VSTC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v S1VSTC5jcHAKQEAgLTE5NzAsMTcgKzE5NzAsNCBAQCBTdHJpbmcgbWltZVR5cGVGcm9tRGF0YVVS TChjb25zdCBTdHJpbmcmIHVybCkKICAgICByZXR1cm4gIiI7CiB9CiAKLWJvb2wgcHJvdG9jb2xJ c0luSFRUUEZhbWlseShjb25zdCBTdHJpbmcmIHVybCkKLXsKLSAgICB1bnNpZ25lZCBsZW5ndGgg PSB1cmwubGVuZ3RoKCk7Ci0gICAgY29uc3QgVUNoYXIqIGNoYXJhY3RlcnMgPSB1cmwuY2hhcmFj dGVycygpOwotICAgIHJldHVybiBsZW5ndGggPiA0Ci0gICAgICAgICYmIGlzTGV0dGVyTWF0Y2hJ Z25vcmluZ0Nhc2UoY2hhcmFjdGVyc1swXSwgJ2gnKQotICAgICAgICAmJiBpc0xldHRlck1hdGNo SWdub3JpbmdDYXNlKGNoYXJhY3RlcnNbMV0sICd0JykKLSAgICAgICAgJiYgaXNMZXR0ZXJNYXRj aElnbm9yaW5nQ2FzZShjaGFyYWN0ZXJzWzJdLCAndCcpCi0gICAgICAgICYmIGlzTGV0dGVyTWF0 Y2hJZ25vcmluZ0Nhc2UoY2hhcmFjdGVyc1szXSwgJ3AnKQotICAgICAgICAmJiAoY2hhcmFjdGVy c1s0XSA9PSAnOicKLSAgICAgICAgICAgIHx8IChpc0xldHRlck1hdGNoSWdub3JpbmdDYXNlKGNo YXJhY3RlcnNbNF0sICdzJykgJiYgbGVuZ3RoID4gNSAmJiBjaGFyYWN0ZXJzWzVdID09ICc6Jykp OwotfQotCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9LVVJMLmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9LVVJMLmgKaW5kZXggZjYyMTE4MC4uYWFhZDkwYyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vS1VSTC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL0tVUkwuaApAQCAtMjg0LDcgKzI4NCw2IEBAIGNvbnN0IEtVUkwmIGJsYW5r VVJMKCk7CiAvLyBUaGlzIGlzIGVzcGVjaWFsbHkgaW1wb3J0YW50IGJlY2F1c2UgdmFsaWQgamF2 YXNjcmlwdCBVUkxzIGFyZSBub3QgbmVjZXNzYXJpbHkgY29uc2lkZXJlZCB2YWxpZCBieSBLVVJM LgogCiBib29sIHByb3RvY29sSXMoY29uc3QgU3RyaW5nJiB1cmwsIGNvbnN0IGNoYXIqIHByb3Rv Y29sKTsKLWJvb2wgcHJvdG9jb2xJc0luSFRUUEZhbWlseShjb25zdCBTdHJpbmcmIHVybCk7CiBi b29sIHByb3RvY29sSXNKYXZhU2NyaXB0KGNvbnN0IFN0cmluZyYgdXJsKTsKIAogYm9vbCBpc0Rl ZmF1bHRQb3J0Rm9yUHJvdG9jb2wodW5zaWduZWQgc2hvcnQgcG9ydCwgY29uc3QgU3RyaW5nJiBw cm90b2NvbCk7Cg== 98076 2011-06-21 16:32:34 -0700 2011-06-22 11:28:31 -0700 Modified constraint to what has been suggested, moved it to IconDatabase class, and added that check to IconController icon-loading-webkit-2.diff text/plain 12023 rafael.lobo ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAyOTBlYTMwLi40NWE3YWQ3IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYt MjEgIFJhZmFlbCBCcmFuZGFvICA8cmFmYWVsLmxvYm9Ab3BlbmJvc3NhLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMb2NhbCBmaWxlcyBjYW5u b3QgbG9hZCBpY29ucy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTYyNDU5CisKKyAgICAgICAgQWRkZWQgYSBsYXlvdXQgdGVzdCB0byB2ZXJpZnkgaWYg dGhlIGZhdmljb24gaXMgYmVpbmcgbG9hZGVkIGZvciBsb2NhbCBmaWxlcywKKyAgICAgICAgYXMg dGhlIHByZXZpb3VzIHBvbGljeSBvbmx5IGFsbG93ZWQgaXQgdG8gcGFnZXMgd2hvc2UgcHJvdG9j b2wgd2FzIGh0dHAgb3IgaHR0cHMuCisKKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9mYXZpY29u LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9yZXNvdXJjZXMvYmFzaWMucG5n OiBBZGRlZC4KKwogMjAxMS0wNi0yMCAgQ2hhbmcgU2h1ICA8Y3NodUB3ZWJraXQub3JnPgogCiAg ICAgICAgIHVucmV2aWV3ZWQuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRl ci9mYXZpY29uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmlj b24tZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVmM2Iy Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29u LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDIgQEAKK2Jhc2ljLnBuZyBoYXMgTUlNRSB0eXBlIGlt YWdlL3BuZworVGhpcyB0ZXN0IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVlIHRvIHNlZSB0aGUgbG9n IG9mIHdoYXQgcmVzb3VyY2VzIGFyZSBsb2FkZWQuIEEgZmF2aWNvbiBzaG91bGQgYmUgbG9hZGVk IGZvciBsb2NhbCBmaWxlcywgc28gImJhc2ljLnBuZyIgc2hvdWxkIGJlIGRpc3BsYXllZC4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24uaHRtbCBiL0xheW91 dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24uaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi42ZGY4ZDFjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9wcmVsb2FkZXIvZmF2aWNvbi5odG1sCkBAIC0wLDAgKzEsMTcgQEAKKzxodG1sPgorPGhlYWQ+ Cis8L2hlYWQ+Cis8bGluayB0eXBlPSJpbWFnZS9wbmciIGhyZWY9InJlc291cmNlcy9iYXNpYy5w bmciIHNpemVzPSI2NHg2NCIgcmVsPSJpY29uIiAvPgorPGJvZHk+Cis8c2NyaXB0PgoraWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBSZXNvdXJjZVJlc3BvbnNlTUlN RVR5cGVzKCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLnNldEljb25EYXRhYmFzZUVuYWJsZWQo dHJ1ZSk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgc2V0VGlt ZW91dCgibGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpIiwyMDAwKTsKK30KKzwvc2Ny aXB0PgorVGhpcyB0ZXN0IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVlIHRvIHNlZSB0aGUgbG9nIG9m IHdoYXQgcmVzb3VyY2VzIGFyZSBsb2FkZWQuIEEgZmF2aWNvbiBzaG91bGQgYmUgbG9hZGVkIGZv ciBsb2NhbCBmaWxlcywgc28gImJhc2ljLnBuZyIgc2hvdWxkIGJlIGRpc3BsYXllZC4KKzwvYm9k eT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL3Jlc291 cmNlcy9iYXNpYy5wbmcgYi9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRlci9yZXNvdXJjZXMvYmFz aWMucG5nCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjM1NzE3Y2NhNThmOTdjNzljM2QzMjRlODM1N2I0YzRmN2IxZTE0 NjQKR0lUIGJpbmFyeSBwYXRjaApsaXRlcmFsIDM5NjEKemNtVi08NH5Gb0dQKTxoOzNLfExrMDAw ZTFOSkxUcTAwMXhtMDAxeHUxXkBzNlJ8NUhtMDAwMDZWb09JdjBSOH59CnowUkhQMylQZXYyMDEw cU5TI3RtWTA3dzc7MDd3OHYkIWs2VTAwMFNnYTZ4QVAwMDF4bTAwMXhtJmhDcz8wMDBpNgp6Tmts PFpYeGBQRFltZ2pRYjtwMUEtdE0wRiZnXkAmXjIoQWUyPzslbjM5XkZgSU17JkFCUkl2STZlZnZO S3RiWSkKelQ/VWhvUEB5MHB1MmVxY1ZGSDF8Tnc3b2whM0JtR05GY19idlV4YTtFTCNHfShuXyt0 VEozN3p5UiRSWHVYfUdrCnpia0ZTVUwpSHJYZztSQl5kd1AwJHt7TVVhPWlKKztUVWN4UGJ2RWI0 eHt3ZTtHPFIyUStzKEZiP1RhdmE7I2F2dwp6OCklc1ZtVG1qKC1VUXVybFhgUkN7PDM2I0RGUHwq Y0VDPjR2ejs0P3FGZm50dmJrT3AjYFMxJVctXj5PSktGfUAKejAyK3U+WnwpbndUcT09RUNYait4 c2tAfmVGV2MqdWRmejN6Pnwzb0I5bT9eOSVvTDFwaWJ9X1VIRExgTWBALXItCnpUY2VOSWg0RjdS TXZmbmRZUEFJKlQ7V1laPm41XnAwJlMhMlBec2o1dyhxLUJ5NGVxUGJaX3VfSGVGVGo9LURDPgp6 NG5kPnw7K1A8YzNCczYwbkN2JSMyPHkrXylKN1oxOX03KHNvRGcmNF9lQXNLQytkP2t3SUc8VTBn YVNNbCMoem4KejNWe143MWwrRGBaZ2ApWURTYyshT0o3O3V4QCYoOT1AUHs7ZXh3T1BvZEF5X3sz eWxgV0JmM3A1a35reUApXktqCnpraWomJGcoQ3x4NHR8IWMpJGF9SkdpUFZWaj9NYVdiQms/Njsp e3tFWGNjTm9DYiNYWHsmTjRPPy1aUWUmVD17SAp6Y0lBcWMzSSY0TGZKbjJgVDh4IXc+KTtyUnFZ UkV4SU1VIUtnSG5QPjg+fEtHXnwwOWVUT0UhK2RaU2d4X0JvI1gKenI9amRDOX5wYzg3WlohcVhY YiQjOzBxeio3bX0yLTlgTk5vKkl0el5fQzRIe2JOZjVgJmtGNzUkPm9iPVRuQl9rCnpVPXZVcHZ9 NGk2cHBgQGBNWFVfMkJaOyZgRE1fVDAwa3pnNWpnSj5yV3YlbnROYENJcDlXfUxackxnaDY+RUVq fgp6Pld4JVZgalFBViFUMD5lPnUkPUgkYDFAd3ZYeEBiWClHNFpaZ3lVTTlidjNuQmRASWApKUxu d3BxbkdFbHRqdHwKenlwakAkSyZSNnxhciohMERqdVhVR2w7SilFN2RkSXgzR0R+NUhxNzZPOV9a SkphI1FQJHJsS0tFYlA4XlNHTCZrCnp6XjJ8fXJFQm1randfTUVwP2AySThDVCZzM2IqTT47aT8y XkF7Jnt3NUk5bnpNQ3oqVEY5bXBvaTFOVDB4PVJQaAp6RUYzVDNSUTQ3M3pVRUpXMD8re3pmaF56 JUE+X0lVMnE5ISkqUkl9PGFfQElIXiVnN1Q0UUZzMWYjV0V3Y0lmVGoKemkwZTJsO0V0M3lOfXwk ekI/WW9NQD1fd0RLJjhHa19kKUQqVjZfWEAyZW5BfCY8VlFwJEZmO3otalV6X0B8I2w8CnpyRjVH Q2x4Vi1lU19HUVhzZFI3cT0wR0prJl5oPSMlOEBQaWEmVHQmODV8eyg1cUE+Y3N0TFJXSFVUY0FL I0J5bwp6NVh0dlZpYCpgdk11QGRCUWJ+am08VF9gYDxtI0BmWWA4UEs7cXQ5MV8jJSk4Kz9BTnVp aCEoS3tufEdjSkAyYWkKek8+O3N5WUg0JkdNSjZpPD9Camd2S21MfVpoYVNUYiVZalFOVFkjbUla UXhtUXorJFAzSlBYdDFSKD5TO1YjJH1NCnp1dWZPbS1UMEN9T0Y8Vj5Vbk0yRSNeXmk2YWBfKU5f N15nbG9KfXNTQiN4N35RaUBENSF0SCNUbGYoRChnS3ZJYAp6STBfUz4yJjRkbk5FU3J0ZWdacnQw JDIrezchcz0tUX5CI3pZPzRUMj1qMXw0QG84fCVue3IhVGBpZkxPY182bmsKejNNKFRaZHRVajUt fE9xPjluNi07bEpLaVUmeHdRLWp3Mkd1RDFsZTMoSiUpJWNKTjF0d25iPldOWDNke2FVQTFeCnow bk1APWQhMWxha34ze3B0RTJaY1VObD5CZHhxe3hhcHFFQW1KMk5jJkRsMVc/WU5fdWkjI19Jckx0 Jk5tYypxfQp6MnFfUlUoWDUqX09wVHZOJH02UGVTWk5rKEVxKWpoI19fVW1eN1dIK2JrJnczcHdp ck5WaFk4eGZZK1ZmeGNTTy0KejxlTFBYQ2llQ1NpMlJQMV9ZZWV8XjV5WkNaYnxobTlmZmpMUVU8 TjBLSlZnSkd4Jj1jcyZnfDBlalNAbVh4UjMoCnp2bjdtVT5PcGB1ZEtwQy1Fei0kUnZMI3cwRlBq eGlOd1RGbVQpa0x1ZE4jZDIjcDxPNVR0RXNUTUVnVzBhezJQeAp6RGd+SyRhdj0hVyhrdyF0THtk P0wqaWIhcDc1bER4QmNWMH5WTjlsQDZXbENlNy1PdShUNyQ4TUQybDIxMGJ2eFMKeiRENXd+VmJ8 PFcqfD44OERQXmlQbk17aD5CLUtoOUdUdUI8KzxQUE5GRGRZNDVtLWpSRF4lV0JzO3FTPG1IZXIt Cno3UlIrMVRjeSVCMDRrRiUrOUxjWUxUaUlJMkdNd29PbjRybFdBY3RCJTQjQ2w1YSRmQioyTE8/ d1JDaXhyQ2YwbQp6TmRtQCMoR3NILStQTFcwNU8tRHkhJVRQQSVlTFJ7TkxeUXM0ODUkWiZyT0Qz YH1YfihwTEUqd0ZDLWd0bkdVUi0Kek9KdlgtRiN9cD90Tn4qenI0MSl9Xng9UEp8NkJlcjEqOGNo alVSKzhIaGxVc2tNbzxhbyNmKT8wX0FtX1hGVFk5CnpTTXlWJlc7eVdpb0RWIytFQ1FLfm1xUiNN MyZ2VzYwY2tBODdfYnM2KChvIW4lXiMhZ00+TjhhU2BlaG08dFNPSwp6RGFocEhJKU1GaHJuU0x1 IzNkbE5NNCtkfmk/azZacEMyVythRXgzJk9EM0RhYkRibzRyTm1mRzk3bHY8I0xQXjwKejxuJVBj JU1nWnxGaXQkdThncSR2c2FqaTw1fHtSeSptezYhNWghPEUoY0AoYjJJQ1ghNyhlaGFIWVNQe1BO YjYzCnpDSzNzMFpMbiZaPjR8WVZgWmZ+OEY8fjROI2hOSkFUPGooKGp4M0xUZHk9MzM/KmdaZkVe X3s/UGNFKyorTG1ZUQp6bytBNi0pWFVKO3tDYXFfUmlXVmdUO058V0pCeWRHNyZzYCRwdFdmJnpM R1ZKWGpLVm9MSytQcEZHfDJDd358Uk4KenlieXVzakA5X2JLUndSKjVyNWg3U35jZF8hM0I7VFQ7 TXpSazgjc2AyNipvc210UXpDSHRCZUBnZ1NyYk9lMm0kCnp5V2BkR0xoMEFpbkF1SHJzK1o4VyNG MClzUEYlK3R0cW95WGZyOWtESCUhU35oYD5XJTlfNXBfOSRwMjByNVIpUwp6P3BNZFNgeUdkdjhW QGNvX1F9UnN7ekRVbWshSjUzSzhUV25gckleIUFOXk5Le1pGQlQwenJLVExZeWFDOXc3YG0KemtA KnNTbHQ/RnhiUSsweCVeVyFUPE5ePFZ7YHVBJUFjU0Qrbys0TjVEemFyfmYhY2hgPjd6QkN7PmQh Vyo8YGpKCnpmOE9Xc0tZRTxNZFNLN21GI3ppPEowUWZseCVydDVgQz11Uis2IWZOLVN8TmN8SWc+ fjNkOGhsZWlmQzBFailrdAp6MEZ9V2AkUTFCe2gpQWFpb09VRXVNaiZWeT8pezc3RSUycEltJCRy c2trYEwrVXxGQCYrT2p3b15NJGAwPTkhPCYKejBkVl4wQkxEZXNxeHw7b1ooTmZeZCMkcl51PXdF QXhvMlpQT3hoc3pBVk1wVEVCRjVhZXN2NHVDIWZUNDFxUUZhCnpuYShUcyhGbWZuXk5fU3F7M3dh UU4mO1gxO3N8cS01ZGNhRi1oMkJkLXR6dnpXI0c/YF99dXh7Z0ZPNHgwdzJHMwp6QylAWHltVlc9 R3YoeSVydWMzclVBfFJwRnFjcmpTIzYjMlBlbGhRZDUlbk5VTnJZJTglak5xJks8RD1CbFZmU0MK enIwSVR9MmtDTzYtSHRwbC1gZH1NVTR7S2A/cF5sJWA0T0tfLUZBZk9Ac044emFlfCtJZX5MZik+ fj5yKUFzRzZHCnpyKystUkFfcyg3NkBsdlVCT182eHg9XmR2WGFvX0JBZno1ZEc9aGxHTn1PX2sw ek1fejFmTEt8YCN7bGgwQGxGagp6PXw9MUd3WGY/JklicyN+Z18kSG0qMjBPVzd3T3NIdjJqYlRi PjhzZCNTMkhFRWgpNSN7STUpcDlQJTRzb1B0a0MKeilMVWN7QEMlZEFRSnM4X2g5OTxPVkx3VTt3 TSojU25GZGl7VEpxVnRyKnVLXkxjazRnPipMK0dadnRUUmp6YTYpCnprPlVEczAlP2NhU3hJMi0q cFl1MFBVYl9odlZBfX0tcU1PUko7N0tARiNhVTZgVio5QFFIIUA+SHJ6flhBPGB6RAp6JGQpZVpj fXJ0dEVxRUVSQ2l2I31UM2Z1I0kraF9UQmhidFA3UlBKNEs3VVZiXm9kJX5tZHkxYVdPMz5nd0cm P18KekFPRGQ0NFAqNTdTTHlGUWoyTHx3LT4oekp0OXd0cTgjODN7M1B8ZXZ2eGxuOCZxUys2ekc7 dHNWfWtxczxgZSpACnpqQERZb1NJXkFwMWlSdj4waXVPeDk9cVF4akdWN20jfWxuRG9GX1c8SDQz IXs4NSVmOVV3QFRDQXcheyVwfGV4NAp6ZEZVNyZHeWpjPDg/MHI2bzBxaXdfOztyJFJhYGN1ZlRS QGNleyhOZ2VPfkxGTTs8KVM9bD1XenFvPForYkxGblcKenZUTFJ9dSQoe3wxcX1xeilYRGVBdkJ6 ZURgYUVqbGQtUWMzcm43NjdZKnZ4VXk1I2ExM2RKbj5MV1dYRmE+ZUZoCnolSmJoeCprfjFqVURx cnZuVilgcW1NMCNXPUkob1V2aXE3Y0hAdk5uK2RncHhwWnhPZldoOCQ1VXNMRWYoUEUrRwp6dSho cU13JWJ9X0dlQjVCYl5OJGw4MkBsfj5jP31JOUMySmczZW1kcGMzbmotQDhQN2tuWFVfaXtsbnp2 ZjQxc14KekBCSHUoZVM/e0ZrbD40LThzPikmUDRNeTA/Y3t4VFpOfCQ7YFVXJDZeMkB1YV5td2Em Zjc1I2g9KVd3eENWXkdHCnpRRVJPZ0xURGdaSmJMaHY7QDt4bGs/O0F+eFBOX2x6VjtqJmRQaC0/ Q0phVG9IblBOVnZoWShYIWleX00rTH13SQp6OUtsRWFkSztobHp8WWFLQ0daWFJlZkFXT0piMGQ2 KkwxTWBzdClGK0whTiFBTkBGb3oxIykmVzxVK1ApYkp0cEgKeih6YlNFQHRGZihEKCFncmdrdnx7 UXwtUT8lYnooLWVybE1AMkZHdyohfDx1aTcoQn1QYjdaX3BWb0BZJUNAOzVkCnpkclEzZ2sybXEp N2UpeUVxXnpEZlVnT08xOHNCK2ZqMkUmO3pjRTIzdEdNLX1vN1d8d3JmSElnNEU1QDxnV3VCVQp6 aEpRQ1pfMUlWPkpFR2IwVE55dDAzUW5GRnBxa3NxZUFtczRAcD93KlVxIXVxLTMyZkI9MzU4KClQ MXtgKSVVZTUKem5eIzxhT0o2R3w5OUw0VHhhKkk9Tit8KTxNeEgoNyV9bV5zKzFqe01FRlMrSXpw fCY/Q3xAbkRhMWxWMTlVe3NPCnphV1Q5NkI/VWhIbHxCNk1wJFUjM3N4dGFxZ1Z+OVlZK2xrY2tZ UStSb352S28keEhXQG5IJnFhPU9lI2h8Q0BUYgp6PCtpfn5CaFdeb0RNfW1HV185QFZrM1F7bV9U SEQ8KHpzaT1gQnoyeGpoQGFBNl4rKmtIdEcwP2lgKlM1Q0FqaEoKentvTUhXZWdOdiM3XnleU3pH enpDVjIwMHJidVY2NEVeNyp9bzReVlomMWJxZ299Ry1VdnA9fVkmRjNyTDsxI2NOCnokXio5dTw/ Z2E3aSpAb3M+VXN3Jkd4LUg5VSVEYGltODRkfVRpMjhOSGFScyhMX2lTTD53WXdSPFhkcCRkd31Q Wgp6eVNrbFhjXzlDfih4Oyh0YEZhV2JEekAlZDRWc2dqNVRaSFIjVSVPQloxLWoyYEklfXdLUXJv QVVvdzIpK3F6K2wKemI8JXMrI0Y5TT09fWFvSDArRFZwPjkrbWNSV0phb0t7ZWBuMVRaaGdsWF53 bGxscylOSyF2MkktPmhgNCo5dXR2CnpndWVZcmVlO3xQaiRfLV8yV0RUNGNPX1E3Y0NlQ15XYk9B UFI9cUVBMzRoKG4kNnR4UzhmMGlBYmd7UXBVWChYaAp6e3ZTekByb1cydWlxUVo3MDN+IXFTYWY0 QFducHc+RW81UElXZEpmVEZnWXpURmZBfU9SNTNPPkdCcjlkR0FsN0sKekl4c0xBRz1CTDIwMDFS KU1PYnVnWik5bV5jYGFtTmJZJWNDRmZjaFNGKSVHS0hCPlArSXg7bW5GZnVES0ZnaD9XClRNVEgy PjAwMDAwTmt2WFh1MG1qZjRSTlcoCgpsaXRlcmFsIDAKSGNtVj9kMDAwMDEKCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5k ZXggMGJjMTNjOC4uNDIwZWIzYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDExLTA2 LTIxICBSYWZhZWwgQnJhbmRhbyAgPHJhZmFlbC5sb2JvQG9wZW5ib3NzYS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTG9jYWwgZmlsZXMgY2Fu bm90IGxvYWQgaWNvbnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD02MjQ1OQorICAgICAgICAKKyAgICAgICAgUHJldmlvdXMgcG9saWN5IG9ubHkgYWxs b3dlZCBpY29ucyBmb3IgcGFnZXMgd2hvc2UgcHJvdG9jb2wgd2FzIHBhcnQgb2YgSFRUUCBmYW1p bHkuCisgICAgICAgIENoYW5nZWQgdGhhdCB0byBhbGxvdyB0byBhbnkgdXJsIHRoYXQncyBub3Qg ZW1wdHkgYW5kIHdob3NlIHByb3RvY29sIGlzIG5vdCAiYWJvdXQiLgorICAgICAgICBBbHNvIGFk ZGVkIHRoaXMgY2hlY2sgd2hlcmUgaXQgYXR0ZW1wdHMgdG8gc3RhcnQgbG9hZGluZyB0aGUgZmF2 aWNvbiwgc28gaXQgY2FuIGF2b2lkCisgICAgICAgIHdhc3RpbmcgdGltZSBkb3dubG9hZGluZyBh IHJlc291cmNlIHRoYXQgd29uJ3QgYmUgc3RvcmVkIGFuZCB3b24ndCBiZSB1c2VkLgorCisgICAg ICAgIFRlc3Q6IGZhc3QvcHJlbG9hZGVyL2Zhdmljb24uaHRtbAorCisgICAgICAgICogbG9hZGVy L2ljb24vSWNvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SWNvbkNvbnRyb2xs ZXI6OnN0YXJ0TG9hZGVyKTogSXQgbm93IHVzZXMgcGFnZUNhbkhhdmVJY29uIGFuZCBhdm9pZCB0 byBkb3dubG9hZCB0aGUgaWNvbiBpZiB0aGUgcGFnZSBjYW4ndCBoYXZlIGl0LgorICAgICAgICAq IGxvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHA6IE1vdmVkIHBhZ2VDYW5IYXZlSWNvbiB0byB0 aGUgSWNvbkRhdGFiYXNlIGNsYXNzLCBzbyBpdCBjb3VsZCBiZSB1c2VkIGJ5IEljb25Db250cm9s bGVyLgorICAgICAgICAqIGxvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oOiBEaXR0by4KKyAgICAg ICAgKFdlYkNvcmU6Okljb25EYXRhYmFzZTo6cGFnZUNhbkhhdmVJY29uKToKKyAgICAgICAgKiBw bGF0Zm9ybS9LVVJMLmNwcDogUmVtb3ZlZCB1bnVzZWQgZnVuY3Rpb24uCisgICAgICAgICogcGxh dGZvcm0vS1VSTC5oOiBEaXR0by4KKwogMjAxMS0wNi0xOSAgTWFkcyBBZ2VyICA8YWdlckBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25Db250cm9sbGVyLmNwcCBiL1NvdXJjZS9X ZWJDb3JlL2xvYWRlci9pY29uL0ljb25Db250cm9sbGVyLmNwcAppbmRleCA3N2Q1MmVlLi43YTMx OTI1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uQ29udHJvbGxl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkNvbnRyb2xsZXIuY3Bw CkBAIC0xMTMsNiArMTEzLDEwIEBAIHZvaWQgSWNvbkNvbnRyb2xsZXI6OnN0YXJ0TG9hZGVyKCkK ICAgICBpZiAoIWljb25EYXRhYmFzZSgpLmlzRW5hYmxlZCgpKQogICAgICAgICByZXR1cm47CiAK KyAgICBTdHJpbmcgcGFnZVVSTCA9IG1fZnJhbWUtPmRvY3VtZW50KCktPnVybCgpOworICAgIGlm ICghSWNvbkRhdGFiYXNlOjpwYWdlQ2FuSGF2ZUljb24ocGFnZVVSTCkpCisgICAgICAgIHJldHVy bjsKKwogICAgIEtVUkwgaWNvblVSTCh1cmwoKSk7CiAgICAgU3RyaW5nIHVybFN0cmluZyhpY29u VVJMLnN0cmluZygpKTsKICAgICBpZiAodXJsU3RyaW5nLmlzRW1wdHkoKSkKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuY3BwCmluZGV4IDM5ZGIwNjcuLmRhM2ZlZTgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmNwcApAQCAtOTks MTEgKzk5LDYgQEAgc3RhdGljIEljb25EYXRhYmFzZUNsaWVudCogZGVmYXVsdENsaWVudCgpCiAg ICAgcmV0dXJuIGRlZmF1bHRDbGllbnQ7CiB9CiAKLXN0YXRpYyBpbmxpbmUgYm9vbCBwYWdlQ2Fu SGF2ZUljb24oY29uc3QgU3RyaW5nJiBwYWdlVVJMKQotewotICAgIHJldHVybiBwcm90b2NvbElz SW5IVFRQRmFtaWx5KHBhZ2VVUkwpOwotfQotCiAvLyAqKioqKioqKioqKioqKioqKioqKioqKioK IC8vICoqKiBNYWluIFRocmVhZCBPbmx5ICoqKgogLy8gKioqKioqKioqKioqKioqKioqKioqKioq CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuaCBi L1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oCmluZGV4IGI1OTM3NjQu LjJhODUxMTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRh YmFzZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oCkBA IC0yOCw2ICsyOCw3IEBACiAjZGVmaW5lIEljb25EYXRhYmFzZV9oCiAKICNpbmNsdWRlICJJY29u RGF0YWJhc2VCYXNlLmgiCisjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlRpbWVyLmgiCiAj aW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgpAQCAtMTM3 LDYgKzEzOCwxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIGlzT3BlbigpIGNvbnN0Owog ICAgIHZpcnR1YWwgU3RyaW5nIGRhdGFiYXNlUGF0aCgpIGNvbnN0OwogICAgIHN0YXRpYyBTdHJp bmcgZGVmYXVsdERhdGFiYXNlRmlsZW5hbWUoKTsKKyAgICBzdGF0aWMgaW5saW5lIGJvb2wgcGFn ZUNhbkhhdmVJY29uKGNvbnN0IFN0cmluZyYgcGFnZVVSTCkKKyAgICB7CisgICAgICAgIHJldHVy biAhcGFnZVVSTC5pc0VtcHR5KCkgJiYgIXByb3RvY29sSXMocGFnZVVSTCwgImFib3V0Iik7Cisg ICAgfQogCiBwcml2YXRlOgogICAgIFBhc3NSZWZQdHI8SWNvblJlY29yZD4gZ2V0T3JDcmVhdGVJ Y29uUmVjb3JkKGNvbnN0IFN0cmluZyYgaWNvblVSTCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9LVVJMLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0tVUkwuY3Bw CmluZGV4IDg2MTFlZDEuLjFmMmMyODkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL0tVUkwuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL0tVUkwuY3BwCkBAIC0x OTcwLDE3ICsxOTcwLDQgQEAgU3RyaW5nIG1pbWVUeXBlRnJvbURhdGFVUkwoY29uc3QgU3RyaW5n JiB1cmwpCiAgICAgcmV0dXJuICIiOwogfQogCi1ib29sIHByb3RvY29sSXNJbkhUVFBGYW1pbHko Y29uc3QgU3RyaW5nJiB1cmwpCi17Ci0gICAgdW5zaWduZWQgbGVuZ3RoID0gdXJsLmxlbmd0aCgp OwotICAgIGNvbnN0IFVDaGFyKiBjaGFyYWN0ZXJzID0gdXJsLmNoYXJhY3RlcnMoKTsKLSAgICBy ZXR1cm4gbGVuZ3RoID4gNAotICAgICAgICAmJiBpc0xldHRlck1hdGNoSWdub3JpbmdDYXNlKGNo YXJhY3RlcnNbMF0sICdoJykKLSAgICAgICAgJiYgaXNMZXR0ZXJNYXRjaElnbm9yaW5nQ2FzZShj aGFyYWN0ZXJzWzFdLCAndCcpCi0gICAgICAgICYmIGlzTGV0dGVyTWF0Y2hJZ25vcmluZ0Nhc2Uo Y2hhcmFjdGVyc1syXSwgJ3QnKQotICAgICAgICAmJiBpc0xldHRlck1hdGNoSWdub3JpbmdDYXNl KGNoYXJhY3RlcnNbM10sICdwJykKLSAgICAgICAgJiYgKGNoYXJhY3RlcnNbNF0gPT0gJzonCi0g ICAgICAgICAgICB8fCAoaXNMZXR0ZXJNYXRjaElnbm9yaW5nQ2FzZShjaGFyYWN0ZXJzWzRdLCAn cycpICYmIGxlbmd0aCA+IDUgJiYgY2hhcmFjdGVyc1s1XSA9PSAnOicpKTsKLX0KLQogfQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vS1VSTC5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vS1VSTC5oCmluZGV4IGY2MjExODAuLmFhYWQ5MGMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL0tVUkwuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9L VVJMLmgKQEAgLTI4NCw3ICsyODQsNiBAQCBjb25zdCBLVVJMJiBibGFua1VSTCgpOwogLy8gVGhp cyBpcyBlc3BlY2lhbGx5IGltcG9ydGFudCBiZWNhdXNlIHZhbGlkIGphdmFzY3JpcHQgVVJMcyBh cmUgbm90IG5lY2Vzc2FyaWx5IGNvbnNpZGVyZWQgdmFsaWQgYnkgS1VSTC4KIAogYm9vbCBwcm90 b2NvbElzKGNvbnN0IFN0cmluZyYgdXJsLCBjb25zdCBjaGFyKiBwcm90b2NvbCk7Ci1ib29sIHBy b3RvY29sSXNJbkhUVFBGYW1pbHkoY29uc3QgU3RyaW5nJiB1cmwpOwogYm9vbCBwcm90b2NvbElz SmF2YVNjcmlwdChjb25zdCBTdHJpbmcmIHVybCk7CiAKIGJvb2wgaXNEZWZhdWx0UG9ydEZvclBy b3RvY29sKHVuc2lnbmVkIHNob3J0IHBvcnQsIGNvbnN0IFN0cmluZyYgcHJvdG9jb2wpOwo= 98206 2011-06-22 11:28:31 -0700 2011-06-27 17:23:17 -0700 Modified layout test to use queueReload instead, and did not change KURL in this patch. icon-loading-webkit-3.diff text/plain 10602 rafael.lobo ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBmMWFmNjhjLi4wYjUyMjY5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYt MjIgIFJhZmFlbCBCcmFuZGFvICA8cmFmYWVsLmxvYm9Ab3BlbmJvc3NhLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMb2NhbCBmaWxlcyBjYW5u b3QgbG9hZCBpY29ucy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTYyNDU5CisKKyAgICAgICAgQWRkZWQgYSBsYXlvdXQgdGVzdCB0byB2ZXJpZnkgaWYg dGhlIGZhdmljb24gaXMgYmVpbmcgbG9hZGVkIGZvciBsb2NhbCBmaWxlcywKKyAgICAgICAgYXMg dGhlIHByZXZpb3VzIHBvbGljeSBvbmx5IGFsbG93ZWQgaXQgdG8gcGFnZXMgd2hvc2UgcHJvdG9j b2wgd2FzIGh0dHAgb3IgaHR0cHMuCisKKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9mYXZpY29u LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9yZXNvdXJjZXMvYmFzaWMucG5n OiBBZGRlZC4KKwogMjAxMS0wNi0yMiAgWXV0YSBLaXRhbXVyYSAgPHl1dGFrQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBVbnJldmlld2VkLCBhcHBseSBhIGNvdXBsZSBvZiBDaHJvbWl1bSB0ZXN0 IGV4cGVjdGF0aW9uIGNoYW5nZXMgdG8gdGVzdF9leHBlY3RhdGlvbnMudHh0LgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29uLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi43YTc3M2Y5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwzIEBA CitmYXZpY29uLmh0bWwgaGFzIE1JTUUgdHlwZSB0ZXh0L2h0bWwKK2Jhc2ljLnBuZyBoYXMgTUlN RSB0eXBlIGltYWdlL3BuZworVGhpcyB0ZXN0IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVlIHRvIHNl ZSB0aGUgbG9nIG9mIHdoYXQgcmVzb3VyY2VzIGFyZSBsb2FkZWQuIEEgZmF2aWNvbiBzaG91bGQg YmUgbG9hZGVkIGZvciBsb2NhbCBmaWxlcywgc28gImJhc2ljLnBuZyIgc2hvdWxkIGJlIGRpc3Bs YXllZC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24uaHRt bCBiL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24uaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwLi4zYmEyNmMwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5odG1sCkBAIC0wLDAgKzEsMTYgQEAKKzxodG1s PgorPGhlYWQ+Cis8L2hlYWQ+Cis8bGluayB0eXBlPSJpbWFnZS9wbmciIGhyZWY9InJlc291cmNl cy9iYXNpYy5wbmciIHNpemVzPSI2NHg2NCIgcmVsPSJpY29uIiAvPgorPGJvZHk+Cis8c2NyaXB0 PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICBsYXlvdXRUZXN0Q29udHJv bGxlci5kdW1wQXNUZXh0KCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBSZXNvdXJjZVJl c3BvbnNlTUlNRVR5cGVzKCk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLnNldEljb25EYXRhYmFz ZUVuYWJsZWQodHJ1ZSk7CisgIGxheW91dFRlc3RDb250cm9sbGVyLnF1ZXVlUmVsb2FkKCk7Cit9 Cis8L3NjcmlwdD4KK1RoaXMgdGVzdCByZXF1aXJlcyBEdW1wUmVuZGVyVHJlZSB0byBzZWUgdGhl IGxvZyBvZiB3aGF0IHJlc291cmNlcyBhcmUgbG9hZGVkLiBBIGZhdmljb24gc2hvdWxkIGJlIGxv YWRlZCBmb3IgbG9jYWwgZmlsZXMsIHNvICJiYXNpYy5wbmciIHNob3VsZCBiZSBkaXNwbGF5ZWQu Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRl ci9yZXNvdXJjZXMvYmFzaWMucG5nIGIvTGF5b3V0VGVzdHMvZmFzdC9wcmVsb2FkZXIvcmVzb3Vy Y2VzL2Jhc2ljLnBuZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zNTcxN2NjYTU4Zjk3Yzc5YzNkMzI0ZTgzNTdiNGM0 ZjdiMWUxNDY0CkdJVCBiaW5hcnkgcGF0Y2gKbGl0ZXJhbCAzOTYxCnpjbVYtPDR+Rm9HUCk8aDsz S3xMazAwMGUxTkpMVHEwMDF4bTAwMXh1MV5AczZSfDVIbTAwMDA2Vm9PSXYwUjh+fQp6MFJIUDMp UGV2MjAxMHFOUyN0bVkwN3c3OzA3dzh2JCFrNlUwMDBTZ2E2eEFQMDAxeG0wMDF4bSZoQ3M/MDAw aTYKek5rbDxaWHhgUERZbWdqUWI7cDFBLXRNMEYmZ15AJl4yKEFlMj87JW4zOV5GYElNeyZBQlJJ dkk2ZWZ2Tkt0YlkpCnpUP1Vob1BAeTBwdTJlcWNWRkgxfE53N29sITNCbUdORmNfYnZVeGE7RUwj R30obl8rdFRKMzd6eVIkUlh1WH1Hawp6YmtGU1VMKUhyWGc7UkJeZHdQMCR7e01VYT1pSis7VFVj eFBidkViNHh7d2U7RzxSMlErcyhGYj9UYXZhOyNhdncKejgpJXNWbVRtaigtVVF1cmxYYFJDezwz NiNERlB8KmNFQz40dno7ND9xRmZudHZia09wI2BTMSVXLV4+T0pLRn1ACnowMit1Plp8KW53VHE9 PUVDWGoreHNrQH5lRldjKnVkZnozej58M29COW0/Xjklb0wxcGlifV9VSERMYE1gQC1yLQp6VGNl TkloNEY3Uk12Zm5kWVBBSSpUO1dZWj5uNV5wMCZTITJQXnNqNXcocS1CeTRlcVBiWl91X0hlRlRq PS1EQz4KejRuZD58OytQPGMzQnM2MG5DdiUjMjx5K18pSjdaMTl9Nyhzb0RnJjRfZUFzS0MrZD9r d0lHPFUwZ2FTTWwjKHpuCnozVnteNzFsK0RgWmdgKVlEU2MrIU9KNzt1eEAmKDk9QFB7O2V4d09Q b2RBeV97M3lsYFdCZjNwNWt+a3lAKV5Lagp6a2lqJiRnKEN8eDR0fCFjKSRhfUpHaVBWVmo/TWFX YkJrPzY7KXt7RVhjY05vQ2IjWFh7Jk40Tz8tWlFlJlQ9e0gKemNJQXFjM0kmNExmSm4yYFQ4eCF3 Pik7clJxWVJFeElNVSFLZ0huUD44PnxLR158MDllVE9FIStkWlNneF9CbyNYCnpyPWpkQzl+cGM4 N1paIXFYWGIkIzswcXoqN219Mi05YE5ObypJdHpeX0M0SHtiTmY1YCZrRjc1JD5vYj1UbkJfawp6 VT12VXB2fTRpNnBwYEBgTVhVXzJCWjsmYERNX1QwMGt6ZzVqZ0o+cld2JW50TmBDSXA5V31MWnJM Z2g2PkVFan4Kej5XeCVWYGpRQVYhVDA+ZT51JD1IJGAxQHd2WHhAYlgpRzRaWmd5VU05YnYzbkJk QElgKSlMbndwcW5HRWx0anR8Cnp5cGpAJEsmUjZ8YXIqITBEanVYVUdsO0opRTdkZEl4M0dEfjVI cTc2TzlfWkpKYSNRUCRybEtLRWJQOF5TR0wmawp6el4yfH1yRUJta2p3X01FcD9gMkk4Q1QmczNi Kk0+O2k/Ml5BeyZ7dzVJOW56TUN6KlRGOW1wb2kxTlQweD1SUGgKekVGM1QzUlE0NzN6VUVKVzA/ K3t6ZmheeiVBPl9JVTJxOSEpKlJJfTxhX0BJSF4lZzdUNFFGczFmI1dFd2NJZlRqCnppMGUybDtF dDN5Tn18JHpCP1lvTUA9X3dESyY4R2tfZClEKlY2X1hAMmVuQXwmPFZRcCRGZjt6LWpVel9AfCNs PAp6ckY1R0NseFYtZVNfR1FYc2RSN3E9MEdKayZeaD0jJThAUGlhJlR0Jjg1fHsoNXFBPmNzdExS V0hVVGNBSyNCeW8KejVYdHZWaWAqYHZNdUBkQlFifmptPFRfYGA8bSNAZllgOFBLO3F0OTFfIyUp OCs/QU51aWghKEt7bnxHY0pAMmFpCnpPPjtzeVlINCZHTUo2aTw/QmpndkttTH1aaGFTVGIlWWpR TlRZI21JWlF4bVF6KyRQM0pQWHQxUig+UztWIyR9TQp6dXVmT20tVDBDfU9GPFY+VW5NMkUjXl5p NmFgXylOXzdeZ2xvSn1zU0IjeDd+UWlARDUhdEgjVGxmKEQoZ0t2SWAKekkwX1M+MiY0ZG5ORVNy dGVnWnJ0MCQyK3s3IXM9LVF+QiN6WT80VDI9ajF8NEBvOHwlbntyIVRgaWZMT2NfNm5rCnozTShU WmR0VWo1LXxPcT45bjYtO2xKS2lVJnh3US1qdzJHdUQxbGUzKEolKSVjSk4xdHduYj5XTlgzZHth VUExXgp6MG5NQD1kITFsYWt+M3twdEUyWmNVTmw+QmR4cXt4YXBxRUFtSjJOYyZEbDFXP1lOX3Vp IyNfSXJMdCZObWMqcX0KejJxX1JVKFg1Kl9PcFR2TiR9NlBlU1pOayhFcSlqaCNfX1VtXjdXSCti ayZ3M3B3aXJOVmhZOHhmWStWZnhjU08tCno8ZUxQWENpZUNTaTJSUDFfWWVlfF41eVpDWmJ8aG05 ZmZqTFFVPE4wS0pWZ0pHeCY9Y3MmZ3wwZWpTQG1YeFIzKAp6dm43bVU+T3BgdWRLcEMtRXotJFJ2 TCN3MEZQanhpTndURm1UKWtMdWROI2QyI3A8TzVUdEVzVE1FZ1cwYXsyUHgKekRnfkskYXY9IVco a3chdEx7ZD9MKmliIXA3NWxEeEJjVjB+Vk45bEA2V2xDZTctT3UoVDckOE1EMmwyMTBidnhTCnok RDV3flZifDxXKnw+ODhEUF5pUG5Ne2g+Qi1LaDlHVHVCPCs8UFBORkRkWTQ1bS1qUkReJVdCcztx UzxtSGVyLQp6N1JSKzFUY3klQjA0a0YlKzlMY1lMVGlJSTJHTXdvT240cmxXQWN0QiU0I0NsNWEk ZkIqMkxPP3dSQ2l4ckNmMG0Kek5kbUAjKEdzSC0rUExXMDVPLUR5ISVUUEElZUxSe05MXlFzNDg1 JFomck9EM2B9WH4ocExFKndGQy1ndG5HVVItCnpPSnZYLUYjfXA/dE5+KnpyNDEpfV54PVBKfDZC ZXIxKjhjaGpVUis4SGhsVXNrTW88YW8jZik/MF9BbV9YRlRZOQp6U015ViZXO3lXaW9EViMrRUNR S35tcVIjTTMmdlc2MGNrQTg3X2JzNigobyFuJV4jIWdNPk44YVNgZWhtPHRTT0sKekRhaHBISSlN RmhyblNMdSMzZGxOTTQrZH5pP2s2WnBDMlcrYUV4MyZPRDNEYWJEYm80ck5tZkc5N2x2PCNMUF48 Cno8biVQYyVNZ1p8Rml0JHU4Z3EkdnNhamk8NXx7UnkqbXs2ITVoITxFKGNAKGIySUNYITcoZWhh SFlTUHtQTmI2Mwp6Q0szczBaTG4mWj40fFlWYFpmfjhGPH40TiNoTkpBVDxqKChqeDNMVGR5PTMz PypnWmZFXl97P1BjRSsqK0xtWVEKem8rQTYtKVhVSjt7Q2FxX1JpV1ZnVDtOfFdKQnlkRzcmc2Ak cHRXZiZ6TEdWSlhqS1ZvTEsrUHBGR3wyQ3d+fFJOCnp5Ynl1c2pAOV9iS1J3Uio1cjVoN1N+Y2Rf ITNCO1RUO016Ums4I3NgMjYqb3NtdFF6Q0h0QmVAZ2dTcmJPZTJtJAp6eVdgZEdMaDBBaW5BdUhy cytaOFcjRjApc1BGJSt0dHFveVhmcjlrREglIVN+aGA+VyU5XzVwXzkkcDIwcjVSKVMKej9wTWRT YHlHZHY4VkBjb19RfVJze3pEVW1rIUo1M0s4VFduYHJJXiFBTl5OS3taRkJUMHpyS1RMWXlhQzl3 N2BtCnprQCpzU2x0P0Z4YlErMHglXlchVDxOXjxWe2B1QSVBY1NEK28rNE41RHphcn5mIWNoYD43 ekJDez5kIVcqPGBqSgp6ZjhPV3NLWUU8TWRTSzdtRiN6aTxKMFFmbHglcnQ1YEM9dVIrNiFmTi1T fE5jfElnPn4zZDhobGVpZkMwRWopa3QKejBGfVdgJFExQntoKUFhaW9PVUV1TWomVnk/KXs3N0Ul MnBJbSQkcnNra2BMK1V8RkAmK09qd29eTSRgMD05ITwmCnowZFZeMEJMRGVzcXh8O29aKE5mXmQj JHJedT13RUF4bzJaUE94aHN6QVZNcFRFQkY1YWVzdjR1QyFmVDQxcVFGYQp6bmEoVHMoRm1mbl5O X1NxezN3YVFOJjtYMTtzfHEtNWRjYUYtaDJCZC10enZ6VyNHP2BffXV4e2dGTzR4MHcyRzMKekMp QFh5bVZXPUd2KHklcnVjM3JVQXxScEZxY3JqUyM2IzJQZWxoUWQ1JW5OVU5yWSU4JWpOcSZLPEQ9 QmxWZlNDCnpyMElUfTJrQ082LUh0cGwtYGR9TVU0e0tgP3BebCVgNE9LXy1GQWZPQHNOOHphZXwr SWV+TGYpPn4+cilBc0c2Rwp6cisrLVJBX3MoNzZAbHZVQk9fNnh4PV5kdlhhb19CQWZ6NWRHPWhs R059T19rMHpNX3oxZkxLfGAje2xoMEBsRmoKej18PTFHd1hmPyZJYnMjfmdfJEhtKjIwT1c3d09z SHYyamJUYj44c2QjUzJIRUVoKTUje0k1KXA5UCU0c29QdGtDCnopTFVje0BDJWRBUUpzOF9oOTk8 T1ZMd1U7d00qI1NuRmRpe1RKcVZ0cip1S15MY2s0Zz4qTCtHWnZ0VFJqemE2KQp6az5VRHMwJT9j YVN4STItKnBZdTBQVWJfaHZWQX19LXFNT1JKOzdLQEYjYVU2YFYqOUBRSCFAPkhyen5YQTxgekQK eiRkKWVaY31ydHRFcUVFUkNpdiN9VDNmdSNJK2hfVEJoYnRQN1JQSjRLN1VWYl5vZCV+bWR5MWFX TzM+Z3dHJj9fCnpBT0RkNDRQKjU3U0x5RlFqMkx8dy0+KHpKdDl3dHE4IzgzezNQfGV2dnhsbjgm cVMrNnpHO3RzVn1rcXM8YGUqQAp6akBEWW9TSV5BcDFpUnY+MGl1T3g5PXFReGpHVjdtI31sbkRv Rl9XPEg0MyF7ODUlZjlVd0BUQ0F3IXslcHxleDQKemRGVTcmR3lqYzw4PzByNm8wcWl3Xzs7ciRS YWBjdWZUUkBjZXsoTmdlT35MRk07PClTPWw9V3pxbzxaK2JMRm5XCnp2VExSfXUkKHt8MXF9cXop WERlQXZCemVEYGFFamxkLVFjM3JuNzY3WSp2eFV5NSNhMTNkSm4+TFdXWEZhPmVGaAp6JUpiaHgq a34xalVEcXJ2blYpYHFtTTAjVz1JKG9VdmlxN2NIQHZObitkZ3B4cFp4T2ZXaDgkNVVzTEVmKFBF K0cKenUoaHFNdyVifV9HZUI1QmJeTiRsODJAbH4+Yz99STlDMkpnM2VtZHBjM25qLUA4UDdrblhV X2l7bG56dmY0MXNeCnpAQkh1KGVTP3tGa2w+NC04cz4pJlA0TXkwP2N7eFRaTnwkO2BVVyQ2XjJA dWFebXdhJmY3NSNoPSlXd3hDVl5HRwp6UUVST2dMVERnWkpiTGh2O0A7eGxrPztBfnhQTl9selY7 aiZkUGgtP0NKYVRvSG5QTlZ2aFkoWCFpXl9NK0x9d0kKejlLbEVhZEs7aGx6fFlhS0NHWlhSZWZB V09KYjBkNipMMU1gc3QpRitMIU4hQU5ARm96MSMpJlc8VStQKWJKdHBICnooemJTRUB0RmYoRCgh Z3Jna3Z8e1F8LVE/JWJ6KC1lcmxNQDJGR3cqIXw8dWk3KEJ9UGI3Wl9wVm9AWSVDQDs1ZAp6ZHJR M2drMm1xKTdlKXlFcV56RGZVZ09PMThzQitmajJFJjt6Y0UyM3RHTS19bzdXfHdyZkhJZzRFNUA8 Z1d1QlUKemhKUUNaXzFJVj5KRUdiMFROeXQwM1FuRkZwcWtzcWVBbXM0QHA/dypVcSF1cS0zMmZC PTM1OCgpUDF7YCklVWU1CnpuXiM8YU9KNkd8OTlMNFR4YSpJPU4rfCk8TXhIKDclfW1ecysxantN RUZTK0l6cHwmP0N8QG5EYTFsVjE5VXtzTwp6YVdUOTZCP1VoSGx8QjZNcCRVIzNzeHRhcWdWfjlZ WStsa2NrWVErUm9+dktvJHhIV0BuSCZxYT1PZSNofENAVGIKejwraX5+QmhXXm9ETX1tR1dfOUBW azNRe21fVEhEPCh6c2k9YEJ6MnhqaEBhQTZeKyprSHRHMD9pYCpTNUNBamhKCnp7b01IV2VnTnYj N155XlN6R3p6Q1YyMDByYnVWNjRFXjcqfW80XlZaJjFicWdvfUctVXZwPX1ZJkYzckw7MSNjTgp6 JF4qOXU8P2dhN2kqQG9zPlVzdyZHeC1IOVUlRGBpbTg0ZH1UaTI4TkhhUnMoTF9pU0w+d1l3UjxY ZHAkZHd9UFoKenlTa2xYY185Q34oeDsodGBGYVdiRHpAJWQ0VnNnajVUWkhSI1UlT0JaMS1qMmBJ JX13S1Fyb0FVb3cyKStxeitsCnpiPCVzKyNGOU09PX1hb0gwK0RWcD45K21jUldKYW9Le2VgbjFU WmhnbFhed2xsbHMpTkshdjJJLT5oYDQqOXV0dgp6Z3VlWXJlZTt8UGokXy1fMldEVDRjT19RN2ND ZUNeV2JPQVBSPXFFQTM0aChuJDZ0eFM4ZjBpQWJne1FwVVgoWGgKent2U3pAcm9XMnVpcVFaNzAz fiFxU2FmNEBXbnB3PkVvNVBJV2RKZlRGZ1l6VEZmQX1PUjUzTz5HQnI5ZEdBbDdLCnpJeHNMQUc9 QkwyMDAxUilNT2J1Z1opOW1eY2BhbU5iWSVjQ0ZmY2hTRiklR0tIQj5QK0l4O21uRmZ1REtGZ2g/ VwpUTVRIMj4wMDAwME5rdlhYdTBtamY0Uk5XKAoKbGl0ZXJhbCAwCkhjbVY/ZDAwMDAxCgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCmluZGV4IDYyZGRkNGYuLmZlMjk3ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAor MjAxMS0wNi0yMiAgUmFmYWVsIEJyYW5kYW8gIDxyYWZhZWwubG9ib0BvcGVuYm9zc2Eub3JnPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIExvY2FsIGZp bGVzIGNhbm5vdCBsb2FkIGljb25zLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NjI0NTkKKworICAgICAgICBQcmV2aW91cyBwb2xpY3kgb25seSBhbGxv d2VkIGljb25zIGZvciBwYWdlcyB3aG9zZSBwcm90b2NvbCB3YXMgcGFydCBvZiBIVFRQIGZhbWls eS4KKyAgICAgICAgQ2hhbmdlZCB0aGF0IHRvIGFsbG93IHRvIGFueSB1cmwgdGhhdCdzIG5vdCBl bXB0eSBhbmQgd2hvc2UgcHJvdG9jb2wgaXMgbm90ICJhYm91dCIuCisgICAgICAgIEFsc28gYWRk ZWQgdGhpcyBjaGVjayB3aGVyZSBpdCBhdHRlbXB0cyB0byBzdGFydCBsb2FkaW5nIHRoZSBmYXZp Y29uLCBzbyBpdCBjYW4gYXZvaWQKKyAgICAgICAgd2FzdGluZyB0aW1lIGRvd25sb2FkaW5nIGEg cmVzb3VyY2UgdGhhdCB3b24ndCBiZSBzdG9yZWQgYW5kIHdvbid0IGJlIHVzZWQuCisKKyAgICAg ICAgVGVzdDogZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5odG1sCisKKyAgICAgICAgKiBsb2FkZXIv aWNvbi9JY29uQ29udHJvbGxlci5jcHA6IEl0IG5vdyB1c2VzIHBhZ2VDYW5IYXZlSWNvbiBhbmQg YXZvaWQgdG8gZG93bmxvYWQgdGhlIGljb24gaWYgdGhlIHBhZ2UgY2FuJ3QgaGF2ZSBpdC4KKyAg ICAgICAgKFdlYkNvcmU6Okljb25Db250cm9sbGVyOjpzdGFydExvYWRlcik6CisgICAgICAgICog bG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmNwcDogTW92ZWQgcGFnZUNhbkhhdmVJY29uIHRvIElj b25EYXRhYmFzZSBjbGFzcywgc28gaXQgY291bGQgYmUgdXNlZCBieSBJY29uQ29udHJvbGxlci4K KyAgICAgICAgKiBsb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuaDogRGl0dG8uCisgICAgICAgIChX ZWJDb3JlOjpJY29uRGF0YWJhc2U6OnBhZ2VDYW5IYXZlSWNvbik6CisKIDIwMTEtMDYtMjAgIERp bWl0cmkgR2xhemtvdiAgPGRnbGF6a292QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBLZW50IFRhbXVyYS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29u L0ljb25Db250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25Db250 cm9sbGVyLmNwcAppbmRleCA3N2Q1MmVlLi43YTMxOTI1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9sb2FkZXIvaWNvbi9JY29uQ29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv bG9hZGVyL2ljb24vSWNvbkNvbnRyb2xsZXIuY3BwCkBAIC0xMTMsNiArMTEzLDEwIEBAIHZvaWQg SWNvbkNvbnRyb2xsZXI6OnN0YXJ0TG9hZGVyKCkKICAgICBpZiAoIWljb25EYXRhYmFzZSgpLmlz RW5hYmxlZCgpKQogICAgICAgICByZXR1cm47CiAKKyAgICBTdHJpbmcgcGFnZVVSTCA9IG1fZnJh bWUtPmRvY3VtZW50KCktPnVybCgpOworICAgIGlmICghSWNvbkRhdGFiYXNlOjpwYWdlQ2FuSGF2 ZUljb24ocGFnZVVSTCkpCisgICAgICAgIHJldHVybjsKKwogICAgIEtVUkwgaWNvblVSTCh1cmwo KSk7CiAgICAgU3RyaW5nIHVybFN0cmluZyhpY29uVVJMLnN0cmluZygpKTsKICAgICBpZiAodXJs U3RyaW5nLmlzRW1wdHkoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29u L0ljb25EYXRhYmFzZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJh c2UuY3BwCmluZGV4IDM5ZGIwNjcuLmRhM2ZlZTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVy L2ljb24vSWNvbkRhdGFiYXNlLmNwcApAQCAtOTksMTEgKzk5LDYgQEAgc3RhdGljIEljb25EYXRh YmFzZUNsaWVudCogZGVmYXVsdENsaWVudCgpCiAgICAgcmV0dXJuIGRlZmF1bHRDbGllbnQ7CiB9 CiAKLXN0YXRpYyBpbmxpbmUgYm9vbCBwYWdlQ2FuSGF2ZUljb24oY29uc3QgU3RyaW5nJiBwYWdl VVJMKQotewotICAgIHJldHVybiBwcm90b2NvbElzSW5IVFRQRmFtaWx5KHBhZ2VVUkwpOwotfQot CiAvLyAqKioqKioqKioqKioqKioqKioqKioqKioKIC8vICoqKiBNYWluIFRocmVhZCBPbmx5ICoq KgogLy8gKioqKioqKioqKioqKioqKioqKioqKioqCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuaCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29u L0ljb25EYXRhYmFzZS5oCmluZGV4IGI1OTM3NjQuLjc2M2FkMGQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oCkBAIC0yOCw2ICsyOCw3IEBACiAjZGVmaW5lIElj b25EYXRhYmFzZV9oCiAKICNpbmNsdWRlICJJY29uRGF0YWJhc2VCYXNlLmgiCisjaW5jbHVkZSAi S1VSTC5oIgogI2luY2x1ZGUgIlRpbWVyLmgiCiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNp bmNsdWRlIDx3dGYvSGFzaFNldC5oPgpAQCAtMTM3LDYgKzEzOCwxMCBAQCBwdWJsaWM6CiAgICAg dmlydHVhbCBib29sIGlzT3BlbigpIGNvbnN0OwogICAgIHZpcnR1YWwgU3RyaW5nIGRhdGFiYXNl UGF0aCgpIGNvbnN0OwogICAgIHN0YXRpYyBTdHJpbmcgZGVmYXVsdERhdGFiYXNlRmlsZW5hbWUo KTsKKyAgICBzdGF0aWMgYm9vbCBwYWdlQ2FuSGF2ZUljb24oY29uc3QgU3RyaW5nJiBwYWdlVVJM KQorICAgIHsKKyAgICAgICAgcmV0dXJuICFwYWdlVVJMLmlzRW1wdHkoKSAmJiAhcHJvdG9jb2xJ cyhwYWdlVVJMLCAiYWJvdXQiKTsKKyAgICB9CiAKIHByaXZhdGU6CiAgICAgUGFzc1JlZlB0cjxJ Y29uUmVjb3JkPiBnZXRPckNyZWF0ZUljb25SZWNvcmQoY29uc3QgU3RyaW5nJiBpY29uVVJMKTsK 98823 2011-06-27 17:23:17 -0700 2011-06-30 10:27:48 -0700 Removing temporary variable and changing variable's name from pageURL to documentURL icon-loading-webkit-4.diff text/plain 10551 rafael.lobo ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAzMzBmZmRjLi5kMzE5MmM0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYt MjcgIFJhZmFlbCBCcmFuZGFvICA8cmFmYWVsLmxvYm9Ab3BlbmJvc3NhLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMb2NhbCBmaWxlcyBjYW5u b3QgbG9hZCBpY29ucy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTYyNDU5CisKKyAgICAgICAgQWRkZWQgYSBsYXlvdXQgdGVzdCB0byB2ZXJpZnkgaWYg dGhlIGZhdmljb24gaXMgYmVpbmcgbG9hZGVkIGZvciBsb2NhbCBmaWxlcywKKyAgICAgICAgYXMg dGhlIHByZXZpb3VzIHBvbGljeSBvbmx5IGFsbG93ZWQgaXQgdG8gcGFnZXMgd2hvc2UgcHJvdG9j b2wgd2FzIGh0dHAgb3IgaHR0cHMuCisKKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9mYXZpY29u LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9yZXNvdXJjZXMvYmFzaWMucG5n OiBBZGRlZC4KKwogMjAxMS0wNi0yNyAgSmVzc2llIEJlcmxpbiAgPGpiZXJsaW5AYXBwbGUuY29t PgogCiAgICAgICAgIFdlYktpdFRlc3RSdW5uZXIgbmVlZHMgYW4gaW1wbGVtZW5hdGlvbiBvZiBh bGxvd1JvdW5kaW5nSGFja3MuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRl ci9mYXZpY29uLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmlj b24tZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdhNzcz ZjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29u LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK2Zhdmljb24uaHRtbCBoYXMgTUlNRSB0eXBl IHRleHQvaHRtbAorYmFzaWMucG5nIGhhcyBNSU1FIHR5cGUgaW1hZ2UvcG5nCitUaGlzIHRlc3Qg cmVxdWlyZXMgRHVtcFJlbmRlclRyZWUgdG8gc2VlIHRoZSBsb2cgb2Ygd2hhdCByZXNvdXJjZXMg YXJlIGxvYWRlZC4gQSBmYXZpY29uIHNob3VsZCBiZSBsb2FkZWQgZm9yIGxvY2FsIGZpbGVzLCBz byAiYmFzaWMucG5nIiBzaG91bGQgYmUgZGlzcGxheWVkLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9wcmVsb2Fk ZXIvZmF2aWNvbi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNiYTI2 YzAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29u Lmh0bWwKQEAgLTAsMCArMSwxNiBAQAorPGh0bWw+Cis8aGVhZD4KKzwvaGVhZD4KKzxsaW5rIHR5 cGU9ImltYWdlL3BuZyIgaHJlZj0icmVzb3VyY2VzL2Jhc2ljLnBuZyIgc2l6ZXM9IjY0eDY0IiBy ZWw9Imljb24iIC8+Cis8Ym9keT4KKzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuZHVtcFJlc291cmNlUmVzcG9uc2VNSU1FVHlwZXMoKTsKKyAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuc2V0SWNvbkRhdGFiYXNlRW5hYmxlZCh0cnVlKTsKKyAgbGF5b3V0VGVz dENvbnRyb2xsZXIucXVldWVSZWxvYWQoKTsKK30KKzwvc2NyaXB0PgorVGhpcyB0ZXN0IHJlcXVp cmVzIER1bXBSZW5kZXJUcmVlIHRvIHNlZSB0aGUgbG9nIG9mIHdoYXQgcmVzb3VyY2VzIGFyZSBs b2FkZWQuIEEgZmF2aWNvbiBzaG91bGQgYmUgbG9hZGVkIGZvciBsb2NhbCBmaWxlcywgc28gImJh c2ljLnBuZyIgc2hvdWxkIGJlIGRpc3BsYXllZC4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL3Jlc291cmNlcy9iYXNpYy5wbmcgYi9MYXlv dXRUZXN0cy9mYXN0L3ByZWxvYWRlci9yZXNvdXJjZXMvYmFzaWMucG5nCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM1 NzE3Y2NhNThmOTdjNzljM2QzMjRlODM1N2I0YzRmN2IxZTE0NjQKR0lUIGJpbmFyeSBwYXRjaAps aXRlcmFsIDM5NjEKemNtVi08NH5Gb0dQKTxoOzNLfExrMDAwZTFOSkxUcTAwMXhtMDAxeHUxXkBz NlJ8NUhtMDAwMDZWb09JdjBSOH59CnowUkhQMylQZXYyMDEwcU5TI3RtWTA3dzc7MDd3OHYkIWs2 VTAwMFNnYTZ4QVAwMDF4bTAwMXhtJmhDcz8wMDBpNgp6TmtsPFpYeGBQRFltZ2pRYjtwMUEtdE0w RiZnXkAmXjIoQWUyPzslbjM5XkZgSU17JkFCUkl2STZlZnZOS3RiWSkKelQ/VWhvUEB5MHB1MmVx Y1ZGSDF8Tnc3b2whM0JtR05GY19idlV4YTtFTCNHfShuXyt0VEozN3p5UiRSWHVYfUdrCnpia0ZT VUwpSHJYZztSQl5kd1AwJHt7TVVhPWlKKztUVWN4UGJ2RWI0eHt3ZTtHPFIyUStzKEZiP1RhdmE7 I2F2dwp6OCklc1ZtVG1qKC1VUXVybFhgUkN7PDM2I0RGUHwqY0VDPjR2ejs0P3FGZm50dmJrT3Aj YFMxJVctXj5PSktGfUAKejAyK3U+WnwpbndUcT09RUNYait4c2tAfmVGV2MqdWRmejN6Pnwzb0I5 bT9eOSVvTDFwaWJ9X1VIRExgTWBALXItCnpUY2VOSWg0RjdSTXZmbmRZUEFJKlQ7V1laPm41XnAw JlMhMlBec2o1dyhxLUJ5NGVxUGJaX3VfSGVGVGo9LURDPgp6NG5kPnw7K1A8YzNCczYwbkN2JSMy PHkrXylKN1oxOX03KHNvRGcmNF9lQXNLQytkP2t3SUc8VTBnYVNNbCMoem4KejNWe143MWwrRGBa Z2ApWURTYyshT0o3O3V4QCYoOT1AUHs7ZXh3T1BvZEF5X3szeWxgV0JmM3A1a35reUApXktqCnpr aWomJGcoQ3x4NHR8IWMpJGF9SkdpUFZWaj9NYVdiQms/Njspe3tFWGNjTm9DYiNYWHsmTjRPPy1a UWUmVD17SAp6Y0lBcWMzSSY0TGZKbjJgVDh4IXc+KTtyUnFZUkV4SU1VIUtnSG5QPjg+fEtHXnww OWVUT0UhK2RaU2d4X0JvI1gKenI9amRDOX5wYzg3WlohcVhYYiQjOzBxeio3bX0yLTlgTk5vKkl0 el5fQzRIe2JOZjVgJmtGNzUkPm9iPVRuQl9rCnpVPXZVcHZ9NGk2cHBgQGBNWFVfMkJaOyZgRE1f VDAwa3pnNWpnSj5yV3YlbnROYENJcDlXfUxackxnaDY+RUVqfgp6Pld4JVZgalFBViFUMD5lPnUk PUgkYDFAd3ZYeEBiWClHNFpaZ3lVTTlidjNuQmRASWApKUxud3BxbkdFbHRqdHwKenlwakAkSyZS NnxhciohMERqdVhVR2w7SilFN2RkSXgzR0R+NUhxNzZPOV9aSkphI1FQJHJsS0tFYlA4XlNHTCZr Cnp6XjJ8fXJFQm1randfTUVwP2AySThDVCZzM2IqTT47aT8yXkF7Jnt3NUk5bnpNQ3oqVEY5bXBv aTFOVDB4PVJQaAp6RUYzVDNSUTQ3M3pVRUpXMD8re3pmaF56JUE+X0lVMnE5ISkqUkl9PGFfQElI XiVnN1Q0UUZzMWYjV0V3Y0lmVGoKemkwZTJsO0V0M3lOfXwkekI/WW9NQD1fd0RLJjhHa19kKUQq VjZfWEAyZW5BfCY8VlFwJEZmO3otalV6X0B8I2w8CnpyRjVHQ2x4Vi1lU19HUVhzZFI3cT0wR0pr Jl5oPSMlOEBQaWEmVHQmODV8eyg1cUE+Y3N0TFJXSFVUY0FLI0J5bwp6NVh0dlZpYCpgdk11QGRC UWJ+am08VF9gYDxtI0BmWWA4UEs7cXQ5MV8jJSk4Kz9BTnVpaCEoS3tufEdjSkAyYWkKek8+O3N5 WUg0JkdNSjZpPD9Camd2S21MfVpoYVNUYiVZalFOVFkjbUlaUXhtUXorJFAzSlBYdDFSKD5TO1Yj JH1NCnp1dWZPbS1UMEN9T0Y8Vj5Vbk0yRSNeXmk2YWBfKU5fN15nbG9KfXNTQiN4N35RaUBENSF0 SCNUbGYoRChnS3ZJYAp6STBfUz4yJjRkbk5FU3J0ZWdacnQwJDIrezchcz0tUX5CI3pZPzRUMj1q MXw0QG84fCVue3IhVGBpZkxPY182bmsKejNNKFRaZHRVajUtfE9xPjluNi07bEpLaVUmeHdRLWp3 Mkd1RDFsZTMoSiUpJWNKTjF0d25iPldOWDNke2FVQTFeCnowbk1APWQhMWxha34ze3B0RTJaY1VO bD5CZHhxe3hhcHFFQW1KMk5jJkRsMVc/WU5fdWkjI19Jckx0Jk5tYypxfQp6MnFfUlUoWDUqX09w VHZOJH02UGVTWk5rKEVxKWpoI19fVW1eN1dIK2JrJnczcHdpck5WaFk4eGZZK1ZmeGNTTy0Kejxl TFBYQ2llQ1NpMlJQMV9ZZWV8XjV5WkNaYnxobTlmZmpMUVU8TjBLSlZnSkd4Jj1jcyZnfDBlalNA bVh4UjMoCnp2bjdtVT5PcGB1ZEtwQy1Fei0kUnZMI3cwRlBqeGlOd1RGbVQpa0x1ZE4jZDIjcDxP NVR0RXNUTUVnVzBhezJQeAp6RGd+SyRhdj0hVyhrdyF0THtkP0wqaWIhcDc1bER4QmNWMH5WTjls QDZXbENlNy1PdShUNyQ4TUQybDIxMGJ2eFMKeiRENXd+VmJ8PFcqfD44OERQXmlQbk17aD5CLUto OUdUdUI8KzxQUE5GRGRZNDVtLWpSRF4lV0JzO3FTPG1IZXItCno3UlIrMVRjeSVCMDRrRiUrOUxj WUxUaUlJMkdNd29PbjRybFdBY3RCJTQjQ2w1YSRmQioyTE8/d1JDaXhyQ2YwbQp6TmRtQCMoR3NI LStQTFcwNU8tRHkhJVRQQSVlTFJ7TkxeUXM0ODUkWiZyT0QzYH1YfihwTEUqd0ZDLWd0bkdVUi0K ek9KdlgtRiN9cD90Tn4qenI0MSl9Xng9UEp8NkJlcjEqOGNoalVSKzhIaGxVc2tNbzxhbyNmKT8w X0FtX1hGVFk5CnpTTXlWJlc7eVdpb0RWIytFQ1FLfm1xUiNNMyZ2VzYwY2tBODdfYnM2KChvIW4l XiMhZ00+TjhhU2BlaG08dFNPSwp6RGFocEhJKU1GaHJuU0x1IzNkbE5NNCtkfmk/azZacEMyVyth RXgzJk9EM0RhYkRibzRyTm1mRzk3bHY8I0xQXjwKejxuJVBjJU1nWnxGaXQkdThncSR2c2FqaTw1 fHtSeSptezYhNWghPEUoY0AoYjJJQ1ghNyhlaGFIWVNQe1BOYjYzCnpDSzNzMFpMbiZaPjR8WVZg WmZ+OEY8fjROI2hOSkFUPGooKGp4M0xUZHk9MzM/KmdaZkVeX3s/UGNFKyorTG1ZUQp6bytBNi0p WFVKO3tDYXFfUmlXVmdUO058V0pCeWRHNyZzYCRwdFdmJnpMR1ZKWGpLVm9MSytQcEZHfDJDd358 Uk4KenlieXVzakA5X2JLUndSKjVyNWg3U35jZF8hM0I7VFQ7TXpSazgjc2AyNipvc210UXpDSHRC ZUBnZ1NyYk9lMm0kCnp5V2BkR0xoMEFpbkF1SHJzK1o4VyNGMClzUEYlK3R0cW95WGZyOWtESCUh U35oYD5XJTlfNXBfOSRwMjByNVIpUwp6P3BNZFNgeUdkdjhWQGNvX1F9UnN7ekRVbWshSjUzSzhU V25gckleIUFOXk5Le1pGQlQwenJLVExZeWFDOXc3YG0KemtAKnNTbHQ/RnhiUSsweCVeVyFUPE5e PFZ7YHVBJUFjU0Qrbys0TjVEemFyfmYhY2hgPjd6QkN7PmQhVyo8YGpKCnpmOE9Xc0tZRTxNZFNL N21GI3ppPEowUWZseCVydDVgQz11Uis2IWZOLVN8TmN8SWc+fjNkOGhsZWlmQzBFailrdAp6MEZ9 V2AkUTFCe2gpQWFpb09VRXVNaiZWeT8pezc3RSUycEltJCRyc2trYEwrVXxGQCYrT2p3b15NJGAw PTkhPCYKejBkVl4wQkxEZXNxeHw7b1ooTmZeZCMkcl51PXdFQXhvMlpQT3hoc3pBVk1wVEVCRjVh ZXN2NHVDIWZUNDFxUUZhCnpuYShUcyhGbWZuXk5fU3F7M3dhUU4mO1gxO3N8cS01ZGNhRi1oMkJk LXR6dnpXI0c/YF99dXh7Z0ZPNHgwdzJHMwp6QylAWHltVlc9R3YoeSVydWMzclVBfFJwRnFjcmpT IzYjMlBlbGhRZDUlbk5VTnJZJTglak5xJks8RD1CbFZmU0MKenIwSVR9MmtDTzYtSHRwbC1gZH1N VTR7S2A/cF5sJWA0T0tfLUZBZk9Ac044emFlfCtJZX5MZik+fj5yKUFzRzZHCnpyKystUkFfcyg3 NkBsdlVCT182eHg9XmR2WGFvX0JBZno1ZEc9aGxHTn1PX2swek1fejFmTEt8YCN7bGgwQGxGagp6 PXw9MUd3WGY/JklicyN+Z18kSG0qMjBPVzd3T3NIdjJqYlRiPjhzZCNTMkhFRWgpNSN7STUpcDlQ JTRzb1B0a0MKeilMVWN7QEMlZEFRSnM4X2g5OTxPVkx3VTt3TSojU25GZGl7VEpxVnRyKnVLXkxj azRnPipMK0dadnRUUmp6YTYpCnprPlVEczAlP2NhU3hJMi0qcFl1MFBVYl9odlZBfX0tcU1PUko7 N0tARiNhVTZgVio5QFFIIUA+SHJ6flhBPGB6RAp6JGQpZVpjfXJ0dEVxRUVSQ2l2I31UM2Z1I0kr aF9UQmhidFA3UlBKNEs3VVZiXm9kJX5tZHkxYVdPMz5nd0cmP18KekFPRGQ0NFAqNTdTTHlGUWoy THx3LT4oekp0OXd0cTgjODN7M1B8ZXZ2eGxuOCZxUys2ekc7dHNWfWtxczxgZSpACnpqQERZb1NJ XkFwMWlSdj4waXVPeDk9cVF4akdWN20jfWxuRG9GX1c8SDQzIXs4NSVmOVV3QFRDQXcheyVwfGV4 NAp6ZEZVNyZHeWpjPDg/MHI2bzBxaXdfOztyJFJhYGN1ZlRSQGNleyhOZ2VPfkxGTTs8KVM9bD1X enFvPForYkxGblcKenZUTFJ9dSQoe3wxcX1xeilYRGVBdkJ6ZURgYUVqbGQtUWMzcm43NjdZKnZ4 VXk1I2ExM2RKbj5MV1dYRmE+ZUZoCnolSmJoeCprfjFqVURxcnZuVilgcW1NMCNXPUkob1V2aXE3 Y0hAdk5uK2RncHhwWnhPZldoOCQ1VXNMRWYoUEUrRwp6dShocU13JWJ9X0dlQjVCYl5OJGw4MkBs fj5jP31JOUMySmczZW1kcGMzbmotQDhQN2tuWFVfaXtsbnp2ZjQxc14KekBCSHUoZVM/e0ZrbD40 LThzPikmUDRNeTA/Y3t4VFpOfCQ7YFVXJDZeMkB1YV5td2EmZjc1I2g9KVd3eENWXkdHCnpRRVJP Z0xURGdaSmJMaHY7QDt4bGs/O0F+eFBOX2x6VjtqJmRQaC0/Q0phVG9IblBOVnZoWShYIWleX00r TH13SQp6OUtsRWFkSztobHp8WWFLQ0daWFJlZkFXT0piMGQ2KkwxTWBzdClGK0whTiFBTkBGb3ox IykmVzxVK1ApYkp0cEgKeih6YlNFQHRGZihEKCFncmdrdnx7UXwtUT8lYnooLWVybE1AMkZHdyoh fDx1aTcoQn1QYjdaX3BWb0BZJUNAOzVkCnpkclEzZ2sybXEpN2UpeUVxXnpEZlVnT08xOHNCK2Zq MkUmO3pjRTIzdEdNLX1vN1d8d3JmSElnNEU1QDxnV3VCVQp6aEpRQ1pfMUlWPkpFR2IwVE55dDAz UW5GRnBxa3NxZUFtczRAcD93KlVxIXVxLTMyZkI9MzU4KClQMXtgKSVVZTUKem5eIzxhT0o2R3w5 OUw0VHhhKkk9Tit8KTxNeEgoNyV9bV5zKzFqe01FRlMrSXpwfCY/Q3xAbkRhMWxWMTlVe3NPCnph V1Q5NkI/VWhIbHxCNk1wJFUjM3N4dGFxZ1Z+OVlZK2xrY2tZUStSb352S28keEhXQG5IJnFhPU9l I2h8Q0BUYgp6PCtpfn5CaFdeb0RNfW1HV185QFZrM1F7bV9USEQ8KHpzaT1gQnoyeGpoQGFBNl4r KmtIdEcwP2lgKlM1Q0FqaEoKentvTUhXZWdOdiM3XnleU3pHenpDVjIwMHJidVY2NEVeNyp9bzRe VlomMWJxZ299Ry1VdnA9fVkmRjNyTDsxI2NOCnokXio5dTw/Z2E3aSpAb3M+VXN3Jkd4LUg5VSVE YGltODRkfVRpMjhOSGFScyhMX2lTTD53WXdSPFhkcCRkd31QWgp6eVNrbFhjXzlDfih4Oyh0YEZh V2JEekAlZDRWc2dqNVRaSFIjVSVPQloxLWoyYEklfXdLUXJvQVVvdzIpK3F6K2wKemI8JXMrI0Y5 TT09fWFvSDArRFZwPjkrbWNSV0phb0t7ZWBuMVRaaGdsWF53bGxscylOSyF2MkktPmhgNCo5dXR2 CnpndWVZcmVlO3xQaiRfLV8yV0RUNGNPX1E3Y0NlQ15XYk9BUFI9cUVBMzRoKG4kNnR4UzhmMGlB Ymd7UXBVWChYaAp6e3ZTekByb1cydWlxUVo3MDN+IXFTYWY0QFducHc+RW81UElXZEpmVEZnWXpU RmZBfU9SNTNPPkdCcjlkR0FsN0sKekl4c0xBRz1CTDIwMDFSKU1PYnVnWik5bV5jYGFtTmJZJWND RmZjaFNGKSVHS0hCPlArSXg7bW5GZnVES0ZnaD9XClRNVEgyPjAwMDAwTmt2WFh1MG1qZjRSTlco CgpsaXRlcmFsIDAKSGNtVj9kMDAwMDEKCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggY2M2MWEwOC4uODg1ODkzZCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDExLTA2LTI3ICBSYWZhZWwgQnJhbmRhbyAg PHJhZmFlbC5sb2JvQG9wZW5ib3NzYS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgTG9jYWwgZmlsZXMgY2Fubm90IGxvYWQgaWNvbnMuCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02MjQ1OQorCisgICAg ICAgIFByZXZpb3VzIHBvbGljeSBvbmx5IGFsbG93ZWQgaWNvbnMgZm9yIHBhZ2VzIHdob3NlIHBy b3RvY29sIHdhcyBwYXJ0IG9mIEhUVFAgZmFtaWx5LgorICAgICAgICBDaGFuZ2VkIHRoYXQgdG8g YWxsb3cgdG8gYW55IHVybCB0aGF0J3Mgbm90IGVtcHR5IGFuZCB3aG9zZSBwcm90b2NvbCBpcyBu b3QgImFib3V0Ii4KKyAgICAgICAgQWxzbyBhZGRlZCB0aGlzIGNoZWNrIHdoZXJlIGl0IGF0dGVt cHRzIHRvIHN0YXJ0IGxvYWRpbmcgdGhlIGZhdmljb24sIHNvIGl0IGNhbiBhdm9pZAorICAgICAg ICB3YXN0aW5nIHRpbWUgZG93bmxvYWRpbmcgYSByZXNvdXJjZSB0aGF0IHdvbid0IGJlIHN0b3Jl ZCBhbmQgd29uJ3QgYmUgdXNlZC4KKworICAgICAgICBUZXN0OiBmYXN0L3ByZWxvYWRlci9mYXZp Y29uLmh0bWwKKworICAgICAgICAqIGxvYWRlci9pY29uL0ljb25Db250cm9sbGVyLmNwcDogSXQg bm93IHVzZXMgcGFnZUNhbkhhdmVJY29uIGFuZCBhdm9pZCB0byBkb3dubG9hZCB0aGUgaWNvbiBp ZiB0aGUgcGFnZSBjYW4ndCBoYXZlIGl0LgorICAgICAgICAoV2ViQ29yZTo6SWNvbkNvbnRyb2xs ZXI6OnN0YXJ0TG9hZGVyKToKKyAgICAgICAgKiBsb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuY3Bw OiBNb3ZlZCBwYWdlQ2FuSGF2ZUljb24gdG8gSWNvbkRhdGFiYXNlIGNsYXNzLCBzbyBpdCBjb3Vs ZCBiZSB1c2VkIGJ5IEljb25Db250cm9sbGVyLgorICAgICAgICAqIGxvYWRlci9pY29uL0ljb25E YXRhYmFzZS5oOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6Okljb25EYXRhYmFzZTo6cGFnZUNh bkhhdmVJY29uKToKKwogMjAxMS0wNi0yNyAgSm9zZXBoIFBlY29yYXJvICA8am9lcGVja0B3ZWJr aXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dl YkNvcmUvbG9hZGVyL2ljb24vSWNvbkNvbnRyb2xsZXIuY3BwCmluZGV4IDc3ZDUyZWUuLmQzOWQ2 NzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25Db250cm9sbGVy LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uQ29udHJvbGxlci5jcHAK QEAgLTExMyw2ICsxMTMsOSBAQCB2b2lkIEljb25Db250cm9sbGVyOjpzdGFydExvYWRlcigpCiAg ICAgaWYgKCFpY29uRGF0YWJhc2UoKS5pc0VuYWJsZWQoKSkKICAgICAgICAgcmV0dXJuOwogCisg ICAgaWYgKCFJY29uRGF0YWJhc2U6OnBhZ2VDYW5IYXZlSWNvbihtX2ZyYW1lLT5kb2N1bWVudCgp LT51cmwoKSkpCisgICAgICAgIHJldHVybjsKKwogICAgIEtVUkwgaWNvblVSTCh1cmwoKSk7CiAg ICAgU3RyaW5nIHVybFN0cmluZyhpY29uVVJMLnN0cmluZygpKTsKICAgICBpZiAodXJsU3RyaW5n LmlzRW1wdHkoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25E YXRhYmFzZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuY3Bw CmluZGV4IGU3NzY0MjEuLjE3NWExNjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRl ci9pY29uL0ljb25EYXRhYmFzZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24v SWNvbkRhdGFiYXNlLmNwcApAQCAtOTksMTEgKzk5LDYgQEAgc3RhdGljIEljb25EYXRhYmFzZUNs aWVudCogZGVmYXVsdENsaWVudCgpCiAgICAgcmV0dXJuIGRlZmF1bHRDbGllbnQ7CiB9CiAKLXN0 YXRpYyBpbmxpbmUgYm9vbCBwYWdlQ2FuSGF2ZUljb24oY29uc3QgU3RyaW5nJiBwYWdlVVJMKQot ewotICAgIHJldHVybiBwcm90b2NvbElzSW5IVFRQRmFtaWx5KHBhZ2VVUkwpOwotfQotCiAvLyAq KioqKioqKioqKioqKioqKioqKioqKioKIC8vICoqKiBNYWluIFRocmVhZCBPbmx5ICoqKgogLy8g KioqKioqKioqKioqKioqKioqKioqKioqCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9sb2Fk ZXIvaWNvbi9JY29uRGF0YWJhc2UuaCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25E YXRhYmFzZS5oCmluZGV4IGI1OTM3NjQuLmVhM2Q4YmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRl ci9pY29uL0ljb25EYXRhYmFzZS5oCkBAIC0yOCw2ICsyOCw3IEBACiAjZGVmaW5lIEljb25EYXRh YmFzZV9oCiAKICNpbmNsdWRlICJJY29uRGF0YWJhc2VCYXNlLmgiCisjaW5jbHVkZSAiS1VSTC5o IgogI2luY2x1ZGUgIlRpbWVyLmgiCiAjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRl IDx3dGYvSGFzaFNldC5oPgpAQCAtMTM3LDYgKzEzOCwxMCBAQCBwdWJsaWM6CiAgICAgdmlydHVh bCBib29sIGlzT3BlbigpIGNvbnN0OwogICAgIHZpcnR1YWwgU3RyaW5nIGRhdGFiYXNlUGF0aCgp IGNvbnN0OwogICAgIHN0YXRpYyBTdHJpbmcgZGVmYXVsdERhdGFiYXNlRmlsZW5hbWUoKTsKKyAg ICBzdGF0aWMgYm9vbCBwYWdlQ2FuSGF2ZUljb24oY29uc3QgU3RyaW5nJiBkb2N1bWVudFVSTCkK KyAgICB7CisgICAgICAgIHJldHVybiAhZG9jdW1lbnRVUkwuaXNFbXB0eSgpICYmICFwcm90b2Nv bElzKGRvY3VtZW50VVJMLCAiYWJvdXQiKTsKKyAgICB9CiAKIHByaXZhdGU6CiAgICAgUGFzc1Jl ZlB0cjxJY29uUmVjb3JkPiBnZXRPckNyZWF0ZUljb25SZWNvcmQoY29uc3QgU3RyaW5nJiBpY29u VVJMKTsK 99329 2011-06-30 10:27:54 -0700 2011-07-18 17:15:08 -0700 Patch with ??? bug-62459-20110630102752.patch text/plain 11646 abarth SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDkwMTI5KQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTEtMDYtMzAgIFJhZmFlbCBC cmFuZGFvICA8cmFmYWVsLmxvYm9Ab3BlbmJvc3NhLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMb2NhbCBmaWxlcyBjYW5ub3QgbG9hZCBpY29u cy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYyNDU5 CisKKyAgICAgICAgUHJldmlvdXMgcG9saWN5IG9ubHkgYWxsb3dlZCBpY29ucyBmb3IgcGFnZXMg d2hvc2UgcHJvdG9jb2wgd2FzIHBhcnQgb2YgSFRUUCBmYW1pbHkuCisgICAgICAgIENoYW5nZWQg dGhhdCB0byBhbGxvdyB0byBhbnkgdXJsIHRoYXQncyBub3QgZW1wdHkgYW5kIHdob3NlIHByb3Rv Y29sIGlzIG5vdCAiYWJvdXQiLgorICAgICAgICBBbHNvIGFkZGVkIHRoaXMgY2hlY2sgd2hlcmUg aXQgYXR0ZW1wdHMgdG8gc3RhcnQgbG9hZGluZyB0aGUgZmF2aWNvbiwgc28gaXQgY2FuIGF2b2lk CisgICAgICAgIHdhc3RpbmcgdGltZSBkb3dubG9hZGluZyBhIHJlc291cmNlIHRoYXQgd29uJ3Qg YmUgc3RvcmVkIGFuZCB3b24ndCBiZSB1c2VkLgorCisgICAgICAgIFRlc3Q6IGZhc3QvcHJlbG9h ZGVyL2Zhdmljb24uaHRtbAorCisgICAgICAgICogbG9hZGVyL2ljb24vSWNvbkNvbnRyb2xsZXIu Y3BwOiBJdCBub3cgdXNlcyBwYWdlQ2FuSGF2ZUljb24gYW5kIGF2b2lkIHRvIGRvd25sb2FkIHRo ZSBpY29uIGlmIHRoZSBwYWdlIGNhbid0IGhhdmUgaXQuCisgICAgICAgIChXZWJDb3JlOjpJY29u Q29udHJvbGxlcjo6c3RhcnRMb2FkZXIpOgorICAgICAgICAqIGxvYWRlci9pY29uL0ljb25EYXRh YmFzZS5jcHA6IE1vdmVkIHBhZ2VDYW5IYXZlSWNvbiB0byBJY29uRGF0YWJhc2UgY2xhc3MsIHNv IGl0IGNvdWxkIGJlIHVzZWQgYnkgSWNvbkNvbnRyb2xsZXIuCisgICAgICAgICogbG9hZGVyL2lj b24vSWNvbkRhdGFiYXNlLmg6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNl OjpwYWdlQ2FuSGF2ZUljb24pOgorCiAyMDExLTA2LTMwICBEYW4gQmVybnN0ZWluICA8bWl0ekBh cHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRlbGUgUGV0ZXJzb24uCkluZGV4OiBT b3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uQ29udHJvbGxlci5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkNvbnRyb2xsZXIuY3BwCShyZXZpc2lv biA5MDEyOSkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25Db250cm9sbGVyLmNw cAkod29ya2luZyBjb3B5KQpAQCAtMTEzLDYgKzExMywxMCBAQCB2b2lkIEljb25Db250cm9sbGVy OjpzdGFydExvYWRlcigpCiAgICAgaWYgKCFpY29uRGF0YWJhc2UoKS5pc0VuYWJsZWQoKSkKICAg ICAgICAgcmV0dXJuOwogCisgICAgQVNTRVJUKCFtX2ZyYW1lLT50cmVlKCktPnBhcmVudCgpKTsK KyAgICBpZiAoIUljb25EYXRhYmFzZTo6cGFnZUNhbkhhdmVJY29uKG1fZnJhbWUtPmRvY3VtZW50 KCktPnVybCgpKSkKKyAgICAgICAgcmV0dXJuOworCiAgICAgS1VSTCBpY29uVVJMKHVybCgpKTsK ICAgICBTdHJpbmcgdXJsU3RyaW5nKGljb25VUkwuc3RyaW5nKCkpOwogICAgIGlmICh1cmxTdHJp bmcuaXNFbXB0eSgpKQpJbmRleDogU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFi YXNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0 YWJhc2UuY3BwCShyZXZpc2lvbiA5MDEyOSkKKysrIFNvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29u L0ljb25EYXRhYmFzZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTk5LDExICs5OSw2IEBAIHN0YXRp YyBJY29uRGF0YWJhc2VDbGllbnQqIGRlZmF1bHRDbGllbnQKICAgICByZXR1cm4gZGVmYXVsdENs aWVudDsKIH0KIAotc3RhdGljIGlubGluZSBib29sIHBhZ2VDYW5IYXZlSWNvbihjb25zdCBTdHJp bmcmIHBhZ2VVUkwpCi17Ci0gICAgcmV0dXJuIHByb3RvY29sSXNJbkhUVFBGYW1pbHkocGFnZVVS TCk7Ci19Ci0KIC8vICoqKioqKioqKioqKioqKioqKioqKioqKgogLy8gKioqIE1haW4gVGhyZWFk IE9ubHkgKioqCiAvLyAqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTg2Miw2ICs4NTcsMTEg QEAgU3RyaW5nIEljb25EYXRhYmFzZTo6ZGF0YWJhc2VQYXRoKCkgY29ucwogICAgIHJldHVybiBt X2NvbXBsZXRlRGF0YWJhc2VQYXRoLnRocmVhZHNhZmVDb3B5KCk7CiB9CiAKK2Jvb2wgSWNvbkRh dGFiYXNlOjpwYWdlQ2FuSGF2ZUljb24oY29uc3QgS1VSTCYqIHVybCkKK3sKKyAgICByZXR1cm4g IXVybC5pc0VtcHR5KCkgJiYgIXByb3RvY29sSXModXJsLCAiYWJvdXQiKTsKK30KKwogU3RyaW5n IEljb25EYXRhYmFzZTo6ZGVmYXVsdERhdGFiYXNlRmlsZW5hbWUoKQogewogICAgIERFRklORV9T VEFUSUNfTE9DQUwoU3RyaW5nLCBkZWZhdWx0RGF0YWJhc2VGaWxlbmFtZSwgKCJXZWJwYWdlSWNv bnMuZGIiKSk7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2Uu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2Uu aAkocmV2aXNpb24gOTAxMjkpCisrKyBTb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0 YWJhc2UuaAkod29ya2luZyBjb3B5KQpAQCAtMjgsNiArMjgsNyBAQAogI2RlZmluZSBJY29uRGF0 YWJhc2VfaAogCiAjaW5jbHVkZSAiSWNvbkRhdGFiYXNlQmFzZS5oIgorI2luY2x1ZGUgIktVUkwu aCIKICNpbmNsdWRlICJUaW1lci5oIgogI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVk ZSA8d3RmL0hhc2hTZXQuaD4KQEAgLTY1LDYgKzY2LDcgQEAgY2xhc3MgSWNvbkRhdGFiYXNlIDog cHVibGljIEljb25EYXRhYmFzZQogcHVibGljOgogICAgIHN0YXRpYyB2b2lkIGRlbGF5RGF0YWJh c2VDbGVhbnVwKCkgeyB9CiAgICAgc3RhdGljIFN0cmluZyBkZWZhdWx0RGF0YWJhc2VGaWxlbmFt ZSgpIHsgcmV0dXJuICJXZWJwYWdlSWNvbnMuZGIiOyB9CisgICAgc3RhdGljIGJvb2wgcGFnZUNh bkhhdmVJY29uKGNvbnN0IEtVUkwmKSB7IHJldHVybiA/Pz87IH0KIH07CiAjZWxzZSAKIApAQCAt MTM3LDYgKzEzOSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIGJvb2wgaXNPcGVuKCkgY29uc3Q7 CiAgICAgdmlydHVhbCBTdHJpbmcgZGF0YWJhc2VQYXRoKCkgY29uc3Q7CiAgICAgc3RhdGljIFN0 cmluZyBkZWZhdWx0RGF0YWJhc2VGaWxlbmFtZSgpOworICAgIHN0YXRpYyBib29sIHBhZ2VDYW5I YXZlSWNvbihjb25zdCBLVVJMJik7CiAKIHByaXZhdGU6CiAgICAgUGFzc1JlZlB0cjxJY29uUmVj b3JkPiBnZXRPckNyZWF0ZUljb25SZWNvcmQoY29uc3QgU3RyaW5nJiBpY29uVVJMKTsKSW5kZXg6 IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VM b2cJKHJldmlzaW9uIDkwMTI5KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNv cHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDYtMzAgIFJhZmFlbCBCcmFuZGFvICA8cmFmYWVs LmxvYm9Ab3BlbmJvc3NhLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBMb2NhbCBmaWxlcyBjYW5ub3QgbG9hZCBpY29ucy4KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYyNDU5CisKKyAgICAgICAgQWRk ZWQgYSBsYXlvdXQgdGVzdCB0byB2ZXJpZnkgaWYgdGhlIGZhdmljb24gaXMgYmVpbmcgbG9hZGVk IGZvciBsb2NhbCBmaWxlcywKKyAgICAgICAgYXMgdGhlIHByZXZpb3VzIHBvbGljeSBvbmx5IGFs bG93ZWQgaXQgdG8gcGFnZXMgd2hvc2UgcHJvdG9jb2wgd2FzIGh0dHAgb3IgaHR0cHMuCisKKyAg ICAgICAgKiBmYXN0L3ByZWxvYWRlci9mYXZpY29uLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L3ByZWxvYWRlci9yZXNvdXJjZXMvYmFzaWMucG5nOiBBZGRlZC4KKwogMjAxMS0wNi0zMCAgTmF0 ZSBDaGFwaW4gIDxqYXBoZXRAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIGNo cm9taXVtIHRlc3QgZXhwZWN0YXRpb25zIHVwZGF0ZSBhZnRlciByOTAxMDEuCkluZGV4OiBMYXlv dXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29uLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29uLWV4cGVjdGVkLnR4dAkocmV2aXNp b24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24tZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMgQEAKK2Zhdmljb24uaHRtbCBoYXMgTUlNRSB0eXBl IHRleHQvaHRtbAorYmFzaWMucG5nIGhhcyBNSU1FIHR5cGUgaW1hZ2UvcG5nCitUaGlzIHRlc3Qg cmVxdWlyZXMgRHVtcFJlbmRlclRyZWUgdG8gc2VlIHRoZSBsb2cgb2Ygd2hhdCByZXNvdXJjZXMg YXJlIGxvYWRlZC4gQSBmYXZpY29uIHNob3VsZCBiZSBsb2FkZWQgZm9yIGxvY2FsIGZpbGVzLCBz byAiYmFzaWMucG5nIiBzaG91bGQgYmUgZGlzcGxheWVkLgpJbmRleDogTGF5b3V0VGVzdHMvZmFz dC9wcmVsb2FkZXIvZmF2aWNvbi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3Qv cHJlbG9hZGVyL2Zhdmljb24uaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3Qv cHJlbG9hZGVyL2Zhdmljb24uaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNiBAQAorPGh0 bWw+Cis8aGVhZD4KKzwvaGVhZD4KKzxsaW5rIHR5cGU9ImltYWdlL3BuZyIgaHJlZj0icmVzb3Vy Y2VzL2Jhc2ljLnBuZyIgc2l6ZXM9IjY0eDY0IiByZWw9Imljb24iIC8+Cis8Ym9keT4KKzxzY3Jp cHQ+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgIGxheW91dFRlc3RDb250 cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcFJlc291cmNl UmVzcG9uc2VNSU1FVHlwZXMoKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIuc2V0SWNvbkRhdGFi YXNlRW5hYmxlZCh0cnVlKTsKKyAgbGF5b3V0VGVzdENvbnRyb2xsZXIucXVldWVSZWxvYWQoKTsK K30KKzwvc2NyaXB0PgorVGhpcyB0ZXN0IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVlIHRvIHNlZSB0 aGUgbG9nIG9mIHdoYXQgcmVzb3VyY2VzIGFyZSBsb2FkZWQuIEEgZmF2aWNvbiBzaG91bGQgYmUg bG9hZGVkIGZvciBsb2NhbCBmaWxlcywgc28gImJhc2ljLnBuZyIgc2hvdWxkIGJlIGRpc3BsYXll ZC4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL3Jl c291cmNlcy9iYXNpYy5wbmcKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpDYW5ub3QgZGlzcGxheTogZmlsZSBtYXJrZWQg YXMgYSBiaW5hcnkgdHlwZS4Kc3ZuOm1pbWUtdHlwZSA9IGFwcGxpY2F0aW9uL29jdGV0LXN0cmVh bQoKUHJvcGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvZmFzdC9wcmVsb2FkZXIvcmVzb3Vy Y2VzL2Jhc2ljLnBuZwpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fCkFkZGVkOiBzdm46bWltZS10eXBlCiAgICsgYXBwbGlj YXRpb24vb2N0ZXQtc3RyZWFtCgoKaVZCT1J3MEtHZ29BQUFBTlNVaEVVZ0FBQURBQUFBQXdDQVlB QUFCWEF2bUhBQUFBQm1KTFIwUUEvZ0QrQVA3ckdOU0NBQUFBQ1hCSQpXWE1BQUFCSUFBQUFTQUJH eVdzK0FBQUFDWFp3UVdjQUFBQXdBQUFBTUFETzdveFhBQUFPb2tsRVFWUm8zdFdhYTVBY1YzWEhm L2ZlCjdwNzN6dXg3dGZMS2tpMEpDVDJNQ2JLREVUallnTTBqT01XYkZDYUpVMEJCNG9wZEJwT1FV S0VnSWE1VVB1UmhBb0hDU2JCRDhjRUYKaGhoSUlNYWdzbms0aml4YkFzblNTcks4V3UxcTM3dXpN OU92ZTI4K2RNL3M3RVBXQ3Z5RlUzV3FlM3A2ZXY3L2UvN24zTnVuVzFocgorWFUyNThXNmtCQkNO SGRYYk52TnRtL3RpekI2NGxlNVJodG9tUUtXYmZ2dDNnVGRkSk42YzkvK3NtUitLUUlwOEhiQVR0 T3puUnVLCm9sd1pkTEs1WGhQRzlXaHhaaktjT0R2YkJ0b0FHb2hUYis0YndGd3FrVXNta0lKWHFi dWxIUy9iNjVaNjN5Vzk3RnV0RlIzSzhZVE0KRkl4d2lrckhnVFZoRFIzN3d1cElXNk9QMklYeGJ6 UkdqaCtJYXJVRklGemhUVUxySnJKdUFtMmo3bENwNUh1Mjc3dFR1dGtQZFhSdgo4SG8yWFZYdTZO a2lFUTVCcEFuaW1DQ0tDY0tZUnBqc040SUk2OC9nMUVZYnloOExUUlNjRUhQajkwVHo0eWZxa3pP MUlKaXZBWTJVClNKU1NNQzhLZ1JTOEJOeXVhMjU0bjVzcGZXYmJTMTlaM3JwcmZ3N3BFc1V4ZnFR SlFwMEFqeUw4S01ZUFkvd3dvaEZHK0VIeUdjQmcKa01FMHVZVWpDeklPZnBhdDFlOE42ak5uWjhl T3pmcHpjNHR0Uk9LTGtiaG9GV3BLSnJmdHF2NXkvNmJ2Rkp6Y3puSTU2M2JsaXBRSwpCWUxZZ0Vp ejAxcU1sV2pyNEJpTG93eU9VampTNENpRFVvSklHNndGN2ZXdzJQMWJIWTQvZXFOVngvWTVudnlu b2V3ckh4bDcvaGNUCmk5Tm41b0VhNEFzaDRoZVNsTE1lOE9VOTExNlZMZlk5M0pWeit6djZ6d3J0 NThubGkyUmNCNFJHWUJOUUdyUmowY2FnbFVRclJhd00KcmlPSnRFUXBTYVNUQWJYV0lvMlBGMVps cmZQYVNuN3UwQjAxdFhDbHNQRzk2ZCtyTk9xTlZGTDZrZ2cwd2ZmOHh1dHV5cGJLRHd4VQpzcFZp ejJrc0ZzeHVkbDU5SFdHc1d5T3ZyU1hXRXRja29Kc2pycFJFeWdTOGtoS0pRS2ZUUVhINi8rZ3FI cVF4TTRpdkxpdlZNOTIzCnNIbkhFRE9qSDBzSmlEWThkaTA1eVJjSWdDenN2blpYdHRqeHdLYmVZ cVZyOEN5T0s1SENvWDl3S3hsWDRUa0t0K2xLNGFvRWFDSWIKbWJnUU9GS2lST3FxN1M4RmVJV0k4 c0FadWtzSHlDd2NMK0JVOWhYM3Z1WlBnQUxRQVJTQkxPQUlJZVM2Q0FnaFpHSFhydDZPY3U5MwpO L1VXSytVTlozQWNnZU1vckhibzdkK0k2emd0NEk2VU9FcWkwbjBsQmJJNThsSWlwVUNsdmpUM1Fl eDBZTFVMMWdlMVNQZlFDYnJ6Cng3SlphZDZSMy83eW0xTVNwWFNiQVpSb3Y4QmFCSnJTcVhSdisr WkFKVGZRT2ZnOHlwRXQ5M0p3WnZnWkhDV1RFWGNTNEtvSnZBVTIKQVM2a1FJb0V1QkRKOTAyTDND NmlSb2kxTVZKSmhCRGtPbWZKNU9xdXFteTRNN3ZoOHEwcCtDS1FCOXlWbU5lS2dLeGMvZG8zRmoz dgpxdjVOYzBJNWFtbDBIVVVtS3dqczQzenJQLzZXbzRjZXd4SExnVXNwVzRDbGtHM2dXWExBWXFt TFBBdlQ1VlorSlBsaXlaZW5zRTVYCjJkMzRrajlMUVJkU1h5VWx1Y2JvTzhWeStSODI5aGN5bVp4 TkxxNGtqcE80VW9wTU1jTHRmSnFUdy9memcyOStpVGdLRTZBSXBBQ0UKU0JaRTZYNENQQ1VDV0F0 QkdCS3JIRlA1NjFsc2traGw1K1JDU3ZGcGNNcWJjbHRlK29wVVBua2d0eklLS3lNZ2UxNzVodC9y NitnZAp6SmJIa3ZDclJNK0poQlNPSXhMSktJRlhyTkV3QnpoMjhFZUl0a1ZvdTBqRmltTnhIT09I QWMyeUhudWRZRldTTTIxVnE2UDNORjQwClczSjdodTVLY2VaU1g1WUxMUUxOMlRhWDdiaWptSXM4 TnhPbHNtaFdsc1NsVWdncEVETFJySnMxVEkyZlNNb3JwT0pZYVJackxYNFkKRXNieHNtL3k5Wk4w ZE5XV0lxRFMzSEZpQ3NXemdOZWQzYmo1eW5Ua213U2NKdmIyQ0lqOGpwZjNFQVNiOHVYeGxtNUo5 UzBkaFhKVgpVZ2F0cEQ3djRsY3orSXNacW5NekJINGRtMDVvMlBhMXN5V01ZK3BCZ0RaNkdVVVpM ZExKVWJJbFdpTXZteFZNU2JLbE9WeTlXSEI2Ck5yMCt4ZXFsQkZ4QUNpRkUrMFFtY3ZueTJ5b0Zt WGR5SVFqWjBpeENvRVJTVVlMWVVEMTNGZnV1ZXlPaE5nUmhUS2FqRTl3c1lSaGoKck1WYWc3R0dL SXFwK1FGaEZLWEhtNTc4WWRmc1Q5bTRjd0lwWmFvMW1VeUsyaVRWU2hveTNqeFIzSHNqOEM4cDhH VVJXRWJBSzFUZQpWNnFzZFNlVi9LbTFGc2UxR0Z1bDBqY0FLcE11MmlMOEtFSnJnellHMFhpTVRI Z2VvV1B5amliS2FpTFhFT2NNc2RiRTJvQzFkSFNjCnBWeHhFa2tDeG9MUkVxTVYycmpvMkJCM1Zn bkRUSGZYeTdiZjdraGRWNDRNdmF5c3owMkdYL3YyL2FlZmROcjFMeVFiYzVrT3JKMUwKWk5BY01R TmFhS3dCWXl5bERTZDU5T0YvWi85Yi9qQUZwQWtqalIrRUxEWjgrak9QODV1dm5lVGk1Z0xsZFp4 blBPaDhWL05UbzJZNQo4UENjRHp5ekxBS1pqSmRET0ZnTHhscUVBV2tzeGhpd0VpdlM4Q3BEelIr ajdrYzB3cEJhRUtUTDVTaFpyQ25JNU9RNmdQMXlwclhCCmI4UWxJTGRFb0tmSGk3UVJKNThmSmJk d2pGdytTeWFid1hPZEpIbWx4RmhOSEVlRVljVE1UTURrOURUQ3l4Q0dtakJPUE5JYWM0bDMKcVZw YmxCS1g5cHZZZW9CcUVTaDNYZEhqWlFvRzR4UHJHRC93TVRZbWloVk9wSkxTSmhJSmFXMndhcHJw aVhFNitqWVN4REZoSEJQRgptaWpXWE93bUtZNHNqMzE3a3AvLzd3S25qeTV5L3F4UExxOFkycFpu NjU0aSs5L1V5OURXL0hwNHRGV2g0UHhjNEY4dU80dVhzUmc0CktNZWd0V2t0dnBJMWpHaFZDV3RD R2cwZkwwckFKN2VTU1M2OEVJSG5qdFg0eHo4OXp2a1JmOW54V2pYbTJNRUZqaDFjNER2M2ozSFQK ZXdaNDd4MlhYemd5TnVsNHRJUTZmK1pNSTQ1Q3UrUFY3MExwMTlLWTJVMTFxcGZRdDhTUlRqeE9Y TWNhclExaFdvR0M5TDQzVE1sYwppTUJEWHg3bGs3Y2VYZ1YrcFJsaitlNVh4N2o3SFllWUdnOHVN UGJKeGxuK1F4T0ZrV2J2R3o2SWtvTDYzRFNISC8xWFN2MVBvWU1DClFYMEhRcHduV3g0aEREcVIr UkorbEVnbmpIUWFpWGpOSERqNjVBSVBmdjc1MWh3Z2hHRHJuaUpYN0NxeVpXZUIybnpNNmFNMW52 N0oKTE5YWlpMWWVmOTduN3o5Nm5MOTZZTS9hTVFEckxEc2d4TG01K1prTitXSWxtZG9MWlhiZCtF RU8vOC9uOFFyRDlHeCtGWldCTFR4LworQUNWd1U3SUZQQ0RpRWluQ1p4MkpGWkdJR2dZN3YyTDR5 M3dwVTZYdDd4L2tOZS9jMkJadGRMYXNqZ1g4NFcvSE9hWm44d0JjUHJvCkl2LzViNlA4OXU5dlhK TkVlNjJ6Y2JENDROUzVaMk0vVE5vZzlTQkNLNDhyOS84QmZuVUw0eWVmeEhnRkJxKyttYzRyOTlF SW9yVHoKa0xSUS9DaUp3RW9DWC8vaUNIT1RFUUJLQ2Q1Nyt5YmU4djdCWmVEUGovamMrZGFEUFB2 VUFoKy9keWZiOTVhV2Z2K2xzOVFXbHEraApoRWdpSUtIVm96VHgvTVJEMCtkK01lK0hFZlVnVEVt RWFDZkw1ZnMvUU9mMjY1TmphYXVrNlg2YkIrbHlvdDJPUERIZjJ0OTdYWVg5CmIrNWQ5djM1RVo5 UDNYYUU2ZkdRZXo5eGdwOStmNG8vK3V4MlhDOGhHUHFHcDM4OHR5SUhoRmtWZ2VyeEl5TlJvN3BR cTlkb0JCR04KSUtRZVJEU0NpTkJLbkhKL0FqNGwxd1NmRUVuN1FORnlBdGJBNk9sRzYvTzFyK3RH T1dJVitJV1pKRUxXd29tbkYrblo0TEZ4UzY1MQozdkRoeFF0SG9DMHB0SW44cjB5UEhQSWJZWnlD VDBqVVcyUVM4QXVUejFHZGZJNkdIN1ptWVQ5S0NMVkw2TnlaQmxGZ1d2TFp1cWQwClFmQkN3QTF2 NitQZHQyOENZUE9PUXV2Y2tlSDZjZ0pwaDl0WlNXRHUySkYvRms3bVE3S3lmVUE0M3RLS05EM0JX RXN3L2lTeStoT1UKcWxHTHQyRTIzRXhzSWRJbW5jaVdMdXA1UzJOa0xYZ1pzU2I0NXZkYVc3ek1P cFloS3lQUXpBTVd4MnU2UG45UGJmU0pXdENXelBVZwpaSEhxRkxVVFh5Y2YvNUQrRFdQMDlsZnA3 ejZNR0gwWTM2OFR4YXQ3VDcwYk0yVHpDa2pxKzdPSHFzelBSS3RHdm1tUGZtT0MrLzdtCkZBQ25q dFpheDFmUHpPa0V1K0tvQWFLRlp4NjczeXlNbks5WHh4T3RMNXduT3ZVMUNyVUhHUm80U0Y5L2xV SWhRNkdRb2JOVHNIbm8KR0Iwei80MklHNnhsZzV1WHRQejRkNmNvVlZ3MnBZQ2tGT3gvY3k5ZGZW N3JuRWNlUE0vbi92d0VvNmVXWkhQbHJzS3lhNlk1c0p4QQpHZ1VOQk5IVXlmZklzY2RtZ3ZvOGF1 Sjc5SFVkcHJOcmxteFdrY202NVBJWkNzVXMrVUtHVWtseXhlWmh5dlBmUjlob0ZZRmQxeXd0Cm1a OStmSlluSHBubTdudDNzdnVhTWplOHJZL2JQbkVGbi96eTdtVWtmdnhmVStnNDBXS2g1TEMxcmF5 MjIxcGlNMEJZUDNYOHVGa1kKLzNCMjZzZHpsaHh4WEVBSzBicnhkbDFGTHUvaHBMZVpyZ3VEL2NQ azUzKzI2b0x2L1BBUWZZT1pkSkRnaTU4YTVvY1BUZkR4eiszawpmWGR0eHN0SStnWXpmUExMdTZu MGVLdCtmOU43QitpL0xMc21nVlc5VVd1dEZVSm9JRmc4ZXZDUjR0N2kzNUh2K2RpNGYzMTV2dllj CkczcEhVWTRtREVXNk5yTEVjYkx3VXlyQ2pTZEoycHBMcGh6QlIvNTZHNS81d00vUnNTWHdEZmQ5 OWhTUFBIaWVYZGQwc1AycUR1YW0KUTU1OXFrcGpNVjRGY25ZeTVFSzJablBYV212U3RuWmo4WmtE WHlydGVQbUVZemZjVSsyK29jdWZPVTErYXBqTEJzZHdYTVB3cWMwWQpQTXI1YzJTOFNXSlJKR2tv TDdkdGUwdTgrNDgzOGVBWFJnajlwS3llT1Y3anpQRWEzM2xnakJleVI3OHhRU2FydVBXam05Y2xv YVpwCmtvY005ZXF4ZzkvUzU0Wi9OenYxMkZna082TFo4bHNaUHZjS1RwNFlvSnJieDN6WHpZenhl a2JuWDBXOWZOMEZML2ptV3dmNTFIMjcKbDlYM3RTeWJWMXgvUzE4ckp4eFhVcXk0NjQvQVNpa0Ix RWFlUGVUTlROeVUyZHE0VXl3ZS94Mi9zcWZjS0Y4dHJYQVJRSlFkSXNvTwpjVEc3L0NVRlB2MlZQ Znp3b1FtT0g2b3krbHlEMlltUWJGN1NNNUJoYUd1ZXExL2R5VXYzbFprY0M3am5JNzlnLzV0NnVl VzJ3VXNqCjBFYWlLVW9iMW1aMStQU1BQdTEwOXQ2WDI5SzRXN2o1VjBYNWpaN09EeFdOMXdrMjZm aUlpOXdkS2lXNDhlMzkzUGoyZmdEcTFSaXAKUkd1K2FGcmZZSWJQZm5VdlhsWXVhd3F2bThBS0Vz MW51anFlbll5cXN6KzR5ODNuSzk3Z0ZhOXh5Z08zQ09YdXNpcUxkZkpDNm5vSApLelA1QlN4ZnVq Q01sYVJXd2x2WGsvbzJPVFZKUkVBUTFldCtOSHprVzNEa2U0RG5sTHU2bldKNUlQKzYwcWVoY1Bs NkNmd3F0dTVYCkRacVRuQkNpT2RuRkpQblJiUGRsNHZtWmFqdy9NK3BYWHpKODROdTZZWXgxMG52 WHhKSTlDK2xNS3JBQ2tXNHg2YmI5M0ZVd0FLeEIKTmVwNkJEQXZ4cE42UmR1VCt0U3pRSVdrcDkr c2RLM1hDbGoraEw3OVNYM3puQXVPWTl2V0IyWmZqSGNsVnI1MnNKS1VaTzMzSkZhOQpMM0VKZjkz S3gxK0p3QnBrYUNOMHNiZFZYcFEzVnY0ZlNaQ212NHJ4aXRFQUFBQWxkRVZZZEdOeVpXRjBaUzFr WVhSbEFESXdNRGt0Ck1UQXRNRFZVTVRZNk1qVTZNRElyTVRBNk1EQWFOSDc1QUFBQUpYUkZXSFJ0 YjJScFpua3RaR0YwWlFBeU1EQTVMVEV3TFRBMVZERTIKT2pJMU9qQXlLekV3T2pBd1JZVUl6UUFB QUFCSlJVNUVya0pnZ2c9PQoK 101240 2011-07-18 17:15:08 -0700 2011-07-21 11:46:23 -0700 Layout test should be skipped for platforms with IconDatabase disabled, and using the test with timeout. icon-loading-webkit-5.diff text/plain 16684 rafael.lobo ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0ZTI5MmFlLi43ODY1YjFhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMDct MTggIFJhZmFlbCBCcmFuZGFvICA8cmFmYWVsLmxvYm9Ab3BlbmJvc3NhLm9yZz4KKworICAgICAg ICBMb2NhbCBmaWxlcyBjYW5ub3QgbG9hZCBpY29ucy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYyNDU5CisKKyAgICAgICAgQWRkZWQgYSBsYXlvdXQg dGVzdCB0byB2ZXJpZnkgaWYgdGhlIGZhdmljb24gaXMgYmVpbmcgbG9hZGVkIGZvciBsb2NhbCBm aWxlcywKKyAgICAgICAgYXMgdGhlIHByZXZpb3VzIHBvbGljeSBvbmx5IGFsbG93ZWQgaXQgdG8g cGFnZXMgd2hvc2UgcHJvdG9jb2wgd2FzIGh0dHAgb3IgaHR0cHMuCisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9mYXZpY29u LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3ByZWxvYWRlci9yZXNvdXJjZXMvYmFzaWMucG5n OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50 eHQ6IFNraXAgdGVzdCAoSWNvbkRhdGFiYXNlIGlzIGRpc2FibGVkKS4KKwogMjAxMS0wNy0xOCAg WW91bmcgSGFuIExlZSAgPGpveWJyb0Bjb21wYW55MTAwLm5ldD4KIAogICAgICAgICBBbmltYXRp b25CYXNlIGFzc2VydHMgaWYgYSB0ZXN0IHRyaWVzIHRvIHBhdXNlIGR1cmluZyB0aGUgZGVsYXkg cGhhc2UKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24tZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9wcmVsb2FkZXIvZmF2aWNvbi1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmNlMTFjNgotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24tZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsMiBAQAorYmFzaWMucG5nIGhhcyBNSU1FIHR5cGUgaW1hZ2UvcG5nCitUaGlz IHRlc3QgcmVxdWlyZXMgRHVtcFJlbmRlclRyZWUgdG8gc2VlIHRoZSBsb2cgb2Ygd2hhdCByZXNv dXJjZXMgYXJlIGxvYWRlZC4gQSBmYXZpY29uIHNob3VsZCBiZSBsb2FkZWQgd2hlbiB0aGUgdXJs IHJlcXVlc3RpbmcgaXQgaXMgYSBsb2NhbCBmaWxlIChodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9NjI0NTkpLCBzbyAiYmFzaWMucG5nIiBzaG91bGQgYmUgZGlzcGxheWVk IGhlcmUuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29uLmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3ByZWxvYWRlci9mYXZpY29uLmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODhkNTdkNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvcHJlbG9hZGVyL2Zhdmljb24uaHRtbApAQCAtMCwwICsxLDE3IEBACis8aHRt bD4KKzxoZWFkPgorPC9oZWFkPgorPGxpbmsgdHlwZT0iaW1hZ2UvcG5nIiBocmVmPSJyZXNvdXJj ZXMvYmFzaWMucG5nIiBzaXplcz0iNjR4NjQiIHJlbD0iaWNvbiIgLz4KKzxib2R5PgorPHNjcmlw dD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgbGF5b3V0VGVzdENvbnRy b2xsZXIuZHVtcEFzVGV4dCgpOworICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wUmVzb3VyY2VS ZXNwb25zZU1JTUVUeXBlcygpOworICBsYXlvdXRUZXN0Q29udHJvbGxlci5zZXRJY29uRGF0YWJh c2VFbmFibGVkKHRydWUpOworICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7 CisgIHNldFRpbWVvdXQoImxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKSIsNDAwKTsK K30KKzwvc2NyaXB0PgorVGhpcyB0ZXN0IHJlcXVpcmVzIER1bXBSZW5kZXJUcmVlIHRvIHNlZSB0 aGUgbG9nIG9mIHdoYXQgcmVzb3VyY2VzIGFyZSBsb2FkZWQuIEEgZmF2aWNvbiBzaG91bGQgYmUg bG9hZGVkIHdoZW4gdGhlIHVybCByZXF1ZXN0aW5nIGl0IGlzIGEgbG9jYWwgZmlsZSAoaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYyNDU5KSwgc28gImJhc2ljLnBuZyIg c2hvdWxkIGJlIGRpc3BsYXllZCBoZXJlLgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9wcmVsb2FkZXIvcmVzb3VyY2VzL2Jhc2ljLnBuZyBiL0xheW91dFRl c3RzL2Zhc3QvcHJlbG9hZGVyL3Jlc291cmNlcy9iYXNpYy5wbmcKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMzU3MTdj Y2E1OGY5N2M3OWMzZDMyNGU4MzU3YjRjNGY3YjFlMTQ2NApHSVQgYmluYXJ5IHBhdGNoCmxpdGVy YWwgMzk2MQp6Y21WLTw0fkZvR1ApPGg7M0t8TGswMDBlMU5KTFRxMDAxeG0wMDF4dTFeQHM2Unw1 SG0wMDAwNlZvT0l2MFI4fn0KejBSSFAzKVBldjIwMTBxTlMjdG1ZMDd3NzswN3c4diQhazZVMDAw U2dhNnhBUDAwMXhtMDAxeG0maENzPzAwMGk2CnpOa2w8Wlh4YFBEWW1nalFiO3AxQS10TTBGJmde QCZeMihBZTI/OyVuMzleRmBJTXsmQUJSSXZJNmVmdk5LdGJZKQp6VD9VaG9QQHkwcHUyZXFjVkZI MXxOdzdvbCEzQm1HTkZjX2J2VXhhO0VMI0d9KG5fK3RUSjM3enlSJFJYdVh9R2sKemJrRlNVTClI clhnO1JCXmR3UDAke3tNVWE9aUorO1RVY3hQYnZFYjR4e3dlO0c8UjJRK3MoRmI/VGF2YTsjYXZ3 Cno4KSVzVm1UbWooLVVRdXJsWGBSQ3s8MzYjREZQfCpjRUM+NHZ6OzQ/cUZmbnR2YmtPcCNgUzEl Vy1ePk9KS0Z9QAp6MDIrdT5afClud1RxPT1FQ1hqK3hza0B+ZUZXYyp1ZGZ6M3o+fDNvQjltP145 JW9MMXBpYn1fVUhETGBNYEAtci0KelRjZU5JaDRGN1JNdmZuZFlQQUkqVDtXWVo+bjVecDAmUyEy UF5zajV3KHEtQnk0ZXFQYlpfdV9IZUZUaj0tREM+Cno0bmQ+fDsrUDxjM0JzNjBuQ3YlIzI8eStf KUo3WjE5fTcoc29EZyY0X2VBc0tDK2Q/a3dJRzxVMGdhU01sIyh6bgp6M1Z7XjcxbCtEYFpnYClZ RFNjKyFPSjc7dXhAJig5PUBQeztleHdPUG9kQXlfezN5bGBXQmYzcDVrfmt5QCleS2oKemtpaiYk ZyhDfHg0dHwhYykkYX1KR2lQVlZqP01hV2JCaz82Oyl7e0VYY2NOb0NiI1hYeyZONE8/LVpRZSZU PXtICnpjSUFxYzNJJjRMZkpuMmBUOHghdz4pO3JScVlSRXhJTVUhS2dIblA+OD58S0defDA5ZVRP RSErZFpTZ3hfQm8jWAp6cj1qZEM5fnBjODdaWiFxWFhiJCM7MHF6KjdtfTItOWBOTm8qSXR6Xl9D NEh7Yk5mNWAma0Y3NSQ+b2I9VG5CX2sKelU9dlVwdn00aTZwcGBAYE1YVV8yQlo7JmBETV9UMDBr emc1amdKPnJXdiVudE5gQ0lwOVd9TFpyTGdoNj5FRWp+Cno+V3glVmBqUUFWIVQwPmU+dSQ9SCRg MUB3dlh4QGJYKUc0WlpneVVNOWJ2M25CZEBJYCkpTG53cHFuR0VsdGp0fAp6eXBqQCRLJlI2fGFy KiEwRGp1WFVHbDtKKUU3ZGRJeDNHRH41SHE3Nk85X1pKSmEjUVAkcmxLS0ViUDheU0dMJmsKenpe Mnx9ckVCbWtqd19NRXA/YDJJOENUJnMzYipNPjtpPzJeQXsme3c1STluek1DeipURjltcG9pMU5U MHg9UlBoCnpFRjNUM1JRNDczelVFSlcwPyt7emZoXnolQT5fSVUycTkhKSpSSX08YV9ASUheJWc3 VDRRRnMxZiNXRXdjSWZUagp6aTBlMmw7RXQzeU59fCR6Qj9Zb01APV93REsmOEdrX2QpRCpWNl9Y QDJlbkF8JjxWUXAkRmY7ei1qVXpfQHwjbDwKenJGNUdDbHhWLWVTX0dRWHNkUjdxPTBHSmsmXmg9 IyU4QFBpYSZUdCY4NXx7KDVxQT5jc3RMUldIVVRjQUsjQnlvCno1WHR2VmlgKmB2TXVAZEJRYn5q bTxUX2BgPG0jQGZZYDhQSztxdDkxXyMlKTgrP0FOdWloIShLe258R2NKQDJhaQp6Tz47c3lZSDQm R01KNmk8P0JqZ3ZLbUx9WmhhU1RiJVlqUU5UWSNtSVpReG1ReiskUDNKUFh0MVIoPlM7ViMkfU0K enV1Zk9tLVQwQ31PRjxWPlVuTTJFI15eaTZhYF8pTl83Xmdsb0p9c1NCI3g3flFpQEQ1IXRII1Rs ZihEKGdLdklgCnpJMF9TPjImNGRuTkVTcnRlZ1pydDAkMit7NyFzPS1RfkIjelk/NFQyPWoxfDRA bzh8JW57ciFUYGlmTE9jXzZuawp6M00oVFpkdFVqNS18T3E+OW42LTtsSktpVSZ4d1EtancyR3VE MWxlMyhKJSklY0pOMXR3bmI+V05YM2R7YVVBMV4KejBuTUA9ZCExbGFrfjN7cHRFMlpjVU5sPkJk eHF7eGFwcUVBbUoyTmMmRGwxVz9ZTl91aSMjX0lyTHQmTm1jKnF9CnoycV9SVShYNSpfT3BUdk4k fTZQZVNaTmsoRXEpamgjX19VbV43V0grYmsmdzNwd2lyTlZoWTh4ZlkrVmZ4Y1NPLQp6PGVMUFhD aWVDU2kyUlAxX1llZXxeNXlaQ1pifGhtOWZmakxRVTxOMEtKVmdKR3gmPWNzJmd8MGVqU0BtWHhS MygKenZuN21VPk9wYHVkS3BDLUV6LSRSdkwjdzBGUGp4aU53VEZtVClrTHVkTiNkMiNwPE81VHRF c1RNRWdXMGF7MlB4CnpEZ35LJGF2PSFXKGt3IXRMe2Q/TCppYiFwNzVsRHhCY1YwflZOOWxANlds Q2U3LU91KFQ3JDhNRDJsMjEwYnZ4Uwp6JEQ1d35WYnw8Vyp8Pjg4RFBeaVBuTXtoPkItS2g5R1R1 QjwrPFBQTkZEZFk0NW0talJEXiVXQnM7cVM8bUhlci0KejdSUisxVGN5JUIwNGtGJSs5TGNZTFRp SUkyR013b09uNHJsV0FjdEIlNCNDbDVhJGZCKjJMTz93UkNpeHJDZjBtCnpOZG1AIyhHc0gtK1BM VzA1Ty1EeSElVFBBJWVMUntOTF5RczQ4NSRaJnJPRDNgfVh+KHBMRSp3RkMtZ3RuR1VSLQp6T0p2 WC1GI31wP3ROfip6cjQxKX1eeD1QSnw2QmVyMSo4Y2hqVVIrOEhobFVza01vPGFvI2YpPzBfQW1f WEZUWTkKelNNeVYmVzt5V2lvRFYjK0VDUUt+bXFSI00zJnZXNjBja0E4N19iczYoKG8hbiVeIyFn TT5OOGFTYGVobTx0U09LCnpEYWhwSEkpTUZocm5TTHUjM2RsTk00K2R+aT9rNlpwQzJXK2FFeDMm T0QzRGFiRGJvNHJObWZHOTdsdjwjTFBePAp6PG4lUGMlTWdafEZpdCR1OGdxJHZzYWppPDV8e1J5 Km17NiE1aCE8RShjQChiMklDWCE3KGVoYUhZU1B7UE5iNjMKekNLM3MwWkxuJlo+NHxZVmBaZn44 Rjx+NE4jaE5KQVQ8aigoangzTFRkeT0zMz8qZ1pmRV5fez9QY0UrKitMbVlRCnpvK0E2LSlYVUo7 e0NhcV9SaVdWZ1Q7TnxXSkJ5ZEc3JnNgJHB0V2YmekxHVkpYaktWb0xLK1BwRkd8MkN3fnxSTgp6 eWJ5dXNqQDlfYktSd1IqNXI1aDdTfmNkXyEzQjtUVDtNelJrOCNzYDI2Km9zbXRRekNIdEJlQGdn U3JiT2UybSQKenlXYGRHTGgwQWluQXVIcnMrWjhXI0YwKXNQRiUrdHRxb3lYZnI5a0RIJSFTfmhg PlclOV81cF85JHAyMHI1UilTCno/cE1kU2B5R2R2OFZAY29fUX1Sc3t6RFVtayFKNTNLOFRXbmBy SV4hQU5eTkt7WkZCVDB6cktUTFl5YUM5dzdgbQp6a0Aqc1NsdD9GeGJRKzB4JV5XIVQ8Tl48Vntg dUElQWNTRCtvKzRONUR6YXJ+ZiFjaGA+N3pCQ3s+ZCFXKjxgakoKemY4T1dzS1lFPE1kU0s3bUYj emk8SjBRZmx4JXJ0NWBDPXVSKzYhZk4tU3xOY3xJZz5+M2Q4aGxlaWZDMEVqKWt0CnowRn1XYCRR MUJ7aClBYWlvT1VFdU1qJlZ5Pyl7NzdFJTJwSW0kJHJza2tgTCtVfEZAJitPandvXk0kYDA9OSE8 Jgp6MGRWXjBCTERlc3F4fDtvWihOZl5kIyRyXnU9d0VBeG8yWlBPeGhzekFWTXBURUJGNWFlc3Y0 dUMhZlQ0MXFRRmEKem5hKFRzKEZtZm5eTl9TcXszd2FRTiY7WDE7c3xxLTVkY2FGLWgyQmQtdHp2 elcjRz9gX311eHtnRk80eDB3MkczCnpDKUBYeW1WVz1Hdih5JXJ1YzNyVUF8UnBGcWNyalMjNiMy UGVsaFFkNSVuTlVOclklOCVqTnEmSzxEPUJsVmZTQwp6cjBJVH0ya0NPNi1IdHBsLWBkfU1VNHtL YD9wXmwlYDRPS18tRkFmT0BzTjh6YWV8K0llfkxmKT5+PnIpQXNHNkcKenIrKy1SQV9zKDc2QGx2 VUJPXzZ4eD1eZHZYYW9fQkFmejVkRz1obEdOfU9fazB6TV96MWZMS3xgI3tsaDBAbEZqCno9fD0x R3dYZj8mSWJzI35nXyRIbSoyME9XN3dPc0h2MmpiVGI+OHNkI1MySEVFaCk1I3tJNSlwOVAlNHNv UHRrQwp6KUxVY3tAQyVkQVFKczhfaDk5PE9WTHdVO3dNKiNTbkZkaXtUSnFWdHIqdUteTGNrNGc+ KkwrR1p2dFRSanphNikKems+VURzMCU/Y2FTeEkyLSpwWXUwUFViX2h2VkF9fS1xTU9SSjs3S0BG I2FVNmBWKjlAUUghQD5Icnp+WEE8YHpECnokZCllWmN9cnR0RXFFRVJDaXYjfVQzZnUjSStoX1RC aGJ0UDdSUEo0SzdVVmJeb2Qlfm1keTFhV08zPmd3RyY/Xwp6QU9EZDQ0UCo1N1NMeUZRajJMfHct Pih6SnQ5d3RxOCM4M3szUHxldnZ4bG44JnFTKzZ6Rzt0c1Z9a3FzPGBlKkAKempARFlvU0leQXAx aVJ2PjBpdU94OT1xUXhqR1Y3bSN9bG5Eb0ZfVzxINDMhezg1JWY5VXdAVENBdyF7JXB8ZXg0Cnpk RlU3Jkd5amM8OD8wcjZvMHFpd187O3IkUmFgY3VmVFJAY2V7KE5nZU9+TEZNOzwpUz1sPVd6cW88 WitiTEZuVwp6dlRMUn11JCh7fDFxfXF6KVhEZUF2QnplRGBhRWpsZC1RYzNybjc2N1kqdnhVeTUj YTEzZEpuPkxXV1hGYT5lRmgKeiVKYmh4Kmt+MWpVRHFydm5WKWBxbU0wI1c9SShvVXZpcTdjSEB2 Tm4rZGdweHBaeE9mV2g4JDVVc0xFZihQRStHCnp1KGhxTXclYn1fR2VCNUJiXk4kbDgyQGx+PmM/ fUk5QzJKZzNlbWRwYzNuai1AOFA3a25YVV9pe2xuenZmNDFzXgp6QEJIdShlUz97RmtsPjQtOHM+ KSZQNE15MD9je3hUWk58JDtgVVckNl4yQHVhXm13YSZmNzUjaD0pV3d4Q1ZeR0cKelFFUk9nTFRE Z1pKYkxodjtAO3hsaz87QX54UE5fbHpWO2omZFBoLT9DSmFUb0huUE5WdmhZKFghaV5fTStMfXdJ Cno5S2xFYWRLO2hsenxZYUtDR1pYUmVmQVdPSmIwZDYqTDFNYHN0KUYrTCFOIUFOQEZvejEjKSZX PFUrUCliSnRwSAp6KHpiU0VAdEZmKEQoIWdyZ2t2fHtRfC1RPyVieigtZXJsTUAyRkd3KiF8PHVp NyhCfVBiN1pfcFZvQFklQ0A7NWQKemRyUTNnazJtcSk3ZSl5RXFeekRmVWdPTzE4c0IrZmoyRSY7 emNFMjN0R00tfW83V3x3cmZISWc0RTVAPGdXdUJVCnpoSlFDWl8xSVY+SkVHYjBUTnl0MDNRbkZG cHFrc3FlQW1zNEBwP3cqVXEhdXEtMzJmQj0zNTgoKVAxe2ApJVVlNQp6bl4jPGFPSjZHfDk5TDRU eGEqST1OK3wpPE14SCg3JX1tXnMrMWp7TUVGUytJenB8Jj9DfEBuRGExbFYxOVV7c08KemFXVDk2 Qj9VaEhsfEI2TXAkVSMzc3h0YXFnVn45WVkrbGtja1lRK1JvfnZLbyR4SFdAbkgmcWE9T2UjaHxD QFRiCno8K2l+fkJoV15vRE19bUdXXzlAVmszUXttX1RIRDwoenNpPWBCejJ4amhAYUE2Xisqa0h0 RzA/aWAqUzVDQWpoSgp6e29NSFdlZ052IzdeeV5Tekd6ekNWMjAwcmJ1VjY0RV43Kn1vNF5WWiYx YnFnb31HLVV2cD19WSZGM3JMOzEjY04KeiReKjl1PD9nYTdpKkBvcz5Vc3cmR3gtSDlVJURgaW04 NGR9VGkyOE5IYVJzKExfaVNMPndZd1I8WGRwJGR3fVBaCnp5U2tsWGNfOUN+KHg7KHRgRmFXYkR6 QCVkNFZzZ2o1VFpIUiNVJU9CWjEtajJgSSV9d0tRcm9BVW93MikrcXorbAp6YjwlcysjRjlNPT19 YW9IMCtEVnA+OSttY1JXSmFvS3tlYG4xVFpoZ2xYXndsbGxzKU5LIXYySS0+aGA0Kjl1dHYKemd1 ZVlyZWU7fFBqJF8tXzJXRFQ0Y09fUTdjQ2VDXldiT0FQUj1xRUEzNGgobiQ2dHhTOGYwaUFiZ3tR cFVYKFhoCnp7dlN6QHJvVzJ1aXFRWjcwM34hcVNhZjRAV25wdz5FbzVQSVdkSmZURmdZelRGZkF9 T1I1M08+R0JyOWRHQWw3Swp6SXhzTEFHPUJMMjAwMVIpTU9idWdaKTltXmNgYW1OYlklY0NGZmNo U0YpJUdLSEI+UCtJeDttbkZmdURLRmdoP1cKVE1USDI+MDAwMDBOa3ZYWHUwbWpmNFJOVygKCmxp dGVyYWwgMApIY21WP2QwMDAwMQoKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2No cm9taXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9t aXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAppbmRleCBlOWQ1OTYxLi4zMjdkNmZkIDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQK KysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0 CkBAIC0yOTg2LDYgKzI5ODYsNyBAQCBCVUdDUjc3NzM0IDogaHR0cC90ZXN0cy91cmkvdXNlcm5h bWUtd2l0aC1uby1ob3N0bmFtZS5odG1sID0gVEVYVAogCiAvLyBDaHJvbWUgZG9lc24ndCBsb2Fk IGZhdmljb25zIGluIERSVCB0ZXN0cy4KIEJVR1dLNTcyNTkgOiBodHRwL3Rlc3RzL21pc2MvbGlu ay1yZWwtaWNvbi1iZWZvcmVsb2FkLmh0bWwgPSBGQUlMIFBBU1MKK0JVR1dLNjI0NTkgOiBmYXN0 L3ByZWxvYWRlci9mYXZpY29uLmh0bWwgPSBGQUlMIFBBU1MKIAogLy8gVGhlc2UgdGVzdHMgYXBw ZWFycyB0byB0aW1lb3V0IGV2ZXJ5IDEwIG9yIDIwIHJ1bnMuCiBCVUdXSzYwMDk0IDogZmFzdC9l bmNvZGluZy9wYXJzZXItdGVzdHMuaHRtbCA9IFRJTUVPVVQgUEFTUwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDc5 YTk4ZDkuLjcwMWQ4NzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzOCBAQAorMjAxMS0wNy0xOCAg UmFmYWVsIEJyYW5kYW8gIDxyYWZhZWwubG9ib0BvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIExv Y2FsIGZpbGVzIGNhbm5vdCBsb2FkIGljb25zLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjI0NTkKKworICAgICAgICBQcmV2aW91cyBwb2xpY3kgb25s eSBhbGxvd2VkIGljb25zIGZvciBwYWdlcyB3aG9zZSBwcm90b2NvbCB3YXMgcGFydCBvZiBIVFRQ IGZhbWlseS4KKyAgICAgICAgQ2hhbmdlZCB0aGF0IHRvIGFsbG93IHRvIGFueSB1cmwgdGhhdCdz IG5vdCBlbXB0eSBhbmQgd2hvc2UgcHJvdG9jb2wgaXMgbm90ICJhYm91dCIuCisgICAgICAgIEFs c28gYWRkZWQgdGhpcyBjaGVjayB3aGVyZSBpdCBhdHRlbXB0cyB0byBzdGFydCBsb2FkaW5nIHRo ZSBmYXZpY29uLCBzbyBpdCBjYW4gYXZvaWQKKyAgICAgICAgd2FzdGluZyB0aW1lIGRvd25sb2Fk aW5nIGEgcmVzb3VyY2UgdGhhdCB3b24ndCBiZSBzdG9yZWQgYW5kIHdvbid0IGJlIHVzZWQuCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFz dC9wcmVsb2FkZXIvZmF2aWNvbi5odG1sCisKKyAgICAgICAgKiBsb2FkZXIvaWNvbi9JY29uQ29u dHJvbGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJY29uQ29udHJvbGxlcjo6c3RhcnRMb2Fk ZXIpOiBBZGRlZCBjaGVjayB0byBhdm9pZCByZXF1ZXN0aW5nIGEgZmF2aWNvbgorICAgICAgICB3 aGVuIHRoZXJlJ3Mgbm8gd2F5IHRvIHN0b3JlIGl0LgorICAgICAgICAKKyAgICAgICAgKiBsb2Fk ZXIvaWNvbi9JY29uRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNl Ojpkb2N1bWVudENhbkhhdmVJY29uKTogUmVuYW1lZCBmdW5jdGlvbiAicGFnZUNhbkhhdmVJY29u IgorICAgICAgICB0byByZWZsZWN0IGJldHRlciB3aGljaCB1cmwgd2UncmUgaGFuZGxpbmcuCisg ICAgICAgIAorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNlOjpzeW5jaHJvbm91c0ljb25G b3JQYWdlVVJMKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpJY29uRGF0YWJhc2U6OnN5bmNo cm9ub3VzSWNvblVSTEZvclBhZ2VVUkwpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6Okljb25E YXRhYmFzZTo6cmV0YWluSWNvbkZvclBhZ2VVUkwpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6 Okljb25EYXRhYmFzZTo6cmVsZWFzZUljb25Gb3JQYWdlVVJMKTogRGl0dG8uCisgICAgICAgIChX ZWJDb3JlOjpJY29uRGF0YWJhc2U6OnNldEljb25VUkxGb3JQYWdlVVJMKTogRGl0dG8uCisgICAg ICAgIChXZWJDb3JlOjpJY29uRGF0YWJhc2U6OmdldE9yQ3JlYXRlUGFnZVVSTFJlY29yZCk6IERp dHRvLgorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNlOjppbXBvcnRJY29uVVJMRm9yUGFn ZVVSTCk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNlOjpwZXJmb3JtVVJM SW1wb3J0KTogRGl0dG8uCisgICAgICAgICogbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmg6Cisg ICAgICAgICogbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlQmFzZS5oOgorICAgICAgICAoV2ViQ29y ZTo6SWNvbkRhdGFiYXNlQmFzZTo6ZG9jdW1lbnRDYW5IYXZlSWNvbik6IEFkZGVkIGl0IGFzIHZp cnR1YWwgdG8gZGlzYWxsb3cgZmF2aWNvbnMKKyAgICAgICAgYnkgZGVmYXVsdCBhbmQgZXZhbHVh dGUgYWNjb3JkaW5nbHkgd2hlbiBJY29uRGF0YWJhc2UgaXMgZW5hYmxlZC4KKwogMjAxMS0wNy0x OCAgWW91bmcgSGFuIExlZSAgPGpveWJyb0Bjb21wYW55MTAwLm5ldD4KIAogICAgICAgICBBbmlt YXRpb25CYXNlIGFzc2VydHMgaWYgYSB0ZXN0IHRyaWVzIHRvIHBhdXNlIGR1cmluZyB0aGUgZGVs YXkgcGhhc2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25Db250 cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25Db250cm9sbGVyLmNw cAppbmRleCA3N2Q1MmVlLi42YzYwNTJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2Fk ZXIvaWNvbi9JY29uQ29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL2lj b24vSWNvbkNvbnRyb2xsZXIuY3BwCkBAIC0xMTMsNiArMTEzLDEwIEBAIHZvaWQgSWNvbkNvbnRy b2xsZXI6OnN0YXJ0TG9hZGVyKCkKICAgICBpZiAoIWljb25EYXRhYmFzZSgpLmlzRW5hYmxlZCgp KQogICAgICAgICByZXR1cm47CiAKKyAgICBBU1NFUlQoIW1fZnJhbWUtPnRyZWUoKS0+cGFyZW50 KCkpOworICAgIGlmICghaWNvbkRhdGFiYXNlKCkuZG9jdW1lbnRDYW5IYXZlSWNvbihtX2ZyYW1l LT5kb2N1bWVudCgpLT51cmwoKSkpCisgICAgICAgIHJldHVybjsKKwogICAgIEtVUkwgaWNvblVS TCh1cmwoKSk7CiAgICAgU3RyaW5nIHVybFN0cmluZyhpY29uVVJMLnN0cmluZygpKTsKICAgICBp ZiAodXJsU3RyaW5nLmlzRW1wdHkoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRl ci9pY29uL0ljb25EYXRhYmFzZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29u RGF0YWJhc2UuY3BwCmluZGV4IGNkMmMzMDQuLmQ4YzIyOTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv bG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmNwcApAQCAtOTksOSArOTksOSBAQCBzdGF0aWMgSWNv bkRhdGFiYXNlQ2xpZW50KiBkZWZhdWx0Q2xpZW50KCkKICAgICByZXR1cm4gZGVmYXVsdENsaWVu dDsKIH0KIAotc3RhdGljIGlubGluZSBib29sIHBhZ2VDYW5IYXZlSWNvbihjb25zdCBTdHJpbmcm IHBhZ2VVUkwpCitib29sIEljb25EYXRhYmFzZTo6ZG9jdW1lbnRDYW5IYXZlSWNvbihjb25zdCBT dHJpbmcmIGRvY3VtZW50VVJMKSBjb25zdAogewotICAgIHJldHVybiBwcm90b2NvbElzSW5IVFRQ RmFtaWx5KHBhZ2VVUkwpOworICAgIHJldHVybiAhZG9jdW1lbnRVUkwuaXNFbXB0eSgpICYmICFw cm90b2NvbElzKGRvY3VtZW50VVJMLCAiYWJvdXQiKTsKIH0KIAogLy8gKioqKioqKioqKioqKioq KioqKioqKioqCkBAIC0yMjMsNyArMjIzLDcgQEAgSW1hZ2UqIEljb25EYXRhYmFzZTo6c3luY2hy b25vdXNJY29uRm9yUGFnZVVSTChjb25zdCBTdHJpbmcmIHBhZ2VVUkxPcmlnaW5hbCwgY28KICAg ICAvLyBwYWdlVVJMT3JpZ2luYWwgY2Fubm90IGJlIHN0b3JlZCB3aXRob3V0IGJlaW5nIGRlZXAg Y29waWVkIGZpcnN0LiAgCiAgICAgLy8gV2Ugc2hvdWxkIGdvIG91ciBvZiBvdXIgd2F5IHRvIG9u bHkgY29weSBpdCBpZiB3ZSBoYXZlIHRvIHN0b3JlIGl0CiAgICAgCi0gICAgaWYgKCFpc09wZW4o KSB8fCAhcGFnZUNhbkhhdmVJY29uKHBhZ2VVUkxPcmlnaW5hbCkpCisgICAgaWYgKCFpc09wZW4o KSB8fCAhZG9jdW1lbnRDYW5IYXZlSWNvbihwYWdlVVJMT3JpZ2luYWwpKQogICAgICAgICByZXR1 cm4gMDsKIAogICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3VybEFuZEljb25Mb2NrKTsKQEAgLTMx MCw3ICszMTAsNyBAQCBTdHJpbmcgSWNvbkRhdGFiYXNlOjpzeW5jaHJvbm91c0ljb25VUkxGb3JQ YWdlVVJMKGNvbnN0IFN0cmluZyYgcGFnZVVSTE9yaWdpbmFsKQogICAgIC8vIENhbm5vdCBkbyBh bnl0aGluZyB3aXRoIHBhZ2VVUkxPcmlnaW5hbCB0aGF0IHdvdWxkIGVuZCB1cCBzdG9yaW5nIGl0 IHdpdGhvdXQgZGVlcCBjb3B5aW5nIGZpcnN0CiAgICAgLy8gQWxzbywgaW4gdGhlIGNhc2Ugd2Ug aGF2ZSBhIHJlYWwgYW5zd2VyIGZvciB0aGUgY2FsbGVyLCB3ZSBtdXN0IGRlZXAgY29weSB0aGF0 IGFzIHdlbGwKICAgICAKLSAgICBpZiAoIWlzT3BlbigpIHx8ICFwYWdlQ2FuSGF2ZUljb24ocGFn ZVVSTE9yaWdpbmFsKSkKKyAgICBpZiAoIWlzT3BlbigpIHx8ICFkb2N1bWVudENhbkhhdmVJY29u KHBhZ2VVUkxPcmlnaW5hbCkpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsKICAgICAgICAgCiAg ICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fdXJsQW5kSWNvbkxvY2spOwpAQCAtNDAwLDcgKzQwMCw3 IEBAIHZvaWQgSWNvbkRhdGFiYXNlOjpyZXRhaW5JY29uRm9yUGFnZVVSTChjb25zdCBTdHJpbmcm IHBhZ2VVUkxPcmlnaW5hbCkKICAgICAKICAgICAvLyBDYW5ub3QgZG8gYW55dGhpbmcgd2l0aCBw YWdlVVJMT3JpZ2luYWwgdGhhdCB3b3VsZCBlbmQgdXAgc3RvcmluZyBpdCB3aXRob3V0IGRlZXAg Y29weWluZyBmaXJzdAogICAgIAotICAgIGlmICghaXNFbmFibGVkKCkgfHwgIXBhZ2VDYW5IYXZl SWNvbihwYWdlVVJMT3JpZ2luYWwpKQorICAgIGlmICghaXNFbmFibGVkKCkgfHwgIWRvY3VtZW50 Q2FuSGF2ZUljb24ocGFnZVVSTE9yaWdpbmFsKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgIAog ICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3VybEFuZEljb25Mb2NrKTsKQEAgLTQ0NCw3ICs0NDQs NyBAQCB2b2lkIEljb25EYXRhYmFzZTo6cmVsZWFzZUljb25Gb3JQYWdlVVJMKGNvbnN0IFN0cmlu ZyYgcGFnZVVSTE9yaWdpbmFsKQogICAgICAgICAKICAgICAvLyBDYW5ub3QgZG8gYW55dGhpbmcg d2l0aCBwYWdlVVJMT3JpZ2luYWwgdGhhdCB3b3VsZCBlbmQgdXAgc3RvcmluZyBpdCB3aXRob3V0 IGRlZXAgY29weWluZyBmaXJzdAogICAgIAotICAgIGlmICghaXNFbmFibGVkKCkgfHwgIXBhZ2VD YW5IYXZlSWNvbihwYWdlVVJMT3JpZ2luYWwpKQorICAgIGlmICghaXNFbmFibGVkKCkgfHwgIWRv Y3VtZW50Q2FuSGF2ZUljb24ocGFnZVVSTE9yaWdpbmFsKSkKICAgICAgICAgcmV0dXJuOwogICAg IAogICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3VybEFuZEljb25Mb2NrKTsKQEAgLTU3MywxMyAr NTczLDE1IEBAIHZvaWQgSWNvbkRhdGFiYXNlOjpzZXRJY29uRGF0YUZvckljb25VUkwoUGFzc1Jl ZlB0cjxTaGFyZWRCdWZmZXI+IGRhdGFPcmlnaW5hbCwKIAogdm9pZCBJY29uRGF0YWJhc2U6OnNl dEljb25VUkxGb3JQYWdlVVJMKGNvbnN0IFN0cmluZyYgaWNvblVSTE9yaWdpbmFsLCBjb25zdCBT dHJpbmcmIHBhZ2VVUkxPcmlnaW5hbCkKIHsgICAgCisgICAgLy9wcmludGYoInNldEljb25VUkxG b3JQYWdlVVJMICVzIC0gJXNcbiIsIGljb25VUkxPcmlnaW5hbC51dGY4KCkuZGF0YSgpLCBwYWdl VVJMT3JpZ2luYWwudXRmOCgpLmRhdGEoKSk7CiAgICAgQVNTRVJUX05PVF9TWU5DX1RIUkVBRCgp OworICAgIC8vcHJpbnRmKCJibGFcbiIpOwogCiAgICAgLy8gQ2Fubm90IGRvIGFueXRoaW5nIHdp dGggaWNvblVSTE9yaWdpbmFsIG9yIHBhZ2VVUkxPcmlnaW5hbCB0aGF0IHdvdWxkIGVuZCB1cCBz dG9yaW5nIHRoZW0gd2l0aG91dCBkZWVwIGNvcHlpbmcgZmlyc3QKICAgICAKICAgICBBU1NFUlQo IWljb25VUkxPcmlnaW5hbC5pc0VtcHR5KCkpOwogICAgICAgICAKLSAgICBpZiAoIWlzT3Blbigp IHx8ICFwYWdlQ2FuSGF2ZUljb24ocGFnZVVSTE9yaWdpbmFsKSkKKyAgICBpZiAoIWlzT3Blbigp IHx8ICFkb2N1bWVudENhbkhhdmVJY29uKHBhZ2VVUkxPcmlnaW5hbCkpCiAgICAgICAgIHJldHVy bjsKICAgICAKICAgICBTdHJpbmcgaWNvblVSTCwgcGFnZVVSTDsKQEAgLTg4OSw3ICs4OTEsNyBA QCBQYWdlVVJMUmVjb3JkKiBJY29uRGF0YWJhc2U6OmdldE9yQ3JlYXRlUGFnZVVSTFJlY29yZChj b25zdCBTdHJpbmcmIHBhZ2VVUkwpCiAgICAgLy8gQ2xpZW50cyBvZiBnZXRPckNyZWF0ZVBhZ2VV UkxSZWNvcmQoKSBhcmUgcmVxdWlyZWQgdG8gYWNxdWlyZSB0aGUgbV91cmxBbmRJY29uTG9jayBi ZWZvcmUgY2FsbGluZyB0aGlzIG1ldGhvZAogICAgIEFTU0VSVCghbV91cmxBbmRJY29uTG9jay50 cnlMb2NrKCkpOwogCi0gICAgaWYgKCFwYWdlQ2FuSGF2ZUljb24ocGFnZVVSTCkpCisgICAgaWYg KCFkb2N1bWVudENhbkhhdmVJY29uKHBhZ2VVUkwpKQogICAgICAgICByZXR1cm4gMDsKIAogICAg IFBhZ2VVUkxSZWNvcmQqIHBhZ2VSZWNvcmQgPSBtX3BhZ2VVUkxUb1JlY29yZE1hcC5nZXQocGFn ZVVSTCk7CkBAIC05MjcsNyArOTI5LDcgQEAgdm9pZCBJY29uRGF0YWJhc2U6OmltcG9ydEljb25V UkxGb3JQYWdlVVJMKGNvbnN0IFN0cmluZyYgaWNvblVSTCwgY29uc3QgU3RyaW5nJgogICAgIC8v IFRoaXMgZnVuY3Rpb24gaXMgb25seSBmb3Igc2V0dGluZyBhY3R1YWwgZXhpc3RpbmcgdXJsIG1h cHBpbmdzIHNvIGFzc2VydCB0aGF0IG5laXRoZXIgb2YgdGhlc2UgVVJMcyBhcmUgZW1wdHkKICAg ICBBU1NFUlQoIWljb25VUkwuaXNFbXB0eSgpKTsKICAgICBBU1NFUlQoIXBhZ2VVUkwuaXNFbXB0 eSgpKTsKLSAgICBBU1NFUlQocGFnZUNhbkhhdmVJY29uKHBhZ2VVUkwpKTsKKyAgICBBU1NFUlQo ZG9jdW1lbnRDYW5IYXZlSWNvbihwYWdlVVJMKSk7CiAgICAgCiAgICAgc2V0SWNvblVSTEZvclBh Z2VVUkxJblNRTERhdGFiYXNlKGljb25VUkwsIHBhZ2VVUkwpOyAgICAKIH0KQEAgLTEyMzQsNyAr MTIzNiw3IEBAIHZvaWQgSWNvbkRhdGFiYXNlOjpwZXJmb3JtVVJMSW1wb3J0KCkKICAgICAgICAg ICAgIC8vIHNvIGdvIGFoZWFkIGFuZCBhY3R1YWxseSBjcmVhdGUgYSBwYWdlVVJMUmVjb3JkIGZv ciB0aGlzIHVybCBldmVuIHRob3VnaCBpdCdzIG5vdCByZXRhaW5lZC4KICAgICAgICAgICAgIC8v IElmIGRhdGFiYXNlIGNsZWFudXAgKmlzKiBhbGxvd2VkLCB3ZSBkb24ndCB3YW50IHRvIGJvdGhl ciBwdWxsaW5nIGluIGEgcGFnZSB1cmwgZnJvbSBkaXNrIHRoYXQgbm9vbmUgaXMgYWN0dWFsbHkg aW50ZXJlc3RlZAogICAgICAgICAgICAgLy8gaW4gLSB3ZSdsbCBwcnVuZSBpdCBsYXRlciBpbnN0 ZWFkIQotICAgICAgICAgICAgaWYgKCFwYWdlUmVjb3JkICYmIGRhdGFiYXNlQ2xlYW51cENvdW50 ZXIgJiYgcGFnZUNhbkhhdmVJY29uKHBhZ2VVUkwpKSB7CisgICAgICAgICAgICBpZiAoIXBhZ2VS ZWNvcmQgJiYgZGF0YWJhc2VDbGVhbnVwQ291bnRlciAmJiBkb2N1bWVudENhbkhhdmVJY29uKHBh Z2VVUkwpKSB7CiAgICAgICAgICAgICAgICAgcGFnZVJlY29yZCA9IG5ldyBQYWdlVVJMUmVjb3Jk KHBhZ2VVUkwpOwogICAgICAgICAgICAgICAgIG1fcGFnZVVSTFRvUmVjb3JkTWFwLnNldChwYWdl VVJMLCBwYWdlUmVjb3JkKTsKICAgICAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5oIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL2lj b24vSWNvbkRhdGFiYXNlLmgKaW5kZXggYjU5Mzc2NC4uNTQ2ZjA4NSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmgKKysrIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmgKQEAgLTEzNiw2ICsxMzYsNyBAQCBwcml2YXRl OgogcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBpc09wZW4oKSBjb25zdDsKICAgICB2aXJ0dWFs IFN0cmluZyBkYXRhYmFzZVBhdGgoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgZG9jdW1lbnRD YW5IYXZlSWNvbihjb25zdCBTdHJpbmcmIGRvY3VtZW50VVJMKSBjb25zdDsKICAgICBzdGF0aWMg U3RyaW5nIGRlZmF1bHREYXRhYmFzZUZpbGVuYW1lKCk7CiAKIHByaXZhdGU6CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2VCYXNlLmggYi9Tb3VyY2Uv V2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2VCYXNlLmgKaW5kZXggYmM2NjViYS4uMTZl YThhNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNl QmFzZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZUJhc2Uu aApAQCAtMTY1LDYgKzE2NSw3IEBAIHB1YmxpYzoKIAogICAgIC8vIFVzZWQgaW50ZXJuYWxseSBi eSBXZWJDb3JlCiAgICAgdmlydHVhbCBib29sIGlzRW5hYmxlZCgpIGNvbnN0IHsgcmV0dXJuIGZh bHNlOyB9CisgICAgdmlydHVhbCBib29sIGRvY3VtZW50Q2FuSGF2ZUljb24oY29uc3QgU3RyaW5n JikgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICAgICAgCiAgICAgdmlydHVhbCB2b2lkIHJl dGFpbkljb25Gb3JQYWdlVVJMKGNvbnN0IFN0cmluZyYpIHsgfQogICAgIHZpcnR1YWwgdm9pZCBy ZWxlYXNlSWNvbkZvclBhZ2VVUkwoY29uc3QgU3RyaW5nJikgeyB9Cg== 101620 2011-07-21 11:46:23 -0700 2011-07-21 17:40:43 -0700 Just added the manual-test and removed the unrelated comments on the code. icon-loading-webkit-6.diff text/plain 14083 rafael.lobo ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA5OTQwZTI1Li45OWUyM2I2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDEg QEAKKzIwMTEtMDctMjEgIFJhZmFlbCBCcmFuZGFvICA8cmFmYWVsLmxvYm9Ab3BlbmJvc3NhLm9y Zz4KKworICAgICAgICBMb2NhbCBmaWxlcyBjYW5ub3QgbG9hZCBpY29ucy4KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYyNDU5CisgICAgICAgIAorICAg ICAgICBQcmV2aW91cyBwb2xpY3kgb25seSBhbGxvd2VkIGZhdmljb25zIGZvciBwYWdlcyB3aG9z ZSBwcm90b2NvbCB3YXMgcGFydCBvZiBIVFRQIGZhbWlseS4KKyAgICAgICAgQ2hhbmdlZCB0aGF0 IHRvIGFsbG93IHRvIGFueSB1cmwgdGhhdCdzIG5vdCBlbXB0eSBhbmQgd2hvc2UgcHJvdG9jb2wg aXMgbm90ICJhYm91dCIuCisgICAgICAgIEFsc28gYWRkZWQgdGhpcyBjaGVjayB3aGVyZSBpdCBh dHRlbXB0cyB0byBzdGFydCBsb2FkaW5nIHRoZSBmYXZpY29uLCBzbyBpdCBjYW4gYXZvaWQKKyAg ICAgICAgd2FzdGluZyB0aW1lIGRvd25sb2FkaW5nIGEgcmVzb3VyY2UgdGhhdCB3b24ndCBiZSBz dG9yZWQgYW5kIHdvbid0IGJlIHVzZWQuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGVzdDogbWFudWFsLXRlc3RzL3Jlc291cmNlcy9mYXZpY29uLWxv YWRzLWZvci1sb2NhbC1maWxlcy5odG1sCisKKyAgICAgICAgKiBsb2FkZXIvaWNvbi9JY29uQ29u dHJvbGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJY29uQ29udHJvbGxlcjo6c3RhcnRMb2Fk ZXIpOiBBZGRlZCBjaGVjayB0byBhdm9pZCB0byByZXF1ZXN0IGEgZmF2aWNvbgorICAgICAgICB3 aGVuIHRoZXJlJ3Mgbm8gd2F5IHRvIHN0b3JlIGl0LgorICAgICAgICAKKyAgICAgICAgKiBsb2Fk ZXIvaWNvbi9JY29uRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNl Ojpkb2N1bWVudENhbkhhdmVJY29uKTogUmVuYW1lZCBmdW5jdGlvbiAicGFnZUNhbkhhdmVJY29u IgorICAgICAgICB0byByZWZsZWN0IGJldHRlciB3aGljaCB1cmwgd2UncmUgaGFuZGxpbmcuCisg ICAgICAgIAorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNlOjpzeW5jaHJvbm91c0ljb25G b3JQYWdlVVJMKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpJY29uRGF0YWJhc2U6OnN5bmNo cm9ub3VzSWNvblVSTEZvclBhZ2VVUkwpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6Okljb25E YXRhYmFzZTo6cmV0YWluSWNvbkZvclBhZ2VVUkwpOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6 Okljb25EYXRhYmFzZTo6cmVsZWFzZUljb25Gb3JQYWdlVVJMKTogRGl0dG8uCisgICAgICAgIChX ZWJDb3JlOjpJY29uRGF0YWJhc2U6OnNldEljb25VUkxGb3JQYWdlVVJMKTogRGl0dG8uCisgICAg ICAgIChXZWJDb3JlOjpJY29uRGF0YWJhc2U6OmdldE9yQ3JlYXRlUGFnZVVSTFJlY29yZCk6IERp dHRvLgorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNlOjppbXBvcnRJY29uVVJMRm9yUGFn ZVVSTCk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6SWNvbkRhdGFiYXNlOjpwZXJmb3JtVVJM SW1wb3J0KTogRGl0dG8uCisgICAgICAgICogbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmg6Cisg ICAgICAgICogbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlQmFzZS5oOgorICAgICAgICAoV2ViQ29y ZTo6SWNvbkRhdGFiYXNlQmFzZTo6ZG9jdW1lbnRDYW5IYXZlSWNvbik6IEFkZGVkIGl0IGFzIHZp cnR1YWwgdG8gcmVwbGFjZSBpdHMKKyAgICAgICAgZGVmYXVsdCBiZWhhdmlvciBvZiBub3QgYWxs b3dpbmcgZmF2aWNvbnMgd2hlbiB3ZSBoYXZlIEljb25EYXRhYmFzZSBlbmFibGVkLgorICAgICAg ICAKKyAgICAgICAgKiBtYW51YWwtdGVzdHMvcmVzb3VyY2VzL2Zhdmljb24tbG9hZHMtZm9yLWxv Y2FsLWZpbGVzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIG1hbnVhbC10ZXN0cy9yZXNvdXJjZXMv ZmF2aWNvbi5wbmc6IEFkZGVkLgorCiAyMDExLTA3LTIxICBQYXZlbCBGZWxkbWFuICA8cGZlbGRt YW5AZ29vZ2xlLmNvbT4KIAogICAgICAgICBOb3QgcmV2aWV3ZWQ6IG9uZSBsaW5lciB0eXBvIGZp eCBpbiBJbnNwZWN0b3IuanNvbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9p Y29uL0ljb25Db250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25D b250cm9sbGVyLmNwcAppbmRleCA3N2Q1MmVlLi42YzYwNTJlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uQ29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvbG9hZGVyL2ljb24vSWNvbkNvbnRyb2xsZXIuY3BwCkBAIC0xMTMsNiArMTEzLDEwIEBAIHZv aWQgSWNvbkNvbnRyb2xsZXI6OnN0YXJ0TG9hZGVyKCkKICAgICBpZiAoIWljb25EYXRhYmFzZSgp LmlzRW5hYmxlZCgpKQogICAgICAgICByZXR1cm47CiAKKyAgICBBU1NFUlQoIW1fZnJhbWUtPnRy ZWUoKS0+cGFyZW50KCkpOworICAgIGlmICghaWNvbkRhdGFiYXNlKCkuZG9jdW1lbnRDYW5IYXZl SWNvbihtX2ZyYW1lLT5kb2N1bWVudCgpLT51cmwoKSkpCisgICAgICAgIHJldHVybjsKKwogICAg IEtVUkwgaWNvblVSTCh1cmwoKSk7CiAgICAgU3RyaW5nIHVybFN0cmluZyhpY29uVVJMLnN0cmlu ZygpKTsKICAgICBpZiAodXJsU3RyaW5nLmlzRW1wdHkoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9sb2Fk ZXIvaWNvbi9JY29uRGF0YWJhc2UuY3BwCmluZGV4IGNkMmMzMDQuLmVkNzE0MTUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmNwcApAQCAtOTksOSArOTksOSBA QCBzdGF0aWMgSWNvbkRhdGFiYXNlQ2xpZW50KiBkZWZhdWx0Q2xpZW50KCkKICAgICByZXR1cm4g ZGVmYXVsdENsaWVudDsKIH0KIAotc3RhdGljIGlubGluZSBib29sIHBhZ2VDYW5IYXZlSWNvbihj b25zdCBTdHJpbmcmIHBhZ2VVUkwpCitib29sIEljb25EYXRhYmFzZTo6ZG9jdW1lbnRDYW5IYXZl SWNvbihjb25zdCBTdHJpbmcmIGRvY3VtZW50VVJMKSBjb25zdAogewotICAgIHJldHVybiBwcm90 b2NvbElzSW5IVFRQRmFtaWx5KHBhZ2VVUkwpOworICAgIHJldHVybiAhZG9jdW1lbnRVUkwuaXNF bXB0eSgpICYmICFwcm90b2NvbElzKGRvY3VtZW50VVJMLCAiYWJvdXQiKTsKIH0KIAogLy8gKioq KioqKioqKioqKioqKioqKioqKioqCkBAIC0yMjMsNyArMjIzLDcgQEAgSW1hZ2UqIEljb25EYXRh YmFzZTo6c3luY2hyb25vdXNJY29uRm9yUGFnZVVSTChjb25zdCBTdHJpbmcmIHBhZ2VVUkxPcmln aW5hbCwgY28KICAgICAvLyBwYWdlVVJMT3JpZ2luYWwgY2Fubm90IGJlIHN0b3JlZCB3aXRob3V0 IGJlaW5nIGRlZXAgY29waWVkIGZpcnN0LiAgCiAgICAgLy8gV2Ugc2hvdWxkIGdvIG91ciBvZiBv dXIgd2F5IHRvIG9ubHkgY29weSBpdCBpZiB3ZSBoYXZlIHRvIHN0b3JlIGl0CiAgICAgCi0gICAg aWYgKCFpc09wZW4oKSB8fCAhcGFnZUNhbkhhdmVJY29uKHBhZ2VVUkxPcmlnaW5hbCkpCisgICAg aWYgKCFpc09wZW4oKSB8fCAhZG9jdW1lbnRDYW5IYXZlSWNvbihwYWdlVVJMT3JpZ2luYWwpKQog ICAgICAgICByZXR1cm4gMDsKIAogICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3VybEFuZEljb25M b2NrKTsKQEAgLTMxMCw3ICszMTAsNyBAQCBTdHJpbmcgSWNvbkRhdGFiYXNlOjpzeW5jaHJvbm91 c0ljb25VUkxGb3JQYWdlVVJMKGNvbnN0IFN0cmluZyYgcGFnZVVSTE9yaWdpbmFsKQogICAgIC8v IENhbm5vdCBkbyBhbnl0aGluZyB3aXRoIHBhZ2VVUkxPcmlnaW5hbCB0aGF0IHdvdWxkIGVuZCB1 cCBzdG9yaW5nIGl0IHdpdGhvdXQgZGVlcCBjb3B5aW5nIGZpcnN0CiAgICAgLy8gQWxzbywgaW4g dGhlIGNhc2Ugd2UgaGF2ZSBhIHJlYWwgYW5zd2VyIGZvciB0aGUgY2FsbGVyLCB3ZSBtdXN0IGRl ZXAgY29weSB0aGF0IGFzIHdlbGwKICAgICAKLSAgICBpZiAoIWlzT3BlbigpIHx8ICFwYWdlQ2Fu SGF2ZUljb24ocGFnZVVSTE9yaWdpbmFsKSkKKyAgICBpZiAoIWlzT3BlbigpIHx8ICFkb2N1bWVu dENhbkhhdmVJY29uKHBhZ2VVUkxPcmlnaW5hbCkpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsK ICAgICAgICAgCiAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fdXJsQW5kSWNvbkxvY2spOwpAQCAt NDAwLDcgKzQwMCw3IEBAIHZvaWQgSWNvbkRhdGFiYXNlOjpyZXRhaW5JY29uRm9yUGFnZVVSTChj b25zdCBTdHJpbmcmIHBhZ2VVUkxPcmlnaW5hbCkKICAgICAKICAgICAvLyBDYW5ub3QgZG8gYW55 dGhpbmcgd2l0aCBwYWdlVVJMT3JpZ2luYWwgdGhhdCB3b3VsZCBlbmQgdXAgc3RvcmluZyBpdCB3 aXRob3V0IGRlZXAgY29weWluZyBmaXJzdAogICAgIAotICAgIGlmICghaXNFbmFibGVkKCkgfHwg IXBhZ2VDYW5IYXZlSWNvbihwYWdlVVJMT3JpZ2luYWwpKQorICAgIGlmICghaXNFbmFibGVkKCkg fHwgIWRvY3VtZW50Q2FuSGF2ZUljb24ocGFnZVVSTE9yaWdpbmFsKSkKICAgICAgICAgcmV0dXJu OwogICAgICAgIAogICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3VybEFuZEljb25Mb2NrKTsKQEAg LTQ0NCw3ICs0NDQsNyBAQCB2b2lkIEljb25EYXRhYmFzZTo6cmVsZWFzZUljb25Gb3JQYWdlVVJM KGNvbnN0IFN0cmluZyYgcGFnZVVSTE9yaWdpbmFsKQogICAgICAgICAKICAgICAvLyBDYW5ub3Qg ZG8gYW55dGhpbmcgd2l0aCBwYWdlVVJMT3JpZ2luYWwgdGhhdCB3b3VsZCBlbmQgdXAgc3Rvcmlu ZyBpdCB3aXRob3V0IGRlZXAgY29weWluZyBmaXJzdAogICAgIAotICAgIGlmICghaXNFbmFibGVk KCkgfHwgIXBhZ2VDYW5IYXZlSWNvbihwYWdlVVJMT3JpZ2luYWwpKQorICAgIGlmICghaXNFbmFi bGVkKCkgfHwgIWRvY3VtZW50Q2FuSGF2ZUljb24ocGFnZVVSTE9yaWdpbmFsKSkKICAgICAgICAg cmV0dXJuOwogICAgIAogICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX3VybEFuZEljb25Mb2NrKTsK QEAgLTU3OSw3ICs1NzksNyBAQCB2b2lkIEljb25EYXRhYmFzZTo6c2V0SWNvblVSTEZvclBhZ2VV UkwoY29uc3QgU3RyaW5nJiBpY29uVVJMT3JpZ2luYWwsIGNvbnN0IFN0cgogICAgIAogICAgIEFT U0VSVCghaWNvblVSTE9yaWdpbmFsLmlzRW1wdHkoKSk7CiAgICAgICAgIAotICAgIGlmICghaXNP cGVuKCkgfHwgIXBhZ2VDYW5IYXZlSWNvbihwYWdlVVJMT3JpZ2luYWwpKQorICAgIGlmICghaXNP cGVuKCkgfHwgIWRvY3VtZW50Q2FuSGF2ZUljb24ocGFnZVVSTE9yaWdpbmFsKSkKICAgICAgICAg cmV0dXJuOwogICAgIAogICAgIFN0cmluZyBpY29uVVJMLCBwYWdlVVJMOwpAQCAtODg5LDcgKzg4 OSw3IEBAIFBhZ2VVUkxSZWNvcmQqIEljb25EYXRhYmFzZTo6Z2V0T3JDcmVhdGVQYWdlVVJMUmVj b3JkKGNvbnN0IFN0cmluZyYgcGFnZVVSTCkKICAgICAvLyBDbGllbnRzIG9mIGdldE9yQ3JlYXRl UGFnZVVSTFJlY29yZCgpIGFyZSByZXF1aXJlZCB0byBhY3F1aXJlIHRoZSBtX3VybEFuZEljb25M b2NrIGJlZm9yZSBjYWxsaW5nIHRoaXMgbWV0aG9kCiAgICAgQVNTRVJUKCFtX3VybEFuZEljb25M b2NrLnRyeUxvY2soKSk7CiAKLSAgICBpZiAoIXBhZ2VDYW5IYXZlSWNvbihwYWdlVVJMKSkKKyAg ICBpZiAoIWRvY3VtZW50Q2FuSGF2ZUljb24ocGFnZVVSTCkpCiAgICAgICAgIHJldHVybiAwOwog CiAgICAgUGFnZVVSTFJlY29yZCogcGFnZVJlY29yZCA9IG1fcGFnZVVSTFRvUmVjb3JkTWFwLmdl dChwYWdlVVJMKTsKQEAgLTkyNyw3ICs5MjcsNyBAQCB2b2lkIEljb25EYXRhYmFzZTo6aW1wb3J0 SWNvblVSTEZvclBhZ2VVUkwoY29uc3QgU3RyaW5nJiBpY29uVVJMLCBjb25zdCBTdHJpbmcmCiAg ICAgLy8gVGhpcyBmdW5jdGlvbiBpcyBvbmx5IGZvciBzZXR0aW5nIGFjdHVhbCBleGlzdGluZyB1 cmwgbWFwcGluZ3Mgc28gYXNzZXJ0IHRoYXQgbmVpdGhlciBvZiB0aGVzZSBVUkxzIGFyZSBlbXB0 eQogICAgIEFTU0VSVCghaWNvblVSTC5pc0VtcHR5KCkpOwogICAgIEFTU0VSVCghcGFnZVVSTC5p c0VtcHR5KCkpOwotICAgIEFTU0VSVChwYWdlQ2FuSGF2ZUljb24ocGFnZVVSTCkpOworICAgIEFT U0VSVChkb2N1bWVudENhbkhhdmVJY29uKHBhZ2VVUkwpKTsKICAgICAKICAgICBzZXRJY29uVVJM Rm9yUGFnZVVSTEluU1FMRGF0YWJhc2UoaWNvblVSTCwgcGFnZVVSTCk7ICAgIAogfQpAQCAtMTIz NCw3ICsxMjM0LDcgQEAgdm9pZCBJY29uRGF0YWJhc2U6OnBlcmZvcm1VUkxJbXBvcnQoKQogICAg ICAgICAgICAgLy8gc28gZ28gYWhlYWQgYW5kIGFjdHVhbGx5IGNyZWF0ZSBhIHBhZ2VVUkxSZWNv cmQgZm9yIHRoaXMgdXJsIGV2ZW4gdGhvdWdoIGl0J3Mgbm90IHJldGFpbmVkLgogICAgICAgICAg ICAgLy8gSWYgZGF0YWJhc2UgY2xlYW51cCAqaXMqIGFsbG93ZWQsIHdlIGRvbid0IHdhbnQgdG8g Ym90aGVyIHB1bGxpbmcgaW4gYSBwYWdlIHVybCBmcm9tIGRpc2sgdGhhdCBub29uZSBpcyBhY3R1 YWxseSBpbnRlcmVzdGVkCiAgICAgICAgICAgICAvLyBpbiAtIHdlJ2xsIHBydW5lIGl0IGxhdGVy IGluc3RlYWQhCi0gICAgICAgICAgICBpZiAoIXBhZ2VSZWNvcmQgJiYgZGF0YWJhc2VDbGVhbnVw Q291bnRlciAmJiBwYWdlQ2FuSGF2ZUljb24ocGFnZVVSTCkpIHsKKyAgICAgICAgICAgIGlmICgh cGFnZVJlY29yZCAmJiBkYXRhYmFzZUNsZWFudXBDb3VudGVyICYmIGRvY3VtZW50Q2FuSGF2ZUlj b24ocGFnZVVSTCkpIHsKICAgICAgICAgICAgICAgICBwYWdlUmVjb3JkID0gbmV3IFBhZ2VVUkxS ZWNvcmQocGFnZVVSTCk7CiAgICAgICAgICAgICAgICAgbV9wYWdlVVJMVG9SZWNvcmRNYXAuc2V0 KHBhZ2VVUkwsIHBhZ2VSZWNvcmQpOwogICAgICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNlLmggYi9Tb3VyY2UvV2ViQ29yZS9sb2Fk ZXIvaWNvbi9JY29uRGF0YWJhc2UuaAppbmRleCBiNTkzNzY0Li41NDZmMDg1IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0YWJhc2UuaApAQCAtMTM2LDYgKzEzNiw3IEBAIHBy aXZhdGU6CiBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIGlzT3BlbigpIGNvbnN0OwogICAgIHZp cnR1YWwgU3RyaW5nIGRhdGFiYXNlUGF0aCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBkb2N1 bWVudENhbkhhdmVJY29uKGNvbnN0IFN0cmluZyYgZG9jdW1lbnRVUkwpIGNvbnN0OwogICAgIHN0 YXRpYyBTdHJpbmcgZGVmYXVsdERhdGFiYXNlRmlsZW5hbWUoKTsKIAogcHJpdmF0ZToKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZUJhc2UuaCBiL1Nv dXJjZS9XZWJDb3JlL2xvYWRlci9pY29uL0ljb25EYXRhYmFzZUJhc2UuaAppbmRleCBiYzY2NWJh Li4xNmVhOGE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9sb2FkZXIvaWNvbi9JY29uRGF0 YWJhc2VCYXNlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL2ljb24vSWNvbkRhdGFiYXNl QmFzZS5oCkBAIC0xNjUsNiArMTY1LDcgQEAgcHVibGljOgogCiAgICAgLy8gVXNlZCBpbnRlcm5h bGx5IGJ5IFdlYkNvcmUKICAgICB2aXJ0dWFsIGJvb2wgaXNFbmFibGVkKCkgY29uc3QgeyByZXR1 cm4gZmFsc2U7IH0KKyAgICB2aXJ0dWFsIGJvb2wgZG9jdW1lbnRDYW5IYXZlSWNvbihjb25zdCBT dHJpbmcmKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICAKICAgICB2aXJ0dWFsIHZv aWQgcmV0YWluSWNvbkZvclBhZ2VVUkwoY29uc3QgU3RyaW5nJikgeyB9CiAgICAgdmlydHVhbCB2 b2lkIHJlbGVhc2VJY29uRm9yUGFnZVVSTChjb25zdCBTdHJpbmcmKSB7IH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL21hbnVhbC10ZXN0cy9yZXNvdXJjZXMvZmF2aWNvbi1sb2Fkcy1mb3It bG9jYWwtZmlsZXMuaHRtbCBiL1NvdXJjZS9XZWJDb3JlL21hbnVhbC10ZXN0cy9yZXNvdXJjZXMv ZmF2aWNvbi1sb2Fkcy1mb3ItbG9jYWwtZmlsZXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi5iOGU4NzVmCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv bWFudWFsLXRlc3RzL3Jlc291cmNlcy9mYXZpY29uLWxvYWRzLWZvci1sb2NhbC1maWxlcy5odG1s CkBAIC0wLDAgKzEsMTAgQEAKKzxodG1sPgorPGhlYWQ+Cis8L2hlYWQ+Cis8bGluayB0eXBlPSJp bWFnZS9wbmciIGhyZWY9ImZhdmljb24ucG5nIiBzaXplcz0iNjR4NjQiIHJlbD0iaWNvbiIgLz4K Kzxib2R5PgorPHA+SXQncyBleHBlY3RlZCB0aGF0IHlvdSBzZWUgYSBmYXZpY29uIGRpc3BsYXll ZCBmb3IgdGhpcyBwYWdlIHdoZW4geW91IG9wZW4gaXQgYXMgYSBsb2NhbCBmaWxlLjwvcD4KKzxw PlRoZSBmYXZpY29uIGxvb2tzIGxpa2UgdGhpczo8L3A+Cis8aW1nIHNyYz0iZmF2aWNvbi5wbmci Lz4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL21hbnVhbC10 ZXN0cy9yZXNvdXJjZXMvZmF2aWNvbi5wbmcgYi9Tb3VyY2UvV2ViQ29yZS9tYW51YWwtdGVzdHMv cmVzb3VyY2VzL2Zhdmljb24ucG5nCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM1NzE3Y2NhNThmOTdjNzljM2QzMjRl ODM1N2I0YzRmN2IxZTE0NjQKR0lUIGJpbmFyeSBwYXRjaApsaXRlcmFsIDM5NjEKemNtVi08NH5G b0dQKTxoOzNLfExrMDAwZTFOSkxUcTAwMXhtMDAxeHUxXkBzNlJ8NUhtMDAwMDZWb09JdjBSOH59 CnowUkhQMylQZXYyMDEwcU5TI3RtWTA3dzc7MDd3OHYkIWs2VTAwMFNnYTZ4QVAwMDF4bTAwMXht JmhDcz8wMDBpNgp6TmtsPFpYeGBQRFltZ2pRYjtwMUEtdE0wRiZnXkAmXjIoQWUyPzslbjM5XkZg SU17JkFCUkl2STZlZnZOS3RiWSkKelQ/VWhvUEB5MHB1MmVxY1ZGSDF8Tnc3b2whM0JtR05GY19i dlV4YTtFTCNHfShuXyt0VEozN3p5UiRSWHVYfUdrCnpia0ZTVUwpSHJYZztSQl5kd1AwJHt7TVVh PWlKKztUVWN4UGJ2RWI0eHt3ZTtHPFIyUStzKEZiP1RhdmE7I2F2dwp6OCklc1ZtVG1qKC1VUXVy bFhgUkN7PDM2I0RGUHwqY0VDPjR2ejs0P3FGZm50dmJrT3AjYFMxJVctXj5PSktGfUAKejAyK3U+ WnwpbndUcT09RUNYait4c2tAfmVGV2MqdWRmejN6Pnwzb0I5bT9eOSVvTDFwaWJ9X1VIRExgTWBA LXItCnpUY2VOSWg0RjdSTXZmbmRZUEFJKlQ7V1laPm41XnAwJlMhMlBec2o1dyhxLUJ5NGVxUGJa X3VfSGVGVGo9LURDPgp6NG5kPnw7K1A8YzNCczYwbkN2JSMyPHkrXylKN1oxOX03KHNvRGcmNF9l QXNLQytkP2t3SUc8VTBnYVNNbCMoem4KejNWe143MWwrRGBaZ2ApWURTYyshT0o3O3V4QCYoOT1A UHs7ZXh3T1BvZEF5X3szeWxgV0JmM3A1a35reUApXktqCnpraWomJGcoQ3x4NHR8IWMpJGF9Skdp UFZWaj9NYVdiQms/Njspe3tFWGNjTm9DYiNYWHsmTjRPPy1aUWUmVD17SAp6Y0lBcWMzSSY0TGZK bjJgVDh4IXc+KTtyUnFZUkV4SU1VIUtnSG5QPjg+fEtHXnwwOWVUT0UhK2RaU2d4X0JvI1gKenI9 amRDOX5wYzg3WlohcVhYYiQjOzBxeio3bX0yLTlgTk5vKkl0el5fQzRIe2JOZjVgJmtGNzUkPm9i PVRuQl9rCnpVPXZVcHZ9NGk2cHBgQGBNWFVfMkJaOyZgRE1fVDAwa3pnNWpnSj5yV3YlbnROYENJ cDlXfUxackxnaDY+RUVqfgp6Pld4JVZgalFBViFUMD5lPnUkPUgkYDFAd3ZYeEBiWClHNFpaZ3lV TTlidjNuQmRASWApKUxud3BxbkdFbHRqdHwKenlwakAkSyZSNnxhciohMERqdVhVR2w7SilFN2Rk SXgzR0R+NUhxNzZPOV9aSkphI1FQJHJsS0tFYlA4XlNHTCZrCnp6XjJ8fXJFQm1randfTUVwP2Ay SThDVCZzM2IqTT47aT8yXkF7Jnt3NUk5bnpNQ3oqVEY5bXBvaTFOVDB4PVJQaAp6RUYzVDNSUTQ3 M3pVRUpXMD8re3pmaF56JUE+X0lVMnE5ISkqUkl9PGFfQElIXiVnN1Q0UUZzMWYjV0V3Y0lmVGoK emkwZTJsO0V0M3lOfXwkekI/WW9NQD1fd0RLJjhHa19kKUQqVjZfWEAyZW5BfCY8VlFwJEZmO3ot alV6X0B8I2w8CnpyRjVHQ2x4Vi1lU19HUVhzZFI3cT0wR0prJl5oPSMlOEBQaWEmVHQmODV8eyg1 cUE+Y3N0TFJXSFVUY0FLI0J5bwp6NVh0dlZpYCpgdk11QGRCUWJ+am08VF9gYDxtI0BmWWA4UEs7 cXQ5MV8jJSk4Kz9BTnVpaCEoS3tufEdjSkAyYWkKek8+O3N5WUg0JkdNSjZpPD9Camd2S21MfVpo YVNUYiVZalFOVFkjbUlaUXhtUXorJFAzSlBYdDFSKD5TO1YjJH1NCnp1dWZPbS1UMEN9T0Y8Vj5V bk0yRSNeXmk2YWBfKU5fN15nbG9KfXNTQiN4N35RaUBENSF0SCNUbGYoRChnS3ZJYAp6STBfUz4y JjRkbk5FU3J0ZWdacnQwJDIrezchcz0tUX5CI3pZPzRUMj1qMXw0QG84fCVue3IhVGBpZkxPY182 bmsKejNNKFRaZHRVajUtfE9xPjluNi07bEpLaVUmeHdRLWp3Mkd1RDFsZTMoSiUpJWNKTjF0d25i PldOWDNke2FVQTFeCnowbk1APWQhMWxha34ze3B0RTJaY1VObD5CZHhxe3hhcHFFQW1KMk5jJkRs MVc/WU5fdWkjI19Jckx0Jk5tYypxfQp6MnFfUlUoWDUqX09wVHZOJH02UGVTWk5rKEVxKWpoI19f VW1eN1dIK2JrJnczcHdpck5WaFk4eGZZK1ZmeGNTTy0KejxlTFBYQ2llQ1NpMlJQMV9ZZWV8XjV5 WkNaYnxobTlmZmpMUVU8TjBLSlZnSkd4Jj1jcyZnfDBlalNAbVh4UjMoCnp2bjdtVT5PcGB1ZEtw Qy1Fei0kUnZMI3cwRlBqeGlOd1RGbVQpa0x1ZE4jZDIjcDxPNVR0RXNUTUVnVzBhezJQeAp6RGd+ SyRhdj0hVyhrdyF0THtkP0wqaWIhcDc1bER4QmNWMH5WTjlsQDZXbENlNy1PdShUNyQ4TUQybDIx MGJ2eFMKeiRENXd+VmJ8PFcqfD44OERQXmlQbk17aD5CLUtoOUdUdUI8KzxQUE5GRGRZNDVtLWpS RF4lV0JzO3FTPG1IZXItCno3UlIrMVRjeSVCMDRrRiUrOUxjWUxUaUlJMkdNd29PbjRybFdBY3RC JTQjQ2w1YSRmQioyTE8/d1JDaXhyQ2YwbQp6TmRtQCMoR3NILStQTFcwNU8tRHkhJVRQQSVlTFJ7 TkxeUXM0ODUkWiZyT0QzYH1YfihwTEUqd0ZDLWd0bkdVUi0Kek9KdlgtRiN9cD90Tn4qenI0MSl9 Xng9UEp8NkJlcjEqOGNoalVSKzhIaGxVc2tNbzxhbyNmKT8wX0FtX1hGVFk5CnpTTXlWJlc7eVdp b0RWIytFQ1FLfm1xUiNNMyZ2VzYwY2tBODdfYnM2KChvIW4lXiMhZ00+TjhhU2BlaG08dFNPSwp6 RGFocEhJKU1GaHJuU0x1IzNkbE5NNCtkfmk/azZacEMyVythRXgzJk9EM0RhYkRibzRyTm1mRzk3 bHY8I0xQXjwKejxuJVBjJU1nWnxGaXQkdThncSR2c2FqaTw1fHtSeSptezYhNWghPEUoY0AoYjJJ Q1ghNyhlaGFIWVNQe1BOYjYzCnpDSzNzMFpMbiZaPjR8WVZgWmZ+OEY8fjROI2hOSkFUPGooKGp4 M0xUZHk9MzM/KmdaZkVeX3s/UGNFKyorTG1ZUQp6bytBNi0pWFVKO3tDYXFfUmlXVmdUO058V0pC eWRHNyZzYCRwdFdmJnpMR1ZKWGpLVm9MSytQcEZHfDJDd358Uk4KenlieXVzakA5X2JLUndSKjVy NWg3U35jZF8hM0I7VFQ7TXpSazgjc2AyNipvc210UXpDSHRCZUBnZ1NyYk9lMm0kCnp5V2BkR0xo MEFpbkF1SHJzK1o4VyNGMClzUEYlK3R0cW95WGZyOWtESCUhU35oYD5XJTlfNXBfOSRwMjByNVIp Uwp6P3BNZFNgeUdkdjhWQGNvX1F9UnN7ekRVbWshSjUzSzhUV25gckleIUFOXk5Le1pGQlQwenJL VExZeWFDOXc3YG0KemtAKnNTbHQ/RnhiUSsweCVeVyFUPE5ePFZ7YHVBJUFjU0Qrbys0TjVEemFy fmYhY2hgPjd6QkN7PmQhVyo8YGpKCnpmOE9Xc0tZRTxNZFNLN21GI3ppPEowUWZseCVydDVgQz11 Uis2IWZOLVN8TmN8SWc+fjNkOGhsZWlmQzBFailrdAp6MEZ9V2AkUTFCe2gpQWFpb09VRXVNaiZW eT8pezc3RSUycEltJCRyc2trYEwrVXxGQCYrT2p3b15NJGAwPTkhPCYKejBkVl4wQkxEZXNxeHw7 b1ooTmZeZCMkcl51PXdFQXhvMlpQT3hoc3pBVk1wVEVCRjVhZXN2NHVDIWZUNDFxUUZhCnpuYShU cyhGbWZuXk5fU3F7M3dhUU4mO1gxO3N8cS01ZGNhRi1oMkJkLXR6dnpXI0c/YF99dXh7Z0ZPNHgw dzJHMwp6QylAWHltVlc9R3YoeSVydWMzclVBfFJwRnFjcmpTIzYjMlBlbGhRZDUlbk5VTnJZJTgl ak5xJks8RD1CbFZmU0MKenIwSVR9MmtDTzYtSHRwbC1gZH1NVTR7S2A/cF5sJWA0T0tfLUZBZk9A c044emFlfCtJZX5MZik+fj5yKUFzRzZHCnpyKystUkFfcyg3NkBsdlVCT182eHg9XmR2WGFvX0JB Zno1ZEc9aGxHTn1PX2swek1fejFmTEt8YCN7bGgwQGxGagp6PXw9MUd3WGY/JklicyN+Z18kSG0q MjBPVzd3T3NIdjJqYlRiPjhzZCNTMkhFRWgpNSN7STUpcDlQJTRzb1B0a0MKeilMVWN7QEMlZEFR SnM4X2g5OTxPVkx3VTt3TSojU25GZGl7VEpxVnRyKnVLXkxjazRnPipMK0dadnRUUmp6YTYpCnpr PlVEczAlP2NhU3hJMi0qcFl1MFBVYl9odlZBfX0tcU1PUko7N0tARiNhVTZgVio5QFFIIUA+SHJ6 flhBPGB6RAp6JGQpZVpjfXJ0dEVxRUVSQ2l2I31UM2Z1I0kraF9UQmhidFA3UlBKNEs3VVZiXm9k JX5tZHkxYVdPMz5nd0cmP18KekFPRGQ0NFAqNTdTTHlGUWoyTHx3LT4oekp0OXd0cTgjODN7M1B8 ZXZ2eGxuOCZxUys2ekc7dHNWfWtxczxgZSpACnpqQERZb1NJXkFwMWlSdj4waXVPeDk9cVF4akdW N20jfWxuRG9GX1c8SDQzIXs4NSVmOVV3QFRDQXcheyVwfGV4NAp6ZEZVNyZHeWpjPDg/MHI2bzBx aXdfOztyJFJhYGN1ZlRSQGNleyhOZ2VPfkxGTTs8KVM9bD1XenFvPForYkxGblcKenZUTFJ9dSQo e3wxcX1xeilYRGVBdkJ6ZURgYUVqbGQtUWMzcm43NjdZKnZ4VXk1I2ExM2RKbj5MV1dYRmE+ZUZo CnolSmJoeCprfjFqVURxcnZuVilgcW1NMCNXPUkob1V2aXE3Y0hAdk5uK2RncHhwWnhPZldoOCQ1 VXNMRWYoUEUrRwp6dShocU13JWJ9X0dlQjVCYl5OJGw4MkBsfj5jP31JOUMySmczZW1kcGMzbmot QDhQN2tuWFVfaXtsbnp2ZjQxc14KekBCSHUoZVM/e0ZrbD40LThzPikmUDRNeTA/Y3t4VFpOfCQ7 YFVXJDZeMkB1YV5td2EmZjc1I2g9KVd3eENWXkdHCnpRRVJPZ0xURGdaSmJMaHY7QDt4bGs/O0F+ eFBOX2x6VjtqJmRQaC0/Q0phVG9IblBOVnZoWShYIWleX00rTH13SQp6OUtsRWFkSztobHp8WWFL Q0daWFJlZkFXT0piMGQ2KkwxTWBzdClGK0whTiFBTkBGb3oxIykmVzxVK1ApYkp0cEgKeih6YlNF QHRGZihEKCFncmdrdnx7UXwtUT8lYnooLWVybE1AMkZHdyohfDx1aTcoQn1QYjdaX3BWb0BZJUNA OzVkCnpkclEzZ2sybXEpN2UpeUVxXnpEZlVnT08xOHNCK2ZqMkUmO3pjRTIzdEdNLX1vN1d8d3Jm SElnNEU1QDxnV3VCVQp6aEpRQ1pfMUlWPkpFR2IwVE55dDAzUW5GRnBxa3NxZUFtczRAcD93KlVx IXVxLTMyZkI9MzU4KClQMXtgKSVVZTUKem5eIzxhT0o2R3w5OUw0VHhhKkk9Tit8KTxNeEgoNyV9 bV5zKzFqe01FRlMrSXpwfCY/Q3xAbkRhMWxWMTlVe3NPCnphV1Q5NkI/VWhIbHxCNk1wJFUjM3N4 dGFxZ1Z+OVlZK2xrY2tZUStSb352S28keEhXQG5IJnFhPU9lI2h8Q0BUYgp6PCtpfn5CaFdeb0RN fW1HV185QFZrM1F7bV9USEQ8KHpzaT1gQnoyeGpoQGFBNl4rKmtIdEcwP2lgKlM1Q0FqaEoKentv TUhXZWdOdiM3XnleU3pHenpDVjIwMHJidVY2NEVeNyp9bzReVlomMWJxZ299Ry1VdnA9fVkmRjNy TDsxI2NOCnokXio5dTw/Z2E3aSpAb3M+VXN3Jkd4LUg5VSVEYGltODRkfVRpMjhOSGFScyhMX2lT TD53WXdSPFhkcCRkd31QWgp6eVNrbFhjXzlDfih4Oyh0YEZhV2JEekAlZDRWc2dqNVRaSFIjVSVP QloxLWoyYEklfXdLUXJvQVVvdzIpK3F6K2wKemI8JXMrI0Y5TT09fWFvSDArRFZwPjkrbWNSV0ph b0t7ZWBuMVRaaGdsWF53bGxscylOSyF2MkktPmhgNCo5dXR2CnpndWVZcmVlO3xQaiRfLV8yV0RU NGNPX1E3Y0NlQ15XYk9BUFI9cUVBMzRoKG4kNnR4UzhmMGlBYmd7UXBVWChYaAp6e3ZTekByb1cy dWlxUVo3MDN+IXFTYWY0QFducHc+RW81UElXZEpmVEZnWXpURmZBfU9SNTNPPkdCcjlkR0FsN0sK ekl4c0xBRz1CTDIwMDFSKU1PYnVnWik5bV5jYGFtTmJZJWNDRmZjaFNGKSVHS0hCPlArSXg7bW5G ZnVES0ZnaD9XClRNVEgyPjAwMDAwTmt2WFh1MG1qZjRSTlcoCgpsaXRlcmFsIDAKSGNtVj9kMDAw MDEKCg==