37880 2010-04-20 12:15:24 -0700 [Qt] Patch for checking content types supported by the QWebPage... 2010-10-14 17:27:51 -0700 1 1 1 Unclassified WebKit WebKit Qt 528+ (Nightly build) All All RESOLVED FIXED Qt, QtTriaged P2 Enhancement --- 31552 1 adawit adawit adjam7 commit-queue hausmann jedrzej.nowacki jesus kenneth laszlo.gombos tonikitoo oldest_to_newest 214840 0 adawit 2010-04-20 12:15:24 -0700 The patch provided here adds a function to query the frame for the content it supports. It can be used to query QtWebKit whether or not it can handle a specific content type. The motivation for this patch is to address a crucial QtWebKit/KDE integration issue. The issue stems from the fact that the KDE integration of QtWebKit changes QtWebKit to use KDE's KIO subsytem for network communication. In doing so, it causes an issue we cannot simply workaround in KDE whenever we need to determine content type and pause the ioslave and transfer/resume it using another request/job. I can provide a detailed analysis of this issue, but essentially all QtWebKit based KDE browsers (e.g. reKonq) are afflicted with this problem. Originally it was thought the problem can be resolved without requiring changes upstream, but further investigation showed that was not possible. If this patch is not acceptable as it stand, it can easily be modified and perhaps be added as a protected member function of QWebPage. Perhaps that would be more acceptable. Regardless, if we are unable to query QtWebKit for the content that it can/cannot handle the issue downstream will never be resolved... 214852 1 53863 adawit 2010-04-20 12:21:53 -0700 Created attachment 53863 Function for checking content-type supported by QWebFrame... 220646 2 adawit 2010-05-04 10:25:57 -0700 The patch provided here adds a function to query the frame for the content it supports. It can be used to query QtWebKit whether or not it can handle a specific content type. The motivation for this patch is to address a crucial QtWebKit/KDE integration issue. The issue stems from the fact that the KDE integration of QtWebKit changes QtWebKit to use KDE's KIO subsytem for network communication. In doing so, it causes an issue we cannot simply workaround in KDE whenever we need to determine content type and pause the ioslave and transfer/resume it using another request/job. I can provide a detailed analysis of this issue, but essentially all QtWebKit based KDE browsers (e.g. reKonq) are afflicted with this problem. Originally it was thought the problem can be resolved without requiring changes upstream, but further investigation showed that was not possible. If this patch is not acceptable as it stand, it can easily be modified and perhaps be added as a protected member function of QWebPage. Perhaps that would be more acceptable. Regardless, if we are unable to query QtWebKit for the content that it can/cannot handle the issue downstream will never be resolved... 223309 3 53863 hausmann 2010-05-10 07:48:25 -0700 Comment on attachment 53863 Function for checking content-type supported by QWebFrame... I suggest to send an email to webkit-qt@lists.webkit.org to see what the others thing. But I'm okay with having this in the API. r- because it should be static and probably in a different class. See the implementaion in FrameLoaderClientQt, it only calls static functions :) 223352 4 adawit 2010-05-10 09:17:08 -0700 (In reply to comment #3) > (From update of attachment 53863 [details]) > I suggest to send an email to webkit-qt@lists.webkit.org to see what the others thing. But I'm okay with having this in the API. > > r- because it should be static and probably in a different class. See the > implementaion in FrameLoaderClientQt, it only calls static functions :) Which class ? QWebSettings or QWebPage ? There is no other place to put it other than that. Also if the function is made static, it would mean duplicating the code and hence all the necessary headers from FrameLoaderClientQt::canShowMIMEType. Is that acceptable thing to do ? 266199 5 64726 adawit 2010-08-18 10:16:42 -0700 Created attachment 64726 Function for checking content-type supported by QWebFrame II... Updated patch: * Changed the function name to isSupportedContentType. * Added a new function, supportedContentTypes() to return all supported content types. @simon: I cannot make these functions static because I will not be able to access the frame's local QWebSettings (d->frame->settings()) to obtain the mimetypes supported by any uploaded plugins just like in FrameLoaderClientQt::canShowMIMEType. Also, you did not say which class these functions might belong to other than where they are, QWebSettings, QWebPage ?? Once these issues are resolved, I can provide unit test cases for these function. 266336 6 64726 kling 2010-08-18 13:23:31 -0700 Comment on attachment 64726 Function for checking content-type supported by QWebFrame II... >WebKit/qt/Api/qwebframe.cpp:1416 > + * Returns true if the frame can handle the given mimeType, false otherwise. Missing \a before "mimeType" And the typical Qt documentation idiom seems to be "Returns true if X; otherwise returns false." >WebKit/qt/Api/qwebframe.cpp:1418 > + bool QWebFrame::isSupportedContentType(const QString &mimeType) const Coding style, should be "const QString& mimeType" >WebKit/qt/Api/qwebframe.cpp:1453 > + const Vector<PluginPackage*> &plugins = PluginDatabase::installedPlugins()->plugins(); Coding style, should be "const Vector<PluginPackage*>& plugins" >WebKit/qt/Api/qwebframe.h:201 > + bool isSupportedContentType(const QString &mimeType) const; Coding style, should be "const QString& mimeType" There is also some inconsistency wrt tab size (should always be 4 spaces.) 266367 7 64726 tonikitoo 2010-08-18 14:10:19 -0700 Comment on attachment 64726 Function for checking content-type supported by QWebFrame II... Generally, looks good. Please fix kling's suggest and also add a changelog entry. I am asking myself if these method should go to QWebFrame. Personally I thing they do not belong to a particularly frame of your page, so I'd rather add them to QWebPage. > +/*! > + * \since 4.8 > + * > + * Returns true if the frame can handle the given mimeType, false otherwise. > + */ > +bool QWebFrame::isSupportedContentType(const QString &mimeType) const Maybe naming it like: QWeb{Frame or Page}::supportsContentType(XXX) ? not sure ... Please block the meta bug for API change in Qt4.8/QtWebKit2.1 : bug 31552 > +/*! > + * \since 4.8 > + * > + * Returns the list of all content types supported by this frame. > + */ > +QStringList QWebFrame::supportedContentTypes() const > +{ > + QStringList mimeTypes; > + > + extractContentTypeFromHash(MIMETypeRegistry::getSupportedImageMIMETypes(), mimeTypes); > + extractContentTypeFromHash(MIMETypeRegistry::getSupportedNonImageMIMETypes(), mimeTypes); why not making a static helper function for the block below, similarly to what you did above? > + if (d->frame && d->frame->settings() && d->frame->settings()->arePluginsEnabled()) { > + const Vector<PluginPackage*> &plugins = PluginDatabase::installedPlugins()->plugins(); > + for (unsigned int i = 0; i < plugins.size(); ++i) { > + MIMEToDescriptionsMap::const_iterator map_it = plugins[i]->mimeToDescriptions().begin(); > + MIMEToDescriptionsMap::const_iterator map_end = plugins[i]->mimeToDescriptions().end(); > + for (; map_it != map_end; ++map_it) > + mimeTypes << map_it->first; > + } > + } > + > + return mimeTypes; > +} 266404 8 adawit 2010-08-18 14:58:54 -0700 (In reply to comment #6) > (From update of attachment 64726 [details]) > >WebKit/qt/Api/qwebframe.cpp:1418 > > + bool QWebFrame::isSupportedContentType(const QString &mimeType) const > Coding style, should be "const QString& mimeType" There are a lot of already implemented functions in that class that do not follow this guideline. In fact, I wrote the functions that way because the functions immediately above it did the same exact thing. It is rather confusing though :( Anyhow, I will fix my patch accordingly. 266405 9 adawit 2010-08-18 14:59:37 -0700 (In reply to comment #7) > (From update of attachment 64726 [details]) > Generally, looks good. Please fix kling's suggest and also add a changelog entry. > > I am asking myself if these method should go to QWebFrame. Personally I thing they do not belong to a particularly frame of your page, so I'd rather add them to QWebPage. > > > +/*! > > + * \since 4.8 > > + * > > + * Returns true if the frame can handle the given mimeType, false otherwise. > > + */ > > +bool QWebFrame::isSupportedContentType(const QString &mimeType) const > > Maybe naming it like: QWeb{Frame or Page}::supportsContentType(XXX) ? not sure ... > > Please block the meta bug for API change in Qt4.8/QtWebKit2.1 : bug 31552 > > > +/*! > > + * \since 4.8 > > + * > > + * Returns the list of all content types supported by this frame. > > + */ > > +QStringList QWebFrame::supportedContentTypes() const > > +{ > > + QStringList mimeTypes; > > + > > + extractContentTypeFromHash(MIMETypeRegistry::getSupportedImageMIMETypes(), mimeTypes); > > + extractContentTypeFromHash(MIMETypeRegistry::getSupportedNonImageMIMETypes(), mimeTypes); > > why not making a static helper function for the block below, similarly to what you did above? > > > + if (d->frame && d->frame->settings() && d->frame->settings()->arePluginsEnabled()) { > > + const Vector<PluginPackage*> &plugins = PluginDatabase::installedPlugins()->plugins(); > > + for (unsigned int i = 0; i < plugins.size(); ++i) { > > + MIMEToDescriptionsMap::const_iterator map_it = plugins[i]->mimeToDescriptions().begin(); > > + MIMEToDescriptionsMap::const_iterator map_end = plugins[i]->mimeToDescriptions().end(); > > + for (; map_it != map_end; ++map_it) > > + mimeTypes << map_it->first; > > + } > > + } > > + > > + return mimeTypes; > > +} 266410 10 adawit 2010-08-18 15:04:05 -0700 (In reply to comment #7) > (From update of attachment 64726 [details]) > Generally, looks good. Please fix kling's suggest and also add a changelog entry. > > I am asking myself if these method should go to QWebFrame. Personally I thing they do not belong to a particularly frame of your page, so I'd rather add them to QWebPage. > > > +/*! > > + * \since 4.8 > > + * > > + * Returns true if the frame can handle the given mimeType, false otherwise. > > + */ > > +bool QWebFrame::isSupportedContentType(const QString &mimeType) const > > Maybe naming it like: QWeb{Frame or Page}::supportsContentType(XXX) ? not sure ... Well I can name the function "canHandleContentType(xxx)" which is what I originally wanted to name it because it reflects exactly what the function does... As to where to add these functions, I settled on QWebFrame because by default QtWebKit sets the current frame as the originating object when constructing QNetworkRequest objects... 266419 11 64781 adawit 2010-08-18 15:31:40 -0700 Created attachment 64781 Function for checking content-type supported by QWebFrame III... Fixed all the issues pointed out by the reviews. Also renamed "isSupportedContentType(xxx)" to "canHandleMimeType(xxx)". I also wonder whether or not there should be some mechanism to prevent QtWebKit from handling certain mimetypes. For example, by default QtWebKit (read: webkit) handles all "text/" mime-types. However, in places where such option is configurable, e.g. KDE, there is no way to prevent QtWebKit from doing this. In fact, a bug report has already been filed against kwebkit about this very same issue. See https://bugs.kde.org/show_bug.cgi?id=242417. 268573 12 65275 adawit 2010-08-24 08:50:03 -0700 Created attachment 65275 Function for checking content-type supported by QWebPage I... Moved the function to QWebPage as suggested by Antonio in comment #7... 268579 13 65275 kenneth 2010-08-24 08:59:53 -0700 Comment on attachment 65275 Function for checking content-type supported by QWebPage I... WebKit/qt/Api/qwebpage.cpp:2164 + static void extractContentTypeFromHash(const HashSet<String>& types, QStringList& list) I dont like not being able to see that is being written to. The name doesn't help making that clear. In Qt, we prefer pointers for out values as that makes the code more clear: ex. extractContentTypeFromHash(types, &outList); 268641 14 65275 tonikitoo 2010-08-24 10:45:03 -0700 Comment on attachment 65275 Function for checking content-type supported by QWebPage I... > diff --git a/WebKit/qt/Api/qwebpage.cpp b/WebKit/qt/Api/qwebpage.cpp > index 5eee21c..3b86582 100644 > --- a/WebKit/qt/Api/qwebpage.cpp > +++ b/WebKit/qt/Api/qwebpage.cpp > @@ -85,6 +85,9 @@ > #include "PageClientQt.h" > #include "WorkerThread.h" > #include "wtf/Threading.h" > +#include "MIMETypeRegistry.h" > +#include "PluginDatabase.h" > +#include "PluginPackage.h" > > #include <QApplication> > #include <QBasicTimer> > @@ -2158,6 +2161,63 @@ QObject *QWebPage::createPlugin(const QString &classid, const QUrl &url, const Q > return 0; > } > > +static void extractContentTypeFromHash(const HashSet<String>& types, QStringList& list) > +{ > + HashSet<String>::const_iterator endIt = types.end(); > + for (HashSet<String>::const_iterator it = types.begin(); it != endIt; ++it) > + list << *it; > +} > + > +static void extractContentTypeFromPluginList(const Vector<PluginPackage*>& plugins, QStringList& list) > +{ > + for (unsigned int i = 0; i < plugins.size(); ++i) { > + MIMEToDescriptionsMap::const_iterator map_it = plugins[i]->mimeToDescriptions().begin(); > + MIMEToDescriptionsMap::const_iterator map_end = plugins[i]->mimeToDescriptions().end(); > + for (; map_it != map_end; ++map_it) > + list << map_it->first; > + } > +} > + > +/*! > + * \since 4.8 > + * > + * Returns the list of all content types supported by this frame. > + */ > +QStringList QWebPage::supportedContentTypes() const > +{ "by this frame" sounds out of date now :) other than that, looks fine. See kenneth's suggestion too. 268781 15 65320 adawit 2010-08-24 14:04:58 -0700 Created attachment 65320 Function for checking content-type supported by QWebPage II... Updated per review suggestions above... 269183 16 65320 tonikitoo 2010-08-25 05:41:24 -0700 Comment on attachment 65320 Function for checking content-type supported by QWebPage II... Almost there! One minor change I would like to see yet. See it below. > +/*! > + * \since 4.8 > + * > + * Returns the list of all content types supported by QWebPage. > + */ > +QStringList QWebPage::supportedContentTypes() const > +{ > + QStringList mimeTypes; > + > + WebCore::Frame *frame = d->page->focusController()->focusedOrMainFrame(); > + extractContentTypeFromHash(MIMETypeRegistry::getSupportedImageMIMETypes(), &mimeTypes); > + extractContentTypeFromHash(MIMETypeRegistry::getSupportedNonImageMIMETypes(), &mimeTypes); > + if (frame && frame->settings() && frame->settings()->arePluginsEnabled()) > + extractContentTypeFromPluginList(PluginDatabase::installedPlugins()->plugins(), &mimeTypes); Frame::settings() is just a shortcut for Page::settings. Lets use the later, please. if (d->page->settings()->arePluginsEnabled()) should work. or maybe with an additional null check for settings. > + > + WebCore::Frame *frame = d->page->focusController()->focusedOrMainFrame(); > + if (frame && frame->settings() && frame->settings()->arePluginsEnabled() && > + PluginDatabase::installedPlugins()->isMIMETypeRegistered(type)) Ditto. Other than that, it looks fine to me. 269248 17 65418 adawit 2010-08-25 07:51:26 -0700 Created attachment 65418 Function for checking content-type supported by QWebPage III... Changed frame->settings() to d->page->settings() as suggested in comment #16. 269727 18 tonikitoo 2010-08-25 22:58:11 -0700 (In reply to comment #17) > Created an attachment (id=65418) [details] > Function for checking content-type supported by QWebPage III... LGTM. Simon, Kenneth? 277252 19 adawit 2010-09-10 09:35:11 -0700 Can someone please review and land this patch or reject it and provide guidance ? We really need this to be available in QtWebKit 2.1 downstream in kdewebkit... 285575 20 65418 kenneth 2010-09-27 10:55:20 -0700 Comment on attachment 65418 Function for checking content-type supported by QWebPage III... View in context: https://bugs.webkit.org/attachment.cgi?id=65418&action=review How is this affecting performance?. LGTM. > WebKit/qt/Api/qwebpage.cpp:2174 > +static void extractContentTypeFromPluginList(const Vector<PluginPackage*>& plugins, QStringList* list) PluginList? It seems to be a vector. > WebKit/qt/Api/qwebpage.cpp:2188 > + * \since 4.8 I don't know if this is right, since this might be part of QtWebKit2.1, but well... > WebKit/qt/Api/qwebpage.cpp:2213 > + return true; indentation seems wrong here > WebKit/qt/Api/qwebpage.cpp:2216 > + return true; identation issue > WebKit/qt/Api/qwebpage.cpp:2218 > + if (d->page->settings() && d->page->settings()->arePluginsEnabled() && && should always be at the start of a line according to the style guide > WebKit/qt/Api/qwebpage.cpp:2220 > + return true; indentation issue 285576 21 kenneth 2010-09-27 10:55:45 -0700 Btw, how is the being tested? 285716 22 68952 adawit 2010-09-27 14:02:17 -0700 Created attachment 68952 65418: Function for checking content-type supported by QWebPage IV... Added test coverage and addressed the issues in the last review... 285721 23 68952 kenneth 2010-09-27 14:05:32 -0700 Comment on attachment 68952 65418: Function for checking content-type supported by QWebPage IV... View in context: https://bugs.webkit.org/attachment.cgi?id=68952&action=review > WebKit/qt/Api/qwebpage.cpp:2213 > + * \since QtWebKit 2.1 I think I should just leave this out for now. I'm not sure this will actually work or break the documentation. 286142 24 65418 eric 2010-09-28 03:18:39 -0700 Comment on attachment 65418 Function for checking content-type supported by QWebPage III... Cleared Kenneth Rohde Christiansen's review+ from obsolete attachment 65418 so that this bug does not appear in http://webkit.org/pending-commit. 287439 25 jedrzej.nowacki 2010-09-30 02:12:15 -0700 Minutes from the first iteration of the API review: - We agree that the functionality is missing in the current API. - Function canHandleSupportedTypes() should be renamed to supportsContentType() which would be symmetric to supportedContentType() and more Qtish. - Both functions should be methods of QWebPage and non static, because current API allows to change supported content types per instance of the QWebPage (by loading a plugin) Summary: The function name should be changed, personally I would like to see an autotest that checks what happens if a plugin is added/removed. Apart form that small issues the patch looks good. 287575 26 adawit 2010-09-30 09:10:40 -0700 (In reply to comment #25) > Minutes from the first iteration of the API review: > - We agree that the functionality is missing in the current API. > - Function canHandleSupportedTypes() should be renamed to supportsContentType() which would be symmetric to supportedContentType() and more Qtish. That is not a problem... > - Both functions should be methods of QWebPage and non static, because current API allows to change supported content types per instance of the QWebPage (by loading a plugin) They are already non-static... > Summary: > The function name should be changed, personally I would like to see an autotest that checks what happens if a plugin is added/removed. Apart form that small issues the patch looks good. That too can be done easily enough... 288254 27 adawit 2010-10-01 08:25:59 -0700 > > Summary: > > [...]personally I would like to see an autotest that checks what happens if a plugin is added/removed. Apart form that small issues the patch looks good. > That too can be done easily enough... Well I spoke too soon here... What kind of plugins are we talking about here ? Qt specific plugins (application/x-qt-plugin) ? webkit plugins that can be embeded into the page, e.g. NPAPI plugins (flash, java applets) ? As it stands right now, none of those are handled by these two new functions because those contents will never generate the "unsupportedContent" signal. 288290 28 69473 adawit 2010-10-01 09:23:06 -0700 Created attachment 69473 Function for checking content-type supported by QWebPage V... Renamed "canHandleContentType" to "supportsContentType" as requested by the API review. 288678 29 68952 eric 2010-10-02 05:30:13 -0700 Comment on attachment 68952 65418: Function for checking content-type supported by QWebPage IV... Cleared Kenneth Rohde Christiansen's review+ from obsolete attachment 68952 so that this bug does not appear in http://webkit.org/pending-commit. 290787 30 69473 kling 2010-10-06 21:03:50 -0700 Comment on attachment 69473 Function for checking content-type supported by QWebPage V... r=me We need to do something about the (lack of) \since tags. I'll open a new bug about that. 294487 31 69473 commit-queue 2010-10-14 17:27:44 -0700 Comment on attachment 69473 Function for checking content-type supported by QWebPage V... Clearing flags on attachment: 69473 Committed r69825: <http://trac.webkit.org/changeset/69825> 294488 32 commit-queue 2010-10-14 17:27:51 -0700 All reviewed patches have been landed. Closing bug. 53863 2010-04-20 12:21:53 -0700 2010-08-18 10:16:42 -0700 Function for checking content-type supported by QWebFrame... qtwebkit_check_supported_content_type.patch text/plain 1652 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBiL1dlYktpdC9xdC9BcGkv cXdlYmZyYW1lLmNwcAppbmRleCAzOTRlYTE3Li5iZGRiMTA0IDEwMDY0NAotLS0gYS9XZWJLaXQv cXQvQXBpL3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCkBA IC0xNTMzLDYgKzE1MzMsMTYgQEAgUVdlYlNlY3VyaXR5T3JpZ2luIFFXZWJGcmFtZTo6c2VjdXJp dHlPcmlnaW4oKSBjb25zdAogICAgIHJldHVybiBRV2ViU2VjdXJpdHlPcmlnaW4ocHJpdik7CiB9 CiAKKy8qIQorICAgIFxzaW5jZSA0LjcKKyAKKyAgICBSZXR1cm5zIHRydWUgaWYgdGhlIGZyYW1l IGNhbiBoYW5kbGUgdGhlIHNwZWNpZmllZCBcYSBtaW1ldHlwZS4KKyAqLworYm9vbCBRV2ViRnJh bWU6OmNhbkhhbmRsZU1JTUVUeXBlKGNvbnN0IFFTdHJpbmcmIG1pbWV0eXBlKSBjb25zdAorewor ICAgIHJldHVybiBkLT5mcmFtZS0+bG9hZGVyKCktPmNsaWVudCgpLT5jYW5TaG93TUlNRVR5cGUo bWltZXR5cGUpOworfQorCiBXZWJDb3JlOjpGcmFtZSogUVdlYkZyYW1lUHJpdmF0ZTo6Y29yZShR V2ViRnJhbWUqIHdlYkZyYW1lKQogewogICAgIHJldHVybiB3ZWJGcmFtZS0+ZC0+ZnJhbWU7CmRp ZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2Vi ZnJhbWUuaAppbmRleCBjZTk4MDViLi5hNTdiMjdkIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBp L3F3ZWJmcmFtZS5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgKQEAgLTE5NSw2ICsx OTUsOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIGV2ZW50KFFFdmVudCAqKTsKIAogICAg IFFXZWJTZWN1cml0eU9yaWdpbiBzZWN1cml0eU9yaWdpbigpIGNvbnN0OworICAgIAorICAgIGJv b2wgY2FuSGFuZGxlTUlNRVR5cGUoY29uc3QgUVN0cmluZyYgbWltZXR5cGUpIGNvbnN0OwogCiBw dWJsaWMgUV9TTE9UUzoKICAgICBRVmFyaWFudCBldmFsdWF0ZUphdmFTY3JpcHQoY29uc3QgUVN0 cmluZyYgc2NyaXB0U291cmNlKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9X ZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IDdkMzI0YWYuLjMzMzNmNGQgMTAwNjQ0Ci0tLSBhL1dl YktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2 IEBACisyMDEwLTA0LTIwICBEYXdpdCBBbGVtYXllaHUgIDxhZGF3aXRAa2RlLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKyAgICAgICAKKyAgICAgICAgQWRkZWQg ZnVuY3Rpb24gZm9yIGRldGVybWluaW5nIHRoZSB0eXBlcyBvZiBjb250ZW50IHRoYXQKKyAgICAg ICAgUVdlYkZyYW1lIGNhbiBoYW5kbGUuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTM3ODgwCisKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmNwcDoK KyAgICAgICAgKFFXZWJGcmFtZTo6Y2FuSGFuZGxlTUlNRVR5cGUpOgorICAgICAgICAqIEFwaS9x d2ViZnJhbWUuaDoKKwogMjAxMC0wNC0xOSAgSm9jZWx5biBUdXJjb3R0ZSAgPGpvY2VseW4udHVy Y290dGVAbm9raWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9uIEhhdXNtYW5uLgo= 64726 2010-08-18 10:16:42 -0700 2010-08-18 15:31:40 -0700 Function for checking content-type supported by QWebFrame II... function_for_checking_supported_content_type_2.patch text/plain 3080 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBiL1dlYktpdC9xdC9BcGkv cXdlYmZyYW1lLmNwcAppbmRleCAwYmI2OTIyLi40ZDQ2Njc5IDEwMDY0NAotLS0gYS9XZWJLaXQv cXQvQXBpL3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCkBA IC00MywxMCArNDMsMTMgQEAKICNpbmNsdWRlICJKU0RPTVdpbmRvd0Jhc2UuaCIKICNpbmNsdWRl ICJKU0xvY2suaCIKICNpbmNsdWRlICJKU09iamVjdC5oIgorI2luY2x1ZGUgIk1JTUVUeXBlUmVn aXN0cnkuaCIKICNpbmNsdWRlICJOb2RlTGlzdC5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNs dWRlICJQbGF0Zm9ybU1vdXNlRXZlbnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQu aCIKKyNpbmNsdWRlICJQbHVnaW5EYXRhYmFzZS5oIgorI2luY2x1ZGUgIlBsdWdpblBhY2thZ2Uu aCIKICNpbmNsdWRlICJQcmludENvbnRleHQuaCIKICNpbmNsdWRlICJQdXRQcm9wZXJ0eVNsb3Qu aCIKICNpbmNsdWRlICJSZW5kZXJMYXllci5oIgpAQCAtMTQwNyw2ICsxNDEwLDU5IEBAIFFXZWJT ZWN1cml0eU9yaWdpbiBRV2ViRnJhbWU6OnNlY3VyaXR5T3JpZ2luKCkgY29uc3QKICAgICByZXR1 cm4gUVdlYlNlY3VyaXR5T3JpZ2luKHByaXYpOwogfQogCisvKiEKKyAqICBcc2luY2UgNC44Cisg KiAKKyAqICBSZXR1cm5zIHRydWUgaWYgdGhlIGZyYW1lIGNhbiBoYW5kbGUgdGhlIGdpdmVuIG1p bWVUeXBlLCBmYWxzZSBvdGhlcndpc2UuCisgKi8KK2Jvb2wgUVdlYkZyYW1lOjppc1N1cHBvcnRl ZENvbnRlbnRUeXBlKGNvbnN0IFFTdHJpbmcgJm1pbWVUeXBlKSBjb25zdAoreworICAgIGNvbnN0 IFN0cmluZyB0eXBlID0gbWltZVR5cGUudG9Mb3dlcigpOworICAgIGlmIChNSU1FVHlwZVJlZ2lz dHJ5Ojppc1N1cHBvcnRlZEltYWdlTUlNRVR5cGUodHlwZSkpCisgICAgICByZXR1cm4gdHJ1ZTsK KworICAgIGlmIChNSU1FVHlwZVJlZ2lzdHJ5Ojppc1N1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGUo dHlwZSkpCisgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmIChkLT5mcmFtZSAmJiBkLT5mcmFt ZS0+c2V0dGluZ3MoKSAmJiBkLT5mcmFtZS0+c2V0dGluZ3MoKS0+YXJlUGx1Z2luc0VuYWJsZWQo KSAmJgorICAgICAgICBQbHVnaW5EYXRhYmFzZTo6aW5zdGFsbGVkUGx1Z2lucygpLT5pc01JTUVU eXBlUmVnaXN0ZXJlZCh0eXBlKSkKKyAgICAgIHJldHVybiB0cnVlOworCisgICAgcmV0dXJuIGZh bHNlOworfQorCitzdGF0aWMgdm9pZCBleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaChjb25zdCBI YXNoU2V0PFN0cmluZz4mIHR5cGVzLCBRU3RyaW5nTGlzdCYgbGlzdCkKK3sKKyAgICBIYXNoU2V0 PFN0cmluZz46OmNvbnN0X2l0ZXJhdG9yIGVuZEl0ID0gdHlwZXMuZW5kKCk7CisgICAgZm9yKEhh c2hTZXQ8U3RyaW5nPjo6Y29uc3RfaXRlcmF0b3IgaXQgPSB0eXBlcy5iZWdpbigpOyBpdCAhPSBl bmRJdDsgKytpdCkKKyAgICAgICAgbGlzdCA8PCAqaXQ7Cit9CisKKy8qIQorICogIFxzaW5jZSA0 LjgKKyAqCisgKiAgUmV0dXJucyB0aGUgbGlzdCBvZiBhbGwgY29udGVudCB0eXBlcyBzdXBwb3J0 ZWQgYnkgdGhpcyBmcmFtZS4KKyAqLworUVN0cmluZ0xpc3QgUVdlYkZyYW1lOjpzdXBwb3J0ZWRD b250ZW50VHlwZXMoKSBjb25zdAoreworICAgIFFTdHJpbmdMaXN0IG1pbWVUeXBlczsKKyAgICAK KyAgICBleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaChNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRTdXBw b3J0ZWRJbWFnZU1JTUVUeXBlcygpLCBtaW1lVHlwZXMpOworICAgIGV4dHJhY3RDb250ZW50VHlw ZUZyb21IYXNoKE1JTUVUeXBlUmVnaXN0cnk6OmdldFN1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGVz KCksIG1pbWVUeXBlcyk7CisgICAgaWYgKGQtPmZyYW1lICYmIGQtPmZyYW1lLT5zZXR0aW5ncygp ICYmIGQtPmZyYW1lLT5zZXR0aW5ncygpLT5hcmVQbHVnaW5zRW5hYmxlZCgpKSB7CisgICAgICAg IGNvbnN0IFZlY3RvcjxQbHVnaW5QYWNrYWdlKj4gJnBsdWdpbnMgPSBQbHVnaW5EYXRhYmFzZTo6 aW5zdGFsbGVkUGx1Z2lucygpLT5wbHVnaW5zKCk7CisgICAgICAgIGZvciAodW5zaWduZWQgaW50 IGkgPSAwOyBpIDwgcGx1Z2lucy5zaXplKCk7ICsraSkgeyAgICAgICAgICAgIAorICAgICAgICAg ICAgTUlNRVRvRGVzY3JpcHRpb25zTWFwOjpjb25zdF9pdGVyYXRvciBtYXBfaXQgPSBwbHVnaW5z W2ldLT5taW1lVG9EZXNjcmlwdGlvbnMoKS5iZWdpbigpOworICAgICAgICAgICAgTUlNRVRvRGVz Y3JpcHRpb25zTWFwOjpjb25zdF9pdGVyYXRvciBtYXBfZW5kID0gcGx1Z2luc1tpXS0+bWltZVRv RGVzY3JpcHRpb25zKCkuZW5kKCk7CisgICAgICAgICAgICBmb3IgKDsgbWFwX2l0ICE9IG1hcF9l bmQ7ICsrbWFwX2l0KQorICAgICAgICAgICAgICBtaW1lVHlwZXMgPDwgbWFwX2l0LT5maXJzdDsg ICAgICAgICAgICAKKyAgICAgICAgfSAgICAgICAgCisgICAgfQorICAgIAorICAgIHJldHVybiBt aW1lVHlwZXM7Cit9CisKKwogV2ViQ29yZTo6RnJhbWUqIFFXZWJGcmFtZVByaXZhdGU6OmNvcmUo UVdlYkZyYW1lKiB3ZWJGcmFtZSkKIHsKICAgICByZXR1cm4gd2ViRnJhbWUtPmQtPmZyYW1lOwpk aWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaCBiL1dlYktpdC9xdC9BcGkvcXdl YmZyYW1lLmgKaW5kZXggZTc4ZmIwNy4uZGU1ZDkxMSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0Fw aS9xd2ViZnJhbWUuaAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oCkBAIC0xOTgsNiAr MTk4LDkgQEAgcHVibGljOgogCiAgICAgUVdlYlNlY3VyaXR5T3JpZ2luIHNlY3VyaXR5T3JpZ2lu KCkgY29uc3Q7CiAKKyAgICBib29sIGlzU3VwcG9ydGVkQ29udGVudFR5cGUoY29uc3QgUVN0cmlu ZyAmbWltZVR5cGUpIGNvbnN0OworICAgIFFTdHJpbmdMaXN0IHN1cHBvcnRlZENvbnRlbnRUeXBl cygpIGNvbnN0OworCiBwdWJsaWMgUV9TTE9UUzoKICAgICBRVmFyaWFudCBldmFsdWF0ZUphdmFT Y3JpcHQoY29uc3QgUVN0cmluZyYgc2NyaXB0U291cmNlKTsKICNpZm5kZWYgUVRfTk9fUFJJTlRF Ugo= 64781 2010-08-18 15:31:40 -0700 2010-08-24 08:50:03 -0700 Function for checking content-type supported by QWebFrame III... function_for_checking_supported_content_type_3.patch text/plain 3962 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBiL1dlYktpdC9xdC9BcGkv cXdlYmZyYW1lLmNwcAppbmRleCAwYmI2OTIyLi5hYzZlMjQ1IDEwMDY0NAotLS0gYS9XZWJLaXQv cXQvQXBpL3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCkBA IC00MywxMCArNDMsMTMgQEAKICNpbmNsdWRlICJKU0RPTVdpbmRvd0Jhc2UuaCIKICNpbmNsdWRl ICJKU0xvY2suaCIKICNpbmNsdWRlICJKU09iamVjdC5oIgorI2luY2x1ZGUgIk1JTUVUeXBlUmVn aXN0cnkuaCIKICNpbmNsdWRlICJOb2RlTGlzdC5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNs dWRlICJQbGF0Zm9ybU1vdXNlRXZlbnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQu aCIKKyNpbmNsdWRlICJQbHVnaW5EYXRhYmFzZS5oIgorI2luY2x1ZGUgIlBsdWdpblBhY2thZ2Uu aCIKICNpbmNsdWRlICJQcmludENvbnRleHQuaCIKICNpbmNsdWRlICJQdXRQcm9wZXJ0eVNsb3Qu aCIKICNpbmNsdWRlICJSZW5kZXJMYXllci5oIgpAQCAtMTQwNyw2ICsxNDEwLDYyIEBAIFFXZWJT ZWN1cml0eU9yaWdpbiBRV2ViRnJhbWU6OnNlY3VyaXR5T3JpZ2luKCkgY29uc3QKICAgICByZXR1 cm4gUVdlYlNlY3VyaXR5T3JpZ2luKHByaXYpOwogfQogCisvKiEKKyAqICBcc2luY2UgNC44Cisg KiAKKyAqICBSZXR1cm5zIHRydWUgaWYgdGhlIGZyYW1lIGNhbiBoYW5kbGUgdGhlIGdpdmVuIFxh IG1pbWVUeXBlOyBvdGhlcndpc2UsIHJldHVybnMgZmFsc2UuCisgKi8KK2Jvb2wgUVdlYkZyYW1l OjpjYW5IYW5kbGVDb250ZW50VHlwZShjb25zdCBRU3RyaW5nJiBtaW1lVHlwZSkgY29uc3QKK3sK KyAgICBjb25zdCBTdHJpbmcgdHlwZSA9IG1pbWVUeXBlLnRvTG93ZXIoKTsKKyAgICBpZiAoTUlN RVR5cGVSZWdpc3RyeTo6aXNTdXBwb3J0ZWRJbWFnZU1JTUVUeXBlKHR5cGUpKQorICAgICAgcmV0 dXJuIHRydWU7CisKKyAgICBpZiAoTUlNRVR5cGVSZWdpc3RyeTo6aXNTdXBwb3J0ZWROb25JbWFn ZU1JTUVUeXBlKHR5cGUpKQorICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBpZiAoZC0+ZnJhbWUg JiYgZC0+ZnJhbWUtPnNldHRpbmdzKCkgJiYgZC0+ZnJhbWUtPnNldHRpbmdzKCktPmFyZVBsdWdp bnNFbmFibGVkKCkgJiYKKyAgICAgICAgUGx1Z2luRGF0YWJhc2U6Omluc3RhbGxlZFBsdWdpbnMo KS0+aXNNSU1FVHlwZVJlZ2lzdGVyZWQodHlwZSkpCisgICAgICByZXR1cm4gdHJ1ZTsKKworICAg IHJldHVybiBmYWxzZTsKK30KKworc3RhdGljIHZvaWQgZXh0cmFjdENvbnRlbnRUeXBlRnJvbUhh c2goY29uc3QgSGFzaFNldDxTdHJpbmc+JiB0eXBlcywgUVN0cmluZ0xpc3QmIGxpc3QpCit7Cisg ICAgSGFzaFNldDxTdHJpbmc+Ojpjb25zdF9pdGVyYXRvciBlbmRJdCA9IHR5cGVzLmVuZCgpOwor ICAgIGZvciAoSGFzaFNldDxTdHJpbmc+Ojpjb25zdF9pdGVyYXRvciBpdCA9IHR5cGVzLmJlZ2lu KCk7IGl0ICE9IGVuZEl0OyArK2l0KQorICAgICAgICBsaXN0IDw8ICppdDsKK30KKworc3RhdGlj IHZvaWQgZXh0cmFjdENvbnRlbnRUeXBlRnJvbVBsdWdpbkxpc3QoY29uc3QgVmVjdG9yPFBsdWdp blBhY2thZ2UqPiYgcGx1Z2lucywgUVN0cmluZ0xpc3QmIGxpc3QpCit7CisgICAgZm9yICh1bnNp Z25lZCBpbnQgaSA9IDA7IGkgPCBwbHVnaW5zLnNpemUoKTsgKytpKSB7CisgICAgICAgIE1JTUVU b0Rlc2NyaXB0aW9uc01hcDo6Y29uc3RfaXRlcmF0b3IgbWFwX2l0ID0gcGx1Z2luc1tpXS0+bWlt ZVRvRGVzY3JpcHRpb25zKCkuYmVnaW4oKTsKKyAgICAgICAgTUlNRVRvRGVzY3JpcHRpb25zTWFw Ojpjb25zdF9pdGVyYXRvciBtYXBfZW5kID0gcGx1Z2luc1tpXS0+bWltZVRvRGVzY3JpcHRpb25z KCkuZW5kKCk7CisgICAgICAgIGZvciAoOyBtYXBfaXQgIT0gbWFwX2VuZDsgKyttYXBfaXQpCisg ICAgICAgICAgICBsaXN0IDw8IG1hcF9pdC0+Zmlyc3Q7CisgICAgfQorfQorCisvKiEKKyAqICBc c2luY2UgNC44CisgKgorICogIFJldHVybnMgdGhlIGxpc3Qgb2YgYWxsIGNvbnRlbnQgdHlwZXMg c3VwcG9ydGVkIGJ5IHRoaXMgZnJhbWUuCisgKi8KK1FTdHJpbmdMaXN0IFFXZWJGcmFtZTo6c3Vw cG9ydGVkQ29udGVudFR5cGVzKCkgY29uc3QKK3sKKyAgICBRU3RyaW5nTGlzdCBtaW1lVHlwZXM7 CisgICAgCisgICAgZXh0cmFjdENvbnRlbnRUeXBlRnJvbUhhc2goTUlNRVR5cGVSZWdpc3RyeTo6 Z2V0U3VwcG9ydGVkSW1hZ2VNSU1FVHlwZXMoKSwgbWltZVR5cGVzKTsKKyAgICBleHRyYWN0Q29u dGVudFR5cGVGcm9tSGFzaChNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRTdXBwb3J0ZWROb25JbWFnZU1J TUVUeXBlcygpLCBtaW1lVHlwZXMpOworICAgIGlmIChkLT5mcmFtZSAmJiBkLT5mcmFtZS0+c2V0 dGluZ3MoKSAmJiBkLT5mcmFtZS0+c2V0dGluZ3MoKS0+YXJlUGx1Z2luc0VuYWJsZWQoKSkKKyAg ICAgICAgZXh0cmFjdENvbnRlbnRUeXBlRnJvbVBsdWdpbkxpc3QoUGx1Z2luRGF0YWJhc2U6Omlu c3RhbGxlZFBsdWdpbnMoKS0+cGx1Z2lucygpLCBtaW1lVHlwZXMpOworICAgIAorICAgIHJldHVy biBtaW1lVHlwZXM7Cit9CisKKwogV2ViQ29yZTo6RnJhbWUqIFFXZWJGcmFtZVByaXZhdGU6OmNv cmUoUVdlYkZyYW1lKiB3ZWJGcmFtZSkKIHsKICAgICByZXR1cm4gd2ViRnJhbWUtPmQtPmZyYW1l OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaCBiL1dlYktpdC9xdC9BcGkv cXdlYmZyYW1lLmgKaW5kZXggZTc4ZmIwNy4uOWRjODU0OCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0 L0FwaS9xd2ViZnJhbWUuaAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oCkBAIC0xOTgs NiArMTk4LDkgQEAgcHVibGljOgogCiAgICAgUVdlYlNlY3VyaXR5T3JpZ2luIHNlY3VyaXR5T3Jp Z2luKCkgY29uc3Q7CiAKKyAgICBib29sIGNhbkhhbmRsZUNvbnRlbnRUeXBlKGNvbnN0IFFTdHJp bmcgJm1pbWVUeXBlKSBjb25zdDsKKyAgICBRU3RyaW5nTGlzdCBzdXBwb3J0ZWRDb250ZW50VHlw ZXMoKSBjb25zdDsKKwogcHVibGljIFFfU0xPVFM6CiAgICAgUVZhcmlhbnQgZXZhbHVhdGVKYXZh U2NyaXB0KGNvbnN0IFFTdHJpbmcmIHNjcmlwdFNvdXJjZSk7CiAjaWZuZGVmIFFUX05PX1BSSU5U RVIKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9n CmluZGV4IDI1ZThmYjMuLmY5ZmM4ZGYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cK KysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEwLTA4LTE4ICBE YXdpdCBBbGVtYXllaHUgIDxhZGF3aXRAa2RlLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIE5ldyBBUEkgZm9yIGNoZWNraW5nL29idGFp bmluZyBjb250ZW50IHR5cGVzIHN1cHBvcnRlZCBieSBRV2ViRnJhbWUuCisgICAgICAgIGh0dHA6 Ly93ZWJraXQub3JnL2IvMzc4ODAKKworICAgICAgICBNYWtlIGl0IHBvc3NpYmxlIGZvciBhcHBs aWNhdGlvbiB0byBkZXRlcm1pbmUgd2hpY2ggY29udGVudC10eXBlcyBhcmUgaGFuZGxlZAorICAg ICAgICBieSBRV2ViRnJhbWUgYW5kIHdoaWNoIG9uZXMgYXJlIG5vdC4KKworICAgICAgICAqIEFw aS9xd2ViZnJhbWUuY3BwOgorICAgICAgICAoUVdlYkZyYW1lOjpjYW5IYW5kbGVDb250ZW50VHlw ZSk6CisgICAgICAgIChleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaCk6CisgICAgICAgIChleHRy YWN0Q29udGVudFR5cGVGcm9tUGx1Z2luTGlzdCk6CisgICAgICAgIChRV2ViRnJhbWU6OnN1cHBv cnRlZENvbnRlbnRUeXBlcyk6CisgICAgICAgICogQXBpL3F3ZWJmcmFtZS5oOgorCiAyMDEwLTA4 LTE3ICBMYXN6bG8gR29tYm9zICA8bGFzemxvLjEuZ29tYm9zQG5va2lhLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBBcml5YSBIaWRheWF0Lgo= 65275 2010-08-24 08:50:03 -0700 2010-08-24 14:06:03 -0700 Function for checking content-type supported by QWebPage I... function_for_checking_supported_content_type_4.patch text/plain 4161 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuY3BwIGIvV2ViS2l0L3F0L0FwaS9x d2VicGFnZS5jcHAKaW5kZXggNWVlZTIxYy4uM2I4NjU4MiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0 L0FwaS9xd2VicGFnZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKQEAgLTg1 LDYgKzg1LDkgQEAKICNpbmNsdWRlICJQYWdlQ2xpZW50UXQuaCIKICNpbmNsdWRlICJXb3JrZXJU aHJlYWQuaCIKICNpbmNsdWRlICJ3dGYvVGhyZWFkaW5nLmgiCisjaW5jbHVkZSAiTUlNRVR5cGVS ZWdpc3RyeS5oIgorI2luY2x1ZGUgIlBsdWdpbkRhdGFiYXNlLmgiCisjaW5jbHVkZSAiUGx1Z2lu UGFja2FnZS5oIgogCiAjaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgogI2luY2x1ZGUgPFFCYXNpY1Rp bWVyPgpAQCAtMjE1OCw2ICsyMTYxLDYzIEBAIFFPYmplY3QgKlFXZWJQYWdlOjpjcmVhdGVQbHVn aW4oY29uc3QgUVN0cmluZyAmY2xhc3NpZCwgY29uc3QgUVVybCAmdXJsLCBjb25zdCBRCiAgICAg cmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZyb21IYXNoKGNv bnN0IEhhc2hTZXQ8U3RyaW5nPiYgdHlwZXMsIFFTdHJpbmdMaXN0JiBsaXN0KQoreworICAgIEhh c2hTZXQ8U3RyaW5nPjo6Y29uc3RfaXRlcmF0b3IgZW5kSXQgPSB0eXBlcy5lbmQoKTsKKyAgICBm b3IgKEhhc2hTZXQ8U3RyaW5nPjo6Y29uc3RfaXRlcmF0b3IgaXQgPSB0eXBlcy5iZWdpbigpOyBp dCAhPSBlbmRJdDsgKytpdCkKKyAgICAgICAgbGlzdCA8PCAqaXQ7Cit9CisKK3N0YXRpYyB2b2lk IGV4dHJhY3RDb250ZW50VHlwZUZyb21QbHVnaW5MaXN0KGNvbnN0IFZlY3RvcjxQbHVnaW5QYWNr YWdlKj4mIHBsdWdpbnMsIFFTdHJpbmdMaXN0JiBsaXN0KQoreworICAgIGZvciAodW5zaWduZWQg aW50IGkgPSAwOyBpIDwgcGx1Z2lucy5zaXplKCk7ICsraSkgeworICAgICAgICBNSU1FVG9EZXNj cmlwdGlvbnNNYXA6OmNvbnN0X2l0ZXJhdG9yIG1hcF9pdCA9IHBsdWdpbnNbaV0tPm1pbWVUb0Rl c2NyaXB0aW9ucygpLmJlZ2luKCk7CisgICAgICAgIE1JTUVUb0Rlc2NyaXB0aW9uc01hcDo6Y29u c3RfaXRlcmF0b3IgbWFwX2VuZCA9IHBsdWdpbnNbaV0tPm1pbWVUb0Rlc2NyaXB0aW9ucygpLmVu ZCgpOworICAgICAgICBmb3IgKDsgbWFwX2l0ICE9IG1hcF9lbmQ7ICsrbWFwX2l0KQorICAgICAg ICAgICAgbGlzdCA8PCBtYXBfaXQtPmZpcnN0OworICAgIH0KK30KKworLyohCisgKiAgXHNpbmNl IDQuOAorICoKKyAqICBSZXR1cm5zIHRoZSBsaXN0IG9mIGFsbCBjb250ZW50IHR5cGVzIHN1cHBv cnRlZCBieSB0aGlzIGZyYW1lLgorICovCitRU3RyaW5nTGlzdCBRV2ViUGFnZTo6c3VwcG9ydGVk Q29udGVudFR5cGVzKCkgY29uc3QKK3sKKyAgICBRU3RyaW5nTGlzdCBtaW1lVHlwZXM7CisKKyAg ICBXZWJDb3JlOjpGcmFtZSAqZnJhbWUgPSBkLT5wYWdlLT5mb2N1c0NvbnRyb2xsZXIoKS0+Zm9j dXNlZE9yTWFpbkZyYW1lKCk7CisgICAgZXh0cmFjdENvbnRlbnRUeXBlRnJvbUhhc2goTUlNRVR5 cGVSZWdpc3RyeTo6Z2V0U3VwcG9ydGVkSW1hZ2VNSU1FVHlwZXMoKSwgbWltZVR5cGVzKTsKKyAg ICBleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaChNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRTdXBwb3J0 ZWROb25JbWFnZU1JTUVUeXBlcygpLCBtaW1lVHlwZXMpOworICAgIGlmIChmcmFtZSAmJiBmcmFt ZS0+c2V0dGluZ3MoKSAmJiBmcmFtZS0+c2V0dGluZ3MoKS0+YXJlUGx1Z2luc0VuYWJsZWQoKSkK KyAgICAgICAgZXh0cmFjdENvbnRlbnRUeXBlRnJvbVBsdWdpbkxpc3QoUGx1Z2luRGF0YWJhc2U6 Omluc3RhbGxlZFBsdWdpbnMoKS0+cGx1Z2lucygpLCBtaW1lVHlwZXMpOworCisgICAgcmV0dXJu IG1pbWVUeXBlczsKK30KKworLyohCisgKiAgXHNpbmNlIDQuOAorICoKKyAqICBSZXR1cm5zIHRy dWUgaWYgdGhlIGZyYW1lIGNhbiBoYW5kbGUgdGhlIGdpdmVuIFxhIG1pbWVUeXBlOyBvdGhlcndp c2UsIHJldHVybnMgZmFsc2UuCisgKi8KK2Jvb2wgUVdlYlBhZ2U6OmNhbkhhbmRsZUNvbnRlbnRU eXBlKGNvbnN0IFFTdHJpbmcmIG1pbWVUeXBlKSBjb25zdAoreworICAgIGNvbnN0IFN0cmluZyB0 eXBlID0gbWltZVR5cGUudG9Mb3dlcigpOworICAgIGlmIChNSU1FVHlwZVJlZ2lzdHJ5Ojppc1N1 cHBvcnRlZEltYWdlTUlNRVR5cGUodHlwZSkpCisgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlm IChNSU1FVHlwZVJlZ2lzdHJ5Ojppc1N1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGUodHlwZSkpCisg ICAgICByZXR1cm4gdHJ1ZTsKKworICAgIFdlYkNvcmU6OkZyYW1lICpmcmFtZSA9IGQtPnBhZ2Ut PmZvY3VzQ29udHJvbGxlcigpLT5mb2N1c2VkT3JNYWluRnJhbWUoKTsKKyAgICBpZiAoZnJhbWUg JiYgZnJhbWUtPnNldHRpbmdzKCkgJiYgZnJhbWUtPnNldHRpbmdzKCktPmFyZVBsdWdpbnNFbmFi bGVkKCkgJiYKKyAgICAgICAgUGx1Z2luRGF0YWJhc2U6Omluc3RhbGxlZFBsdWdpbnMoKS0+aXNN SU1FVHlwZVJlZ2lzdGVyZWQodHlwZSkpCisgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVy biBmYWxzZTsKK30KKwogc3RhdGljIFdlYkNvcmU6OkZyYW1lTG9hZFJlcXVlc3QgZnJhbWVMb2Fk UmVxdWVzdChjb25zdCBRVXJsICZ1cmwsIFdlYkNvcmU6OkZyYW1lICpmcmFtZSkKIHsKICAgICBX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcnIodXJsLCBmcmFtZS0+bG9hZGVyKCktPm91dGdvaW5n UmVmZXJyZXIoKSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmggYi9XZWJL aXQvcXQvQXBpL3F3ZWJwYWdlLmgKaW5kZXggMTRmM2I4Yi4uMmIwYTczOCAxMDA2NDQKLS0tIGEv V2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuaApA QCAtMzA0LDYgKzMwNCw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc2V0VXNlclBlcm1pc3Npb24o UVdlYkZyYW1lKiBmcmFtZSwgUGVybWlzc2lvbkRvbWFpbiBkb21haW4sIFBlcm1pc3Npb25Qb2xp Y3kgcG9saWN5KTsKIAorICAgIFFTdHJpbmdMaXN0IHN1cHBvcnRlZENvbnRlbnRUeXBlcygpIGNv bnN0OworICAgIGJvb2wgY2FuSGFuZGxlQ29udGVudFR5cGUoY29uc3QgUVN0cmluZyYgbWltZVR5 cGUpIGNvbnN0OworCiAgICAgZW51bSBFeHRlbnNpb24gewogICAgICAgICBDaG9vc2VNdWx0aXBs ZUZpbGVzRXh0ZW5zaW9uLAogICAgICAgICBFcnJvclBhZ2VFeHRlbnNpb24KZGlmZiAtLWdpdCBh L1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCmluZGV4IDRjNTg2Yjgu LjRlZmQ5MzYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0 L0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEwLTA4LTI0ICBEYXdpdCBBbGVtYXllaHUg IDxhZGF3aXRAa2RlLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBbUXRdIEFkZGVkIGZ1bmN0aW9ucyBmb3Igb2J0YWluaW5nIGFuZCBjaGVja2lu ZyB0aGUgY29udGVudCB0eXBlcyBzdXBwb3J0ZWQgYnkgUVdlYlBhZ2UuCisgICAgICAgIGh0dHA6 Ly93ZWJraXQub3JnL2IvMzc4ODAKKworICAgICAgICBNYWtlIGl0IHBvc3NpYmxlIGZvciBhcHBs aWNhdGlvbnMgdG8gZGV0ZXJtaW5lIHdoaWNoIGNvbnRlbnQtdHlwZXMgYXJlIGhhbmRsZWQKKyAg ICAgICAgYnkgUVdlYlBhZ2UgYW5kIHByb3ZpZGUgYSB3YXkgZm9yIGRpc2FibGluZyB0aGUgaGFu ZGxpbmcgb2YgcGxhaW4gdGV4dCBmaWxlcy4KKworICAgICAgICAqIEFwaS9xd2VicGFnZS5jcHA6 CisgICAgICAgIChleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaCk6CisgICAgICAgIChleHRyYWN0 Q29udGVudFR5cGVGcm9tUGx1Z2luTGlzdCk6CisgICAgICAgIChRV2ViUGFnZTo6c3VwcG9ydGVk Q29udGVudFR5cGVzKToKKyAgICAgICAgKFFXZWJQYWdlOjpjYW5IYW5kbGVDb250ZW50VHlwZSk6 CisgICAgICAgIChRV2ViUGFnZTo6c2V0RGlzYWJsZVBsYWluVGV4dEhhbmRsaW5nKToKKyAgICAg ICAgKiBBcGkvcXdlYnBhZ2UuaDoKKwogMjAxMC0wOC0yNCAgQW5kcmFzIEJlY3NpICA8YWJlY3Np QGluZi51LXN6ZWdlZC5odT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4K 65320 2010-08-24 14:04:58 -0700 2010-08-25 07:51:26 -0700 Function for checking content-type supported by QWebPage II... function_for_checking_supported_content_type_5.patch text/plain 4237 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuY3BwIGIvV2ViS2l0L3F0L0FwaS9x d2VicGFnZS5jcHAKaW5kZXggNWVlZTIxYy4uY2MyZTM4MiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0 L0FwaS9xd2VicGFnZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKQEAgLTg1 LDYgKzg1LDkgQEAKICNpbmNsdWRlICJQYWdlQ2xpZW50UXQuaCIKICNpbmNsdWRlICJXb3JrZXJU aHJlYWQuaCIKICNpbmNsdWRlICJ3dGYvVGhyZWFkaW5nLmgiCisjaW5jbHVkZSAiTUlNRVR5cGVS ZWdpc3RyeS5oIgorI2luY2x1ZGUgIlBsdWdpbkRhdGFiYXNlLmgiCisjaW5jbHVkZSAiUGx1Z2lu UGFja2FnZS5oIgogCiAjaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgogI2luY2x1ZGUgPFFCYXNpY1Rp bWVyPgpAQCAtMjE1OCw2ICsyMTYxLDY5IEBAIFFPYmplY3QgKlFXZWJQYWdlOjpjcmVhdGVQbHVn aW4oY29uc3QgUVN0cmluZyAmY2xhc3NpZCwgY29uc3QgUVVybCAmdXJsLCBjb25zdCBRCiAgICAg cmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZyb21IYXNoKGNv bnN0IEhhc2hTZXQ8U3RyaW5nPiYgdHlwZXMsIFFTdHJpbmdMaXN0KiBsaXN0KQoreworICAgIGlm ICghbGlzdCkKKyAgICAgICAgcmV0dXJuOworCisgICAgSGFzaFNldDxTdHJpbmc+Ojpjb25zdF9p dGVyYXRvciBlbmRJdCA9IHR5cGVzLmVuZCgpOworICAgIGZvciAoSGFzaFNldDxTdHJpbmc+Ojpj b25zdF9pdGVyYXRvciBpdCA9IHR5cGVzLmJlZ2luKCk7IGl0ICE9IGVuZEl0OyArK2l0KQorICAg ICAgICAqbGlzdCA8PCAqaXQ7Cit9CisKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZy b21QbHVnaW5MaXN0KGNvbnN0IFZlY3RvcjxQbHVnaW5QYWNrYWdlKj4mIHBsdWdpbnMsIFFTdHJp bmdMaXN0KiBsaXN0KQoreworICAgIGlmICghbGlzdCkKKyAgICAgICAgcmV0dXJuOworICAgIAor ICAgIGZvciAodW5zaWduZWQgaW50IGkgPSAwOyBpIDwgcGx1Z2lucy5zaXplKCk7ICsraSkgewor ICAgICAgICBNSU1FVG9EZXNjcmlwdGlvbnNNYXA6OmNvbnN0X2l0ZXJhdG9yIG1hcF9pdCA9IHBs dWdpbnNbaV0tPm1pbWVUb0Rlc2NyaXB0aW9ucygpLmJlZ2luKCk7CisgICAgICAgIE1JTUVUb0Rl c2NyaXB0aW9uc01hcDo6Y29uc3RfaXRlcmF0b3IgbWFwX2VuZCA9IHBsdWdpbnNbaV0tPm1pbWVU b0Rlc2NyaXB0aW9ucygpLmVuZCgpOworICAgICAgICBmb3IgKDsgbWFwX2l0ICE9IG1hcF9lbmQ7 ICsrbWFwX2l0KQorICAgICAgICAgICAgKmxpc3QgPDwgbWFwX2l0LT5maXJzdDsKKyAgICB9Cit9 CisKKy8qIQorICogIFxzaW5jZSA0LjgKKyAqCisgKiAgUmV0dXJucyB0aGUgbGlzdCBvZiBhbGwg Y29udGVudCB0eXBlcyBzdXBwb3J0ZWQgYnkgUVdlYlBhZ2UuCisgKi8KK1FTdHJpbmdMaXN0IFFX ZWJQYWdlOjpzdXBwb3J0ZWRDb250ZW50VHlwZXMoKSBjb25zdAoreworICAgIFFTdHJpbmdMaXN0 IG1pbWVUeXBlczsKKworICAgIFdlYkNvcmU6OkZyYW1lICpmcmFtZSA9IGQtPnBhZ2UtPmZvY3Vz Q29udHJvbGxlcigpLT5mb2N1c2VkT3JNYWluRnJhbWUoKTsKKyAgICBleHRyYWN0Q29udGVudFR5 cGVGcm9tSGFzaChNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRTdXBwb3J0ZWRJbWFnZU1JTUVUeXBlcygp LCAmbWltZVR5cGVzKTsKKyAgICBleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaChNSU1FVHlwZVJl Z2lzdHJ5OjpnZXRTdXBwb3J0ZWROb25JbWFnZU1JTUVUeXBlcygpLCAmbWltZVR5cGVzKTsKKyAg ICBpZiAoZnJhbWUgJiYgZnJhbWUtPnNldHRpbmdzKCkgJiYgZnJhbWUtPnNldHRpbmdzKCktPmFy ZVBsdWdpbnNFbmFibGVkKCkpCisgICAgICAgIGV4dHJhY3RDb250ZW50VHlwZUZyb21QbHVnaW5M aXN0KFBsdWdpbkRhdGFiYXNlOjppbnN0YWxsZWRQbHVnaW5zKCktPnBsdWdpbnMoKSwgJm1pbWVU eXBlcyk7CisKKyAgICByZXR1cm4gbWltZVR5cGVzOworfQorCisvKiEKKyAqICBcc2luY2UgNC44 CisgKgorICogIFJldHVybnMgdHJ1ZSBpZiBRV2ViUGFnZSBjYW4gaGFuZGxlIHRoZSBnaXZlbiBc YSBtaW1lVHlwZTsgb3RoZXJ3aXNlLCByZXR1cm5zIGZhbHNlLgorICovCitib29sIFFXZWJQYWdl OjpjYW5IYW5kbGVDb250ZW50VHlwZShjb25zdCBRU3RyaW5nJiBtaW1lVHlwZSkgY29uc3QKK3sK KyAgICBjb25zdCBTdHJpbmcgdHlwZSA9IG1pbWVUeXBlLnRvTG93ZXIoKTsKKyAgICBpZiAoTUlN RVR5cGVSZWdpc3RyeTo6aXNTdXBwb3J0ZWRJbWFnZU1JTUVUeXBlKHR5cGUpKQorICAgICAgcmV0 dXJuIHRydWU7CisKKyAgICBpZiAoTUlNRVR5cGVSZWdpc3RyeTo6aXNTdXBwb3J0ZWROb25JbWFn ZU1JTUVUeXBlKHR5cGUpKQorICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBXZWJDb3JlOjpGcmFt ZSAqZnJhbWUgPSBkLT5wYWdlLT5mb2N1c0NvbnRyb2xsZXIoKS0+Zm9jdXNlZE9yTWFpbkZyYW1l KCk7CisgICAgaWYgKGZyYW1lICYmIGZyYW1lLT5zZXR0aW5ncygpICYmIGZyYW1lLT5zZXR0aW5n cygpLT5hcmVQbHVnaW5zRW5hYmxlZCgpICYmCisgICAgICAgIFBsdWdpbkRhdGFiYXNlOjppbnN0 YWxsZWRQbHVnaW5zKCktPmlzTUlNRVR5cGVSZWdpc3RlcmVkKHR5cGUpKQorICAgICAgcmV0dXJu IHRydWU7CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIHN0YXRpYyBXZWJDb3JlOjpGcmFtZUxv YWRSZXF1ZXN0IGZyYW1lTG9hZFJlcXVlc3QoY29uc3QgUVVybCAmdXJsLCBXZWJDb3JlOjpGcmFt ZSAqZnJhbWUpCiB7CiAgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0IHJyKHVybCwgZnJhbWUt PmxvYWRlcigpLT5vdXRnb2luZ1JlZmVycmVyKCkpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0Fw aS9xd2VicGFnZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCmluZGV4IDE0ZjNiOGIuLjJi MGE3MzggMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuaAorKysgYi9XZWJLaXQv cXQvQXBpL3F3ZWJwYWdlLmgKQEAgLTMwNCw2ICszMDQsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lk IHNldFVzZXJQZXJtaXNzaW9uKFFXZWJGcmFtZSogZnJhbWUsIFBlcm1pc3Npb25Eb21haW4gZG9t YWluLCBQZXJtaXNzaW9uUG9saWN5IHBvbGljeSk7CiAKKyAgICBRU3RyaW5nTGlzdCBzdXBwb3J0 ZWRDb250ZW50VHlwZXMoKSBjb25zdDsKKyAgICBib29sIGNhbkhhbmRsZUNvbnRlbnRUeXBlKGNv bnN0IFFTdHJpbmcmIG1pbWVUeXBlKSBjb25zdDsKKwogICAgIGVudW0gRXh0ZW5zaW9uIHsKICAg ICAgICAgQ2hvb3NlTXVsdGlwbGVGaWxlc0V4dGVuc2lvbiwKICAgICAgICAgRXJyb3JQYWdlRXh0 ZW5zaW9uCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5n ZUxvZwppbmRleCA0YzU4NmI4Li40ZWZkOTM2IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdl TG9nCisrKyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMC0wOC0y NCAgRGF3aXQgQWxlbWF5ZWh1ICA8YWRhd2l0QGtkZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW1F0XSBBZGRlZCBmdW5jdGlvbnMgZm9yIG9i dGFpbmluZyBhbmQgY2hlY2tpbmcgdGhlIGNvbnRlbnQgdHlwZXMgc3VwcG9ydGVkIGJ5IFFXZWJQ YWdlLgorICAgICAgICBodHRwOi8vd2Via2l0Lm9yZy9iLzM3ODgwCisKKyAgICAgICAgTWFrZSBp dCBwb3NzaWJsZSBmb3IgYXBwbGljYXRpb25zIHRvIGRldGVybWluZSB3aGljaCBjb250ZW50LXR5 cGVzIGFyZSBoYW5kbGVkCisgICAgICAgIGJ5IFFXZWJQYWdlIGFuZCBwcm92aWRlIGEgd2F5IGZv ciBkaXNhYmxpbmcgdGhlIGhhbmRsaW5nIG9mIHBsYWluIHRleHQgZmlsZXMuCisKKyAgICAgICAg KiBBcGkvcXdlYnBhZ2UuY3BwOgorICAgICAgICAoZXh0cmFjdENvbnRlbnRUeXBlRnJvbUhhc2gp OgorICAgICAgICAoZXh0cmFjdENvbnRlbnRUeXBlRnJvbVBsdWdpbkxpc3QpOgorICAgICAgICAo UVdlYlBhZ2U6OnN1cHBvcnRlZENvbnRlbnRUeXBlcyk6CisgICAgICAgIChRV2ViUGFnZTo6Y2Fu SGFuZGxlQ29udGVudFR5cGUpOgorICAgICAgICAoUVdlYlBhZ2U6OnNldERpc2FibGVQbGFpblRl eHRIYW5kbGluZyk6CisgICAgICAgICogQXBpL3F3ZWJwYWdlLmg6CisKIDIwMTAtMDgtMjQgIEFu ZHJhcyBCZWNzaSAgPGFiZWNzaUBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgU2ltb24gSGF1c21hbm4uCg== 65418 2010-08-25 07:51:26 -0700 2010-09-28 03:18:39 -0700 Function for checking content-type supported by QWebPage III... function_for_checking_supported_content_type_6.patch text/plain 3882 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuY3BwIGIvV2ViS2l0L3F0L0FwaS9x d2VicGFnZS5jcHAKaW5kZXggNWVlZTIxYy4uYmI4YjYyNiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0 L0FwaS9xd2VicGFnZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKQEAgLTg1 LDYgKzg1LDkgQEAKICNpbmNsdWRlICJQYWdlQ2xpZW50UXQuaCIKICNpbmNsdWRlICJXb3JrZXJU aHJlYWQuaCIKICNpbmNsdWRlICJ3dGYvVGhyZWFkaW5nLmgiCisjaW5jbHVkZSAiTUlNRVR5cGVS ZWdpc3RyeS5oIgorI2luY2x1ZGUgIlBsdWdpbkRhdGFiYXNlLmgiCisjaW5jbHVkZSAiUGx1Z2lu UGFja2FnZS5oIgogCiAjaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgogI2luY2x1ZGUgPFFCYXNpY1Rp bWVyPgpAQCAtMjE1OCw2ICsyMTYxLDY3IEBAIFFPYmplY3QgKlFXZWJQYWdlOjpjcmVhdGVQbHVn aW4oY29uc3QgUVN0cmluZyAmY2xhc3NpZCwgY29uc3QgUVVybCAmdXJsLCBjb25zdCBRCiAgICAg cmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZyb21IYXNoKGNv bnN0IEhhc2hTZXQ8U3RyaW5nPiYgdHlwZXMsIFFTdHJpbmdMaXN0KiBsaXN0KQoreworICAgIGlm ICghbGlzdCkKKyAgICAgICAgcmV0dXJuOworCisgICAgSGFzaFNldDxTdHJpbmc+Ojpjb25zdF9p dGVyYXRvciBlbmRJdCA9IHR5cGVzLmVuZCgpOworICAgIGZvciAoSGFzaFNldDxTdHJpbmc+Ojpj b25zdF9pdGVyYXRvciBpdCA9IHR5cGVzLmJlZ2luKCk7IGl0ICE9IGVuZEl0OyArK2l0KQorICAg ICAgICAqbGlzdCA8PCAqaXQ7Cit9CisKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZy b21QbHVnaW5MaXN0KGNvbnN0IFZlY3RvcjxQbHVnaW5QYWNrYWdlKj4mIHBsdWdpbnMsIFFTdHJp bmdMaXN0KiBsaXN0KQoreworICAgIGlmICghbGlzdCkKKyAgICAgICAgcmV0dXJuOworCisgICAg Zm9yICh1bnNpZ25lZCBpbnQgaSA9IDA7IGkgPCBwbHVnaW5zLnNpemUoKTsgKytpKSB7CisgICAg ICAgIE1JTUVUb0Rlc2NyaXB0aW9uc01hcDo6Y29uc3RfaXRlcmF0b3IgbWFwX2l0ID0gcGx1Z2lu c1tpXS0+bWltZVRvRGVzY3JpcHRpb25zKCkuYmVnaW4oKTsKKyAgICAgICAgTUlNRVRvRGVzY3Jp cHRpb25zTWFwOjpjb25zdF9pdGVyYXRvciBtYXBfZW5kID0gcGx1Z2luc1tpXS0+bWltZVRvRGVz Y3JpcHRpb25zKCkuZW5kKCk7CisgICAgICAgIGZvciAoOyBtYXBfaXQgIT0gbWFwX2VuZDsgKytt YXBfaXQpCisgICAgICAgICAgICAqbGlzdCA8PCBtYXBfaXQtPmZpcnN0OworICAgIH0KK30KKwor LyohCisgKiAgXHNpbmNlIDQuOAorICoKKyAqICBSZXR1cm5zIHRoZSBsaXN0IG9mIGFsbCBjb250 ZW50IHR5cGVzIHN1cHBvcnRlZCBieSBRV2ViUGFnZS4KKyAqLworUVN0cmluZ0xpc3QgUVdlYlBh Z2U6OnN1cHBvcnRlZENvbnRlbnRUeXBlcygpIGNvbnN0Cit7CisgICAgUVN0cmluZ0xpc3QgbWlt ZVR5cGVzOworCisgICAgZXh0cmFjdENvbnRlbnRUeXBlRnJvbUhhc2goTUlNRVR5cGVSZWdpc3Ry eTo6Z2V0U3VwcG9ydGVkSW1hZ2VNSU1FVHlwZXMoKSwgJm1pbWVUeXBlcyk7CisgICAgZXh0cmFj dENvbnRlbnRUeXBlRnJvbUhhc2goTUlNRVR5cGVSZWdpc3RyeTo6Z2V0U3VwcG9ydGVkTm9uSW1h Z2VNSU1FVHlwZXMoKSwgJm1pbWVUeXBlcyk7CisgICAgaWYgKGQtPnBhZ2UtPnNldHRpbmdzKCkg JiYgZC0+cGFnZS0+c2V0dGluZ3MoKS0+YXJlUGx1Z2luc0VuYWJsZWQoKSkKKyAgICAgICAgZXh0 cmFjdENvbnRlbnRUeXBlRnJvbVBsdWdpbkxpc3QoUGx1Z2luRGF0YWJhc2U6Omluc3RhbGxlZFBs dWdpbnMoKS0+cGx1Z2lucygpLCAmbWltZVR5cGVzKTsKKworICAgIHJldHVybiBtaW1lVHlwZXM7 Cit9CisKKy8qIQorICogIFxzaW5jZSA0LjgKKyAqCisgKiAgUmV0dXJucyB0cnVlIGlmIFFXZWJQ YWdlIGNhbiBoYW5kbGUgdGhlIGdpdmVuIFxhIG1pbWVUeXBlOyBvdGhlcndpc2UsIHJldHVybnMg ZmFsc2UuCisgKi8KK2Jvb2wgUVdlYlBhZ2U6OmNhbkhhbmRsZUNvbnRlbnRUeXBlKGNvbnN0IFFT dHJpbmcmIG1pbWVUeXBlKSBjb25zdAoreworICAgIGNvbnN0IFN0cmluZyB0eXBlID0gbWltZVR5 cGUudG9Mb3dlcigpOworICAgIGlmIChNSU1FVHlwZVJlZ2lzdHJ5Ojppc1N1cHBvcnRlZEltYWdl TUlNRVR5cGUodHlwZSkpCisgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmIChNSU1FVHlwZVJl Z2lzdHJ5Ojppc1N1cHBvcnRlZE5vbkltYWdlTUlNRVR5cGUodHlwZSkpCisgICAgICByZXR1cm4g dHJ1ZTsKKworICAgIGlmIChkLT5wYWdlLT5zZXR0aW5ncygpICYmIGQtPnBhZ2UtPnNldHRpbmdz KCktPmFyZVBsdWdpbnNFbmFibGVkKCkgJiYKKyAgICAgICAgUGx1Z2luRGF0YWJhc2U6Omluc3Rh bGxlZFBsdWdpbnMoKS0+aXNNSU1FVHlwZVJlZ2lzdGVyZWQodHlwZSkpCisgICAgICByZXR1cm4g dHJ1ZTsKKworICAgIHJldHVybiBmYWxzZTsKK30KKwogc3RhdGljIFdlYkNvcmU6OkZyYW1lTG9h ZFJlcXVlc3QgZnJhbWVMb2FkUmVxdWVzdChjb25zdCBRVXJsICZ1cmwsIFdlYkNvcmU6OkZyYW1l ICpmcmFtZSkKIHsKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcnIodXJsLCBmcmFtZS0+ bG9hZGVyKCktPm91dGdvaW5nUmVmZXJyZXIoKSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBp L3F3ZWJwYWdlLmggYi9XZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmgKaW5kZXggMTRmM2I4Yi4uMmIw YTczOCAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCisrKyBiL1dlYktpdC9x dC9BcGkvcXdlYnBhZ2UuaApAQCAtMzA0LDYgKzMwNCw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQg c2V0VXNlclBlcm1pc3Npb24oUVdlYkZyYW1lKiBmcmFtZSwgUGVybWlzc2lvbkRvbWFpbiBkb21h aW4sIFBlcm1pc3Npb25Qb2xpY3kgcG9saWN5KTsKIAorICAgIFFTdHJpbmdMaXN0IHN1cHBvcnRl ZENvbnRlbnRUeXBlcygpIGNvbnN0OworICAgIGJvb2wgY2FuSGFuZGxlQ29udGVudFR5cGUoY29u c3QgUVN0cmluZyYgbWltZVR5cGUpIGNvbnN0OworCiAgICAgZW51bSBFeHRlbnNpb24gewogICAg ICAgICBDaG9vc2VNdWx0aXBsZUZpbGVzRXh0ZW5zaW9uLAogICAgICAgICBFcnJvclBhZ2VFeHRl bnNpb24KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdl TG9nCmluZGV4IDNkNTdhMzkuLmE4NDZlMTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEwLTA4LTI0 ICBEYXdpdCBBbGVtYXllaHUgIDxhZGF3aXRAa2RlLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbUXRdIEFkZGVkIGZ1bmN0aW9ucyBmb3Igb2J0 YWluaW5nIGFuZCBjaGVja2luZyB0aGUgY29udGVudCB0eXBlcyBzdXBwb3J0ZWQgYnkgUVdlYlBh Z2UuCisgICAgICAgIGh0dHA6Ly93ZWJraXQub3JnL2IvMzc4ODAKKworICAgICAgICAqIEFwaS9x d2VicGFnZS5jcHA6CisgICAgICAgIChleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaCk6CisgICAg ICAgIChleHRyYWN0Q29udGVudFR5cGVGcm9tUGx1Z2luTGlzdCk6CisgICAgICAgIChRV2ViUGFn ZTo6c3VwcG9ydGVkQ29udGVudFR5cGVzKToKKyAgICAgICAgKFFXZWJQYWdlOjpjYW5IYW5kbGVD b250ZW50VHlwZSk6CisgICAgICAgIChRV2ViUGFnZTo6c2V0RGlzYWJsZVBsYWluVGV4dEhhbmRs aW5nKToKKyAgICAgICAgKiBBcGkvcXdlYnBhZ2UuaDoKKwogMjAxMC0wOC0yNSAgR2Fib3IgTG9r aSAgPGxva2lAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBHYXZpbiBCYXJyYWNs b3VnaC4K 68952 2010-09-27 14:02:17 -0700 2010-10-02 05:30:13 -0700 65418: Function for checking content-type supported by QWebPage IV... bug_37880.patch text/plain 7765 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuY3BwIGIvV2ViS2l0L3F0L0FwaS9x d2VicGFnZS5jcHAKaW5kZXggNTczNTAwZS4uMmVhMWNmMSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0 L0FwaS9xd2VicGFnZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKQEAgLTg5 LDYgKzg5LDkgQEAKICNpbmNsdWRlICJQYWdlQ2xpZW50UXQuaCIKICNpbmNsdWRlICJXb3JrZXJU aHJlYWQuaCIKICNpbmNsdWRlICJ3dGYvVGhyZWFkaW5nLmgiCisjaW5jbHVkZSAiTUlNRVR5cGVS ZWdpc3RyeS5oIgorI2luY2x1ZGUgIlBsdWdpbkRhdGFiYXNlLmgiCisjaW5jbHVkZSAiUGx1Z2lu UGFja2FnZS5oIgogCiAjaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgogI2luY2x1ZGUgPFFCYXNpY1Rp bWVyPgpAQCAtMjE2Niw2ICsyMTY5LDY3IEBAIFFPYmplY3QgKlFXZWJQYWdlOjpjcmVhdGVQbHVn aW4oY29uc3QgUVN0cmluZyAmY2xhc3NpZCwgY29uc3QgUVVybCAmdXJsLCBjb25zdCBRCiAgICAg cmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZyb21IYXNoKGNv bnN0IEhhc2hTZXQ8U3RyaW5nPiYgdHlwZXMsIFFTdHJpbmdMaXN0KiBsaXN0KQoreworICAgIGlm ICghbGlzdCkKKyAgICAgICAgcmV0dXJuOworCisgICAgSGFzaFNldDxTdHJpbmc+Ojpjb25zdF9p dGVyYXRvciBlbmRJdCA9IHR5cGVzLmVuZCgpOworICAgIGZvciAoSGFzaFNldDxTdHJpbmc+Ojpj b25zdF9pdGVyYXRvciBpdCA9IHR5cGVzLmJlZ2luKCk7IGl0ICE9IGVuZEl0OyArK2l0KQorICAg ICAgICAqbGlzdCA8PCAqaXQ7Cit9CisKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZy b21QbHVnaW5WZWN0b3IoY29uc3QgVmVjdG9yPFBsdWdpblBhY2thZ2UqPiYgcGx1Z2lucywgUVN0 cmluZ0xpc3QqIGxpc3QpCit7CisgICAgaWYgKCFsaXN0KQorICAgICAgICByZXR1cm47CisKKyAg ICBmb3IgKHVuc2lnbmVkIGludCBpID0gMDsgaSA8IHBsdWdpbnMuc2l6ZSgpOyArK2kpIHsKKyAg ICAgICAgTUlNRVRvRGVzY3JpcHRpb25zTWFwOjpjb25zdF9pdGVyYXRvciBtYXBfaXQgPSBwbHVn aW5zW2ldLT5taW1lVG9EZXNjcmlwdGlvbnMoKS5iZWdpbigpOworICAgICAgICBNSU1FVG9EZXNj cmlwdGlvbnNNYXA6OmNvbnN0X2l0ZXJhdG9yIG1hcF9lbmQgPSBwbHVnaW5zW2ldLT5taW1lVG9E ZXNjcmlwdGlvbnMoKS5lbmQoKTsKKyAgICAgICAgZm9yICg7IG1hcF9pdCAhPSBtYXBfZW5kOyAr K21hcF9pdCkKKyAgICAgICAgICAgICpsaXN0IDw8IG1hcF9pdC0+Zmlyc3Q7CisgICAgfQorfQor CisvKiEKKyAqICBcc2luY2UgUXRXZWJLaXQgMi4xCisgKgorICogIFJldHVybnMgdGhlIGxpc3Qg b2YgYWxsIGNvbnRlbnQgdHlwZXMgc3VwcG9ydGVkIGJ5IFFXZWJQYWdlLgorICovCitRU3RyaW5n TGlzdCBRV2ViUGFnZTo6c3VwcG9ydGVkQ29udGVudFR5cGVzKCkgY29uc3QKK3sKKyAgICBRU3Ry aW5nTGlzdCBtaW1lVHlwZXM7CisKKyAgICBleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaChNSU1F VHlwZVJlZ2lzdHJ5OjpnZXRTdXBwb3J0ZWRJbWFnZU1JTUVUeXBlcygpLCAmbWltZVR5cGVzKTsK KyAgICBleHRyYWN0Q29udGVudFR5cGVGcm9tSGFzaChNSU1FVHlwZVJlZ2lzdHJ5OjpnZXRTdXBw b3J0ZWROb25JbWFnZU1JTUVUeXBlcygpLCAmbWltZVR5cGVzKTsKKyAgICBpZiAoZC0+cGFnZS0+ c2V0dGluZ3MoKSAmJiBkLT5wYWdlLT5zZXR0aW5ncygpLT5hcmVQbHVnaW5zRW5hYmxlZCgpKQor ICAgICAgICBleHRyYWN0Q29udGVudFR5cGVGcm9tUGx1Z2luVmVjdG9yKFBsdWdpbkRhdGFiYXNl OjppbnN0YWxsZWRQbHVnaW5zKCktPnBsdWdpbnMoKSwgJm1pbWVUeXBlcyk7CisKKyAgICByZXR1 cm4gbWltZVR5cGVzOworfQorCisvKiEKKyAqICBcc2luY2UgUXRXZWJLaXQgMi4xCisgKgorICog IFJldHVybnMgdHJ1ZSBpZiBRV2ViUGFnZSBjYW4gaGFuZGxlIHRoZSBnaXZlbiBcYSBtaW1lVHlw ZTsgb3RoZXJ3aXNlLCByZXR1cm5zIGZhbHNlLgorICovCitib29sIFFXZWJQYWdlOjpjYW5IYW5k bGVDb250ZW50VHlwZShjb25zdCBRU3RyaW5nJiBtaW1lVHlwZSkgY29uc3QKK3sKKyAgICBjb25z dCBTdHJpbmcgdHlwZSA9IG1pbWVUeXBlLnRvTG93ZXIoKTsKKyAgICBpZiAoTUlNRVR5cGVSZWdp c3RyeTo6aXNTdXBwb3J0ZWRJbWFnZU1JTUVUeXBlKHR5cGUpKQorICAgICAgICByZXR1cm4gdHJ1 ZTsKKworICAgIGlmIChNSU1FVHlwZVJlZ2lzdHJ5Ojppc1N1cHBvcnRlZE5vbkltYWdlTUlNRVR5 cGUodHlwZSkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgaWYgKGQtPnBhZ2UtPnNldHRp bmdzKCkgJiYgZC0+cGFnZS0+c2V0dGluZ3MoKS0+YXJlUGx1Z2luc0VuYWJsZWQoKQorICAgICAg ICAmJiBQbHVnaW5EYXRhYmFzZTo6aW5zdGFsbGVkUGx1Z2lucygpLT5pc01JTUVUeXBlUmVnaXN0 ZXJlZCh0eXBlKSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICByZXR1cm4gZmFsc2U7Cit9 CisKIHN0YXRpYyBXZWJDb3JlOjpGcmFtZUxvYWRSZXF1ZXN0IGZyYW1lTG9hZFJlcXVlc3QoY29u c3QgUVVybCAmdXJsLCBXZWJDb3JlOjpGcmFtZSAqZnJhbWUpCiB7CiAgICAgV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0IHJyKHVybCwgZnJhbWUtPmxvYWRlcigpLT5vdXRnb2luZ1JlZmVycmVyKCkp OwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oIGIvV2ViS2l0L3F0L0FwaS9x d2VicGFnZS5oCmluZGV4IGEyMDA3NGYuLjJlZGZiZTkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9B cGkvcXdlYnBhZ2UuaAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJwYWdlLmgKQEAgLTMwOSw2ICsz MDksOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHNldFVzZXJQZXJtaXNzaW9uKFFXZWJGcmFtZSog ZnJhbWUsIFBlcm1pc3Npb25Eb21haW4gZG9tYWluLCBQZXJtaXNzaW9uUG9saWN5IHBvbGljeSk7 CiAKKyAgICBRU3RyaW5nTGlzdCBzdXBwb3J0ZWRDb250ZW50VHlwZXMoKSBjb25zdDsKKyAgICBi b29sIGNhbkhhbmRsZUNvbnRlbnRUeXBlKGNvbnN0IFFTdHJpbmcmIG1pbWVUeXBlKSBjb25zdDsK KwogICAgIGVudW0gRXh0ZW5zaW9uIHsKICAgICAgICAgQ2hvb3NlTXVsdGlwbGVGaWxlc0V4dGVu c2lvbiwKICAgICAgICAgRXJyb3JQYWdlRXh0ZW5zaW9uCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQv Q2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCAzMzQxODI4Li5mZjQzMWM5IDEw MDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxOCBAQAorMjAxMC0wOS0yNyBEYXdpdCBBbGVtYXllaHUgIDxhZGF3aXRAa2Rl Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBb UXRdIEFkZGVkIGZ1bmN0aW9ucyBmb3Igb2J0YWluaW5nIGFuZCBjaGVja2luZyB0aGUgc3VwcG9y dGVkIGNvbnRlbnQgdHlwZXMuCisgICAgICAgIGh0dHA6Ly93ZWJraXQub3JnL2IvMzc4ODAKKwor ICAgICAgICAqIEFwaS9xd2VicGFnZS5jcHA6CisgICAgICAgIChleHRyYWN0Q29udGVudFR5cGVG cm9tSGFzaCk6CisgICAgICAgIChleHRyYWN0Q29udGVudFR5cGVGcm9tUGx1Z2luVmVjdG9yKToK KyAgICAgICAgKFFXZWJQYWdlOjpzdXBwb3J0ZWRDb250ZW50VHlwZXMpOgorICAgICAgICAoUVdl YlBhZ2U6OmNhbkhhbmRsZUNvbnRlbnRUeXBlKToKKyAgICAgICAgKiB0ZXN0cy9xd2VicGFnZS90 c3RfcXdlYnBhZ2UuY3BwOgorICAgICAgICAodHN0X1FXZWJQYWdlOjpzdXBwb3J0ZWRDb250ZW50 VHlwZSk6CisKIDIwMTAtMDktMjcgIEdpcmlzaCBSYW1ha3Jpc2huYW4gIDxnaXJpc2hAZm9yd2Fy ZGJpYXMuaW4+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQW50b25pbyBHb21lcy4KQEAgLTc1LDcg KzkwLDYgQEAKICAgICAgICAgKFFXZWJTZXR0aW5nczo6UVdlYlNldHRpbmdzKToKICAgICAgICAg KiBBcGkvcXdlYnNldHRpbmdzLmg6CiAKLQogMjAxMC0wOS0yMyAgVG9yIEFybmUgVmVzdGLDuCAg PHRvci5hcm5lLnZlc3Rib0Bub2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24g SGF1c21hbm4uCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvdGVzdHMvcXdlYnBhZ2UvdHN0X3F3ZWJw YWdlLmNwcCBiL1dlYktpdC9xdC90ZXN0cy9xd2VicGFnZS90c3RfcXdlYnBhZ2UuY3BwCmluZGV4 IDEwYWY5NGMuLjhlZmJjOWEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC90ZXN0cy9xd2VicGFnZS90 c3RfcXdlYnBhZ2UuY3BwCisrKyBiL1dlYktpdC9xdC90ZXN0cy9xd2VicGFnZS90c3RfcXdlYnBh Z2UuY3BwCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSA8cXdlYnBhZ2UuaD4KICNpbmNsdWRl IDxxd2Vic2VjdXJpdHlvcmlnaW4uaD4KICNpbmNsdWRlIDxxd2Vidmlldy5oPgorI2luY2x1ZGUg PHFpbWFnZXdyaXRlci5oPgogCiBjbGFzcyBFdmVudFNweSA6IHB1YmxpYyBRT2JqZWN0LCBwdWJs aWMgUUxpc3Q8UUV2ZW50OjpUeXBlPgogewpAQCAtMTI2LDYgKzEyNyw3IEBAIHByaXZhdGUgc2xv dHM6CiAgICAgdm9pZCBzaG93TW9kYWxEaWFsb2coKTsKICAgICB2b2lkIHRlc3RTdG9wU2NoZWR1 bGVkUGFnZVJlZnJlc2goKTsKICAgICB2b2lkIGZpbmRUZXh0KCk7CisgICAgdm9pZCBzdXBwb3J0 ZWRDb250ZW50VHlwZSgpOwogICAgIAogcHJpdmF0ZToKICAgICBRV2ViVmlldyogbV92aWV3OwpA QCAtMjIyNCw1ICsyMjI2LDg2IEBAIHZvaWQgdHN0X1FXZWJQYWdlOjpmaW5kVGV4dCgpCiAgICAg fQogfQogCitzdHJ1Y3QgSW1hZ2VFeHRlbnNpb25NYXAgeworICAgIGNvbnN0IGNoYXIqIGV4dGVu c2lvbjsKKyAgICBjb25zdCBjaGFyKiBtaW1lVHlwZTsKK307CisKK3N0YXRpYyBjb25zdCBJbWFn ZUV4dGVuc2lvbk1hcCBleHRlbnNpb25NYXBbXSA9IHsKKyAgICB7ICJibXAiLCAiaW1hZ2UvYm1w IiB9LAorICAgIHsgImNzcyIsICJ0ZXh0L2NzcyIgfSwKKyAgICB7ICJnaWYiLCAiaW1hZ2UvZ2lm IiB9LAorICAgIHsgImh0bWwiLCAidGV4dC9odG1sIiB9LAorICAgIHsgImh0bSIsICJ0ZXh0L2h0 bWwiIH0sCisgICAgeyAiaWNvIiwgImltYWdlL3gtaWNvbiIgfSwKKyAgICB7ICJqcGVnIiwgImlt YWdlL2pwZWciIH0sCisgICAgeyAianBnIiwgImltYWdlL2pwZWciIH0sCisgICAgeyAianMiLCAi YXBwbGljYXRpb24veC1qYXZhc2NyaXB0IiB9LAorICAgIHsgIm1uZyIsICJ2aWRlby94LW1uZyIg fSwKKyAgICB7ICJwYm0iLCAiaW1hZ2UveC1wb3J0YWJsZS1iaXRtYXAiIH0sCisgICAgeyAicGdt IiwgImltYWdlL3gtcG9ydGFibGUtZ3JheW1hcCIgfSwKKyAgICB7ICJwZGYiLCAiYXBwbGljYXRp b24vcGRmIiB9LAorICAgIHsgInBuZyIsICJpbWFnZS9wbmciIH0sCisgICAgeyAicHBtIiwgImlt YWdlL3gtcG9ydGFibGUtcGl4bWFwIiB9LAorICAgIHsgInJzcyIsICJhcHBsaWNhdGlvbi9yc3Mr eG1sIiB9LAorICAgIHsgInN2ZyIsICJpbWFnZS9zdmcreG1sIiB9LAorICAgIHsgInRleHQiLCAi dGV4dC9wbGFpbiIgfSwKKyAgICB7ICJ0aWYiLCAiaW1hZ2UvdGlmZiIgfSwKKyAgICB7ICJ0aWZm IiwgImltYWdlL3RpZmYiIH0sCisgICAgeyAidHh0IiwgInRleHQvcGxhaW4iIH0sCisgICAgeyAi eGJtIiwgImltYWdlL3gteGJpdG1hcCIgfSwKKyAgICB7ICJ4bWwiLCAidGV4dC94bWwiIH0sCisg ICAgeyAieHBtIiwgImltYWdlL3gteHBtIiB9LAorICAgIHsgInhzbCIsICJ0ZXh0L3hzbCIgfSwK KyAgICB7ICJ4aHRtbCIsICJhcHBsaWNhdGlvbi94aHRtbCt4bWwiIH0sCisgICAgeyAid21sIiwg InRleHQvdm5kLndhcC53bWwiIH0sCisgICAgeyAid21sYyIsICJhcHBsaWNhdGlvbi92bmQud2Fw LndtbGMiIH0sCisgICAgeyAwLCAwIH0KK307CisKK3N0YXRpYyBRU3RyaW5nIGdldE1pbWVUeXBl Rm9yRXh0ZW5zaW9uKGNvbnN0IFFTdHJpbmcgJmV4dCkKK3sKKyAgICBjb25zdCBJbWFnZUV4dGVu c2lvbk1hcCAqZSA9IGV4dGVuc2lvbk1hcDsKKyAgICB3aGlsZSAoZS0+ZXh0ZW5zaW9uKSB7Cisg ICAgICAgIGlmIChleHQuY29tcGFyZShRTGF0aW4xU3RyaW5nKGUtPmV4dGVuc2lvbiksIFF0OjpD YXNlSW5zZW5zaXRpdmUpID09IDApCisgICAgICAgICAgICByZXR1cm4gUUxhdGluMVN0cmluZyhl LT5taW1lVHlwZSk7CisgICAgICAgICsrZTsKKyAgICB9CisKKyAgICByZXR1cm4gUVN0cmluZygp OworfQorCit2b2lkIHRzdF9RV2ViUGFnZTo6c3VwcG9ydGVkQ29udGVudFR5cGUoKQoreworICAg UVN0cmluZ0xpc3QgY29udGVudFR5cGVzOworCisgICAvLyBBZGQgc3VwcG9ydGVkIG5vbiBpbWFn ZSB0eXBlcy4uLgorICAgY29udGVudFR5cGVzIDw8ICJ0ZXh0L2h0bWwiIDw8ICJ0ZXh0L3htbCIg PDwgInRleHQveHNsIiA8PCAidGV4dC9wbGFpbiIgPDwgInRleHQvIgorICAgICAgICAgICAgICAg IDw8ICJhcHBsaWNhdGlvbi94bWwiIDw8ICJhcHBsaWNhdGlvbi94aHRtbCt4bWwiIDw8ICJhcHBs aWNhdGlvbi92bmQud2FwLnhodG1sK3htbCIKKyAgICAgICAgICAgICAgICA8PCAiYXBwbGljYXRp b24vcnNzK3htbCIgPDwgImFwcGxpY2F0aW9uL2F0b20reG1sIiA8PCAiYXBwbGljYXRpb24vanNv biI7CisKKyAgIC8vIEFkZCBzdXBwb3J0ZWQgaW1hZ2UgdHlwZXMuLi4KKyAgIFFfRk9SRUFDSChj b25zdCBRQnl0ZUFycmF5JiBpbWFnZVR5cGUsIFFJbWFnZVdyaXRlcjo6c3VwcG9ydGVkSW1hZ2VG b3JtYXRzKCkpIHsKKyAgICAgIGNvbnN0IFFTdHJpbmcgbWltZVR5cGUgPSBnZXRNaW1lVHlwZUZv ckV4dGVuc2lvbihpbWFnZVR5cGUpOworICAgICAgaWYgKCFtaW1lVHlwZS5pc0VtcHR5KCkpCisg ICAgICAgICAgY29udGVudFR5cGVzIDw8IG1pbWVUeXBlOworICAgfQorCisgICAvLyBHZXQgdGhl IG1pbWUgdHlwZXMgc3VwcG9ydGVkIGJ5IHdlYmtpdC4uLgorICAgY29uc3QgUVN0cmluZ0xpc3Qg c3VwcG9ydGVkQ29udGVudFR5cGVzID0gbV9wYWdlLT5zdXBwb3J0ZWRDb250ZW50VHlwZXMoKTsK KworICAgUV9GT1JFQUNIKGNvbnN0IFFTdHJpbmcmIG1pbWVUeXBlLCBjb250ZW50VHlwZXMpCisg ICAgICBRVkVSSUZZMihzdXBwb3J0ZWRDb250ZW50VHlwZXMuY29udGFpbnMobWltZVR5cGUpLCBR U3RyaW5nKCInJTEnIGlzIG5vdCBhIHN1cHBvcnRlZCBjb250ZW50IHR5cGUhIikuYXJnKG1pbWVU eXBlKS50b0xhdGluMSgpKTsKKyAgICAgIAorICAgUV9GT1JFQUNIKGNvbnN0IFFTdHJpbmcmIG1p bWVUeXBlLCBjb250ZW50VHlwZXMpCisgICAgICBRVkVSSUZZMihtX3BhZ2UtPmNhbkhhbmRsZUNv bnRlbnRUeXBlKG1pbWVUeXBlKSwgUVN0cmluZygiQ2Fubm90IGhhbmRsZSBjb250ZW50IHR5cGVz ICclMSchIikuYXJnKG1pbWVUeXBlKS50b0xhdGluMSgpKTsKKworICAgUVZFUklGWTIoIW1fcGFn ZS0+Y2FuSGFuZGxlQ29udGVudFR5cGUoImFwcGxpY2F0aW9uL3gtc2hvY2t3YXZlLWZsYXNoIiks CisgICAgICAgICAgICAiU2hvdWxkIG5vdCBoYW5kbGUgY29udGVudCBvZiB0eXBlICdhcHBsaWNh dGlvbi94LXNob2Nrd2F2ZS1mbGFzaCciKTsKKworICAgUVZFUklGWTIoIW1fcGFnZS0+Y2FuSGFu ZGxlQ29udGVudFR5cGUoImFwcGxpY2F0aW9uL3gtamF2YS1hcHBsZXQiKSwKKyAgICAgICAgICAg ICJTaG91bGQgbm90IGhhbmRsZSBjb250ZW50IG9mIHR5cGUgJ2FwcGxpY2F0aW9uL3gtamF2YS1h cHBsZXQnIik7Cit9CisKIFFURVNUX01BSU4odHN0X1FXZWJQYWdlKQogI2luY2x1ZGUgInRzdF9x d2VicGFnZS5tb2MiCg== 69473 2010-10-01 09:23:06 -0700 2010-10-14 17:27:44 -0700 Function for checking content-type supported by QWebPage V... bug_37880.patch text/plain 7394 adawit ZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuY3BwIGIvV2ViS2l0L3F0L0FwaS9x d2VicGFnZS5jcHAKaW5kZXggOTMyMTAzZC4uMzU1YzM0MiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0 L0FwaS9xd2VicGFnZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5jcHAKQEAgLTkx LDYgKzkxLDkgQEAKICNpbmNsdWRlICJQbGF0Zm9ybVRvdWNoRXZlbnQuaCIKICNpbmNsdWRlICJX b3JrZXJUaHJlYWQuaCIKICNpbmNsdWRlICJ3dGYvVGhyZWFkaW5nLmgiCisjaW5jbHVkZSAiTUlN RVR5cGVSZWdpc3RyeS5oIgorI2luY2x1ZGUgIlBsdWdpbkRhdGFiYXNlLmgiCisjaW5jbHVkZSAi UGx1Z2luUGFja2FnZS5oIgogCiAjaW5jbHVkZSA8UUFwcGxpY2F0aW9uPgogI2luY2x1ZGUgPFFC YXNpY1RpbWVyPgpAQCAtMjE0OSw2ICsyMTUyLDYzIEBAIFFPYmplY3QgKlFXZWJQYWdlOjpjcmVh dGVQbHVnaW4oY29uc3QgUVN0cmluZyAmY2xhc3NpZCwgY29uc3QgUVVybCAmdXJsLCBjb25zdCBR CiAgICAgcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50VHlwZUZyb21I YXNoKGNvbnN0IEhhc2hTZXQ8U3RyaW5nPiYgdHlwZXMsIFFTdHJpbmdMaXN0KiBsaXN0KQorewor ICAgIGlmICghbGlzdCkKKyAgICAgICAgcmV0dXJuOworCisgICAgSGFzaFNldDxTdHJpbmc+Ojpj b25zdF9pdGVyYXRvciBlbmRJdCA9IHR5cGVzLmVuZCgpOworICAgIGZvciAoSGFzaFNldDxTdHJp bmc+Ojpjb25zdF9pdGVyYXRvciBpdCA9IHR5cGVzLmJlZ2luKCk7IGl0ICE9IGVuZEl0OyArK2l0 KQorICAgICAgICAqbGlzdCA8PCAqaXQ7Cit9CisKK3N0YXRpYyB2b2lkIGV4dHJhY3RDb250ZW50 VHlwZUZyb21QbHVnaW5WZWN0b3IoY29uc3QgVmVjdG9yPFBsdWdpblBhY2thZ2UqPiYgcGx1Z2lu cywgUVN0cmluZ0xpc3QqIGxpc3QpCit7CisgICAgaWYgKCFsaXN0KQorICAgICAgICByZXR1cm47 CisKKyAgICBmb3IgKHVuc2lnbmVkIGludCBpID0gMDsgaSA8IHBsdWdpbnMuc2l6ZSgpOyArK2kp IHsKKyAgICAgICAgTUlNRVRvRGVzY3JpcHRpb25zTWFwOjpjb25zdF9pdGVyYXRvciBtYXBfaXQg PSBwbHVnaW5zW2ldLT5taW1lVG9EZXNjcmlwdGlvbnMoKS5iZWdpbigpOworICAgICAgICBNSU1F VG9EZXNjcmlwdGlvbnNNYXA6OmNvbnN0X2l0ZXJhdG9yIG1hcF9lbmQgPSBwbHVnaW5zW2ldLT5t aW1lVG9EZXNjcmlwdGlvbnMoKS5lbmQoKTsKKyAgICAgICAgZm9yICg7IG1hcF9pdCAhPSBtYXBf ZW5kOyArK21hcF9pdCkKKyAgICAgICAgICAgICpsaXN0IDw8IG1hcF9pdC0+Zmlyc3Q7CisgICAg fQorfQorCisvKiEKKyAqICBSZXR1cm5zIHRoZSBsaXN0IG9mIGFsbCBjb250ZW50IHR5cGVzIHN1 cHBvcnRlZCBieSBRV2ViUGFnZS4KKyAqLworUVN0cmluZ0xpc3QgUVdlYlBhZ2U6OnN1cHBvcnRl ZENvbnRlbnRUeXBlcygpIGNvbnN0Cit7CisgICAgUVN0cmluZ0xpc3QgbWltZVR5cGVzOworCisg ICAgZXh0cmFjdENvbnRlbnRUeXBlRnJvbUhhc2goTUlNRVR5cGVSZWdpc3RyeTo6Z2V0U3VwcG9y dGVkSW1hZ2VNSU1FVHlwZXMoKSwgJm1pbWVUeXBlcyk7CisgICAgZXh0cmFjdENvbnRlbnRUeXBl RnJvbUhhc2goTUlNRVR5cGVSZWdpc3RyeTo6Z2V0U3VwcG9ydGVkTm9uSW1hZ2VNSU1FVHlwZXMo KSwgJm1pbWVUeXBlcyk7CisgICAgaWYgKGQtPnBhZ2UtPnNldHRpbmdzKCkgJiYgZC0+cGFnZS0+ c2V0dGluZ3MoKS0+YXJlUGx1Z2luc0VuYWJsZWQoKSkKKyAgICAgICAgZXh0cmFjdENvbnRlbnRU eXBlRnJvbVBsdWdpblZlY3RvcihQbHVnaW5EYXRhYmFzZTo6aW5zdGFsbGVkUGx1Z2lucygpLT5w bHVnaW5zKCksICZtaW1lVHlwZXMpOworCisgICAgcmV0dXJuIG1pbWVUeXBlczsKK30KKworLyoh CisgKiAgUmV0dXJucyB0cnVlIGlmIFFXZWJQYWdlIGNhbiBoYW5kbGUgdGhlIGdpdmVuIFxhIG1p bWVUeXBlOyBvdGhlcndpc2UsIHJldHVybnMgZmFsc2UuCisgKi8KK2Jvb2wgUVdlYlBhZ2U6OnN1 cHBvcnRzQ29udGVudFR5cGUoY29uc3QgUVN0cmluZyYgbWltZVR5cGUpIGNvbnN0Cit7CisgICAg Y29uc3QgU3RyaW5nIHR5cGUgPSBtaW1lVHlwZS50b0xvd2VyKCk7CisgICAgaWYgKE1JTUVUeXBl UmVnaXN0cnk6OmlzU3VwcG9ydGVkSW1hZ2VNSU1FVHlwZSh0eXBlKSkKKyAgICAgICAgcmV0dXJu IHRydWU7CisKKyAgICBpZiAoTUlNRVR5cGVSZWdpc3RyeTo6aXNTdXBwb3J0ZWROb25JbWFnZU1J TUVUeXBlKHR5cGUpKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmIChkLT5wYWdlLT5z ZXR0aW5ncygpICYmIGQtPnBhZ2UtPnNldHRpbmdzKCktPmFyZVBsdWdpbnNFbmFibGVkKCkKKyAg ICAgICAgJiYgUGx1Z2luRGF0YWJhc2U6Omluc3RhbGxlZFBsdWdpbnMoKS0+aXNNSU1FVHlwZVJl Z2lzdGVyZWQodHlwZSkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgcmV0dXJuIGZhbHNl OworfQorCiBzdGF0aWMgV2ViQ29yZTo6RnJhbWVMb2FkUmVxdWVzdCBmcmFtZUxvYWRSZXF1ZXN0 KGNvbnN0IFFVcmwgJnVybCwgV2ViQ29yZTo6RnJhbWUgKmZyYW1lKQogewogICAgIFdlYkNvcmU6 OlJlc291cmNlUmVxdWVzdCBycih1cmwsIGZyYW1lLT5sb2FkZXIoKS0+b3V0Z29pbmdSZWZlcnJl cigpKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYnBhZ2UuaCBiL1dlYktpdC9xdC9B cGkvcXdlYnBhZ2UuaAppbmRleCBlNzFlM2RhLi4xMTM3YzZkIDEwMDY0NAotLS0gYS9XZWJLaXQv cXQvQXBpL3F3ZWJwYWdlLmgKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2VicGFnZS5oCkBAIC0zMDks NiArMzA5LDkgQEAgcHVibGljOgogCiAgICAgdm9pZCBzZXRVc2VyUGVybWlzc2lvbihRV2ViRnJh bWUqIGZyYW1lLCBQZXJtaXNzaW9uRG9tYWluIGRvbWFpbiwgUGVybWlzc2lvblBvbGljeSBwb2xp Y3kpOwogCisgICAgUVN0cmluZ0xpc3Qgc3VwcG9ydGVkQ29udGVudFR5cGVzKCkgY29uc3Q7Cisg ICAgYm9vbCBzdXBwb3J0c0NvbnRlbnRUeXBlKGNvbnN0IFFTdHJpbmcmIG1pbWVUeXBlKSBjb25z dDsKKwogICAgIGVudW0gRXh0ZW5zaW9uIHsKICAgICAgICAgQ2hvb3NlTXVsdGlwbGVGaWxlc0V4 dGVuc2lvbiwKICAgICAgICAgRXJyb3JQYWdlRXh0ZW5zaW9uCmRpZmYgLS1naXQgYS9XZWJLaXQv cXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCAyOGQ3MGE5Li45ZDBhMDI1 IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9xdC9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxOCBAQAorMjAxMC0wOS0yNyBEYXdpdCBBbGVtYXllaHUgIDxhZGF3aXRA a2RlLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBbUXRdIEFkZGVkIGZ1bmN0aW9ucyBmb3Igb2J0YWluaW5nIGFuZCBjaGVja2luZyB0aGUgc3Vw cG9ydGVkIGNvbnRlbnQgdHlwZXMuCisgICAgICAgIGh0dHA6Ly93ZWJraXQub3JnL2IvMzc4ODAK KworICAgICAgICAqIEFwaS9xd2VicGFnZS5jcHA6CisgICAgICAgIChleHRyYWN0Q29udGVudFR5 cGVGcm9tSGFzaCk6CisgICAgICAgIChleHRyYWN0Q29udGVudFR5cGVGcm9tUGx1Z2luVmVjdG9y KToKKyAgICAgICAgKFFXZWJQYWdlOjpzdXBwb3J0ZWRDb250ZW50VHlwZXMpOgorICAgICAgICAo UVdlYlBhZ2U6OnN1cHBvcnRzQ29udGVudFR5cGUpOgorICAgICAgICAqIHRlc3RzL3F3ZWJwYWdl L3RzdF9xd2VicGFnZS5jcHA6CisgICAgICAgICh0c3RfUVdlYlBhZ2U6OnN1cHBvcnRlZENvbnRl bnRUeXBlKToKKwogMjAxMC0wOS0zMCAgQW5kcmVhcyBLbGluZyAgPGFuZHJlYXMua2xpbmdAbm9r aWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFRvciBBcm5lIFZlc3Riw7guCkBAIC0yNzks NyArMjk0LDYgQEAKICAgICAgICAgKFFXZWJTZXR0aW5nczo6UVdlYlNldHRpbmdzKToKICAgICAg ICAgKiBBcGkvcXdlYnNldHRpbmdzLmg6CiAKLQogMjAxMC0wOS0yMyAgVG9yIEFybmUgVmVzdGLD uCAgPHRvci5hcm5lLnZlc3Rib0Bub2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2lt b24gSGF1c21hbm4uCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvdGVzdHMvcXdlYnBhZ2UvdHN0X3F3 ZWJwYWdlLmNwcCBiL1dlYktpdC9xdC90ZXN0cy9xd2VicGFnZS90c3RfcXdlYnBhZ2UuY3BwCmlu ZGV4IDNkZGJmNGUuLjA0NjI5NTMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC90ZXN0cy9xd2VicGFn ZS90c3RfcXdlYnBhZ2UuY3BwCisrKyBiL1dlYktpdC9xdC90ZXN0cy9xd2VicGFnZS90c3RfcXdl YnBhZ2UuY3BwCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSA8cXdlYnBhZ2UuaD4KICNpbmNs dWRlIDxxd2Vic2VjdXJpdHlvcmlnaW4uaD4KICNpbmNsdWRlIDxxd2Vidmlldy5oPgorI2luY2x1 ZGUgPHFpbWFnZXdyaXRlci5oPgogCiBjbGFzcyBFdmVudFNweSA6IHB1YmxpYyBRT2JqZWN0LCBw dWJsaWMgUUxpc3Q8UUV2ZW50OjpUeXBlPgogewpAQCAtMTI2LDYgKzEyNyw3IEBAIHByaXZhdGUg c2xvdHM6CiAgICAgdm9pZCBzaG93TW9kYWxEaWFsb2coKTsKICAgICB2b2lkIHRlc3RTdG9wU2No ZWR1bGVkUGFnZVJlZnJlc2goKTsKICAgICB2b2lkIGZpbmRUZXh0KCk7CisgICAgdm9pZCBzdXBw b3J0ZWRDb250ZW50VHlwZSgpOwogICAgIAogcHJpdmF0ZToKICAgICBRV2ViVmlldyogbV92aWV3 OwpAQCAtMjIwMyw1ICsyMjA1LDgwIEBAIHZvaWQgdHN0X1FXZWJQYWdlOjpmaW5kVGV4dCgpCiAg ICAgfQogfQogCitzdHJ1Y3QgSW1hZ2VFeHRlbnNpb25NYXAgeworICAgIGNvbnN0IGNoYXIqIGV4 dGVuc2lvbjsKKyAgICBjb25zdCBjaGFyKiBtaW1lVHlwZTsKK307CisKK3N0YXRpYyBjb25zdCBJ bWFnZUV4dGVuc2lvbk1hcCBleHRlbnNpb25NYXBbXSA9IHsKKyAgICB7ICJibXAiLCAiaW1hZ2Uv Ym1wIiB9LAorICAgIHsgImNzcyIsICJ0ZXh0L2NzcyIgfSwKKyAgICB7ICJnaWYiLCAiaW1hZ2Uv Z2lmIiB9LAorICAgIHsgImh0bWwiLCAidGV4dC9odG1sIiB9LAorICAgIHsgImh0bSIsICJ0ZXh0 L2h0bWwiIH0sCisgICAgeyAiaWNvIiwgImltYWdlL3gtaWNvbiIgfSwKKyAgICB7ICJqcGVnIiwg ImltYWdlL2pwZWciIH0sCisgICAgeyAianBnIiwgImltYWdlL2pwZWciIH0sCisgICAgeyAianMi LCAiYXBwbGljYXRpb24veC1qYXZhc2NyaXB0IiB9LAorICAgIHsgIm1uZyIsICJ2aWRlby94LW1u ZyIgfSwKKyAgICB7ICJwYm0iLCAiaW1hZ2UveC1wb3J0YWJsZS1iaXRtYXAiIH0sCisgICAgeyAi cGdtIiwgImltYWdlL3gtcG9ydGFibGUtZ3JheW1hcCIgfSwKKyAgICB7ICJwZGYiLCAiYXBwbGlj YXRpb24vcGRmIiB9LAorICAgIHsgInBuZyIsICJpbWFnZS9wbmciIH0sCisgICAgeyAicHBtIiwg ImltYWdlL3gtcG9ydGFibGUtcGl4bWFwIiB9LAorICAgIHsgInJzcyIsICJhcHBsaWNhdGlvbi9y c3MreG1sIiB9LAorICAgIHsgInN2ZyIsICJpbWFnZS9zdmcreG1sIiB9LAorICAgIHsgInRleHQi LCAidGV4dC9wbGFpbiIgfSwKKyAgICB7ICJ0aWYiLCAiaW1hZ2UvdGlmZiIgfSwKKyAgICB7ICJ0 aWZmIiwgImltYWdlL3RpZmYiIH0sCisgICAgeyAidHh0IiwgInRleHQvcGxhaW4iIH0sCisgICAg eyAieGJtIiwgImltYWdlL3gteGJpdG1hcCIgfSwKKyAgICB7ICJ4bWwiLCAidGV4dC94bWwiIH0s CisgICAgeyAieHBtIiwgImltYWdlL3gteHBtIiB9LAorICAgIHsgInhzbCIsICJ0ZXh0L3hzbCIg fSwKKyAgICB7ICJ4aHRtbCIsICJhcHBsaWNhdGlvbi94aHRtbCt4bWwiIH0sCisgICAgeyAid21s IiwgInRleHQvdm5kLndhcC53bWwiIH0sCisgICAgeyAid21sYyIsICJhcHBsaWNhdGlvbi92bmQu d2FwLndtbGMiIH0sCisgICAgeyAwLCAwIH0KK307CisKK3N0YXRpYyBRU3RyaW5nIGdldE1pbWVU eXBlRm9yRXh0ZW5zaW9uKGNvbnN0IFFTdHJpbmcgJmV4dCkKK3sKKyAgICBjb25zdCBJbWFnZUV4 dGVuc2lvbk1hcCAqZSA9IGV4dGVuc2lvbk1hcDsKKyAgICB3aGlsZSAoZS0+ZXh0ZW5zaW9uKSB7 CisgICAgICAgIGlmIChleHQuY29tcGFyZShRTGF0aW4xU3RyaW5nKGUtPmV4dGVuc2lvbiksIFF0 OjpDYXNlSW5zZW5zaXRpdmUpID09IDApCisgICAgICAgICAgICByZXR1cm4gUUxhdGluMVN0cmlu ZyhlLT5taW1lVHlwZSk7CisgICAgICAgICsrZTsKKyAgICB9CisKKyAgICByZXR1cm4gUVN0cmlu ZygpOworfQorCit2b2lkIHRzdF9RV2ViUGFnZTo6c3VwcG9ydGVkQ29udGVudFR5cGUoKQorewor ICAgUVN0cmluZ0xpc3QgY29udGVudFR5cGVzOworCisgICAvLyBBZGQgc3VwcG9ydGVkIG5vbiBp bWFnZSB0eXBlcy4uLgorICAgY29udGVudFR5cGVzIDw8ICJ0ZXh0L2h0bWwiIDw8ICJ0ZXh0L3ht bCIgPDwgInRleHQveHNsIiA8PCAidGV4dC9wbGFpbiIgPDwgInRleHQvIgorICAgICAgICAgICAg ICAgIDw8ICJhcHBsaWNhdGlvbi94bWwiIDw8ICJhcHBsaWNhdGlvbi94aHRtbCt4bWwiIDw8ICJh cHBsaWNhdGlvbi92bmQud2FwLnhodG1sK3htbCIKKyAgICAgICAgICAgICAgICA8PCAiYXBwbGlj YXRpb24vcnNzK3htbCIgPDwgImFwcGxpY2F0aW9uL2F0b20reG1sIiA8PCAiYXBwbGljYXRpb24v anNvbiI7CisKKyAgIC8vIEFkZCBzdXBwb3J0ZWQgaW1hZ2UgdHlwZXMuLi4KKyAgIFFfRk9SRUFD SChjb25zdCBRQnl0ZUFycmF5JiBpbWFnZVR5cGUsIFFJbWFnZVdyaXRlcjo6c3VwcG9ydGVkSW1h Z2VGb3JtYXRzKCkpIHsKKyAgICAgIGNvbnN0IFFTdHJpbmcgbWltZVR5cGUgPSBnZXRNaW1lVHlw ZUZvckV4dGVuc2lvbihpbWFnZVR5cGUpOworICAgICAgaWYgKCFtaW1lVHlwZS5pc0VtcHR5KCkp CisgICAgICAgICAgY29udGVudFR5cGVzIDw8IG1pbWVUeXBlOworICAgfQorCisgICAvLyBHZXQg dGhlIG1pbWUgdHlwZXMgc3VwcG9ydGVkIGJ5IHdlYmtpdC4uLgorICAgY29uc3QgUVN0cmluZ0xp c3Qgc3VwcG9ydGVkQ29udGVudFR5cGVzID0gbV9wYWdlLT5zdXBwb3J0ZWRDb250ZW50VHlwZXMo KTsKKworICAgUV9GT1JFQUNIKGNvbnN0IFFTdHJpbmcmIG1pbWVUeXBlLCBjb250ZW50VHlwZXMp CisgICAgICBRVkVSSUZZMihzdXBwb3J0ZWRDb250ZW50VHlwZXMuY29udGFpbnMobWltZVR5cGUp LCBRU3RyaW5nKCInJTEnIGlzIG5vdCBhIHN1cHBvcnRlZCBjb250ZW50IHR5cGUhIikuYXJnKG1p bWVUeXBlKS50b0xhdGluMSgpKTsKKyAgICAgIAorICAgUV9GT1JFQUNIKGNvbnN0IFFTdHJpbmcm IG1pbWVUeXBlLCBjb250ZW50VHlwZXMpCisgICAgICBRVkVSSUZZMihtX3BhZ2UtPnN1cHBvcnRz Q29udGVudFR5cGUobWltZVR5cGUpLCBRU3RyaW5nKCJDYW5ub3QgaGFuZGxlIGNvbnRlbnQgdHlw ZXMgJyUxJyEiKS5hcmcobWltZVR5cGUpLnRvTGF0aW4xKCkpOworfQorCiBRVEVTVF9NQUlOKHRz dF9RV2ViUGFnZSkKICNpbmNsdWRlICJ0c3RfcXdlYnBhZ2UubW9jIgo=