32068 2009-12-02 06:58:45 -0800 Implement Chromium Geolocation Sevice (GeolocationServiceChromium) 2010-03-24 09:14:19 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 32065 1 joth bulach bulach commit-queue jorlow joth oldest_to_newest 167977 0 joth 2009-12-02 06:58:45 -0800 A working implementation of GeolocationService is required as part of https://bugs.webkit.org/show_bug.cgi?id=32065 186410 1 47840 bulach 2010-02-01 07:25:05 -0800 Created attachment 47840 WebCore bits (note: this is not yet for formal review, rather a pre-design review. counterpart in chromium: http://codereview.chromium.org/548188/show) 186411 2 47841 bulach 2010-02-01 07:26:13 -0800 Created attachment 47841 WebKit bits (same notes as previous attachment..) 186416 3 joth 2010-02-01 07:38:56 -0800 assigning to marcus.. 189801 4 48591 bulach 2010-02-11 14:33:10 -0800 Created attachment 48591 WebCore bits jorlow, would you please take a look at this? 189803 5 48592 bulach 2010-02-11 14:33:40 -0800 Created attachment 48592 WebKit bits 189998 6 48592 jorlow 2010-02-12 03:07:18 -0800 Comment on attachment 48592 WebKit bits Please do not separate the WebCore and WebKit bits. You'll need to edit your .gclient file to make this work. Normally you set the review flag to ? when you're ready for a review. > Index: WebKit.gyp > =================================================================== > --- WebKit.gyp (revision 54653) > +++ WebKit.gyp (working copy) > @@ -68,6 +68,7 @@ > 'WEBKIT_IMPLEMENTATION', > ], > 'sources': [ > + 'public/GeolocationServiceBridge.h', > 'public/gtk/WebInputEventFactory.h', > 'public/linux/WebFontRendering.h', > 'public/linux/WebRenderTheme.h', > @@ -231,6 +232,7 @@ > 'src/EventListenerWrapper.h', > 'src/FrameLoaderClientImpl.cpp', > 'src/FrameLoaderClientImpl.h', > + 'src/GeolocationServiceBridgeChromium.cpp', > 'src/gtk/WebFontInfo.cpp', > 'src/gtk/WebFontInfo.h', > 'src/gtk/WebInputEventFactory.cpp', I believe you should only be modifying the webkit.gypi. I'm not sure why there are any files even in this. > Index: public/GeolocationServiceBridgeChromium.h > =================================================================== > --- public/GeolocationServiceBridgeChromium.h (revision 0) > +++ public/GeolocationServiceBridgeChromium.h (revision 0) > @@ -0,0 +1,91 @@ > +/* > + * Copyright (c) 2009, Google Inc. All rights reserved. 2010 > + > +// This is the flow from WebKit -> Chromium: Even though this is the "Chromium" API we try to avoid talking about "Chromium" in it. Just call it "embedder" Also, in general, WebKit looks down on comments...especially comments that can easily go stale. Document just what this does and let the code speak for itself. > +class GeolocationServiceInterface { > +public: > + // Requests permission for this frame. > + virtual void requestPermissionForFrame(int bridge_id, const WebURL& url) = 0; > + // Asks the browser process to start updating geolocation. > + virtual void startUpdating(int bridge_id, bool hasHighAccuracy) = 0; > + // Asks the browser process to stop updating geolocation. > + virtual void stopUpdating(int bridge_id) = 0; > + // Asks the browser process to suspend updating geolocation. > + virtual void suspend(int bridge_id) = 0; > + // Asks the browser process to resume updating geolocation. > + virtual void resume(int bridge_id) = 0; > + // Attaches the GeolocationBridge to this view and returns its id, which > + // should be used on subsequent calls for the methods above. > + virtual int attachBridge(WebKit::WebGeolocationServiceBridge* geolocationServiceBridge) = 0; This is all really hard to read. Maybe add newlines between functions. > Index: public/WebViewClient.h > =================================================================== > --- public/WebViewClient.h (revision 54653) > +++ public/WebViewClient.h (working copy) > @@ -42,6 +42,7 @@ > > namespace WebKit { > > +class GeolocationServiceInterface; As you'll notice, pretty much any classes in WebKit are generally prefixed by Web. > class WebAccessibilityObject; > class WebDragData; > class WebFileChooserCompletion; > @@ -277,6 +278,16 @@ public: > virtual void removeAutofillSuggestions(const WebString& name, > const WebString& value) { } > > + // Geolocation --------------------------------------------------------- Newline (since most of the other sections do this) > + // Geolocation related functions. This is the API used by > + // WebKit::GeolocationServiceChromium and ChromeClientImpl to issue IPC > + // requests to the browser process. Once again, make it vague and not Chromium specific. > + > + // Requests permission for this frame. > + virtual WebKit::GeolocationServiceInterface* getGeolocationService() { > + return NULL; > + } Put on one line. If you put on multiple, use webkit style. > + > protected: > ~WebViewClient() { } > }; > Index: src/ChromeClientImpl.cpp > =================================================================== > --- src/ChromeClientImpl.cpp (revision 54653) > +++ src/ChromeClientImpl.cpp (working copy) > @@ -43,6 +43,10 @@ > #include "FloatRect.h" > #include "FrameLoadRequest.h" > #include "FrameView.h" > +#include "Geolocation.h" > +#include "GeolocationService.h" > +#include "GeolocationServiceBridgeChromium.h" > +#include "GeolocationServiceChromium.h" > #include "HitTestResult.h" > #include "IntRect.h" > #include "Node.h" > @@ -674,4 +678,14 @@ NotificationPresenter* ChromeClientImpl: > } > #endif > > +void ChromeClientImpl::requestGeolocationPermissionForFrame( > + Frame* frame, Geolocation* geolocation) { No 80 col limit. Unwrap most of these unless it's super long. > + GeolocationServiceChromium* geolocation_service = > + reinterpret_cast<GeolocationServiceChromium*>( > + geolocation->getGeolocationService()); > + m_webView->client()->getGeolocationService()-> > + requestPermissionForFrame(geolocation_service->geolocationServiceBridge()->getBridgeId(), > + frame->document()->url()); > +} > + > } // namespace WebKit > Index: src/ChromeClientImpl.h > =================================================================== > --- src/ChromeClientImpl.h (revision 54653) > +++ src/ChromeClientImpl.h (working copy) > @@ -122,7 +122,7 @@ public: > virtual WebCore::NotificationPresenter* notificationPresenter() const; > #endif > virtual void requestGeolocationPermissionForFrame( > - WebCore::Frame*, WebCore::Geolocation*) { } > + WebCore::Frame*, WebCore::Geolocation*); Don't wrap. Why did you take out the {}? Not all the clients will implement it. > virtual void runOpenPanel(WebCore::Frame*, PassRefPtr<WebCore::FileChooser>); > virtual bool setCursor(WebCore::PlatformCursorHandle) { return false; } > virtual void formStateDidChange(const WebCore::Node*); > Index: src/GeolocationServiceBridgeChromium.cpp > =================================================================== > --- src/GeolocationServiceBridgeChromium.cpp (revision 0) > +++ src/GeolocationServiceBridgeChromium.cpp (revision 0) > @@ -0,0 +1,174 @@ > +/* > + * Copyright (c) 2009, Google Inc. All rights reserved. 2010 > + > +#include "GeolocationServiceChromium.h" > +#include "GeolocationServiceBridgeChromium.h" > +#include "Chrome.h" > +#include "ChromeClientImpl.h" > +#include "Frame.h" > +#include "Geolocation.h" > +#include "Geoposition.h" > +#include "Page.h" > +#include "PositionError.h" > +#include "PositionOptions.h" > +#include "WebFrame.h" > +#include "WebFrameImpl.h" > +#include "WebViewClient.h" > +#include "WebViewImpl.h" Alpha order. > + > +#if ENABLE(GEOLOCATION) > + > +using WebCore::Coordinates; > +using WebCore::Frame; > +using WebCore::Geolocation; > +using WebCore::GeolocationServiceChromium; Alpha order. > +using WebCore::GeolocationServiceBridge; > +using WebCore::GeolocationServiceClient; > +using WebCore::Geoposition; > +using WebCore::PositionError; > +using WebCore::PositionOptions; > +using WebCore::String; > + > +namespace WebKit { > + > +class GeolocationServiceBridgeImpl > + : public GeolocationServiceBridge, public WebGeolocationServiceBridge { Combine those lines. > +public: > + explicit GeolocationServiceBridgeImpl(GeolocationServiceChromium* c); Only put parameter names when it's necessary to understand what the parameter is. > + virtual ~GeolocationServiceBridgeImpl(); > + > + // GeolocationServiceBridge > + virtual bool startUpdating(PositionOptions*); > + virtual void stopUpdating(); > + virtual void suspend(); > + virtual void resume(); > + virtual int getBridgeId() const; > + > + // WebGeolocationServiceBridge > + virtual void setIsAllowed(bool allowed); > + virtual void setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp); > + virtual void setLastError(int error_code, const WebString& message); > + > +private: > + WebViewClient* getWebViewClient(); > + > + GeolocationServiceChromium* m_GeolocationServiceChromium; Should this be deleted automatically at te end? If so, this should be an OwnPtr. > + int m_BridgeId; m_bridgeId. > +}; > + > +static GeolocationServiceBridge* createGeolocationServiceBridgeImpl(GeolocationServiceChromium* c) > +{ > + return new GeolocationServiceBridgeImpl(c); > +} > + > +GeolocationServiceBridgeImpl::GeolocationServiceBridgeImpl(GeolocationServiceChromium* c) c is a bad name. > + : m_GeolocationServiceChromium(c) > +{ > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > + m_BridgeId = webViewClient->getGeolocationService()->attachBridge(this); ASSERT(m_bridgeId) since later you do an if (m_bridgeId) to see if it's valid. But why even do this? Can't you do it lazily on start? (Or is start implicit when it's created?) > +} > + > +GeolocationServiceBridgeImpl::~GeolocationServiceBridgeImpl() > +{ > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > + // webViewClient might be NULL at this point if the frame has been disconnected. > + // Note that in this case, stopUpdating() has been called, and we have already > + // dettached ourselves. I assume that you've seen this condition or are 99% sure it's possible? We like to avoid error checking code "just in case". > + if (m_BridgeId && webViewClient) > + webViewClient->getGeolocationService()->dettachBridge(m_BridgeId); > +} > + > +bool GeolocationServiceBridgeImpl::startUpdating(PositionOptions* positionOptions) > +{ > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > + if (!m_BridgeId) m_BridgeId = webViewClient->getGeolocationService()->attachBridge(this); Avoid putting these on the same lines. > + webViewClient->getGeolocationService()->startUpdating( > + m_BridgeId, positionOptions->enableHighAccuracy()); Combine these lines. > + //// TODO(bulach): this will trigger a permission request regardless. // FIXME: This will trigger a permission request regardless. Is it correct? Confirm with andreip. > + //// Is it correct? confirm with andreip. > + //positionChanged(); > + return true; > +} > + > +void GeolocationServiceBridgeImpl::stopUpdating() > +{ > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > + webViewClient->getGeolocationService()->stopUpdating(m_BridgeId); > + m_BridgeId = 0; // Do you need to disconnect it? > +} > + > +void GeolocationServiceBridgeImpl::suspend() > +{ > + getWebViewClient()->getGeolocationService()->suspend(m_BridgeId); Use this style everywhere instead of saving te webViewClient to a var. > +} > + > +void GeolocationServiceBridgeImpl::resume() > +{ > + getWebViewClient()->getGeolocationService()->resume(m_BridgeId); > +} > + > +int GeolocationServiceBridgeImpl::getBridgeId() const > +{ > + return m_BridgeId; > +} > + > +void GeolocationServiceBridgeImpl::setIsAllowed(bool allowed) { > + m_GeolocationServiceChromium->setIsAllowed(allowed); > +} > + > +void GeolocationServiceBridgeImpl::setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp) { > + m_GeolocationServiceChromium->setLastPosition(latitude, longitude, providesAltitude, altitude, accuracy, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed, timestamp); > +} > + > +void GeolocationServiceBridgeImpl::setLastError(int error_code, const WebString& message) { { on newline here and elsewhere. > + m_GeolocationServiceChromium->setLastError(error_code, message); > +} > + > +WebViewClient* GeolocationServiceBridgeImpl::getWebViewClient() { > + Frame* frame = m_GeolocationServiceChromium->frame(); > + if (!frame || !frame->page()) > + return NULL; When can this happen? Handling these conditions is a pain, so lets only do it if we know we need to. > + WebKit::ChromeClientImpl* chromeClientImpl = static_cast<WebKit::ChromeClientImpl*>(frame->page()->chrome()->client()); > + WebKit::WebViewClient* webViewClient = chromeClientImpl->webView()->client(); > + return webViewClient; > +} > + > +} // namespace WebKit > + > + > +namespace WebCore { > + > +// Sets up the factory function for GeolocationService. > +GeolocationServiceChromium::BridgeFactoryFunction* GeolocationServiceChromium::s_bridgeFactoryFunction = &WebKit::createGeolocationServiceBridgeImpl; > + > +} // namespace WebCore Put this at the beginning if you must... Is there precedent for something like this elsewhere? If not, maybe there's a better way to do this. > + > + > +#endif // ENABLE(GEOLOCATION) > > Property changes on: src/GeolocationServiceBridgeChromium.cpp > ___________________________________________________________________ > Added: svn:executable > + * > Added: svn:eol-style > + LF > > Index: src/WebViewImpl.cpp > =================================================================== > --- src/WebViewImpl.cpp (revision 54653) > +++ src/WebViewImpl.cpp (working copy) > @@ -426,7 +426,7 @@ void WebViewImpl::mouseUp(const WebMouse > IntPoint contentPoint = view->windowToContents(clickPoint); > HitTestResult hitTestResult = focused->eventHandler()->hitTestResultAtPoint(contentPoint, false, false, ShouldHitTestScrollbars); > // We don't want to send a paste when middle clicking a scroll bar or a > - // link (which will navigate later in the code). The main scrollbars > + // link (which will navigate later in the code). The main scrollbars > // have to be handled separately. > if (!hitTestResult.scrollbar() && !hitTestResult.isLiveLink() && focused && !view->scrollbarAtPoint(clickPoint)) { > Editor* editor = focused->editor(); Whitespace cleanup here or there is ok, but changes where the majority (or entirety) are white space are looked down upon. Please remove this file. 189999 7 48591 jorlow 2010-02-12 03:36:52 -0800 Comment on attachment 48591 WebCore bits > Index: platform/chromium/GeolocationServiceChromium.cpp > =================================================================== > --- platform/chromium/GeolocationServiceChromium.cpp (revision 54653) > +++ platform/chromium/GeolocationServiceChromium.cpp (working copy) > @@ -29,27 +29,81 @@ > */ > > #include "config.h" > -#include "GeolocationService.h" > +#include "GeolocationServiceChromium.h" > > namespace WebCore { > > -class GeolocationServiceChromium : public GeolocationService { > -public: > - GeolocationServiceChromium(GeolocationServiceClient* c) > - : GeolocationService(c) > - { > - } > - // FIXME: Implement. https://bugs.webkit.org/show_bug.cgi?id=32068 > -}; > - > -// This guard is the counterpart of the one in WebCore/platform/GeolocationService.cpp > -#if ENABLE(GEOLOCATION) > -static GeolocationService* createGeolocationService(GeolocationServiceClient* c) > +GeolocationServiceChromium::GeolocationServiceChromium(GeolocationServiceClient* c) > + : GeolocationService(c), > + m_Geolocation(reinterpret_cast<Geolocation*>(c)) > +{ > + m_LastPosition = Geoposition::create( > + Coordinates::create(0.0, 0.0, false, 0.0, 0.0, false, 0.0, false, 0.0, false, 0.0), > + 0); All on one line. > + m_LastError = PositionError::create(PositionError::POSITION_UNAVAILABLE, ""); > + m_geolocationServiceBridge.set((*s_bridgeFactoryFunction)(this)); Just use ChromiumBridge if you're going to use linking tricks anyway. You can probably also do this in the initialization section as well. > +} > + > +void GeolocationServiceChromium::setIsAllowed(bool allowed) > +{ > + m_Geolocation->setIsAllowed(allowed); > +} > + > +void GeolocationServiceChromium::setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp) > +{ > + m_LastPosition = Geoposition::create( > + Coordinates::create(latitude, longitude, providesAltitude, altitude, accuracy, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed), > + timestamp); One line. > + positionChanged(); > +} > + > +void GeolocationServiceChromium::setLastError(int error_code, const String& message) > +{ > + m_LastError = PositionError::create(static_cast<PositionError::ErrorCode>(error_code), message); > + errorOccurred(); > +} > + > +Frame* GeolocationServiceChromium::frame() > +{ > + return m_Geolocation->frame(); > +} > + > +bool GeolocationServiceChromium::startUpdating(PositionOptions* options) > +{ > + return m_geolocationServiceBridge->startUpdating(options); > +} > + > +void GeolocationServiceChromium::stopUpdating() > +{ > + return m_geolocationServiceBridge->stopUpdating(); > +} > + > +void GeolocationServiceChromium::suspend() > +{ > + return m_geolocationServiceBridge->suspend(); > +} > + > +void GeolocationServiceChromium::resume() > +{ > + return m_geolocationServiceBridge->resume(); > +} > + > +Geoposition* GeolocationServiceChromium::lastPosition() const > +{ > + return m_LastPosition.get(); > +} > + > +PositionError* GeolocationServiceChromium::lastError() const > +{ > + return m_LastError.get(); This doesn't seem particularly safe. You probably should be passing a PassRefPtr. Read: http://webkit.org/coding/RefPtr.html > +} > + > +static GeolocationService* createGeolocationServiceChromium(GeolocationServiceClient* c) > { > return new GeolocationServiceChromium(c); > } > > -GeolocationService::FactoryFunction* GeolocationService::s_factoryFunction = &createGeolocationService; > -#endif > +// Sets up the factory function for GeolocationService. > +GeolocationService::FactoryFunction* GeolocationService::s_factoryFunction = &createGeolocationServiceChromium; > > } // namespace WebCore > Index: platform/chromium/GeolocationServiceChromium.h > =================================================================== > --- platform/chromium/GeolocationServiceChromium.h (revision 0) > +++ platform/chromium/GeolocationServiceChromium.h (revision 0) > @@ -0,0 +1,84 @@ > +/* > + * Copyright (c) 2009, Google Inc. All rights reserved. 2010 > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions are > + * met: > + * > + * * Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * * Redistributions in binary form must reproduce the above > + * copyright notice, this list of conditions and the following disclaimer > + * in the documentation and/or other materials provided with the > + * distribution. > + * * Neither the name of Google Inc. nor the names of its > + * contributors may be used to endorse or promote products derived from > + * this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR > + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT > + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, > + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY > + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#include "config.h" This only goes in the .cpp files. > +#include "PlatformString.h" Alpha order. > +#include "Geolocation.h" > +#include "GeolocationService.h" > +#include "Geoposition.h" > +#include "PositionError.h" > + > +namespace WebCore { > + > +// Provides an interface for GeolocationServiceChromium to call into chromium. > +class GeolocationServiceBridge { > +public: > + // Called by GeolocationServiceChromium. > + virtual bool startUpdating(PositionOptions*) = 0; > + virtual void stopUpdating() = 0; > + virtual void suspend() = 0; > + virtual void resume() = 0; > + > + // Called by the Chromium side, to identify this bridge.. > + virtual int getBridgeId() const = 0; > +}; > + > +// This class extends GeolocationService, and uses GeolocationServiceBridge to > +// call into chromium, as well as provides a few extra methods so that we can > +// be notified of permission, position, error, etc, from chromium. > +class GeolocationServiceChromium : public GeolocationService { > +public: > + explicit GeolocationServiceChromium(GeolocationServiceClient* c); Delete c. > + > + GeolocationServiceBridge* geolocationServiceBridge() const { return m_geolocationServiceBridge.get(); } > + void setIsAllowed(bool allowed); > + void setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp); > + void setLastError(int error_code, const String& message); > + Frame* frame(); > + > + // From GeolocationService. > + virtual bool startUpdating(PositionOptions*); > + virtual void stopUpdating(); > + virtual void suspend(); > + virtual void resume(); > + virtual Geoposition* lastPosition() const; > + virtual PositionError* lastError() const; > + > +private: > + Geolocation* m_Geolocation; > + OwnPtr<GeolocationServiceBridge*> m_geolocationServiceBridge; Why is this an OwnPtr to a pointer? > + RefPtr<Geoposition> m_LastPosition; > + RefPtr<PositionError> m_LastError; > + > + typedef GeolocationServiceBridge* (BridgeFactoryFunction)(GeolocationServiceChromium*); > + static BridgeFactoryFunction* s_bridgeFactoryFunction; Get rid of. Use ChromiumBridge. > +}; > + > +} // namespace WebCore > > Property changes on: platform/chromium/GeolocationServiceChromium.h > ___________________________________________________________________ > Added: svn:eol-style > + LF > 190079 8 48649 bulach 2010-02-12 09:47:14 -0800 Created attachment 48649 Geolocation implementation thanks for the quick review jeremy! all comments addressed (will reply in a separate email), ran WebKitTools/Scripts/check-webkit-style and have a single file for this patch. would you please take another look? thanks, marcus 190087 9 bulach 2010-02-12 10:09:49 -0800 (In reply to comment #6) > (From update of attachment 48592 [details]) > Please do not separate the WebCore and WebKit bits. You'll need to edit your > .gclient file to make this work. done, using a single file now. > > Normally you set the review flag to ? when you're ready for a review. done. > > > Index: WebKit.gyp > > =================================================================== > > --- WebKit.gyp (revision 54653) > > +++ WebKit.gyp (working copy) > > @@ -68,6 +68,7 @@ > > 'WEBKIT_IMPLEMENTATION', > > ], > > 'sources': [ > > + 'public/GeolocationServiceBridge.h', > > 'public/gtk/WebInputEventFactory.h', > > 'public/linux/WebFontRendering.h', > > 'public/linux/WebRenderTheme.h', > > @@ -231,6 +232,7 @@ > > 'src/EventListenerWrapper.h', > > 'src/FrameLoaderClientImpl.cpp', > > 'src/FrameLoaderClientImpl.h', > > + 'src/GeolocationServiceBridgeChromium.cpp', > > 'src/gtk/WebFontInfo.cpp', > > 'src/gtk/WebFontInfo.h', > > 'src/gtk/WebInputEventFactory.cpp', > > I believe you should only be modifying the webkit.gypi. I'm not sure why there > are any files even in this. hmm.. there aren't that many files in gypi, only a few specific projects from what I understood.. I kept this in gyp instead to keep in line with existing stuff, but I'm happy to change. > > > Index: public/GeolocationServiceBridgeChromium.h > > =================================================================== > > --- public/GeolocationServiceBridgeChromium.h (revision 0) > > +++ public/GeolocationServiceBridgeChromium.h (revision 0) > > @@ -0,0 +1,91 @@ > > +/* > > + * Copyright (c) 2009, Google Inc. All rights reserved. > > 2010 > > > > + > > +// This is the flow from WebKit -> Chromium: > > Even though this is the "Chromium" API we try to avoid talking about "Chromium" > in it. Just call it "embedder" > > Also, in general, WebKit looks down on comments...especially comments that can > easily go stale. Document just what this does and let the code speak for > itself. I see, thanks for the clarification! Fixed. > > > +class GeolocationServiceInterface { > > +public: > > + // Requests permission for this frame. > > + virtual void requestPermissionForFrame(int bridge_id, const WebURL& url) = 0; > > + // Asks the browser process to start updating geolocation. > > + virtual void startUpdating(int bridge_id, bool hasHighAccuracy) = 0; > > + // Asks the browser process to stop updating geolocation. > > + virtual void stopUpdating(int bridge_id) = 0; > > + // Asks the browser process to suspend updating geolocation. > > + virtual void suspend(int bridge_id) = 0; > > + // Asks the browser process to resume updating geolocation. > > + virtual void resume(int bridge_id) = 0; > > + // Attaches the GeolocationBridge to this view and returns its id, which > > + // should be used on subsequent calls for the methods above. > > + virtual int attachBridge(WebKit::WebGeolocationServiceBridge* geolocationServiceBridge) = 0; > > This is all really hard to read. Maybe add newlines between functions. Simplified it a lot. > > > Index: public/WebViewClient.h > > =================================================================== > > --- public/WebViewClient.h (revision 54653) > > +++ public/WebViewClient.h (working copy) > > @@ -42,6 +42,7 @@ > > > > namespace WebKit { > > > > +class GeolocationServiceInterface; > > As you'll notice, pretty much any classes in WebKit are generally prefixed by > Web. Renamed. > > > class WebAccessibilityObject; > > class WebDragData; > > class WebFileChooserCompletion; > > @@ -277,6 +278,16 @@ public: > > virtual void removeAutofillSuggestions(const WebString& name, > > const WebString& value) { } > > > > + // Geolocation --------------------------------------------------------- > > Newline (since most of the other sections do this) Done. > > > + // Geolocation related functions. This is the API used by > > + // WebKit::GeolocationServiceChromium and ChromeClientImpl to issue IPC > > + // requests to the browser process. > > Once again, make it vague and not Chromium specific. Done. > > > + > > + // Requests permission for this frame. > > + virtual WebKit::GeolocationServiceInterface* getGeolocationService() { > > + return NULL; > > + } > > Put on one line. If you put on multiple, use webkit style. Done. > > > + > > protected: > > ~WebViewClient() { } > > }; > > Index: src/ChromeClientImpl.cpp > > =================================================================== > > --- src/ChromeClientImpl.cpp (revision 54653) > > +++ src/ChromeClientImpl.cpp (working copy) > > @@ -43,6 +43,10 @@ > > #include "FloatRect.h" > > #include "FrameLoadRequest.h" > > #include "FrameView.h" > > +#include "Geolocation.h" > > +#include "GeolocationService.h" > > +#include "GeolocationServiceBridgeChromium.h" > > +#include "GeolocationServiceChromium.h" > > #include "HitTestResult.h" > > #include "IntRect.h" > > #include "Node.h" > > @@ -674,4 +678,14 @@ NotificationPresenter* ChromeClientImpl: > > } > > #endif > > > > +void ChromeClientImpl::requestGeolocationPermissionForFrame( > > + Frame* frame, Geolocation* geolocation) { > > No 80 col limit. Unwrap most of these unless it's super long. Done > > > + GeolocationServiceChromium* geolocation_service = > > + reinterpret_cast<GeolocationServiceChromium*>( > > + geolocation->getGeolocationService()); > > + m_webView->client()->getGeolocationService()-> > > + requestPermissionForFrame(geolocation_service->geolocationServiceBridge()->getBridgeId(), > > + frame->document()->url()); > > +} > > + > > } // namespace WebKit > > Index: src/ChromeClientImpl.h > > =================================================================== > > --- src/ChromeClientImpl.h (revision 54653) > > +++ src/ChromeClientImpl.h (working copy) > > @@ -122,7 +122,7 @@ public: > > virtual WebCore::NotificationPresenter* notificationPresenter() const; > > #endif > > virtual void requestGeolocationPermissionForFrame( > > - WebCore::Frame*, WebCore::Geolocation*) { } > > + WebCore::Frame*, WebCore::Geolocation*); > > Don't wrap. Why did you take out the {}? Not all the clients will implement > it. hmm, this is the ChromeClientImpl.h, which now implements this function on ChromeClientImpl.cc.. > > > virtual void runOpenPanel(WebCore::Frame*, PassRefPtr<WebCore::FileChooser>); > > virtual bool setCursor(WebCore::PlatformCursorHandle) { return false; } > > virtual void formStateDidChange(const WebCore::Node*); > > Index: src/GeolocationServiceBridgeChromium.cpp > > =================================================================== > > --- src/GeolocationServiceBridgeChromium.cpp (revision 0) > > +++ src/GeolocationServiceBridgeChromium.cpp (revision 0) > > @@ -0,0 +1,174 @@ > > +/* > > + * Copyright (c) 2009, Google Inc. All rights reserved. > > 2010 done > > > + > > +#include "GeolocationServiceChromium.h" > > +#include "GeolocationServiceBridgeChromium.h" > > +#include "Chrome.h" > > +#include "ChromeClientImpl.h" > > +#include "Frame.h" > > +#include "Geolocation.h" > > +#include "Geoposition.h" > > +#include "Page.h" > > +#include "PositionError.h" > > +#include "PositionOptions.h" > > +#include "WebFrame.h" > > +#include "WebFrameImpl.h" > > +#include "WebViewClient.h" > > +#include "WebViewImpl.h" > > Alpha order. done > > > + > > +#if ENABLE(GEOLOCATION) > > + > > +using WebCore::Coordinates; > > +using WebCore::Frame; > > +using WebCore::Geolocation; > > +using WebCore::GeolocationServiceChromium; > > Alpha order. done > > > +using WebCore::GeolocationServiceBridge; > > +using WebCore::GeolocationServiceClient; > > +using WebCore::Geoposition; > > +using WebCore::PositionError; > > +using WebCore::PositionOptions; > > +using WebCore::String; > > + > > +namespace WebKit { > > + > > +class GeolocationServiceBridgeImpl > > + : public GeolocationServiceBridge, public WebGeolocationServiceBridge { > > Combine those lines. done > > > +public: > > + explicit GeolocationServiceBridgeImpl(GeolocationServiceChromium* c); > > Only put parameter names when it's necessary to understand what the parameter > is. done > > > + virtual ~GeolocationServiceBridgeImpl(); > > + > > + // GeolocationServiceBridge > > + virtual bool startUpdating(PositionOptions*); > > + virtual void stopUpdating(); > > + virtual void suspend(); > > + virtual void resume(); > > + virtual int getBridgeId() const; > > + > > + // WebGeolocationServiceBridge > > + virtual void setIsAllowed(bool allowed); > > + virtual void setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp); > > + virtual void setLastError(int error_code, const WebString& message); > > + > > +private: > > + WebViewClient* getWebViewClient(); > > + > > + GeolocationServiceChromium* m_GeolocationServiceChromium; > > Should this be deleted automatically at te end? If so, this should be an > OwnPtr. added a comment clarifying why it's not an OwnPtr. > > > + int m_BridgeId; > > m_bridgeId. done > > > +}; > > + > > +static GeolocationServiceBridge* createGeolocationServiceBridgeImpl(GeolocationServiceChromium* c) > > +{ > > + return new GeolocationServiceBridgeImpl(c); > > +} > > + > > +GeolocationServiceBridgeImpl::GeolocationServiceBridgeImpl(GeolocationServiceChromium* c) > > c is a bad name. Renamed > > > + : m_GeolocationServiceChromium(c) > > +{ > > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > > + m_BridgeId = webViewClient->getGeolocationService()->attachBridge(this); > > ASSERT(m_bridgeId) since later you do an if (m_bridgeId) to see if it's valid. > > But why even do this? Can't you do it lazily on start? (Or is start implicit > when it's created?) as we chatted, changed this a bit and added a few comments to clarify. > > > +} > > + > > +GeolocationServiceBridgeImpl::~GeolocationServiceBridgeImpl() > > +{ > > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > > + // webViewClient might be NULL at this point if the frame has been disconnected. > > + // Note that in this case, stopUpdating() has been called, and we have already > > + // dettached ourselves. > > I assume that you've seen this condition or are 99% sure it's possible? We > like to avoid error checking code "just in case". as above, this seems to be necessary. > > > + if (m_BridgeId && webViewClient) > > + webViewClient->getGeolocationService()->dettachBridge(m_BridgeId); > > +} > > + > > +bool GeolocationServiceBridgeImpl::startUpdating(PositionOptions* positionOptions) > > +{ > > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > > + if (!m_BridgeId) m_BridgeId = webViewClient->getGeolocationService()->attachBridge(this); > > Avoid putting these on the same lines. done > > > + webViewClient->getGeolocationService()->startUpdating( > > + m_BridgeId, positionOptions->enableHighAccuracy()); > > Combine these lines. done > > > + //// TODO(bulach): this will trigger a permission request regardless. > > // FIXME: This will trigger a permission request regardless. Is it correct? > Confirm with andreip. done > > > + //// Is it correct? confirm with andreip. > > + //positionChanged(); > > + return true; > > +} > > + > > +void GeolocationServiceBridgeImpl::stopUpdating() > > +{ > > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > > + webViewClient->getGeolocationService()->stopUpdating(m_BridgeId); > > + m_BridgeId = 0; > > // Do you need to disconnect it? ahn, good catch! fixed. > > > +} > > + > > +void GeolocationServiceBridgeImpl::suspend() > > +{ > > + getWebViewClient()->getGeolocationService()->suspend(m_BridgeId); > > Use this style everywhere instead of saving te webViewClient to a var. done > > > +} > > + > > +void GeolocationServiceBridgeImpl::resume() > > +{ > > + getWebViewClient()->getGeolocationService()->resume(m_BridgeId); > > +} > > + > > +int GeolocationServiceBridgeImpl::getBridgeId() const > > +{ > > + return m_BridgeId; > > +} > > + > > +void GeolocationServiceBridgeImpl::setIsAllowed(bool allowed) { > > + m_GeolocationServiceChromium->setIsAllowed(allowed); > > +} > > + > > +void GeolocationServiceBridgeImpl::setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp) { > > + m_GeolocationServiceChromium->setLastPosition(latitude, longitude, providesAltitude, altitude, accuracy, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed, timestamp); > > +} > > + > > +void GeolocationServiceBridgeImpl::setLastError(int error_code, const WebString& message) { > > { on newline here and elsewhere. done > > > + m_GeolocationServiceChromium->setLastError(error_code, message); > > +} > > + > > +WebViewClient* GeolocationServiceBridgeImpl::getWebViewClient() { > > + Frame* frame = m_GeolocationServiceChromium->frame(); > > + if (!frame || !frame->page()) > > + return NULL; > > When can this happen? Handling these conditions is a pain, so lets only do it > if we know we need to. as above, this is needed for the case where Geolocation itself has been disconnected from the frame, and after that it'll destroy its GeolocationService. > > > + WebKit::ChromeClientImpl* chromeClientImpl = static_cast<WebKit::ChromeClientImpl*>(frame->page()->chrome()->client()); > > + WebKit::WebViewClient* webViewClient = chromeClientImpl->webView()->client(); > > + return webViewClient; > > +} > > + > > +} // namespace WebKit > > + > > + > > +namespace WebCore { > > + > > +// Sets up the factory function for GeolocationService. > > +GeolocationServiceChromium::BridgeFactoryFunction* GeolocationServiceChromium::s_bridgeFactoryFunction = &WebKit::createGeolocationServiceBridgeImpl; > > + > > +} // namespace WebCore > > Put this at the beginning if you must... Is there precedent for something like > this elsewhere? If not, maybe there's a better way to do this. using ChromiumBridge as suggested. however, instead of publishing the GeolocationServiceBridgeImpl, there's a factory function createGeolocationServiceBridgeImpl which is used by ChromiumBridge, and implemented here.. > > > + > > + > > +#endif // ENABLE(GEOLOCATION) > > > > Property changes on: src/GeolocationServiceBridgeChromium.cpp > > ___________________________________________________________________ > > Added: svn:executable > > + * > > Added: svn:eol-style > > + LF > > > > Index: src/WebViewImpl.cpp > > =================================================================== > > --- src/WebViewImpl.cpp (revision 54653) > > +++ src/WebViewImpl.cpp (working copy) > > @@ -426,7 +426,7 @@ void WebViewImpl::mouseUp(const WebMouse > > IntPoint contentPoint = view->windowToContents(clickPoint); > > HitTestResult hitTestResult = focused->eventHandler()->hitTestResultAtPoint(contentPoint, false, false, ShouldHitTestScrollbars); > > // We don't want to send a paste when middle clicking a scroll bar or a > > - // link (which will navigate later in the code). The main scrollbars > > + // link (which will navigate later in the code). The main scrollbars > > // have to be handled separately. > > if (!hitTestResult.scrollbar() && !hitTestResult.isLiveLink() && focused && !view->scrollbarAtPoint(clickPoint)) { > > Editor* editor = focused->editor(); > > Whitespace cleanup here or there is ok, but changes where the majority (or > entirety) are white space are looked down upon. Please remove this file. removed. 190089 10 bulach 2010-02-12 10:12:17 -0800 (In reply to comment #7) > (From update of attachment 48591 [details]) > > Index: platform/chromium/GeolocationServiceChromium.cpp > > =================================================================== > > --- platform/chromium/GeolocationServiceChromium.cpp (revision 54653) > > +++ platform/chromium/GeolocationServiceChromium.cpp (working copy) > > @@ -29,27 +29,81 @@ > > */ > > > > #include "config.h" > > -#include "GeolocationService.h" > > +#include "GeolocationServiceChromium.h" > > > > namespace WebCore { > > > > -class GeolocationServiceChromium : public GeolocationService { > > -public: > > - GeolocationServiceChromium(GeolocationServiceClient* c) > > - : GeolocationService(c) > > - { > > - } > > - // FIXME: Implement. https://bugs.webkit.org/show_bug.cgi?id=32068 > > -}; > > - > > -// This guard is the counterpart of the one in WebCore/platform/GeolocationService.cpp > > -#if ENABLE(GEOLOCATION) > > -static GeolocationService* createGeolocationService(GeolocationServiceClient* c) > > +GeolocationServiceChromium::GeolocationServiceChromium(GeolocationServiceClient* c) > > + : GeolocationService(c), > > + m_Geolocation(reinterpret_cast<Geolocation*>(c)) > > +{ > > + m_LastPosition = Geoposition::create( > > + Coordinates::create(0.0, 0.0, false, 0.0, 0.0, false, 0.0, false, 0.0, false, 0.0), > > + 0); > > All on one line. done > > > + m_LastError = PositionError::create(PositionError::POSITION_UNAVAILABLE, ""); > > + m_geolocationServiceBridge.set((*s_bridgeFactoryFunction)(this)); > > Just use ChromiumBridge if you're going to use linking tricks anyway. You can > probably also do this in the initialization section as well. using ChromiumBridge, thanks! > > > +} > > + > > +void GeolocationServiceChromium::setIsAllowed(bool allowed) > > +{ > > + m_Geolocation->setIsAllowed(allowed); > > +} > > + > > +void GeolocationServiceChromium::setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp) > > +{ > > + m_LastPosition = Geoposition::create( > > + Coordinates::create(latitude, longitude, providesAltitude, altitude, accuracy, providesAltitudeAccuracy, altitudeAccuracy, providesHeading, heading, providesSpeed, speed), > > + timestamp); > > One line. done > > > + positionChanged(); > > +} > > + > > +void GeolocationServiceChromium::setLastError(int error_code, const String& message) > > +{ > > + m_LastError = PositionError::create(static_cast<PositionError::ErrorCode>(error_code), message); > > + errorOccurred(); > > +} > > + > > +Frame* GeolocationServiceChromium::frame() > > +{ > > + return m_Geolocation->frame(); > > +} > > + > > +bool GeolocationServiceChromium::startUpdating(PositionOptions* options) > > +{ > > + return m_geolocationServiceBridge->startUpdating(options); > > +} > > + > > +void GeolocationServiceChromium::stopUpdating() > > +{ > > + return m_geolocationServiceBridge->stopUpdating(); > > +} > > + > > +void GeolocationServiceChromium::suspend() > > +{ > > + return m_geolocationServiceBridge->suspend(); > > +} > > + > > +void GeolocationServiceChromium::resume() > > +{ > > + return m_geolocationServiceBridge->resume(); > > +} > > + > > +Geoposition* GeolocationServiceChromium::lastPosition() const > > +{ > > + return m_LastPosition.get(); > > +} > > + > > +PositionError* GeolocationServiceChromium::lastError() const > > +{ > > + return m_LastError.get(); > > This doesn't seem particularly safe. You probably should be passing a > PassRefPtr. > > Read: http://webkit.org/coding/RefPtr.html this is already defined by GeolocationService interface, this class just implements it.. ownership is not transferred (in Geolocation.cpp, it just uses the values to create new objects), so it seems to be fine. > > > +} > > + > > +static GeolocationService* createGeolocationServiceChromium(GeolocationServiceClient* c) > > { > > return new GeolocationServiceChromium(c); > > } > > > > -GeolocationService::FactoryFunction* GeolocationService::s_factoryFunction = &createGeolocationService; > > -#endif > > +// Sets up the factory function for GeolocationService. > > +GeolocationService::FactoryFunction* GeolocationService::s_factoryFunction = &createGeolocationServiceChromium; > > > > } // namespace WebCore > > Index: platform/chromium/GeolocationServiceChromium.h > > =================================================================== > > --- platform/chromium/GeolocationServiceChromium.h (revision 0) > > +++ platform/chromium/GeolocationServiceChromium.h (revision 0) > > @@ -0,0 +1,84 @@ > > +/* > > + * Copyright (c) 2009, Google Inc. All rights reserved. > > 2010 done > > > + * > > + * Redistribution and use in source and binary forms, with or without > > + * modification, are permitted provided that the following conditions are > > + * met: > > + * > > + * * Redistributions of source code must retain the above copyright > > + * notice, this list of conditions and the following disclaimer. > > + * * Redistributions in binary form must reproduce the above > > + * copyright notice, this list of conditions and the following disclaimer > > + * in the documentation and/or other materials provided with the > > + * distribution. > > + * * Neither the name of Google Inc. nor the names of its > > + * contributors may be used to endorse or promote products derived from > > + * this software without specific prior written permission. > > + * > > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > > + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR > > + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT > > + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > > + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > > + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, > > + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY > > + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > > + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > > + */ > > + > > +#include "config.h" > > This only goes in the .cpp files. > > > +#include "PlatformString.h" > > Alpha order. done > > > +#include "Geolocation.h" > > +#include "GeolocationService.h" > > +#include "Geoposition.h" > > +#include "PositionError.h" > > + > > +namespace WebCore { > > + > > +// Provides an interface for GeolocationServiceChromium to call into chromium. > > +class GeolocationServiceBridge { > > +public: > > + // Called by GeolocationServiceChromium. > > + virtual bool startUpdating(PositionOptions*) = 0; > > + virtual void stopUpdating() = 0; > > + virtual void suspend() = 0; > > + virtual void resume() = 0; > > + > > + // Called by the Chromium side, to identify this bridge.. > > + virtual int getBridgeId() const = 0; > > +}; > > + > > +// This class extends GeolocationService, and uses GeolocationServiceBridge to > > +// call into chromium, as well as provides a few extra methods so that we can > > +// be notified of permission, position, error, etc, from chromium. > > +class GeolocationServiceChromium : public GeolocationService { > > +public: > > + explicit GeolocationServiceChromium(GeolocationServiceClient* c); > > Delete c. done > > > + > > + GeolocationServiceBridge* geolocationServiceBridge() const { return m_geolocationServiceBridge.get(); } > > + void setIsAllowed(bool allowed); > > + void setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp); > > + void setLastError(int error_code, const String& message); > > + Frame* frame(); > > + > > + // From GeolocationService. > > + virtual bool startUpdating(PositionOptions*); > > + virtual void stopUpdating(); > > + virtual void suspend(); > > + virtual void resume(); > > + virtual Geoposition* lastPosition() const; > > + virtual PositionError* lastError() const; > > + > > +private: > > + Geolocation* m_Geolocation; > > + OwnPtr<GeolocationServiceBridge*> m_geolocationServiceBridge; > > Why is this an OwnPtr to a pointer? my bad, removed. > > > + RefPtr<Geoposition> m_LastPosition; > > + RefPtr<PositionError> m_LastError; > > + > > + typedef GeolocationServiceBridge* (BridgeFactoryFunction)(GeolocationServiceChromium*); > > + static BridgeFactoryFunction* s_bridgeFactoryFunction; > > Get rid of. Use ChromiumBridge. done. > > > +}; > > + > > +} // namespace WebCore > > > > Property changes on: platform/chromium/GeolocationServiceChromium.h > > ___________________________________________________________________ > > Added: svn:eol-style > > + LF > > 190120 11 48649 jorlow 2010-02-12 12:20:41 -0800 Comment on attachment 48649 Geolocation implementation r=me 190973 12 48649 commit-queue 2010-02-17 04:00:21 -0800 Comment on attachment 48649 Geolocation implementation Clearing flags on attachment: 48649 Committed r54883: <http://trac.webkit.org/changeset/54883> 190974 13 commit-queue 2010-02-17 04:00:26 -0800 All reviewed patches have been landed. Closing bug. 203168 14 48649 fishd 2010-03-23 13:26:38 -0700 Comment on attachment 48649 Geolocation implementation > Index: WebKit/chromium/public/GeolocationServiceBridgeChromium.h This file is incorrectly named. The files in the public directory should be prefixed with Web*. Why is there a Chromium suffix? > +#ifndef GeolocationServiceBridgeChromium_h > +#define GeolocationServiceBridgeChromium_h > + > +namespace WebCore { > +class GeolocationServiceBridge; > +class GeolocationServiceChromium; > +} > + > +namespace WebKit { > + > +class WebString; > +class WebURL; > + > +// Provides a WebKit API called by the embedder. > +class WebGeolocationServiceBridge { > +public: > + virtual void setIsAllowed(bool allowed) = 0; > + virtual void setLastPosition(double latitude, double longitude, bool providesAltitude, double altitude, double accuracy, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed, long long timestamp) = 0; This function is begging to have its parameters expressed using a struct. It is bad form to write functions with so many named arguments since it is really hard to tell at the call site if you get the order of the arguments wrong. > + virtual void setLastError(int errorCode, const WebString& message) = 0; > +}; > + > +// Provides an embedder API called by WebKit. > +class WebGeolocationServiceInterface { > +public: > + virtual void requestPermissionForFrame(int bridgeId, const WebURL& url) = 0; > + virtual void startUpdating(int bridgeId, bool hasHighAccuracy) = 0; > + virtual void stopUpdating(int bridgeId) = 0; > + virtual void suspend(int bridgeId) = 0; > + virtual void resume(int bridgeId) = 0; > + > + // Attaches the GeolocationBridge to the embedder and returns its id, which > + // should be used on subsequent calls for the methods above. > + virtual int attachBridge(WebKit::WebGeolocationServiceBridge* geolocationServiceBridge) = 0; > + > + // Dettaches the GeolocationService from the embedder. > + virtual void dettachBridge(int bridgeId) = 0; > +}; There should be a separate header file for each type. > +WebCore::GeolocationServiceBridge* createGeolocationServiceBridgeImpl(WebCore::GeolocationServiceChromium*); Why is the public WebKit API exposing functions to create WebCore types? At the very least this should be wrapped with a WEBKIT_IMPLEMENTATION macro. > Index: WebKit/chromium/public/WebViewClient.h > =================================================================== > --- WebKit/chromium/public/WebViewClient.h (revision 54724) > +++ WebKit/chromium/public/WebViewClient.h (working copy) > @@ -46,6 +46,7 @@ class WebAccessibilityObject; > class WebDragData; > class WebFileChooserCompletion; > class WebFrame; > +class WebGeolocationServiceInterface; > class WebNode; > class WebNotificationPresenter; > class WebRange; > @@ -277,6 +278,11 @@ public: > virtual void removeAutofillSuggestions(const WebString& name, > const WebString& value) { } > > + // Geolocation --------------------------------------------------------- > + > + // Access the embedder API for geolocation services. > + virtual WebKit::WebGeolocationServiceInterface* getGeolocationService() { return 0; } Normally, we do not use the suffix Interface. Also, simple getter functions should not be prefixed with "get", and you do not need to use the WebKit:: prefix when you are inside the WebKit namespace. This should probably be: virtual WebGeolocationService* geolocationService() { return 0; } > Index: WebKit/chromium/src/ChromeClientImpl.cpp ... > +void ChromeClientImpl::requestGeolocationPermissionForFrame(Frame* frame, Geolocation* geolocation) > +{ > + GeolocationServiceChromium* geolocationService = reinterpret_cast<GeolocationServiceChromium*>(geolocation->getGeolocationService()); > + m_webView->client()->getGeolocationService()->requestPermissionForFrame(geolocationService->geolocationServiceBridge()->getBridgeId(), frame->document()->url()); Note: the WebViewClient can be null! > Index: WebKit/chromium/src/GeolocationServiceBridgeChromium.cpp ... > +GeolocationServiceBridgeImpl::~GeolocationServiceBridgeImpl() > +{ > + WebKit::WebViewClient* webViewClient = getWebViewClient(); > + // Geolocation has an OwnPtr to us, and it's destroyed after the frame has > + // been potentially disconnected. In this case, it calls stopUpdating() > + // has been called and we have already dettached ourselves. > + if (!webViewClient) { > + ASSERT(!m_bridgeId); > + } else if (m_bridgeId) nit: no brackets around single line statements > +WebViewClient* GeolocationServiceBridgeImpl::getWebViewClient() > +{ > + Frame* frame = m_GeolocationServiceChromium->frame(); > + if (!frame || !frame->page()) > + return 0; > + WebKit::ChromeClientImpl* chromeClientImpl = static_cast<WebKit::ChromeClientImpl*>(frame->page()->chrome()->client()); > + WebKit::WebViewClient* webViewClient = chromeClientImpl->webView()->client(); > + return webViewClient; > +} nit: no need for WebKit:: prefix when you are in the WebKit namespace 203438 15 bulach 2010-03-24 09:14:19 -0700 Darin, thanks for the comments! I addressed all of them at https://bugs.webkit.org/show_bug.cgi?id=36535 would you mind taking a look please? Thanks, Marcus 47840 2010-02-01 07:25:05 -0800 2010-02-11 14:33:10 -0800 WebCore bits wc-chromium00.txt text/plain 5589 bulach SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDU0MDA0 KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDEt MjggIE1hcmN1cyBCdWxhY2ggIDxidWxhY2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEltcGxlbWVudHMgR2VvbG9jYXRpb25T ZXJ2aWNlcyBmb3IgQ2hyb21pdW0uCisgIAkgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTMyMDY4CisKKyAgICAgICAgVGhpcyBpcyBwYXJ0IG9mIGltcGxlbWVudGlu ZyBHZW9sb2NhdGlvbiBmcmFtZXdvcmsgZm9yIENocm9taXVtLiBFeGlzdGluZyBsYXlvdXQgdGVz dHMgc2hvdWxkIHBhc3MuCisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogcGFn ZS9HZW9sb2NhdGlvbi5oOgorICAgICAgICAqIHBsYXRmb3JtL0dlb2xvY2F0aW9uU2VydmljZS5o OgorCiAyMDEwLTAxLTI4ICBLZW50IFRhbXVyYSAgPHRrZW50QGNocm9taXVtLm9yZz4KIAogICAg ICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KSW5kZXg6IFdlYkNvcmUuZ3lwaQo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlLmd5cGkJKHJldmlzaW9uIDUzOTQxKQorKysgV2ViQ29yZS5neXBpCSh3 b3JraW5nIGNvcHkpCkBAIC0xOTAyLDcgKzE5MDIsNiBAQAogICAgICAgICAgICAgJ3BsYXRmb3Jt L2Nocm9taXVtL0ZyYW1lbGVzc1Njcm9sbFZpZXcuY3BwJywKICAgICAgICAgICAgICdwbGF0Zm9y bS9jaHJvbWl1bS9GcmFtZWxlc3NTY3JvbGxWaWV3LmgnLAogICAgICAgICAgICAgJ3BsYXRmb3Jt L2Nocm9taXVtL0ZyYW1lbGVzc1Njcm9sbFZpZXdDbGllbnQuaCcsCi0gICAgICAgICAgICAncGxh dGZvcm0vY2hyb21pdW0vR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0uY3BwJywKICAgICAgICAg ICAgICdwbGF0Zm9ybS9jaHJvbWl1bS9LZXlDb2RlQ29udmVyc2lvbi5oJywKICAgICAgICAgICAg ICdwbGF0Zm9ybS9jaHJvbWl1bS9LZXlDb2RlQ29udmVyc2lvbkd0ay5jcHAnLAogICAgICAgICAg ICAgJ3BsYXRmb3JtL2Nocm9taXVtL0tleWJvYXJkQ29kZXNQb3NpeC5oJywKSW5kZXg6IHBhZ2Uv R2VvbG9jYXRpb24uaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBwYWdlL0dlb2xvY2F0aW9uLmgJKHJldmlzaW9u IDUzOTQxKQorKysgcGFnZS9HZW9sb2NhdGlvbi5oCSh3b3JraW5nIGNvcHkpCkBAIC03OCw2ICs3 OCw3IEBAIHB1YmxpYzoKICAgICAKICAgICB2b2lkIHNldFNob3VsZENsZWFyQ2FjaGUoYm9vbCBz aG91bGRDbGVhckNhY2hlKSB7IG1fc2hvdWxkQ2xlYXJDYWNoZSA9IHNob3VsZENsZWFyQ2FjaGU7 IH0KICAgICBib29sIHNob3VsZENsZWFyQ2FjaGUoKSBjb25zdCB7IHJldHVybiBtX3Nob3VsZENs ZWFyQ2FjaGU7IH0KKyAgICBGcmFtZSogZnJhbWUoKSBjb25zdCB7IHJldHVybiBtX2ZyYW1lOyB9 CiAKICNpZiBFTkFCTEUoQ0xJRU5UX0JBU0VEX0dFT0xPQ0FUSU9OKQogICAgIHZvaWQgc2V0UG9z aXRpb24oR2VvbG9jYXRpb25Qb3NpdGlvbiopOwpJbmRleDogcGxhdGZvcm0vR2VvbG9jYXRpb25T ZXJ2aWNlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gcGxhdGZvcm0vR2VvbG9jYXRpb25TZXJ2aWNlLmgJKHJl dmlzaW9uIDUzOTQxKQorKysgcGxhdGZvcm0vR2VvbG9jYXRpb25TZXJ2aWNlLmgJKHdvcmtpbmcg Y29weSkKQEAgLTIwLDcgKzIwLDcgQEAKICAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKICAqIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAogICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCi0gKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLiAKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAogI2lmbmRlZiBH ZW9sb2NhdGlvblNlcnZpY2VfaApAQCAtNDYsMTAgKzQ2LDEwIEBAIGNsYXNzIEdlb2xvY2F0aW9u U2VydmljZSA6IHB1YmxpYyBOb25jb3AKIHB1YmxpYzoKICAgICBzdGF0aWMgR2VvbG9jYXRpb25T ZXJ2aWNlKiBjcmVhdGUoR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50Kik7CiAgICAgdmlydHVhbCB+ R2VvbG9jYXRpb25TZXJ2aWNlKCkgeyB9Ci0gICAgCisKICAgICB2aXJ0dWFsIGJvb2wgc3RhcnRV cGRhdGluZyhQb3NpdGlvbk9wdGlvbnMqKSB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwg dm9pZCBzdG9wVXBkYXRpbmcoKSB7IH0KLSAgICAKKwogICAgIHZpcnR1YWwgdm9pZCBzdXNwZW5k KCkgeyB9CiAgICAgdmlydHVhbCB2b2lkIHJlc3VtZSgpIHsgfQogCkBAIC02Myw2ICs2Myw3IEBA IHB1YmxpYzoKIAogcHJvdGVjdGVkOgogICAgIEdlb2xvY2F0aW9uU2VydmljZShHZW9sb2NhdGlv blNlcnZpY2VDbGllbnQqKTsKKyAgICBHZW9sb2NhdGlvblNlcnZpY2VDbGllbnQqIGdlb2xvY2F0 aW9uU2VydmljZUNsaWVudCgpIGNvbnN0IHsgcmV0dXJuIG1fZ2VvbG9jYXRpb25TZXJ2aWNlQ2xp ZW50OyB9CiAKIHByaXZhdGU6CiAgICAgR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KiBtX2dlb2xv Y2F0aW9uU2VydmljZUNsaWVudDsKSW5kZXg6IHBsYXRmb3JtL2Nocm9taXVtL0dlb2xvY2F0aW9u U2VydmljZUNocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBwbGF0Zm9ybS9jaHJvbWl1bS9HZW9s b2NhdGlvblNlcnZpY2VDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDUzOTQxKQorKysgcGxhdGZvcm0v Y2hyb21pdW0vR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0xLDU1ICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDksIEdvb2dsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCi0gKiAKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQot ICogbWV0OgotICogCi0gKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogICAgICogUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQotICogY29weXJp Z2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lcgotICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZQotICogZGlzdHJpYnV0aW9uLgotICogICAgICogTmVpdGhlciB0aGUg bmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cwotICogY29udHJpYnV0b3Jz IG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20K LSAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Np b24uCi0gKiAKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBI T0xERVJTIEFORCBDT05UUklCVVRPUlMKLSAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCi0gKiBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKLSAq IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBU SEUgQ09QWVJJR0hUCi0gKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKLSAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKLSAqIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LAotICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZCi0gKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCi0gKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKLSAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCi0gKi8KLQotI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1ZGUgIkdlb2xvY2F0 aW9uU2VydmljZS5oIgotCi1uYW1lc3BhY2UgV2ViQ29yZSB7Ci0KLWNsYXNzIEdlb2xvY2F0aW9u U2VydmljZUNocm9taXVtIDogcHVibGljIEdlb2xvY2F0aW9uU2VydmljZSB7Ci1wdWJsaWM6Ci0g ICAgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0oR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KiBj KQotICAgICAgICA6IEdlb2xvY2F0aW9uU2VydmljZShjKQotICAgIHsKLSAgICB9Ci0gICAgLy8g RklYTUU6IEltcGxlbWVudC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTMyMDY4Ci19OwotCi0vLyBUaGlzIGd1YXJkIGlzIHRoZSBjb3VudGVycGFydCBvZiB0aGUgb25l IGluIFdlYkNvcmUvcGxhdGZvcm0vR2VvbG9jYXRpb25TZXJ2aWNlLmNwcAotI2lmIEVOQUJMRShH RU9MT0NBVElPTikKLXN0YXRpYyBHZW9sb2NhdGlvblNlcnZpY2UqIGNyZWF0ZUdlb2xvY2F0aW9u U2VydmljZShHZW9sb2NhdGlvblNlcnZpY2VDbGllbnQqIGMpCi17Ci0gICAgcmV0dXJuIG5ldyBH ZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bShjKTsKLX0KLQotR2VvbG9jYXRpb25TZXJ2aWNlOjpG YWN0b3J5RnVuY3Rpb24qIEdlb2xvY2F0aW9uU2VydmljZTo6c19mYWN0b3J5RnVuY3Rpb24gPSAm Y3JlYXRlR2VvbG9jYXRpb25TZXJ2aWNlOwotI2VuZGlmCi0KLX0gLy8gbmFtZXNwYWNlIFdlYkNv cmUK 47841 2010-02-01 07:26:13 -0800 2010-02-11 14:33:40 -0800 WebKit bits wk-chromium00.txt text/plain 17388 bulach SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDU0MDA0 KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTggQEAKKzIwMTAtMDEt MjggIE1hcmN1cyBCdWxhY2ggIDxidWxhY2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEltcGxlbWVudHMgR2VvbG9jYXRpb25T ZXJ2aWNlcyBmb3IgQ2hyb21pdW0uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0zMjA2OAorCisgICAgICAgIFRoaXMgaXMgcGFydCBvZiBpbXBsZW1lbnRp bmcgR2VvbG9jYXRpb24gZnJhbWV3b3JrIGZvciBDaHJvbWl1bS4gRXhpc3RpbmcgbGF5b3V0IHRl c3RzIHNob3VsZCBwYXNzLgorCisgICAgICAgICogcHVibGljL0dlb2xvY2F0aW9uU2VydmljZUJy aWRnZUNocm9taXVtLmgKKyAgICAgICAgKiBwdWJsaWMvV2ViVmlld0NsaWVudC5oCisgICAgICAg ICogc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwOgorICAgICAgICAqIHNyYy9DaHJvbWVDbGllbnRJ bXBsLmg6CisgICAgICAgICogc3JjL0dlb2xvY2F0aW9uU2VydmljZUNocm9taXVtLmNwcAorCiAy MDEwLTAxLTI3ICBEYXJpbiBGaXNoZXIgIDxkYXJpbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgUGF2ZWwgRmVsZG1hbi4KSW5kZXg6IFdlYktpdC5neXAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0Lmd5cAkocmV2aXNpb24gNTM5NDEpCisrKyBXZWJLaXQuZ3lwCSh3b3JraW5nIGNv cHkpCkBAIC0yMTcsNiArMjE3LDcgQEAKICAgICAgICAgICAgICAgICAnc3JjL0V2ZW50TGlzdGVu ZXJXcmFwcGVyLmgnLAogICAgICAgICAgICAgICAgICdzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBs LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaCcsCisg ICAgICAgICAgICAgICAgJ3NyYy9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5jcHAnLAkJCiAg ICAgICAgICAgICAgICAgJ3NyYy9ndGsvV2ViRm9udEluZm8uY3BwJywKICAgICAgICAgICAgICAg ICAnc3JjL2d0ay9XZWJGb250SW5mby5oJywKICAgICAgICAgICAgICAgICAnc3JjL2d0ay9XZWJJ bnB1dEV2ZW50RmFjdG9yeS5jcHAnLApJbmRleDogcHVibGljL0dlb2xvY2F0aW9uU2VydmljZUJy aWRnZUNocm9taXVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcHVibGljL0dlb2xvY2F0aW9uU2VydmljZUJy aWRnZUNocm9taXVtLmgJKHJldmlzaW9uIDApCisrKyBwdWJsaWMvR2VvbG9jYXRpb25TZXJ2aWNl QnJpZGdlQ2hyb21pdW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw4MyBAQAorLyoKKyAqIENv cHlyaWdodCAoYykgMjAwOSwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqICAK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICogIAorICogICAgICog UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRp c3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9y IHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNl IG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICogIAorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9S UworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVS IE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAq IFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZu ZGVmIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUNocm9taXVtX2gKKyNkZWZpbmUgR2VvbG9jYXRp b25TZXJ2aWNlQnJpZGdlQ2hyb21pdW1faAorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3Mg V2ViU3RyaW5nOworY2xhc3MgV2ViVVJMOworCisvLyBUaGlzIGlzIHRoZSBBUEkgcHJvdmlkZWQg YnkgV2ViS2l0IHRvIENocm9taXVtIGZvciBnZW9sb2NhdGlvbi1yZWxhdGVkCisvLyBzZXJ2aWNl cy4gVGhpcyBpcyBleHBvc2VkIGJ5IEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtIHdoaWNoIHJl Z2lzdGVycworLy8gaXRzZWxmIG9uIENocm9taXVtIHZpYSBHZW9sb2NhdGlvblNlcnZpY2VJbnRl cmZhY2VDaHJvbWl1bTo6YXR0YWNoU2VydmljZS4KK2NsYXNzIEdlb2xvY2F0aW9uU2VydmljZUJy aWRnZUNocm9taXVtIHsKK3B1YmxpYzoKKyAgICAvLyBUaGlzIGVudW0gbXVzdCBiZSB0aGUgc2Ft ZSBhcyBXZWJDb3JlOjpQb3NpdGlvbkVycm9yOjpFcnJvckNvZGUuCisgICAgZW51bSBFcnJvckNv ZGUgeworICAgICAgICBQRVJNSVNTSU9OX0RFTklFRCA9IDEsCisgICAgICAgIFBPU0lUSU9OX1VO QVZBSUxBQkxFID0gMiwKKyAgICAgICAgVElNRU9VVCA9IDMKKyAgICB9OworICAgIHZpcnR1YWwg V2ViVVJMIGdldFVSTCgpID0gMDsKKyAgICAvLyBUaGVzZSBhcmUgdXNlZCBmcm9tIENocm9taXVt IGJyb3dzZXIgcHJvY2VzcyB0byBub3RpZnkgdGhpcyBzZXJ2aWNlLgorICAgIC8vIFNldHMgdGhl IHBlcm1pc3Npb24gZm9yIHRoaXMgc2VydmljZS4KKyAgICB2aXJ0dWFsIHZvaWQgc2V0SXNBbGxv d2VkKGJvb2wgYWxsb3dlZCkgPSAwOworICAgIC8vIFRoZSBwYXJhbXMgbXVzdCBtYXRjaCBXZWJD b3JlOjpHZW9wb3NpdGlvbjo6Y3JlYXRlKCkuCisgICAgdmlydHVhbCB2b2lkIHNldExhc3RQb3Np dGlvbihkb3VibGUgbGF0aXR1ZGUsIGRvdWJsZSBsb25naXR1ZGUsIGJvb2wgcHJvdmlkZXNBbHRp dHVkZSwgZG91YmxlIGFsdGl0dWRlLCBkb3VibGUgYWNjdXJhY3ksIGJvb2wgcHJvdmlkZXNBbHRp dHVkZUFjY3VyYWN5LCBkb3VibGUgYWx0aXR1ZGVBY2N1cmFjeSwgYm9vbCBwcm92aWRlc0hlYWRp bmcsIGRvdWJsZSBoZWFkaW5nLCBib29sIHByb3ZpZGVzU3BlZWQsIGRvdWJsZSBzcGVlZCwgbG9u ZyBsb25nIHRpbWVzdGFtcCkgPSAwOworICAgIC8vIFRoZSBwYXJhbXMgbXVzdCBtYXRjaCBXZWJD b3JlOjpQb3NpdGlvbkVycm9yOjpjcmVhdGUoKS4KKyAgICB2aXJ0dWFsIHZvaWQgc2V0TGFzdEVy cm9yKEVycm9yQ29kZSBlcnJvcl9jb2RlLCBjb25zdCBXZWJTdHJpbmcmIG1lc3NhZ2UpID0gMDsK K307CisKKy8vIFRoaXMgaXMgdGhlIEFQSSBwcm92aWRlZCBieSBDaHJvbWl1bSB0byBXZWJLaXQg Zm9yIGdlb2xvY2F0aW9uLXJlbGF0ZWQKKy8vIHNlcnZpY2VzLCBhY2Nlc3NpYmxlIHZpYSBSZW5k ZXJWaWV3OjpnZXRHZW9sb2NhdGlvblNlcnZpY2VJbnRlcmZhY2VDaHJvbWl1bSgpLgorY2xhc3Mg R2VvbG9jYXRpb25TZXJ2aWNlSW50ZXJmYWNlQ2hyb21pdW0geworcHVibGljOgorICAvLyBSZXF1 ZXN0cyBwZXJtaXNzaW9uIGZvciB0aGlzIGZyYW1lLgorICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBl cm1pc3Npb25Gb3JGcmFtZShjb25zdCBXZWJVUkwmIHVybCkgPSAwOworICAvLyBBc2tzIHRoZSBi cm93c2VyIHByb2Nlc3MgdG8gc3RhcnQgdXBkYXRpbmcgZ2VvbG9jYXRpb24uCisgIHZpcnR1YWwg dm9pZCBzdGFydFVwZGF0aW5nKGNvbnN0IFdlYlVSTCYgdXJsLCBib29sIGhhc0hpZ2hBY2N1cmFj eSkgPSAwOworICAvLyBBc2tzIHRoZSBicm93c2VyIHByb2Nlc3MgdG8gc3RvcCB1cGRhdGluZyBn ZW9sb2NhdGlvbi4KKyAgdmlydHVhbCB2b2lkIHN0b3BVcGRhdGluZyhjb25zdCBXZWJVUkwmIHVy bCkgPSAwOworICAvLyBBc2tzIHRoZSBicm93c2VyIHByb2Nlc3MgdG8gc3VzcGVuZCB1cGRhdGlu ZyBnZW9sb2NhdGlvbi4KKyAgdmlydHVhbCB2b2lkIHN1c3BlbmQoY29uc3QgV2ViVVJMJiB1cmwp ID0gMDsKKyAgLy8gQXNrcyB0aGUgYnJvd3NlciBwcm9jZXNzIHRvIHJlc3VtZSB1cGRhdGluZyBn ZW9sb2NhdGlvbi4KKyAgdmlydHVhbCB2b2lkIHJlc3VtZShjb25zdCBXZWJVUkwmIHVybCkgPSAw OworICAvLyBBdHRhY2hlcyB0aGUgR2VvbG9jYXRpb25TZXJ2aWNlIHRvIHRoaXMgdmlldy4KKyAg dmlydHVhbCB2b2lkIGF0dGFjaFNlcnZpY2UoR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlQ2hyb21p dW0qIGdlb2xvY2F0aW9uU2VydmljZSkgPSAwOworICAvLyBEZXR0YWNoZXMgdGhlIEdlb2xvY2F0 aW9uU2VydmljZSBmcm9tIHRoaXMgdmlldy4KKyAgdmlydHVhbCB2b2lkIGRldHRhY2hTZXJ2aWNl KEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUNocm9taXVtKiBnZW9sb2NhdGlvblNlcnZpY2UpID0g MDsKK307CisKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZiAgLy8gR2VvbG9jYXRp b25TZXJ2aWNlQnJpZGdlQ2hyb21pdW1faApcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKClBy b3BlcnR5IGNoYW5nZXMgb246IHB1YmxpYy9HZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1 bS5oCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KQWRkZWQ6IHN2bjplb2wtc3R5bGUKICAgKyBMRgoKSW5kZXg6IHB1Ymxp Yy9XZWJWaWV3Q2xpZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcHVibGljL1dlYlZpZXdDbGllbnQuaAko cmV2aXNpb24gNTM5NDEpCisrKyBwdWJsaWMvV2ViVmlld0NsaWVudC5oCSh3b3JraW5nIGNvcHkp CkBAIC00Miw2ICs0Miw3IEBACiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCitjbGFzcyBHZW9sb2Nh dGlvblNlcnZpY2VJbnRlcmZhY2VDaHJvbWl1bTsKIGNsYXNzIFdlYkFjY2Vzc2liaWxpdHlPYmpl Y3Q7CiBjbGFzcyBXZWJEcmFnRGF0YTsKIGNsYXNzIFdlYkZpbGVDaG9vc2VyQ29tcGxldGlvbjsK QEAgLTI3Miw2ICsyNzMsMTcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCByZW1vdmVBdXRv ZmlsbFN1Z2dlc3Rpb25zKGNvbnN0IFdlYlN0cmluZyYgbmFtZSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBXZWJTdHJpbmcmIHZhbHVlKSB7IH0KIAor ICAgIC8vIEdlb2xvY2F0aW9uIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIEdlb2xvY2F0aW9uIHJlbGF0ZWQgZnVuY3Rpb25z LiBUaGlzIGlzIHRoZSBBUEkgdXNlZCBieQorICAgIC8vIFdlYktpdDo6R2VvbG9jYXRpb25TZXJ2 aWNlQ2hyb21pdW0gYW5kIENocm9tZUNsaWVudEltcGwgdG8gaXNzdWUgSVBDCisgICAgLy8gcmVx dWVzdHMgdG8gdGhlIGJyb3dzZXIgcHJvY2Vzcy4KKworICAgIC8vIFJlcXVlc3RzIHBlcm1pc3Np b24gZm9yIHRoaXMgZnJhbWUuCisgICAgdmlydHVhbCBXZWJLaXQ6Okdlb2xvY2F0aW9uU2Vydmlj ZUludGVyZmFjZUNocm9taXVtKgorICAgICAgICBnZXRHZW9sb2NhdGlvblNlcnZpY2VJbnRlcmZh Y2VDaHJvbWl1bSgpIHsKKyAgICAgIHJldHVybiBOVUxMOworICAgIH0KKwogcHJvdGVjdGVkOgog ICAgIH5XZWJWaWV3Q2xpZW50KCkgeyB9CiB9OwpJbmRleDogc3JjL0Nocm9tZUNsaWVudEltcGwu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIHNyYy9DaHJvbWVDbGllbnRJbXBsLmNwcAkocmV2aXNpb24gNTM5 NDEpCisrKyBzcmMvQ2hyb21lQ2xpZW50SW1wbC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQzLDYg KzQzLDcgQEAKICNpbmNsdWRlICJGbG9hdFJlY3QuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRSZXF1 ZXN0LmgiCiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiR2VvbG9jYXRpb25TZXJ2 aWNlQnJpZGdlQ2hyb21pdW0uaCIKICNpbmNsdWRlICJIaXRUZXN0UmVzdWx0LmgiCiAjaW5jbHVk ZSAiSW50UmVjdC5oIgogI2luY2x1ZGUgIk5vZGUuaCIKQEAgLTY2Niw0ICs2NjcsMTAgQEAgTm90 aWZpY2F0aW9uUHJlc2VudGVyKiBDaHJvbWVDbGllbnRJbXBsOgogfQogI2VuZGlmCiAKK3ZvaWQg Q2hyb21lQ2xpZW50SW1wbDo6cmVxdWVzdEdlb2xvY2F0aW9uUGVybWlzc2lvbkZvckZyYW1lKAor ICAgICAgICBXZWJDb3JlOjpGcmFtZSogZnJhbWUsIFdlYkNvcmU6Okdlb2xvY2F0aW9uKiBnZW9s b2NhdGlvbikgeworICBtX3dlYlZpZXctPmNsaWVudCgpLT5nZXRHZW9sb2NhdGlvblNlcnZpY2VJ bnRlcmZhY2VDaHJvbWl1bSgpLT4KKyAgICAgIHJlcXVlc3RQZXJtaXNzaW9uRm9yRnJhbWUoV2Vi RnJhbWVJbXBsOjpmcm9tRnJhbWUoZnJhbWUpLT51cmwoKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNl IFdlYktpdApJbmRleDogc3JjL0Nocm9tZUNsaWVudEltcGwuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzcmMv Q2hyb21lQ2xpZW50SW1wbC5oCShyZXZpc2lvbiA1Mzk0MSkKKysrIHNyYy9DaHJvbWVDbGllbnRJ bXBsLmgJKHdvcmtpbmcgY29weSkKQEAgLTEyMSw3ICsxMjEsNyBAQCBwdWJsaWM6CiAgICAgdmly dHVhbCBXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVzZW50ZXIqIG5vdGlmaWNhdGlvblByZXNlbnRl cigpIGNvbnN0OwogI2VuZGlmCiAgICAgdmlydHVhbCB2b2lkIHJlcXVlc3RHZW9sb2NhdGlvblBl cm1pc3Npb25Gb3JGcmFtZSgKLSAgICAgICAgV2ViQ29yZTo6RnJhbWUqLCBXZWJDb3JlOjpHZW9s b2NhdGlvbiopIHsgfQorICAgICAgICBXZWJDb3JlOjpGcmFtZSosIFdlYkNvcmU6Okdlb2xvY2F0 aW9uKik7CiAgICAgdmlydHVhbCB2b2lkIHJ1bk9wZW5QYW5lbChXZWJDb3JlOjpGcmFtZSosIFBh c3NSZWZQdHI8V2ViQ29yZTo6RmlsZUNob29zZXI+KTsKICAgICB2aXJ0dWFsIGJvb2wgc2V0Q3Vy c29yKFdlYkNvcmU6OlBsYXRmb3JtQ3Vyc29ySGFuZGxlKSB7IHJldHVybiBmYWxzZTsgfQogICAg IHZpcnR1YWwgdm9pZCBmb3JtU3RhdGVEaWRDaGFuZ2UoY29uc3QgV2ViQ29yZTo6Tm9kZSopOwpJ bmRleDogc3JjL0dlb2xvY2F0aW9uU2VydmljZUNocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBz cmMvR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0uY3BwCShyZXZpc2lvbiAwKQorKysgc3JjL0dl b2xvY2F0aW9uU2VydmljZUNocm9taXVtLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMDEg QEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDksIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKmdlb2xvY2F0aW9uX3Blcm1pc3Npb25fY29udGV4dAorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKmdlb2xvY2F0aW9uX3Blcm1pc3Npb25fY29udGV4 dAorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAq IGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29v Z2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNl ZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNv ZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICpnZW9s b2NhdGlvbl9wZXJtaXNzaW9uX2NvbnRleHQKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgIkdlb2xvY2F0aW9u U2VydmljZS5oIgorI2luY2x1ZGUgIkdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUNocm9taXVtLmgi CisjaW5jbHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ2hyb21lQ2xpZW50SW1wbC5oIgorI2lu Y2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiR2VvcG9zaXRpb24uaCIKKyNpbmNsdWRlICJHZW9s b2NhdGlvbi5oIgorI2luY2x1ZGUgIlBhZ2UuaCIKKyNpbmNsdWRlICJQb3NpdGlvbkVycm9yLmgi CisjaW5jbHVkZSAiUG9zaXRpb25PcHRpb25zLmgiCisjaW5jbHVkZSAiV2ViRnJhbWUuaCIKKyNp bmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNpbmNsdWRlICJXZWJWaWV3Q2xpZW50LmgiCisjaW5j bHVkZSAiV2ViVmlld0ltcGwuaCIKKworI2lmIEVOQUJMRShHRU9MT0NBVElPTikKKwordXNpbmcg V2ViQ29yZTo6Q29vcmRpbmF0ZXM7Cit1c2luZyBXZWJDb3JlOjpGcmFtZTsKK3VzaW5nIFdlYkNv cmU6Okdlb2xvY2F0aW9uOwordXNpbmcgV2ViQ29yZTo6R2VvbG9jYXRpb25TZXJ2aWNlOwordXNp bmcgV2ViQ29yZTo6R2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50OwordXNpbmcgV2ViQ29yZTo6R2Vv cG9zaXRpb247Cit1c2luZyBXZWJDb3JlOjpQb3NpdGlvbkVycm9yOwordXNpbmcgV2ViQ29yZTo6 UG9zaXRpb25PcHRpb25zOwordXNpbmcgV2ViQ29yZTo6U3RyaW5nOworCituYW1lc3BhY2UgV2Vi S2l0IHsKKworY2xhc3MgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0gOiBwdWJsaWMgR2VvbG9j YXRpb25TZXJ2aWNlLCBwdWJsaWMgR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlQ2hyb21pdW0gewor cHVibGljOgorICAgIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKEdlb2xvY2F0aW9uU2Vydmlj ZUNsaWVudCogYyk7CisKKyAgICB2aXJ0dWFsIH5HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bSgp OworCisgICAgLy8gR2VvbG9jYXRpb25TZXJ2aWNlCisgICAgdmlydHVhbCBib29sIHN0YXJ0VXBk YXRpbmcoUG9zaXRpb25PcHRpb25zKiBwb3NpdGlvbk9wdGlvbnMpOworICAgIHZpcnR1YWwgdm9p ZCBzdG9wVXBkYXRpbmcoKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3VzcGVuZCgpOworICAgIHZpcnR1 YWwgdm9pZCByZXN1bWUoKTsKKyAgICB2aXJ0dWFsIEdlb3Bvc2l0aW9uKiBsYXN0UG9zaXRpb24o KSBjb25zdDsKKyAgICB2aXJ0dWFsIFBvc2l0aW9uRXJyb3IqIGxhc3RFcnJvcigpIGNvbnN0Owor CisgICAgLy8gR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW1CcmlkZ2UKKyAgICB2aXJ0dWFsIFdl YlVSTCBnZXRVUkwoKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0SXNBbGxvd2VkKGJvb2wgYWxsb3dl ZCk7CisgICAgdmlydHVhbCB2b2lkIHNldExhc3RQb3NpdGlvbihkb3VibGUgbGF0aXR1ZGUsIGRv dWJsZSBsb25naXR1ZGUsIGJvb2wgcHJvdmlkZXNBbHRpdHVkZSwgZG91YmxlIGFsdGl0dWRlLCBk b3VibGUgYWNjdXJhY3ksIGJvb2wgcHJvdmlkZXNBbHRpdHVkZUFjY3VyYWN5LCBkb3VibGUgYWx0 aXR1ZGVBY2N1cmFjeSwgYm9vbCBwcm92aWRlc0hlYWRpbmcsIGRvdWJsZSBoZWFkaW5nLCBib29s IHByb3ZpZGVzU3BlZWQsIGRvdWJsZSBzcGVlZCwgbG9uZyBsb25nIHRpbWVzdGFtcCk7CisgICAg dmlydHVhbCB2b2lkIHNldExhc3RFcnJvcihFcnJvckNvZGUgZXJyb3JfY29kZSwgY29uc3QgV2Vi U3RyaW5nJiBtZXNzYWdlKTsKKworcHJpdmF0ZToKKyAgICBXZWJLaXQ6OldlYlZpZXdDbGllbnQq IGdldFdlYlZpZXdDbGllbnQoKSBjb25zdDsKKworICAgIFJlZlB0cjxHZW9wb3NpdGlvbj4gbV9M YXN0UG9zaXRpb247CisgICAgUmVmUHRyPFBvc2l0aW9uRXJyb3I+IG1fTGFzdEVycm9yOworfTsK Kworc3RhdGljIEdlb2xvY2F0aW9uU2VydmljZSogY3JlYXRlR2VvbG9jYXRpb25TZXJ2aWNlKEdl b2xvY2F0aW9uU2VydmljZUNsaWVudCogYykKK3sKKyAgICByZXR1cm4gbmV3IEdlb2xvY2F0aW9u U2VydmljZUNocm9taXVtKGMpOworfQorCitHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6R2Vv bG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0oR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KiBjKQorICAg IDogR2VvbG9jYXRpb25TZXJ2aWNlKGMpCit7CisgICAgV2ViS2l0OjpXZWJWaWV3Q2xpZW50KiB3 ZWJWaWV3Q2xpZW50ID0gZ2V0V2ViVmlld0NsaWVudCgpOworICAgIHdlYlZpZXdDbGllbnQtPmdl dEdlb2xvY2F0aW9uU2VydmljZUludGVyZmFjZUNocm9taXVtKCktPmF0dGFjaFNlcnZpY2UodGhp cyk7CisgICAgbV9MYXN0UG9zaXRpb24gPSBHZW9wb3NpdGlvbjo6Y3JlYXRlKAorICAgICAgICBD b29yZGluYXRlczo6Y3JlYXRlKDAuMCwgMC4wLCBmYWxzZSwgMC4wLCAwLjAsIGZhbHNlLCAwLjAs IGZhbHNlLCAwLjAsIGZhbHNlLCAwLjApLAorICAgICAgICAwKTsKKyAgICBtX0xhc3RFcnJvciA9 IFBvc2l0aW9uRXJyb3I6OmNyZWF0ZShQb3NpdGlvbkVycm9yOjpQT1NJVElPTl9VTkFWQUlMQUJM RSwgIiIpOworfQorCitHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6fkdlb2xvY2F0aW9uU2Vy dmljZUNocm9taXVtKCkKK3sKKyAgICBXZWJLaXQ6OldlYlZpZXdDbGllbnQqIHdlYlZpZXdDbGll bnQgPSBnZXRXZWJWaWV3Q2xpZW50KCk7CisgICAgLy8gd2ViVmlld0NsaWVudCBtaWdodCBiZSBO VUxMIGF0IHRoaXMgcG9pbnQgaWYgdGhlIGZyYW1lIGhhcyBiZWVuIGRpc2Nvbm5lY3RlZC4KKyAg ICBpZiAod2ViVmlld0NsaWVudCkKKyAgICAgICAgd2ViVmlld0NsaWVudC0+Z2V0R2VvbG9jYXRp b25TZXJ2aWNlSW50ZXJmYWNlQ2hyb21pdW0oKS0+ZGV0dGFjaFNlcnZpY2UoCisgICAgICAgICAg ICB0aGlzKTsKK30KKworV2ViVVJMIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpnZXRVUkwo KQoreworICBGcmFtZSogZnJhbWUgPSByZWludGVycHJldF9jYXN0PEdlb2xvY2F0aW9uKj4oZ2Vv bG9jYXRpb25TZXJ2aWNlQ2xpZW50KCkpLT5mcmFtZSgpOworICByZXR1cm4gV2ViRnJhbWVJbXBs Ojpmcm9tRnJhbWUoZnJhbWUpLT51cmwoKTsKK30KKworYm9vbCBHZW9sb2NhdGlvblNlcnZpY2VD aHJvbWl1bTo6c3RhcnRVcGRhdGluZyhQb3NpdGlvbk9wdGlvbnMqIHBvc2l0aW9uT3B0aW9ucykK K3sKKyAgICBXZWJLaXQ6OldlYlZpZXdDbGllbnQqIHdlYlZpZXdDbGllbnQgPSBnZXRXZWJWaWV3 Q2xpZW50KCk7CisgICAgd2ViVmlld0NsaWVudC0+Z2V0R2VvbG9jYXRpb25TZXJ2aWNlSW50ZXJm YWNlQ2hyb21pdW0oKS0+YXR0YWNoU2VydmljZSgKKyAgICAgICAgdGhpcyk7CisgICAgd2ViVmll d0NsaWVudC0+Z2V0R2VvbG9jYXRpb25TZXJ2aWNlSW50ZXJmYWNlQ2hyb21pdW0oKS0+c3RhcnRV cGRhdGluZygKKyAgICAgICAgZ2V0VVJMKCksIHBvc2l0aW9uT3B0aW9ucy0+ZW5hYmxlSGlnaEFj Y3VyYWN5KCkpOworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIEdlb2xvY2F0aW9uU2Vydmlj ZUNocm9taXVtOjpzdG9wVXBkYXRpbmcoKQoreworICAgIFdlYktpdDo6V2ViVmlld0NsaWVudCog d2ViVmlld0NsaWVudCA9IGdldFdlYlZpZXdDbGllbnQoKTsKKyAgICAvLyB3ZWJWaWV3Q2xpZW50 IG1pZ2h0IGJlIE5VTEwgYXQgdGhpcyBwb2ludCBpZiB0aGUgZnJhbWUgaGFzIGJlZW4gZGlzY29u bmVjdGVkLgorICAgIGlmICh3ZWJWaWV3Q2xpZW50KQorICAgIHsKKyAgICAgIHdlYlZpZXdDbGll bnQtPmdldEdlb2xvY2F0aW9uU2VydmljZUludGVyZmFjZUNocm9taXVtKCktPnN0b3BVcGRhdGlu ZygKKyAgICAgICAgICBnZXRVUkwoKSk7CisgICAgICB3ZWJWaWV3Q2xpZW50LT5nZXRHZW9sb2Nh dGlvblNlcnZpY2VJbnRlcmZhY2VDaHJvbWl1bSgpLT5kZXR0YWNoU2VydmljZSgKKyAgICAgICAg ICB0aGlzKTsKKyAgICB9Cit9CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06OnN1 c3BlbmQoKQoreworICAgIGdldFdlYlZpZXdDbGllbnQoKS0+Z2V0R2VvbG9jYXRpb25TZXJ2aWNl SW50ZXJmYWNlQ2hyb21pdW0oKS0+c3VzcGVuZCgKKyAgICAgICAgZ2V0VVJMKCkpOworfQorCit2 b2lkIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpyZXN1bWUoKQoreworICAgIGdldFdlYlZp ZXdDbGllbnQoKS0+Z2V0R2VvbG9jYXRpb25TZXJ2aWNlSW50ZXJmYWNlQ2hyb21pdW0oKS0+cmVz dW1lKAorICAgICAgICBnZXRVUkwoKSk7Cit9CisKK0dlb3Bvc2l0aW9uKiBHZW9sb2NhdGlvblNl cnZpY2VDaHJvbWl1bTo6bGFzdFBvc2l0aW9uKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9MYXN0 UG9zaXRpb24uZ2V0KCk7Cit9CisKK1Bvc2l0aW9uRXJyb3IqIEdlb2xvY2F0aW9uU2VydmljZUNo cm9taXVtOjpsYXN0RXJyb3IoKSBjb25zdAoreworICAgIHJldHVybiBtX0xhc3RFcnJvci5nZXQo KTsKK30KKwordm9pZCBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6c2V0SXNBbGxvd2VkKGJv b2wgYWxsb3dlZCkgeworICBHZW9sb2NhdGlvbiogZ2VvbG9jYXRpb24gPSByZWludGVycHJldF9j YXN0PEdlb2xvY2F0aW9uKj4oZ2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KCkpOworICBpZiAoZ2Vv bG9jYXRpb24pCisgICAgICBnZW9sb2NhdGlvbi0+c2V0SXNBbGxvd2VkKGFsbG93ZWQpOworfQor Cit2b2lkIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpzZXRMYXN0UG9zaXRpb24oZG91Ymxl IGxhdGl0dWRlLCBkb3VibGUgbG9uZ2l0dWRlLCBib29sIHByb3ZpZGVzQWx0aXR1ZGUsIGRvdWJs ZSBhbHRpdHVkZSwgZG91YmxlIGFjY3VyYWN5LCBib29sIHByb3ZpZGVzQWx0aXR1ZGVBY2N1cmFj eSwgZG91YmxlIGFsdGl0dWRlQWNjdXJhY3ksIGJvb2wgcHJvdmlkZXNIZWFkaW5nLCBkb3VibGUg aGVhZGluZywgYm9vbCBwcm92aWRlc1NwZWVkLCBkb3VibGUgc3BlZWQsIGxvbmcgbG9uZyB0aW1l c3RhbXApIHsKKyAgICBtX0xhc3RQb3NpdGlvbiA9IEdlb3Bvc2l0aW9uOjpjcmVhdGUoCisgICAg ICAgIENvb3JkaW5hdGVzOjpjcmVhdGUobGF0aXR1ZGUsIGxvbmdpdHVkZSwgcHJvdmlkZXNBbHRp dHVkZSwgYWx0aXR1ZGUsIGFjY3VyYWN5LCBwcm92aWRlc0FsdGl0dWRlQWNjdXJhY3ksIGFsdGl0 dWRlQWNjdXJhY3ksIHByb3ZpZGVzSGVhZGluZywgaGVhZGluZywgcHJvdmlkZXNTcGVlZCwgc3Bl ZWQpLAorICAgICAgICB0aW1lc3RhbXApOworICAgIHBvc2l0aW9uQ2hhbmdlZCgpOworfQorCit2 b2lkIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpzZXRMYXN0RXJyb3IoRXJyb3JDb2RlIGVy cm9yX2NvZGUsIGNvbnN0IFdlYlN0cmluZyYgbWVzc2FnZSkgeworICAgIG1fTGFzdEVycm9yID0g UG9zaXRpb25FcnJvcjo6Y3JlYXRlKHN0YXRpY19jYXN0PFBvc2l0aW9uRXJyb3I6OkVycm9yQ29k ZT4oZXJyb3JfY29kZSksIG1lc3NhZ2UpOworICAgIGVycm9yT2NjdXJyZWQoKTsKK30KKworV2Vi S2l0OjpXZWJWaWV3Q2xpZW50KiBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6Z2V0V2ViVmll d0NsaWVudCgpIGNvbnN0IHsKKyAgICBGcmFtZSogZnJhbWUgPSByZWludGVycHJldF9jYXN0PEdl b2xvY2F0aW9uKj4oZ2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KCkpLT5mcmFtZSgpOworICAgIGlm ICghZnJhbWUgfHwgIWZyYW1lLT5wYWdlKCkpCisgICAgICAgIHJldHVybiBOVUxMOworICAgIFdl YktpdDo6Q2hyb21lQ2xpZW50SW1wbCogY2hyb21lQ2xpZW50SW1wbCA9IHN0YXRpY19jYXN0PFdl YktpdDo6Q2hyb21lQ2xpZW50SW1wbCo+KGZyYW1lLT5wYWdlKCktPmNocm9tZSgpLT5jbGllbnQo KSk7CisgICAgV2ViS2l0OjpXZWJWaWV3Q2xpZW50KiB3ZWJWaWV3Q2xpZW50ID0gY2hyb21lQ2xp ZW50SW1wbC0+d2ViVmlldygpLT5jbGllbnQoKTsKKyAgICByZXR1cm4gd2ViVmlld0NsaWVudDsK K30KKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisv LyBTZXRzIHVwIHRoZSBmYWN0b3J5IGZ1bmN0aW9uIGZvciBHZW9sb2NhdGlvblNlcnZpY2UuCitH ZW9sb2NhdGlvblNlcnZpY2U6OkZhY3RvcnlGdW5jdGlvbiogR2VvbG9jYXRpb25TZXJ2aWNlOjpz X2ZhY3RvcnlGdW5jdGlvbiA9ICZXZWJLaXQ6OmNyZWF0ZUdlb2xvY2F0aW9uU2VydmljZTsKKwor fSAgLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworCisjZW5kaWYgLy8gRU5BQkxFKEdFT0xPQ0FUSU9O KQoKUHJvcGVydHkgY2hhbmdlcyBvbjogc3JjL0dlb2xvY2F0aW9uU2VydmljZUNocm9taXVtLmNw cApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCkFkZGVkOiBzdm46ZXhlY3V0YWJsZQogICArICoKQWRkZWQ6IHN2bjplb2wt c3R5bGUKICAgKyBMRgoKSW5kZXg6IHNyYy9XZWJWaWV3SW1wbC5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g c3JjL1dlYlZpZXdJbXBsLmNwcAkocmV2aXNpb24gNTM5NDEpCisrKyBzcmMvV2ViVmlld0ltcGwu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOTYsNyArMzk2LDcgQEAgdm9pZCBXZWJWaWV3SW1wbDo6 bW91c2VVcChjb25zdCBXZWJNb3VzZQogICAgICAgICBJbnRQb2ludCBjb250ZW50UG9pbnQgPSB2 aWV3LT53aW5kb3dUb0NvbnRlbnRzKGNsaWNrUG9pbnQpOwogICAgICAgICBIaXRUZXN0UmVzdWx0 IGhpdFRlc3RSZXN1bHQgPSBmb2N1c2VkLT5ldmVudEhhbmRsZXIoKS0+aGl0VGVzdFJlc3VsdEF0 UG9pbnQoY29udGVudFBvaW50LCBmYWxzZSwgZmFsc2UsIFNob3VsZEhpdFRlc3RTY3JvbGxiYXJz KTsKICAgICAgICAgLy8gV2UgZG9uJ3Qgd2FudCB0byBzZW5kIGEgcGFzdGUgd2hlbiBtaWRkbGUg Y2xpY2tpbmcgYSBzY3JvbGwgYmFyIG9yIGEKLSAgICAgICAgLy8gbGluayAod2hpY2ggd2lsbCBu YXZpZ2F0ZSBsYXRlciBpbiB0aGUgY29kZSkuICBUaGUgbWFpbiBzY3JvbGxiYXJzIAorICAgICAg ICAvLyBsaW5rICh3aGljaCB3aWxsIG5hdmlnYXRlIGxhdGVyIGluIHRoZSBjb2RlKS4gIFRoZSBt YWluIHNjcm9sbGJhcnMKICAgICAgICAgLy8gaGF2ZSB0byBiZSBoYW5kbGVkIHNlcGFyYXRlbHku CiAgICAgICAgIGlmICghaGl0VGVzdFJlc3VsdC5zY3JvbGxiYXIoKSAmJiAhaGl0VGVzdFJlc3Vs dC5pc0xpdmVMaW5rKCkgJiYgZm9jdXNlZCAmJiAhdmlldy0+c2Nyb2xsYmFyQXRQb2ludChjbGlj a1BvaW50KSkgewogICAgICAgICAgICAgRWRpdG9yKiBlZGl0b3IgPSBmb2N1c2VkLT5lZGl0b3Io KTsK 48591 2010-02-11 14:33:10 -0800 2010-02-12 09:47:14 -0800 WebCore bits webcore.diff text/plain 10803 bulach SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDU0MzQw KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDIt MDIgIE1hcmN1cyBCdWxhY2ggIDxidWxhY2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEltcGxlbWVudHMgR2VvbG9jYXRpb25T ZXJ2aWNlcyBmb3IgQ2hyb21pdW0uCisgIAkgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTMyMDY4CisKKyAgICAgICAgVGhpcyBpcyBwYXJ0IG9mIGltcGxlbWVudGlu ZyBHZW9sb2NhdGlvbiBmcmFtZXdvcmsgZm9yIENocm9taXVtLiBFeGlzdGluZyBsYXlvdXQgdGVz dHMgc2hvdWxkIHBhc3MuCisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogcGFn ZS9HZW9sb2NhdGlvbi5oOgorICAgICAgICAqIHBsYXRmb3JtL0dlb2xvY2F0aW9uU2VydmljZS5o OgorCiAyMDEwLTAyLTA0ICBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlciAgPHplY2tlQHNlbGZp c2gub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFhhbiBMb3Blei4KSW5kZXg6IFdlYkNvcmUu Z3lwaQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlLmd5cGkJKHJldmlzaW9uIDU0NjUzKQorKysgV2Vi Q29yZS5neXBpCSh3b3JraW5nIGNvcHkpCkBAIC0xOTI1LDYgKzE5MjUsNyBAQAogICAgICAgICAg ICAgJ3BsYXRmb3JtL2Nocm9taXVtL0ZyYW1lbGVzc1Njcm9sbFZpZXcuaCcsCiAgICAgICAgICAg ICAncGxhdGZvcm0vY2hyb21pdW0vRnJhbWVsZXNzU2Nyb2xsVmlld0NsaWVudC5oJywKICAgICAg ICAgICAgICdwbGF0Zm9ybS9jaHJvbWl1bS9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5jcHAn LAorICAgICAgICAgICAgJ3BsYXRmb3JtL2Nocm9taXVtL0dlb2xvY2F0aW9uU2VydmljZUNocm9t aXVtLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2Nocm9taXVtL0tleUNvZGVDb252ZXJzaW9u LmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2Nocm9taXVtL0tleUNvZGVDb252ZXJzaW9uR3Rr LmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vY2hyb21pdW0vS2V5Ym9hcmRDb2Rlc1Bvc2l4 LmgnLApJbmRleDogcGFnZS9HZW9sb2NhdGlvbi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHBhZ2UvR2VvbG9j YXRpb24uaAkocmV2aXNpb24gNTQ2NTMpCisrKyBwYWdlL0dlb2xvY2F0aW9uLmgJKHdvcmtpbmcg Y29weSkKQEAgLTc4LDEwICs3OCwxMyBAQCBwdWJsaWM6CiAgICAgCiAgICAgdm9pZCBzZXRTaG91 bGRDbGVhckNhY2hlKGJvb2wgc2hvdWxkQ2xlYXJDYWNoZSkgeyBtX3Nob3VsZENsZWFyQ2FjaGUg PSBzaG91bGRDbGVhckNhY2hlOyB9CiAgICAgYm9vbCBzaG91bGRDbGVhckNhY2hlKCkgY29uc3Qg eyByZXR1cm4gbV9zaG91bGRDbGVhckNhY2hlOyB9CisgICAgRnJhbWUqIGZyYW1lKCkgY29uc3Qg eyByZXR1cm4gbV9mcmFtZTsgfQogCiAjaWYgRU5BQkxFKENMSUVOVF9CQVNFRF9HRU9MT0NBVElP TikKICAgICB2b2lkIHNldFBvc2l0aW9uKEdlb2xvY2F0aW9uUG9zaXRpb24qKTsKICAgICB2b2lk IHNldEVycm9yKEdlb2xvY2F0aW9uRXJyb3IqKTsKKyNlbHNlCisgICAgR2VvbG9jYXRpb25TZXJ2 aWNlKiBnZXRHZW9sb2NhdGlvblNlcnZpY2UoKSBjb25zdCB7IHJldHVybiBtX3NlcnZpY2UuZ2V0 KCk7IH0KICNlbmRpZgogCiBwcml2YXRlOgpJbmRleDogcGxhdGZvcm0vR2VvbG9jYXRpb25TZXJ2 aWNlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gcGxhdGZvcm0vR2VvbG9jYXRpb25TZXJ2aWNlLmgJKHJldmlz aW9uIDU0NjUzKQorKysgcGxhdGZvcm0vR2VvbG9jYXRpb25TZXJ2aWNlLmgJKHdvcmtpbmcgY29w eSkKQEAgLTIwLDcgKzIwLDcgQEAKICAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKICAqIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAogICogKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFCi0gKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLiAKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgKi8KIAogI2lmbmRlZiBHZW9s b2NhdGlvblNlcnZpY2VfaApAQCAtNDYsMTAgKzQ2LDEwIEBAIGNsYXNzIEdlb2xvY2F0aW9uU2Vy dmljZSA6IHB1YmxpYyBOb25jb3AKIHB1YmxpYzoKICAgICBzdGF0aWMgR2VvbG9jYXRpb25TZXJ2 aWNlKiBjcmVhdGUoR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50Kik7CiAgICAgdmlydHVhbCB+R2Vv bG9jYXRpb25TZXJ2aWNlKCkgeyB9Ci0gICAgCisKICAgICB2aXJ0dWFsIGJvb2wgc3RhcnRVcGRh dGluZyhQb3NpdGlvbk9wdGlvbnMqKSB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgdm9p ZCBzdG9wVXBkYXRpbmcoKSB7IH0KLSAgICAKKwogICAgIHZpcnR1YWwgdm9pZCBzdXNwZW5kKCkg eyB9CiAgICAgdmlydHVhbCB2b2lkIHJlc3VtZSgpIHsgfQogCkBAIC02Myw2ICs2Myw3IEBAIHB1 YmxpYzoKIAogcHJvdGVjdGVkOgogICAgIEdlb2xvY2F0aW9uU2VydmljZShHZW9sb2NhdGlvblNl cnZpY2VDbGllbnQqKTsKKyAgICBHZW9sb2NhdGlvblNlcnZpY2VDbGllbnQqIGdlb2xvY2F0aW9u U2VydmljZUNsaWVudCgpIGNvbnN0IHsgcmV0dXJuIG1fZ2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50 OyB9CiAKIHByaXZhdGU6CiAgICAgR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KiBtX2dlb2xvY2F0 aW9uU2VydmljZUNsaWVudDsKSW5kZXg6IHBsYXRmb3JtL2Nocm9taXVtL0dlb2xvY2F0aW9uU2Vy dmljZUNocm9taXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBwbGF0Zm9ybS9jaHJvbWl1bS9HZW9sb2Nh dGlvblNlcnZpY2VDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDU0NjUzKQorKysgcGxhdGZvcm0vY2hy b21pdW0vR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0y OSwyNyArMjksODEgQEAKICAqLwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCi0jaW5jbHVkZSAiR2Vv bG9jYXRpb25TZXJ2aWNlLmgiCisjaW5jbHVkZSAiR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0u aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1jbGFzcyBHZW9sb2NhdGlvblNlcnZpY2VDaHJv bWl1bSA6IHB1YmxpYyBHZW9sb2NhdGlvblNlcnZpY2UgewotcHVibGljOgotICAgIEdlb2xvY2F0 aW9uU2VydmljZUNocm9taXVtKEdlb2xvY2F0aW9uU2VydmljZUNsaWVudCogYykKLSAgICAgICAg OiBHZW9sb2NhdGlvblNlcnZpY2UoYykKLSAgICB7Ci0gICAgfQotICAgIC8vIEZJWE1FOiBJbXBs ZW1lbnQuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zMjA2OAotfTsK LQotLy8gVGhpcyBndWFyZCBpcyB0aGUgY291bnRlcnBhcnQgb2YgdGhlIG9uZSBpbiBXZWJDb3Jl L3BsYXRmb3JtL0dlb2xvY2F0aW9uU2VydmljZS5jcHAKLSNpZiBFTkFCTEUoR0VPTE9DQVRJT04p Ci1zdGF0aWMgR2VvbG9jYXRpb25TZXJ2aWNlKiBjcmVhdGVHZW9sb2NhdGlvblNlcnZpY2UoR2Vv bG9jYXRpb25TZXJ2aWNlQ2xpZW50KiBjKQorR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06Okdl b2xvY2F0aW9uU2VydmljZUNocm9taXVtKEdlb2xvY2F0aW9uU2VydmljZUNsaWVudCogYykKKyAg ICAgICAgOiBHZW9sb2NhdGlvblNlcnZpY2UoYyksCisgICAgICAgICAgbV9HZW9sb2NhdGlvbihy ZWludGVycHJldF9jYXN0PEdlb2xvY2F0aW9uKj4oYykpCit7CisgICAgbV9MYXN0UG9zaXRpb24g PSBHZW9wb3NpdGlvbjo6Y3JlYXRlKAorICAgICAgICBDb29yZGluYXRlczo6Y3JlYXRlKDAuMCwg MC4wLCBmYWxzZSwgMC4wLCAwLjAsIGZhbHNlLCAwLjAsIGZhbHNlLCAwLjAsIGZhbHNlLCAwLjAp LAorICAgICAgICAwKTsKKyAgICBtX0xhc3RFcnJvciA9IFBvc2l0aW9uRXJyb3I6OmNyZWF0ZShQ b3NpdGlvbkVycm9yOjpQT1NJVElPTl9VTkFWQUlMQUJMRSwgIiIpOworICAgIG1fZ2VvbG9jYXRp b25TZXJ2aWNlQnJpZGdlLnNldCgoKnNfYnJpZGdlRmFjdG9yeUZ1bmN0aW9uKSh0aGlzKSk7Cit9 CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06OnNldElzQWxsb3dlZChib29sIGFs bG93ZWQpCit7CisgICAgbV9HZW9sb2NhdGlvbi0+c2V0SXNBbGxvd2VkKGFsbG93ZWQpOyAgCit9 CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06OnNldExhc3RQb3NpdGlvbihkb3Vi bGUgbGF0aXR1ZGUsIGRvdWJsZSBsb25naXR1ZGUsIGJvb2wgcHJvdmlkZXNBbHRpdHVkZSwgZG91 YmxlIGFsdGl0dWRlLCBkb3VibGUgYWNjdXJhY3ksIGJvb2wgcHJvdmlkZXNBbHRpdHVkZUFjY3Vy YWN5LCBkb3VibGUgYWx0aXR1ZGVBY2N1cmFjeSwgYm9vbCBwcm92aWRlc0hlYWRpbmcsIGRvdWJs ZSBoZWFkaW5nLCBib29sIHByb3ZpZGVzU3BlZWQsIGRvdWJsZSBzcGVlZCwgbG9uZyBsb25nIHRp bWVzdGFtcCkKK3sKKyAgICBtX0xhc3RQb3NpdGlvbiA9IEdlb3Bvc2l0aW9uOjpjcmVhdGUoCisg ICAgICAgIENvb3JkaW5hdGVzOjpjcmVhdGUobGF0aXR1ZGUsIGxvbmdpdHVkZSwgcHJvdmlkZXNB bHRpdHVkZSwgYWx0aXR1ZGUsIGFjY3VyYWN5LCBwcm92aWRlc0FsdGl0dWRlQWNjdXJhY3ksIGFs dGl0dWRlQWNjdXJhY3ksIHByb3ZpZGVzSGVhZGluZywgaGVhZGluZywgcHJvdmlkZXNTcGVlZCwg c3BlZWQpLAorICAgICAgICB0aW1lc3RhbXApOworICAgIHBvc2l0aW9uQ2hhbmdlZCgpOworfQor Cit2b2lkIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpzZXRMYXN0RXJyb3IoaW50IGVycm9y X2NvZGUsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSkKK3sKKyAgICBtX0xhc3RFcnJvciA9IFBvc2l0 aW9uRXJyb3I6OmNyZWF0ZShzdGF0aWNfY2FzdDxQb3NpdGlvbkVycm9yOjpFcnJvckNvZGU+KGVy cm9yX2NvZGUpLCBtZXNzYWdlKTsKKyAgICBlcnJvck9jY3VycmVkKCk7Cit9CisKK0ZyYW1lKiBH ZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6ZnJhbWUoKQoreworICAgIHJldHVybiBtX0dlb2xv Y2F0aW9uLT5mcmFtZSgpOworfQorCitib29sIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpz dGFydFVwZGF0aW5nKFBvc2l0aW9uT3B0aW9ucyogb3B0aW9ucykKK3sKKyAgICByZXR1cm4gbV9n ZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2UtPnN0YXJ0VXBkYXRpbmcob3B0aW9ucyk7Cit9CisKK3Zv aWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06OnN0b3BVcGRhdGluZygpCit7CisgICAgcmV0 dXJuIG1fZ2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlLT5zdG9wVXBkYXRpbmcoKTsKK30KKwordm9p ZCBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6c3VzcGVuZCgpCit7CisgICAgcmV0dXJuIG1f Z2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlLT5zdXNwZW5kKCk7Cit9CisKK3ZvaWQgR2VvbG9jYXRp b25TZXJ2aWNlQ2hyb21pdW06OnJlc3VtZSgpCit7CisgICAgcmV0dXJuIG1fZ2VvbG9jYXRpb25T ZXJ2aWNlQnJpZGdlLT5yZXN1bWUoKTsKK30KKworR2VvcG9zaXRpb24qIEdlb2xvY2F0aW9uU2Vy dmljZUNocm9taXVtOjpsYXN0UG9zaXRpb24oKSBjb25zdAoreworICAgIHJldHVybiBtX0xhc3RQ b3NpdGlvbi5nZXQoKTsKK30KKworUG9zaXRpb25FcnJvciogR2VvbG9jYXRpb25TZXJ2aWNlQ2hy b21pdW06Omxhc3RFcnJvcigpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fTGFzdEVycm9yLmdldCgp OworfQorCitzdGF0aWMgR2VvbG9jYXRpb25TZXJ2aWNlKiBjcmVhdGVHZW9sb2NhdGlvblNlcnZp Y2VDaHJvbWl1bShHZW9sb2NhdGlvblNlcnZpY2VDbGllbnQqIGMpCiB7CiAgICAgcmV0dXJuIG5l dyBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bShjKTsKIH0KIAotR2VvbG9jYXRpb25TZXJ2aWNl OjpGYWN0b3J5RnVuY3Rpb24qIEdlb2xvY2F0aW9uU2VydmljZTo6c19mYWN0b3J5RnVuY3Rpb24g PSAmY3JlYXRlR2VvbG9jYXRpb25TZXJ2aWNlOwotI2VuZGlmCisvLyBTZXRzIHVwIHRoZSBmYWN0 b3J5IGZ1bmN0aW9uIGZvciBHZW9sb2NhdGlvblNlcnZpY2UuCitHZW9sb2NhdGlvblNlcnZpY2U6 OkZhY3RvcnlGdW5jdGlvbiogR2VvbG9jYXRpb25TZXJ2aWNlOjpzX2ZhY3RvcnlGdW5jdGlvbiA9 ICZjcmVhdGVHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpJbmRleDogcGxhdGZvcm0vY2hyb21pdW0vR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0u aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBwbGF0Zm9ybS9jaHJvbWl1bS9HZW9sb2NhdGlvblNlcnZpY2VDaHJv bWl1bS5oCShyZXZpc2lvbiAwKQorKysgcGxhdGZvcm0vY2hyb21pdW0vR2VvbG9jYXRpb25TZXJ2 aWNlQ2hyb21pdW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw4NCBAQAorLyoKKyAqIENvcHly aWdodCAoYykgMjAwOSwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIAorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKiAKKyAqICAgICAqIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmli dXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUg bmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBw cm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNw ZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqIAorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICog IkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlICJHZW9sb2Nh dGlvbi5oIgorI2luY2x1ZGUgIkdlb2xvY2F0aW9uU2VydmljZS5oIgorI2luY2x1ZGUgIkdlb3Bv c2l0aW9uLmgiCisjaW5jbHVkZSAiUG9zaXRpb25FcnJvci5oIgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKKy8vIFByb3ZpZGVzIGFuIGludGVyZmFjZSBmb3IgR2VvbG9jYXRpb25TZXJ2aWNlQ2hy b21pdW0gdG8gY2FsbCBpbnRvIGNocm9taXVtLgorY2xhc3MgR2VvbG9jYXRpb25TZXJ2aWNlQnJp ZGdlIHsKK3B1YmxpYzoKKyAgICAvLyBDYWxsZWQgYnkgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21p dW0uCisgICAgdmlydHVhbCBib29sIHN0YXJ0VXBkYXRpbmcoUG9zaXRpb25PcHRpb25zKikgPSAw OworICAgIHZpcnR1YWwgdm9pZCBzdG9wVXBkYXRpbmcoKSA9IDA7CisgICAgdmlydHVhbCB2b2lk IHN1c3BlbmQoKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHJlc3VtZSgpID0gMDsKKworICAgIC8v IENhbGxlZCBieSB0aGUgQ2hyb21pdW0gc2lkZSwgdG8gaWRlbnRpZnkgdGhpcyBicmlkZ2UuLgor ICAgIHZpcnR1YWwgaW50IGdldEJyaWRnZUlkKCkgY29uc3QgPSAwOworfTsKKworLy8gVGhpcyBj bGFzcyBleHRlbmRzIEdlb2xvY2F0aW9uU2VydmljZSwgYW5kIHVzZXMgR2VvbG9jYXRpb25TZXJ2 aWNlQnJpZGdlIHRvCisvLyBjYWxsIGludG8gY2hyb21pdW0sIGFzIHdlbGwgYXMgcHJvdmlkZXMg YSBmZXcgZXh0cmEgbWV0aG9kcyBzbyB0aGF0IHdlIGNhbgorLy8gYmUgbm90aWZpZWQgb2YgcGVy bWlzc2lvbiwgcG9zaXRpb24sIGVycm9yLCBldGMsIGZyb20gY2hyb21pdW0uCitjbGFzcyBHZW9s b2NhdGlvblNlcnZpY2VDaHJvbWl1bSA6IHB1YmxpYyBHZW9sb2NhdGlvblNlcnZpY2UgeworcHVi bGljOgorICAgIGV4cGxpY2l0IEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKEdlb2xvY2F0aW9u U2VydmljZUNsaWVudCogYyk7CisKKyAgICBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2UqIGdlb2xv Y2F0aW9uU2VydmljZUJyaWRnZSgpIGNvbnN0IHsgcmV0dXJuIG1fZ2VvbG9jYXRpb25TZXJ2aWNl QnJpZGdlLmdldCgpOyB9CisgICAgdm9pZCBzZXRJc0FsbG93ZWQoYm9vbCBhbGxvd2VkKTsKKyAg ICB2b2lkIHNldExhc3RQb3NpdGlvbihkb3VibGUgbGF0aXR1ZGUsIGRvdWJsZSBsb25naXR1ZGUs IGJvb2wgcHJvdmlkZXNBbHRpdHVkZSwgZG91YmxlIGFsdGl0dWRlLCBkb3VibGUgYWNjdXJhY3ks IGJvb2wgcHJvdmlkZXNBbHRpdHVkZUFjY3VyYWN5LCBkb3VibGUgYWx0aXR1ZGVBY2N1cmFjeSwg Ym9vbCBwcm92aWRlc0hlYWRpbmcsIGRvdWJsZSBoZWFkaW5nLCBib29sIHByb3ZpZGVzU3BlZWQs IGRvdWJsZSBzcGVlZCwgbG9uZyBsb25nIHRpbWVzdGFtcCk7CisgICAgdm9pZCBzZXRMYXN0RXJy b3IoaW50IGVycm9yX2NvZGUsIGNvbnN0IFN0cmluZyYgbWVzc2FnZSk7CisgICAgRnJhbWUqIGZy YW1lKCk7CisKKyAgICAvLyBGcm9tIEdlb2xvY2F0aW9uU2VydmljZS4KKyAgICB2aXJ0dWFsIGJv b2wgc3RhcnRVcGRhdGluZyhQb3NpdGlvbk9wdGlvbnMqKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3Rv cFVwZGF0aW5nKCk7CisgICAgdmlydHVhbCB2b2lkIHN1c3BlbmQoKTsKKyAgICB2aXJ0dWFsIHZv aWQgcmVzdW1lKCk7CisgICAgdmlydHVhbCBHZW9wb3NpdGlvbiogbGFzdFBvc2l0aW9uKCkgY29u c3Q7CisgICAgdmlydHVhbCBQb3NpdGlvbkVycm9yKiBsYXN0RXJyb3IoKSBjb25zdDsKKworcHJp dmF0ZToKKyAgICBHZW9sb2NhdGlvbiogbV9HZW9sb2NhdGlvbjsKKyAgICBPd25QdHI8R2VvbG9j YXRpb25TZXJ2aWNlQnJpZGdlKj4gbV9nZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2U7ICAgIAorICAg IFJlZlB0cjxHZW9wb3NpdGlvbj4gbV9MYXN0UG9zaXRpb247CisgICAgUmVmUHRyPFBvc2l0aW9u RXJyb3I+IG1fTGFzdEVycm9yOworCisgICAgdHlwZWRlZiBHZW9sb2NhdGlvblNlcnZpY2VCcmlk Z2UqIChCcmlkZ2VGYWN0b3J5RnVuY3Rpb24pKEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKik7 CisgICAgc3RhdGljIEJyaWRnZUZhY3RvcnlGdW5jdGlvbiogc19icmlkZ2VGYWN0b3J5RnVuY3Rp b247Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCgpQcm9wZXJ0eSBjaGFuZ2VzIG9uOiBw bGF0Zm9ybS9jaHJvbWl1bS9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5oCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K QWRkZWQ6IHN2bjplb2wtc3R5bGUKICAgKyBMRgoK 48592 2010-02-11 14:33:40 -0800 2010-02-12 09:47:14 -0800 WebKit bits webkit.diff text/plain 17644 bulach SW5kZXg6IENoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBDaGFuZ2VMb2cJKHJldmlzaW9uIDU0MzQw KQorKysgQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTggQEAKKzIwMTAtMDEt MjggIE1hcmN1cyBCdWxhY2ggIDxidWxhY2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEltcGxlbWVudHMgR2VvbG9jYXRpb25T ZXJ2aWNlcyBmb3IgQ2hyb21pdW0uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0zMjA2OAorCisgICAgICAgIFRoaXMgaXMgcGFydCBvZiBpbXBsZW1lbnRp bmcgR2VvbG9jYXRpb24gZnJhbWV3b3JrIGZvciBDaHJvbWl1bS4gRXhpc3RpbmcgbGF5b3V0IHRl c3RzIHNob3VsZCBwYXNzLgorCisgICAgICAgICogcHVibGljL0dlb2xvY2F0aW9uU2VydmljZUJy aWRnZUNocm9taXVtLmgKKyAgICAgICAgKiBwdWJsaWMvV2ViVmlld0NsaWVudC5oCisgICAgICAg ICogc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwOgorICAgICAgICAqIHNyYy9DaHJvbWVDbGllbnRJ bXBsLmg6CisgICAgICAgICogc3JjL0dlb2xvY2F0aW9uU2VydmljZUNocm9taXVtLmNwcAorCiAy MDEwLTAyLTA0ICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFVucmV2aWV3ZWQuIFJldmVydCA1NDMzMyB3aGljaCBicm9rZSBDaHJvbWl1bSBidWlsZC4K SW5kZXg6IFdlYktpdC5neXAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0Lmd5cAkocmV2aXNpb24gNTQ2 NTMpCisrKyBXZWJLaXQuZ3lwCSh3b3JraW5nIGNvcHkpCkBAIC02OCw2ICs2OCw3IEBACiAgICAg ICAgICAgICAgICAgJ1dFQktJVF9JTVBMRU1FTlRBVElPTicsCiAgICAgICAgICAgICBdLAogICAg ICAgICAgICAgJ3NvdXJjZXMnOiBbCisgICAgICAgICAgICAgICAgJ3B1YmxpYy9HZW9sb2NhdGlv blNlcnZpY2VCcmlkZ2UuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9ndGsvV2ViSW5wdXRF dmVudEZhY3RvcnkuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9saW51eC9XZWJGb250UmVu ZGVyaW5nLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvbGludXgvV2ViUmVuZGVyVGhlbWUu aCcsCkBAIC0yMzEsNiArMjMyLDcgQEAKICAgICAgICAgICAgICAgICAnc3JjL0V2ZW50TGlzdGVu ZXJXcmFwcGVyLmgnLAogICAgICAgICAgICAgICAgICdzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBs LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuaCcsCisg ICAgICAgICAgICAgICAgJ3NyYy9HZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5jcHAn LAkJCiAgICAgICAgICAgICAgICAgJ3NyYy9ndGsvV2ViRm9udEluZm8uY3BwJywKICAgICAgICAg ICAgICAgICAnc3JjL2d0ay9XZWJGb250SW5mby5oJywKICAgICAgICAgICAgICAgICAnc3JjL2d0 ay9XZWJJbnB1dEV2ZW50RmFjdG9yeS5jcHAnLApJbmRleDogcHVibGljL0dlb2xvY2F0aW9uU2Vy dmljZUJyaWRnZUNocm9taXVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcHVibGljL0dlb2xvY2F0aW9uU2Vy dmljZUJyaWRnZUNocm9taXVtLmgJKHJldmlzaW9uIDApCisrKyBwdWJsaWMvR2VvbG9jYXRpb25T ZXJ2aWNlQnJpZGdlQ2hyb21pdW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw5MSBAQAorLyoK KyAqIENvcHlyaWdodCAoYykgMjAwOSwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAg KiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICog ZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBu b3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9y c2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0 aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9S UworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVS IE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAq IFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZu ZGVmIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZV9oCisjZGVmaW5lIEdlb2xvY2F0aW9uU2Vydmlj ZUJyaWRnZV9oCisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBXZWJTdHJpbmc7CitjbGFz cyBXZWJVUkw7CisKKy8vIFRoaXMgaXMgdGhlIGZsb3cgZnJvbSBXZWJLaXQgLT4gQ2hyb21pdW06 CisvLyAtIFdlYkNvcmU6Okdlb2xvY2F0aW9uIG93bnMgV2ViQ29yZTo6R2VvbG9jYXRpb25TZXJ2 aWNlQ2hyb21pdW0gKGNyZWF0ZWQgdmlhCisvLyBhIGZhY3RvcnkgZnVuY3Rpb24pLgorLy8gLSBX ZWJDb3JlOjpHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bSBvd25zIFdlYkNvcmU6Okdlb2xvY2F0 aW9uU2VydmljZUJyaWRnZQorLy8gKGNyZWF0ZWQgdmlhIGEgZmFjdG9yeSBmdW5jdGlvbikgYW5k IGltcGxlbWVudGVkIGJ5CisvLyBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsLgorLy8gLSBB bGwgY2FsbHMgZnJvbSBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bSBhcmUgdGhlbiBkZWxlZ2F0 ZWQgdG8KKy8vIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUltcGwsIHdoaWNoIHRoZW4gZGVsZWdh dGVzIHRvCisvLyBHZW9sb2NhdGlvblNlcnZpY2VJbnRlcmZhY2UgcHJvdmlkZWQgYnkKKy8vIFdl YktpdDo6V2ViVmlld0NsaWVudDo6Z2V0V2ViVmlld0NsaWVudCBhbmQgaW1wbGVtZW50ZWQgYnkK Ky8vIEdlb2xvY2F0aW9uRGlzcGF0Y2hlci4KKy8vIC0gTm90ZTogV2ViQ29yZTo6R2VvbG9jYXRp b24gaXMgc2xpZ2h0bHkgZGlmZmVyZW50IGFzIGl0IGNhbGxzIGRpcmVjdGx5CisvLyBDaHJvbWVD bGllbnRJbXBsOjpyZXF1ZXN0R2VvbG9jYXRpb25QZXJtaXNzaW9uRm9yRnJhbWU6IGl0IGRvZXNu J3QgdXNlIHRoZQorLy8gR2VvbG9jYXRpb25TZXJ2aWNlIG9yIGl0cyBicmlkZ2UuIEhvd2V2ZXIs IHRoZSByZXNwb25zZSBjb21lcyBiYWNrIHZpYQorLy8gdGhlIGJyaWRnZS4KKy8vCisvLyBUaGlz IGlzIHRoZSBmbG93IGZyb20gQ2hyb21pdW0gLT4gV2ViS2l0OgorLy8gLSBHZW9sb2NhdGlvblNl cnZpY2VCcmlkZ2VJbXBsIGFsc28gaW1wbGVtZW50cyBXZWJHZW9sb2NhdGlvblNlcnZpY2VCcmlk Z2UuCisvLyAtIEl0IHJlZ2lzdGVycyBpdHNlbGYgdmlhCisvLyBXZWJLaXQ6OldlYlZpZXdDbGll bnQ6OmdldFdlYlZpZXdDbGllbnQ6OmF0dGFjaEJyaWRnZS4KKy8vIENocm9taXVtIHRoZW4gZWl0 aGVyIHRyYXZlcnNlcyBpdHMgcmVnaXN0cnkgdG8gYnJvYWRjYXN0IHBvc2l0aW9uIHVwZGF0ZXMg LworLy8gZXJyb3JzLCBvciBjYWxscyBhIHNwZWNpZmljIGJyaWRnZSB0byBub3RpZnkgcGVybWlz c2lvbi4KK2NsYXNzIFdlYkdlb2xvY2F0aW9uU2VydmljZUJyaWRnZSB7CitwdWJsaWM6CisgICAg dmlydHVhbCB2b2lkIHNldElzQWxsb3dlZChib29sIGFsbG93ZWQpID0gMDsKKyAgICB2aXJ0dWFs IHZvaWQgc2V0TGFzdFBvc2l0aW9uKGRvdWJsZSBsYXRpdHVkZSwgZG91YmxlIGxvbmdpdHVkZSwg Ym9vbCBwcm92aWRlc0FsdGl0dWRlLCBkb3VibGUgYWx0aXR1ZGUsIGRvdWJsZSBhY2N1cmFjeSwg Ym9vbCBwcm92aWRlc0FsdGl0dWRlQWNjdXJhY3ksIGRvdWJsZSBhbHRpdHVkZUFjY3VyYWN5LCBi b29sIHByb3ZpZGVzSGVhZGluZywgZG91YmxlIGhlYWRpbmcsIGJvb2wgcHJvdmlkZXNTcGVlZCwg ZG91YmxlIHNwZWVkLCBsb25nIGxvbmcgdGltZXN0YW1wKSA9IDA7CisgICAgdmlydHVhbCB2b2lk IHNldExhc3RFcnJvcihpbnQgZXJyb3JfY29kZSwgY29uc3QgV2ViU3RyaW5nJiBtZXNzYWdlKSA9 IDA7Cit9OworCisvLyBUaGlzIGlzIHRoZSBpbnRlcmZhY2UgdXNlZCBieSBXZWJDb3JlOjpHZW9s b2NhdGlvblNlcnZpY2VDaHJvbWl1bSB0bworLy8gY29tbXVuaWNhdGUgd2l0aCBjaHJvbWl1bS4K K2NsYXNzIEdlb2xvY2F0aW9uU2VydmljZUludGVyZmFjZSB7CitwdWJsaWM6CisgIC8vIFJlcXVl c3RzIHBlcm1pc3Npb24gZm9yIHRoaXMgZnJhbWUuCisgIHZpcnR1YWwgdm9pZCByZXF1ZXN0UGVy bWlzc2lvbkZvckZyYW1lKGludCBicmlkZ2VfaWQsIGNvbnN0IFdlYlVSTCYgdXJsKSA9IDA7Cisg IC8vIEFza3MgdGhlIGJyb3dzZXIgcHJvY2VzcyB0byBzdGFydCB1cGRhdGluZyBnZW9sb2NhdGlv bi4KKyAgdmlydHVhbCB2b2lkIHN0YXJ0VXBkYXRpbmcoaW50IGJyaWRnZV9pZCwgYm9vbCBoYXNI aWdoQWNjdXJhY3kpID0gMDsKKyAgLy8gQXNrcyB0aGUgYnJvd3NlciBwcm9jZXNzIHRvIHN0b3Ag dXBkYXRpbmcgZ2VvbG9jYXRpb24uCisgIHZpcnR1YWwgdm9pZCBzdG9wVXBkYXRpbmcoaW50IGJy aWRnZV9pZCkgPSAwOworICAvLyBBc2tzIHRoZSBicm93c2VyIHByb2Nlc3MgdG8gc3VzcGVuZCB1 cGRhdGluZyBnZW9sb2NhdGlvbi4KKyAgdmlydHVhbCB2b2lkIHN1c3BlbmQoaW50IGJyaWRnZV9p ZCkgPSAwOworICAvLyBBc2tzIHRoZSBicm93c2VyIHByb2Nlc3MgdG8gcmVzdW1lIHVwZGF0aW5n IGdlb2xvY2F0aW9uLgorICB2aXJ0dWFsIHZvaWQgcmVzdW1lKGludCBicmlkZ2VfaWQpID0gMDsK KyAgLy8gQXR0YWNoZXMgdGhlIEdlb2xvY2F0aW9uQnJpZGdlIHRvIHRoaXMgdmlldyBhbmQgcmV0 dXJucyBpdHMgaWQsIHdoaWNoCisgIC8vIHNob3VsZCBiZSB1c2VkIG9uIHN1YnNlcXVlbnQgY2Fs bHMgZm9yIHRoZSBtZXRob2RzIGFib3ZlLgorICB2aXJ0dWFsIGludCBhdHRhY2hCcmlkZ2UoV2Vi S2l0OjpXZWJHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2UqIGdlb2xvY2F0aW9uU2VydmljZUJyaWRn ZSkgPSAwOworICAvLyBEZXR0YWNoZXMgdGhlIEdlb2xvY2F0aW9uU2VydmljZSBmcm9tIHRoaXMg dmlldy4KKyAgdmlydHVhbCB2b2lkIGRldHRhY2hCcmlkZ2UoaW50IGJyaWRnZV9pZCkgPSAwOwor fTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZiAgLy8gR2VvbG9jYXRpb25TZXJ2 aWNlQnJpZGdlX2gKClByb3BlcnR5IGNoYW5nZXMgb246IHB1YmxpYy9HZW9sb2NhdGlvblNlcnZp Y2VCcmlkZ2VDaHJvbWl1bS5oCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjplb2wtc3R5bGUKICAgKyBM RgoKSW5kZXg6IHB1YmxpYy9XZWJWaWV3Q2xpZW50LmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcHVibGljL1dl YlZpZXdDbGllbnQuaAkocmV2aXNpb24gNTQ2NTMpCisrKyBwdWJsaWMvV2ViVmlld0NsaWVudC5o CSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0Miw3IEBACiAKIG5hbWVzcGFjZSBXZWJLaXQgewog CitjbGFzcyBHZW9sb2NhdGlvblNlcnZpY2VJbnRlcmZhY2U7CiBjbGFzcyBXZWJBY2Nlc3NpYmls aXR5T2JqZWN0OwogY2xhc3MgV2ViRHJhZ0RhdGE7CiBjbGFzcyBXZWJGaWxlQ2hvb3NlckNvbXBs ZXRpb247CkBAIC0yNzcsNiArMjc4LDE2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgcmVt b3ZlQXV0b2ZpbGxTdWdnZXN0aW9ucyhjb25zdCBXZWJTdHJpbmcmIG5hbWUsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgV2ViU3RyaW5nJiB2YWx1ZSkg eyB9CiAKKyAgICAvLyBHZW9sb2NhdGlvbiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAvLyBHZW9sb2NhdGlvbiByZWxhdGVkIGZ1 bmN0aW9ucy4gVGhpcyBpcyB0aGUgQVBJIHVzZWQgYnkKKyAgICAvLyBXZWJLaXQ6Okdlb2xvY2F0 aW9uU2VydmljZUNocm9taXVtIGFuZCBDaHJvbWVDbGllbnRJbXBsIHRvIGlzc3VlIElQQworICAg IC8vIHJlcXVlc3RzIHRvIHRoZSBicm93c2VyIHByb2Nlc3MuCisKKyAgICAvLyBSZXF1ZXN0cyBw ZXJtaXNzaW9uIGZvciB0aGlzIGZyYW1lLgorICAgIHZpcnR1YWwgV2ViS2l0OjpHZW9sb2NhdGlv blNlcnZpY2VJbnRlcmZhY2UqIGdldEdlb2xvY2F0aW9uU2VydmljZSgpIHsKKyAgICAgIHJldHVy biBOVUxMOworICAgIH0KKwogcHJvdGVjdGVkOgogICAgIH5XZWJWaWV3Q2xpZW50KCkgeyB9CiB9 OwpJbmRleDogc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHNyYy9DaHJv bWVDbGllbnRJbXBsLmNwcAkocmV2aXNpb24gNTQ2NTMpCisrKyBzcmMvQ2hyb21lQ2xpZW50SW1w bC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQzLDYgKzQzLDEwIEBACiAjaW5jbHVkZSAiRmxvYXRS ZWN0LmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkUmVxdWVzdC5oIgogI2luY2x1ZGUgIkZyYW1lVmll dy5oIgorI2luY2x1ZGUgIkdlb2xvY2F0aW9uLmgiCisjaW5jbHVkZSAiR2VvbG9jYXRpb25TZXJ2 aWNlLmgiCisjaW5jbHVkZSAiR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlQ2hyb21pdW0uaCIKKyNp bmNsdWRlICJHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5oIgogI2luY2x1ZGUgIkhpdFRlc3RS ZXN1bHQuaCIKICNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiTm9kZS5oIgpAQCAtNjc0 LDQgKzY3OCwxNCBAQCBOb3RpZmljYXRpb25QcmVzZW50ZXIqIENocm9tZUNsaWVudEltcGw6CiB9 CiAjZW5kaWYKIAordm9pZCBDaHJvbWVDbGllbnRJbXBsOjpyZXF1ZXN0R2VvbG9jYXRpb25QZXJt aXNzaW9uRm9yRnJhbWUoCisgICAgICAgIEZyYW1lKiBmcmFtZSwgR2VvbG9jYXRpb24qIGdlb2xv Y2F0aW9uKSB7CisgIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKiBnZW9sb2NhdGlvbl9zZXJ2 aWNlID0KKyAgICAgIHJlaW50ZXJwcmV0X2Nhc3Q8R2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0q PigKKyAgICAgICAgICBnZW9sb2NhdGlvbi0+Z2V0R2VvbG9jYXRpb25TZXJ2aWNlKCkpOworICBt X3dlYlZpZXctPmNsaWVudCgpLT5nZXRHZW9sb2NhdGlvblNlcnZpY2UoKS0+CisgICAgICByZXF1 ZXN0UGVybWlzc2lvbkZvckZyYW1lKGdlb2xvY2F0aW9uX3NlcnZpY2UtPmdlb2xvY2F0aW9uU2Vy dmljZUJyaWRnZSgpLT5nZXRCcmlkZ2VJZCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBmcmFtZS0+ZG9jdW1lbnQoKS0+dXJsKCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJL aXQKSW5kZXg6IHNyYy9DaHJvbWVDbGllbnRJbXBsLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3JjL0Nocm9t ZUNsaWVudEltcGwuaAkocmV2aXNpb24gNTQ2NTMpCisrKyBzcmMvQ2hyb21lQ2xpZW50SW1wbC5o CSh3b3JraW5nIGNvcHkpCkBAIC0xMjIsNyArMTIyLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwg V2ViQ29yZTo6Tm90aWZpY2F0aW9uUHJlc2VudGVyKiBub3RpZmljYXRpb25QcmVzZW50ZXIoKSBj b25zdDsKICNlbmRpZgogICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0R2VvbG9jYXRpb25QZXJtaXNz aW9uRm9yRnJhbWUoCi0gICAgICAgIFdlYkNvcmU6OkZyYW1lKiwgV2ViQ29yZTo6R2VvbG9jYXRp b24qKSB7IH0KKyAgICAgICAgV2ViQ29yZTo6RnJhbWUqLCBXZWJDb3JlOjpHZW9sb2NhdGlvbiop OwogICAgIHZpcnR1YWwgdm9pZCBydW5PcGVuUGFuZWwoV2ViQ29yZTo6RnJhbWUqLCBQYXNzUmVm UHRyPFdlYkNvcmU6OkZpbGVDaG9vc2VyPik7CiAgICAgdmlydHVhbCBib29sIHNldEN1cnNvcihX ZWJDb3JlOjpQbGF0Zm9ybUN1cnNvckhhbmRsZSkgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0 dWFsIHZvaWQgZm9ybVN0YXRlRGlkQ2hhbmdlKGNvbnN0IFdlYkNvcmU6Ok5vZGUqKTsKSW5kZXg6 IHNyYy9HZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g c3JjL0dlb2xvY2F0aW9uU2VydmljZUJyaWRnZUNocm9taXVtLmNwcAkocmV2aXNpb24gMCkKKysr IHNyYy9HZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5jcHAJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEsMTc0IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA5LCBHb29nbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICpnZW9sb2NhdGlvbl9wZXJtaXNzaW9uX2NvbnRleHQKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICpnZW9sb2NhdGlvbl9wZXJt aXNzaW9uX2NvbnRleHQKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5 cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRo ZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRv cnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJv bQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlz c2lvbi4KKyAqZ2VvbG9jYXRpb25fcGVybWlzc2lvbl9jb250ZXh0CisgKiBUSElTIFNPRlRXQVJF IElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisg KiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1Ig Q09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5D TFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRF IEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9S IEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhF T1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwg T1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRl ICJHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5oIgorI2luY2x1ZGUgIkdlb2xvY2F0aW9uU2Vy dmljZUJyaWRnZUNocm9taXVtLmgiCisjaW5jbHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ2hy b21lQ2xpZW50SW1wbC5oIgorI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiR2VvbG9jYXRp b24uaCIKKyNpbmNsdWRlICJHZW9wb3NpdGlvbi5oIgorI2luY2x1ZGUgIlBhZ2UuaCIKKyNpbmNs dWRlICJQb3NpdGlvbkVycm9yLmgiCisjaW5jbHVkZSAiUG9zaXRpb25PcHRpb25zLmgiCisjaW5j bHVkZSAiV2ViRnJhbWUuaCIKKyNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNpbmNsdWRlICJX ZWJWaWV3Q2xpZW50LmgiCisjaW5jbHVkZSAiV2ViVmlld0ltcGwuaCIKKworI2lmIEVOQUJMRShH RU9MT0NBVElPTikKKwordXNpbmcgV2ViQ29yZTo6Q29vcmRpbmF0ZXM7Cit1c2luZyBXZWJDb3Jl OjpGcmFtZTsKK3VzaW5nIFdlYkNvcmU6Okdlb2xvY2F0aW9uOwordXNpbmcgV2ViQ29yZTo6R2Vv bG9jYXRpb25TZXJ2aWNlQ2hyb21pdW07Cit1c2luZyBXZWJDb3JlOjpHZW9sb2NhdGlvblNlcnZp Y2VCcmlkZ2U7Cit1c2luZyBXZWJDb3JlOjpHZW9sb2NhdGlvblNlcnZpY2VDbGllbnQ7Cit1c2lu ZyBXZWJDb3JlOjpHZW9wb3NpdGlvbjsKK3VzaW5nIFdlYkNvcmU6OlBvc2l0aW9uRXJyb3I7Cit1 c2luZyBXZWJDb3JlOjpQb3NpdGlvbk9wdGlvbnM7Cit1c2luZyBXZWJDb3JlOjpTdHJpbmc7CisK K25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBs CisgICAgOiBwdWJsaWMgR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlLCBwdWJsaWMgV2ViR2VvbG9j YXRpb25TZXJ2aWNlQnJpZGdlIHsKK3B1YmxpYzoKKyAgICBleHBsaWNpdCBHZW9sb2NhdGlvblNl cnZpY2VCcmlkZ2VJbXBsKEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKiBjKTsKKyAgICB2aXJ0 dWFsIH5HZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsKCk7CisKKyAgICAvLyBHZW9sb2NhdGlv blNlcnZpY2VCcmlkZ2UKKyAgICB2aXJ0dWFsIGJvb2wgc3RhcnRVcGRhdGluZyhQb3NpdGlvbk9w dGlvbnMqKTsKKyAgICB2aXJ0dWFsIHZvaWQgc3RvcFVwZGF0aW5nKCk7CisgICAgdmlydHVhbCB2 b2lkIHN1c3BlbmQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVzdW1lKCk7CisgICAgdmlydHVhbCBp bnQgZ2V0QnJpZGdlSWQoKSBjb25zdDsKKworICAgIC8vIFdlYkdlb2xvY2F0aW9uU2VydmljZUJy aWRnZQorICAgIHZpcnR1YWwgdm9pZCBzZXRJc0FsbG93ZWQoYm9vbCBhbGxvd2VkKTsKKyAgICB2 aXJ0dWFsIHZvaWQgc2V0TGFzdFBvc2l0aW9uKGRvdWJsZSBsYXRpdHVkZSwgZG91YmxlIGxvbmdp dHVkZSwgYm9vbCBwcm92aWRlc0FsdGl0dWRlLCBkb3VibGUgYWx0aXR1ZGUsIGRvdWJsZSBhY2N1 cmFjeSwgYm9vbCBwcm92aWRlc0FsdGl0dWRlQWNjdXJhY3ksIGRvdWJsZSBhbHRpdHVkZUFjY3Vy YWN5LCBib29sIHByb3ZpZGVzSGVhZGluZywgZG91YmxlIGhlYWRpbmcsIGJvb2wgcHJvdmlkZXNT cGVlZCwgZG91YmxlIHNwZWVkLCBsb25nIGxvbmcgdGltZXN0YW1wKTsKKyAgICB2aXJ0dWFsIHZv aWQgc2V0TGFzdEVycm9yKGludCBlcnJvcl9jb2RlLCBjb25zdCBXZWJTdHJpbmcmIG1lc3NhZ2Up OworCitwcml2YXRlOgorICAgIFdlYlZpZXdDbGllbnQqIGdldFdlYlZpZXdDbGllbnQoKTsKKwor ICAgIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKiBtX0dlb2xvY2F0aW9uU2VydmljZUNocm9t aXVtOworICAgIGludCBtX0JyaWRnZUlkOworfTsKKworc3RhdGljIEdlb2xvY2F0aW9uU2Vydmlj ZUJyaWRnZSogY3JlYXRlR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlSW1wbChHZW9sb2NhdGlvblNl cnZpY2VDaHJvbWl1bSogYykKK3sKKyAgICByZXR1cm4gbmV3IEdlb2xvY2F0aW9uU2VydmljZUJy aWRnZUltcGwoYyk7Cit9CisKK0dlb2xvY2F0aW9uU2VydmljZUJyaWRnZUltcGw6Okdlb2xvY2F0 aW9uU2VydmljZUJyaWRnZUltcGwoR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0qIGMpCisgICAg OiBtX0dlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKGMpCit7CisgICAgV2ViS2l0OjpXZWJWaWV3 Q2xpZW50KiB3ZWJWaWV3Q2xpZW50ID0gZ2V0V2ViVmlld0NsaWVudCgpOworICAgIG1fQnJpZGdl SWQgPSB3ZWJWaWV3Q2xpZW50LT5nZXRHZW9sb2NhdGlvblNlcnZpY2UoKS0+YXR0YWNoQnJpZGdl KHRoaXMpOworfQorCitHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsOjp+R2VvbG9jYXRpb25T ZXJ2aWNlQnJpZGdlSW1wbCgpCit7CisgICAgV2ViS2l0OjpXZWJWaWV3Q2xpZW50KiB3ZWJWaWV3 Q2xpZW50ID0gZ2V0V2ViVmlld0NsaWVudCgpOworICAgIC8vIHdlYlZpZXdDbGllbnQgbWlnaHQg YmUgTlVMTCBhdCB0aGlzIHBvaW50IGlmIHRoZSBmcmFtZSBoYXMgYmVlbiBkaXNjb25uZWN0ZWQu CisgICAgLy8gTm90ZSB0aGF0IGluIHRoaXMgY2FzZSwgc3RvcFVwZGF0aW5nKCkgaGFzIGJlZW4g Y2FsbGVkLCBhbmQgd2UgaGF2ZSBhbHJlYWR5CisgICAgLy8gZGV0dGFjaGVkIG91cnNlbHZlcy4K KyAgICBpZiAobV9CcmlkZ2VJZCAmJiB3ZWJWaWV3Q2xpZW50KQorICAgICAgICB3ZWJWaWV3Q2xp ZW50LT5nZXRHZW9sb2NhdGlvblNlcnZpY2UoKS0+ZGV0dGFjaEJyaWRnZShtX0JyaWRnZUlkKTsK K30KKworYm9vbCBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsOjpzdGFydFVwZGF0aW5nKFBv c2l0aW9uT3B0aW9ucyogcG9zaXRpb25PcHRpb25zKQoreworICAgIFdlYktpdDo6V2ViVmlld0Ns aWVudCogd2ViVmlld0NsaWVudCA9IGdldFdlYlZpZXdDbGllbnQoKTsKKyAgICBpZiAoIW1fQnJp ZGdlSWQpIG1fQnJpZGdlSWQgPSB3ZWJWaWV3Q2xpZW50LT5nZXRHZW9sb2NhdGlvblNlcnZpY2Uo KS0+YXR0YWNoQnJpZGdlKHRoaXMpOworICAgIHdlYlZpZXdDbGllbnQtPmdldEdlb2xvY2F0aW9u U2VydmljZSgpLT5zdGFydFVwZGF0aW5nKAorICAgICAgICBtX0JyaWRnZUlkLCBwb3NpdGlvbk9w dGlvbnMtPmVuYWJsZUhpZ2hBY2N1cmFjeSgpKTsKKyAgICAvLy8vIFRPRE8oYnVsYWNoKTogdGhp cyB3aWxsIHRyaWdnZXIgYSBwZXJtaXNzaW9uIHJlcXVlc3QgcmVnYXJkbGVzcy4KKyAgICAvLy8v IElzIGl0IGNvcnJlY3Q/IGNvbmZpcm0gd2l0aCBhbmRyZWlwLgorICAgIC8vcG9zaXRpb25DaGFu Z2VkKCk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNlQnJp ZGdlSW1wbDo6c3RvcFVwZGF0aW5nKCkKK3sKKyAgICBXZWJLaXQ6OldlYlZpZXdDbGllbnQqIHdl YlZpZXdDbGllbnQgPSBnZXRXZWJWaWV3Q2xpZW50KCk7CisgICAgd2ViVmlld0NsaWVudC0+Z2V0 R2VvbG9jYXRpb25TZXJ2aWNlKCktPnN0b3BVcGRhdGluZyhtX0JyaWRnZUlkKTsKKyAgICBtX0Jy aWRnZUlkID0gMDsKK30KKwordm9pZCBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsOjpzdXNw ZW5kKCkKK3sKKyAgICBnZXRXZWJWaWV3Q2xpZW50KCktPmdldEdlb2xvY2F0aW9uU2VydmljZSgp LT5zdXNwZW5kKG1fQnJpZGdlSWQpOworfQorCit2b2lkIEdlb2xvY2F0aW9uU2VydmljZUJyaWRn ZUltcGw6OnJlc3VtZSgpCit7CisgICAgZ2V0V2ViVmlld0NsaWVudCgpLT5nZXRHZW9sb2NhdGlv blNlcnZpY2UoKS0+cmVzdW1lKG1fQnJpZGdlSWQpOworfQorCitpbnQgR2VvbG9jYXRpb25TZXJ2 aWNlQnJpZGdlSW1wbDo6Z2V0QnJpZGdlSWQoKSBjb25zdAoreworICAgIHJldHVybiBtX0JyaWRn ZUlkOworfQorCit2b2lkIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUltcGw6OnNldElzQWxsb3dl ZChib29sIGFsbG93ZWQpIHsKKyAgICBtX0dlb2xvY2F0aW9uU2VydmljZUNocm9taXVtLT5zZXRJ c0FsbG93ZWQoYWxsb3dlZCk7Cit9CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlSW1w bDo6c2V0TGFzdFBvc2l0aW9uKGRvdWJsZSBsYXRpdHVkZSwgZG91YmxlIGxvbmdpdHVkZSwgYm9v bCBwcm92aWRlc0FsdGl0dWRlLCBkb3VibGUgYWx0aXR1ZGUsIGRvdWJsZSBhY2N1cmFjeSwgYm9v bCBwcm92aWRlc0FsdGl0dWRlQWNjdXJhY3ksIGRvdWJsZSBhbHRpdHVkZUFjY3VyYWN5LCBib29s IHByb3ZpZGVzSGVhZGluZywgZG91YmxlIGhlYWRpbmcsIGJvb2wgcHJvdmlkZXNTcGVlZCwgZG91 YmxlIHNwZWVkLCBsb25nIGxvbmcgdGltZXN0YW1wKSB7CisgICAgbV9HZW9sb2NhdGlvblNlcnZp Y2VDaHJvbWl1bS0+c2V0TGFzdFBvc2l0aW9uKGxhdGl0dWRlLCBsb25naXR1ZGUsIHByb3ZpZGVz QWx0aXR1ZGUsIGFsdGl0dWRlLCBhY2N1cmFjeSwgcHJvdmlkZXNBbHRpdHVkZUFjY3VyYWN5LCBh bHRpdHVkZUFjY3VyYWN5LCBwcm92aWRlc0hlYWRpbmcsIGhlYWRpbmcsIHByb3ZpZGVzU3BlZWQs IHNwZWVkLCB0aW1lc3RhbXApOworfQorCit2b2lkIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUlt cGw6OnNldExhc3RFcnJvcihpbnQgZXJyb3JfY29kZSwgY29uc3QgV2ViU3RyaW5nJiBtZXNzYWdl KSB7CisgICAgbV9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS0+c2V0TGFzdEVycm9yKGVycm9y X2NvZGUsIG1lc3NhZ2UpOworfQorCitXZWJWaWV3Q2xpZW50KiBHZW9sb2NhdGlvblNlcnZpY2VC cmlkZ2VJbXBsOjpnZXRXZWJWaWV3Q2xpZW50KCkgeworICAgIEZyYW1lKiBmcmFtZSA9IG1fR2Vv bG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0tPmZyYW1lKCk7CisgICAgaWYgKCFmcmFtZSB8fCAhZnJh bWUtPnBhZ2UoKSkKKyAgICAgICAgcmV0dXJuIE5VTEw7CisgICAgV2ViS2l0OjpDaHJvbWVDbGll bnRJbXBsKiBjaHJvbWVDbGllbnRJbXBsID0gc3RhdGljX2Nhc3Q8V2ViS2l0OjpDaHJvbWVDbGll bnRJbXBsKj4oZnJhbWUtPnBhZ2UoKS0+Y2hyb21lKCktPmNsaWVudCgpKTsKKyAgICBXZWJLaXQ6 OldlYlZpZXdDbGllbnQqIHdlYlZpZXdDbGllbnQgPSBjaHJvbWVDbGllbnRJbXBsLT53ZWJWaWV3 KCktPmNsaWVudCgpOworICAgIHJldHVybiB3ZWJWaWV3Q2xpZW50OworfQorCit9IC8vIG5hbWVz cGFjZSBXZWJLaXQKKworCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8vIFNldHMgdXAgdGhlIGZh Y3RvcnkgZnVuY3Rpb24gZm9yIEdlb2xvY2F0aW9uU2VydmljZS4KK0dlb2xvY2F0aW9uU2Vydmlj ZUNocm9taXVtOjpCcmlkZ2VGYWN0b3J5RnVuY3Rpb24qIEdlb2xvY2F0aW9uU2VydmljZUNocm9t aXVtOjpzX2JyaWRnZUZhY3RvcnlGdW5jdGlvbiA9ICZXZWJLaXQ6OmNyZWF0ZUdlb2xvY2F0aW9u U2VydmljZUJyaWRnZUltcGw7CisKK30gIC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKworI2VuZGlm IC8vIEVOQUJMRShHRU9MT0NBVElPTikKClByb3BlcnR5IGNoYW5nZXMgb246IHNyYy9HZW9sb2Nh dGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5jcHAKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpBZGRlZDogc3ZuOmV4ZWN1 dGFibGUKICAgKyAqCkFkZGVkOiBzdm46ZW9sLXN0eWxlCiAgICsgTEYKCkluZGV4OiBzcmMvV2Vi Vmlld0ltcGwuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHNyYy9XZWJWaWV3SW1wbC5jcHAJKHJldmlzaW9u IDU0NjUzKQorKysgc3JjL1dlYlZpZXdJbXBsLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDI2LDcg KzQyNiw3IEBAIHZvaWQgV2ViVmlld0ltcGw6Om1vdXNlVXAoY29uc3QgV2ViTW91c2UKICAgICAg ICAgSW50UG9pbnQgY29udGVudFBvaW50ID0gdmlldy0+d2luZG93VG9Db250ZW50cyhjbGlja1Bv aW50KTsKICAgICAgICAgSGl0VGVzdFJlc3VsdCBoaXRUZXN0UmVzdWx0ID0gZm9jdXNlZC0+ZXZl bnRIYW5kbGVyKCktPmhpdFRlc3RSZXN1bHRBdFBvaW50KGNvbnRlbnRQb2ludCwgZmFsc2UsIGZh bHNlLCBTaG91bGRIaXRUZXN0U2Nyb2xsYmFycyk7CiAgICAgICAgIC8vIFdlIGRvbid0IHdhbnQg dG8gc2VuZCBhIHBhc3RlIHdoZW4gbWlkZGxlIGNsaWNraW5nIGEgc2Nyb2xsIGJhciBvciBhCi0g ICAgICAgIC8vIGxpbmsgKHdoaWNoIHdpbGwgbmF2aWdhdGUgbGF0ZXIgaW4gdGhlIGNvZGUpLiAg VGhlIG1haW4gc2Nyb2xsYmFycyAKKyAgICAgICAgLy8gbGluayAod2hpY2ggd2lsbCBuYXZpZ2F0 ZSBsYXRlciBpbiB0aGUgY29kZSkuICBUaGUgbWFpbiBzY3JvbGxiYXJzCiAgICAgICAgIC8vIGhh dmUgdG8gYmUgaGFuZGxlZCBzZXBhcmF0ZWx5LgogICAgICAgICBpZiAoIWhpdFRlc3RSZXN1bHQu c2Nyb2xsYmFyKCkgJiYgIWhpdFRlc3RSZXN1bHQuaXNMaXZlTGluaygpICYmIGZvY3VzZWQgJiYg IXZpZXctPnNjcm9sbGJhckF0UG9pbnQoY2xpY2tQb2ludCkpIHsKICAgICAgICAgICAgIEVkaXRv ciogZWRpdG9yID0gZm9jdXNlZC0+ZWRpdG9yKCk7Cg== 48649 2010-02-12 09:47:14 -0800 2010-03-23 13:26:38 -0700 Geolocation implementation geolocation.diff text/plain 28680 bulach SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1NDcyNCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTYgQEAKKzIwMTAtMDItMDIgIE1hcmN1cyBCdWxhY2ggIDxidWxhY2hAY2hyb21p dW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEltcGxlbWVudHMgR2VvbG9jYXRpb25TZXJ2aWNlcyBmb3IgQ2hyb21pdW0uCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zMjA2OAorCisgICAgICAgIFRo aXMgaXMgcGFydCBvZiBpbXBsZW1lbnRpbmcgR2VvbG9jYXRpb24gZnJhbWV3b3JrIGZvciBDaHJv bWl1bS4gRXhpc3RpbmcgbGF5b3V0IHRlc3RzIHNob3VsZCBwYXNzLgorCisgICAgICAgICogV2Vi Q29yZS5neXBpOgorICAgICAgICAqIHBhZ2UvR2VvbG9jYXRpb24uaDoKKyAgICAgICAgKiBwbGF0 Zm9ybS9HZW9sb2NhdGlvblNlcnZpY2UuaDoKKwogMjAxMC0wMi0xMiAgUGF2ZWwgRmVsZG1hbiAg PHBmZWxkbWFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBUaW1vdGh5IEhh dGNoZXIuCkluZGV4OiBXZWJDb3JlL1dlYkNvcmUuZ3lwaQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L1dlYkNvcmUuZ3lwaQkocmV2aXNpb24gNTQ3MjQpCisrKyBXZWJDb3JlL1dlYkNvcmUuZ3lwaQko d29ya2luZyBjb3B5KQpAQCAtMTkyNSw2ICsxOTI1LDcgQEAKICAgICAgICAgICAgICdwbGF0Zm9y bS9jaHJvbWl1bS9GcmFtZWxlc3NTY3JvbGxWaWV3LmgnLAogICAgICAgICAgICAgJ3BsYXRmb3Jt L2Nocm9taXVtL0ZyYW1lbGVzc1Njcm9sbFZpZXdDbGllbnQuaCcsCiAgICAgICAgICAgICAncGxh dGZvcm0vY2hyb21pdW0vR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0uY3BwJywKKyAgICAgICAg ICAgICdwbGF0Zm9ybS9jaHJvbWl1bS9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5oJywKICAg ICAgICAgICAgICdwbGF0Zm9ybS9jaHJvbWl1bS9LZXlDb2RlQ29udmVyc2lvbi5oJywKICAgICAg ICAgICAgICdwbGF0Zm9ybS9jaHJvbWl1bS9LZXlDb2RlQ29udmVyc2lvbkd0ay5jcHAnLAogICAg ICAgICAgICAgJ3BsYXRmb3JtL2Nocm9taXVtL0tleWJvYXJkQ29kZXNQb3NpeC5oJywKSW5kZXg6 IFdlYkNvcmUvcGFnZS9HZW9sb2NhdGlvbi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGFnZS9H ZW9sb2NhdGlvbi5oCShyZXZpc2lvbiA1NDcyNCkKKysrIFdlYkNvcmUvcGFnZS9HZW9sb2NhdGlv bi5oCSh3b3JraW5nIGNvcHkpCkBAIC03OCwxMCArNzgsMTMgQEAgcHVibGljOgogICAgIAogICAg IHZvaWQgc2V0U2hvdWxkQ2xlYXJDYWNoZShib29sIHNob3VsZENsZWFyQ2FjaGUpIHsgbV9zaG91 bGRDbGVhckNhY2hlID0gc2hvdWxkQ2xlYXJDYWNoZTsgfQogICAgIGJvb2wgc2hvdWxkQ2xlYXJD YWNoZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2hvdWxkQ2xlYXJDYWNoZTsgfQorICAgIEZyYW1lKiBm cmFtZSgpIGNvbnN0IHsgcmV0dXJuIG1fZnJhbWU7IH0KIAogI2lmIEVOQUJMRShDTElFTlRfQkFT RURfR0VPTE9DQVRJT04pCiAgICAgdm9pZCBzZXRQb3NpdGlvbihHZW9sb2NhdGlvblBvc2l0aW9u Kik7CiAgICAgdm9pZCBzZXRFcnJvcihHZW9sb2NhdGlvbkVycm9yKik7CisjZWxzZQorICAgIEdl b2xvY2F0aW9uU2VydmljZSogZ2V0R2VvbG9jYXRpb25TZXJ2aWNlKCkgY29uc3QgeyByZXR1cm4g bV9zZXJ2aWNlLmdldCgpOyB9CiAjZW5kaWYKIAogcHJpdmF0ZToKSW5kZXg6IFdlYkNvcmUvcGxh dGZvcm0vR2VvbG9jYXRpb25TZXJ2aWNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRm b3JtL0dlb2xvY2F0aW9uU2VydmljZS5jcHAJKHJldmlzaW9uIDU0NzI0KQorKysgV2ViQ29yZS9w bGF0Zm9ybS9HZW9sb2NhdGlvblNlcnZpY2UuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNSwxMiAr MjUsMTMgQEAKIAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkdlb2xvY2F0aW9uU2Vy dmljZS5oIgotI2luY2x1ZGUgIkdlb3Bvc2l0aW9uLmgiCisKICNpbmNsdWRlICJHZW9sb2NhdGlv blNlcnZpY2VNb2NrLmgiCisjaW5jbHVkZSAiR2VvcG9zaXRpb24uaCIKICNpbmNsdWRlICJQb3Np dGlvbkVycm9yLmgiCiAKLSNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KICNpbmNsdWRlIDx3 dGYvQXNzZXJ0aW9ucy5oPgorI2luY2x1ZGUgPHd0Zi9DdXJyZW50VGltZS5oPgogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKSW5kZXg6IFdlYkNvcmUvcGxhdGZvcm0vR2VvbG9jYXRpb25TZXJ2aWNl LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9HZW9sb2NhdGlvblNlcnZpY2UuaAko cmV2aXNpb24gNTQ3MjQpCisrKyBXZWJDb3JlL3BsYXRmb3JtL0dlb2xvY2F0aW9uU2VydmljZS5o CSh3b3JraW5nIGNvcHkpCkBAIC0yMCw3ICsyMCw3IEBACiAgKiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCiAgKiBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK ICAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQotICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKiBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICovCiAK ICNpZm5kZWYgR2VvbG9jYXRpb25TZXJ2aWNlX2gKQEAgLTQ2LDEwICs0NiwxMCBAQCBjbGFzcyBH ZW9sb2NhdGlvblNlcnZpY2UgOiBwdWJsaWMgTm9uY29wCiBwdWJsaWM6CiAgICAgc3RhdGljIEdl b2xvY2F0aW9uU2VydmljZSogY3JlYXRlKEdlb2xvY2F0aW9uU2VydmljZUNsaWVudCopOwogICAg IHZpcnR1YWwgfkdlb2xvY2F0aW9uU2VydmljZSgpIHsgfQotICAgIAorCiAgICAgdmlydHVhbCBi b29sIHN0YXJ0VXBkYXRpbmcoUG9zaXRpb25PcHRpb25zKikgeyByZXR1cm4gZmFsc2U7IH0KICAg ICB2aXJ0dWFsIHZvaWQgc3RvcFVwZGF0aW5nKCkgeyB9Ci0gICAgCisKICAgICB2aXJ0dWFsIHZv aWQgc3VzcGVuZCgpIHsgfQogICAgIHZpcnR1YWwgdm9pZCByZXN1bWUoKSB7IH0KIApAQCAtNjMs NiArNjMsNyBAQCBwdWJsaWM6CiAKIHByb3RlY3RlZDoKICAgICBHZW9sb2NhdGlvblNlcnZpY2Uo R2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50Kik7CisgICAgR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50 KiBnZW9sb2NhdGlvblNlcnZpY2VDbGllbnQoKSBjb25zdCB7IHJldHVybiBtX2dlb2xvY2F0aW9u U2VydmljZUNsaWVudDsgfQogCiBwcml2YXRlOgogICAgIEdlb2xvY2F0aW9uU2VydmljZUNsaWVu dCogbV9nZW9sb2NhdGlvblNlcnZpY2VDbGllbnQ7CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2No cm9taXVtL0Nocm9taXVtQnJpZGdlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9j aHJvbWl1bS9DaHJvbWl1bUJyaWRnZS5oCShyZXZpc2lvbiA1NDcyNCkKKysrIFdlYkNvcmUvcGxh dGZvcm0vY2hyb21pdW0vQ2hyb21pdW1CcmlkZ2UuaAkod29ya2luZyBjb3B5KQpAQCAtNTMsNiAr NTMsOCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgY2xhc3MgQ3Vyc29yOwogICAgIGNsYXNz IERvY3VtZW50OwogICAgIGNsYXNzIEZyYW1lOworICAgIGNsYXNzIEdlb2xvY2F0aW9uU2Vydmlj ZUJyaWRnZTsKKyAgICBjbGFzcyBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTsKICAgICBjbGFz cyBHcmFwaGljc0NvbnRleHQ7CiAgICAgY2xhc3MgSW1hZ2U7CiAgICAgY2xhc3MgSW50UmVjdDsK QEAgLTExNyw2ICsxMTksOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIC8vIEZvcm1z IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCiAgICAgICAgIHN0YXRpYyB2b2lkIG5vdGlmeUZvcm1TdGF0ZUNoYW5nZWQoY29uc3Qg RG9jdW1lbnQqKTsKIAorICAgICAgICAvLyBHZW9sb2NhdGlvbiAtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgICAgICBzdGF0aWMgR2Vv bG9jYXRpb25TZXJ2aWNlQnJpZGdlKiBjcmVhdGVHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2UoR2Vv bG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0qKTsKKwogICAgICAgICAvLyBIVE1MNSBEQiAtLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogI2lm IEVOQUJMRShEQVRBQkFTRSkKICAgICAgICAgLy8gUmV0dXJucyBhIGhhbmRsZSB0byB0aGUgREIg ZmlsZSBhbmQgb29wdGlvbmFsbHkgYSBoYW5kbGUgdG8gaXRzIGNvbnRhaW5pbmcgZGlyZWN0b3J5 CkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0dlb2xvY2F0aW9uU2VydmljZUNocm9t aXVtLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2Nocm9taXVtL0dlb2xvY2F0 aW9uU2VydmljZUNocm9taXVtLmNwcAkocmV2aXNpb24gNTQ3MjQpCisrKyBXZWJDb3JlL3BsYXRm b3JtL2Nocm9taXVtL0dlb2xvY2F0aW9uU2VydmljZUNocm9taXVtLmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMSw1ICsxLDUgQEAKIC8qCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDksIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAsIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKiAKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFy ZQpAQCAtMjksMjcgKzI5LDc5IEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1 ZGUgIkdlb2xvY2F0aW9uU2VydmljZS5oIgorI2luY2x1ZGUgIkdlb2xvY2F0aW9uU2VydmljZUNo cm9taXVtLmgiCisKKyNpbmNsdWRlICJDaHJvbWl1bUJyaWRnZS5oIgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKLWNsYXNzIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtIDogcHVibGljIEdlb2xv Y2F0aW9uU2VydmljZSB7Ci1wdWJsaWM6Ci0gICAgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0o R2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KiBjKQotICAgICAgICA6IEdlb2xvY2F0aW9uU2Vydmlj ZShjKQotICAgIHsKLSAgICB9Ci0gICAgLy8gRklYTUU6IEltcGxlbWVudC4gaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMyMDY4Ci19OwotCi0vLyBUaGlzIGd1YXJkIGlz IHRoZSBjb3VudGVycGFydCBvZiB0aGUgb25lIGluIFdlYkNvcmUvcGxhdGZvcm0vR2VvbG9jYXRp b25TZXJ2aWNlLmNwcAotI2lmIEVOQUJMRShHRU9MT0NBVElPTikKLXN0YXRpYyBHZW9sb2NhdGlv blNlcnZpY2UqIGNyZWF0ZUdlb2xvY2F0aW9uU2VydmljZShHZW9sb2NhdGlvblNlcnZpY2VDbGll bnQqIGMpCitHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6R2VvbG9jYXRpb25TZXJ2aWNlQ2hy b21pdW0oR2VvbG9jYXRpb25TZXJ2aWNlQ2xpZW50KiBjKQorICAgICAgICA6IEdlb2xvY2F0aW9u U2VydmljZShjKSwKKyAgICAgICAgICBtX2dlb2xvY2F0aW9uKHJlaW50ZXJwcmV0X2Nhc3Q8R2Vv bG9jYXRpb24qPihjKSksCisgICAgICAgICAgbV9sYXN0UG9zaXRpb24oR2VvcG9zaXRpb246OmNy ZWF0ZShDb29yZGluYXRlczo6Y3JlYXRlKDAuMCwgMC4wLCBmYWxzZSwgMC4wLCAwLjAsIGZhbHNl LCAwLjAsIGZhbHNlLCAwLjAsIGZhbHNlLCAwLjApLCAwKSksCisgICAgICAgICAgbV9sYXN0RXJy b3IoUG9zaXRpb25FcnJvcjo6Y3JlYXRlKFBvc2l0aW9uRXJyb3I6OlBPU0lUSU9OX1VOQVZBSUxB QkxFLCAiIikpLAorICAgICAgICAgIG1fZ2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlKENocm9taXVt QnJpZGdlOjpjcmVhdGVHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2UodGhpcykpCit7Cit9CisKK3Zv aWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06OnNldElzQWxsb3dlZChib29sIGFsbG93ZWQp Cit7CisgICAgbV9nZW9sb2NhdGlvbi0+c2V0SXNBbGxvd2VkKGFsbG93ZWQpOyAgCit9CisKK3Zv aWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06OnNldExhc3RQb3NpdGlvbihkb3VibGUgbGF0 aXR1ZGUsIGRvdWJsZSBsb25naXR1ZGUsIGJvb2wgcHJvdmlkZXNBbHRpdHVkZSwgZG91YmxlIGFs dGl0dWRlLCBkb3VibGUgYWNjdXJhY3ksIGJvb2wgcHJvdmlkZXNBbHRpdHVkZUFjY3VyYWN5LCBk b3VibGUgYWx0aXR1ZGVBY2N1cmFjeSwgYm9vbCBwcm92aWRlc0hlYWRpbmcsIGRvdWJsZSBoZWFk aW5nLCBib29sIHByb3ZpZGVzU3BlZWQsIGRvdWJsZSBzcGVlZCwgbG9uZyBsb25nIHRpbWVzdGFt cCkKK3sKKyAgICBtX2xhc3RQb3NpdGlvbiA9IEdlb3Bvc2l0aW9uOjpjcmVhdGUoQ29vcmRpbmF0 ZXM6OmNyZWF0ZShsYXRpdHVkZSwgbG9uZ2l0dWRlLCBwcm92aWRlc0FsdGl0dWRlLCBhbHRpdHVk ZSwgYWNjdXJhY3ksIHByb3ZpZGVzQWx0aXR1ZGVBY2N1cmFjeSwgYWx0aXR1ZGVBY2N1cmFjeSwg cHJvdmlkZXNIZWFkaW5nLCBoZWFkaW5nLCBwcm92aWRlc1NwZWVkLCBzcGVlZCksIHRpbWVzdGFt cCk7CisgICAgcG9zaXRpb25DaGFuZ2VkKCk7Cit9CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNl Q2hyb21pdW06OnNldExhc3RFcnJvcihpbnQgZXJyb3JDb2RlLCBjb25zdCBTdHJpbmcmIG1lc3Nh Z2UpCit7CisgICAgbV9sYXN0RXJyb3IgPSBQb3NpdGlvbkVycm9yOjpjcmVhdGUoc3RhdGljX2Nh c3Q8UG9zaXRpb25FcnJvcjo6RXJyb3JDb2RlPihlcnJvckNvZGUpLCBtZXNzYWdlKTsKKyAgICBl cnJvck9jY3VycmVkKCk7Cit9CisKK0ZyYW1lKiBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTo6 ZnJhbWUoKQoreworICAgIHJldHVybiBtX2dlb2xvY2F0aW9uLT5mcmFtZSgpOworfQorCitib29s IEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpzdGFydFVwZGF0aW5nKFBvc2l0aW9uT3B0aW9u cyogb3B0aW9ucykKK3sKKyAgICByZXR1cm4gbV9nZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2UtPnN0 YXJ0VXBkYXRpbmcob3B0aW9ucyk7Cit9CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21p dW06OnN0b3BVcGRhdGluZygpCit7CisgICAgcmV0dXJuIG1fZ2VvbG9jYXRpb25TZXJ2aWNlQnJp ZGdlLT5zdG9wVXBkYXRpbmcoKTsKK30KKwordm9pZCBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1 bTo6c3VzcGVuZCgpCit7CisgICAgcmV0dXJuIG1fZ2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlLT5z dXNwZW5kKCk7Cit9CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06OnJlc3VtZSgp Cit7CisgICAgcmV0dXJuIG1fZ2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlLT5yZXN1bWUoKTsKK30K KworR2VvcG9zaXRpb24qIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtOjpsYXN0UG9zaXRpb24o KSBjb25zdAoreworICAgIHJldHVybiBtX2xhc3RQb3NpdGlvbi5nZXQoKTsKK30KKworUG9zaXRp b25FcnJvciogR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW06Omxhc3RFcnJvcigpIGNvbnN0Cit7 CisgICAgcmV0dXJuIG1fbGFzdEVycm9yLmdldCgpOworfQorCitzdGF0aWMgR2VvbG9jYXRpb25T ZXJ2aWNlKiBjcmVhdGVHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bShHZW9sb2NhdGlvblNlcnZp Y2VDbGllbnQqIGMpCiB7CiAgICAgcmV0dXJuIG5ldyBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1 bShjKTsKIH0KIAotR2VvbG9jYXRpb25TZXJ2aWNlOjpGYWN0b3J5RnVuY3Rpb24qIEdlb2xvY2F0 aW9uU2VydmljZTo6c19mYWN0b3J5RnVuY3Rpb24gPSAmY3JlYXRlR2VvbG9jYXRpb25TZXJ2aWNl OwotI2VuZGlmCisvLyBTZXRzIHVwIHRoZSBmYWN0b3J5IGZ1bmN0aW9uIGZvciBHZW9sb2NhdGlv blNlcnZpY2UuCitHZW9sb2NhdGlvblNlcnZpY2U6OkZhY3RvcnlGdW5jdGlvbiogR2VvbG9jYXRp b25TZXJ2aWNlOjpzX2ZhY3RvcnlGdW5jdGlvbiA9ICZjcmVhdGVHZW9sb2NhdGlvblNlcnZpY2VD aHJvbWl1bTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9wbGF0Zm9y bS9jaHJvbWl1bS9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0uaAkocmV2 aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vY2hyb21pdW0vR2VvbG9jYXRpb25TZXJ2aWNl Q2hyb21pdW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw4NSBAQAorLyoKKyAqIENvcHlyaWdo dCAoYykgMjAxMCwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIAorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKiAKKyAqICAgICAqIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRp b24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFt ZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9t b3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNp ZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqIAorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIEdlb2xv Y2F0aW9uU2VydmljZUNocm9taXVtX2gKKyNkZWZpbmUgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21p dW1faAorCisjaW5jbHVkZSAiR2VvbG9jYXRpb24uaCIKKyNpbmNsdWRlICJHZW9sb2NhdGlvblNl cnZpY2UuaCIKKyNpbmNsdWRlICJHZW9wb3NpdGlvbi5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3Ry aW5nLmgiCisjaW5jbHVkZSAiUG9zaXRpb25FcnJvci5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKKy8vIFByb3ZpZGVzIGFuIGludGVyZmFjZSBmb3IgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21p dW0gdG8gY2FsbCBpbnRvIHRoZSBlbWJlZGRlci4KK2NsYXNzIEdlb2xvY2F0aW9uU2VydmljZUJy aWRnZSB7CitwdWJsaWM6CisgICAgLy8gQ2FsbGVkIGJ5IEdlb2xvY2F0aW9uU2VydmljZUNocm9t aXVtLgorICAgIHZpcnR1YWwgYm9vbCBzdGFydFVwZGF0aW5nKFBvc2l0aW9uT3B0aW9ucyopID0g MDsKKyAgICB2aXJ0dWFsIHZvaWQgc3RvcFVwZGF0aW5nKCkgPSAwOworICAgIHZpcnR1YWwgdm9p ZCBzdXNwZW5kKCkgPSAwOworICAgIHZpcnR1YWwgdm9pZCByZXN1bWUoKSA9IDA7CisKKyAgICAv LyBDYWxsZWQgYnkgdGhlIGVtYmVkZGVyLCB0byBpZGVudGlmeSB0aGlzIGJyaWRnZS4KKyAgICB2 aXJ0dWFsIGludCBnZXRCcmlkZ2VJZCgpIGNvbnN0ID0gMDsKK307CisKKy8vIFRoaXMgY2xhc3Mg ZXh0ZW5kcyBHZW9sb2NhdGlvblNlcnZpY2UsIGFuZCB1c2VzIEdlb2xvY2F0aW9uU2VydmljZUJy aWRnZSB0bworLy8gY2FsbCBpbnRvIHRoZSBlbWJlZGRlciwgYXMgd2VsbCBhcyBwcm92aWRlcyBh IGZldyBleHRyYSBtZXRob2RzIHNvIHRoYXQgdGhlCisvLyBlbWJlZGRlciBjYW4gbm90aWZ5IHBl cm1pc3Npb24sIHBvc2l0aW9uLCBlcnJvciwgZXRjLgorY2xhc3MgR2VvbG9jYXRpb25TZXJ2aWNl Q2hyb21pdW0gOiBwdWJsaWMgR2VvbG9jYXRpb25TZXJ2aWNlIHsKK3B1YmxpYzoKKyAgICBleHBs aWNpdCBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bShHZW9sb2NhdGlvblNlcnZpY2VDbGllbnQq KTsKKworICAgIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZSogZ2VvbG9jYXRpb25TZXJ2aWNlQnJp ZGdlKCkgY29uc3QgeyByZXR1cm4gbV9nZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2UuZ2V0KCk7IH0K KyAgICB2b2lkIHNldElzQWxsb3dlZChib29sIGFsbG93ZWQpOworICAgIHZvaWQgc2V0TGFzdFBv c2l0aW9uKGRvdWJsZSBsYXRpdHVkZSwgZG91YmxlIGxvbmdpdHVkZSwgYm9vbCBwcm92aWRlc0Fs dGl0dWRlLCBkb3VibGUgYWx0aXR1ZGUsIGRvdWJsZSBhY2N1cmFjeSwgYm9vbCBwcm92aWRlc0Fs dGl0dWRlQWNjdXJhY3ksIGRvdWJsZSBhbHRpdHVkZUFjY3VyYWN5LCBib29sIHByb3ZpZGVzSGVh ZGluZywgZG91YmxlIGhlYWRpbmcsIGJvb2wgcHJvdmlkZXNTcGVlZCwgZG91YmxlIHNwZWVkLCBs b25nIGxvbmcgdGltZXN0YW1wKTsKKyAgICB2b2lkIHNldExhc3RFcnJvcihpbnQgZXJyb3JDb2Rl LCBjb25zdCBTdHJpbmcmIG1lc3NhZ2UpOworICAgIEZyYW1lKiBmcmFtZSgpOworCisgICAgLy8g RnJvbSBHZW9sb2NhdGlvblNlcnZpY2UuCisgICAgdmlydHVhbCBib29sIHN0YXJ0VXBkYXRpbmco UG9zaXRpb25PcHRpb25zKik7CisgICAgdmlydHVhbCB2b2lkIHN0b3BVcGRhdGluZygpOworICAg IHZpcnR1YWwgdm9pZCBzdXNwZW5kKCk7CisgICAgdmlydHVhbCB2b2lkIHJlc3VtZSgpOworICAg IHZpcnR1YWwgR2VvcG9zaXRpb24qIGxhc3RQb3NpdGlvbigpIGNvbnN0OworICAgIHZpcnR1YWwg UG9zaXRpb25FcnJvciogbGFzdEVycm9yKCkgY29uc3Q7CisKK3ByaXZhdGU6CisgICAgR2VvbG9j YXRpb24qIG1fZ2VvbG9jYXRpb247CisgICAgT3duUHRyPEdlb2xvY2F0aW9uU2VydmljZUJyaWRn ZT4gbV9nZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2U7ICAgIAorICAgIFJlZlB0cjxHZW9wb3NpdGlv bj4gbV9sYXN0UG9zaXRpb247CisgICAgUmVmUHRyPFBvc2l0aW9uRXJyb3I+IG1fbGFzdEVycm9y OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gR2VvbG9jYXRpb25T ZXJ2aWNlQ2hyb21pdW1faAoKUHJvcGVydHkgY2hhbmdlcyBvbjogV2ViQ29yZS9wbGF0Zm9ybS9j aHJvbWl1bS9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS5oCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2 bjplb2wtc3R5bGUKICAgKyBMRgoKSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCShyZXZpc2lvbiA1NDcyNCkK KysrIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCSh3b3JraW5nIGNvcHkpCkBAIC02OCw2ICs2 OCw3IEBACiAgICAgICAgICAgICAgICAgJ1dFQktJVF9JTVBMRU1FTlRBVElPTicsCiAgICAgICAg ICAgICBdLAogICAgICAgICAgICAgJ3NvdXJjZXMnOiBbCisgICAgICAgICAgICAgICAgJ3B1Ymxp Yy9HZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5oJywKICAgICAgICAgICAgICAgICAn cHVibGljL2d0ay9XZWJJbnB1dEV2ZW50RmFjdG9yeS5oJywKICAgICAgICAgICAgICAgICAncHVi bGljL2xpbnV4L1dlYkZvbnRSZW5kZXJpbmcuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9s aW51eC9XZWJSZW5kZXJUaGVtZS5oJywKQEAgLTIzMSw2ICsyMzIsNyBAQAogICAgICAgICAgICAg ICAgICdzcmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9G cmFtZUxvYWRlckNsaWVudEltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL0ZyYW1lTG9h ZGVyQ2xpZW50SW1wbC5oJywKKyAgICAgICAgICAgICAgICAnc3JjL0dlb2xvY2F0aW9uU2Vydmlj ZUJyaWRnZUNocm9taXVtLmNwcCcsCQkKICAgICAgICAgICAgICAgICAnc3JjL2d0ay9XZWJGb250 SW5mby5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvZ3RrL1dlYkZvbnRJbmZvLmgnLAogICAg ICAgICAgICAgICAgICdzcmMvZ3RrL1dlYklucHV0RXZlbnRGYWN0b3J5LmNwcCcsCkluZGV4OiBX ZWJLaXQvY2hyb21pdW0vcHVibGljL0dlb2xvY2F0aW9uU2VydmljZUJyaWRnZUNocm9taXVtLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9HZW9sb2NhdGlvblNlcnZpY2VC cmlkZ2VDaHJvbWl1bS5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9H ZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDczIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDEwLCBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0Ogor ICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisg KiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdv b2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVz ZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdI VAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlQ2hyb21pdW1faAorI2RlZmlu ZSBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bV9oCisKK25hbWVzcGFjZSBXZWJDb3Jl IHsKK2NsYXNzIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZTsKK2NsYXNzIEdlb2xvY2F0aW9uU2Vy dmljZUNocm9taXVtOworfQorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgV2ViU3RyaW5n OworY2xhc3MgV2ViVVJMOworCisvLyBQcm92aWRlcyBhIFdlYktpdCBBUEkgY2FsbGVkIGJ5IHRo ZSBlbWJlZGRlci4KK2NsYXNzIFdlYkdlb2xvY2F0aW9uU2VydmljZUJyaWRnZSB7CitwdWJsaWM6 CisgICAgdmlydHVhbCB2b2lkIHNldElzQWxsb3dlZChib29sIGFsbG93ZWQpID0gMDsKKyAgICB2 aXJ0dWFsIHZvaWQgc2V0TGFzdFBvc2l0aW9uKGRvdWJsZSBsYXRpdHVkZSwgZG91YmxlIGxvbmdp dHVkZSwgYm9vbCBwcm92aWRlc0FsdGl0dWRlLCBkb3VibGUgYWx0aXR1ZGUsIGRvdWJsZSBhY2N1 cmFjeSwgYm9vbCBwcm92aWRlc0FsdGl0dWRlQWNjdXJhY3ksIGRvdWJsZSBhbHRpdHVkZUFjY3Vy YWN5LCBib29sIHByb3ZpZGVzSGVhZGluZywgZG91YmxlIGhlYWRpbmcsIGJvb2wgcHJvdmlkZXNT cGVlZCwgZG91YmxlIHNwZWVkLCBsb25nIGxvbmcgdGltZXN0YW1wKSA9IDA7CisgICAgdmlydHVh bCB2b2lkIHNldExhc3RFcnJvcihpbnQgZXJyb3JDb2RlLCBjb25zdCBXZWJTdHJpbmcmIG1lc3Nh Z2UpID0gMDsKK307CisKKy8vIFByb3ZpZGVzIGFuIGVtYmVkZGVyIEFQSSBjYWxsZWQgYnkgV2Vi S2l0LgorY2xhc3MgV2ViR2VvbG9jYXRpb25TZXJ2aWNlSW50ZXJmYWNlIHsKK3B1YmxpYzoKKyAg ICB2aXJ0dWFsIHZvaWQgcmVxdWVzdFBlcm1pc3Npb25Gb3JGcmFtZShpbnQgYnJpZGdlSWQsIGNv bnN0IFdlYlVSTCYgdXJsKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0VXBkYXRpbmcoaW50 IGJyaWRnZUlkLCBib29sIGhhc0hpZ2hBY2N1cmFjeSkgPSAwOworICAgIHZpcnR1YWwgdm9pZCBz dG9wVXBkYXRpbmcoaW50IGJyaWRnZUlkKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHN1c3BlbmQo aW50IGJyaWRnZUlkKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHJlc3VtZShpbnQgYnJpZGdlSWQp ID0gMDsKKworICAgIC8vIEF0dGFjaGVzIHRoZSBHZW9sb2NhdGlvbkJyaWRnZSB0byB0aGUgZW1i ZWRkZXIgYW5kIHJldHVybnMgaXRzIGlkLCB3aGljaAorICAgIC8vIHNob3VsZCBiZSB1c2VkIG9u IHN1YnNlcXVlbnQgY2FsbHMgZm9yIHRoZSBtZXRob2RzIGFib3ZlLgorICAgIHZpcnR1YWwgaW50 IGF0dGFjaEJyaWRnZShXZWJLaXQ6OldlYkdlb2xvY2F0aW9uU2VydmljZUJyaWRnZSogZ2VvbG9j YXRpb25TZXJ2aWNlQnJpZGdlKSA9IDA7CisKKyAgICAvLyBEZXR0YWNoZXMgdGhlIEdlb2xvY2F0 aW9uU2VydmljZSBmcm9tIHRoZSBlbWJlZGRlci4KKyAgICB2aXJ0dWFsIHZvaWQgZGV0dGFjaEJy aWRnZShpbnQgYnJpZGdlSWQpID0gMDsKK307CisKK1dlYkNvcmU6Okdlb2xvY2F0aW9uU2Vydmlj ZUJyaWRnZSogY3JlYXRlR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlSW1wbChXZWJDb3JlOjpHZW9s b2NhdGlvblNlcnZpY2VDaHJvbWl1bSopOworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2Vu ZGlmIC8vIEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUNocm9taXVtX2gKClByb3BlcnR5IGNoYW5n ZXMgb246IFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlQ2hy b21pdW0uaApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCkFkZGVkOiBzdm46ZW9sLXN0eWxlCiAgICsgTEYKCkluZGV4OiBX ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlZpZXdDbGllbnQuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYlZpZXdDbGllbnQuaAkocmV2aXNpb24gNTQ3MjQpCisrKyBX ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlZpZXdDbGllbnQuaAkod29ya2luZyBjb3B5KQpAQCAt NDYsNiArNDYsNyBAQCBjbGFzcyBXZWJBY2Nlc3NpYmlsaXR5T2JqZWN0OwogY2xhc3MgV2ViRHJh Z0RhdGE7CiBjbGFzcyBXZWJGaWxlQ2hvb3NlckNvbXBsZXRpb247CiBjbGFzcyBXZWJGcmFtZTsK K2NsYXNzIFdlYkdlb2xvY2F0aW9uU2VydmljZUludGVyZmFjZTsKIGNsYXNzIFdlYk5vZGU7CiBj bGFzcyBXZWJOb3RpZmljYXRpb25QcmVzZW50ZXI7CiBjbGFzcyBXZWJSYW5nZTsKQEAgLTI3Nyw2 ICsyNzgsMTEgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCByZW1vdmVBdXRvZmlsbFN1Z2dl c3Rpb25zKGNvbnN0IFdlYlN0cmluZyYgbmFtZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjb25zdCBXZWJTdHJpbmcmIHZhbHVlKSB7IH0KIAorICAgIC8vIEdl b2xvY2F0aW9uIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorCisgICAgLy8gQWNjZXNzIHRoZSBlbWJlZGRlciBBUEkgZm9yIGdlb2xvY2F0 aW9uIHNlcnZpY2VzLgorICAgIHZpcnR1YWwgV2ViS2l0OjpXZWJHZW9sb2NhdGlvblNlcnZpY2VJ bnRlcmZhY2UqIGdldEdlb2xvY2F0aW9uU2VydmljZSgpIHsgcmV0dXJuIDA7IH0KKwogcHJvdGVj dGVkOgogICAgIH5XZWJWaWV3Q2xpZW50KCkgeyB9CiB9OwpJbmRleDogV2ViS2l0L2Nocm9taXVt L3NyYy9DaHJvbWVDbGllbnRJbXBsLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvY2hyb21pdW0v c3JjL0Nocm9tZUNsaWVudEltcGwuY3BwCShyZXZpc2lvbiA1NDcyNCkKKysrIFdlYktpdC9jaHJv bWl1bS9zcmMvQ2hyb21lQ2xpZW50SW1wbC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQzLDYgKzQz LDEwIEBACiAjaW5jbHVkZSAiRmxvYXRSZWN0LmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkUmVxdWVz dC5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIkdlb2xvY2F0aW9uLmgiCisj aW5jbHVkZSAiR2VvbG9jYXRpb25TZXJ2aWNlLmgiCisjaW5jbHVkZSAiR2VvbG9jYXRpb25TZXJ2 aWNlQnJpZGdlQ2hyb21pdW0uaCIKKyNpbmNsdWRlICJHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1 bS5oIgogI2luY2x1ZGUgIkhpdFRlc3RSZXN1bHQuaCIKICNpbmNsdWRlICJJbnRSZWN0LmgiCiAj aW5jbHVkZSAiTm9kZS5oIgpAQCAtNjc0LDQgKzY3OCwxMCBAQCBOb3RpZmljYXRpb25QcmVzZW50 ZXIqIENocm9tZUNsaWVudEltcGw6CiB9CiAjZW5kaWYKIAordm9pZCBDaHJvbWVDbGllbnRJbXBs OjpyZXF1ZXN0R2VvbG9jYXRpb25QZXJtaXNzaW9uRm9yRnJhbWUoRnJhbWUqIGZyYW1lLCBHZW9s b2NhdGlvbiogZ2VvbG9jYXRpb24pCit7CisgICAgR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0q IGdlb2xvY2F0aW9uU2VydmljZSA9IHJlaW50ZXJwcmV0X2Nhc3Q8R2VvbG9jYXRpb25TZXJ2aWNl Q2hyb21pdW0qPihnZW9sb2NhdGlvbi0+Z2V0R2VvbG9jYXRpb25TZXJ2aWNlKCkpOworICAgIG1f d2ViVmlldy0+Y2xpZW50KCktPmdldEdlb2xvY2F0aW9uU2VydmljZSgpLT5yZXF1ZXN0UGVybWlz c2lvbkZvckZyYW1lKGdlb2xvY2F0aW9uU2VydmljZS0+Z2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdl KCktPmdldEJyaWRnZUlkKCksIGZyYW1lLT5kb2N1bWVudCgpLT51cmwoKSk7Cit9CisKIH0gLy8g bmFtZXNwYWNlIFdlYktpdApJbmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9DaHJvbWVDbGllbnRJ bXBsLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9DaHJvbWVDbGllbnRJbXBs LmgJKHJldmlzaW9uIDU0NzI0KQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9DaHJvbWVDbGllbnRJ bXBsLmgJKHdvcmtpbmcgY29weSkKQEAgLTEyMSw4ICsxMjEsNyBAQCBwdWJsaWM6CiAjaWYgRU5B QkxFKE5PVElGSUNBVElPTlMpCiAgICAgdmlydHVhbCBXZWJDb3JlOjpOb3RpZmljYXRpb25QcmVz ZW50ZXIqIG5vdGlmaWNhdGlvblByZXNlbnRlcigpIGNvbnN0OwogI2VuZGlmCi0gICAgdmlydHVh bCB2b2lkIHJlcXVlc3RHZW9sb2NhdGlvblBlcm1pc3Npb25Gb3JGcmFtZSgKLSAgICAgICAgV2Vi Q29yZTo6RnJhbWUqLCBXZWJDb3JlOjpHZW9sb2NhdGlvbiopIHsgfQorICAgIHZpcnR1YWwgdm9p ZCByZXF1ZXN0R2VvbG9jYXRpb25QZXJtaXNzaW9uRm9yRnJhbWUoV2ViQ29yZTo6RnJhbWUqLCBX ZWJDb3JlOjpHZW9sb2NhdGlvbiopOwogICAgIHZpcnR1YWwgdm9pZCBydW5PcGVuUGFuZWwoV2Vi Q29yZTo6RnJhbWUqLCBQYXNzUmVmUHRyPFdlYkNvcmU6OkZpbGVDaG9vc2VyPik7CiAgICAgdmly dHVhbCBib29sIHNldEN1cnNvcihXZWJDb3JlOjpQbGF0Zm9ybUN1cnNvckhhbmRsZSkgeyByZXR1 cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFsIHZvaWQgZm9ybVN0YXRlRGlkQ2hhbmdlKGNvbnN0IFdl YkNvcmU6Ok5vZGUqKTsKSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9zcmMvQ2hyb21pdW1CcmlkZ2Uu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvQ2hyb21pdW1CcmlkZ2UuY3Bw CShyZXZpc2lvbiA1NDcyNCkKKysrIFdlYktpdC9jaHJvbWl1bS9zcmMvQ2hyb21pdW1CcmlkZ2Uu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC03Myw2ICs3Myw3IEBACiAjaW5jbHVkZSAiQml0bWFwSW1h Z2UuaCIKICNpbmNsdWRlICJDb29raWUuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKKyNpbmNs dWRlICJHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5oIgogI2luY2x1ZGUgIkdyYXBo aWNzQ29udGV4dC5oIgogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRl ZC5oIgpAQCAtMzEwLDYgKzMxMSwxMyBAQCBTdHJpbmcgQ2hyb21pdW1CcmlkZ2U6OmdldEZvbnRG YW1pbHlGb3JDCiB9CiAjZW5kaWYKIAorLy8gR2VvbG9jYXRpb24gLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitHZW9sb2Nh dGlvblNlcnZpY2VCcmlkZ2UqIENocm9taXVtQnJpZGdlOjpjcmVhdGVHZW9sb2NhdGlvblNlcnZp Y2VCcmlkZ2UoR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0qIGdlb2xvY2F0aW9uU2VydmljZUNo cm9taXVtKQoreworICAgIHJldHVybiBjcmVhdGVHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBs KGdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKTsKK30KKwogLy8gSFRNTDUgREIgLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQogCiAjaWYgRU5BQkxFKERBVEFCQVNFKQpJbmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9HZW9s b2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2No cm9taXVtL3NyYy9HZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5jcHAJKHJldmlzaW9u IDApCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL0dlb2xvY2F0aW9uU2VydmljZUJyaWRnZUNocm9t aXVtLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNzcgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgor ICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9m IGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisKKyNpbmNsdWRlICJHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VDaHJvbWl1bS5oIgorCisjaW5j bHVkZSAiQ2hyb21lLmgiCisjaW5jbHVkZSAiQ2hyb21lQ2xpZW50SW1wbC5oIgorI2luY2x1ZGUg IkZyYW1lLmgiCisjaW5jbHVkZSAiR2VvbG9jYXRpb24uaCIKKyNpbmNsdWRlICJHZW9sb2NhdGlv blNlcnZpY2VDaHJvbWl1bS5oIgorI2luY2x1ZGUgIkdlb3Bvc2l0aW9uLmgiCisjaW5jbHVkZSAi UGFnZS5oIgorI2luY2x1ZGUgIlBvc2l0aW9uRXJyb3IuaCIKKyNpbmNsdWRlICJQb3NpdGlvbk9w dGlvbnMuaCIKKyNpbmNsdWRlICJXZWJGcmFtZS5oIgorI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5o IgorI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKKyNpbmNsdWRlICJXZWJWaWV3SW1wbC5oIgor CisjaWYgRU5BQkxFKEdFT0xPQ0FUSU9OKQorCit1c2luZyBXZWJDb3JlOjpDb29yZGluYXRlczsK K3VzaW5nIFdlYkNvcmU6OkZyYW1lOwordXNpbmcgV2ViQ29yZTo6R2VvbG9jYXRpb247Cit1c2lu ZyBXZWJDb3JlOjpHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2U7Cit1c2luZyBXZWJDb3JlOjpHZW9s b2NhdGlvblNlcnZpY2VDaHJvbWl1bTsKK3VzaW5nIFdlYkNvcmU6Okdlb2xvY2F0aW9uU2Vydmlj ZUNsaWVudDsKK3VzaW5nIFdlYkNvcmU6Okdlb3Bvc2l0aW9uOwordXNpbmcgV2ViQ29yZTo6UG9z aXRpb25FcnJvcjsKK3VzaW5nIFdlYkNvcmU6OlBvc2l0aW9uT3B0aW9uczsKK3VzaW5nIFdlYkNv cmU6OlN0cmluZzsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIEdlb2xvY2F0aW9uU2Vy dmljZUJyaWRnZUltcGwgOiBwdWJsaWMgR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlLCBwdWJsaWMg V2ViR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlIHsKK3B1YmxpYzoKKyAgICBleHBsaWNpdCBHZW9s b2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsKEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKik7Cisg ICAgdmlydHVhbCB+R2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlSW1wbCgpOworCisgICAgLy8gR2Vv bG9jYXRpb25TZXJ2aWNlQnJpZGdlCisgICAgdmlydHVhbCBib29sIHN0YXJ0VXBkYXRpbmcoUG9z aXRpb25PcHRpb25zKik7CisgICAgdmlydHVhbCB2b2lkIHN0b3BVcGRhdGluZygpOworICAgIHZp cnR1YWwgdm9pZCBzdXNwZW5kKCk7CisgICAgdmlydHVhbCB2b2lkIHJlc3VtZSgpOworICAgIHZp cnR1YWwgaW50IGdldEJyaWRnZUlkKCkgY29uc3Q7CisKKyAgICAvLyBXZWJHZW9sb2NhdGlvblNl cnZpY2VCcmlkZ2UKKyAgICB2aXJ0dWFsIHZvaWQgc2V0SXNBbGxvd2VkKGJvb2wgYWxsb3dlZCk7 CisgICAgdmlydHVhbCB2b2lkIHNldExhc3RQb3NpdGlvbihkb3VibGUgbGF0aXR1ZGUsIGRvdWJs ZSBsb25naXR1ZGUsIGJvb2wgcHJvdmlkZXNBbHRpdHVkZSwgZG91YmxlIGFsdGl0dWRlLCBkb3Vi bGUgYWNjdXJhY3ksIGJvb2wgcHJvdmlkZXNBbHRpdHVkZUFjY3VyYWN5LCBkb3VibGUgYWx0aXR1 ZGVBY2N1cmFjeSwgYm9vbCBwcm92aWRlc0hlYWRpbmcsIGRvdWJsZSBoZWFkaW5nLCBib29sIHBy b3ZpZGVzU3BlZWQsIGRvdWJsZSBzcGVlZCwgbG9uZyBsb25nIHRpbWVzdGFtcCk7CisgICAgdmly dHVhbCB2b2lkIHNldExhc3RFcnJvcihpbnQgZXJyb3JDb2RlLCBjb25zdCBXZWJTdHJpbmcmIG1l c3NhZ2UpOworCitwcml2YXRlOgorICAgIFdlYlZpZXdDbGllbnQqIGdldFdlYlZpZXdDbGllbnQo KTsKKworICAgIC8vIEdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtIG93bnMgdXMsIHdlIG9ubHkg aGF2ZSBhIHBvaW50ZXIgYmFjayB0byBpdC4KKyAgICBHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1 bSogbV9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bTsKKyAgICBpbnQgbV9icmlkZ2VJZDsKK307 CisKK0dlb2xvY2F0aW9uU2VydmljZUJyaWRnZSogY3JlYXRlR2VvbG9jYXRpb25TZXJ2aWNlQnJp ZGdlSW1wbChHZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bSogZ2VvbG9jYXRpb25TZXJ2aWNlQ2hy b21pdW0pCit7CisgICAgcmV0dXJuIG5ldyBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsKGdl b2xvY2F0aW9uU2VydmljZUNocm9taXVtKTsKK30KKworR2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdl SW1wbDo6R2VvbG9jYXRpb25TZXJ2aWNlQnJpZGdlSW1wbChHZW9sb2NhdGlvblNlcnZpY2VDaHJv bWl1bSogZ2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0pCisgICAgOiBtX0dlb2xvY2F0aW9uU2Vy dmljZUNocm9taXVtKGdlb2xvY2F0aW9uU2VydmljZUNocm9taXVtKQoreworICAgIC8vIFdlIG5l ZWQgdG8gYXR0YWNoIG91cnNlbHZlcyBoZXJlOiBHZW9sb2NhdGlvbiBjYWxscyByZXF1ZXN0UGVy bWlzc2lvbkZvckZyYW1lKCkKKyAgICAvLyBkaXJlY3RseSwgYW5kIHdlIG5lZWQgdG8gYmUgYXR0 YWNoZWQgc28gdGhhdCB0aGUgZW1iZWRkZXIgY2FuIGNhbGwKKyAgICAvLyBvdXIgc2V0SXNBbGxv d2VkKCkuCisgICAgbV9icmlkZ2VJZCA9IGdldFdlYlZpZXdDbGllbnQoKS0+Z2V0R2VvbG9jYXRp b25TZXJ2aWNlKCktPmF0dGFjaEJyaWRnZSh0aGlzKTsKKyAgICBBU1NFUlQobV9icmlkZ2VJZCk7 Cit9CisKK0dlb2xvY2F0aW9uU2VydmljZUJyaWRnZUltcGw6On5HZW9sb2NhdGlvblNlcnZpY2VC cmlkZ2VJbXBsKCkKK3sKKyAgICBXZWJLaXQ6OldlYlZpZXdDbGllbnQqIHdlYlZpZXdDbGllbnQg PSBnZXRXZWJWaWV3Q2xpZW50KCk7CisgICAgLy8gR2VvbG9jYXRpb24gaGFzIGFuIE93blB0ciB0 byB1cywgYW5kIGl0J3MgZGVzdHJveWVkIGFmdGVyIHRoZSBmcmFtZSBoYXMKKyAgICAvLyBiZWVu IHBvdGVudGlhbGx5IGRpc2Nvbm5lY3RlZC4gSW4gdGhpcyBjYXNlLCBpdCBjYWxscyBzdG9wVXBk YXRpbmcoKQorICAgIC8vIGhhcyBiZWVuIGNhbGxlZCBhbmQgd2UgaGF2ZSBhbHJlYWR5IGRldHRh Y2hlZCBvdXJzZWx2ZXMuCisgICAgaWYgKCF3ZWJWaWV3Q2xpZW50KSB7CisgICAgICAgIEFTU0VS VCghbV9icmlkZ2VJZCk7CisgICAgfSBlbHNlIGlmIChtX2JyaWRnZUlkKQorICAgICAgICB3ZWJW aWV3Q2xpZW50LT5nZXRHZW9sb2NhdGlvblNlcnZpY2UoKS0+ZGV0dGFjaEJyaWRnZShtX2JyaWRn ZUlkKTsKK30KKworYm9vbCBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJbXBsOjpzdGFydFVwZGF0 aW5nKFBvc2l0aW9uT3B0aW9ucyogcG9zaXRpb25PcHRpb25zKQoreworICAgIGlmICghbV9icmlk Z2VJZCkKKyAgICAgICAgbV9icmlkZ2VJZCA9IGdldFdlYlZpZXdDbGllbnQoKS0+Z2V0R2VvbG9j YXRpb25TZXJ2aWNlKCktPmF0dGFjaEJyaWRnZSh0aGlzKTsKKyAgICBnZXRXZWJWaWV3Q2xpZW50 KCktPmdldEdlb2xvY2F0aW9uU2VydmljZSgpLT5zdGFydFVwZGF0aW5nKG1fYnJpZGdlSWQsIHBv c2l0aW9uT3B0aW9ucy0+ZW5hYmxlSGlnaEFjY3VyYWN5KCkpOworICAgIC8vLy8gRklYTUU6IHRo aXMgd2lsbCB0cmlnZ2VyIGEgcGVybWlzc2lvbiByZXF1ZXN0IHJlZ2FyZGxlc3MuCisgICAgLy8v LyBJcyBpdCBjb3JyZWN0PyBjb25maXJtIHdpdGggYW5kcmVpcC4KKyAgICAvLyBwb3NpdGlvbkNo YW5nZWQoKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9pZCBHZW9sb2NhdGlvblNlcnZpY2VC cmlkZ2VJbXBsOjpzdG9wVXBkYXRpbmcoKQoreworICAgIFdlYkdlb2xvY2F0aW9uU2VydmljZUlu dGVyZmFjZSogZ2VvbG9jYXRpb25TZXJ2aWNlID0gZ2V0V2ViVmlld0NsaWVudCgpLT5nZXRHZW9s b2NhdGlvblNlcnZpY2UoKTsKKyAgICBnZW9sb2NhdGlvblNlcnZpY2UtPnN0b3BVcGRhdGluZyht X2JyaWRnZUlkKTsKKyAgICBnZW9sb2NhdGlvblNlcnZpY2UtPmRldHRhY2hCcmlkZ2UobV9icmlk Z2VJZCk7CisgICAgbV9icmlkZ2VJZCA9IDA7Cit9CisKK3ZvaWQgR2VvbG9jYXRpb25TZXJ2aWNl QnJpZGdlSW1wbDo6c3VzcGVuZCgpCit7CisgICAgZ2V0V2ViVmlld0NsaWVudCgpLT5nZXRHZW9s b2NhdGlvblNlcnZpY2UoKS0+c3VzcGVuZChtX2JyaWRnZUlkKTsKK30KKwordm9pZCBHZW9sb2Nh dGlvblNlcnZpY2VCcmlkZ2VJbXBsOjpyZXN1bWUoKQoreworICAgIGdldFdlYlZpZXdDbGllbnQo KS0+Z2V0R2VvbG9jYXRpb25TZXJ2aWNlKCktPnJlc3VtZShtX2JyaWRnZUlkKTsKK30KKworaW50 IEdlb2xvY2F0aW9uU2VydmljZUJyaWRnZUltcGw6OmdldEJyaWRnZUlkKCkgY29uc3QKK3sKKyAg ICByZXR1cm4gbV9icmlkZ2VJZDsKK30KKwordm9pZCBHZW9sb2NhdGlvblNlcnZpY2VCcmlkZ2VJ bXBsOjpzZXRJc0FsbG93ZWQoYm9vbCBhbGxvd2VkKQoreworICAgIG1fR2VvbG9jYXRpb25TZXJ2 aWNlQ2hyb21pdW0tPnNldElzQWxsb3dlZChhbGxvd2VkKTsKK30KKwordm9pZCBHZW9sb2NhdGlv blNlcnZpY2VCcmlkZ2VJbXBsOjpzZXRMYXN0UG9zaXRpb24oZG91YmxlIGxhdGl0dWRlLCBkb3Vi bGUgbG9uZ2l0dWRlLCBib29sIHByb3ZpZGVzQWx0aXR1ZGUsIGRvdWJsZSBhbHRpdHVkZSwgZG91 YmxlIGFjY3VyYWN5LCBib29sIHByb3ZpZGVzQWx0aXR1ZGVBY2N1cmFjeSwgZG91YmxlIGFsdGl0 dWRlQWNjdXJhY3ksIGJvb2wgcHJvdmlkZXNIZWFkaW5nLCBkb3VibGUgaGVhZGluZywgYm9vbCBw cm92aWRlc1NwZWVkLCBkb3VibGUgc3BlZWQsIGxvbmcgbG9uZyB0aW1lc3RhbXApCit7CisgICAg bV9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS0+c2V0TGFzdFBvc2l0aW9uKGxhdGl0dWRlLCBs b25naXR1ZGUsIHByb3ZpZGVzQWx0aXR1ZGUsIGFsdGl0dWRlLCBhY2N1cmFjeSwgcHJvdmlkZXNB bHRpdHVkZUFjY3VyYWN5LCBhbHRpdHVkZUFjY3VyYWN5LCBwcm92aWRlc0hlYWRpbmcsIGhlYWRp bmcsIHByb3ZpZGVzU3BlZWQsIHNwZWVkLCB0aW1lc3RhbXApOworfQorCit2b2lkIEdlb2xvY2F0 aW9uU2VydmljZUJyaWRnZUltcGw6OnNldExhc3RFcnJvcihpbnQgZXJyb3JDb2RlLCBjb25zdCBX ZWJTdHJpbmcmIG1lc3NhZ2UpCit7CisgICAgbV9HZW9sb2NhdGlvblNlcnZpY2VDaHJvbWl1bS0+ c2V0TGFzdEVycm9yKGVycm9yQ29kZSwgbWVzc2FnZSk7Cit9CisKK1dlYlZpZXdDbGllbnQqIEdl b2xvY2F0aW9uU2VydmljZUJyaWRnZUltcGw6OmdldFdlYlZpZXdDbGllbnQoKQoreworICAgIEZy YW1lKiBmcmFtZSA9IG1fR2VvbG9jYXRpb25TZXJ2aWNlQ2hyb21pdW0tPmZyYW1lKCk7CisgICAg aWYgKCFmcmFtZSB8fCAhZnJhbWUtPnBhZ2UoKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgV2Vi S2l0OjpDaHJvbWVDbGllbnRJbXBsKiBjaHJvbWVDbGllbnRJbXBsID0gc3RhdGljX2Nhc3Q8V2Vi S2l0OjpDaHJvbWVDbGllbnRJbXBsKj4oZnJhbWUtPnBhZ2UoKS0+Y2hyb21lKCktPmNsaWVudCgp KTsKKyAgICBXZWJLaXQ6OldlYlZpZXdDbGllbnQqIHdlYlZpZXdDbGllbnQgPSBjaHJvbWVDbGll bnRJbXBsLT53ZWJWaWV3KCktPmNsaWVudCgpOworICAgIHJldHVybiB3ZWJWaWV3Q2xpZW50Owor fQorCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmIC8vIEVOQUJMRShHRU9MT0NBVElP TikKClByb3BlcnR5IGNoYW5nZXMgb246IFdlYktpdC9jaHJvbWl1bS9zcmMvR2VvbG9jYXRpb25T ZXJ2aWNlQnJpZGdlQ2hyb21pdW0uY3BwCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjplb2wtc3R5bGUK ICAgKyBMRgoK