67616 2011-09-05 12:49:24 -0700 [Chromium] Add WebViewport for Android 2011-11-29 13:30:59 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED INVALID P2 Normal --- 68075 66687 1 abarth abarth fishd fsamuel peter rjkroege steveblock oldest_to_newest 462230 0 abarth 2011-09-05 12:49:24 -0700 [Chromium] Add WebViewport for Android 462231 1 106354 abarth 2011-09-05 12:50:36 -0700 Created attachment 106354 Patch 462817 2 106354 fishd 2011-09-06 13:38:42 -0700 Comment on attachment 106354 Patch Can you say more about how this will be used? It is really hard to review this without having the bigger picture in mind. 462839 3 abarth 2011-09-06 13:59:38 -0700 Sure. Here are some snippets from the Android to-be-upstreamed patch. It looks like plumbing for the viewport meta tag. --- a/Source/WebKit/chromium/public/WebViewClient.h +++ b/Source/WebKit/chromium/public/WebViewClient.h + // Did receive the viewport meta tag + virtual void didReceiveViewport(const WebViewport&) { } --- a/Source/WebKit/chromium/src/ChromeClientImpl.cpp +++ b/Source/WebKit/chromium/src/ChromeClientImpl.cpp +void ChromeClientImpl::dispatchViewportDataDidChange(const ViewportArguments& arguments) const +{ +#if OS(ANDROID) + if (m_webView->client()) { + ViewportArguments args; + if (arguments == args) { + // Default viewport arguments passed in. This is a signal to reset the viewport. + args.width = ViewportArguments::ValueDesktopWidth; + } else { + args = arguments; + if (arguments.minimumScale == 1.0f && + arguments.initialScale == ViewportArguments::ValueAuto && + arguments.width == ViewportArguments::ValueAuto && + arguments.height == ViewportArguments::ValueAuto) { + // Fix for mobile google.com, since right now only minimum-scale + // 1.0 is passed in the viewport argument. + args.width = ViewportArguments::ValueDeviceWidth; + } + } + WebViewClient* client = m_webView->client(); + WebRect deviceRect = client->getDeviceRect(); + // Call the common viewport computing logic in ViewportArguments.cpp. + ViewportAttributes computed = computeViewportAttributes( + args, client->getFixedLayoutWidth(), deviceRect.width, deviceRect.height, + client->getDeviceDpi(), IntSize(deviceRect.width, deviceRect.height)); + int computedWidth = computed.layoutSize.width(); + int computedHeight = computed.layoutSize.height(); + + WebViewport viewport; + viewport.initialScale = computed.initialScale; + viewport.initialScaleExplicitlySet = + (arguments.initialScale != ViewportArguments::ValueAuto); + viewport.minimumScale = computed.minimumScale; + viewport.maximumScale = computed.maximumScale; + viewport.width = computedWidth; + viewport.height = computedHeight; + viewport.devicePixelRatio = computed.devicePixelRatio; + viewport.userScalable = (computed.userScalable == 1 || + computed.userScalable == ViewportArguments::ValueAuto); + m_webView->client()->didReceiveViewport(viewport); + + // FIXME: + // "width=320" is a magic number as it was used in the early days to + // indicate the site wants the device width; while it's not handled in + // computeViewportAttributes. May want to upstream later. + IntSize size(computedWidth, computedHeight); + if (computedWidth == 320 || !viewport.userScalable) { + FloatRect rect = const_cast<ChromeClientImpl*>(this)->windowRect(); + size.setWidth(rect.width()); + size.setHeight(rect.height()); + } + m_webView->page()->mainFrame()->view()->setFixedLayoutSize(size); + } +#endif +} Here's some documentation about the viewport meta tag: https://developer.mozilla.org/en/mobile/viewport_meta_tag http://dev.opera.com/articles/view/an-introduction-to-meta-viewport-and-viewport/ It is a widely used feature on the mobile web. 463695 4 106354 eric 2011-09-07 15:20:31 -0700 Comment on attachment 106354 Patch Why a struct? That's very much not webkit style. :( 463722 5 abarth 2011-09-07 15:46:06 -0700 grep tells me there are 49 struct declarations in the Chromium WebKit API. It's an API pattern we use when exposing pure data either to or from the embedder. For example, here is a declaration for WebRect: http://trac.webkit.org/browser/trunk/Source/WebKit/chromium/public/WebRect.h 463923 6 106354 fishd 2011-09-08 00:01:38 -0700 Comment on attachment 106354 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106354&action=review > Source/WebKit/chromium/public/WebViewport.h:39 > + DeviceValue = 0, nit: there's a convention in webkit API to name enum values like so: enum Foo { FooBar, FooBaz }; Obviously, it is OK to drop the enum name since you don't need it, but perhaps it would be good to change DeviceValue to ValueSomething. That said, it looks like DeviceValue is unused. If a different patch will use it, then maybe it could be called ValueDefault? > Source/WebKit/chromium/public/WebViewport.h:66 > +} nit: } // namespace WebKit 463937 7 106354 abarth 2011-09-08 00:15:30 -0700 Comment on attachment 106354 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=106354&action=review >> Source/WebKit/chromium/public/WebViewport.h:39 >> + DeviceValue = 0, > > nit: there's a convention in webkit API to name enum values like so: > > enum Foo { > FooBar, > FooBaz > }; > > Obviously, it is OK to drop the enum name since you don't need it, but perhaps > it would be good to change DeviceValue to ValueSomething. That said, it looks > like DeviceValue is unused. If a different patch will use it, then maybe it > could be called ValueDefault? ValueDevice doesn't read that well... Maybe: enum SpecialValue { SpecialValueUndefined, SpecialValueDevice, }; Although, perhaps a better solution is to avoid in-band signaling altogether using a struct for each of these values: struct Value { bool isDefined; bool isDevice; float value; }; Although then you have the problem of what the semantics are if both isDefined and isDevice are true... 463950 8 106710 abarth 2011-09-08 01:23:42 -0700 Created attachment 106710 Patch 466490 9 106710 abarth 2011-09-13 13:06:52 -0700 Comment on attachment 106710 Patch I talked this over with fishd. It's hard to understand whether this data structure is correct in isolation. I'm going to look at the bigger picture and revise. 486240 10 fsamuel 2011-10-18 12:44:39 -0700 I took a look at the renderer side of things to see where its used. This seems to be where (content/renderer/render_view.cc - now render_view_impl.cc): #if defined(OS_ANDROID) void RenderView::didReceiveViewport(const WebKit::WebViewport& viewport) { dpi_scale_ = viewport.devicePixelRatio; user_scalable_ = viewport.userScalable; minimum_scale_ = std::max(viewport.minimumScale, content::kMinMagnifyZoom); maximum_scale_ = std::min(viewport.maximumScale, content::kMaxMagnifyZoom); UpdateHostViewportScale(); SetMagnifyZoomAndScroll(viewport.initialScale * dpi_scale_, gfx::Point(0, 0)); magnify_scale_set_ = viewport.initialScaleExplicitlySet; } This suggests to me width, height and targetDensityDpi are unnecessary. I'm not certain if we absolutely need two variables, one for userScalable, and initialScaleExplicitlySet. I'll see if we can avoid that. I suspect devicePixelRatio might be unnecessary as well if we use and expose deviceScaleFactor that was recently upstreamed. 486242 11 fsamuel 2011-10-18 12:46:39 -0700 (In reply to comment #10) > I took a look at the renderer side of things to see where its used. This seems to be where (content/renderer/render_view.cc - now render_view_impl.cc): > > #if defined(OS_ANDROID) > void RenderView::didReceiveViewport(const WebKit::WebViewport& viewport) { > dpi_scale_ = viewport.devicePixelRatio; > user_scalable_ = viewport.userScalable; > minimum_scale_ = std::max(viewport.minimumScale, content::kMinMagnifyZoom); > maximum_scale_ = std::min(viewport.maximumScale, content::kMaxMagnifyZoom); > UpdateHostViewportScale(); > > SetMagnifyZoomAndScroll(viewport.initialScale * dpi_scale_, gfx::Point(0, 0)); > magnify_scale_set_ = viewport.initialScaleExplicitlySet; > } > > This suggests to me width, height and targetDensityDpi are unnecessary. > > I'm not certain if we absolutely need two variables, one for userScalable, and initialScaleExplicitlySet. I'll see if we can avoid that. I suspect devicePixelRatio might be unnecessary as well if we use and expose deviceScaleFactor that was recently upstreamed. Given that we can probably get away with just 4 parameters, I suggest avoiding this struct all together, and instead passing them all explicitly to didReceiveViewport. 511015 12 fsamuel 2011-11-29 12:41:55 -0800 Adam, do you mind if I close this bug? I don't think I'll be using WebViewport when I upstream my changes. Thanks. 511067 13 abarth 2011-11-29 13:30:59 -0800 You should feel free to close any of my bugs that you think should be closed. I'll re-open them if I disagree. :) 106354 2011-09-05 12:50:36 -0700 2011-09-08 01:23:38 -0700 Patch bug-67616-20110905125034.patch text/plain 4120 abarth U3VidmVyc2lvbiBSZXZpc2lvbjogOTQ0OTkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXgg MjlkZDk0Njc1YjAxNzUwODMyMTg5MTQwOTNkNGUyZDY2YzZhMzlkYS4uOGJmOTJiY2E5NmMwYWEx Y2IzOGNkYmVmNGQyNzhkZmI4ZmRiYmUzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAg LTEsNSArMSwxOSBAQAogMjAxMS0wOS0wNSAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3Jn PgogCisgICAgICAgIFtDaHJvbWl1bV0gQWRkIFdlYlZpZXdwb3J0IGZvciBBbmRyb2lkCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NzYxNgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFuZHJvaWQgbmVlZHMg YSBtb3JlIGV4cGxpY2l0IG5vdGlvbiBvZiBhIHZpZXdwb3J0LCBwcmVzdW1hYmx5IHRvCisgICAg ICAgIGhhbmRsZSByb3RhdGlvbiBhbmQgc2NhbGluZy4KKworICAgICAgICAqIFdlYktpdC5neXA6 CisgICAgICAgICogcHVibGljL1dlYlZpZXdwb3J0Lmg6IEFkZGVkLgorICAgICAgICAoV2ViS2l0 OjpXZWJWaWV3cG9ydDo6V2ViVmlld3BvcnQpOgorCisyMDExLTA5LTA1ICBBZGFtIEJhcnRoICA8 YWJhcnRoQHdlYmtpdC5vcmc+CisKICAgICAgICAgW0Nocm9taXVtXSBVcGRhdGUgV2ViVG91Y2hF dmVudCBmb3IgQW5kcm9pZAogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9Njc2MTUKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJL aXQuZ3lwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCmluZGV4IDVjNTZjZjYw OTZlYTUzMDY5ZDE5ZTQ1ZjNlZGJhNDBiOGRiYzFlOTQuLjQzMGI5MDRhNjQ0NWJmYmJhYjM1NGQz MTZjMGIwMjQ3NDE4MGM3ZjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2Vi S2l0Lmd5cAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKQEAgLTI5OSw2 ICsyOTksNyBAQAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViVmVjdG9yLmgnLAogICAgICAg ICAgICAgICAgICdwdWJsaWMvV2ViVmlldy5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dl YlZpZXdDbGllbnQuaCcsCisgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJWaWV3cG9ydC5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYldpZGdldC5oJywKICAgICAgICAgICAgICAgICAn cHVibGljL1dlYldpZGdldENsaWVudC5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYldv cmtlci5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlZp ZXdwb3J0LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJWaWV3cG9ydC5oCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmZkNDZlZjAwMTBhY2ViODlhYzMwYjhiMzYyMDg3NzllNDk0Mjg3OGEKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJWaWV3cG9ydC5o CkBAIC0wLDAgKzEsNjggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUK KyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJp Z2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUg bmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3Jz IG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20K KyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Np b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhP TERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICog QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRI RSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us CisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYlZpZXdwb3J0X2gKKyNkZWZpbmUgV2ViVmlld3Bv cnRfaAorCituYW1lc3BhY2UgV2ViS2l0IHsKKworc3RydWN0IFdlYlZpZXdwb3J0IHsKKyAgICBl bnVtIHsKKyAgICAgICAgVmFsdWVVbmRlZmluZWQgPSAtMSwKKyAgICAgICAgRGV2aWNlVmFsdWUg PSAwLAorICAgIH07CisKKyAgICBmbG9hdCBpbml0aWFsU2NhbGU7CisgICAgYm9vbCBpbml0aWFs U2NhbGVFeHBsaWNpdGx5U2V0OworICAgIGZsb2F0IG1pbmltdW1TY2FsZTsKKyAgICBmbG9hdCBt YXhpbXVtU2NhbGU7CisgICAgaW50IHdpZHRoOworICAgIGludCBoZWlnaHQ7CisgICAgaW50IHRh cmdldERlbnNpdHlEcGk7CisgICAgYm9vbCB1c2VyU2NhbGFibGU7CisgICAgZmxvYXQgZGV2aWNl UGl4ZWxSYXRpbzsKKworICAgIFdlYlZpZXdwb3J0KCkKKyAgICAgICAgOiBpbml0aWFsU2NhbGUo VmFsdWVVbmRlZmluZWQpCisgICAgICAgICwgaW5pdGlhbFNjYWxlRXhwbGljaXRseVNldChmYWxz ZSkKKyAgICAgICAgLCBtaW5pbXVtU2NhbGUoVmFsdWVVbmRlZmluZWQpCisgICAgICAgICwgbWF4 aW11bVNjYWxlKFZhbHVlVW5kZWZpbmVkKQorICAgICAgICAsIHdpZHRoKFZhbHVlVW5kZWZpbmVk KQorICAgICAgICAsIGhlaWdodChWYWx1ZVVuZGVmaW5lZCkKKyAgICAgICAgLCB0YXJnZXREZW5z aXR5RHBpKFZhbHVlVW5kZWZpbmVkKQorICAgICAgICAsIHVzZXJTY2FsYWJsZSh0cnVlKQorICAg ICAgICAsIGRldmljZVBpeGVsUmF0aW8oVmFsdWVVbmRlZmluZWQpCisgICAgeworICAgIH0KK307 CisKK30KKworI2VuZGlmCg== 106710 2011-09-08 01:23:42 -0700 2011-09-13 13:06:52 -0700 Patch bug-67616-20110908012340.patch text/plain 4072 abarth SW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiA5NDc0NykKKysrIFNvdXJj ZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcg QEAKKzIwMTEtMDktMDggIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KKworICAgICAg ICBbQ2hyb21pdW1dIEFkZCBXZWJWaWV3cG9ydCBmb3IgQW5kcm9pZAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Njc2MTYKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbmRyb2lkIG5lZWRzIGEgbW9yZSBleHBs aWNpdCBub3Rpb24gb2YgYSB2aWV3cG9ydCwgcHJlc3VtYWJseSB0bworICAgICAgICBoYW5kbGUg cm90YXRpb24gYW5kIHNjYWxpbmcuCisKKyAgICAgICAgKiBXZWJLaXQuZ3lwOgorICAgICAgICAq IHB1YmxpYy9XZWJWaWV3cG9ydC5oOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdDo6V2ViVmlld3Bv cnQ6OldlYlZpZXdwb3J0KToKKwogMjAxMS0wOS0wNyAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJr aXQub3JnPgogCiAgICAgICAgIEZyYW1lTG9hZGVyOjphZGRFeHRyYUZpZWxkc1RvUmVxdWVzdCBj YW4gY3Jhc2ggd2hlbiBjYWxsZWQgZnJvbSBvciBhZnRlciBGcmFtZUxvYWRlcjo6ZGV0YWNoRnJv bVBhcmVudApJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAkocmV2aXNpb24gOTQ3NDcp CisrKyBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAJKHdvcmtpbmcgY29weSkKQEAg LTI5OSw2ICsyOTksNyBAQAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViVmVjdG9yLmgnLAog ICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViVmlldy5oJywKICAgICAgICAgICAgICAgICAncHVi bGljL1dlYlZpZXdDbGllbnQuaCcsCisgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJWaWV3cG9y dC5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYldpZGdldC5oJywKICAgICAgICAgICAg ICAgICAncHVibGljL1dlYldpZGdldENsaWVudC5oJywKICAgICAgICAgICAgICAgICAncHVibGlj L1dlYldvcmtlci5oJywKSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlZp ZXdwb3J0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi Vmlld3BvcnQuaAkocmV2aXNpb24gMCkKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYlZpZXdwb3J0LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjggQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYlZp ZXdwb3J0X2gKKyNkZWZpbmUgV2ViVmlld3BvcnRfaAorCituYW1lc3BhY2UgV2ViS2l0IHsKKwor c3RydWN0IFdlYlZpZXdwb3J0IHsKKyAgICBlbnVtIFNwZWNpYWxWYWx1ZSB7CisgICAgICAgIFNw ZWNpYWxWYWx1ZVVuZGVmaW5lZCA9IC0xLAorICAgICAgICBTcGVjaWFsVmFsdWVEZXZpY2UgPSAw LAorICAgIH07CisKKyAgICBmbG9hdCBpbml0aWFsU2NhbGU7CisgICAgYm9vbCBpbml0aWFsU2Nh bGVFeHBsaWNpdGx5U2V0OworICAgIGZsb2F0IG1pbmltdW1TY2FsZTsKKyAgICBmbG9hdCBtYXhp bXVtU2NhbGU7CisgICAgaW50IHdpZHRoOworICAgIGludCBoZWlnaHQ7CisgICAgaW50IHRhcmdl dERlbnNpdHlEcGk7CisgICAgYm9vbCB1c2VyU2NhbGFibGU7CisgICAgZmxvYXQgZGV2aWNlUGl4 ZWxSYXRpbzsKKworICAgIFdlYlZpZXdwb3J0KCkKKyAgICAgICAgOiBpbml0aWFsU2NhbGUoU3Bl Y2lhbFZhbHVlVW5kZWZpbmVkKQorICAgICAgICAsIGluaXRpYWxTY2FsZUV4cGxpY2l0bHlTZXQo ZmFsc2UpCisgICAgICAgICwgbWluaW11bVNjYWxlKFNwZWNpYWxWYWx1ZVVuZGVmaW5lZCkKKyAg ICAgICAgLCBtYXhpbXVtU2NhbGUoU3BlY2lhbFZhbHVlVW5kZWZpbmVkKQorICAgICAgICAsIHdp ZHRoKFNwZWNpYWxWYWx1ZVVuZGVmaW5lZCkKKyAgICAgICAgLCBoZWlnaHQoU3BlY2lhbFZhbHVl VW5kZWZpbmVkKQorICAgICAgICAsIHRhcmdldERlbnNpdHlEcGkoU3BlY2lhbFZhbHVlVW5kZWZp bmVkKQorICAgICAgICAsIHVzZXJTY2FsYWJsZSh0cnVlKQorICAgICAgICAsIGRldmljZVBpeGVs UmF0aW8oU3BlY2lhbFZhbHVlVW5kZWZpbmVkKQorICAgIHsKKyAgICB9Cit9OworCit9IC8vIG5h bWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCg==