38742 2010-05-07 05:06:53 -0700 [chromium] Implement canEstablishDatabase call for workers. 2010-05-15 15:30:02 -0700 1 1 1 Unclassified WebKit WebKit Misc. 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 39145 0 jochen webkit-unassigned abarth atwilson commit-queue dglazkov dimich ericu levin michaeln webkit.review.bot oldest_to_newest 222279 0 jochen 2010-05-07 05:06:53 -0700 This wires up the canEstablishDatabase call for workers. It gets routed to WebWorkerCommonClient::allowDatabase 222281 1 55364 jochen 2010-05-07 05:08:16 -0700 Created attachment 55364 Patch 222284 2 webkit.review.bot 2010-05-07 05:12:48 -0700 Attachment 55364 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--no-squash']" exit_code: 1 WebKit/chromium/ChangeLog:6: Line contains tab character. [whitespace/tab] [5] Total errors found: 1 in 6 files If any of these errors are false positives, please file a bug against check-webkit-style. 222285 3 55365 jochen 2010-05-07 05:16:51 -0700 Created attachment 55365 Patch 222286 4 webkit.review.bot 2010-05-07 05:18:05 -0700 Attachment 55364 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/2196035 222288 5 55367 jochen 2010-05-07 05:23:23 -0700 Created attachment 55367 Patch 222290 6 webkit.review.bot 2010-05-07 05:25:21 -0700 Attachment 55365 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/2215040 222499 7 55367 dimich 2010-05-07 11:19:37 -0700 Comment on attachment 55367 Patch Looks reasonable, couple of notes: WebKit/chromium/src/WebWorkerBase.cpp:157 + return false; It is enough to have simple ASSERT(controller) here, since this method is not supposed to be called for non-worker contexts and there is no meaningful scenario when we actually want to return false from here. WebKit/chromium/src/WebWorkerBase.h:150 + class AllowDatabaseMainThreadBridge; This class is a detail of implementation and should be declared/defined in cpp file. WebKit/chromium/src/WebWorkerBase.h:152 + static void allowDatabaseTask( This can be just a static method in cpp file, it does not need to be in .h WebKit/chromium/src/WebWorkerBase.cpp:198 + void WebWorkerBase::AllowDatabaseMainThreadBridge::cancel() Where is this method used? WebKit/chromium/src/WebWorkerBase.cpp:206 + MutexLocker lock(m_synchronousMutex); Why this mutex is necessary? It is usually not needed to protect bool values like that. 222525 8 michaeln 2010-05-07 12:09:02 -0700 This looks pretty good to me. Consider setting the result data member and done data member in the AllowDatabaseMainThreadBridge::didComplete() method body which is run on the context thread. That could help get rid of the mutex. 91 // Controls whether access to Web Databases is allowed for this worker. 92 virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize); Does WebWorkerBase::allowDatabase really need to be virtual? I don't think this is an overload of the method in the public api. Also I think the method arguments can be in terms of WebCore types instead of WebKit types. Is WebWorkerClientImpl::allowDatabase really needed? When/where is that method called? 222536 9 michaeln 2010-05-07 12:17:22 -0700 > Is WebWorkerClientImpl::allowDatabase really needed? When/where is that method > called? Duh... please ignore that last comment (above) about WebWorkerClientImpl :) 222542 10 jochen 2010-05-07 12:23:10 -0700 (In reply to comment #8) > This looks pretty good to me. > > Consider setting the result data member and done data member in the > AllowDatabaseMainThreadBridge::didComplete() method body which is run on the > context thread. That could help get rid of the mutex. good point. > > 91 // Controls whether access to Web Databases is allowed for this worker. > 92 virtual bool allowDatabase(WebFrame*, const WebString& name, const > WebString& displayName, unsigned long estimatedSize); > > Does WebWorkerBase::allowDatabase really need to be virtual? I don't think this > is an overload of the method in the public api. Also I think the method > arguments can be in terms of WebCore types instead of WebKit types. > > Is WebWorkerClientImpl::allowDatabase really needed? When/where is that method > called? 222544 11 jochen 2010-05-07 12:25:05 -0700 (In reply to comment #7) > (From update of attachment 55367 [details]) > Looks reasonable, couple of notes: > > WebKit/chromium/src/WebWorkerBase.cpp:157 > + return false; > It is enough to have simple ASSERT(controller) here, since this method is not > supposed to be called for non-worker contexts and there is no meaningful > scenario when we actually want to return false from here. > > WebKit/chromium/src/WebWorkerBase.h:150 > + class AllowDatabaseMainThreadBridge; > This class is a detail of implementation and should be declared/defined in cpp > file. > > WebKit/chromium/src/WebWorkerBase.h:152 > + static void allowDatabaseTask( > This can be just a static method in cpp file, it does not need to be in .h > > WebKit/chromium/src/WebWorkerBase.cpp:198 > + void WebWorkerBase::AllowDatabaseMainThreadBridge::cancel() > Where is this method used? Hups, I've intended to invoke this when the runloop was terminated before the call was completed. In that case, the didComplete call should be get scheduled on the context thread. > > WebKit/chromium/src/WebWorkerBase.cpp:206 > + MutexLocker lock(m_synchronousMutex); > Why this mutex is necessary? It is usually not needed to protect bool values > like that. 223180 12 55524 jochen 2010-05-10 00:29:37 -0700 Created attachment 55524 Patch 223181 13 webkit.review.bot 2010-05-10 00:30:40 -0700 Attachment 55524 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--no-squash']" exit_code: 1 WebKit/chromium/src/WebWorkerBase.cpp:122: One space before end of line comments [whitespace/comments] [5] Total errors found: 1 in 8 files If any of these errors are false positives, please file a bug against check-webkit-style. 223182 14 jochen 2010-05-10 00:35:18 -0700 (In reply to comment #13) > Attachment 55524 [details] did not pass style-queue: > > Failed to run "['WebKitTools/Scripts/check-webkit-style', '--no-squash']" exit_code: 1 > WebKit/chromium/src/WebWorkerBase.cpp:122: One space before end of line comments [whitespace/comments] [5] > Total errors found: 1 in 8 files > > > If any of these errors are false positives, please file a bug against check-webkit-style. this is } // namespace there's another instance in WebCore/rendering that does the same, and the coding style doesn't really say what to do with namespaces :/ 223234 15 55540 jochen 2010-05-10 03:57:48 -0700 Created attachment 55540 Patch 223320 16 jochen 2010-05-10 08:25:30 -0700 I've landed the allowDatabase stubs on chromium, so this patch is safe to apply. 223324 17 abarth 2010-05-10 08:27:57 -0700 > > If any of these errors are false positives, please file a bug against check-webkit-style. > > this is > > } // namespace > > there's another instance in WebCore/rendering that does the same, and the coding style doesn't really say what to do with namespaces :/ I believe the style checker is correct here and the examples of this in other files are errors that predate the style checker. 223328 18 jochen 2010-05-10 08:29:55 -0700 (In reply to comment #17) > > > If any of these errors are false positives, please file a bug against check-webkit-style. > > > > this is > > > > } // namespace > > > > there's another instance in WebCore/rendering that does the same, and the coding style doesn't really say what to do with namespaces :/ > > I believe the style checker is correct here and the examples of this in other files are errors that predate the style checker. yes, I've updated the patch accordingly. 223501 19 55540 atwilson 2010-05-10 13:59:51 -0700 Comment on attachment 55540 Patch > diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog > index 13e117d3f520ad993695e5793be6b66eb7f22b6a..8d0886515d3e350977640e8bec0a7132d6df23db 100644 > --- a/WebKit/chromium/ChangeLog > +++ b/WebKit/chromium/ChangeLog > @@ -1,3 +1,26 @@ > +2010-05-07 Jochen Eisinger <jochen@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Implement canEstablishDatabase call for workers. > + https://bugs.webkit.org/show_bug.cgi?id=38742 > + > + * public/WebCommonWorkerClient.h: > + * src/DatabaseObserver.cpp: > + (WebCore::DatabaseObserver::canEstablishDatabase): > + * src/WebWorkerBase.cpp: > + (WebKit::WebWorkerBase::allowDatabase): > + (WebKit::WebWorkerBase::allowDatabaseTask): > + (WebKit::WebWorkerBase::AllowDatabaseMainThreadBridge::AllowDatabaseMainThreadBridge): > + (WebKit::WebWorkerBase::AllowDatabaseMainThreadBridge::cancel): > + (WebKit::WebWorkerBase::AllowDatabaseMainThreadBridge::done): > + (WebKit::WebWorkerBase::AllowDatabaseMainThreadBridge::result): > + (WebKit::WebWorkerBase::AllowDatabaseMainThreadBridge::signalCompleted): > + (WebKit::WebWorkerBase::AllowDatabaseMainThreadBridge::didComplete): > + * src/WebWorkerBase.h: > + * src/WebWorkerClientImpl.h: > + (WebKit::WebWorkerClientImpl::allowDatabase): > + > 2010-05-08 Jens Alfke <snej@chromium.org> > > Reviewed by Darin Fisher. > diff --git a/WebKit/chromium/public/WebCommonWorkerClient.h b/WebKit/chromium/public/WebCommonWorkerClient.h > index 13603cbc9315085430393a84c7f695e1e305d256..cea647123a52f5032850890dc84552c41644ff2d 100644 > --- a/WebKit/chromium/public/WebCommonWorkerClient.h > +++ b/WebKit/chromium/public/WebCommonWorkerClient.h > @@ -35,6 +35,7 @@ namespace WebKit { > > class WebApplicationCacheHost; > class WebApplicationCacheHostClient; > +class WebFrame; > class WebNotificationPresenter; > class WebString; > class WebWorker; > @@ -79,6 +80,9 @@ public: > // Called on the main webkit thread in the worker process during initialization. > virtual WebApplicationCacheHost* createApplicationCacheHost(WebApplicationCacheHostClient*) = 0; > > + // Called on the main webkit thread before opening a web database. > + virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) = 0; > + > protected: > ~WebCommonWorkerClient() { } > }; > diff --git a/WebKit/chromium/src/DatabaseObserver.cpp b/WebKit/chromium/src/DatabaseObserver.cpp > index 6a2e2a70ac08441adbb8e22e0e49355475507c6c..1c5117c0f57bdff1ca51dcc8774af6b3cd27912b 100644 > --- a/WebKit/chromium/src/DatabaseObserver.cpp > +++ b/WebKit/chromium/src/DatabaseObserver.cpp > @@ -50,12 +50,16 @@ namespace WebCore { > bool DatabaseObserver::canEstablishDatabase(ScriptExecutionContext* scriptExecutionContext, const String& name, const String& displayName, unsigned long estimatedSize) > { > ASSERT(scriptExecutionContext->isContextThread()); > - // FIXME: add support for the case scriptExecutionContext()->isWorker() once workers implement web databases. > - ASSERT(scriptExecutionContext->isDocument()); > + ASSERT(scriptExecutionContext->isDocument() || scriptExecutionContext->isWorkerContext()); > if (scriptExecutionContext->isDocument()) { > Document* document = static_cast<Document*>(scriptExecutionContext); > WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame()); > return webFrame->client()->allowDatabase(webFrame, name, displayName, estimatedSize); > + } else { > + WorkerContext* workerContext = static_cast<WorkerContext*>(scriptExecutionContext); > + WorkerLoaderProxy* workerLoaderProxy = &workerContext->thread()->workerLoaderProxy(); > + WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerLoaderProxy); > + return webWorker->allowDatabase(0, name, displayName, estimatedSize); > } > > return true; > diff --git a/WebKit/chromium/src/WebWorkerBase.cpp b/WebKit/chromium/src/WebWorkerBase.cpp > index 2c4b4f632341a2ee8b82ecb51ac172c8a50119b8..b844345ab160a2b6ee9ee1e053692d4b4a44466a 100644 > --- a/WebKit/chromium/src/WebWorkerBase.cpp > +++ b/WebKit/chromium/src/WebWorkerBase.cpp > @@ -31,6 +31,7 @@ > #include "config.h" > #include "WebWorkerBase.h" > > +#include "DatabaseTask.h" > #include "GenericWorkerTask.h" > #include "MessagePortChannel.h" > #include "PlatformMessagePortChannel.h" > @@ -44,6 +45,7 @@ > #include "WebView.h" > #include "WebWorkerClient.h" > > +#include "WorkerScriptController.h" > #include "WorkerThread.h" > #include <wtf/MainThread.h> > > @@ -53,6 +55,72 @@ namespace WebKit { > > #if ENABLE(WORKERS) > > +static const char allowDatabaseMode[] = "allowDatabaseMode"; > + > +namespace { > + > +// This class is used to route the result of the WebWorkerBase::allowDatabase > +// call back to the worker context. > +class AllowDatabaseMainThreadBridge : public ThreadSafeShared<AllowDatabaseMainThreadBridge> { > +public: > + static PassRefPtr<AllowDatabaseMainThreadBridge> create(WebWorkerBase* worker, const WebCore::String& mode, WebCommonWorkerClient* commonClient, WebFrame* frame, const WebCore::String& name, const WebCore::String& displayName, unsigned long estimatedSize) { return adoptRef(new AllowDatabaseMainThreadBridge(worker, mode, commonClient, frame, name, displayName, estimatedSize)); } > + > + // These methods are invoked on the worker context. > + void cancel() > + { > + MutexLocker locker(m_mutex); > + m_worker = 0; > + } > + > + bool done() > + { > + return m_completed; > + } > + > + bool result() > + { > + return m_result; > + } > + > + // This method is invoked on the main thread. > + void signalCompleted(bool result) > + { > + MutexLocker locker(m_mutex); > + if (m_worker) > + m_worker->postTaskForModeToWorkerContext(createCallbackTask(&didComplete, this, result), m_mode); > + } > + > +private: > + AllowDatabaseMainThreadBridge(WebWorkerBase* worker, const WebCore::String& mode, WebCommonWorkerClient* commonClient, WebFrame* frame, const WebCore::String& name, const WebCore::String& displayName, unsigned long estimatedSize) > + : m_completed(false) > + , m_worker(worker) > + , m_mode(mode) > + { > + worker->dispatchTaskToMainThread(createCallbackTask(&allowDatabaseTask, commonClient, frame, String(name), String(displayName), estimatedSize, this)); > + } > + > + static void allowDatabaseTask(WebCore::ScriptExecutionContext* context, WebCommonWorkerClient* commonClient, WebFrame* frame, const WebCore::String name, const WebCore::String displayName, unsigned long estimatedSize, PassRefPtr<AllowDatabaseMainThreadBridge> bridge) > + { > + if (!commonClient) > + bridge->signalCompleted(false); > + else > + bridge->signalCompleted(commonClient->allowDatabase(frame, name, displayName, estimatedSize)); > + } > + > + static void didComplete(WebCore::ScriptExecutionContext* context, PassRefPtr<AllowDatabaseMainThreadBridge> bridge, bool result) > + { > + bridge->m_result = result; > + bridge->m_completed = true; > + } > + > + bool m_result; > + bool m_completed; > + Mutex m_mutex; > + WebWorkerBase* m_worker; > + WebCore::String m_mode; > +}; > +} > + > // This function is called on the main thread to force to initialize some static > // values used in WebKit before any worker thread is started. This is because in > // our worker processs, we do not run any WebKit code in main thread and thus > @@ -147,6 +215,30 @@ WebApplicationCacheHost* WebWorkerBase::createApplicationCacheHost(WebFrame*, We > return 0; > } > > +bool WebWorkerBase::allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) > +{ > + WorkerRunLoop& runLoop = m_workerThread->runLoop(); > + WorkerScriptController* controller = WorkerScriptController::controllerForContext(); > + ASSERT(controller); > + WorkerContext* workerContext = controller->workerContext(); > + > + // Create a unique mode just for this synchronous call. > + String mode = allowDatabaseMode; > + mode.append(String::number(runLoop.createUniqueId())); > + > + RefPtr<AllowDatabaseMainThreadBridge> bridge = AllowDatabaseMainThreadBridge::create(this, mode, commonClient(), m_webView->mainFrame(), String(name), String(displayName), estimatedSize); > + MessageQueueWaitResult result = MessageQueueMessageReceived; > + while (!bridge->done() && result != MessageQueueTerminated) > + result = runLoop.runInMode(workerContext, mode); > + > + if (!bridge->done() && result == MessageQueueTerminated) { > + bridge->cancel(); > + return false; > + } > + > + return bridge->result(); > +} > + > // WorkerObjectProxy ----------------------------------------------------------- > > void WebWorkerBase::postMessageToWorkerObject(PassRefPtr<SerializedScriptValue> message, > diff --git a/WebKit/chromium/src/WebWorkerBase.h b/WebKit/chromium/src/WebWorkerBase.h > index a470ee467d2f8629879d95af4c7593249597bd54..15e8013c9e5958b2765fca51e55729570c052a6d 100644 > --- a/WebKit/chromium/src/WebWorkerBase.h > +++ b/WebKit/chromium/src/WebWorkerBase.h > @@ -88,6 +88,9 @@ public: > virtual void didCreateDataSource(WebFrame*, WebDataSource*); > virtual WebApplicationCacheHost* createApplicationCacheHost(WebFrame*, WebApplicationCacheHostClient*); > > + // Controls whether access to Web Databases is allowed for this worker. > + virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize); > + > // Executes the given task on the main thread. > static void dispatchTaskToMainThread(PassOwnPtr<WebCore::ScriptExecutionContext::Task>); > > diff --git a/WebKit/chromium/src/WebWorkerClientImpl.h b/WebKit/chromium/src/WebWorkerClientImpl.h > index 907499a266a6762cfbf29acd93d10574a60f9eeb..afa9b9b337695270e72737dd71ce3995ff59e718 100644 > --- a/WebKit/chromium/src/WebWorkerClientImpl.h > +++ b/WebKit/chromium/src/WebWorkerClientImpl.h > @@ -95,6 +95,7 @@ public: > return 0; > } > virtual WebApplicationCacheHost* createApplicationCacheHost(WebApplicationCacheHostClient*) { return 0; } > + virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) { return true; } > > private: > virtual ~WebWorkerClientImpl(); > diff --git a/WebKitTools/ChangeLog b/WebKitTools/ChangeLog > index 4e48b364a4c12269074dafaf26b4b4d30312952f..4b57ab4260d7de0290da772e93d236f1d9724644 100644 > --- a/WebKitTools/ChangeLog > +++ b/WebKitTools/ChangeLog > @@ -1,3 +1,15 @@ > +2010-05-07 Jochen Eisinger <jochen@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Add allowDatabase method to TestWebWorker. > + https://bugs.webkit.org/show_bug.cgi?id=38742 > + > + Need a short description and bug URL (OOPS!) > + > + * DumpRenderTree/chromium/TestWebWorker.h: > + (TestWebWorker::allowDatabase): > + > 2010-05-09 Daniel Bates <dbates@rim.com> > > Reviewed by Chris Jerdonek. > diff --git a/WebKitTools/DumpRenderTree/chromium/TestWebWorker.h b/WebKitTools/DumpRenderTree/chromium/TestWebWorker.h > index f28cc2055d25754478f0622f3b71673dffb30102..94708040d50e412390c55ab8956639be8add5e09 100644 > --- a/WebKitTools/DumpRenderTree/chromium/TestWebWorker.h > +++ b/WebKitTools/DumpRenderTree/chromium/TestWebWorker.h > @@ -80,6 +80,7 @@ public: > virtual WebKit::WebWorker* createWorker(WebKit::WebWorkerClient*) { return 0; } > virtual WebKit::WebNotificationPresenter* notificationPresenter() { return 0; } > virtual WebKit::WebApplicationCacheHost* createApplicationCacheHost(WebKit::WebApplicationCacheHostClient*) { return 0; } > + virtual bool allowDatabase(WebKit::WebFrame*, const WebKit::WebString&, const WebKit::WebString&, unsigned long) { return true; } > > private: > ~TestWebWorker() {} WebKit/chromium/src/WebWorkerBase.cpp:221 + WorkerScriptController* controller = WorkerScriptController::controllerForContext(); We should be checking for controller == 0 here (allowDatabase() called while worker is shutting down) and returning false. WebKit/chromium/src/WebWorkerClientImpl.h:98 + virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) { return true; } This should never be called on the renderer side, so I think this should be ASSERT_NOT_REACHED() WebKit/chromium/src/WebWorkerBase.cpp:66 + static PassRefPtr<AllowDatabaseMainThreadBridge> create(WebWorkerBase* worker, const WebCore::String& mode, WebCommonWorkerClient* commonClient, WebFrame* frame, const WebCore::String& name, const WebCore::String& displayName, unsigned long estimatedSize) { return adoptRef(new AllowDatabaseMainThreadBridge(worker, mode, commonClient, frame, name, displayName, estimatedSize)); } This seems really hard to read as one big long line. Can we break this up? I'd suggest putting the function body on its own lines at least: static PassRefPtr<...>create(.....) { return adoptRef(...); } WebKit/chromium/src/WebWorkerBase.cpp:234 + if (!bridge->done() && result == MessageQueueTerminated) { Just curious - do we need the check for bridge->done() here and above (and any of the m_completed logic in the Bridge class)? I'm not seeing how runInMode() can return without the appropriate task having been fired (or the queue terminated). 223506 20 atwilson 2010-05-10 14:06:01 -0700 Sorry, reviewer FAIL on that previous comment :( Anyhow, just a quick drive-by: WebKit/chromium/src/WebWorkerBase.cpp:221 + WorkerScriptController* controller = WorkerScriptController::controllerForContext(); We should be checking for controller == 0 here (allowDatabase() called while worker is shutting down) and returning false. WebKit/chromium/src/WebWorkerClientImpl.h:98 + virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) { return true; } This should never be called on the renderer side, so I think this should be ASSERT_NOT_REACHED() WebKit/chromium/src/WebWorkerBase.cpp:66 + static PassRefPtr<AllowDatabaseMainThreadBridge> create(WebWorkerBase* worker, const WebCore::String& mode, WebCommonWorkerClient* commonClient, WebFrame* frame, const WebCore::String& name, const WebCore::String& displayName, unsigned long estimatedSize) { return adoptRef(new AllowDatabaseMainThreadBridge(worker, mode, commonClient, frame, name, displayName, estimatedSize)); } This seems really hard to read as one big long line. Can we break this up? I'd suggest putting the function body on its own lines at least: static PassRefPtr<...>create(.....) { return adoptRef(...); } WebKit/chromium/src/WebWorkerBase.cpp:234 + if (!bridge->done() && result == MessageQueueTerminated) { Just curious - do we need the check for bridge->done() here and above (and any of the m_completed logic in the Bridge class)? I'm not seeing how runInMode() can return without the appropriate task having been fired (or the queue terminated). 223801 21 jochen 2010-05-11 00:53:14 -0700 (In reply to comment #20) > Sorry, reviewer FAIL on that previous comment :( > > Anyhow, just a quick drive-by: > > WebKit/chromium/src/WebWorkerBase.cpp:221 > + WorkerScriptController* controller = WorkerScriptController::controllerForContext(); > We should be checking for controller == 0 here (allowDatabase() called while worker is shutting down) and returning false. Dmitry stated in Comment #7 that this was not possible > > WebKit/chromium/src/WebWorkerClientImpl.h:98 > + virtual bool allowDatabase(WebFrame*, const WebString& name, const WebString& displayName, unsigned long estimatedSize) { return true; } > This should never be called on the renderer side, so I think this should be ASSERT_NOT_REACHED() e.g. createApplicationCacheHost should not be called either, I'd rather add ASSERT_NOT_REACHED to all methods that should not be invoked (but I cannot judge which these are), or none. wdyt? > > WebKit/chromium/src/WebWorkerBase.cpp:66 > + static PassRefPtr<AllowDatabaseMainThreadBridge> create(WebWorkerBase* worker, const WebCore::String& mode, WebCommonWorkerClient* commonClient, WebFrame* frame, const WebCore::String& name, const WebCore::String& displayName, unsigned long estimatedSize) { return adoptRef(new AllowDatabaseMainThreadBridge(worker, mode, commonClient, frame, name, displayName, estimatedSize)); } > This seems really hard to read as one big long line. Can we break this up? I'd suggest putting the function body on its own lines at least: > > static PassRefPtr<...>create(.....) > { > return adoptRef(...); > } done > > > WebKit/chromium/src/WebWorkerBase.cpp:234 > + if (!bridge->done() && result == MessageQueueTerminated) { > Just curious - do we need the check for bridge->done() here and above (and any of the m_completed logic in the Bridge class)? I'm not seeing how runInMode() can return without the appropriate task having been fired (or the queue terminated). done 223802 22 55673 jochen 2010-05-11 00:54:49 -0700 Created attachment 55673 Patch 223988 23 atwilson 2010-05-11 10:12:18 -0700 (In reply to comment #21) > Dmitry stated in Comment #7 that this was not possible I don't think that's correct. What he was saying is that you are never going to call this code outside of worker context, which I agree with. However, you could certainly call this code while the worker is shutting down, which will also cause controllerForContext() to return 0, I believe. Dmitry is indeed the authority here, but I'd like him to confirm that not checking for 0 is OK. > > e.g. createApplicationCacheHost should not be called either, I'd rather add ASSERT_NOT_REACHED to all methods that should not be invoked (but I cannot judge which these are), or none. > I understand your desire for consistency. If you want to change those other lines to be ASSERT_NOT_REACHED() also (and run the appropriate tests to make sure it doesn't break anything) I'm fine with that. The worker interface is confusing enough with various interfaces that are implemented but never called on certain sides of the renderer/worker divide, that I feel pretty strongly that we should be using ASSERT_NOT_REACHED() wherever possible, even if past authors haven't been rigorous in this regard. 224081 24 michaeln 2010-05-11 12:24:29 -0700 > > e.g. createApplicationCacheHost should not be called either, I'd rather add ASSERT_NOT_REACHED to all methods that should not be invoked (but I cannot judge which these are), or none. > > > I understand your desire for consistency. If you want to change those other > lines to be ASSERT_NOT_REACHED() also (and run the appropriate tests to make > sure it doesn't break anything) I'm fine with that. The worker interface is > confusing enough with various interfaces that are implemented but never called > on certain sides of the renderer/worker divide, that I feel pretty strongly > that we should be using ASSERT_NOT_REACHED() wherever possible, even if past > authors haven't been rigorous in this regard. The traversing into and out of and back into (etc) in various processes really makes it challenging to grok the worker interfaces, especially when the same interfaces are used for very different purposes in different places. Interfaces like WebSharedWorker and WebWorker are difficult to get a handle on because they are both used by chrome to call into webkit and used by webkit to call out to chrome, and some of the methods are only applicable on one side or the other. What may be nice is if the worker interfaces where more segregated than they are. One programming interface for use in the process that creates a javascript worker object. Another for use in the process that realizes the worker thread. Could possibly help to avoid NOT_REACHED methods altogether. 224460 25 55815 jochen 2010-05-12 00:50:56 -0700 Created attachment 55815 Patch 224636 26 jochen 2010-05-12 08:34:29 -0700 (In reply to comment #23) > (In reply to comment #21) > > Dmitry stated in Comment #7 that this was not possible > I don't think that's correct. What he was saying is that you are never going to call this code outside of worker context, which I agree with. However, you could certainly call this code while the worker is shutting down, which will also cause controllerForContext() to return 0, I believe. Dmitry is indeed the authority here, but I'd like him to confirm that not checking for 0 is OK. I've added the check for 0 back in. It surely won't hurt. > > > > > e.g. createApplicationCacheHost should not be called either, I'd rather add ASSERT_NOT_REACHED to all methods that should not be invoked (but I cannot judge which these are), or none. > > > I understand your desire for consistency. If you want to change those other lines to be ASSERT_NOT_REACHED() also (and run the appropriate tests to make sure it doesn't break anything) I'm fine with that. The worker interface is confusing enough with various interfaces that are implemented but never called on certain sides of the renderer/worker divide, that I feel pretty strongly that we should be using ASSERT_NOT_REACHED() wherever possible, even if past authors haven't been rigorous in this regard. I've added ASSERT_NOT_REACHED() to allowDatabase then 225408 27 dimich 2010-05-13 11:35:22 -0700 (In reply to comment #24) > The traversing into and out of and back into (etc) in various processes really makes it challenging to grok the worker interfaces, especially when the same interfaces are used for very different purposes in different places. Interfaces like WebSharedWorker and WebWorker are difficult to get a handle on because they are both used by chrome to call into webkit and used by webkit to call out to chrome, and some of the methods are only applicable on one side or the other. > > What may be nice is if the worker interfaces where more segregated than they are. One programming interface for use in the process that creates a javascript worker object. Another for use in the process that realizes the worker thread. Could possibly help to avoid NOT_REACHED methods altogether. This is certainly a painful issue. In Chromium setup, the number of layers, objects and interfaces that simply deliver a call from Worker object to WorkerContext and back clearly exceeds is the number of things the brain can keep simultaneously :-) I think we will have an opportunity to re-visit this once we can run workers in the same process. Dedicated workers could be simply switched back to the renderer process and we might need a setup for shared workers that can support both in-process and IPC connections w/o much code required specifically for the latter. In any case, patches that improve readability and simplify code are very welcome! 225418 28 55815 dimich 2010-05-13 11:58:28 -0700 Comment on attachment 55815 Patch Looks great, would r+ with "change on landing" but since cq is needed, we need a perfect patch. One small thing: WebKit/chromium/src/WebWorkerBase.cpp:217 + // The controller might be 0 when the worker context is in the process of shutting down. I see the discussion in the comments about this check. It is not really needed. There is another method which returns a V8 proxy (WorkerScriptController::proxy()) which indeed returns 0 when the termination of JS in the worker is requested. The WorkerScriptController::controllerForContext() always returns a non-null controller in worker context. See http://trac.webkit.org/changeset/56580. That change split the old function that could return 0 if either the context is not WorkerContext or the termination was requested, to be able to make these checks separately. This is why I think there is no real case when we need an "if(!controller)" here and rather could just have an assert, or even better no check at all since the very next statement is going to crash reliably anyways. 225435 29 michaeln 2010-05-13 12:24:18 -0700 > I think we will have an opportunity to re-visit this once we can run workers in the > same process. Dedicated workers could be simply switched back to the renderer process > and we might need a setup for shared workers that can support both in-process and IPC > connections w/o much code required specifically for the latter. Interesting point about the difference a multithreaded V8 could make. There would be a cost to making that switch, but it could be worth it. 225691 30 56060 jochen 2010-05-14 00:46:46 -0700 Created attachment 56060 Patch 225692 31 jochen 2010-05-14 00:48:05 -0700 (In reply to comment #28) > (From update of attachment 55815 [details]) > Looks great, would r+ with "change on landing" but since cq is needed, we need a perfect patch. > > One small thing: > > WebKit/chromium/src/WebWorkerBase.cpp:217 > + // The controller might be 0 when the worker context is in the process of shutting down. > I see the discussion in the comments about this check. It is not really needed. There is another method which returns a V8 proxy (WorkerScriptController::proxy()) which indeed returns 0 when the termination of JS in the worker is requested. The WorkerScriptController::controllerForContext() always returns a non-null controller in worker context. > See http://trac.webkit.org/changeset/56580. That change split the old function that could return 0 if either the context is not WorkerContext or the termination was requested, to be able to make these checks separately. This is why I think there is no real case when we need an "if(!controller)" here and rather could just have an assert, or even better no check at all since the very next statement is going to crash reliably anyways. hope it's perfect now :) 225920 32 56060 dimich 2010-05-14 11:33:13 -0700 Comment on attachment 56060 Patch r=me 226265 33 56060 commit-queue 2010-05-15 09:23:42 -0700 Comment on attachment 56060 Patch Rejecting patch 56060 from commit-queue. Failed to run "[u'git', u'svn', u'dcommit']" exit_code: 1 Last 500 characters of output: WebKit/chromium/src/WebWorkerClientImpl.h M WebKitTools/ChangeLog M WebKitTools/DumpRenderTree/chromium/TestWebWorker.h A repository hook failed: MERGE request failed on '/repository/webkit/trunk': Commit blocked by pre-commit hook (exit code 1) with output: svnlook: Can't write to stream: Broken pipe The following ChangeLog files contain OOPS: trunk/WebKitTools/ChangeLog Please don't ever say "OOPS" in a ChangeLog file. at /usr/local/git/libexec/git-core/git-svn line 570 Full output: http://webkit-commit-queue.appspot.com/results/2313110 226271 34 abarth 2010-05-15 10:07:18 -0700 "Need a short description and bug URL (OOPS!)" was left in the second ChangeLog. I'll clean it up for you. 226273 35 56158 abarth 2010-05-15 10:08:44 -0700 Created attachment 56158 Patch for landing 226337 36 56158 commit-queue 2010-05-15 15:29:54 -0700 Comment on attachment 56158 Patch for landing Clearing flags on attachment: 56158 Committed r59555: <http://trac.webkit.org/changeset/59555> 226338 37 commit-queue 2010-05-15 15:30:02 -0700 All reviewed patches have been landed. Closing bug. 55364 2010-05-07 05:08:16 -0700 2010-05-07 05:16:43 -0700 Patch bug-38742-20100507140814.patch text/plain 11658 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IDY4MTI5YjAyZDM0MWE1ZjQ2YTBiMWJmMzZmZGYzMDNmMGU4ZTYyYjcu LjkzZjU5NGJmYmFiMThmMTg4NWQ0MGI2NjYwODFhMWM4YmRlZGI4NWIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI3IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorCWh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODc0MgorCisgICAgICAgICog cHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oOgorICAgICAgICAqIHNyYy9EYXRhYmFzZU9i c2VydmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlT2JzZXJ2ZXI6OmNhbkVzdGFi bGlzaERhdGFiYXNlKToKKyAgICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5jcHA6CisgICAgICAg IChXZWJLaXQ6OldlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UpOgorICAgICAgICAoV2ViS2l0 OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlVGFzayk6CisgICAgICAgIChXZWJLaXQ6Oldl YldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpBbGxvd0RhdGFiYXNl TWFpblRocmVhZEJyaWRnZSk6CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckJhc2U6OkFsbG93 RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpjYW5jZWwpOgorICAgICAgICAoV2ViS2l0OjpXZWJX b3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6ZG9uZSk6CisgICAgICAg IChXZWJLaXQ6OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpy ZXN1bHQpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFp blRocmVhZEJyaWRnZTo6c2lnbmFsQ29tcGxldGVkKToKKyAgICAgICAgKFdlYktpdDo6V2ViV29y a2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRpZENvbXBsZXRlKToKKyAg ICAgICAgKiBzcmMvV2ViV29ya2VyQmFzZS5oOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJC YXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y3JlYXRlKToKKyAgICAgICAgKiBz cmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJDbGll bnRJbXBsOjphbGxvd0RhdGFiYXNlKToKKwogMjAxMC0wNS0wNiAgS2VudCBUYW11cmEgIDx0a2Vu dEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGltaXRyaSBHbGF6a292Lgpk aWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQu aCBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXgg MTM2MDNjYmM5MzE1MDg1NDMwMzkzYTg0YzdmNjk1ZTFlMzA1ZDI1Ni4uY2VhNjQ3MTIzYTUyZjUw MzI4NTA4OTBkYzg0NTUyYzQxNjQ0ZmYyZCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1 YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYkNvbW1vbldvcmtlckNsaWVudC5oCkBAIC0zNSw2ICszNSw3IEBAIG5hbWVzcGFjZSBXZWJL aXQgewogCiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdDsKIGNsYXNzIFdlYkFwcGxpY2F0 aW9uQ2FjaGVIb3N0Q2xpZW50OworY2xhc3MgV2ViRnJhbWU7CiBjbGFzcyBXZWJOb3RpZmljYXRp b25QcmVzZW50ZXI7CiBjbGFzcyBXZWJTdHJpbmc7CiBjbGFzcyBXZWJXb3JrZXI7CkBAIC03OSw2 ICs4MCw5IEBAIHB1YmxpYzoKICAgICAvLyBDYWxsZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVh ZCBpbiB0aGUgd29ya2VyIHByb2Nlc3MgZHVyaW5nIGluaXRpYWxpemF0aW9uLgogICAgIHZpcnR1 YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdl YkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50KikgPSAwOwogCisgICAgLy8gQ2FsbGVkIG9uIHRo ZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9wZW5pbmcgYSB3ZWIgZGF0YWJhc2UuCisgICAg dmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5h bWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVk U2l6ZSkgPSAwOworCiBwcm90ZWN0ZWQ6CiAgICAgfldlYkNvbW1vbldvcmtlckNsaWVudCgpIHsg fQogfTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5j cHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwCmluZGV4IDZhMmUy YTcwYWMwODQ0MWFkYmI4ZTIyZTBlNDkzNTU0NzU1MDdjNmMuLjFjNTExN2MwZjU3YmRmZjFjYTUx ZGNjODc3NGFmNmIzY2QyNzkxMmIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9EYXRhYmFzZU9ic2Vy dmVyLmNwcApAQCAtNTAsMTIgKzUwLDE2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGJvb2wgRGF0 YWJhc2VPYnNlcnZlcjo6Y2FuRXN0YWJsaXNoRGF0YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJp bmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCiB7CiAgICAgQVNT RVJUKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlzQ29udGV4dFRocmVhZCgpKTsKLSAgICAvLyBG SVhNRTogYWRkIHN1cHBvcnQgZm9yIHRoZSBjYXNlIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+ aXNXb3JrZXIoKSBvbmNlIHdvcmtlcnMgaW1wbGVtZW50IHdlYiBkYXRhYmFzZXMuCi0gICAgQVNT RVJUKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlzRG9jdW1lbnQoKSk7CisgICAgQVNTRVJUKHNj cmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlzRG9jdW1lbnQoKSB8fCBzY3JpcHRFeGVjdXRpb25Db250 ZXh0LT5pc1dvcmtlckNvbnRleHQoKSk7CiAgICAgaWYgKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQt PmlzRG9jdW1lbnQoKSkgewogICAgICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBzdGF0aWNfY2Fz dDxEb2N1bWVudCo+KHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQpOwogICAgICAgICBXZWJGcmFtZUlt cGwqIHdlYkZyYW1lID0gV2ViRnJhbWVJbXBsOjpmcm9tRnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkp OwogICAgICAgICByZXR1cm4gd2ViRnJhbWUtPmNsaWVudCgpLT5hbGxvd0RhdGFiYXNlKHdlYkZy YW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSk7CisgICAgfSBlbHNlIHsKKyAg ICAgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNv bnRleHQqPihzY3JpcHRFeGVjdXRpb25Db250ZXh0KTsKKyAgICAgICAgV29ya2VyTG9hZGVyUHJv eHkqIHdvcmtlckxvYWRlclByb3h5ID0gJndvcmtlckNvbnRleHQtPnRocmVhZCgpLT53b3JrZXJM b2FkZXJQcm94eSgpOworICAgICAgICBXZWJXb3JrZXJCYXNlKiB3ZWJXb3JrZXIgPSBzdGF0aWNf Y2FzdDxXZWJXb3JrZXJCYXNlKj4od29ya2VyTG9hZGVyUHJveHkpOworICAgICAgICByZXR1cm4g d2ViV29ya2VyLT5hbGxvd0RhdGFiYXNlKDAsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRT aXplKTsKICAgICB9CiAKICAgICByZXR1cm4gdHJ1ZTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtl ckJhc2UuY3BwCmluZGV4IDhlMjY1NjA1NmNlZTBiMDliNDAxYWU1OWI5ZGJhZjU5NzY3ZmU2M2Yu LmJkMDRiNDIxMjU2ZGI1MTliMWExZmFkY2VhNmM2OTUyNzE5ZjcyOGMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgImNvbmZp Zy5oIgogI2luY2x1ZGUgIldlYldvcmtlckJhc2UuaCIKIAorI2luY2x1ZGUgIkRhdGFiYXNlVGFz ay5oIgogI2luY2x1ZGUgIkdlbmVyaWNXb3JrZXJUYXNrLmgiCiAjaW5jbHVkZSAiTWVzc2FnZVBv cnRDaGFubmVsLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1NZXNzYWdlUG9ydENoYW5uZWwuaCIKQEAg LTQyLDYgKzQzLDcgQEAKICNpbmNsdWRlICJXZWJWaWV3LmgiCiAjaW5jbHVkZSAiV2ViV29ya2Vy Q2xpZW50LmgiCiAKKyNpbmNsdWRlICJXb3JrZXJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVk ZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KIApAQCAtNTEs NiArNTMsOCBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogI2lmIEVOQUJMRShXT1JLRVJTKQogCitz dGF0aWMgY29uc3QgY2hhciBhbGxvd0RhdGFiYXNlTW9kZVtdID0gImFsbG93RGF0YWJhc2VNb2Rl IjsKKwogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIG1haW4gdGhyZWFkIHRvIGZv cmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKIC8vIHZhbHVlcyB1c2VkIGluIFdlYktpdCBi ZWZvcmUgYW55IHdvcmtlciB0aHJlYWQgaXMgc3RhcnRlZC4gVGhpcyBpcyBiZWNhdXNlIGluCiAv LyBvdXIgd29ya2VyIHByb2Nlc3NzLCB3ZSBkbyBub3QgcnVuIGFueSBXZWJLaXQgY29kZSBpbiBt YWluIHRocmVhZCBhbmQgdGh1cwpAQCAtMTQ0LDYgKzE0OCw4NSBAQCBXZWJBcHBsaWNhdGlvbkNh Y2hlSG9zdCogV2ViV29ya2VyQmFzZTo6Y3JlYXRlQXBwbGljYXRpb25DYWNoZUhvc3QoV2ViRnJh bWUqLCBXZQogICAgIHJldHVybiAwOwogfQogCitib29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0 YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYg ZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKK3sKKyAgICBXb3JrZXJS dW5Mb29wJiBydW5Mb29wID0gbV93b3JrZXJUaHJlYWQtPnJ1bkxvb3AoKTsKKyAgICBXb3JrZXJT Y3JpcHRDb250cm9sbGVyKiBjb250cm9sbGVyID0gV29ya2VyU2NyaXB0Q29udHJvbGxlcjo6Y29u dHJvbGxlckZvckNvbnRleHQoKTsKKyAgICBpZiAoIWNvbnRyb2xsZXIpIHsKKyAgICAgICAgQVNT RVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgV29y a2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IGNvbnRyb2xsZXItPndvcmtlckNvbnRleHQoKTsK KworICAgIC8vIENyZWF0ZSBhIHVuaXF1ZSBtb2RlIGp1c3QgZm9yIHRoaXMgc3luY2hyb25vdXMg Y2FsbC4KKyAgICBTdHJpbmcgbW9kZSA9IGFsbG93RGF0YWJhc2VNb2RlOworICAgIG1vZGUuYXBw ZW5kKFN0cmluZzo6bnVtYmVyKHJ1bkxvb3AuY3JlYXRlVW5pcXVlSWQoKSkpOworCisgICAgUmVm UHRyPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UgPSBBbGxvd0RhdGFiYXNl TWFpblRocmVhZEJyaWRnZTo6Y3JlYXRlKHRoaXMsIG1vZGUsIFN0cmluZyhuYW1lKSwgU3RyaW5n KGRpc3BsYXlOYW1lKSwgZXN0aW1hdGVkU2l6ZSk7CisgICAgTWVzc2FnZVF1ZXVlV2FpdFJlc3Vs dCByZXN1bHQgPSBNZXNzYWdlUXVldWVNZXNzYWdlUmVjZWl2ZWQ7CisgICAgd2hpbGUgKCFicmlk Z2UtPmRvbmUoKSAmJiByZXN1bHQgIT0gTWVzc2FnZVF1ZXVlVGVybWluYXRlZCkKKyAgICAgICAg cmVzdWx0ID0gcnVuTG9vcC5ydW5Jbk1vZGUod29ya2VyQ29udGV4dCwgbW9kZSk7CisKKyAgICBp ZiAocmVzdWx0ID09IE1lc3NhZ2VRdWV1ZVRlcm1pbmF0ZWQpCisgICAgICAgIHJldHVybiBmYWxz ZTsKKworICAgIHJldHVybiBicmlkZ2UtPnJlc3VsdCgpOworfQorCit2b2lkIFdlYldvcmtlckJh c2U6OmFsbG93RGF0YWJhc2VUYXNrKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdlYldvcmtlckJhc2UqIHRoaXNQ dHIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFN0cmluZyBuYW1lLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcgZGlzcGxheU5hbWUs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGxvbmcgZXN0 aW1hdGVkU2l6ZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUGFzc1Jl ZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlKQoreworICAgIGlmICgh dGhpc1B0ci0+Y29tbW9uQ2xpZW50KCkpCisgICAgICAgIGJyaWRnZS0+c2lnbmFsQ29tcGxldGVk KGZhbHNlKTsKKyAgICBlbHNlCisgICAgICAgIGJyaWRnZS0+c2lnbmFsQ29tcGxldGVkKHRoaXNQ dHItPmNvbW1vbkNsaWVudCgpLT5hbGxvd0RhdGFiYXNlKHRoaXNQdHItPm1fd2ViVmlldy0+bWFp bkZyYW1lKCksIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKSk7Cit9CisKK1dlYldv cmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpBbGxvd0RhdGFiYXNlTWFp blRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0IFN0cmluZyYgbW9kZSwg Y29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUpCisgICAgOiBtX2NvbXBsZXRlZChmYWxzZSkKKyAgICAsIG1fd29y a2VyKHdvcmtlcikKKyAgICAsIG1fbW9kZShtb2RlKQoreworICAgIHdvcmtlci0+ZGlzcGF0Y2hU YXNrVG9NYWluVGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmV2ViV29ya2VyQmFzZTo6YWxsb3dE YXRhYmFzZVRhc2ssIHdvcmtlciwgU3RyaW5nKG5hbWUpLCBTdHJpbmcoZGlzcGxheU5hbWUpLCBl c3RpbWF0ZWRTaXplLCB0aGlzKSk7CisKK30KKwordm9pZCBXZWJXb3JrZXJCYXNlOjpBbGxvd0Rh dGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKCkKK3sKKyAgICBNdXRleExvY2tlciBsb2Nr KG1fc3luY2hyb25vdXNNdXRleCk7CisgICAgbV93b3JrZXIgPSAwOworfQorCitib29sIFdlYldv cmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpkb25lKCkKK3sKKyAgICBN dXRleExvY2tlciBsb2NrKG1fc3luY2hyb25vdXNNdXRleCk7CisgICAgcmV0dXJuIG1fY29tcGxl dGVkOworfQorCitib29sIFdlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJp ZGdlOjpyZXN1bHQoKQoreworICAgIE11dGV4TG9ja2VyIGxvY2sobV9zeW5jaHJvbm91c011dGV4 KTsKKyAgICByZXR1cm4gbV9yZXN1bHQ7Cit9CisKK3ZvaWQgV2ViV29ya2VyQmFzZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OnNpZ25hbENvbXBsZXRlZChib29sIHJlc3VsdCkKK3sK KyAgICBNdXRleExvY2tlciBsb2NrKG1fc3luY2hyb25vdXNNdXRleCk7CisgICAgbV9yZXN1bHQg PSByZXN1bHQ7CisgICAgbV9jb21wbGV0ZWQgPSB0cnVlOworICAgIGlmIChtX3dvcmtlcikKKyAg ICAgICAgbV93b3JrZXItPnBvc3RUYXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dChjcmVhdGVDYWxs YmFja1Rhc2soJmRpZENvbXBsZXRlLCB0aGlzKSwgbV9tb2RlKTsKK30KKwordm9pZCBXZWJXb3Jr ZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6ZGlkQ29tcGxldGUoU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdlYldvcmtlckJhc2U6OkFsbG93RGF0 YWJhc2VNYWluVGhyZWFkQnJpZGdlKiB0aGlzUHRyKQoreworfQorCiAvLyBXb3JrZXJPYmplY3RQ cm94eSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQogCiB2b2lkIFdlYldvcmtlckJhc2U6OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3Qo UGFzc1JlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQmFzZS5oCmluZGV4IGE0NzBlZTQ2N2QyZjg2Mjk4NzlkOTVhZjRjNzU5MzI0OTU5 N2JkNTQuLjFlMmFlZjhiNTczZGVkMmNiMjQ5NDExMWJjYTMwZDhmMGNjYzgwNzUgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCkBAIC04OCw2ICs4OCw5IEBAIHB1YmxpYzoKICAgICB2 aXJ0dWFsIHZvaWQgZGlkQ3JlYXRlRGF0YVNvdXJjZShXZWJGcmFtZSosIFdlYkRhdGFTb3VyY2Uq KTsKICAgICB2aXJ0dWFsIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlv bkNhY2hlSG9zdChXZWJGcmFtZSosIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50Kik7CiAK KyAgICAvLyBDb250cm9scyB3aGV0aGVyIGFjY2VzcyB0byBXZWIgRGF0YWJhc2VzIGlzIGFsbG93 ZWQgZm9yIHRoaXMgd29ya2VyLgorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZy YW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1l LCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpOworCiAgICAgLy8gRXhlY3V0ZXMgdGhlIGdp dmVuIHRhc2sgb24gdGhlIG1haW4gdGhyZWFkLgogICAgIHN0YXRpYyB2b2lkIGRpc3BhdGNoVGFz a1RvTWFpblRocmVhZChQYXNzT3duUHRyPFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6 OlRhc2s+KTsKIApAQCAtMTQ0LDYgKzE0Nyw0MiBAQCBwcml2YXRlOgogICAgICAgICBXZWJDb3Jl OjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LAogICAgICAgICBXZWJXb3JrZXJCYXNl KiB0aGlzUHRyKTsKIAorICAgIGNsYXNzIEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOwor CisgICAgc3RhdGljIHZvaWQgYWxsb3dEYXRhYmFzZVRhc2soCisgICAgICAgIFdlYkNvcmU6OlNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsCisgICAgICAgIFdlYldvcmtlckJhc2UqIHRo aXNQdHIsCisgICAgICAgIGNvbnN0IFdlYkNvcmU6OlN0cmluZyBuYW1lLAorICAgICAgICBjb25z dCBXZWJDb3JlOjpTdHJpbmcgZGlzcGxheU5hbWUsCisgICAgICAgIHVuc2lnbmVkIGxvbmcgZXN0 aW1hdGVkU2l6ZSwKKyAgICAgICAgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZT4gYnJpZGdlKTsKKworICAgIC8vIFRoaXMgY2xhc3MgaXMgdXNlZCB0byByb3V0ZSB0aGUg cmVzdWx0IG9mIHRoZSBhbGxvd0RhdGFiYXNlIGNhbGwgYmFjaworICAgIC8vIHRvIHRoZSB3b3Jr ZXIgY29udGV4dC4KKyAgICBjbGFzcyBBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZSA6IHB1 YmxpYyBUaHJlYWRTYWZlU2hhcmVkPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiB7Cisg ICAgcHVibGljOgorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRo cmVhZEJyaWRnZT4gY3JlYXRlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6 U3RyaW5nJiBtb2RlLCBjb25zdCBXZWJDb3JlOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6 OlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgeyByZXR1 cm4gYWRvcHRSZWYobmV3IEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlKHdvcmtlciwgbW9k ZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsgfQorCisgICAgICAgIC8vIFRo ZXNlIG1ldGhvZHMgYXJlIGludm9rZWQgb24gdGhlIHdvcmtlciBjb250ZXh0LgorICAgICAgICB2 b2lkIGNhbmNlbCgpOworICAgICAgICBib29sIGRvbmUoKTsKKyAgICAgICAgYm9vbCByZXN1bHQo KTsKKworICAgICAgICAvLyBUaGlzIG1ldGhvZCBpcyBpbnZva2VkIG9uIHRoZSBtYWluIHRocmVh ZC4KKyAgICAgICAgdm9pZCBzaWduYWxDb21wbGV0ZWQoYm9vbCByZXN1bHQpOworCisgICAgcHJp dmF0ZToKKyAgICAgICAgQWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UoV2ViV29ya2VyQmFz ZSogd29ya2VyLCBjb25zdCBXZWJDb3JlOjpTdHJpbmcmIG1vZGUsIGNvbnN0IFdlYkNvcmU6OlN0 cmluZyYgbmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQg bG9uZyBlc3RpbWF0ZWRTaXplKTsKKworICAgICAgICBzdGF0aWMgdm9pZCBkaWRDb21wbGV0ZShX ZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBBbGxvd0RhdGFiYXNlTWFp blRocmVhZEJyaWRnZSogdGhpc1B0cik7CisKKyAgICAgICAgYm9vbCBtX3Jlc3VsdDsKKyAgICAg ICAgYm9vbCBtX2NvbXBsZXRlZDsKKyAgICAgICAgTXV0ZXggbV9zeW5jaHJvbm91c011dGV4Owor ICAgICAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICAgICAgV2ViQ29yZTo6U3RyaW5n IG1fbW9kZTsKKyAgICB9OworCiAgICAgLy8gJ3NoYWRvdyBwYWdlJyAtIGNyZWF0ZWQgdG8gcHJv eHkgbG9hZGluZyByZXF1ZXN0cyBmcm9tIHRoZSB3b3JrZXIuCiAgICAgUmVmUHRyPFdlYkNvcmU6 OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ+IG1fbG9hZGluZ0RvY3VtZW50OwogICAgIFdlYlZpZXcq IG1fd2ViVmlldzsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xp ZW50SW1wbC5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKaW5k ZXggOTA3NDk5YTI2NmE2NzYyY2ZiZjI5YWNkOTNkMTA1NzRhNjBmOWVlYi4uYWZhOWI5YjMzNzY5 NTI3MGU3MjczN2RkNzFjZTM5OTVmZjU5ZTcxOCAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJX b3JrZXJDbGllbnRJbXBsLmgKQEAgLTk1LDYgKzk1LDcgQEAgcHVibGljOgogICAgICAgICByZXR1 cm4gMDsKICAgICB9CiAgICAgdmlydHVhbCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogY3JlYXRl QXBwbGljYXRpb25DYWNoZUhvc3QoV2ViQXBwbGljYXRpb25DYWNoZUhvc3RDbGllbnQqKSB7IHJl dHVybiAwOyB9CisgICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25z dCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVk IGxvbmcgZXN0aW1hdGVkU2l6ZSkgeyByZXR1cm4gdHJ1ZTsgfQogCiBwcml2YXRlOgogICAgIHZp cnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsK 55365 2010-05-07 05:16:51 -0700 2010-05-07 05:23:16 -0700 Patch bug-38742-20100507141649.patch text/plain 11665 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IDY4MTI5YjAyZDM0MWE1ZjQ2YTBiMWJmMzZmZGYzMDNmMGU4ZTYyYjcu LjI0NzE5NjM4YTBiNjk1OGY0YjIyMWQ4MDIwNzc5ZTgxMjUzZGNkMGMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI3IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAg ICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKiBzcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpj YW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKToKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZVRhc2spOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRvbmUpOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZTo6cmVzdWx0KToKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2U6OnNpZ25hbENvbXBsZXRlZCk6CisgICAgICAgIChXZWJLaXQ6 OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpkaWRDb21wbGV0 ZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuaDoKKyAgICAgICAgKFdlYktpdDo6V2Vi V29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmNyZWF0ZSk6CisgICAg ICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29y a2VyQ2xpZW50SW1wbDo6YWxsb3dEYXRhYmFzZSk6CisKIDIwMTAtMDUtMDYgIEtlbnQgVGFtdXJh ICA8dGtlbnRAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERpbWl0cmkgR2xh emtvdi4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5o CmluZGV4IDEzNjAzY2JjOTMxNTA4NTQzMDM5M2E4NGM3ZjY5NWUxZTMwNWQyNTYuLmNlYTY0NzEy M2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZmMmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAtMzUsNiArMzUsNyBAQCBuYW1lc3Bh Y2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CiBjbGFzcyBXZWJB cHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudDsKK2NsYXNzIFdlYkZyYW1lOwogY2xhc3MgV2ViTm90 aWZpY2F0aW9uUHJlc2VudGVyOwogY2xhc3MgV2ViU3RyaW5nOwogY2xhc3MgV2ViV29ya2VyOwpA QCAtNzksNiArODAsOSBAQCBwdWJsaWM6CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtp dCB0aHJlYWQgaW4gdGhlIHdvcmtlciBwcm9jZXNzIGR1cmluZyBpbml0aWFsaXphdGlvbi4KICAg ICB2aXJ0dWFsIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hl SG9zdChXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudCopID0gMDsKIAorICAgIC8vIENhbGxl ZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNl LgorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3Ry aW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVz dGltYXRlZFNpemUpID0gMDsKKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGll bnQoKSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2Jz ZXJ2ZXIuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9EYXRhYmFzZU9ic2VydmVyLmNwcAppbmRl eCA2YTJlMmE3MGFjMDg0NDFhZGJiOGUyMmUwZTQ5MzU1NDc1NTA3YzZjLi4xYzUxMTdjMGY1N2Jk ZmYxY2E1MWRjYzg3NzRhZjZiM2NkMjc5MTJiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0YWJh c2VPYnNlcnZlci5jcHAKQEAgLTUwLDEyICs1MCwxNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBi b29sIERhdGFiYXNlT2JzZXJ2ZXI6OmNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29u c3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogewog ICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7Ci0g ICAgLy8gRklYTUU6IGFkZCBzdXBwb3J0IGZvciB0aGUgY2FzZSBzY3JpcHRFeGVjdXRpb25Db250 ZXh0KCktPmlzV29ya2VyKCkgb25jZSB3b3JrZXJzIGltcGxlbWVudCB3ZWIgZGF0YWJhc2VzLgot ICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFT U0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkgfHwgc2NyaXB0RXhlY3V0 aW9uQ29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkpOwogICAgIGlmIChzY3JpcHRFeGVjdXRpb25D b250ZXh0LT5pc0RvY3VtZW50KCkpIHsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3Rh dGljX2Nhc3Q8RG9jdW1lbnQqPihzY3JpcHRFeGVjdXRpb25Db250ZXh0KTsKICAgICAgICAgV2Vi RnJhbWVJbXBsKiB3ZWJGcmFtZSA9IFdlYkZyYW1lSW1wbDo6ZnJvbUZyYW1lKGRvY3VtZW50LT5m cmFtZSgpKTsKICAgICAgICAgcmV0dXJuIHdlYkZyYW1lLT5jbGllbnQoKS0+YWxsb3dEYXRhYmFz ZSh3ZWJGcmFtZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpOworICAgIH0gZWxz ZSB7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxX b3JrZXJDb250ZXh0Kj4oc2NyaXB0RXhlY3V0aW9uQ29udGV4dCk7CisgICAgICAgIFdvcmtlckxv YWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+ d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0g c3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAgICAgICAg cmV0dXJuIHdlYldvcmtlci0+YWxsb3dEYXRhYmFzZSgwLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0 aW1hdGVkU2l6ZSk7CiAgICAgfQogCiAgICAgcmV0dXJuIHRydWU7CmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmNwcAppbmRleCA4ZTI2NTYwNTZjZWUwYjA5YjQwMWFlNTliOWRiYWY1OTc2 N2ZlNjNmLi5iZDA0YjQyMTI1NmRiNTE5YjFhMWZhZGNlYTZjNjk1MjcxOWY3MjhjIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRl ICJjb25maWcuaCIKICNpbmNsdWRlICJXZWJXb3JrZXJCYXNlLmgiCiAKKyNpbmNsdWRlICJEYXRh YmFzZVRhc2suaCIKICNpbmNsdWRlICJHZW5lcmljV29ya2VyVGFzay5oIgogI2luY2x1ZGUgIk1l c3NhZ2VQb3J0Q2hhbm5lbC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVs LmgiCkBAIC00Miw2ICs0Myw3IEBACiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldl YldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgog I2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAK QEAgLTUxLDYgKzUzLDggQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAKICNpZiBFTkFCTEUoV09SS0VS UykKIAorc3RhdGljIGNvbnN0IGNoYXIgYWxsb3dEYXRhYmFzZU1vZGVbXSA9ICJhbGxvd0RhdGFi YXNlTW9kZSI7CisKIC8vIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVh ZCB0byBmb3JjZSB0byBpbml0aWFsaXplIHNvbWUgc3RhdGljCiAvLyB2YWx1ZXMgdXNlZCBpbiBX ZWJLaXQgYmVmb3JlIGFueSB3b3JrZXIgdGhyZWFkIGlzIHN0YXJ0ZWQuIFRoaXMgaXMgYmVjYXVz ZSBpbgogLy8gb3VyIHdvcmtlciBwcm9jZXNzcywgd2UgZG8gbm90IHJ1biBhbnkgV2ViS2l0IGNv ZGUgaW4gbWFpbiB0aHJlYWQgYW5kIHRodXMKQEAgLTE0NCw2ICsxNDgsODUgQEAgV2ViQXBwbGlj YXRpb25DYWNoZUhvc3QqIFdlYldvcmtlckJhc2U6OmNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0 KFdlYkZyYW1lKiwgV2UKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBXZWJXb3JrZXJCYXNlOjph bGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCit7CisgICAg V29ya2VyUnVuTG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhyZWFkLT5ydW5Mb29wKCk7CisgICAg V29ya2VyU2NyaXB0Q29udHJvbGxlciogY29udHJvbGxlciA9IFdvcmtlclNjcmlwdENvbnRyb2xs ZXI6OmNvbnRyb2xsZXJGb3JDb250ZXh0KCk7CisgICAgaWYgKCFjb250cm9sbGVyKSB7CisgICAg ICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQor ICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBjb250cm9sbGVyLT53b3JrZXJDb250 ZXh0KCk7CisKKyAgICAvLyBDcmVhdGUgYSB1bmlxdWUgbW9kZSBqdXN0IGZvciB0aGlzIHN5bmNo cm9ub3VzIGNhbGwuCisgICAgU3RyaW5nIG1vZGUgPSBhbGxvd0RhdGFiYXNlTW9kZTsKKyAgICBt b2RlLmFwcGVuZChTdHJpbmc6Om51bWJlcihydW5Mb29wLmNyZWF0ZVVuaXF1ZUlkKCkpKTsKKwor ICAgIFJlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlID0gQWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmNyZWF0ZSh0aGlzLCBtb2RlLCBTdHJpbmcobmFtZSks IFN0cmluZyhkaXNwbGF5TmFtZSksIGVzdGltYXRlZFNpemUpOworICAgIE1lc3NhZ2VRdWV1ZVdh aXRSZXN1bHQgcmVzdWx0ID0gTWVzc2FnZVF1ZXVlTWVzc2FnZVJlY2VpdmVkOworICAgIHdoaWxl ICghYnJpZGdlLT5kb25lKCkgJiYgcmVzdWx0ICE9IE1lc3NhZ2VRdWV1ZVRlcm1pbmF0ZWQpCisg ICAgICAgIHJlc3VsdCA9IHJ1bkxvb3AucnVuSW5Nb2RlKHdvcmtlckNvbnRleHQsIG1vZGUpOwor CisgICAgaWYgKHJlc3VsdCA9PSBNZXNzYWdlUXVldWVUZXJtaW5hdGVkKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICByZXR1cm4gYnJpZGdlLT5yZXN1bHQoKTsKK30KKwordm9pZCBXZWJX b3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJXb3JrZXJCYXNl KiB0aGlzUHRyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcg bmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU3RyaW5nIGRpc3Bs YXlOYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSkKK3sKKyAg ICBpZiAoIXRoaXNQdHItPmNvbW1vbkNsaWVudCgpKQorICAgICAgICBicmlkZ2UtPnNpZ25hbENv bXBsZXRlZChmYWxzZSk7CisgICAgZWxzZQorICAgICAgICBicmlkZ2UtPnNpZ25hbENvbXBsZXRl ZCh0aGlzUHRyLT5jb21tb25DbGllbnQoKS0+YWxsb3dEYXRhYmFzZSh0aGlzUHRyLT5tX3dlYlZp ZXctPm1haW5GcmFtZSgpLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSkpOworfQor CitXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2UoV2ViV29ya2VyQmFzZSogd29ya2VyLCBjb25zdCBTdHJpbmcm IG1vZGUsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5z aWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQorICAgIDogbV9jb21wbGV0ZWQoZmFsc2UpCisgICAg LCBtX3dvcmtlcih3b3JrZXIpCisgICAgLCBtX21vZGUobW9kZSkKK3sKKyAgICB3b3JrZXItPmRp c3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJldlYldvcmtlckJhc2U6 OmFsbG93RGF0YWJhc2VUYXNrLCB3b3JrZXIsIFN0cmluZyhuYW1lKSwgU3RyaW5nKGRpc3BsYXlO YW1lKSwgZXN0aW1hdGVkU2l6ZSwgdGhpcykpOworCit9CisKK3ZvaWQgV2ViV29ya2VyQmFzZTo6 QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmNhbmNlbCgpCit7CisgICAgTXV0ZXhMb2Nr ZXIgbG9jayhtX3N5bmNocm9ub3VzTXV0ZXgpOworICAgIG1fd29ya2VyID0gMDsKK30KKworYm9v bCBXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6ZG9uZSgpCit7 CisgICAgTXV0ZXhMb2NrZXIgbG9jayhtX3N5bmNocm9ub3VzTXV0ZXgpOworICAgIHJldHVybiBt X2NvbXBsZXRlZDsKK30KKworYm9vbCBXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRo cmVhZEJyaWRnZTo6cmVzdWx0KCkKK3sKKyAgICBNdXRleExvY2tlciBsb2NrKG1fc3luY2hyb25v dXNNdXRleCk7CisgICAgcmV0dXJuIG1fcmVzdWx0OworfQorCit2b2lkIFdlYldvcmtlckJhc2U6 OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpzaWduYWxDb21wbGV0ZWQoYm9vbCByZXN1 bHQpCit7CisgICAgTXV0ZXhMb2NrZXIgbG9jayhtX3N5bmNocm9ub3VzTXV0ZXgpOworICAgIG1f cmVzdWx0ID0gcmVzdWx0OworICAgIG1fY29tcGxldGVkID0gdHJ1ZTsKKyAgICBpZiAobV93b3Jr ZXIpCisgICAgICAgIG1fd29ya2VyLT5wb3N0VGFza0Zvck1vZGVUb1dvcmtlckNvbnRleHQoY3Jl YXRlQ2FsbGJhY2tUYXNrKCZkaWRDb21wbGV0ZSwgdGhpcyksIG1fbW9kZSk7Cit9CisKK3ZvaWQg V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRpZENvbXBsZXRl KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJXb3JrZXJCYXNlOjpB bGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZSogdGhpc1B0cikKK3sKK30KKwogLy8gV29ya2Vy T2JqZWN0UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2FnZVRvV29ya2Vy T2JqZWN0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdlLApkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYldvcmtlckJhc2UuaAppbmRleCBhNDcwZWU0NjdkMmY4NjI5ODc5ZDk1YWY0Yzc1 OTMyNDk1OTdiZDU0Li4xZTJhZWY4YjU3M2RlZDJjYjI0OTQxMTFiY2EzMGQ4ZjBjY2M4MDc1IDEw MDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtODgsNiArODgsOSBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCB2b2lkIGRpZENyZWF0ZURhdGFTb3VyY2UoV2ViRnJhbWUqLCBXZWJEYXRh U291cmNlKik7CiAgICAgdmlydHVhbCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogY3JlYXRlQXBw bGljYXRpb25DYWNoZUhvc3QoV2ViRnJhbWUqLCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVu dCopOwogCisgICAgLy8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNlcyBp cyBhbGxvd2VkIGZvciB0aGlzIHdvcmtlci4KKyAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFz ZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNw bGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKKwogICAgIC8vIEV4ZWN1dGVz IHRoZSBnaXZlbiB0YXNrIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNw YXRjaFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPik7CiAKQEAgLTE0NCw2ICsxNDcsNDIgQEAgcHJpdmF0ZToKICAgICAgICAg V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwKICAgICAgICAgV2ViV29y a2VyQmFzZSogdGhpc1B0cik7CiAKKyAgICBjbGFzcyBBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZTsKKworICAgIHN0YXRpYyB2b2lkIGFsbG93RGF0YWJhc2VUYXNrKAorICAgICAgICBXZWJD b3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LAorICAgICAgICBXZWJXb3JrZXJC YXNlKiB0aGlzUHRyLAorICAgICAgICBjb25zdCBXZWJDb3JlOjpTdHJpbmcgbmFtZSwKKyAgICAg ICAgY29uc3QgV2ViQ29yZTo6U3RyaW5nIGRpc3BsYXlOYW1lLAorICAgICAgICB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUsCisgICAgICAgIFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFzZU1haW5U aHJlYWRCcmlkZ2U+IGJyaWRnZSk7CisKKyAgICAvLyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcm91 dGUgdGhlIHJlc3VsdCBvZiB0aGUgYWxsb3dEYXRhYmFzZSBjYWxsIGJhY2sKKyAgICAvLyB0byB0 aGUgd29ya2VyIGNvbnRleHQuCisgICAgY2xhc3MgQWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlk Z2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRn ZT4geworICAgIHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFz ZU1haW5UaHJlYWRCcmlkZ2U+IGNyZWF0ZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0IFdl YkNvcmU6OlN0cmluZyYgbW9kZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBuYW1lLCBjb25zdCBX ZWJDb3JlOjpTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUp IHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZSh3b3Jr ZXIsIG1vZGUsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKSk7IH0KKworICAgICAg ICAvLyBUaGVzZSBtZXRob2RzIGFyZSBpbnZva2VkIG9uIHRoZSB3b3JrZXIgY29udGV4dC4KKyAg ICAgICAgdm9pZCBjYW5jZWwoKTsKKyAgICAgICAgYm9vbCBkb25lKCk7CisgICAgICAgIGJvb2wg cmVzdWx0KCk7CisKKyAgICAgICAgLy8gVGhpcyBtZXRob2QgaXMgaW52b2tlZCBvbiB0aGUgbWFp biB0aHJlYWQuCisgICAgICAgIHZvaWQgc2lnbmFsQ29tcGxldGVkKGJvb2wgcmVzdWx0KTsKKwor ICAgIHByaXZhdGU6CisgICAgICAgIEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlKFdlYldv cmtlckJhc2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBtb2RlLCBjb25zdCBXZWJD b3JlOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisKKyAgICAgICAgc3RhdGljIHZvaWQgZGlkQ29t cGxldGUoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2UqIHRoaXNQdHIpOworCisgICAgICAgIGJvb2wgbV9yZXN1bHQ7 CisgICAgICAgIGJvb2wgbV9jb21wbGV0ZWQ7CisgICAgICAgIE11dGV4IG1fc3luY2hyb25vdXNN dXRleDsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgICAgIFdlYkNvcmU6 OlN0cmluZyBtX21vZGU7CisgICAgfTsKKwogICAgIC8vICdzaGFkb3cgcGFnZScgLSBjcmVhdGVk IHRvIHByb3h5IGxvYWRpbmcgcmVxdWVzdHMgZnJvbSB0aGUgd29ya2VyLgogICAgIFJlZlB0cjxX ZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0PiBtX2xvYWRpbmdEb2N1bWVudDsKICAgICBX ZWJWaWV3KiBtX3dlYlZpZXc7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckNsaWVudEltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1w bC5oCmluZGV4IDkwNzQ5OWEyNjZhNjc2MmNmYmYyOWFjZDkzZDEwNTc0YTYwZjllZWIuLmFmYTli OWIzMzc2OTUyNzBlNzI3MzdkZDcxY2UzOTk1ZmY1OWU3MTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCkBAIC05NSw2ICs5NSw3IEBAIHB1YmxpYzoKICAgICAg ICAgcmV0dXJuIDA7CiAgICAgfQogICAgIHZpcnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Qq IGNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50 KikgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1l KiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1 bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpIHsgcmV0dXJuIHRydWU7IH0KIAogcHJpdmF0ZToK ICAgICB2aXJ0dWFsIH5XZWJXb3JrZXJDbGllbnRJbXBsKCk7Cg== 55367 2010-05-07 05:23:23 -0700 2010-05-10 00:29:30 -0700 Patch bug-38742-20100507142321.patch text/plain 13158 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IDY4MTI5YjAyZDM0MWE1ZjQ2YTBiMWJmMzZmZGYzMDNmMGU4ZTYyYjcu LjI0NzE5NjM4YTBiNjk1OGY0YjIyMWQ4MDIwNzc5ZTgxMjUzZGNkMGMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI3IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAg ICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKiBzcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpj YW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKToKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZVRhc2spOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRvbmUpOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZTo6cmVzdWx0KToKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2U6OnNpZ25hbENvbXBsZXRlZCk6CisgICAgICAgIChXZWJLaXQ6 OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpkaWRDb21wbGV0 ZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuaDoKKyAgICAgICAgKFdlYktpdDo6V2Vi V29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmNyZWF0ZSk6CisgICAg ICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwuaDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29y a2VyQ2xpZW50SW1wbDo6YWxsb3dEYXRhYmFzZSk6CisKIDIwMTAtMDUtMDYgIEtlbnQgVGFtdXJh ICA8dGtlbnRAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERpbWl0cmkgR2xh emtvdi4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2Vy Q2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5o CmluZGV4IDEzNjAzY2JjOTMxNTA4NTQzMDM5M2E4NGM3ZjY5NWUxZTMwNWQyNTYuLmNlYTY0NzEy M2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZmMmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAtMzUsNiArMzUsNyBAQCBuYW1lc3Bh Y2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CiBjbGFzcyBXZWJB cHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudDsKK2NsYXNzIFdlYkZyYW1lOwogY2xhc3MgV2ViTm90 aWZpY2F0aW9uUHJlc2VudGVyOwogY2xhc3MgV2ViU3RyaW5nOwogY2xhc3MgV2ViV29ya2VyOwpA QCAtNzksNiArODAsOSBAQCBwdWJsaWM6CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtp dCB0aHJlYWQgaW4gdGhlIHdvcmtlciBwcm9jZXNzIGR1cmluZyBpbml0aWFsaXphdGlvbi4KICAg ICB2aXJ0dWFsIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hl SG9zdChXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudCopID0gMDsKIAorICAgIC8vIENhbGxl ZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNl LgorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3Ry aW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVz dGltYXRlZFNpemUpID0gMDsKKwogcHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGll bnQoKSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2Jz ZXJ2ZXIuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9EYXRhYmFzZU9ic2VydmVyLmNwcAppbmRl eCA2YTJlMmE3MGFjMDg0NDFhZGJiOGUyMmUwZTQ5MzU1NDc1NTA3YzZjLi4xYzUxMTdjMGY1N2Jk ZmYxY2E1MWRjYzg3NzRhZjZiM2NkMjc5MTJiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0YWJh c2VPYnNlcnZlci5jcHAKQEAgLTUwLDEyICs1MCwxNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBi b29sIERhdGFiYXNlT2JzZXJ2ZXI6OmNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlv bkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29u c3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogewog ICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7Ci0g ICAgLy8gRklYTUU6IGFkZCBzdXBwb3J0IGZvciB0aGUgY2FzZSBzY3JpcHRFeGVjdXRpb25Db250 ZXh0KCktPmlzV29ya2VyKCkgb25jZSB3b3JrZXJzIGltcGxlbWVudCB3ZWIgZGF0YWJhc2VzLgot ICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFT U0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkgfHwgc2NyaXB0RXhlY3V0 aW9uQ29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkpOwogICAgIGlmIChzY3JpcHRFeGVjdXRpb25D b250ZXh0LT5pc0RvY3VtZW50KCkpIHsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3Rh dGljX2Nhc3Q8RG9jdW1lbnQqPihzY3JpcHRFeGVjdXRpb25Db250ZXh0KTsKICAgICAgICAgV2Vi RnJhbWVJbXBsKiB3ZWJGcmFtZSA9IFdlYkZyYW1lSW1wbDo6ZnJvbUZyYW1lKGRvY3VtZW50LT5m cmFtZSgpKTsKICAgICAgICAgcmV0dXJuIHdlYkZyYW1lLT5jbGllbnQoKS0+YWxsb3dEYXRhYmFz ZSh3ZWJGcmFtZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpOworICAgIH0gZWxz ZSB7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxX b3JrZXJDb250ZXh0Kj4oc2NyaXB0RXhlY3V0aW9uQ29udGV4dCk7CisgICAgICAgIFdvcmtlckxv YWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+ d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0g c3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAgICAgICAg cmV0dXJuIHdlYldvcmtlci0+YWxsb3dEYXRhYmFzZSgwLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0 aW1hdGVkU2l6ZSk7CiAgICAgfQogCiAgICAgcmV0dXJuIHRydWU7CmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmNwcAppbmRleCA4ZTI2NTYwNTZjZWUwYjA5YjQwMWFlNTliOWRiYWY1OTc2 N2ZlNjNmLi5iZDA0YjQyMTI1NmRiNTE5YjFhMWZhZGNlYTZjNjk1MjcxOWY3MjhjIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRl ICJjb25maWcuaCIKICNpbmNsdWRlICJXZWJXb3JrZXJCYXNlLmgiCiAKKyNpbmNsdWRlICJEYXRh YmFzZVRhc2suaCIKICNpbmNsdWRlICJHZW5lcmljV29ya2VyVGFzay5oIgogI2luY2x1ZGUgIk1l c3NhZ2VQb3J0Q2hhbm5lbC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVs LmgiCkBAIC00Miw2ICs0Myw3IEBACiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldl YldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgog I2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAK QEAgLTUxLDYgKzUzLDggQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAKICNpZiBFTkFCTEUoV09SS0VS UykKIAorc3RhdGljIGNvbnN0IGNoYXIgYWxsb3dEYXRhYmFzZU1vZGVbXSA9ICJhbGxvd0RhdGFi YXNlTW9kZSI7CisKIC8vIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVh ZCB0byBmb3JjZSB0byBpbml0aWFsaXplIHNvbWUgc3RhdGljCiAvLyB2YWx1ZXMgdXNlZCBpbiBX ZWJLaXQgYmVmb3JlIGFueSB3b3JrZXIgdGhyZWFkIGlzIHN0YXJ0ZWQuIFRoaXMgaXMgYmVjYXVz ZSBpbgogLy8gb3VyIHdvcmtlciBwcm9jZXNzcywgd2UgZG8gbm90IHJ1biBhbnkgV2ViS2l0IGNv ZGUgaW4gbWFpbiB0aHJlYWQgYW5kIHRodXMKQEAgLTE0NCw2ICsxNDgsODUgQEAgV2ViQXBwbGlj YXRpb25DYWNoZUhvc3QqIFdlYldvcmtlckJhc2U6OmNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0 KFdlYkZyYW1lKiwgV2UKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBXZWJXb3JrZXJCYXNlOjph bGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCit7CisgICAg V29ya2VyUnVuTG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhyZWFkLT5ydW5Mb29wKCk7CisgICAg V29ya2VyU2NyaXB0Q29udHJvbGxlciogY29udHJvbGxlciA9IFdvcmtlclNjcmlwdENvbnRyb2xs ZXI6OmNvbnRyb2xsZXJGb3JDb250ZXh0KCk7CisgICAgaWYgKCFjb250cm9sbGVyKSB7CisgICAg ICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQor ICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNvbnRleHQgPSBjb250cm9sbGVyLT53b3JrZXJDb250 ZXh0KCk7CisKKyAgICAvLyBDcmVhdGUgYSB1bmlxdWUgbW9kZSBqdXN0IGZvciB0aGlzIHN5bmNo cm9ub3VzIGNhbGwuCisgICAgU3RyaW5nIG1vZGUgPSBhbGxvd0RhdGFiYXNlTW9kZTsKKyAgICBt b2RlLmFwcGVuZChTdHJpbmc6Om51bWJlcihydW5Mb29wLmNyZWF0ZVVuaXF1ZUlkKCkpKTsKKwor ICAgIFJlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlID0gQWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmNyZWF0ZSh0aGlzLCBtb2RlLCBTdHJpbmcobmFtZSks IFN0cmluZyhkaXNwbGF5TmFtZSksIGVzdGltYXRlZFNpemUpOworICAgIE1lc3NhZ2VRdWV1ZVdh aXRSZXN1bHQgcmVzdWx0ID0gTWVzc2FnZVF1ZXVlTWVzc2FnZVJlY2VpdmVkOworICAgIHdoaWxl ICghYnJpZGdlLT5kb25lKCkgJiYgcmVzdWx0ICE9IE1lc3NhZ2VRdWV1ZVRlcm1pbmF0ZWQpCisg ICAgICAgIHJlc3VsdCA9IHJ1bkxvb3AucnVuSW5Nb2RlKHdvcmtlckNvbnRleHQsIG1vZGUpOwor CisgICAgaWYgKHJlc3VsdCA9PSBNZXNzYWdlUXVldWVUZXJtaW5hdGVkKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICByZXR1cm4gYnJpZGdlLT5yZXN1bHQoKTsKK30KKwordm9pZCBXZWJX b3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlVGFzayhTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJXb3JrZXJCYXNl KiB0aGlzUHRyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcg bmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU3RyaW5nIGRpc3Bs YXlOYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSkKK3sKKyAg ICBpZiAoIXRoaXNQdHItPmNvbW1vbkNsaWVudCgpKQorICAgICAgICBicmlkZ2UtPnNpZ25hbENv bXBsZXRlZChmYWxzZSk7CisgICAgZWxzZQorICAgICAgICBicmlkZ2UtPnNpZ25hbENvbXBsZXRl ZCh0aGlzUHRyLT5jb21tb25DbGllbnQoKS0+YWxsb3dEYXRhYmFzZSh0aGlzUHRyLT5tX3dlYlZp ZXctPm1haW5GcmFtZSgpLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSkpOworfQor CitXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2UoV2ViV29ya2VyQmFzZSogd29ya2VyLCBjb25zdCBTdHJpbmcm IG1vZGUsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5z aWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQorICAgIDogbV9jb21wbGV0ZWQoZmFsc2UpCisgICAg LCBtX3dvcmtlcih3b3JrZXIpCisgICAgLCBtX21vZGUobW9kZSkKK3sKKyAgICB3b3JrZXItPmRp c3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJldlYldvcmtlckJhc2U6 OmFsbG93RGF0YWJhc2VUYXNrLCB3b3JrZXIsIFN0cmluZyhuYW1lKSwgU3RyaW5nKGRpc3BsYXlO YW1lKSwgZXN0aW1hdGVkU2l6ZSwgdGhpcykpOworCit9CisKK3ZvaWQgV2ViV29ya2VyQmFzZTo6 QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmNhbmNlbCgpCit7CisgICAgTXV0ZXhMb2Nr ZXIgbG9jayhtX3N5bmNocm9ub3VzTXV0ZXgpOworICAgIG1fd29ya2VyID0gMDsKK30KKworYm9v bCBXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6ZG9uZSgpCit7 CisgICAgTXV0ZXhMb2NrZXIgbG9jayhtX3N5bmNocm9ub3VzTXV0ZXgpOworICAgIHJldHVybiBt X2NvbXBsZXRlZDsKK30KKworYm9vbCBXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRo cmVhZEJyaWRnZTo6cmVzdWx0KCkKK3sKKyAgICBNdXRleExvY2tlciBsb2NrKG1fc3luY2hyb25v dXNNdXRleCk7CisgICAgcmV0dXJuIG1fcmVzdWx0OworfQorCit2b2lkIFdlYldvcmtlckJhc2U6 OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpzaWduYWxDb21wbGV0ZWQoYm9vbCByZXN1 bHQpCit7CisgICAgTXV0ZXhMb2NrZXIgbG9jayhtX3N5bmNocm9ub3VzTXV0ZXgpOworICAgIG1f cmVzdWx0ID0gcmVzdWx0OworICAgIG1fY29tcGxldGVkID0gdHJ1ZTsKKyAgICBpZiAobV93b3Jr ZXIpCisgICAgICAgIG1fd29ya2VyLT5wb3N0VGFza0Zvck1vZGVUb1dvcmtlckNvbnRleHQoY3Jl YXRlQ2FsbGJhY2tUYXNrKCZkaWRDb21wbGV0ZSwgdGhpcyksIG1fbW9kZSk7Cit9CisKK3ZvaWQg V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRpZENvbXBsZXRl KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJXb3JrZXJCYXNlOjpB bGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZSogdGhpc1B0cikKK3sKK30KKwogLy8gV29ya2Vy T2JqZWN0UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KIAogdm9pZCBXZWJXb3JrZXJCYXNlOjpwb3N0TWVzc2FnZVRvV29ya2Vy T2JqZWN0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiBtZXNzYWdlLApkaWZmIC0t Z2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmggYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYldvcmtlckJhc2UuaAppbmRleCBhNDcwZWU0NjdkMmY4NjI5ODc5ZDk1YWY0Yzc1 OTMyNDk1OTdiZDU0Li4xZTJhZWY4YjU3M2RlZDJjYjI0OTQxMTFiY2EzMGQ4ZjBjY2M4MDc1IDEw MDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAorKysgYi9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaApAQCAtODgsNiArODgsOSBAQCBwdWJsaWM6 CiAgICAgdmlydHVhbCB2b2lkIGRpZENyZWF0ZURhdGFTb3VyY2UoV2ViRnJhbWUqLCBXZWJEYXRh U291cmNlKik7CiAgICAgdmlydHVhbCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogY3JlYXRlQXBw bGljYXRpb25DYWNoZUhvc3QoV2ViRnJhbWUqLCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVu dCopOwogCisgICAgLy8gQ29udHJvbHMgd2hldGhlciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNlcyBp cyBhbGxvd2VkIGZvciB0aGlzIHdvcmtlci4KKyAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFz ZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNw bGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKTsKKwogICAgIC8vIEV4ZWN1dGVz IHRoZSBnaXZlbiB0YXNrIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNw YXRjaFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25D b250ZXh0OjpUYXNrPik7CiAKQEAgLTE0NCw2ICsxNDcsNDIgQEAgcHJpdmF0ZToKICAgICAgICAg V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwKICAgICAgICAgV2ViV29y a2VyQmFzZSogdGhpc1B0cik7CiAKKyAgICBjbGFzcyBBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZTsKKworICAgIHN0YXRpYyB2b2lkIGFsbG93RGF0YWJhc2VUYXNrKAorICAgICAgICBXZWJD b3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LAorICAgICAgICBXZWJXb3JrZXJC YXNlKiB0aGlzUHRyLAorICAgICAgICBjb25zdCBXZWJDb3JlOjpTdHJpbmcgbmFtZSwKKyAgICAg ICAgY29uc3QgV2ViQ29yZTo6U3RyaW5nIGRpc3BsYXlOYW1lLAorICAgICAgICB1bnNpZ25lZCBs b25nIGVzdGltYXRlZFNpemUsCisgICAgICAgIFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFzZU1haW5U aHJlYWRCcmlkZ2U+IGJyaWRnZSk7CisKKyAgICAvLyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcm91 dGUgdGhlIHJlc3VsdCBvZiB0aGUgYWxsb3dEYXRhYmFzZSBjYWxsIGJhY2sKKyAgICAvLyB0byB0 aGUgd29ya2VyIGNvbnRleHQuCisgICAgY2xhc3MgQWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlk Z2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRn ZT4geworICAgIHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFz ZU1haW5UaHJlYWRCcmlkZ2U+IGNyZWF0ZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0IFdl YkNvcmU6OlN0cmluZyYgbW9kZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBuYW1lLCBjb25zdCBX ZWJDb3JlOjpTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUp IHsgcmV0dXJuIGFkb3B0UmVmKG5ldyBBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZSh3b3Jr ZXIsIG1vZGUsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKSk7IH0KKworICAgICAg ICAvLyBUaGVzZSBtZXRob2RzIGFyZSBpbnZva2VkIG9uIHRoZSB3b3JrZXIgY29udGV4dC4KKyAg ICAgICAgdm9pZCBjYW5jZWwoKTsKKyAgICAgICAgYm9vbCBkb25lKCk7CisgICAgICAgIGJvb2wg cmVzdWx0KCk7CisKKyAgICAgICAgLy8gVGhpcyBtZXRob2QgaXMgaW52b2tlZCBvbiB0aGUgbWFp biB0aHJlYWQuCisgICAgICAgIHZvaWQgc2lnbmFsQ29tcGxldGVkKGJvb2wgcmVzdWx0KTsKKwor ICAgIHByaXZhdGU6CisgICAgICAgIEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlKFdlYldv cmtlckJhc2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBtb2RlLCBjb25zdCBXZWJD b3JlOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZGlzcGxheU5hbWUsIHVu c2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisKKyAgICAgICAgc3RhdGljIHZvaWQgZGlkQ29t cGxldGUoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgQWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2UqIHRoaXNQdHIpOworCisgICAgICAgIGJvb2wgbV9yZXN1bHQ7 CisgICAgICAgIGJvb2wgbV9jb21wbGV0ZWQ7CisgICAgICAgIE11dGV4IG1fc3luY2hyb25vdXNN dXRleDsKKyAgICAgICAgV2ViV29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgICAgIFdlYkNvcmU6 OlN0cmluZyBtX21vZGU7CisgICAgfTsKKwogICAgIC8vICdzaGFkb3cgcGFnZScgLSBjcmVhdGVk IHRvIHByb3h5IGxvYWRpbmcgcmVxdWVzdHMgZnJvbSB0aGUgd29ya2VyLgogICAgIFJlZlB0cjxX ZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0PiBtX2xvYWRpbmdEb2N1bWVudDsKICAgICBX ZWJWaWV3KiBtX3dlYlZpZXc7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckNsaWVudEltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1w bC5oCmluZGV4IDkwNzQ5OWEyNjZhNjc2MmNmYmYyOWFjZDkzZDEwNTc0YTYwZjllZWIuLmFmYTli OWIzMzc2OTUyNzBlNzI3MzdkZDcxY2UzOTk1ZmY1OWU3MTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCkBAIC05NSw2ICs5NSw3IEBAIHB1YmxpYzoKICAgICAg ICAgcmV0dXJuIDA7CiAgICAgfQogICAgIHZpcnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3Qq IGNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50 KikgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1l KiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1 bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpIHsgcmV0dXJuIHRydWU7IH0KIAogcHJpdmF0ZToK ICAgICB2aXJ0dWFsIH5XZWJXb3JrZXJDbGllbnRJbXBsKCk7CmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9DaGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5kZXggOTA5NDc2ZDBmNDk0 ZWJjMzJkOTI5Njc4ZTgxYjkwMzc3ODc0MmE5OS4uZjViYjYxZmJjNWIwYmZkZDFlNzgyMmNlYzVi NGMwMWM4YTNmZTQwMyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dl YktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEwLTA1LTA3ICBKb2NoZW4g RWlzaW5nZXIgIDxqb2NoZW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhbGxvd0RhdGFiYXNlIG1ldGhvZCB0byBUZXN0 V2ViV29ya2VyLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9Mzg3NDIKKworICAgICAgICBOZWVkIGEgc2hvcnQgZGVzY3JpcHRpb24gYW5kIGJ1ZyBVUkwg KE9PUFMhKQorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtl ci5oOgorICAgICAgICAoVGVzdFdlYldvcmtlcjo6YWxsb3dEYXRhYmFzZSk6CisKIDIwMTAtMDUt MDYgIE1hcmsgUm93ZSAgPG1yb3dlQGFwcGxlLmNvbT4KIAogICAgICAgICBSdWJiZXItc3RhbXBl ZCBieSBEYW4gQmVybnN0ZWluLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv Y2hyb21pdW0vVGVzdFdlYldvcmtlci5oCmluZGV4IGYyOGNjMjA1NWQyNTc1NDQ3OGYwNjIyZjNi NzE2NzNkZmZiMzAxMDIuLjk0NzA4MDQwZDUwZTQxMjM5MGM1NWFiODk1NjYzOWJlOGFkZDVlMDkg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJX b3JrZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9UZXN0V2Vi V29ya2VyLmgKQEAgLTgwLDYgKzgwLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgV2ViS2l0OjpX ZWJXb3JrZXIqIGNyZWF0ZVdvcmtlcihXZWJLaXQ6OldlYldvcmtlckNsaWVudCopIHsgcmV0dXJu IDA7IH0KICAgICB2aXJ0dWFsIFdlYktpdDo6V2ViTm90aWZpY2F0aW9uUHJlc2VudGVyKiBub3Rp ZmljYXRpb25QcmVzZW50ZXIoKSB7IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBXZWJLaXQ6Oldl YkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJLaXQ6 OldlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50KikgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1 YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYktpdDo6V2ViRnJhbWUqLCBjb25zdCBXZWJLaXQ6Oldl YlN0cmluZyYsIGNvbnN0IFdlYktpdDo6V2ViU3RyaW5nJiwgdW5zaWduZWQgbG9uZykgeyByZXR1 cm4gdHJ1ZTsgfQogCiBwcml2YXRlOgogICAgIH5UZXN0V2ViV29ya2VyKCkge30K 55524 2010-05-10 00:29:37 -0700 2010-05-10 03:57:40 -0700 Patch bug-38742-20100510092935.patch text/plain 11769 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IDEzZTExN2QzZjUyMGFkOTkzNjk1ZTU3OTNiZTZiNjZlYjdmMjJiNmEu LjhkMDg4NjUxNWQzZTM1MDk3NzY0MGU4YmVjMGE3MTMyZDZkZjIzZGIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI2IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAg ICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKiBzcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpj YW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKToKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZVRhc2spOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRvbmUpOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZTo6cmVzdWx0KToKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2U6OnNpZ25hbENvbXBsZXRlZCk6CisgICAgICAgIChXZWJLaXQ6 OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpkaWRDb21wbGV0 ZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuaDoKKyAgICAgICAgKiBzcmMvV2ViV29y a2VyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJDbGllbnRJbXBsOjph bGxvd0RhdGFiYXNlKToKKwogMjAxMC0wNS0wOCAgSmVucyBBbGZrZSAgPHNuZWpAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEZpc2hlci4KZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCmluZGV4IDEzNjAzY2JjOTMxNTA4 NTQzMDM5M2E4NGM3ZjY5NWUxZTMwNWQyNTYuLmNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1 MmM0MTY0NGZmMmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9u V29ya2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3Jr ZXJDbGllbnQuaApAQCAtMzUsNiArMzUsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3Mg V2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENs aWVudDsKK2NsYXNzIFdlYkZyYW1lOwogY2xhc3MgV2ViTm90aWZpY2F0aW9uUHJlc2VudGVyOwog Y2xhc3MgV2ViU3RyaW5nOwogY2xhc3MgV2ViV29ya2VyOwpAQCAtNzksNiArODAsOSBAQCBwdWJs aWM6CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgaW4gdGhlIHdvcmtl ciBwcm9jZXNzIGR1cmluZyBpbml0aWFsaXphdGlvbi4KICAgICB2aXJ0dWFsIFdlYkFwcGxpY2F0 aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJBcHBsaWNhdGlvbkNh Y2hlSG9zdENsaWVudCopID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQg dGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNlLgorICAgIHZpcnR1YWwgYm9vbCBh bGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKKwog cHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRpZmYgLS1n aXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwIGIvV2ViS2l0L2No cm9taXVtL3NyYy9EYXRhYmFzZU9ic2VydmVyLmNwcAppbmRleCA2YTJlMmE3MGFjMDg0NDFhZGJi OGUyMmUwZTQ5MzU1NDc1NTA3YzZjLi4xYzUxMTdjMGY1N2JkZmYxY2E1MWRjYzg3NzRhZjZiM2Nk Mjc5MTJiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIu Y3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5jcHAKQEAgLTUw LDEyICs1MCwxNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBib29sIERhdGFiYXNlT2JzZXJ2ZXI6 OmNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFt ZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogewogICAgIEFTU0VSVChzY3JpcHRFeGVj dXRpb25Db250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7Ci0gICAgLy8gRklYTUU6IGFkZCBzdXBw b3J0IGZvciB0aGUgY2FzZSBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzV29ya2VyKCkgb25j ZSB3b3JrZXJzIGltcGxlbWVudCB3ZWIgZGF0YWJhc2VzLgotICAgIEFTU0VSVChzY3JpcHRFeGVj dXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25D b250ZXh0LT5pc0RvY3VtZW50KCkgfHwgc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+aXNXb3JrZXJD b250ZXh0KCkpOwogICAgIGlmIChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkp IHsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihz Y3JpcHRFeGVjdXRpb25Db250ZXh0KTsKICAgICAgICAgV2ViRnJhbWVJbXBsKiB3ZWJGcmFtZSA9 IFdlYkZyYW1lSW1wbDo6ZnJvbUZyYW1lKGRvY3VtZW50LT5mcmFtZSgpKTsKICAgICAgICAgcmV0 dXJuIHdlYkZyYW1lLT5jbGllbnQoKS0+YWxsb3dEYXRhYmFzZSh3ZWJGcmFtZSwgbmFtZSwgZGlz cGxheU5hbWUsIGVzdGltYXRlZFNpemUpOworICAgIH0gZWxzZSB7CisgICAgICAgIFdvcmtlckNv bnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oc2NyaXB0 RXhlY3V0aW9uQ29udGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2Fk ZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsK KyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2Vy QmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAgICAgICAgcmV0dXJuIHdlYldvcmtlci0+YWxs b3dEYXRhYmFzZSgwLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSk7CiAgICAgfQog CiAgICAgcmV0dXJuIHRydWU7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRl eCAyYzRiNGY2MzIzNDFhMmVlOGI4MmVjYjUxYWMxNzJjOGE1MDExOWI4Li43ODY1MzE0MTExNWM1 NTc3YThkYTYwNzFhMGI1NjcxYmI0ZmM5MThhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2Vy QmFzZS5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRl ICJXZWJXb3JrZXJCYXNlLmgiCiAKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKICNpbmNsdWRl ICJHZW5lcmljV29ya2VyVGFzay5oIgogI2luY2x1ZGUgIk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgog I2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCkBAIC00NCw2ICs0NSw3IEBA CiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgogCisj aW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVh ZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAKQEAgLTUzLDYgKzU1LDcyIEBAIG5h bWVzcGFjZSBXZWJLaXQgewogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKK3N0YXRpYyBjb25zdCBj aGFyIGFsbG93RGF0YWJhc2VNb2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworCituYW1lc3Bh Y2UgeworCisvLyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcm91dGUgdGhlIHJlc3VsdCBvZiB0aGUg V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZQorLy8gY2FsbCBiYWNrIHRvIHRoZSB3b3JrZXIg Y29udGV4dC4KK2NsYXNzIEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlIDogcHVibGljIFRo cmVhZFNhZmVTaGFyZWQ8QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IHsKK3B1YmxpYzoK KyAgICBzdGF0aWMgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gY3Jl YXRlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBtb2RlLCBX ZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25z dCBXZWJDb3JlOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZGlzcGxheU5h bWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IEFs bG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlKHdvcmtlciwgbW9kZSwgY29tbW9uQ2xpZW50LCBm cmFtZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsgfQorCisgICAgLy8gVGhl c2UgbWV0aG9kcyBhcmUgaW52b2tlZCBvbiB0aGUgd29ya2VyIGNvbnRleHQuCisgICAgdm9pZCBj YW5jZWwoKQorICAgIHsKKyAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAg ICAgICBtX3dvcmtlciA9IDA7CisgICAgfQorCisgICAgYm9vbCBkb25lKCkKKyAgICB7CisgICAg ICAgIHJldHVybiBtX2NvbXBsZXRlZDsKKyAgICB9CisKKyAgICBib29sIHJlc3VsdCgpCisgICAg eworICAgICAgICByZXR1cm4gbV9yZXN1bHQ7CisgICAgfQorCisgICAgLy8gVGhpcyBtZXRob2Qg aXMgaW52b2tlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgdm9pZCBzaWduYWxDb21wbGV0ZWQo Ym9vbCByZXN1bHQpCisgICAgeworICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7 CisgICAgICAgIGlmIChtX3dvcmtlcikKKyAgICAgICAgICAgIG1fd29ya2VyLT5wb3N0VGFza0Zv ck1vZGVUb1dvcmtlckNvbnRleHQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRDb21wbGV0ZSwgdGhp cywgcmVzdWx0KSwgbV9tb2RlKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgQWxsb3dEYXRhYmFz ZU1haW5UaHJlYWRCcmlkZ2UoV2ViV29ya2VyQmFzZSogd29ya2VyLCBjb25zdCBXZWJDb3JlOjpT dHJpbmcmIG1vZGUsIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGcmFt ZSogZnJhbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgbmFtZSwgY29uc3QgV2ViQ29yZTo6U3Ry aW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQorICAgICAgICA6 IG1fY29tcGxldGVkKGZhbHNlKQorICAgICAgICAsIG1fd29ya2VyKHdvcmtlcikKKyAgICAgICAg LCBtX21vZGUobW9kZSkKKyAgICB7CisgICAgICAgIHdvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWlu VGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmYWxsb3dEYXRhYmFzZVRhc2ssIGNvbW1vbkNsaWVu dCwgZnJhbWUsIFN0cmluZyhuYW1lKSwgU3RyaW5nKGRpc3BsYXlOYW1lKSwgZXN0aW1hdGVkU2l6 ZSwgdGhpcykpOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIGFsbG93RGF0YWJhc2VUYXNrKFdl YkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFdlYkNvbW1vbldvcmtlckNs aWVudCogY29tbW9uQ2xpZW50LCBXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmlu ZyBuYW1lLCBjb25zdCBXZWJDb3JlOjpTdHJpbmcgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSwgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4g YnJpZGdlKQorICAgIHsKKyAgICAgICAgaWYgKCFjb21tb25DbGllbnQpCisgICAgICAgICAgICBi cmlkZ2UtPnNpZ25hbENvbXBsZXRlZChmYWxzZSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAg IGJyaWRnZS0+c2lnbmFsQ29tcGxldGVkKGNvbW1vbkNsaWVudC0+YWxsb3dEYXRhYmFzZShmcmFt ZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKKyAgICB9CisKKyAgICBzdGF0 aWMgdm9pZCBkaWRDb21wbGV0ZShXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LCBQYXNzUmVmUHRyPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UsIGJv b2wgcmVzdWx0KQorICAgIHsKKyAgICAgICAgYnJpZGdlLT5tX3Jlc3VsdCA9IHJlc3VsdDsKKyAg ICAgICAgYnJpZGdlLT5tX2NvbXBsZXRlZCA9IHRydWU7CisgICAgfQorCisgICAgYm9vbCBtX3Jl c3VsdDsKKyAgICBib29sIG1fY29tcGxldGVkOworICAgIE11dGV4IG1fbXV0ZXg7CisgICAgV2Vi V29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgV2ViQ29yZTo6U3RyaW5nIG1fbW9kZTsKK307Cit9 ICAvLyBuYW1lc3BhY2UKKwogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIG1haW4g dGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKIC8vIHZhbHVlcyB1c2Vk IGluIFdlYktpdCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWQgaXMgc3RhcnRlZC4gVGhpcyBpcyBi ZWNhdXNlIGluCiAvLyBvdXIgd29ya2VyIHByb2Nlc3NzLCB3ZSBkbyBub3QgcnVuIGFueSBXZWJL aXQgY29kZSBpbiBtYWluIHRocmVhZCBhbmQgdGh1cwpAQCAtMTQ3LDYgKzIxNSwzMCBAQCBXZWJB cHBsaWNhdGlvbkNhY2hlSG9zdCogV2ViV29ya2VyQmFzZTo6Y3JlYXRlQXBwbGljYXRpb25DYWNo ZUhvc3QoV2ViRnJhbWUqLCBXZQogICAgIHJldHVybiAwOwogfQogCitib29sIFdlYldvcmtlckJh c2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0 IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKK3sK KyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0gbV93b3JrZXJUaHJlYWQtPnJ1bkxvb3AoKTsK KyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBjb250cm9sbGVyID0gV29ya2VyU2NyaXB0Q29u dHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQoKTsKKyAgICBBU1NFUlQoY29udHJvbGxlcik7 CisgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IGNvbnRyb2xsZXItPndvcmtlckNv bnRleHQoKTsKKworICAgIC8vIENyZWF0ZSBhIHVuaXF1ZSBtb2RlIGp1c3QgZm9yIHRoaXMgc3lu Y2hyb25vdXMgY2FsbC4KKyAgICBTdHJpbmcgbW9kZSA9IGFsbG93RGF0YWJhc2VNb2RlOworICAg IG1vZGUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKHJ1bkxvb3AuY3JlYXRlVW5pcXVlSWQoKSkpOwor CisgICAgUmVmUHRyPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UgPSBBbGxv d0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y3JlYXRlKHRoaXMsIG1vZGUsIGNvbW1vbkNsaWVu dCgpLCBtX3dlYlZpZXctPm1haW5GcmFtZSgpLCBTdHJpbmcobmFtZSksIFN0cmluZyhkaXNwbGF5 TmFtZSksIGVzdGltYXRlZFNpemUpOworICAgIE1lc3NhZ2VRdWV1ZVdhaXRSZXN1bHQgcmVzdWx0 ID0gTWVzc2FnZVF1ZXVlTWVzc2FnZVJlY2VpdmVkOworICAgIHdoaWxlICghYnJpZGdlLT5kb25l KCkgJiYgcmVzdWx0ICE9IE1lc3NhZ2VRdWV1ZVRlcm1pbmF0ZWQpCisgICAgICAgIHJlc3VsdCA9 IHJ1bkxvb3AucnVuSW5Nb2RlKHdvcmtlckNvbnRleHQsIG1vZGUpOworCisgICAgaWYgKCFicmlk Z2UtPmRvbmUoKSAmJiByZXN1bHQgPT0gTWVzc2FnZVF1ZXVlVGVybWluYXRlZCkgeworICAgICAg ICBicmlkZ2UtPmNhbmNlbCgpOworICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAg cmV0dXJuIGJyaWRnZS0+cmVzdWx0KCk7Cit9CisKIC8vIFdvcmtlck9iamVjdFByb3h5IC0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAK IHZvaWQgV2ViV29ya2VyQmFzZTo6cG9zdE1lc3NhZ2VUb1dvcmtlck9iamVjdChQYXNzUmVmUHRy PFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gbWVzc2FnZSwKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJC YXNlLmgKaW5kZXggYTQ3MGVlNDY3ZDJmODYyOTg3OWQ5NWFmNGM3NTkzMjQ5NTk3YmQ1NC4uMTVl ODAxM2M5ZTU5NThiMjc2NWZjYTUxZTU1NzI5NTcwYzA1MmE2ZCAxMDA2NDQKLS0tIGEvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJXb3JrZXJCYXNlLmgKQEAgLTg4LDYgKzg4LDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9p ZCBkaWRDcmVhdGVEYXRhU291cmNlKFdlYkZyYW1lKiwgV2ViRGF0YVNvdXJjZSopOwogICAgIHZp cnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0 KFdlYkZyYW1lKiwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3RDbGllbnQqKTsKIAorICAgIC8vIENv bnRyb2xzIHdoZXRoZXIgYWNjZXNzIHRvIFdlYiBEYXRhYmFzZXMgaXMgYWxsb3dlZCBmb3IgdGhp cyB3b3JrZXIuCisgICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25z dCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVk IGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisKICAgICAvLyBFeGVjdXRlcyB0aGUgZ2l2ZW4gdGFzayBv biB0aGUgbWFpbiB0aHJlYWQuCiAgICAgc3RhdGljIHZvaWQgZGlzcGF0Y2hUYXNrVG9NYWluVGhy ZWFkKFBhc3NPd25QdHI8V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6VGFzaz4pOwog CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaCBi L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCmluZGV4IDkwNzQ5OWEy NjZhNjc2MmNmYmYyOWFjZDkzZDEwNTc0YTYwZjllZWIuLmFmYTliOWIzMzc2OTUyNzBlNzI3Mzdk ZDcxY2UzOTk1ZmY1OWU3MTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29y a2VyQ2xpZW50SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50 SW1wbC5oCkBAIC05NSw2ICs5NSw3IEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIDA7CiAgICAg fQogICAgIHZpcnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNyZWF0ZUFwcGxpY2F0aW9u Q2FjaGVIb3N0KFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50KikgeyByZXR1cm4gMDsgfQor ICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5n JiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGlt YXRlZFNpemUpIHsgcmV0dXJuIHRydWU7IH0KIAogcHJpdmF0ZToKICAgICB2aXJ0dWFsIH5XZWJX b3JrZXJDbGllbnRJbXBsKCk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9X ZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5kZXggNGU0OGIzNjRhNGMxMjI2OTA3NGRhZmFmMjZiNGI0 ZDMwMzEyOTUyZi4uNGI1N2FiNDI2MGQ3ZGUwMjkwZGE3NzJlOTNkMjM2ZjFkOTcyNDY0NCAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDE1IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5A Y2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZCBhbGxvd0RhdGFiYXNlIG1ldGhvZCB0byBUZXN0V2ViV29ya2VyLgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAgICAg ICBOZWVkIGEgc2hvcnQgZGVzY3JpcHRpb24gYW5kIGJ1ZyBVUkwgKE9PUFMhKQorCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oOgorICAgICAgICAoVGVz dFdlYldvcmtlcjo6YWxsb3dEYXRhYmFzZSk6CisKIDIwMTAtMDUtMDkgIERhbmllbCBCYXRlcyAg PGRiYXRlc0ByaW0uY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IENocmlzIEplcmRvbmVrLgpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldv cmtlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtl ci5oCmluZGV4IGYyOGNjMjA1NWQyNTc1NDQ3OGYwNjIyZjNiNzE2NzNkZmZiMzAxMDIuLjk0NzA4 MDQwZDUwZTQxMjM5MGM1NWFiODk1NjYzOWJlOGFkZDVlMDkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJXb3JrZXIuaAorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9UZXN0V2ViV29ya2VyLmgKQEAgLTgwLDYgKzgw LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgV2ViS2l0OjpXZWJXb3JrZXIqIGNyZWF0ZVdvcmtl cihXZWJLaXQ6OldlYldvcmtlckNsaWVudCopIHsgcmV0dXJuIDA7IH0KICAgICB2aXJ0dWFsIFdl YktpdDo6V2ViTm90aWZpY2F0aW9uUHJlc2VudGVyKiBub3RpZmljYXRpb25QcmVzZW50ZXIoKSB7 IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBXZWJLaXQ6OldlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0 KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJLaXQ6OldlYkFwcGxpY2F0aW9uQ2FjaGVI b3N0Q2xpZW50KikgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNl KFdlYktpdDo6V2ViRnJhbWUqLCBjb25zdCBXZWJLaXQ6OldlYlN0cmluZyYsIGNvbnN0IFdlYktp dDo6V2ViU3RyaW5nJiwgdW5zaWduZWQgbG9uZykgeyByZXR1cm4gdHJ1ZTsgfQogCiBwcml2YXRl OgogICAgIH5UZXN0V2ViV29ya2VyKCkge30K 55540 2010-05-10 03:57:48 -0700 2010-05-11 00:54:41 -0700 Patch bug-38742-20100510125745.patch text/plain 11755 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IDEzZTExN2QzZjUyMGFkOTkzNjk1ZTU3OTNiZTZiNjZlYjdmMjJiNmEu LjhkMDg4NjUxNWQzZTM1MDk3NzY0MGU4YmVjMGE3MTMyZDZkZjIzZGIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI2IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAg ICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKiBzcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpj YW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKToKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZVRhc2spOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRvbmUpOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZTo6cmVzdWx0KToKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2U6OnNpZ25hbENvbXBsZXRlZCk6CisgICAgICAgIChXZWJLaXQ6 OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpkaWRDb21wbGV0 ZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuaDoKKyAgICAgICAgKiBzcmMvV2ViV29y a2VyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJDbGllbnRJbXBsOjph bGxvd0RhdGFiYXNlKToKKwogMjAxMC0wNS0wOCAgSmVucyBBbGZrZSAgPHNuZWpAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEZpc2hlci4KZGlmZiAtLWdpdCBhL1dl YktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCmluZGV4IDEzNjAzY2JjOTMxNTA4 NTQzMDM5M2E4NGM3ZjY5NWUxZTMwNWQyNTYuLmNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1 MmM0MTY0NGZmMmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9u V29ya2VyQ2xpZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3Jr ZXJDbGllbnQuaApAQCAtMzUsNiArMzUsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3Mg V2ViQXBwbGljYXRpb25DYWNoZUhvc3Q7CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENs aWVudDsKK2NsYXNzIFdlYkZyYW1lOwogY2xhc3MgV2ViTm90aWZpY2F0aW9uUHJlc2VudGVyOwog Y2xhc3MgV2ViU3RyaW5nOwogY2xhc3MgV2ViV29ya2VyOwpAQCAtNzksNiArODAsOSBAQCBwdWJs aWM6CiAgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgaW4gdGhlIHdvcmtl ciBwcm9jZXNzIGR1cmluZyBpbml0aWFsaXphdGlvbi4KICAgICB2aXJ0dWFsIFdlYkFwcGxpY2F0 aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJBcHBsaWNhdGlvbkNh Y2hlSG9zdENsaWVudCopID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQg dGhyZWFkIGJlZm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNlLgorICAgIHZpcnR1YWwgYm9vbCBh bGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJT dHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKKwog cHJvdGVjdGVkOgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRpZmYgLS1n aXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwIGIvV2ViS2l0L2No cm9taXVtL3NyYy9EYXRhYmFzZU9ic2VydmVyLmNwcAppbmRleCA2YTJlMmE3MGFjMDg0NDFhZGJi OGUyMmUwZTQ5MzU1NDc1NTA3YzZjLi4xYzUxMTdjMGY1N2JkZmYxY2E1MWRjYzg3NzRhZjZiM2Nk Mjc5MTJiIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIu Y3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5jcHAKQEAgLTUw LDEyICs1MCwxNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBib29sIERhdGFiYXNlT2JzZXJ2ZXI6 OmNhbkVzdGFibGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFt ZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogewogICAgIEFTU0VSVChzY3JpcHRFeGVj dXRpb25Db250ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7Ci0gICAgLy8gRklYTUU6IGFkZCBzdXBw b3J0IGZvciB0aGUgY2FzZSBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzV29ya2VyKCkgb25j ZSB3b3JrZXJzIGltcGxlbWVudCB3ZWIgZGF0YWJhc2VzLgotICAgIEFTU0VSVChzY3JpcHRFeGVj dXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25D b250ZXh0LT5pc0RvY3VtZW50KCkgfHwgc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+aXNXb3JrZXJD b250ZXh0KCkpOwogICAgIGlmIChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkp IHsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihz Y3JpcHRFeGVjdXRpb25Db250ZXh0KTsKICAgICAgICAgV2ViRnJhbWVJbXBsKiB3ZWJGcmFtZSA9 IFdlYkZyYW1lSW1wbDo6ZnJvbUZyYW1lKGRvY3VtZW50LT5mcmFtZSgpKTsKICAgICAgICAgcmV0 dXJuIHdlYkZyYW1lLT5jbGllbnQoKS0+YWxsb3dEYXRhYmFzZSh3ZWJGcmFtZSwgbmFtZSwgZGlz cGxheU5hbWUsIGVzdGltYXRlZFNpemUpOworICAgIH0gZWxzZSB7CisgICAgICAgIFdvcmtlckNv bnRleHQqIHdvcmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oc2NyaXB0 RXhlY3V0aW9uQ29udGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2Fk ZXJQcm94eSA9ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsK KyAgICAgICAgV2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2Vy QmFzZSo+KHdvcmtlckxvYWRlclByb3h5KTsKKyAgICAgICAgcmV0dXJuIHdlYldvcmtlci0+YWxs b3dEYXRhYmFzZSgwLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSk7CiAgICAgfQog CiAgICAgcmV0dXJuIHRydWU7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRl eCAyYzRiNGY2MzIzNDFhMmVlOGI4MmVjYjUxYWMxNzJjOGE1MDExOWI4Li5iODQ0MzQ1YWIxNjBh MmI2ZWU5ZWUxZTA1MzY5MmQ0YjRhNDQ0NjZhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYldvcmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2Vy QmFzZS5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRl ICJXZWJXb3JrZXJCYXNlLmgiCiAKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKICNpbmNsdWRl ICJHZW5lcmljV29ya2VyVGFzay5oIgogI2luY2x1ZGUgIk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgog I2luY2x1ZGUgIlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCkBAIC00NCw2ICs0NSw3IEBA CiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgogCisj aW5jbHVkZSAiV29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVh ZC5oIgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAKQEAgLTUzLDYgKzU1LDcyIEBAIG5h bWVzcGFjZSBXZWJLaXQgewogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKK3N0YXRpYyBjb25zdCBj aGFyIGFsbG93RGF0YWJhc2VNb2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworCituYW1lc3Bh Y2UgeworCisvLyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcm91dGUgdGhlIHJlc3VsdCBvZiB0aGUg V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZQorLy8gY2FsbCBiYWNrIHRvIHRoZSB3b3JrZXIg Y29udGV4dC4KK2NsYXNzIEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlIDogcHVibGljIFRo cmVhZFNhZmVTaGFyZWQ8QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IHsKK3B1YmxpYzoK KyAgICBzdGF0aWMgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gY3Jl YXRlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBtb2RlLCBX ZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25z dCBXZWJDb3JlOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZGlzcGxheU5h bWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgeyByZXR1cm4gYWRvcHRSZWYobmV3IEFs bG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlKHdvcmtlciwgbW9kZSwgY29tbW9uQ2xpZW50LCBm cmFtZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsgfQorCisgICAgLy8gVGhl c2UgbWV0aG9kcyBhcmUgaW52b2tlZCBvbiB0aGUgd29ya2VyIGNvbnRleHQuCisgICAgdm9pZCBj YW5jZWwoKQorICAgIHsKKyAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOworICAg ICAgICBtX3dvcmtlciA9IDA7CisgICAgfQorCisgICAgYm9vbCBkb25lKCkKKyAgICB7CisgICAg ICAgIHJldHVybiBtX2NvbXBsZXRlZDsKKyAgICB9CisKKyAgICBib29sIHJlc3VsdCgpCisgICAg eworICAgICAgICByZXR1cm4gbV9yZXN1bHQ7CisgICAgfQorCisgICAgLy8gVGhpcyBtZXRob2Qg aXMgaW52b2tlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgdm9pZCBzaWduYWxDb21wbGV0ZWQo Ym9vbCByZXN1bHQpCisgICAgeworICAgICAgICBNdXRleExvY2tlciBsb2NrZXIobV9tdXRleCk7 CisgICAgICAgIGlmIChtX3dvcmtlcikKKyAgICAgICAgICAgIG1fd29ya2VyLT5wb3N0VGFza0Zv ck1vZGVUb1dvcmtlckNvbnRleHQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZkaWRDb21wbGV0ZSwgdGhp cywgcmVzdWx0KSwgbV9tb2RlKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgQWxsb3dEYXRhYmFz ZU1haW5UaHJlYWRCcmlkZ2UoV2ViV29ya2VyQmFzZSogd29ya2VyLCBjb25zdCBXZWJDb3JlOjpT dHJpbmcmIG1vZGUsIFdlYkNvbW1vbldvcmtlckNsaWVudCogY29tbW9uQ2xpZW50LCBXZWJGcmFt ZSogZnJhbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgbmFtZSwgY29uc3QgV2ViQ29yZTo6U3Ry aW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQorICAgICAgICA6 IG1fY29tcGxldGVkKGZhbHNlKQorICAgICAgICAsIG1fd29ya2VyKHdvcmtlcikKKyAgICAgICAg LCBtX21vZGUobW9kZSkKKyAgICB7CisgICAgICAgIHdvcmtlci0+ZGlzcGF0Y2hUYXNrVG9NYWlu VGhyZWFkKGNyZWF0ZUNhbGxiYWNrVGFzaygmYWxsb3dEYXRhYmFzZVRhc2ssIGNvbW1vbkNsaWVu dCwgZnJhbWUsIFN0cmluZyhuYW1lKSwgU3RyaW5nKGRpc3BsYXlOYW1lKSwgZXN0aW1hdGVkU2l6 ZSwgdGhpcykpOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIGFsbG93RGF0YWJhc2VUYXNrKFdl YkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFdlYkNvbW1vbldvcmtlckNs aWVudCogY29tbW9uQ2xpZW50LCBXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmlu ZyBuYW1lLCBjb25zdCBXZWJDb3JlOjpTdHJpbmcgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcg ZXN0aW1hdGVkU2l6ZSwgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4g YnJpZGdlKQorICAgIHsKKyAgICAgICAgaWYgKCFjb21tb25DbGllbnQpCisgICAgICAgICAgICBi cmlkZ2UtPnNpZ25hbENvbXBsZXRlZChmYWxzZSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAg IGJyaWRnZS0+c2lnbmFsQ29tcGxldGVkKGNvbW1vbkNsaWVudC0+YWxsb3dEYXRhYmFzZShmcmFt ZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGltYXRlZFNpemUpKTsKKyAgICB9CisKKyAgICBzdGF0 aWMgdm9pZCBkaWRDb21wbGV0ZShXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250 ZXh0LCBQYXNzUmVmUHRyPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UsIGJv b2wgcmVzdWx0KQorICAgIHsKKyAgICAgICAgYnJpZGdlLT5tX3Jlc3VsdCA9IHJlc3VsdDsKKyAg ICAgICAgYnJpZGdlLT5tX2NvbXBsZXRlZCA9IHRydWU7CisgICAgfQorCisgICAgYm9vbCBtX3Jl c3VsdDsKKyAgICBib29sIG1fY29tcGxldGVkOworICAgIE11dGV4IG1fbXV0ZXg7CisgICAgV2Vi V29ya2VyQmFzZSogbV93b3JrZXI7CisgICAgV2ViQ29yZTo6U3RyaW5nIG1fbW9kZTsKK307Cit9 CisKIC8vIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIG9uIHRoZSBtYWluIHRocmVhZCB0byBmb3Jj ZSB0byBpbml0aWFsaXplIHNvbWUgc3RhdGljCiAvLyB2YWx1ZXMgdXNlZCBpbiBXZWJLaXQgYmVm b3JlIGFueSB3b3JrZXIgdGhyZWFkIGlzIHN0YXJ0ZWQuIFRoaXMgaXMgYmVjYXVzZSBpbgogLy8g b3VyIHdvcmtlciBwcm9jZXNzcywgd2UgZG8gbm90IHJ1biBhbnkgV2ViS2l0IGNvZGUgaW4gbWFp biB0aHJlYWQgYW5kIHRodXMKQEAgLTE0Nyw2ICsyMTUsMzAgQEAgV2ViQXBwbGljYXRpb25DYWNo ZUhvc3QqIFdlYldvcmtlckJhc2U6OmNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdlYkZyYW1l KiwgV2UKICAgICByZXR1cm4gMDsKIH0KIAorYm9vbCBXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFi YXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCit7CisgICAgV29ya2VyUnVu TG9vcCYgcnVuTG9vcCA9IG1fd29ya2VyVGhyZWFkLT5ydW5Mb29wKCk7CisgICAgV29ya2VyU2Ny aXB0Q29udHJvbGxlciogY29udHJvbGxlciA9IFdvcmtlclNjcmlwdENvbnRyb2xsZXI6OmNvbnRy b2xsZXJGb3JDb250ZXh0KCk7CisgICAgQVNTRVJUKGNvbnRyb2xsZXIpOworICAgIFdvcmtlckNv bnRleHQqIHdvcmtlckNvbnRleHQgPSBjb250cm9sbGVyLT53b3JrZXJDb250ZXh0KCk7CisKKyAg ICAvLyBDcmVhdGUgYSB1bmlxdWUgbW9kZSBqdXN0IGZvciB0aGlzIHN5bmNocm9ub3VzIGNhbGwu CisgICAgU3RyaW5nIG1vZGUgPSBhbGxvd0RhdGFiYXNlTW9kZTsKKyAgICBtb2RlLmFwcGVuZChT dHJpbmc6Om51bWJlcihydW5Mb29wLmNyZWF0ZVVuaXF1ZUlkKCkpKTsKKworICAgIFJlZlB0cjxB bGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlID0gQWxsb3dEYXRhYmFzZU1haW5U aHJlYWRCcmlkZ2U6OmNyZWF0ZSh0aGlzLCBtb2RlLCBjb21tb25DbGllbnQoKSwgbV93ZWJWaWV3 LT5tYWluRnJhbWUoKSwgU3RyaW5nKG5hbWUpLCBTdHJpbmcoZGlzcGxheU5hbWUpLCBlc3RpbWF0 ZWRTaXplKTsKKyAgICBNZXNzYWdlUXVldWVXYWl0UmVzdWx0IHJlc3VsdCA9IE1lc3NhZ2VRdWV1 ZU1lc3NhZ2VSZWNlaXZlZDsKKyAgICB3aGlsZSAoIWJyaWRnZS0+ZG9uZSgpICYmIHJlc3VsdCAh PSBNZXNzYWdlUXVldWVUZXJtaW5hdGVkKQorICAgICAgICByZXN1bHQgPSBydW5Mb29wLnJ1bklu TW9kZSh3b3JrZXJDb250ZXh0LCBtb2RlKTsKKworICAgIGlmICghYnJpZGdlLT5kb25lKCkgJiYg cmVzdWx0ID09IE1lc3NhZ2VRdWV1ZVRlcm1pbmF0ZWQpIHsKKyAgICAgICAgYnJpZGdlLT5jYW5j ZWwoKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIHJldHVybiBicmlkZ2Ut PnJlc3VsdCgpOworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtl ckJhc2U6OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2Ny aXB0VmFsdWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IGE0 NzBlZTQ2N2QyZjg2Mjk4NzlkOTVhZjRjNzU5MzI0OTU5N2JkNTQuLjE1ZTgwMTNjOWU1OTU4YjI3 NjVmY2E1MWU1NTcyOTU3MGMwNTJhNmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5o CkBAIC04OCw2ICs4OCw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ3JlYXRlRGF0 YVNvdXJjZShXZWJGcmFtZSosIFdlYkRhdGFTb3VyY2UqKTsKICAgICB2aXJ0dWFsIFdlYkFwcGxp Y2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJGcmFtZSosIFdl YkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50Kik7CiAKKyAgICAvLyBDb250cm9scyB3aGV0aGVy IGFjY2VzcyB0byBXZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgorICAg IHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBu YW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRl ZFNpemUpOworCiAgICAgLy8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhy ZWFkLgogICAgIHN0YXRpYyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRy PFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAppbmRleCA5MDc0OTlhMjY2YTY3NjJjZmJmMjlh Y2Q5M2QxMDU3NGE2MGY5ZWViLi5hZmE5YjliMzM3Njk1MjcwZTcyNzM3ZGQ3MWNlMzk5NWZmNTll NzE4IDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwu aAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtOTUs NiArOTUsNyBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KICAgICB2aXJ0dWFs IFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJB cHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudCopIHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIGJv b2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3Qg V2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKSB7IHJl dHVybiB0cnVlOyB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1w bCgpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hh bmdlTG9nCmluZGV4IDRlNDhiMzY0YTRjMTIyNjkwNzRkYWZhZjI2YjRiNGQzMDMxMjk1MmYuLjRi NTdhYjQyNjBkN2RlMDI5MGRhNzcyZTkzZDIzNmYxZDk3MjQ2NDQgMTAwNjQ0Ci0tLSBhL1dlYktp dFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx NSBAQAorMjAxMC0wNS0wNyAgSm9jaGVuIEVpc2luZ2VyICA8am9jaGVuQGNocm9taXVtLm9yZz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYWxs b3dEYXRhYmFzZSBtZXRob2QgdG8gVGVzdFdlYldvcmtlci4KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4NzQyCisKKyAgICAgICAgTmVlZCBhIHNob3J0 IGRlc2NyaXB0aW9uIGFuZCBidWcgVVJMIChPT1BTISkKKworICAgICAgICAqIER1bXBSZW5kZXJU cmVlL2Nocm9taXVtL1Rlc3RXZWJXb3JrZXIuaDoKKyAgICAgICAgKFRlc3RXZWJXb3JrZXI6OmFs bG93RGF0YWJhc2UpOgorCiAyMDEwLTA1LTA5ICBEYW5pZWwgQmF0ZXMgIDxkYmF0ZXNAcmltLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBDaHJpcyBKZXJkb25lay4KZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJXb3JrZXIuaCBiL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJXb3JrZXIuaAppbmRleCBmMjhj YzIwNTVkMjU3NTQ0NzhmMDYyMmYzYjcxNjczZGZmYjMwMTAyLi45NDcwODA0MGQ1MGU0MTIzOTBj NTVhYjg5NTY2MzliZThhZGQ1ZTA5IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9jaHJvbWl1bS9UZXN0V2ViV29ya2VyLmgKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oCkBAIC04MCw2ICs4MCw3IEBAIHB1YmxpYzoK ICAgICB2aXJ0dWFsIFdlYktpdDo6V2ViV29ya2VyKiBjcmVhdGVXb3JrZXIoV2ViS2l0OjpXZWJX b3JrZXJDbGllbnQqKSB7IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBXZWJLaXQ6OldlYk5vdGlm aWNhdGlvblByZXNlbnRlciogbm90aWZpY2F0aW9uUHJlc2VudGVyKCkgeyByZXR1cm4gMDsgfQog ICAgIHZpcnR1YWwgV2ViS2l0OjpXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogY3JlYXRlQXBwbGlj YXRpb25DYWNoZUhvc3QoV2ViS2l0OjpXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudCopIHsg cmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJLaXQ6OldlYkZy YW1lKiwgY29uc3QgV2ViS2l0OjpXZWJTdHJpbmcmLCBjb25zdCBXZWJLaXQ6OldlYlN0cmluZyYs IHVuc2lnbmVkIGxvbmcpIHsgcmV0dXJuIHRydWU7IH0KIAogcHJpdmF0ZToKICAgICB+VGVzdFdl YldvcmtlcigpIHt9Cg== 55673 2010-05-11 00:54:49 -0700 2010-05-12 00:50:48 -0700 Patch bug-38742-20100511095447.patch text/plain 11437 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IGVhYWIxYWFmMjRjY2JhNTY5ZmEyNmZmNTEwODgwMzZlZDNlZWZiY2Iu LjUwZjMyNGIzZTMxODFiYzFjZDA1Yjg0MDJkY2M4OTRkOTU0YTQxODkgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI1IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAg ICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKiBzcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpj YW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKToKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZVRhc2spOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OnJlc3VsdCk6 CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFk QnJpZGdlOjpzaWduYWxDb21wbGV0ZWQpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6ZGlkQ29tcGxldGUpOgorICAgICAgICAq IHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwu aDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6YWxsb3dEYXRhYmFzZSk6 CisKIDIwMTAtMDUtMTAgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KIAogICAgICAg ICBSZXZpZXdlZCBieSBLZW50IFRhbXVyYS4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YkNvbW1vbldvcmtlckNsaWVudC5oCmluZGV4IDEzNjAzY2JjOTMxNTA4NTQzMDM5M2E4NGM3ZjY5 NWUxZTMwNWQyNTYuLmNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZmMmQgMTAw NjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgK KysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAt MzUsNiArMzUsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRpb25D YWNoZUhvc3Q7CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudDsKK2NsYXNzIFdl YkZyYW1lOwogY2xhc3MgV2ViTm90aWZpY2F0aW9uUHJlc2VudGVyOwogY2xhc3MgV2ViU3RyaW5n OwogY2xhc3MgV2ViV29ya2VyOwpAQCAtNzksNiArODAsOSBAQCBwdWJsaWM6CiAgICAgLy8gQ2Fs bGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgaW4gdGhlIHdvcmtlciBwcm9jZXNzIGR1cmlu ZyBpbml0aWFsaXphdGlvbi4KICAgICB2aXJ0dWFsIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBj cmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudCop ID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBv cGVuaW5nIGEgd2ViIGRhdGFiYXNlLgorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdl YkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlO YW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKKwogcHJvdGVjdGVkOgogICAg IH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hy b21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9EYXRh YmFzZU9ic2VydmVyLmNwcAppbmRleCA2YTJlMmE3MGFjMDg0NDFhZGJiOGUyMmUwZTQ5MzU1NDc1 NTA3YzZjLi4xYzUxMTdjMGY1N2JkZmYxY2E1MWRjYzg3NzRhZjZiM2NkMjc5MTJiIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwCisrKyBiL1dlYktp dC9jaHJvbWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5jcHAKQEAgLTUwLDEyICs1MCwxNiBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiBib29sIERhdGFiYXNlT2JzZXJ2ZXI6OmNhbkVzdGFibGlzaERh dGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9u ZyBlc3RpbWF0ZWRTaXplKQogewogICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5p c0NvbnRleHRUaHJlYWQoKSk7Ci0gICAgLy8gRklYTUU6IGFkZCBzdXBwb3J0IGZvciB0aGUgY2Fz ZSBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzV29ya2VyKCkgb25jZSB3b3JrZXJzIGltcGxl bWVudCB3ZWIgZGF0YWJhc2VzLgotICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5p c0RvY3VtZW50KCkpOworICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3Vt ZW50KCkgfHwgc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkpOwogICAg IGlmIChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkpIHsKICAgICAgICAgRG9j dW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihzY3JpcHRFeGVjdXRpb25D b250ZXh0KTsKICAgICAgICAgV2ViRnJhbWVJbXBsKiB3ZWJGcmFtZSA9IFdlYkZyYW1lSW1wbDo6 ZnJvbUZyYW1lKGRvY3VtZW50LT5mcmFtZSgpKTsKICAgICAgICAgcmV0dXJuIHdlYkZyYW1lLT5j bGllbnQoKS0+YWxsb3dEYXRhYmFzZSh3ZWJGcmFtZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGlt YXRlZFNpemUpOworICAgIH0gZWxzZSB7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNv bnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oc2NyaXB0RXhlY3V0aW9uQ29udGV4 dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3Jr ZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29y a2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxv YWRlclByb3h5KTsKKyAgICAgICAgcmV0dXJuIHdlYldvcmtlci0+YWxsb3dEYXRhYmFzZSgwLCBu YW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSk7CiAgICAgfQogCiAgICAgcmV0dXJuIHRy dWU7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRleCAyYzRiNGY2MzIzNDFh MmVlOGI4MmVjYjUxYWMxNzJjOGE1MDExOWI4Li5kNWQwZmI2NmFlZGRjNjExNjc3MmJhNWI5ZDg1 MzE4YmM5ZTBiYjljIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJh c2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTMx LDYgKzMxLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXZWJXb3JrZXJCYXNl LmgiCiAKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKICNpbmNsdWRlICJHZW5lcmljV29ya2Vy VGFzay5oIgogI2luY2x1ZGUgIk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgogI2luY2x1ZGUgIlBsYXRm b3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCkBAIC00NCw2ICs0NSw3IEBACiAjaW5jbHVkZSAiV2Vi Vmlldy5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2Vy U2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUg PHd0Zi9NYWluVGhyZWFkLmg+CiAKQEAgLTUzLDYgKzU1LDY3IEBAIG5hbWVzcGFjZSBXZWJLaXQg ewogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKK3N0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJh c2VNb2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworCituYW1lc3BhY2UgeworCisvLyBUaGlz IGNsYXNzIGlzIHVzZWQgdG8gcm91dGUgdGhlIHJlc3VsdCBvZiB0aGUgV2ViV29ya2VyQmFzZTo6 YWxsb3dEYXRhYmFzZQorLy8gY2FsbCBiYWNrIHRvIHRoZSB3b3JrZXIgY29udGV4dC4KK2NsYXNz IEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlIDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8 QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFz c1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gY3JlYXRlKFdlYldvcmtlckJh c2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBtb2RlLCBXZWJDb21tb25Xb3JrZXJD bGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25zdCBXZWJDb3JlOjpTdHJp bmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxv bmcgZXN0aW1hdGVkU2l6ZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgQWxs b3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2Uod29ya2VyLCBtb2RlLCBjb21tb25DbGllbnQsIGZy YW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSkpOworICAgIH0KKworICAgIC8v IFRoZXNlIG1ldGhvZHMgYXJlIGludm9rZWQgb24gdGhlIHdvcmtlciBjb250ZXh0LgorICAgIHZv aWQgY2FuY2VsKCkKKyAgICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211dGV4KTsK KyAgICAgICAgbV93b3JrZXIgPSAwOworICAgIH0KKworICAgIGJvb2wgcmVzdWx0KCkKKyAgICB7 CisgICAgICAgIHJldHVybiBtX3Jlc3VsdDsKKyAgICB9CisKKyAgICAvLyBUaGlzIG1ldGhvZCBp cyBpbnZva2VkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAgICB2b2lkIHNpZ25hbENvbXBsZXRlZChi b29sIHJlc3VsdCkKKyAgICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211dGV4KTsK KyAgICAgICAgaWYgKG1fd29ya2VyKQorICAgICAgICAgICAgbV93b3JrZXItPnBvc3RUYXNrRm9y TW9kZVRvV29ya2VyQ29udGV4dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZENvbXBsZXRlLCB0aGlz LCByZXN1bHQpLCBtX21vZGUpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBBbGxvd0RhdGFiYXNl TWFpblRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0IFdlYkNvcmU6OlN0 cmluZyYgbW9kZSwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZyYW1l KiBmcmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBuYW1lLCBjb25zdCBXZWJDb3JlOjpTdHJp bmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCisgICAgICAgIDog bV93b3JrZXIod29ya2VyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgIHsKKyAgICAgICAg d29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZhbGxv d0RhdGFiYXNlVGFzaywgY29tbW9uQ2xpZW50LCBmcmFtZSwgU3RyaW5nKG5hbWUpLCBTdHJpbmco ZGlzcGxheU5hbWUpLCBlc3RpbWF0ZWRTaXplLCB0aGlzKSk7CisgICAgfQorCisgICAgc3RhdGlj IHZvaWQgYWxsb3dEYXRhYmFzZVRhc2soV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZyYW1lKiBm cmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyBk aXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBQYXNzUmVmUHRyPEFsbG93 RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UpCisgICAgeworICAgICAgICBpZiAoIWNv bW1vbkNsaWVudCkKKyAgICAgICAgICAgIGJyaWRnZS0+c2lnbmFsQ29tcGxldGVkKGZhbHNlKTsK KyAgICAgICAgZWxzZQorICAgICAgICAgICAgYnJpZGdlLT5zaWduYWxDb21wbGV0ZWQoY29tbW9u Q2xpZW50LT5hbGxvd0RhdGFiYXNlKGZyYW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVk U2l6ZSkpOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIGRpZENvbXBsZXRlKFdlYkNvcmU6OlNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFzZU1h aW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSwgYm9vbCByZXN1bHQpCisgICAgeworICAgICAgICBicmlk Z2UtPm1fcmVzdWx0ID0gcmVzdWx0OworICAgIH0KKworICAgIGJvb2wgbV9yZXN1bHQ7CisgICAg TXV0ZXggbV9tdXRleDsKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBXZWJDb3Jl OjpTdHJpbmcgbV9tb2RlOworfTsKK30KKwogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24g dGhlIG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKIC8vIHZh bHVlcyB1c2VkIGluIFdlYktpdCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWQgaXMgc3RhcnRlZC4g VGhpcyBpcyBiZWNhdXNlIGluCiAvLyBvdXIgd29ya2VyIHByb2Nlc3NzLCB3ZSBkbyBub3QgcnVu IGFueSBXZWJLaXQgY29kZSBpbiBtYWluIHRocmVhZCBhbmQgdGh1cwpAQCAtMTQ3LDYgKzIxMCwy OCBAQCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogV2ViV29ya2VyQmFzZTo6Y3JlYXRlQXBwbGlj YXRpb25DYWNoZUhvc3QoV2ViRnJhbWUqLCBXZQogICAgIHJldHVybiAwOwogfQogCitib29sIFdl YldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5h bWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVk U2l6ZSkKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0gbV93b3JrZXJUaHJlYWQtPnJ1 bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBjb250cm9sbGVyID0gV29ya2Vy U2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQoKTsKKyAgICBBU1NFUlQoY29u dHJvbGxlcik7CisgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IGNvbnRyb2xsZXIt PndvcmtlckNvbnRleHQoKTsKKworICAgIC8vIENyZWF0ZSBhIHVuaXF1ZSBtb2RlIGp1c3QgZm9y IHRoaXMgc3luY2hyb25vdXMgY2FsbC4KKyAgICBTdHJpbmcgbW9kZSA9IGFsbG93RGF0YWJhc2VN b2RlOworICAgIG1vZGUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKHJ1bkxvb3AuY3JlYXRlVW5pcXVl SWQoKSkpOworCisgICAgUmVmUHRyPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlk Z2UgPSBBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y3JlYXRlKHRoaXMsIG1vZGUsIGNv bW1vbkNsaWVudCgpLCBtX3dlYlZpZXctPm1haW5GcmFtZSgpLCBTdHJpbmcobmFtZSksIFN0cmlu ZyhkaXNwbGF5TmFtZSksIGVzdGltYXRlZFNpemUpOworCisgICAgLy8gRWl0aGVyIHRoZSBicmlk Z2UgcmV0dXJucywgb3IgdGhlIHF1ZXVlIGdldHMgdGVybWluYXRlZC4KKyAgICBpZiAocnVuTG9v cC5ydW5Jbk1vZGUod29ya2VyQ29udGV4dCwgbW9kZSkgPT0gTWVzc2FnZVF1ZXVlVGVybWluYXRl ZCkgeworICAgICAgICBicmlkZ2UtPmNhbmNlbCgpOworICAgICAgICByZXR1cm4gZmFsc2U7Cisg ICAgfQorCisgICAgcmV0dXJuIGJyaWRnZS0+cmVzdWx0KCk7Cit9CisKIC8vIFdvcmtlck9iamVj dFByb3h5IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCiAKIHZvaWQgV2ViV29ya2VyQmFzZTo6cG9zdE1lc3NhZ2VUb1dvcmtlck9iamVj dChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gbWVzc2FnZSwKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJXb3JrZXJCYXNlLmgKaW5kZXggYTQ3MGVlNDY3ZDJmODYyOTg3OWQ5NWFmNGM3NTkzMjQ5 NTk3YmQ1NC4uMTVlODAxM2M5ZTU5NThiMjc2NWZjYTUxZTU1NzI5NTcwYzA1MmE2ZCAxMDA2NDQK LS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKKysrIGIvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKQEAgLTg4LDYgKzg4LDkgQEAgcHVibGljOgogICAg IHZpcnR1YWwgdm9pZCBkaWRDcmVhdGVEYXRhU291cmNlKFdlYkZyYW1lKiwgV2ViRGF0YVNvdXJj ZSopOwogICAgIHZpcnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNyZWF0ZUFwcGxpY2F0 aW9uQ2FjaGVIb3N0KFdlYkZyYW1lKiwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3RDbGllbnQqKTsK IAorICAgIC8vIENvbnRyb2xzIHdoZXRoZXIgYWNjZXNzIHRvIFdlYiBEYXRhYmFzZXMgaXMgYWxs b3dlZCBmb3IgdGhpcyB3b3JrZXIuCisgICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2Vi RnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5h bWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisKICAgICAvLyBFeGVjdXRlcyB0aGUg Z2l2ZW4gdGFzayBvbiB0aGUgbWFpbiB0aHJlYWQuCiAgICAgc3RhdGljIHZvaWQgZGlzcGF0Y2hU YXNrVG9NYWluVGhyZWFkKFBhc3NPd25QdHI8V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4 dDo6VGFzaz4pOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNs aWVudEltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCmlu ZGV4IDkwNzQ5OWEyNjZhNjc2MmNmYmYyOWFjZDkzZDEwNTc0YTYwZjllZWIuLmFmYTliOWIzMzc2 OTUyNzBlNzI3MzdkZDcxY2UzOTk1ZmY1OWU3MTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi V29ya2VyQ2xpZW50SW1wbC5oCkBAIC05NSw2ICs5NSw3IEBAIHB1YmxpYzoKICAgICAgICAgcmV0 dXJuIDA7CiAgICAgfQogICAgIHZpcnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNyZWF0 ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50KikgeyBy ZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29u c3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25l ZCBsb25nIGVzdGltYXRlZFNpemUpIHsgcmV0dXJuIHRydWU7IH0KIAogcHJpdmF0ZToKICAgICB2 aXJ0dWFsIH5XZWJXb3JrZXJDbGllbnRJbXBsKCk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9D aGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5kZXggY2FiOTJiODM2MDhkYzA3YWJh NzQ2NWJlZThkNTFhYzU0NzAyYzM4ZS4uNzNmNzY1N2UyYzk4MWFmZWY3OWY5M2U1ZDdkODBmNTdi N2M5ZTM0ZiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRv b2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5n ZXIgIDxqb2NoZW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZCBhbGxvd0RhdGFiYXNlIG1ldGhvZCB0byBUZXN0V2ViV29y a2VyLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3 NDIKKworICAgICAgICBOZWVkIGEgc2hvcnQgZGVzY3JpcHRpb24gYW5kIGJ1ZyBVUkwgKE9PUFMh KQorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oOgor ICAgICAgICAoVGVzdFdlYldvcmtlcjo6YWxsb3dEYXRhYmFzZSk6CisKIDIwMTAtMDUtMTAgIFRv bnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBLZW50 IFRhbXVyYS4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVt L1Rlc3RXZWJXb3JrZXIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rl c3RXZWJXb3JrZXIuaAppbmRleCBmMjhjYzIwNTVkMjU3NTQ0NzhmMDYyMmYzYjcxNjczZGZmYjMw MTAyLi45NDcwODA0MGQ1MGU0MTIzOTBjNTVhYjg5NTY2MzliZThhZGQ1ZTA5IDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9UZXN0V2ViV29ya2VyLmgKKysr IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oCkBA IC04MCw2ICs4MCw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIFdlYktpdDo6V2ViV29ya2VyKiBj cmVhdGVXb3JrZXIoV2ViS2l0OjpXZWJXb3JrZXJDbGllbnQqKSB7IHJldHVybiAwOyB9CiAgICAg dmlydHVhbCBXZWJLaXQ6OldlYk5vdGlmaWNhdGlvblByZXNlbnRlciogbm90aWZpY2F0aW9uUHJl c2VudGVyKCkgeyByZXR1cm4gMDsgfQogICAgIHZpcnR1YWwgV2ViS2l0OjpXZWJBcHBsaWNhdGlv bkNhY2hlSG9zdCogY3JlYXRlQXBwbGljYXRpb25DYWNoZUhvc3QoV2ViS2l0OjpXZWJBcHBsaWNh dGlvbkNhY2hlSG9zdENsaWVudCopIHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIGJvb2wgYWxs b3dEYXRhYmFzZShXZWJLaXQ6OldlYkZyYW1lKiwgY29uc3QgV2ViS2l0OjpXZWJTdHJpbmcmLCBj b25zdCBXZWJLaXQ6OldlYlN0cmluZyYsIHVuc2lnbmVkIGxvbmcpIHsgcmV0dXJuIHRydWU7IH0K IAogcHJpdmF0ZToKICAgICB+VGVzdFdlYldvcmtlcigpIHt9Cg== 55815 2010-05-12 00:50:56 -0700 2010-05-14 00:46:38 -0700 Patch bug-38742-20100512095054.patch text/plain 11615 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IDQ4NmE1NmU0NGU0ODQyNWFjYTQ0YTZmNmYzMGI1N2Y3ODNmMmY4NzIu LjM0YjIwNWE0YmU3OGM5NDkyMmFhYzAzMGUzOWMxYTQzZmFmZDM4MjggMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI1IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAg ICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKiBzcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpj YW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKToKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZVRhc2spOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OnJlc3VsdCk6 CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFk QnJpZGdlOjpzaWduYWxDb21wbGV0ZWQpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6ZGlkQ29tcGxldGUpOgorICAgICAgICAq IHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwu aDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6YWxsb3dEYXRhYmFzZSk6 CisKIDIwMTAtMDUtMTEgIEtlbnQgVGFtdXJhICA8dGtlbnRAY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IERpbWl0cmkgR2xhemtvdi4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCmluZGV4IDEzNjAzY2JjOTMxNTA4NTQzMDM5M2E4 NGM3ZjY5NWUxZTMwNWQyNTYuLmNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZm MmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xp ZW50LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQu aApAQCAtMzUsNiArMzUsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGlj YXRpb25DYWNoZUhvc3Q7CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudDsKK2Ns YXNzIFdlYkZyYW1lOwogY2xhc3MgV2ViTm90aWZpY2F0aW9uUHJlc2VudGVyOwogY2xhc3MgV2Vi U3RyaW5nOwogY2xhc3MgV2ViV29ya2VyOwpAQCAtNzksNiArODAsOSBAQCBwdWJsaWM6CiAgICAg Ly8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgaW4gdGhlIHdvcmtlciBwcm9jZXNz IGR1cmluZyBpbml0aWFsaXphdGlvbi4KICAgICB2aXJ0dWFsIFdlYkFwcGxpY2F0aW9uQ2FjaGVI b3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENs aWVudCopID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJl Zm9yZSBvcGVuaW5nIGEgd2ViIGRhdGFiYXNlLgorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFi YXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKKwogcHJvdGVjdGVk OgogICAgIH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJL aXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3Ny Yy9EYXRhYmFzZU9ic2VydmVyLmNwcAppbmRleCA2YTJlMmE3MGFjMDg0NDFhZGJiOGUyMmUwZTQ5 MzU1NDc1NTA3YzZjLi4xYzUxMTdjMGY1N2JkZmYxY2E1MWRjYzg3NzRhZjZiM2NkMjc5MTJiIDEw MDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwCisrKyBi L1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5jcHAKQEAgLTUwLDEyICs1MCwx NiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBib29sIERhdGFiYXNlT2JzZXJ2ZXI6OmNhbkVzdGFi bGlzaERhdGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWdu ZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQogewogICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250 ZXh0LT5pc0NvbnRleHRUaHJlYWQoKSk7Ci0gICAgLy8gRklYTUU6IGFkZCBzdXBwb3J0IGZvciB0 aGUgY2FzZSBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzV29ya2VyKCkgb25jZSB3b3JrZXJz IGltcGxlbWVudCB3ZWIgZGF0YWJhc2VzLgotICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250 ZXh0LT5pc0RvY3VtZW50KCkpOworICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5p c0RvY3VtZW50KCkgfHwgc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkp OwogICAgIGlmIChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkpIHsKICAgICAg ICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihzY3JpcHRFeGVj dXRpb25Db250ZXh0KTsKICAgICAgICAgV2ViRnJhbWVJbXBsKiB3ZWJGcmFtZSA9IFdlYkZyYW1l SW1wbDo6ZnJvbUZyYW1lKGRvY3VtZW50LT5mcmFtZSgpKTsKICAgICAgICAgcmV0dXJuIHdlYkZy YW1lLT5jbGllbnQoKS0+YWxsb3dEYXRhYmFzZSh3ZWJGcmFtZSwgbmFtZSwgZGlzcGxheU5hbWUs IGVzdGltYXRlZFNpemUpOworICAgIH0gZWxzZSB7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdv cmtlckNvbnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oc2NyaXB0RXhlY3V0aW9u Q29udGV4dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9 ICZ3b3JrZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAg V2ViV29ya2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdv cmtlckxvYWRlclByb3h5KTsKKyAgICAgICAgcmV0dXJuIHdlYldvcmtlci0+YWxsb3dEYXRhYmFz ZSgwLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSk7CiAgICAgfQogCiAgICAgcmV0 dXJuIHRydWU7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2Uu Y3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRleCAyYzRiNGY2 MzIzNDFhMmVlOGI4MmVjYjUxYWMxNzJjOGE1MDExOWI4Li40MWI0NjA0YmYwMTdkNzQzOWQ4YjJl Y2QzNGIyMzZmZTRjNzc2NTMyIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAK QEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXZWJXb3Jr ZXJCYXNlLmgiCiAKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKICNpbmNsdWRlICJHZW5lcmlj V29ya2VyVGFzay5oIgogI2luY2x1ZGUgIk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgogI2luY2x1ZGUg IlBsYXRmb3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCkBAIC00NCw2ICs0NSw3IEBACiAjaW5jbHVk ZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAi V29ya2VyU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2lu Y2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAKQEAgLTUzLDYgKzU1LDY3IEBAIG5hbWVzcGFjZSBX ZWJLaXQgewogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKK3N0YXRpYyBjb25zdCBjaGFyIGFsbG93 RGF0YWJhc2VNb2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworCituYW1lc3BhY2UgeworCisv LyBUaGlzIGNsYXNzIGlzIHVzZWQgdG8gcm91dGUgdGhlIHJlc3VsdCBvZiB0aGUgV2ViV29ya2Vy QmFzZTo6YWxsb3dEYXRhYmFzZQorLy8gY2FsbCBiYWNrIHRvIHRoZSB3b3JrZXIgY29udGV4dC4K K2NsYXNzIEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlIDogcHVibGljIFRocmVhZFNhZmVT aGFyZWQ8QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IHsKK3B1YmxpYzoKKyAgICBzdGF0 aWMgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gY3JlYXRlKFdlYldv cmtlckJhc2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBtb2RlLCBXZWJDb21tb25X b3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25zdCBXZWJDb3Jl OjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2ln bmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihu ZXcgQWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2Uod29ya2VyLCBtb2RlLCBjb21tb25DbGll bnQsIGZyYW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSkpOworICAgIH0KKwor ICAgIC8vIFRoZXNlIG1ldGhvZHMgYXJlIGludm9rZWQgb24gdGhlIHdvcmtlciBjb250ZXh0Lgor ICAgIHZvaWQgY2FuY2VsKCkKKyAgICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211 dGV4KTsKKyAgICAgICAgbV93b3JrZXIgPSAwOworICAgIH0KKworICAgIGJvb2wgcmVzdWx0KCkK KyAgICB7CisgICAgICAgIHJldHVybiBtX3Jlc3VsdDsKKyAgICB9CisKKyAgICAvLyBUaGlzIG1l dGhvZCBpcyBpbnZva2VkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAgICB2b2lkIHNpZ25hbENvbXBs ZXRlZChib29sIHJlc3VsdCkKKyAgICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211 dGV4KTsKKyAgICAgICAgaWYgKG1fd29ya2VyKQorICAgICAgICAgICAgbV93b3JrZXItPnBvc3RU YXNrRm9yTW9kZVRvV29ya2VyQ29udGV4dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZENvbXBsZXRl LCB0aGlzLCByZXN1bHQpLCBtX21vZGUpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBBbGxvd0Rh dGFiYXNlTWFpblRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0IFdlYkNv cmU6OlN0cmluZyYgbW9kZSwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdl YkZyYW1lKiBmcmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBuYW1lLCBjb25zdCBXZWJDb3Jl OjpTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCisgICAg ICAgIDogbV93b3JrZXIod29ya2VyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgIHsKKyAg ICAgICAgd29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNr KCZhbGxvd0RhdGFiYXNlVGFzaywgY29tbW9uQ2xpZW50LCBmcmFtZSwgU3RyaW5nKG5hbWUpLCBT dHJpbmcoZGlzcGxheU5hbWUpLCBlc3RpbWF0ZWRTaXplLCB0aGlzKSk7CisgICAgfQorCisgICAg c3RhdGljIHZvaWQgYWxsb3dEYXRhYmFzZVRhc2soV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY29udGV4dCwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZy YW1lKiBmcmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0 cmluZyBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBQYXNzUmVmUHRy PEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UpCisgICAgeworICAgICAgICBp ZiAoIWNvbW1vbkNsaWVudCkKKyAgICAgICAgICAgIGJyaWRnZS0+c2lnbmFsQ29tcGxldGVkKGZh bHNlKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgYnJpZGdlLT5zaWduYWxDb21wbGV0ZWQo Y29tbW9uQ2xpZW50LT5hbGxvd0RhdGFiYXNlKGZyYW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0 aW1hdGVkU2l6ZSkpOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIGRpZENvbXBsZXRlKFdlYkNv cmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8QWxsb3dEYXRh YmFzZU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSwgYm9vbCByZXN1bHQpCisgICAgeworICAgICAg ICBicmlkZ2UtPm1fcmVzdWx0ID0gcmVzdWx0OworICAgIH0KKworICAgIGJvb2wgbV9yZXN1bHQ7 CisgICAgTXV0ZXggbV9tdXRleDsKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBX ZWJDb3JlOjpTdHJpbmcgbV9tb2RlOworfTsKK30KKwogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxs ZWQgb24gdGhlIG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMK IC8vIHZhbHVlcyB1c2VkIGluIFdlYktpdCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWQgaXMgc3Rh cnRlZC4gVGhpcyBpcyBiZWNhdXNlIGluCiAvLyBvdXIgd29ya2VyIHByb2Nlc3NzLCB3ZSBkbyBu b3QgcnVuIGFueSBXZWJLaXQgY29kZSBpbiBtYWluIHRocmVhZCBhbmQgdGh1cwpAQCAtMTQ3LDYg KzIxMCwzMCBAQCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogV2ViV29ya2VyQmFzZTo6Y3JlYXRl QXBwbGljYXRpb25DYWNoZUhvc3QoV2ViRnJhbWUqLCBXZQogICAgIHJldHVybiAwOwogfQogCiti b29sIFdlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJp bmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0 aW1hdGVkU2l6ZSkKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0gbV93b3JrZXJUaHJl YWQtPnJ1bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBjb250cm9sbGVyID0g V29ya2VyU2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQoKTsKKyAgICAvLyBU aGUgY29udHJvbGxlciBtaWdodCBiZSAwIHdoZW4gdGhlIHdvcmtlciBjb250ZXh0IGlzIGluIHRo ZSBwcm9jZXNzIG9mIHNodXR0aW5nIGRvd24uCisgICAgaWYgKCFjb250cm9sbGVyKQorICAgICAg ICByZXR1cm4gZmFsc2U7CisgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29udGV4dCA9IGNvbnRy b2xsZXItPndvcmtlckNvbnRleHQoKTsKKworICAgIC8vIENyZWF0ZSBhIHVuaXF1ZSBtb2RlIGp1 c3QgZm9yIHRoaXMgc3luY2hyb25vdXMgY2FsbC4KKyAgICBTdHJpbmcgbW9kZSA9IGFsbG93RGF0 YWJhc2VNb2RlOworICAgIG1vZGUuYXBwZW5kKFN0cmluZzo6bnVtYmVyKHJ1bkxvb3AuY3JlYXRl VW5pcXVlSWQoKSkpOworCisgICAgUmVmUHRyPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdl PiBicmlkZ2UgPSBBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y3JlYXRlKHRoaXMsIG1v ZGUsIGNvbW1vbkNsaWVudCgpLCBtX3dlYlZpZXctPm1haW5GcmFtZSgpLCBTdHJpbmcobmFtZSks IFN0cmluZyhkaXNwbGF5TmFtZSksIGVzdGltYXRlZFNpemUpOworCisgICAgLy8gRWl0aGVyIHRo ZSBicmlkZ2UgcmV0dXJucywgb3IgdGhlIHF1ZXVlIGdldHMgdGVybWluYXRlZC4KKyAgICBpZiAo cnVuTG9vcC5ydW5Jbk1vZGUod29ya2VyQ29udGV4dCwgbW9kZSkgPT0gTWVzc2FnZVF1ZXVlVGVy bWluYXRlZCkgeworICAgICAgICBicmlkZ2UtPmNhbmNlbCgpOworICAgICAgICByZXR1cm4gZmFs c2U7CisgICAgfQorCisgICAgcmV0dXJuIGJyaWRnZS0+cmVzdWx0KCk7Cit9CisKIC8vIFdvcmtl ck9iamVjdFByb3h5IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCiAKIHZvaWQgV2ViV29ya2VyQmFzZTo6cG9zdE1lc3NhZ2VUb1dvcmtl ck9iamVjdChQYXNzUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4gbWVzc2FnZSwKZGlmZiAt LWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKaW5kZXggYTQ3MGVlNDY3ZDJmODYyOTg3OWQ5NWFmNGM3 NTkzMjQ5NTk3YmQ1NC4uMTVlODAxM2M5ZTU5NThiMjc2NWZjYTUxZTU1NzI5NTcwYzA1MmE2ZCAx MDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKKysrIGIvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmgKQEAgLTg4LDYgKzg4LDkgQEAgcHVibGlj OgogICAgIHZpcnR1YWwgdm9pZCBkaWRDcmVhdGVEYXRhU291cmNlKFdlYkZyYW1lKiwgV2ViRGF0 YVNvdXJjZSopOwogICAgIHZpcnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNyZWF0ZUFw cGxpY2F0aW9uQ2FjaGVIb3N0KFdlYkZyYW1lKiwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3RDbGll bnQqKTsKIAorICAgIC8vIENvbnRyb2xzIHdoZXRoZXIgYWNjZXNzIHRvIFdlYiBEYXRhYmFzZXMg aXMgYWxsb3dlZCBmb3IgdGhpcyB3b3JrZXIuCisgICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJh c2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlz cGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSk7CisKICAgICAvLyBFeGVjdXRl cyB0aGUgZ2l2ZW4gdGFzayBvbiB0aGUgbWFpbiB0aHJlYWQuCiAgICAgc3RhdGljIHZvaWQgZGlz cGF0Y2hUYXNrVG9NYWluVGhyZWFkKFBhc3NPd25QdHI8V2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9u Q29udGV4dDo6VGFzaz4pOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckNsaWVudEltcGwuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1w bC5oCmluZGV4IDkwNzQ5OWEyNjZhNjc2MmNmYmYyOWFjZDkzZDEwNTc0YTYwZjllZWIuLmRlYTVh Njc5ZmY2MjEzNmRkNjZmMDk1OTQ1ODg5NGMxMGJlZjdiMGMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oCkBAIC05NSw2ICs5NSwxMSBAQCBwdWJsaWM6CiAgICAg ICAgIHJldHVybiAwOwogICAgIH0KICAgICB2aXJ0dWFsIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0 KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVu dCopIHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFt ZSosIGNvbnN0IFdlYlN0cmluZyYgbmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwg dW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplKQorICAgIHsKKyAgICAgICAgQVNTRVJUX05PVF9S RUFDSEVEKCk7CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KIAogcHJpdmF0ZToKICAgICB2 aXJ0dWFsIH5XZWJXb3JrZXJDbGllbnRJbXBsKCk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9D aGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5kZXggOTZhNTk2NDcxZDk3MzVkOGU2 ZTE1MDllNTc5YWIwZWM1NzA5OTI3NS4uYmUyN2YzYjUyZjQwOTk4NzA1N2M1ZTA0ZDAwNDgyZjRi NWY0ZDFlOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRv b2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5n ZXIgIDxqb2NoZW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZCBhbGxvd0RhdGFiYXNlIG1ldGhvZCB0byBUZXN0V2ViV29y a2VyLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3 NDIKKworICAgICAgICBOZWVkIGEgc2hvcnQgZGVzY3JpcHRpb24gYW5kIGJ1ZyBVUkwgKE9PUFMh KQorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oOgor ICAgICAgICAoVGVzdFdlYldvcmtlcjo6YWxsb3dEYXRhYmFzZSk6CisKIDIwMTAtMDUtMTEgIENo cmlzIEplcmRvbmVrICA8Y2plcmRvbmVrQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9UZXN0V2ViV29ya2VyLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9jaHJv bWl1bS9UZXN0V2ViV29ya2VyLmgKaW5kZXggZjI4Y2MyMDU1ZDI1NzU0NDc4ZjA2MjJmM2I3MTY3 M2RmZmIzMDEwMi4uOTQ3MDgwNDBkNTBlNDEyMzkwYzU1YWI4OTU2NjM5YmU4YWRkNWUwOSAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtl ci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJXb3Jr ZXIuaApAQCAtODAsNiArODAsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBXZWJLaXQ6OldlYldv cmtlciogY3JlYXRlV29ya2VyKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50KikgeyByZXR1cm4gMDsg fQogICAgIHZpcnR1YWwgV2ViS2l0OjpXZWJOb3RpZmljYXRpb25QcmVzZW50ZXIqIG5vdGlmaWNh dGlvblByZXNlbnRlcigpIHsgcmV0dXJuIDA7IH0KICAgICB2aXJ0dWFsIFdlYktpdDo6V2ViQXBw bGljYXRpb25DYWNoZUhvc3QqIGNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdlYktpdDo6V2Vi QXBwbGljYXRpb25DYWNoZUhvc3RDbGllbnQqKSB7IHJldHVybiAwOyB9CisgICAgdmlydHVhbCBi b29sIGFsbG93RGF0YWJhc2UoV2ViS2l0OjpXZWJGcmFtZSosIGNvbnN0IFdlYktpdDo6V2ViU3Ry aW5nJiwgY29uc3QgV2ViS2l0OjpXZWJTdHJpbmcmLCB1bnNpZ25lZCBsb25nKSB7IHJldHVybiB0 cnVlOyB9CiAKIHByaXZhdGU6CiAgICAgflRlc3RXZWJXb3JrZXIoKSB7fQo= 56060 2010-05-14 00:46:46 -0700 2010-05-15 10:08:35 -0700 Patch bug-38742-20100514094644.patch text/plain 11484 jochen ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IDlkNmM5ZjZmYTZmZjBlOTQzMDYwMmFkNjJjY2Y4NzM2YjE4NjliZTcu LjFhNTViYjA4NzI4ZTAyNTNjNjAyNWU3NTJkOWQ4ZmUxY2RkYzliZjMgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI1IEBACisyMDEwLTA1LTA3ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEltcGxlbWVudCBjYW5Fc3RhYmxpc2hEYXRhYmFzZSBjYWxsIGZvciB3b3JrZXJzLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg3NDIKKworICAg ICAgICAqIHB1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaDoKKyAgICAgICAgKiBzcmMvRGF0 YWJhc2VPYnNlcnZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZU9ic2VydmVyOjpj YW5Fc3RhYmxpc2hEYXRhYmFzZSk6CisgICAgICAgICogc3JjL1dlYldvcmtlckJhc2UuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjphbGxvd0RhdGFiYXNlKToKKyAgICAgICAg KFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZVRhc2spOgorICAgICAgICAoV2Vi S2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6Y2FuY2VsKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OnJlc3VsdCk6 CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFk QnJpZGdlOjpzaWduYWxDb21wbGV0ZWQpOgorICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNl OjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZTo6ZGlkQ29tcGxldGUpOgorICAgICAgICAq IHNyYy9XZWJXb3JrZXJCYXNlLmg6CisgICAgICAgICogc3JjL1dlYldvcmtlckNsaWVudEltcGwu aDoKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQ2xpZW50SW1wbDo6YWxsb3dEYXRhYmFzZSk6 CisKIDIwMTAtMDUtMTMgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KIAogICAgICAg ICBSZXZpZXdlZCBieSBLZW50IFRhbXVyYS4KZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmggYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YkNvbW1vbldvcmtlckNsaWVudC5oCmluZGV4IDEzNjAzY2JjOTMxNTA4NTQzMDM5M2E4NGM3ZjY5 NWUxZTMwNWQyNTYuLmNlYTY0NzEyM2E1MmY1MDMyODUwODkwZGM4NDU1MmM0MTY0NGZmMmQgMTAw NjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50LmgK KysrIGIvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaApAQCAt MzUsNiArMzUsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViQXBwbGljYXRpb25D YWNoZUhvc3Q7CiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudDsKK2NsYXNzIFdl YkZyYW1lOwogY2xhc3MgV2ViTm90aWZpY2F0aW9uUHJlc2VudGVyOwogY2xhc3MgV2ViU3RyaW5n OwogY2xhc3MgV2ViV29ya2VyOwpAQCAtNzksNiArODAsOSBAQCBwdWJsaWM6CiAgICAgLy8gQ2Fs bGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgaW4gdGhlIHdvcmtlciBwcm9jZXNzIGR1cmlu ZyBpbml0aWFsaXphdGlvbi4KICAgICB2aXJ0dWFsIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBj cmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudCop ID0gMDsKIAorICAgIC8vIENhbGxlZCBvbiB0aGUgbWFpbiB3ZWJraXQgdGhyZWFkIGJlZm9yZSBv cGVuaW5nIGEgd2ViIGRhdGFiYXNlLgorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdl YkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlO YW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpID0gMDsKKwogcHJvdGVjdGVkOgogICAg IH5XZWJDb21tb25Xb3JrZXJDbGllbnQoKSB7IH0KIH07CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hy b21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9EYXRh YmFzZU9ic2VydmVyLmNwcAppbmRleCA2YTJlMmE3MGFjMDg0NDFhZGJiOGUyMmUwZTQ5MzU1NDc1 NTA3YzZjLi4xYzUxMTdjMGY1N2JkZmYxY2E1MWRjYzg3NzRhZjZiM2NkMjc5MTJiIDEwMDY0NAot LS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFiYXNlT2JzZXJ2ZXIuY3BwCisrKyBiL1dlYktp dC9jaHJvbWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5jcHAKQEAgLTUwLDEyICs1MCwxNiBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7CiBib29sIERhdGFiYXNlT2JzZXJ2ZXI6OmNhbkVzdGFibGlzaERh dGFiYXNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9u ZyBlc3RpbWF0ZWRTaXplKQogewogICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5p c0NvbnRleHRUaHJlYWQoKSk7Ci0gICAgLy8gRklYTUU6IGFkZCBzdXBwb3J0IGZvciB0aGUgY2Fz ZSBzY3JpcHRFeGVjdXRpb25Db250ZXh0KCktPmlzV29ya2VyKCkgb25jZSB3b3JrZXJzIGltcGxl bWVudCB3ZWIgZGF0YWJhc2VzLgotICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5p c0RvY3VtZW50KCkpOworICAgIEFTU0VSVChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3Vt ZW50KCkgfHwgc2NyaXB0RXhlY3V0aW9uQ29udGV4dC0+aXNXb3JrZXJDb250ZXh0KCkpOwogICAg IGlmIChzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc0RvY3VtZW50KCkpIHsKICAgICAgICAgRG9j dW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihzY3JpcHRFeGVjdXRpb25D b250ZXh0KTsKICAgICAgICAgV2ViRnJhbWVJbXBsKiB3ZWJGcmFtZSA9IFdlYkZyYW1lSW1wbDo6 ZnJvbUZyYW1lKGRvY3VtZW50LT5mcmFtZSgpKTsKICAgICAgICAgcmV0dXJuIHdlYkZyYW1lLT5j bGllbnQoKS0+YWxsb3dEYXRhYmFzZSh3ZWJGcmFtZSwgbmFtZSwgZGlzcGxheU5hbWUsIGVzdGlt YXRlZFNpemUpOworICAgIH0gZWxzZSB7CisgICAgICAgIFdvcmtlckNvbnRleHQqIHdvcmtlckNv bnRleHQgPSBzdGF0aWNfY2FzdDxXb3JrZXJDb250ZXh0Kj4oc2NyaXB0RXhlY3V0aW9uQ29udGV4 dCk7CisgICAgICAgIFdvcmtlckxvYWRlclByb3h5KiB3b3JrZXJMb2FkZXJQcm94eSA9ICZ3b3Jr ZXJDb250ZXh0LT50aHJlYWQoKS0+d29ya2VyTG9hZGVyUHJveHkoKTsKKyAgICAgICAgV2ViV29y a2VyQmFzZSogd2ViV29ya2VyID0gc3RhdGljX2Nhc3Q8V2ViV29ya2VyQmFzZSo+KHdvcmtlckxv YWRlclByb3h5KTsKKyAgICAgICAgcmV0dXJuIHdlYldvcmtlci0+YWxsb3dEYXRhYmFzZSgwLCBu YW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSk7CiAgICAgfQogCiAgICAgcmV0dXJuIHRy dWU7CmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwIGIv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcAppbmRleCAyYzRiNGY2MzIzNDFh MmVlOGI4MmVjYjUxYWMxNzJjOGE1MDExOWI4Li4xZmVkZWIyMzVhMDcyYzRhN2JkYTlmNWFkMzMz MTA1MTQ3ZTlkNTRlIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJh c2UuY3BwCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAKQEAgLTMx LDYgKzMxLDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJXZWJXb3JrZXJCYXNl LmgiCiAKKyNpbmNsdWRlICJEYXRhYmFzZVRhc2suaCIKICNpbmNsdWRlICJHZW5lcmljV29ya2Vy VGFzay5oIgogI2luY2x1ZGUgIk1lc3NhZ2VQb3J0Q2hhbm5lbC5oIgogI2luY2x1ZGUgIlBsYXRm b3JtTWVzc2FnZVBvcnRDaGFubmVsLmgiCkBAIC00NCw2ICs0NSw3IEBACiAjaW5jbHVkZSAiV2Vi Vmlldy5oIgogI2luY2x1ZGUgIldlYldvcmtlckNsaWVudC5oIgogCisjaW5jbHVkZSAiV29ya2Vy U2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIldvcmtlclRocmVhZC5oIgogI2luY2x1ZGUg PHd0Zi9NYWluVGhyZWFkLmg+CiAKQEAgLTUzLDYgKzU1LDY3IEBAIG5hbWVzcGFjZSBXZWJLaXQg ewogCiAjaWYgRU5BQkxFKFdPUktFUlMpCiAKK3N0YXRpYyBjb25zdCBjaGFyIGFsbG93RGF0YWJh c2VNb2RlW10gPSAiYWxsb3dEYXRhYmFzZU1vZGUiOworCituYW1lc3BhY2UgeworCisvLyBUaGlz IGNsYXNzIGlzIHVzZWQgdG8gcm91dGUgdGhlIHJlc3VsdCBvZiB0aGUgV2ViV29ya2VyQmFzZTo6 YWxsb3dEYXRhYmFzZQorLy8gY2FsbCBiYWNrIHRvIHRoZSB3b3JrZXIgY29udGV4dC4KK2NsYXNz IEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlIDogcHVibGljIFRocmVhZFNhZmVTaGFyZWQ8 QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFz c1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gY3JlYXRlKFdlYldvcmtlckJh c2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBtb2RlLCBXZWJDb21tb25Xb3JrZXJD bGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZyYW1lLCBjb25zdCBXZWJDb3JlOjpTdHJp bmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxv bmcgZXN0aW1hdGVkU2l6ZSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgQWxs b3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2Uod29ya2VyLCBtb2RlLCBjb21tb25DbGllbnQsIGZy YW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVkU2l6ZSkpOworICAgIH0KKworICAgIC8v IFRoZXNlIG1ldGhvZHMgYXJlIGludm9rZWQgb24gdGhlIHdvcmtlciBjb250ZXh0LgorICAgIHZv aWQgY2FuY2VsKCkKKyAgICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211dGV4KTsK KyAgICAgICAgbV93b3JrZXIgPSAwOworICAgIH0KKworICAgIGJvb2wgcmVzdWx0KCkKKyAgICB7 CisgICAgICAgIHJldHVybiBtX3Jlc3VsdDsKKyAgICB9CisKKyAgICAvLyBUaGlzIG1ldGhvZCBp cyBpbnZva2VkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAgICB2b2lkIHNpZ25hbENvbXBsZXRlZChi b29sIHJlc3VsdCkKKyAgICB7CisgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihtX211dGV4KTsK KyAgICAgICAgaWYgKG1fd29ya2VyKQorICAgICAgICAgICAgbV93b3JrZXItPnBvc3RUYXNrRm9y TW9kZVRvV29ya2VyQ29udGV4dChjcmVhdGVDYWxsYmFja1Rhc2soJmRpZENvbXBsZXRlLCB0aGlz LCByZXN1bHQpLCBtX21vZGUpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBBbGxvd0RhdGFiYXNl TWFpblRocmVhZEJyaWRnZShXZWJXb3JrZXJCYXNlKiB3b3JrZXIsIGNvbnN0IFdlYkNvcmU6OlN0 cmluZyYgbW9kZSwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZyYW1l KiBmcmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBuYW1lLCBjb25zdCBXZWJDb3JlOjpTdHJp bmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCisgICAgICAgIDog bV93b3JrZXIod29ya2VyKQorICAgICAgICAsIG1fbW9kZShtb2RlKQorICAgIHsKKyAgICAgICAg d29ya2VyLT5kaXNwYXRjaFRhc2tUb01haW5UaHJlYWQoY3JlYXRlQ2FsbGJhY2tUYXNrKCZhbGxv d0RhdGFiYXNlVGFzaywgY29tbW9uQ2xpZW50LCBmcmFtZSwgU3RyaW5nKG5hbWUpLCBTdHJpbmco ZGlzcGxheU5hbWUpLCBlc3RpbWF0ZWRTaXplLCB0aGlzKSk7CisgICAgfQorCisgICAgc3RhdGlj IHZvaWQgYWxsb3dEYXRhYmFzZVRhc2soV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29udGV4dCog Y29udGV4dCwgV2ViQ29tbW9uV29ya2VyQ2xpZW50KiBjb21tb25DbGllbnQsIFdlYkZyYW1lKiBm cmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmluZyBk aXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRTaXplLCBQYXNzUmVmUHRyPEFsbG93 RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBicmlkZ2UpCisgICAgeworICAgICAgICBpZiAoIWNv bW1vbkNsaWVudCkKKyAgICAgICAgICAgIGJyaWRnZS0+c2lnbmFsQ29tcGxldGVkKGZhbHNlKTsK KyAgICAgICAgZWxzZQorICAgICAgICAgICAgYnJpZGdlLT5zaWduYWxDb21wbGV0ZWQoY29tbW9u Q2xpZW50LT5hbGxvd0RhdGFiYXNlKGZyYW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1hdGVk U2l6ZSkpOworICAgIH0KKworICAgIHN0YXRpYyB2b2lkIGRpZENvbXBsZXRlKFdlYkNvcmU6OlNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIFBhc3NSZWZQdHI8QWxsb3dEYXRhYmFzZU1h aW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSwgYm9vbCByZXN1bHQpCisgICAgeworICAgICAgICBicmlk Z2UtPm1fcmVzdWx0ID0gcmVzdWx0OworICAgIH0KKworICAgIGJvb2wgbV9yZXN1bHQ7CisgICAg TXV0ZXggbV9tdXRleDsKKyAgICBXZWJXb3JrZXJCYXNlKiBtX3dvcmtlcjsKKyAgICBXZWJDb3Jl OjpTdHJpbmcgbV9tb2RlOworfTsKK30KKwogLy8gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgb24g dGhlIG1haW4gdGhyZWFkIHRvIGZvcmNlIHRvIGluaXRpYWxpemUgc29tZSBzdGF0aWMKIC8vIHZh bHVlcyB1c2VkIGluIFdlYktpdCBiZWZvcmUgYW55IHdvcmtlciB0aHJlYWQgaXMgc3RhcnRlZC4g VGhpcyBpcyBiZWNhdXNlIGluCiAvLyBvdXIgd29ya2VyIHByb2Nlc3NzLCB3ZSBkbyBub3QgcnVu IGFueSBXZWJLaXQgY29kZSBpbiBtYWluIHRocmVhZCBhbmQgdGh1cwpAQCAtMTQ3LDYgKzIxMCwy NyBAQCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogV2ViV29ya2VyQmFzZTo6Y3JlYXRlQXBwbGlj YXRpb25DYWNoZUhvc3QoV2ViRnJhbWUqLCBXZQogICAgIHJldHVybiAwOwogfQogCitib29sIFdl YldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5h bWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVk U2l6ZSkKK3sKKyAgICBXb3JrZXJSdW5Mb29wJiBydW5Mb29wID0gbV93b3JrZXJUaHJlYWQtPnJ1 bkxvb3AoKTsKKyAgICBXb3JrZXJTY3JpcHRDb250cm9sbGVyKiBjb250cm9sbGVyID0gV29ya2Vy U2NyaXB0Q29udHJvbGxlcjo6Y29udHJvbGxlckZvckNvbnRleHQoKTsKKyAgICBXb3JrZXJDb250 ZXh0KiB3b3JrZXJDb250ZXh0ID0gY29udHJvbGxlci0+d29ya2VyQ29udGV4dCgpOworCisgICAg Ly8gQ3JlYXRlIGEgdW5pcXVlIG1vZGUganVzdCBmb3IgdGhpcyBzeW5jaHJvbm91cyBjYWxsLgor ICAgIFN0cmluZyBtb2RlID0gYWxsb3dEYXRhYmFzZU1vZGU7CisgICAgbW9kZS5hcHBlbmQoU3Ry aW5nOjpudW1iZXIocnVuTG9vcC5jcmVhdGVVbmlxdWVJZCgpKSk7CisKKyAgICBSZWZQdHI8QWxs b3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSA9IEFsbG93RGF0YWJhc2VNYWluVGhy ZWFkQnJpZGdlOjpjcmVhdGUodGhpcywgbW9kZSwgY29tbW9uQ2xpZW50KCksIG1fd2ViVmlldy0+ bWFpbkZyYW1lKCksIFN0cmluZyhuYW1lKSwgU3RyaW5nKGRpc3BsYXlOYW1lKSwgZXN0aW1hdGVk U2l6ZSk7CisKKyAgICAvLyBFaXRoZXIgdGhlIGJyaWRnZSByZXR1cm5zLCBvciB0aGUgcXVldWUg Z2V0cyB0ZXJtaW5hdGVkLgorICAgIGlmIChydW5Mb29wLnJ1bkluTW9kZSh3b3JrZXJDb250ZXh0 LCBtb2RlKSA9PSBNZXNzYWdlUXVldWVUZXJtaW5hdGVkKSB7CisgICAgICAgIGJyaWRnZS0+Y2Fu Y2VsKCk7CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKKyAgICByZXR1cm4gYnJpZGdl LT5yZXN1bHQoKTsKK30KKwogLy8gV29ya2VyT2JqZWN0UHJveHkgLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAogdm9pZCBXZWJXb3Jr ZXJCYXNlOjpwb3N0TWVzc2FnZVRvV29ya2VyT2JqZWN0KFBhc3NSZWZQdHI8U2VyaWFsaXplZFNj cmlwdFZhbHVlPiBtZXNzYWdlLApkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJX b3JrZXJCYXNlLmggYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuaAppbmRleCBh NDcwZWU0NjdkMmY4NjI5ODc5ZDk1YWY0Yzc1OTMyNDk1OTdiZDU0Li4xNWU4MDEzYzllNTk1OGIy NzY1ZmNhNTFlNTU3Mjk1NzBjMDUyYTZkIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYldvcmtlckJhc2UuaAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2Uu aApAQCAtODgsNiArODgsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRpZENyZWF0ZURh dGFTb3VyY2UoV2ViRnJhbWUqLCBXZWJEYXRhU291cmNlKik7CiAgICAgdmlydHVhbCBXZWJBcHBs aWNhdGlvbkNhY2hlSG9zdCogY3JlYXRlQXBwbGljYXRpb25DYWNoZUhvc3QoV2ViRnJhbWUqLCBX ZWJBcHBsaWNhdGlvbkNhY2hlSG9zdENsaWVudCopOwogCisgICAgLy8gQ29udHJvbHMgd2hldGhl ciBhY2Nlc3MgdG8gV2ViIERhdGFiYXNlcyBpcyBhbGxvd2VkIGZvciB0aGlzIHdvcmtlci4KKyAg ICB2aXJ0dWFsIGJvb2wgYWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYg bmFtZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0 ZWRTaXplKTsKKwogICAgIC8vIEV4ZWN1dGVzIHRoZSBnaXZlbiB0YXNrIG9uIHRoZSBtYWluIHRo cmVhZC4KICAgICBzdGF0aWMgdm9pZCBkaXNwYXRjaFRhc2tUb01haW5UaHJlYWQoUGFzc093blB0 cjxXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpUYXNrPik7CiAKZGlmZiAtLWdpdCBh L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQ2xpZW50SW1wbC5oIGIvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKaW5kZXggOTA3NDk5YTI2NmE2NzYyY2ZiZjI5 YWNkOTNkMTA1NzRhNjBmOWVlYi4uZGVhNWE2NzlmZjYyMTM2ZGQ2NmYwOTU5NDU4ODk0YzEwYmVm N2IwYyAxMDA2NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBs LmgKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmgKQEAgLTk1 LDYgKzk1LDExIEBAIHB1YmxpYzoKICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogICAgIHZpcnR1 YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNyZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdl YkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50KikgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwg Ym9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBuYW1lLCBjb25z dCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUpCisg ICAgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgcmV0dXJuIHRydWU7 CisgICAgfQogCiBwcml2YXRlOgogICAgIHZpcnR1YWwgfldlYldvcmtlckNsaWVudEltcGwoKTsK ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBlODE2OGEzNmEwOGY3NjBjYTY5MjZlZDhkMDU5MWI4OTM2ZGNiNTc2Li45Y2FkMTlk MDk2NmY4M2U2OTlmNWU3ZmQzZDFmMTNlNGY3Y2EzNjhhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAK KzIwMTAtMDUtMDcgIEpvY2hlbiBFaXNpbmdlciAgPGpvY2hlbkBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGFsbG93RGF0 YWJhc2UgbWV0aG9kIHRvIFRlc3RXZWJXb3JrZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODc0MgorCisgICAgICAgIE5lZWQgYSBzaG9ydCBkZXNj cmlwdGlvbiBhbmQgYnVnIFVSTCAoT09QUyEpCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9UZXN0V2ViV29ya2VyLmg6CisgICAgICAgIChUZXN0V2ViV29ya2VyOjphbGxvd0Rh dGFiYXNlKToKKwogMjAxMC0wNS0xMyAgRGllZ28gR29uemFsZXogIDxkaWVnb2hjZ0B3ZWJraXQu b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuLgpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldv cmtlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtl ci5oCmluZGV4IGYyOGNjMjA1NWQyNTc1NDQ3OGYwNjIyZjNiNzE2NzNkZmZiMzAxMDIuLjk0NzA4 MDQwZDUwZTQxMjM5MGM1NWFiODk1NjYzOWJlOGFkZDVlMDkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJXb3JrZXIuaAorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9UZXN0V2ViV29ya2VyLmgKQEAgLTgwLDYgKzgw LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgV2ViS2l0OjpXZWJXb3JrZXIqIGNyZWF0ZVdvcmtl cihXZWJLaXQ6OldlYldvcmtlckNsaWVudCopIHsgcmV0dXJuIDA7IH0KICAgICB2aXJ0dWFsIFdl YktpdDo6V2ViTm90aWZpY2F0aW9uUHJlc2VudGVyKiBub3RpZmljYXRpb25QcmVzZW50ZXIoKSB7 IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBXZWJLaXQ6OldlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0 KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJLaXQ6OldlYkFwcGxpY2F0aW9uQ2FjaGVI b3N0Q2xpZW50KikgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNl KFdlYktpdDo6V2ViRnJhbWUqLCBjb25zdCBXZWJLaXQ6OldlYlN0cmluZyYsIGNvbnN0IFdlYktp dDo6V2ViU3RyaW5nJiwgdW5zaWduZWQgbG9uZykgeyByZXR1cm4gdHJ1ZTsgfQogCiBwcml2YXRl OgogICAgIH5UZXN0V2ViV29ya2VyKCkge30K 56158 2010-05-15 10:08:44 -0700 2010-05-15 15:29:53 -0700 Patch for landing bug-38742-20100515100842.patch text/plain 11409 abarth ZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9XZWJLaXQvY2hyb21pdW0v Q2hhbmdlTG9nCmluZGV4IGFlZTJkNjY0YWUyZjhjODQ5MTJhOGRjZTRjYTIzZGM4MmY4OTg4OTUu LjBlNzlhMTZlYTc5OTY0N2Y5NzJlZDg3MGU0NzAyNjc1M2Q1ZjA0NTIgMTAwNjQ0Ci0tLSBhL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI1IEBACisyMDEwLTA1LTE1ICBKb2NoZW4gRWlzaW5nZXIgIDxqb2NoZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IERtaXRyeSBUaXRvdi4KKworICAgICAg ICBJbXBsZW1lbnQgY2FuRXN0YWJsaXNoRGF0YWJhc2UgY2FsbCBmb3Igd29ya2Vycy4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4NzQyCisKKyAgICAg ICAgKiBwdWJsaWMvV2ViQ29tbW9uV29ya2VyQ2xpZW50Lmg6CisgICAgICAgICogc3JjL0RhdGFi YXNlT2JzZXJ2ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2VPYnNlcnZlcjo6Y2Fu RXN0YWJsaXNoRGF0YWJhc2UpOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJCYXNlLmNwcDoKKyAg ICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZSk6CisgICAgICAgIChX ZWJLaXQ6OldlYldvcmtlckJhc2U6OmFsbG93RGF0YWJhc2VUYXNrKToKKyAgICAgICAgKFdlYktp dDo6V2ViV29ya2VyQmFzZTo6QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OkFsbG93RGF0 YWJhc2VNYWluVGhyZWFkQnJpZGdlKToKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6 QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmNhbmNlbCk6CisgICAgICAgIChXZWJLaXQ6 OldlYldvcmtlckJhc2U6OkFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlOjpyZXN1bHQpOgor ICAgICAgICAoV2ViS2l0OjpXZWJXb3JrZXJCYXNlOjpBbGxvd0RhdGFiYXNlTWFpblRocmVhZEJy aWRnZTo6c2lnbmFsQ29tcGxldGVkKToKKyAgICAgICAgKFdlYktpdDo6V2ViV29ya2VyQmFzZTo6 QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U6OmRpZENvbXBsZXRlKToKKyAgICAgICAgKiBz cmMvV2ViV29ya2VyQmFzZS5oOgorICAgICAgICAqIHNyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmg6 CisgICAgICAgIChXZWJLaXQ6OldlYldvcmtlckNsaWVudEltcGw6OmFsbG93RGF0YWJhc2UpOgor CiAyMDEwLTA1LTE1ICBFdmFuIFN0YWRlICA8ZXN0YWRlQGNocm9taXVtLm9yZz4KIAogICAgICAg ICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2Nocm9taXVtL3B1 YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaCBiL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi Q29tbW9uV29ya2VyQ2xpZW50LmgKaW5kZXggMTM2MDNjYmM5MzE1MDg1NDMwMzkzYTg0YzdmNjk1 ZTFlMzA1ZDI1Ni4uY2VhNjQ3MTIzYTUyZjUwMzI4NTA4OTBkYzg0NTUyYzQxNjQ0ZmYyZCAxMDA2 NDQKLS0tIGEvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJDb21tb25Xb3JrZXJDbGllbnQuaAor KysgYi9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkNvbW1vbldvcmtlckNsaWVudC5oCkBAIC0z NSw2ICszNSw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBXZWJBcHBsaWNhdGlvbkNh Y2hlSG9zdDsKIGNsYXNzIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50OworY2xhc3MgV2Vi RnJhbWU7CiBjbGFzcyBXZWJOb3RpZmljYXRpb25QcmVzZW50ZXI7CiBjbGFzcyBXZWJTdHJpbmc7 CiBjbGFzcyBXZWJXb3JrZXI7CkBAIC03OSw2ICs4MCw5IEBAIHB1YmxpYzoKICAgICAvLyBDYWxs ZWQgb24gdGhlIG1haW4gd2Via2l0IHRocmVhZCBpbiB0aGUgd29ya2VyIHByb2Nlc3MgZHVyaW5n IGluaXRpYWxpemF0aW9uLgogICAgIHZpcnR1YWwgV2ViQXBwbGljYXRpb25DYWNoZUhvc3QqIGNy ZWF0ZUFwcGxpY2F0aW9uQ2FjaGVIb3N0KFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50Kikg PSAwOwogCisgICAgLy8gQ2FsbGVkIG9uIHRoZSBtYWluIHdlYmtpdCB0aHJlYWQgYmVmb3JlIG9w ZW5pbmcgYSB3ZWIgZGF0YWJhc2UuCisgICAgdmlydHVhbCBib29sIGFsbG93RGF0YWJhc2UoV2Vi RnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYlN0cmluZyYgZGlzcGxheU5h bWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkgPSAwOworCiBwcm90ZWN0ZWQ6CiAgICAg fldlYkNvbW1vbldvcmtlckNsaWVudCgpIHsgfQogfTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJv bWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5jcHAgYi9XZWJLaXQvY2hyb21pdW0vc3JjL0RhdGFi YXNlT2JzZXJ2ZXIuY3BwCmluZGV4IDZhMmUyYTcwYWMwODQ0MWFkYmI4ZTIyZTBlNDkzNTU0NzU1 MDdjNmMuLjFjNTExN2MwZjU3YmRmZjFjYTUxZGNjODc3NGFmNmIzY2QyNzkxMmIgMTAwNjQ0Ci0t LSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvRGF0YWJhc2VPYnNlcnZlci5jcHAKKysrIGIvV2ViS2l0 L2Nocm9taXVtL3NyYy9EYXRhYmFzZU9ic2VydmVyLmNwcApAQCAtNTAsMTIgKzUwLDE2IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKIGJvb2wgRGF0YWJhc2VPYnNlcnZlcjo6Y2FuRXN0YWJsaXNoRGF0 YWJhc2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogc2NyaXB0RXhlY3V0aW9uQ29udGV4dCwgY29u c3QgU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25n IGVzdGltYXRlZFNpemUpCiB7CiAgICAgQVNTRVJUKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlz Q29udGV4dFRocmVhZCgpKTsKLSAgICAvLyBGSVhNRTogYWRkIHN1cHBvcnQgZm9yIHRoZSBjYXNl IHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKS0+aXNXb3JrZXIoKSBvbmNlIHdvcmtlcnMgaW1wbGVt ZW50IHdlYiBkYXRhYmFzZXMuCi0gICAgQVNTRVJUKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlz RG9jdW1lbnQoKSk7CisgICAgQVNTRVJUKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlzRG9jdW1l bnQoKSB8fCBzY3JpcHRFeGVjdXRpb25Db250ZXh0LT5pc1dvcmtlckNvbnRleHQoKSk7CiAgICAg aWYgKHNjcmlwdEV4ZWN1dGlvbkNvbnRleHQtPmlzRG9jdW1lbnQoKSkgewogICAgICAgICBEb2N1 bWVudCogZG9jdW1lbnQgPSBzdGF0aWNfY2FzdDxEb2N1bWVudCo+KHNjcmlwdEV4ZWN1dGlvbkNv bnRleHQpOwogICAgICAgICBXZWJGcmFtZUltcGwqIHdlYkZyYW1lID0gV2ViRnJhbWVJbXBsOjpm cm9tRnJhbWUoZG9jdW1lbnQtPmZyYW1lKCkpOwogICAgICAgICByZXR1cm4gd2ViRnJhbWUtPmNs aWVudCgpLT5hbGxvd0RhdGFiYXNlKHdlYkZyYW1lLCBuYW1lLCBkaXNwbGF5TmFtZSwgZXN0aW1h dGVkU2l6ZSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgV29ya2VyQ29udGV4dCogd29ya2VyQ29u dGV4dCA9IHN0YXRpY19jYXN0PFdvcmtlckNvbnRleHQqPihzY3JpcHRFeGVjdXRpb25Db250ZXh0 KTsKKyAgICAgICAgV29ya2VyTG9hZGVyUHJveHkqIHdvcmtlckxvYWRlclByb3h5ID0gJndvcmtl ckNvbnRleHQtPnRocmVhZCgpLT53b3JrZXJMb2FkZXJQcm94eSgpOworICAgICAgICBXZWJXb3Jr ZXJCYXNlKiB3ZWJXb3JrZXIgPSBzdGF0aWNfY2FzdDxXZWJXb3JrZXJCYXNlKj4od29ya2VyTG9h ZGVyUHJveHkpOworICAgICAgICByZXR1cm4gd2ViV29ya2VyLT5hbGxvd0RhdGFiYXNlKDAsIG5h bWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKTsKICAgICB9CiAKICAgICByZXR1cm4gdHJ1 ZTsKZGlmZiAtLWdpdCBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5jcHAgYi9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckJhc2UuY3BwCmluZGV4IDJjNGI0ZjYzMjM0MWEy ZWU4YjgyZWNiNTFhYzE3MmM4YTUwMTE5YjguLjFmZWRlYjIzNWEwNzJjNGE3YmRhOWY1YWQzMzMx MDUxNDdlOWQ1NGUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFz ZS5jcHAKKysrIGIvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJCYXNlLmNwcApAQCAtMzEs NiArMzEsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIldlYldvcmtlckJhc2Uu aCIKIAorI2luY2x1ZGUgIkRhdGFiYXNlVGFzay5oIgogI2luY2x1ZGUgIkdlbmVyaWNXb3JrZXJU YXNrLmgiCiAjaW5jbHVkZSAiTWVzc2FnZVBvcnRDaGFubmVsLmgiCiAjaW5jbHVkZSAiUGxhdGZv cm1NZXNzYWdlUG9ydENoYW5uZWwuaCIKQEAgLTQ0LDYgKzQ1LDcgQEAKICNpbmNsdWRlICJXZWJW aWV3LmgiCiAjaW5jbHVkZSAiV2ViV29ya2VyQ2xpZW50LmgiCiAKKyNpbmNsdWRlICJXb3JrZXJT Y3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAiV29ya2VyVGhyZWFkLmgiCiAjaW5jbHVkZSA8 d3RmL01haW5UaHJlYWQuaD4KIApAQCAtNTMsNiArNTUsNjcgQEAgbmFtZXNwYWNlIFdlYktpdCB7 CiAKICNpZiBFTkFCTEUoV09SS0VSUykKIAorc3RhdGljIGNvbnN0IGNoYXIgYWxsb3dEYXRhYmFz ZU1vZGVbXSA9ICJhbGxvd0RhdGFiYXNlTW9kZSI7CisKK25hbWVzcGFjZSB7CisKKy8vIFRoaXMg Y2xhc3MgaXMgdXNlZCB0byByb3V0ZSB0aGUgcmVzdWx0IG9mIHRoZSBXZWJXb3JrZXJCYXNlOjph bGxvd0RhdGFiYXNlCisvLyBjYWxsIGJhY2sgdG8gdGhlIHdvcmtlciBjb250ZXh0LgorY2xhc3Mg QWxsb3dEYXRhYmFzZU1haW5UaHJlYWRCcmlkZ2UgOiBwdWJsaWMgVGhyZWFkU2FmZVNoYXJlZDxB bGxvd0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4geworcHVibGljOgorICAgIHN0YXRpYyBQYXNz UmVmUHRyPEFsbG93RGF0YWJhc2VNYWluVGhyZWFkQnJpZGdlPiBjcmVhdGUoV2ViV29ya2VyQmFz ZSogd29ya2VyLCBjb25zdCBXZWJDb3JlOjpTdHJpbmcmIG1vZGUsIFdlYkNvbW1vbldvcmtlckNs aWVudCogY29tbW9uQ2xpZW50LCBXZWJGcmFtZSogZnJhbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmlu ZyYgbmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9u ZyBlc3RpbWF0ZWRTaXplKQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBBbGxv d0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZSh3b3JrZXIsIG1vZGUsIGNvbW1vbkNsaWVudCwgZnJh bWUsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRTaXplKSk7CisgICAgfQorCisgICAgLy8g VGhlc2UgbWV0aG9kcyBhcmUgaW52b2tlZCBvbiB0aGUgd29ya2VyIGNvbnRleHQuCisgICAgdm9p ZCBjYW5jZWwoKQorICAgIHsKKyAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOwor ICAgICAgICBtX3dvcmtlciA9IDA7CisgICAgfQorCisgICAgYm9vbCByZXN1bHQoKQorICAgIHsK KyAgICAgICAgcmV0dXJuIG1fcmVzdWx0OworICAgIH0KKworICAgIC8vIFRoaXMgbWV0aG9kIGlz IGludm9rZWQgb24gdGhlIG1haW4gdGhyZWFkLgorICAgIHZvaWQgc2lnbmFsQ29tcGxldGVkKGJv b2wgcmVzdWx0KQorICAgIHsKKyAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2VyKG1fbXV0ZXgpOwor ICAgICAgICBpZiAobV93b3JrZXIpCisgICAgICAgICAgICBtX3dvcmtlci0+cG9zdFRhc2tGb3JN b2RlVG9Xb3JrZXJDb250ZXh0KGNyZWF0ZUNhbGxiYWNrVGFzaygmZGlkQ29tcGxldGUsIHRoaXMs IHJlc3VsdCksIG1fbW9kZSk7CisgICAgfQorCitwcml2YXRlOgorICAgIEFsbG93RGF0YWJhc2VN YWluVGhyZWFkQnJpZGdlKFdlYldvcmtlckJhc2UqIHdvcmtlciwgY29uc3QgV2ViQ29yZTo6U3Ry aW5nJiBtb2RlLCBXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUq IGZyYW1lLCBjb25zdCBXZWJDb3JlOjpTdHJpbmcmIG5hbWUsIGNvbnN0IFdlYkNvcmU6OlN0cmlu ZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKKyAgICAgICAgOiBt X3dvcmtlcih3b3JrZXIpCisgICAgICAgICwgbV9tb2RlKG1vZGUpCisgICAgeworICAgICAgICB3 b3JrZXItPmRpc3BhdGNoVGFza1RvTWFpblRocmVhZChjcmVhdGVDYWxsYmFja1Rhc2soJmFsbG93 RGF0YWJhc2VUYXNrLCBjb21tb25DbGllbnQsIGZyYW1lLCBTdHJpbmcobmFtZSksIFN0cmluZyhk aXNwbGF5TmFtZSksIGVzdGltYXRlZFNpemUsIHRoaXMpKTsKKyAgICB9CisKKyAgICBzdGF0aWMg dm9pZCBhbGxvd0RhdGFiYXNlVGFzayhXZWJDb3JlOjpTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBj b250ZXh0LCBXZWJDb21tb25Xb3JrZXJDbGllbnQqIGNvbW1vbkNsaWVudCwgV2ViRnJhbWUqIGZy YW1lLCBjb25zdCBXZWJDb3JlOjpTdHJpbmcgbmFtZSwgY29uc3QgV2ViQ29yZTo6U3RyaW5nIGRp c3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRlZFNpemUsIFBhc3NSZWZQdHI8QWxsb3dE YXRhYmFzZU1haW5UaHJlYWRCcmlkZ2U+IGJyaWRnZSkKKyAgICB7CisgICAgICAgIGlmICghY29t bW9uQ2xpZW50KQorICAgICAgICAgICAgYnJpZGdlLT5zaWduYWxDb21wbGV0ZWQoZmFsc2UpOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBicmlkZ2UtPnNpZ25hbENvbXBsZXRlZChjb21tb25D bGllbnQtPmFsbG93RGF0YWJhc2UoZnJhbWUsIG5hbWUsIGRpc3BsYXlOYW1lLCBlc3RpbWF0ZWRT aXplKSk7CisgICAgfQorCisgICAgc3RhdGljIHZvaWQgZGlkQ29tcGxldGUoV2ViQ29yZTo6U2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgUGFzc1JlZlB0cjxBbGxvd0RhdGFiYXNlTWFp blRocmVhZEJyaWRnZT4gYnJpZGdlLCBib29sIHJlc3VsdCkKKyAgICB7CisgICAgICAgIGJyaWRn ZS0+bV9yZXN1bHQgPSByZXN1bHQ7CisgICAgfQorCisgICAgYm9vbCBtX3Jlc3VsdDsKKyAgICBN dXRleCBtX211dGV4OworICAgIFdlYldvcmtlckJhc2UqIG1fd29ya2VyOworICAgIFdlYkNvcmU6 OlN0cmluZyBtX21vZGU7Cit9OworfQorCiAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBvbiB0 aGUgbWFpbiB0aHJlYWQgdG8gZm9yY2UgdG8gaW5pdGlhbGl6ZSBzb21lIHN0YXRpYwogLy8gdmFs dWVzIHVzZWQgaW4gV2ViS2l0IGJlZm9yZSBhbnkgd29ya2VyIHRocmVhZCBpcyBzdGFydGVkLiBU aGlzIGlzIGJlY2F1c2UgaW4KIC8vIG91ciB3b3JrZXIgcHJvY2Vzc3MsIHdlIGRvIG5vdCBydW4g YW55IFdlYktpdCBjb2RlIGluIG1haW4gdGhyZWFkIGFuZCB0aHVzCkBAIC0xNDcsNiArMjEwLDI3 IEBAIFdlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBXZWJXb3JrZXJCYXNlOjpjcmVhdGVBcHBsaWNh dGlvbkNhY2hlSG9zdChXZWJGcmFtZSosIFdlCiAgICAgcmV0dXJuIDA7CiB9CiAKK2Jvb2wgV2Vi V29ya2VyQmFzZTo6YWxsb3dEYXRhYmFzZShXZWJGcmFtZSosIGNvbnN0IFdlYlN0cmluZyYgbmFt ZSwgY29uc3QgV2ViU3RyaW5nJiBkaXNwbGF5TmFtZSwgdW5zaWduZWQgbG9uZyBlc3RpbWF0ZWRT aXplKQoreworICAgIFdvcmtlclJ1bkxvb3AmIHJ1bkxvb3AgPSBtX3dvcmtlclRocmVhZC0+cnVu TG9vcCgpOworICAgIFdvcmtlclNjcmlwdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSBXb3JrZXJT Y3JpcHRDb250cm9sbGVyOjpjb250cm9sbGVyRm9yQ29udGV4dCgpOworICAgIFdvcmtlckNvbnRl eHQqIHdvcmtlckNvbnRleHQgPSBjb250cm9sbGVyLT53b3JrZXJDb250ZXh0KCk7CisKKyAgICAv LyBDcmVhdGUgYSB1bmlxdWUgbW9kZSBqdXN0IGZvciB0aGlzIHN5bmNocm9ub3VzIGNhbGwuCisg ICAgU3RyaW5nIG1vZGUgPSBhbGxvd0RhdGFiYXNlTW9kZTsKKyAgICBtb2RlLmFwcGVuZChTdHJp bmc6Om51bWJlcihydW5Mb29wLmNyZWF0ZVVuaXF1ZUlkKCkpKTsKKworICAgIFJlZlB0cjxBbGxv d0RhdGFiYXNlTWFpblRocmVhZEJyaWRnZT4gYnJpZGdlID0gQWxsb3dEYXRhYmFzZU1haW5UaHJl YWRCcmlkZ2U6OmNyZWF0ZSh0aGlzLCBtb2RlLCBjb21tb25DbGllbnQoKSwgbV93ZWJWaWV3LT5t YWluRnJhbWUoKSwgU3RyaW5nKG5hbWUpLCBTdHJpbmcoZGlzcGxheU5hbWUpLCBlc3RpbWF0ZWRT aXplKTsKKworICAgIC8vIEVpdGhlciB0aGUgYnJpZGdlIHJldHVybnMsIG9yIHRoZSBxdWV1ZSBn ZXRzIHRlcm1pbmF0ZWQuCisgICAgaWYgKHJ1bkxvb3AucnVuSW5Nb2RlKHdvcmtlckNvbnRleHQs IG1vZGUpID09IE1lc3NhZ2VRdWV1ZVRlcm1pbmF0ZWQpIHsKKyAgICAgICAgYnJpZGdlLT5jYW5j ZWwoKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIHJldHVybiBicmlkZ2Ut PnJlc3VsdCgpOworfQorCiAvLyBXb3JrZXJPYmplY3RQcm94eSAtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiB2b2lkIFdlYldvcmtl ckJhc2U6OnBvc3RNZXNzYWdlVG9Xb3JrZXJPYmplY3QoUGFzc1JlZlB0cjxTZXJpYWxpemVkU2Ny aXB0VmFsdWU+IG1lc3NhZ2UsCmRpZmYgLS1naXQgYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldv cmtlckJhc2UuaCBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5oCmluZGV4IGE0 NzBlZTQ2N2QyZjg2Mjk4NzlkOTVhZjRjNzU5MzI0OTU5N2JkNTQuLjE1ZTgwMTNjOWU1OTU4YjI3 NjVmY2E1MWU1NTcyOTU3MGMwNTJhNmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViV29ya2VyQmFzZS5oCisrKyBiL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViV29ya2VyQmFzZS5o CkBAIC04OCw2ICs4OCw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ3JlYXRlRGF0 YVNvdXJjZShXZWJGcmFtZSosIFdlYkRhdGFTb3VyY2UqKTsKICAgICB2aXJ0dWFsIFdlYkFwcGxp Y2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlvbkNhY2hlSG9zdChXZWJGcmFtZSosIFdl YkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50Kik7CiAKKyAgICAvLyBDb250cm9scyB3aGV0aGVy IGFjY2VzcyB0byBXZWIgRGF0YWJhc2VzIGlzIGFsbG93ZWQgZm9yIHRoaXMgd29ya2VyLgorICAg IHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYkZyYW1lKiwgY29uc3QgV2ViU3RyaW5nJiBu YW1lLCBjb25zdCBXZWJTdHJpbmcmIGRpc3BsYXlOYW1lLCB1bnNpZ25lZCBsb25nIGVzdGltYXRl ZFNpemUpOworCiAgICAgLy8gRXhlY3V0ZXMgdGhlIGdpdmVuIHRhc2sgb24gdGhlIG1haW4gdGhy ZWFkLgogICAgIHN0YXRpYyB2b2lkIGRpc3BhdGNoVGFza1RvTWFpblRocmVhZChQYXNzT3duUHRy PFdlYkNvcmU6OlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OlRhc2s+KTsKIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJXb3JrZXJDbGllbnRJbXBsLmggYi9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaAppbmRleCA2MDk4M2JlMWJjYWM1OGFjZTQzY2Jj M2E2MjAzMjI3MzE5M2M2OTFiLi43NThjMzc2MTM4ZDNiY2M2OWRiYjFkNjJmNjZiOTgzMDFkYWFi ZTdhIDEwMDY0NAotLS0gYS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwu aAorKysgYi9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYldvcmtlckNsaWVudEltcGwuaApAQCAtOTQs NiArOTQsMTEgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gMDsKICAgICB9CiAgICAgdmlydHVh bCBXZWJBcHBsaWNhdGlvbkNhY2hlSG9zdCogY3JlYXRlQXBwbGljYXRpb25DYWNoZUhvc3QoV2Vi QXBwbGljYXRpb25DYWNoZUhvc3RDbGllbnQqKSB7IHJldHVybiAwOyB9CisgICAgdmlydHVhbCBi b29sIGFsbG93RGF0YWJhc2UoV2ViRnJhbWUqLCBjb25zdCBXZWJTdHJpbmcmIG5hbWUsIGNvbnN0 IFdlYlN0cmluZyYgZGlzcGxheU5hbWUsIHVuc2lnbmVkIGxvbmcgZXN0aW1hdGVkU2l6ZSkKKyAg ICB7CisgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICByZXR1cm4gdHJ1ZTsK KyAgICB9CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCB+V2ViV29ya2VyQ2xpZW50SW1wbCgpOwpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9n CmluZGV4IGM2YTA3YjljYWIwOTNkNTE3MmFlNDQ5ZDI5Y2Q3ZmI0NmZhY2M1ZmMuLjY1YTNlYzAy ODc1NDJmZGQ4YjI4OTE2NGUxZDczOGQzNzYyNjhhOGUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAor MjAxMC0wNS0xNSAgSm9jaGVuIEVpc2luZ2VyICA8am9jaGVuQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBEbWl0cnkgVGl0b3YuCisKKyAgICAgICAgQWRkIGFsbG93RGF0YWJh c2UgbWV0aG9kIHRvIFRlc3RXZWJXb3JrZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0zODc0MgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hy b21pdW0vVGVzdFdlYldvcmtlci5oOgorICAgICAgICAoVGVzdFdlYldvcmtlcjo6YWxsb3dEYXRh YmFzZSk6CisKIDIwMTAtMDUtMTUgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IE1hY2llaiBTdGFjaG93aWFrLgpkaWZmIC0tZ2l0IGEvV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oIGIvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYldvcmtlci5oCmluZGV4IGYyOGNjMjA1 NWQyNTc1NDQ3OGYwNjIyZjNiNzE2NzNkZmZiMzAxMDIuLjk0NzA4MDQwZDUwZTQxMjM5MGM1NWFi ODk1NjYzOWJlOGFkZDVlMDkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L2Nocm9taXVtL1Rlc3RXZWJXb3JrZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9UZXN0V2ViV29ya2VyLmgKQEAgLTgwLDYgKzgwLDcgQEAgcHVibGljOgogICAg IHZpcnR1YWwgV2ViS2l0OjpXZWJXb3JrZXIqIGNyZWF0ZVdvcmtlcihXZWJLaXQ6OldlYldvcmtl ckNsaWVudCopIHsgcmV0dXJuIDA7IH0KICAgICB2aXJ0dWFsIFdlYktpdDo6V2ViTm90aWZpY2F0 aW9uUHJlc2VudGVyKiBub3RpZmljYXRpb25QcmVzZW50ZXIoKSB7IHJldHVybiAwOyB9CiAgICAg dmlydHVhbCBXZWJLaXQ6OldlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0KiBjcmVhdGVBcHBsaWNhdGlv bkNhY2hlSG9zdChXZWJLaXQ6OldlYkFwcGxpY2F0aW9uQ2FjaGVIb3N0Q2xpZW50KikgeyByZXR1 cm4gMDsgfQorICAgIHZpcnR1YWwgYm9vbCBhbGxvd0RhdGFiYXNlKFdlYktpdDo6V2ViRnJhbWUq LCBjb25zdCBXZWJLaXQ6OldlYlN0cmluZyYsIGNvbnN0IFdlYktpdDo6V2ViU3RyaW5nJiwgdW5z aWduZWQgbG9uZykgeyByZXR1cm4gdHJ1ZTsgfQogCiBwcml2YXRlOgogICAgIH5UZXN0V2ViV29y a2VyKCkge30K