197947 2019-05-16 06:56:04 -0700 [GTK] Should use light theme unless website declares support for dark themes in color-schemes property 2024-04-12 03:42:12 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build PC Linux RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=126907 https://bugs.webkit.org/show_bug.cgi?id=165072 https://bugs.webkit.org/show_bug.cgi?id=118234 https://bugs.webkit.org/show_bug.cgi?id=186146 https://bugs.webkit.org/show_bug.cgi?id=196685 https://bugs.webkit.org/show_bug.cgi?id=186219 https://bugs.webkit.org/show_bug.cgi?id=202194 https://bugs.webkit.org/show_bug.cgi?id=206953 https://bugs.webkit.org/show_bug.cgi?id=197276 https://bugs.webkit.org/show_bug.cgi?id=209385 https://bugs.webkit.org/show_bug.cgi?id=208204 P2 Normal --- 1 mcatanzaro webkit-unassigned annulen aperez benjamin berto bugs-noreply cassidy cdumez cgarcia cmarcelo contact+bugs.webkit.org dbates emilio esprehn+autocc ews-watchlist glenn gustavo gyuyoung.kim ie2kl43y kangil.han kondapallykalyan mcatanzaro otte pdr ryuan.choi sergio oldest_to_newest 1536789 0 mcatanzaro 2019-05-16 06:56:04 -0700 Currently the web breaks pretty badly when users use a dark GTK theme. We should follow macOS in restricting dark theme usage to websites that have declared support for it using the color-scheme CSS property, as documented in https://webkit.org/blog/8840/dark-mode-support-in-webkit/. This is not possible to do perfectly because GTK does not have any concept of dark vs. light themes, so we'll have to use heuristics. We can attempt to switch from a dark theme to light theme by default, e.g. by pruning -dark or :dark off the name of the GTK theme and hoping for the best. Then we can switch back to the dark theme variant only if used on websites that really support dark mode. If we cannot switch like this due to performance considerations, then it's better to always try to prune the -dark portion of the theme name and use a light theme, because dark themes will never be web-compatible except for websites that opt-in. 1536792 1 cgarcia 2019-05-16 07:16:05 -0700 This is indeed not so easy. Our theming code always uses the values from current theme, and the only way to use a different theme is by actually changing the theme. That's indeed what mac does, but in GTK loading a new theme takes some time, and we would need to do that for every single call to RenderTheme API. I implemented it, and it was unusable. 1536796 2 mcatanzaro 2019-05-16 07:38:38 -0700 OK. (In reply to Carlos Garcia Campos from comment #1) > and we would need to do that for every single call to RenderTheme API. Naively, we'd like to change the theme just once per webpage. Nowadays we're guaranteed to have a separate process per web view, except for related views. The problem becomes related views and frames. The page displayed in a parent frame might opt-in to dark theme, but not the page in a child frame, even if both frames share the same security origin (and therefore the same process, under PSON). So at a minimum, we would need to change the theme at least as often as we switch between rendering related views or different frames in the same process, but only to the extent the pages rendered in those views/frames want different themes. An alternative approach would be to attempt to force light theme in GTK 3, punt dark theme to GTK 4, and see if we can convince Company to support multiple themes in the same process. It could be doable if GTK were to grow a library context object so that multiple instances of GTK could run in the same process. That might be nuts, though. 1574350 3 cassidy 2019-09-25 21:03:39 -0700 Something that might simplify this: it looks like almost* all other engines on other OSes use the light styles always, regardless of the site declaring support in CSS. I presume this is because browsers have largely had light-styled defaults for so long that it's less breaking to keep the light defaults, and assume that developers adopting the *new* feature of `prefers-color-scheme` are going to provide styles that work in the majority of browsers shipping today. I've put together a little demo site to show the current behaviors of Gecko, Blink, WebKit, and WebKitGTK across OSes: https://cassidyjames.com/dark-demo/ https://cassidyjames.com/dark-demo/mixed.html https://cassidyjames.com/dark-demo/dark.html It looks like the two outliers are Firefox on Linux (due to using the dark GTK theme for inputs) and WebKitGTK due to using a dark default stylesheet *and* dark styled inputs. I think WebKit GTK could safely always use the light GTK variant and be more in line with the other browsers. 1574451 4 mcatanzaro 2019-09-26 08:13:28 -0700 (In reply to Cassidy James Blaede from comment #3) > It looks like the two outliers are Firefox on Linux (due to using the dark > GTK theme for inputs) and WebKitGTK due to using a dark default stylesheet > *and* dark styled inputs. I think WebKit GTK could safely always use the > light GTK variant and be more in line with the other browsers. It is not technically possible to do with GTK, per Carlos's comments above. We seem to have reached a consensus that we need to remove support for GTK themes in order to fix this bug, because the GTK developers are not interested in changing GTK to make this solvable. Fixing this bug is more important than keeping GTK theme support, and GTK developers don't want us using GTK theme on the web anyway. A large number of other dark mode bugs will disappear as soon as we remove the GTK support. But that requires writing a cross-platform theme to replace the GTK theme. Safari might be doing this soon too, to get away from macOS platform theme, so we will wait and see what happens there. 1574478 5 cassidy 2019-09-26 09:35:40 -0700 (In reply to Michael Catanzaro from comment #4) > We seem to have reached a consensus that we need to remove support for GTK > themes in order to fix this bug, because the GTK developers are not > interested in changing GTK to make this solvable. Fixing this bug is more > important than keeping GTK theme support, and GTK developers don't want us > using GTK theme on the web anyway. A large number of other dark mode bugs > will disappear as soon as we remove the GTK support. That does sound reasonable for a long-term goal, and is in line with what Chrome has done across platforms as far as I can tell. > But that requires writing a cross-platform theme to replace the GTK theme. > Safari might be doing this soon too, to get away from macOS platform theme, > so we will wait and see what happens there. The one major issue I see with waiting is that the behavior in WebKitGTK changed recently, and is badly breaking websites. See specifically the case where a developer defines a foreground color but not a background color, which is not uncommon: https://cassidyjames.com/dark-demo/mixed.html A real-world example of this is Startpage.com search results and the GNOME Wiki (https://wiki.gnome.org/Apps/Web). Websites are completely broken with the new dark default stylesheet when using a dark GTK theme. If that's a standalone bug, I am fine to file it, but it's my biggest concern right now with WebKitGTK and will make WebKitGTK unusable for elementary OS in its current state. 1574482 6 cassidy 2019-09-26 09:40:45 -0700 (In reply to Michael Catanzaro from comment #4) > But that requires writing a cross-platform theme to replace the GTK theme. > Safari might be doing this soon too, to get away from macOS platform theme, > so we will wait and see what happens there. Would it be unreasonable to bundle a light-only Adwaita with WebKitGTK, at least in the meantime? Adwaita is a very neutral style and removing its dark variant would not be difficult. 1574483 7 mcatanzaro 2019-09-26 09:41:33 -0700 Sadly dark themes have *never* been well-supported by WebKitGTK (as evidenced by many, many bugs in this bugtracker) so I strongly recommend you ensure it doesn't get used until this changes... somehow. If it's possible to change theme using environment variables (not sure), then you could run Epiphany with an envvar to force light theme, for instance. If there's some particular commit that has made the situation worse recently, and you could identify it, then we could consider reverting. (In reply to Cassidy James Blaede from comment #6) > Would it be unreasonable to bundle a light-only Adwaita with WebKitGTK, at > least in the meantime? Adwaita is a very neutral style and removing its dark > variant would not be difficult. Maybe? 1574486 8 mcatanzaro 2019-09-26 09:46:36 -0700 (In reply to Cassidy James Blaede from comment #3) > I've put together a little demo site to show the current behaviors of Gecko, > Blink, WebKit, and WebKitGTK across OSes: > > https://cassidyjames.com/dark-demo/ > https://cassidyjames.com/dark-demo/mixed.html > https://cassidyjames.com/dark-demo/dark.html > > It looks like the two outliers are Firefox on Linux (due to using the dark > GTK theme for inputs) and WebKitGTK due to using a dark default stylesheet > *and* dark styled inputs. I think WebKit GTK could safely always use the > light GTK variant and be more in line with the other browsers. This is a really helpful demo BTW. I agree the WebKitGTK behavior is clearly broken. 1574495 9 aperez 2019-09-26 09:53:31 -0700 (In reply to Michael Catanzaro from comment #7) > Sadly dark themes have *never* been well-supported by WebKitGTK (as > evidenced by many, many bugs in this bugtracker) so I strongly recommend you > ensure it doesn't get used until this changes... somehow. If it's possible > to change theme using environment variables (not sure), then you could run > Epiphany with an envvar to force light theme, for instance. The GTK_THEME environment variable works for all GTK+ applications: % GTK_THEME=Adwaita epiphany It should also be possible to use the GtkSettings::theme-name property to set a theme programatically. That being said, forcing its value for any application that uses WebKitGTK would be to blatantly ignore the user's settings: instead, I would only do it for the Web process, where we do handling of the widgets *from Web pages*, so only those would be affected, and the chrome of the applications using WebKitGTK (like Epiphany) would still follow the user settings. > If there's some particular commit that has made the situation worse > recently, and you could identify it, then we could consider reverting. > > (In reply to Cassidy James Blaede from comment #6) > > Would it be unreasonable to bundle a light-only Adwaita with WebKitGTK, at > > least in the meantime? Adwaita is a very neutral style and removing its dark > > variant would not be difficult. > > Maybe? If that is the way we want things to go (forcing a non-dark theme) there is no need to bundle it. We can use GtkSettings::theme-name or GTK_THEME (as outlined above) to force using Adwaita in the Web process as soon as it starts. I would rather not bundle a GTK theme with WebKit which is expected to be installed anyway — if we do, it will soon get desynced from upstream Adwaita. 1574498 10 aperez 2019-09-26 09:59:19 -0700 (In reply to Adrian Perez from comment #9) > > [...] > > If that is the way we want things to go (forcing a non-dark theme) > there is no need to bundle it. We can use GtkSettings::theme-name > or GTK_THEME (as outlined above) to force using Adwaita in the Web > process as soon as it starts. Actually, I would try and be more fine grained here: if the current value of GtkSettings::theme-name ends in “-dark”, remove the suffix; in any other case set it to “Adwaita”. If the theme name resulting from removing the “-dark” suffix is not installed, GTK will default to Adwaita anyway. Rationaly: If I have installed themes “Arc” and “Arc-dark”, and my settings have “Arc-dark” configured, I would rather have controls rendered in Web pages using “Arc” than “Adwaita”. (Yes, I am one of those people in the intersection of “subjects who don't like Adwaita much” and “subjects who have the slight amount of OCD to care that widgets in Web pages get rendered at least in a somewhat coherent way with the rest of the system theme”). 1574503 11 mcatanzaro 2019-09-26 10:05:31 -0700 (In reply to Adrian Perez from comment #10) > Actually, I would try and be more fine grained here: if the current > value of GtkSettings::theme-name ends in “-dark”, remove the suffix; +1, let's do this for now, and close all the dark theme bugs. Themes named "midnight" will just stay broken for now. In the long term, after removing support for GTK themes, then we can have some proper dark mode support. But until then, forcing light is the way to go. > in any other case set it to “Adwaita”. This must be a typo, because then we'd change "Arc" to "Adwaita" and you don't want that. 1574516 12 aperez 2019-09-26 10:19:48 -0700 (In reply to Michael Catanzaro from comment #11) > (In reply to Adrian Perez from comment #10) > > Actually, I would try and be more fine grained here: if the current > > value of GtkSettings::theme-name ends in “-dark”, remove the suffix; > > +1, let's do this for now, and close all the dark theme bugs. Themes named > "midnight" will just stay broken for now. > > In the long term, after removing support for GTK themes, then we can have > some proper dark mode support. But until then, forcing light is the way to > go. I can try to have a patch ready in the next days. > > in any other case set it to “Adwaita”. > > This must be a typo, because then we'd change "Arc" to "Adwaita" and you > don't want that. True, I wrote too fast. Let's try again, this time writing down things properly: * If the theme name is “<name>-dark”: - Remove the “-dark” suffix, use “<name>” as the theme. - If the theme “<name>” does not exist, GTK automatically fall-back to Adwaita. * Otherwise: - Keep the current theme name, assuming that it is light. This matches the on-going discussion about the proposal started around the last GUADEC where dark themes should be required to have a “-dark” suffix. 1585093 13 mcatanzaro 2019-10-29 14:18:00 -0700 (In reply to Cassidy James Blaede from comment #3) > I've put together a little demo site to show the current behaviors of Gecko, > Blink, WebKit, and WebKitGTK across OSes: > > https://cassidyjames.com/dark-demo/ > https://cassidyjames.com/dark-demo/mixed.html > https://cassidyjames.com/dark-demo/dark.html > > It looks like the two outliers are Firefox on Linux (due to using the dark > GTK theme for inputs) and WebKitGTK due to using a dark default stylesheet > *and* dark styled inputs. I think WebKit GTK could safely always use the > light GTK variant and be more in line with the other browsers. BTW Emilio: this is what I had mentioned to you a couple weeks ago. You can see in https://cassidyjames.com/dark-demo/ or https://cassidyjames.com/dark-demo/mixed.html that Firefox on Linux displays a clearly undesirable result. With https://cassidyjames.com/dark-demo/dark.html the page content looks OK but is still different than all the other browsers. 1585825 14 emilio 2019-10-31 01:21:09 -0700 I can see that in Firefox 67 (just a build that I had handy), but seems fixed in Firefox 70 (this is the "force light theme" hack that I mentioned at the hackfest) 1592785 15 contact+bugs.webkit.org 2019-11-22 07:27:13 -0800 Is there any update on fixing this quite critical bug? For now the only way for users is to launch WebKitGTK applications with a light variant of the theme, which breaks integration for the whole application (rather than just web, which is doomed to not be) and usage for non-advanced users which would still prefer a dark variant for their desktop. 1599418 16 mcatanzaro 2019-12-17 07:46:19 -0800 I agree with Adrian that this is a good idea: (In reply to Adrian Perez from comment #12) > * If the theme name is “<name>-dark”: > - Remove the “-dark” suffix, use “<name>” as the theme. > - If the theme “<name>” does not exist, GTK automatically > fall-back to Adwaita. > * Otherwise: > - Keep the current theme name, assuming that it is light. > > This matches the on-going discussion about the proposal started around > the last GUADEC where dark themes should be required to have a “-dark” > suffix. Then we need to revert the change from bug #196685 and have PageClientImpl::effectiveAppearanceIsDark always return false. And then we can close this bug, and all related dark mode bugs. In the future, it would be nice to actually support dark mode, but it's clear at this point we can't do that in GTK, so it must be preconditioned on removal of GTK theme support and implementation of a cross-platform theme that doesn't use GTK. 1611693 17 mcatanzaro 2020-01-27 16:35:15 -0800 (In reply to Michael Catanzaro from comment #16) > Then we need to revert the change from bug #196685 and have > PageClientImpl::effectiveAppearanceIsDark always return false. And then we > can close this bug, and all related dark mode bugs. Carlos, are you OK with this proposal? It requires rolling out r244766. (In reply to Adrian Perez from comment #12) > * If the theme name is “<name>-dark”: > - Remove the “-dark” suffix, use “<name>” as the theme. > - If the theme “<name>” does not exist, GTK automatically > fall-back to Adwaita. > * Otherwise: > - Keep the current theme name, assuming that it is light. Let's do this too. I guess the RenderTheme::singleton() constructor in RenderThemeGtk.cpp would be a good place. Only other place I can think of that might be appropriate would be WebProcessMainGtk.cpp. 1611941 18 389004 cgarcia 2020-01-28 08:41:32 -0800 Created attachment 389004 Patch 1611943 19 ews-watchlist 2020-01-28 08:42:52 -0800 Thanks for the patch. If this patch contains new public API please make sure it follows the guidelines for new WebKit2 GTK+ API. See http://trac.webkit.org/wiki/WebKitGTK/AddingNewWebKit2API 1611989 20 389004 mcatanzaro 2020-01-28 09:27:39 -0800 Comment on attachment 389004 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=389004&action=review Thanks Carlos, this was a huge help. I'll test it soon to verify it fixes older unpatched Evolution, and to check out its behavior in Cassidy's test cases. > LayoutTests/platform/gtk/css-dark-mode/default-colors-expected.txt:9 > -PASS Body text color is white > -FAIL View base background color is a dark grey assert_equals: expected "rgb(30, 30, 30)" but got "rgb(51, 57, 59)" > +FAIL Body text color is white assert_equals: expected "rgb(255, 255, 255)" but got "rgb(0, 0, 0)" > +FAIL View base background color is a dark grey assert_equals: expected "rgb(30, 30, 30)" but got "rgb(255, 255, 255)" I have a dream that one day, we can make this pass. One day.... > Source/WebCore/ChangeLog:10 > + guads should be enough. guards > Source/WebKit/ChangeLog:11 > + Handle the theme changes in the UI process, converting dark variant to the light one before sending the theme > + name to the web process. The web process is still notified when a dark theme is in use, so that if website > + prefers a dark color scheme it will be used, but the gtk theme that will be used for controls styling will > + always be light. I wrote a very long comment on why you should not do this, but checking Cassidy's example, maybe you're right and this is actually safe and amazing. I had failed to realize that other browser's dark modes are actually using light form controls (except Firefox on Linux, at least in Cassidy's old screenshots; I think Emilio mentioned that needs to be fixed). So maybe this is perfect. I will test. > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:598 > + if (name.endsWith("-dark")) Why aren't you also checking for ":dark" here? Mistake? > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:601 > +String PageClientImpl::themeName() const > +{ > + if (auto* themeNameEnv = g_getenv("GTK_THEME")) { > + String name = String::fromUTF8(themeNameEnv); > + if (name.endsWith("-dark") || name.endsWith(":dark")) > + return name.substring(0, name.length() - 5); > + return name; > + } > + > + GUniqueOutPtr<char> themeNameSetting; > + g_object_get(gtk_widget_get_settings(m_viewWidget), "gtk-theme-name", &themeNameSetting.outPtr(), nullptr); > + String name = String::fromUTF8(themeNameSetting.get()); > + if (name.endsWith("-dark")) > + return name.substring(0, name.length() - 5); > + return name; > +} Why does this have to be done in UI process instead of the web process? I was thinking we would do it in the RenderThemeGtk singleton function, so it takes effect exactly once per process, before rendering anything. Then you wouldn't have to remove the web process theme monitor. Is there a problem with that? I'm OK with removing the web process theme monitor if this really needs to move to the UI process, I just don't see why it does. > Source/WebKit/WebProcess/gtk/WebProcessMainGtk.cpp:58 > + // Ignore the GTK_THEME environment variable, the theme is always set by the UI process now. > + g_unsetenv("GTK_THEME"); You can't mutate the environment after XInitThreads(). It's not safe. Prior to this point, we have the g_usleep() -- which probably doesn't initialize threads, but we don't know for sure that will never change -- and the AuxiliaryProcessMainBase constructor, and libgcrypt initialization in Source/WebKit/WebProcess/EntryPoint/unix/WebProcessMain.cpp. I would move this to the top of WebProcessMain.cpp. Even if doing it at the top of this constructor is totally safe -- I think it is, because our platformInitialize() is currently called before InitializeWebKit2(), putting it there would be dangerous because any of that could change in the future. Mutating the environment is so exceptionally dangerous that it's just not worth messing around with this. The top of main() in WebProcessMain.cpp is always going to be safe, so definitely makes sense to do it there. > Source/WebKit/WebProcess/gtk/WebProcessMainGtk.cpp:60 > gtk_init(nullptr, nullptr); GTK actually uses a library constructor to unset environment variables, to avoid crashes that could occur if it were to do so in gtk_init(). On Windows, where library constructors aren't available, it risks crashing. 1612194 21 mcatanzaro 2020-01-28 14:48:12 -0800 (In reply to Michael Catanzaro from comment #20) > Thanks Carlos, this was a huge help. I'll test it soon to verify it fixes > older unpatched Evolution, and to check out its behavior in Cassidy's test > cases. OK, it fixes the Evolution/Geary regression as expected. Great! It also fixes Cassidy's third test in comment #3, dark style, which was previously broken. It badly fails Cassidy's first two tests though (neither of which passed before). Test #1 (no style) is now worse than before because it now uses black text (as desired) instead of light text (not desired) on a dark background (not desired). Test #2 (some style) is a little better than before, but still pretty bad. We need to pass these tests to be web-compatible. The problem is that you've now fixed the text color and all the form controls, but the background color is still wrong because the web process background is transparent, so the web content is displayed over the UI process's dark background instead of the light web process background. That is, everything is now perfect except for the background, and the background is only wrong because it is still drawn using the UI process theme! I'm going to give r+ because your patch moves us far in the desired direction. Everything except the background now works as desired, which is much better than before. We'll probably get new bug reports from users once this lands though, because dark mode users are going to see more dark text on dark background than they did before this patch. So after this patch lands, then a full, complete fix for all our dark mode problems would simply require rendering a default web view background in the web process, instead of allowing the UI process background color to peek through. So I plan to close all existing dark mode bugs and open one new bug for the background. Do you agree? And: is the background something you'd have time to work on? 1612348 22 cgarcia 2020-01-29 00:55:36 -0800 (In reply to Michael Catanzaro from comment #20) > Comment on attachment 389004 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=389004&action=review > > Thanks Carlos, this was a huge help. I'll test it soon to verify it fixes > older unpatched Evolution, and to check out its behavior in Cassidy's test > cases. > > > LayoutTests/platform/gtk/css-dark-mode/default-colors-expected.txt:9 > > -PASS Body text color is white > > -FAIL View base background color is a dark grey assert_equals: expected "rgb(30, 30, 30)" but got "rgb(51, 57, 59)" > > +FAIL Body text color is white assert_equals: expected "rgb(255, 255, 255)" but got "rgb(0, 0, 0)" > > +FAIL View base background color is a dark grey assert_equals: expected "rgb(30, 30, 30)" but got "rgb(255, 255, 255)" > > I have a dream that one day, we can make this pass. One day.... Once we stop using GTK theme, I guess. > > Source/WebCore/ChangeLog:10 > > + guads should be enough. > > guards Ooops. > > Source/WebKit/ChangeLog:11 > > + Handle the theme changes in the UI process, converting dark variant to the light one before sending the theme > > + name to the web process. The web process is still notified when a dark theme is in use, so that if website > > + prefers a dark color scheme it will be used, but the gtk theme that will be used for controls styling will > > + always be light. > > I wrote a very long comment on why you should not do this, but checking > Cassidy's example, maybe you're right and this is actually safe and amazing. This seems to be what other browsers do, according to the screenshots in the demos. When it's properly implemented it looks great, like the web inspector in dark mode. > I had failed to realize that other browser's dark modes are actually using > light form controls (except Firefox on Linux, at least in Cassidy's old > screenshots; I think Emilio mentioned that needs to be fixed). So maybe this > is perfect. I will test. Looks consistent and fixes the problem of unreadable form controls. > > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:598 > > + if (name.endsWith("-dark")) > > Why aren't you also checking for ":dark" here? Mistake? That's what we currently do, I think :dark is only used in the env var, but not in theme name settings. > > Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp:601 > > +String PageClientImpl::themeName() const > > +{ > > + if (auto* themeNameEnv = g_getenv("GTK_THEME")) { > > + String name = String::fromUTF8(themeNameEnv); > > + if (name.endsWith("-dark") || name.endsWith(":dark")) > > + return name.substring(0, name.length() - 5); > > + return name; > > + } > > + > > + GUniqueOutPtr<char> themeNameSetting; > > + g_object_get(gtk_widget_get_settings(m_viewWidget), "gtk-theme-name", &themeNameSetting.outPtr(), nullptr); > > + String name = String::fromUTF8(themeNameSetting.get()); > > + if (name.endsWith("-dark")) > > + return name.substring(0, name.length() - 5); > > + return name; > > +} > > Why does this have to be done in UI process instead of the web process? We need to override the theme to force a light variant in the web process. Once you have overriden the theme by setting the gtk-theme-name setting, you don't get notifications when the theme is changed in the system. So, the theme monitor in the web process does nothing. > I > was thinking we would do it in the RenderThemeGtk singleton function, so it > takes effect exactly once per process, before rendering anything. Then you > wouldn't have to remove the web process theme monitor. Is there a problem > with that? Yes, it doesn't work after setting the theme manually. > I'm OK with removing the web process theme monitor if this really needs to > move to the UI process, I just don't see why it does. > > > Source/WebKit/WebProcess/gtk/WebProcessMainGtk.cpp:58 > > + // Ignore the GTK_THEME environment variable, the theme is always set by the UI process now. > > + g_unsetenv("GTK_THEME"); > > You can't mutate the environment after XInitThreads(). It's not safe. > > Prior to this point, we have the g_usleep() -- which probably doesn't > initialize threads, but we don't know for sure that will never change -- and > the AuxiliaryProcessMainBase constructor, and libgcrypt initialization in > Source/WebKit/WebProcess/EntryPoint/unix/WebProcessMain.cpp. I would move > this to the top of WebProcessMain.cpp. Even if doing it at the top of this > constructor is totally safe -- I think it is, because our > platformInitialize() is currently called before InitializeWebKit2(), putting > it there would be dangerous because any of that could change in the future. > Mutating the environment is so exceptionally dangerous that it's just not > worth messing around with this. The top of main() in WebProcessMain.cpp is > always going to be safe, so definitely makes sense to do it there. I'll move it. > > Source/WebKit/WebProcess/gtk/WebProcessMainGtk.cpp:60 > > gtk_init(nullptr, nullptr); > > GTK actually uses a library constructor to unset environment variables, to > avoid crashes that could occur if it were to do so in gtk_init(). On > Windows, where library constructors aren't available, it risks crashing. I don't understand this. 1612350 23 cgarcia 2020-01-29 01:08:04 -0800 (In reply to Michael Catanzaro from comment #21) > (In reply to Michael Catanzaro from comment #20) > > Thanks Carlos, this was a huge help. I'll test it soon to verify it fixes > > older unpatched Evolution, and to check out its behavior in Cassidy's test > > cases. > > OK, it fixes the Evolution/Geary regression as expected. Great! \o/ > It also fixes Cassidy's third test in comment #3, dark style, which was > previously broken. > > It badly fails Cassidy's first two tests though (neither of which passed > before). They work fine here, I'm getting the same results than the screenshots (expect the WebKitGTK and Firefox on Linux, of course). > Test #1 (no style) is now worse than before because it now uses > black text (as desired) instead of light text (not desired) on a dark > background (not desired). Background shouldn't be dark, it's white here. > Test #2 (some style) is a little better than > before, but still pretty bad. We need to pass these tests to be > web-compatible. The problem is that you've now fixed the text color and all > the form controls, but the background color is still wrong because the web > process background is transparent, so the web content is displayed over the > UI process's dark background instead of the light web process background. > That is, everything is now perfect except for the background, and the > background is only wrong because it is still drawn using the UI process > theme! #if HAVE(OS_DARK_MODE_SUPPORT) -#if PLATFORM(COCOA) - static const auto cssValueControlBackground = CSSValueAppleSystemControlBackground; -#else - static const auto cssValueControlBackground = CSSValueWindow; -#endif - Color baseBackgroundColor = backgroundColor.valueOr(RenderTheme::singleton().systemColor(cssValueControlBackground, styleColorOptions())); + Color baseBackgroundColor = backgroundColor.valueOr(RenderTheme::singleton().systemColor(CSSValueAppleSystemControlBackground, styleColorOptions())); #else Color baseBackgroundColor = backgroundColor.valueOr(Color::white); #endif This reverts changes made in r244635, so now we always use white. Please, check OS_DARK_MODE_SUPPORT is not defined in your build. > I'm going to give r+ because your patch moves us far in the desired > direction. Everything except the background now works as desired, which is > much better than before. We'll probably get new bug reports from users once > this lands though, because dark mode users are going to see more dark text > on dark background than they did before this patch. So after this patch > lands, then a full, complete fix for all our dark mode problems would simply > require rendering a default web view background in the web process, instead > of allowing the UI process background color to peek through. So I plan to > close all existing dark mode bugs and open one new bug for the background. > Do you agree? And: is the background something you'd have time to work on? Yes, I can work on it if I can reproduce it. 1612355 24 cgarcia 2020-01-29 01:49:41 -0800 Committed r255342: <https://trac.webkit.org/changeset/255342> 1612426 25 mcatanzaro 2020-01-29 06:54:49 -0800 (In reply to Carlos Garcia Campos from comment #22) > > > Source/WebKit/WebProcess/gtk/WebProcessMainGtk.cpp:60 > > > gtk_init(nullptr, nullptr); > > > > GTK actually uses a library constructor to unset environment variables, to > > avoid crashes that could occur if it were to do so in gtk_init(). On > > Windows, where library constructors aren't available, it risks crashing. > > I don't understand this. It's simple! gtk_init() is a library call, so it has no way to guarantee that it will be called before the application creates a secondary thread. And you know that you cannot mutate the environment after threads are created, because setenv() and unsetenv() are "MT-Unsafe const:env" (meaning: cannot be used in multithreaded programs unless you guarantee no other threads ever use getenv(), which is wildly unrealistic and never possible for a library to guarantee). I'm sure you're well aware of that, because we discussed it many times in the past. :) So by using a library constructor, GTK guarantees it can call unsetenv() before application code ever runs. The only way this fails is if another library uses a library constructor that decides to initialize threads. 1612432 26 mcatanzaro 2020-01-29 07:23:05 -0800 It occurs to me that there is one thing Cassidy's examples don't check: the color-scheme CSS property (formerly supported-color-schemes). Now, we can't support that until the distant future arrives, once we have an HTML theme that doesn't depend on GTK. If that is set by the website, then we should draw form controls using the OS's dark theme. I think. Cassidy, any chance you have time to investigate this further, in a new bug report? It would be helpful to have a fourth test case that makes use of color-schemes and does not use prefers-color-scheme at all, and maybe a fifth that uses both. Does that make sense? (In reply to Carlos Garcia Campos from comment #23) > This reverts changes made in r244635, so now we always use white. Please, > check OS_DARK_MODE_SUPPORT is not defined in your build. I will check. It doesn't seem likely, but I don't know how else to explain hte difference in behavior we are seeing. 1612435 27 mcatanzaro 2020-01-29 07:34:19 -0800 (In reply to Michael Catanzaro from comment #26) > It occurs to me that there is one thing Cassidy's examples don't check: the > color-scheme CSS property (formerly supported-color-schemes). Now, we can't > support that until the distant future arrives, once we have an HTML theme > that doesn't depend on GTK. BTW, it's currently only implemented by Safari: https://caniuse.com/#search=color-scheme. Other browsers only have prefers-color-scheme. So it's not a big deal that it will be a long time before we can make it work. 1612562 28 mcatanzaro 2020-01-29 11:14:23 -0800 (In reply to Carlos Garcia Campos from comment #23) > #if HAVE(OS_DARK_MODE_SUPPORT) > -#if PLATFORM(COCOA) > - static const auto cssValueControlBackground = > CSSValueAppleSystemControlBackground; > -#else > - static const auto cssValueControlBackground = CSSValueWindow; > -#endif > - Color baseBackgroundColor = > backgroundColor.valueOr(RenderTheme::singleton(). > systemColor(cssValueControlBackground, styleColorOptions())); > + Color baseBackgroundColor = > backgroundColor.valueOr(RenderTheme::singleton(). > systemColor(CSSValueAppleSystemControlBackground, styleColorOptions())); > #else > Color baseBackgroundColor = backgroundColor.valueOr(Color::white); > #endif > > This reverts changes made in r244635, so now we always use white. Please, > check OS_DARK_MODE_SUPPORT is not defined in your build. Just to confirm, you are testing Cassidy's example https://cassidyjames.com/dark-demo/ with Adwaita Dark and you and you are seeing a white background on that page? Testing again with a clean build, it's definitely dark here. It doesn't make any sense why we would see different behavior in a basic test like this. And it doesn't matter whether my build defines OS_DARK_MODE_SUPPORT because after your change, that is only ever used in *.mm files. 1612595 29 mcatanzaro 2020-01-29 11:50:38 -0800 I decided not to report a new bug for the color-schemes property. We can deal with it later if desired, or not. (In reply to Michael Catanzaro from comment #28) > And it doesn't matter whether my build defines OS_DARK_MODE_SUPPORT because > after your change, that is only ever used in *.mm files. So I write, immediately after quoting a code example that uses it in FrameView.cpp. I'm hopeless. I was grepping under Source/WebKit instead of toplevel Source/. Whoops. I did a rebuild using #error to be 100% certain it's not somehow defined. It's not. Let's continue in bug #206953. 1612690 30 mcatanzaro 2020-01-29 14:37:44 -0800 (In reply to Michael Catanzaro from comment #29) > Let's continue in bug #206953. It was caused by Ephy calling webkit_web_view_set_background_color(). :) Seems we are done here. Carlos, you fixed a huge number of longstanding bugs all at once. Awesome! 1612703 31 mcatanzaro 2020-01-29 14:53:49 -0800 BTW, at the risk of leaving seven Bugzilla comments in a row, we should have retitled the bug before landing. We landed this as: [GTK] Should use light theme unless website declares support for dark themes in color-schemes property But, in fact, we do not support color-schemes at all. Oh well. 1776240 32 mcatanzaro 2021-07-11 17:04:43 -0700 (In reply to Michael Catanzaro from comment #29) > I decided not to report a new bug for the color-schemes property. We can > deal with it later if desired, or not. Bug #208204 389004 2020-01-28 08:41:32 -0800 2020-01-28 14:48:19 -0800 Patch wk2-dark-mode.diff text/plain 26868 cgarcia ZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCAxNjU3NDhmNTBmYS4uMjI3 Yjk4MjJkY2IgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwxNCBAQAorMjAyMC0wMS0yOCAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxp YS5jb20+CisKKyAgICAgICAgW0dUS10gU2hvdWxkIHVzZSBsaWdodCB0aGVtZSB1bmxlc3Mgd2Vi c2l0ZSBkZWNsYXJlcyBzdXBwb3J0IGZvciBkYXJrIHRoZW1lcyBpbiBjb2xvci1zY2hlbWVzIHBy b3BlcnR5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x OTc5NDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBE byBub3QgZGVmaW5lIEhBVkVfT1NfREFSS19NT0RFX1NVUFBPUlQuCisKKyAgICAgICAgKiBTb3Vy Y2UvY21ha2UvT3B0aW9uc0dUSy5jbWFrZToKKwogMjAyMC0wMS0yMiAgRG9uIE9sbXN0ZWFkICA8 ZG9uLm9sbXN0ZWFkQHNvbnkuY29tPgogCiAgICAgICAgIFtPcGVuU1NMXSBBZGQgc3R1YnMgYW5k IGJ1aWxkIGZvciBXZWIgQ3J5cHRvCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cg Yi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggZjZhNWM5N2VkMzUuLjc2YmM1Yzk4NTI3IDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMjAtMDEtMjggIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8 Y2dhcmNpYUBpZ2FsaWEuY29tPgorCisgICAgICAgIFtHVEtdIFNob3VsZCB1c2UgbGlnaHQgdGhl bWUgdW5sZXNzIHdlYnNpdGUgZGVjbGFyZXMgc3VwcG9ydCBmb3IgZGFyayB0aGVtZXMgaW4gY29s b3Itc2NoZW1lcyBwcm9wZXJ0eQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTk3OTQ3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgUmViYXNlbGluZSBzZXZlcmFsIHRlc3RzIGZvciB0aGUgbmV3IGJlaGF2aW9y LgorCisgICAgICAgICogcGxhdGZvcm0vZ3RrL2Nzcy1kYXJrLW1vZGUvY29sb3Itc2NoZW1lLXBy aW9yaXR5LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL2Nzcy1k YXJrLW1vZGUvZGVmYXVsdC1jb2xvcnMtZXhwZWN0ZWQudHh0OgorICAgICAgICAqIHBsYXRmb3Jt L2d0ay9jc3MtZGFyay1tb2RlL3ByZWZlcnMtY29sb3Itc2NoZW1lLWV4cGVjdGVkLnR4dDoKKwog MjAyMC0wMS0yNyAgTm9hbSBSb3NlbnRoYWwgIDxub2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAg LXdlYmtpdC1pbWFnZS1zZXQgc2hvdWxkIHN1cHBvcnQgcmVzb2x1dGlvbiB1bml0cyBvdGhlciB0 aGFuICd4JwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Nzcy1kYXJrLW1v ZGUvY29sb3Itc2NoZW1lLXByaW9yaXR5LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRm b3JtL2d0ay9jc3MtZGFyay1tb2RlL2NvbG9yLXNjaGVtZS1wcmlvcml0eS1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjQ4N2I5ZjIyNWMxCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Nzcy1kYXJrLW1vZGUvY29s b3Itc2NoZW1lLXByaW9yaXR5LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDUgQEAKKworUEFTUyBF bGVtZW50IGNvbG9ycyBhcmUgY29ycmVjdCBpbiBsaWdodCBjb2xvciBzY2hlbWUgd2l0aCBsaWdo dCBhbmQgZGFyayBjb2xvciBzY2hlbWUgCitQQVNTIERhcmsgY29sb3Igc2NoZW1lIGVuYWJsZWQg CitGQUlMIEVsZW1lbnQgY29sb3JzIGFyZSBjb3JyZWN0IGluIGRhcmsgY29sb3Igc2NoZW1lIHdp dGggbGlnaHQgYW5kIGRhcmsgY29sb3Igc2NoZW1lIGFzc2VydF9lcXVhbHM6IGV4cGVjdGVkICJy Z2IoMjU1LCAyNTUsIDI1NSkiIGJ1dCBnb3QgInJnYigwLCAwLCAwKSIKKwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Nzcy1kYXJrLW1vZGUvZGVmYXVsdC1jb2xvcnMtZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Nzcy1kYXJrLW1vZGUvZGVmYXVs dC1jb2xvcnMtZXhwZWN0ZWQudHh0CmluZGV4IDQ0ZjhiNGYzZDU4Li42M2FhNDE5MTk4MyAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL2Nzcy1kYXJrLW1vZGUvZGVmYXVsdC1j b2xvcnMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9jc3MtZGFy ay1tb2RlL2RlZmF1bHQtY29sb3JzLWV4cGVjdGVkLnR4dApAQCAtMiw5ICsyLDkgQEAKIFBBU1Mg Qm9keSB0ZXh0IGNvbG9yIGlzIGJsYWNrLCBzaW5jZSB0aGUgcGFnZSBpc24ndCBpbiBkYXJrIG1v ZGUgCiBQQVNTIFZpZXcgYmFzZSBiYWNrZ3JvdW5kIGNvbG9yIGlzIHdoaXRlLCBzaW5jZSB0aGUg cGFnZSBpc24ndCBpbiBkYXJrIG1vZGUgCiBQQVNTIFNldCBkYXJrIGFwcGVhcmFuY2UgCi1GQUlM IEJvZHkgdGV4dCBjb2xvciBpcyBibGFjaywgc2luY2UgdGhlIHBhZ2UgaGFzbid0IHNldCBhIHN1 cHBvcnRlZCBjb2xvciBzY2hlbWUgYXNzZXJ0X2VxdWFsczogZXhwZWN0ZWQgInJnYigwLCAwLCAw KSIgYnV0IGdvdCAicmdiKDI1NSwgMjU1LCAyNTUpIgorUEFTUyBCb2R5IHRleHQgY29sb3IgaXMg YmxhY2ssIHNpbmNlIHRoZSBwYWdlIGhhc24ndCBzZXQgYSBzdXBwb3J0ZWQgY29sb3Igc2NoZW1l IAogUEFTUyBWaWV3IGJhc2UgYmFja2dyb3VuZCBjb2xvciBpcyB3aGl0ZSwgc2luY2UgdGhlIHBh Z2UgaGFzbid0IHNldCBhIHN1cHBvcnRlZCBjb2xvciBzY2hlbWUgCiBQQVNTIFNldCBwcmVmZXJz LWNvbG9yLXNjaGVtZXM6IGxpZ2h0IGRhcmsgb24gdGhlIGJvZHkgCi1QQVNTIEJvZHkgdGV4dCBj b2xvciBpcyB3aGl0ZSAKLUZBSUwgVmlldyBiYXNlIGJhY2tncm91bmQgY29sb3IgaXMgYSBkYXJr IGdyZXkgYXNzZXJ0X2VxdWFsczogZXhwZWN0ZWQgInJnYigzMCwgMzAsIDMwKSIgYnV0IGdvdCAi cmdiKDUxLCA1NywgNTkpIgorRkFJTCBCb2R5IHRleHQgY29sb3IgaXMgd2hpdGUgYXNzZXJ0X2Vx dWFsczogZXhwZWN0ZWQgInJnYigyNTUsIDI1NSwgMjU1KSIgYnV0IGdvdCAicmdiKDAsIDAsIDAp IgorRkFJTCBWaWV3IGJhc2UgYmFja2dyb3VuZCBjb2xvciBpcyBhIGRhcmsgZ3JleSBhc3NlcnRf ZXF1YWxzOiBleHBlY3RlZCAicmdiKDMwLCAzMCwgMzApIiBidXQgZ290ICJyZ2IoMjU1LCAyNTUs IDI1NSkiCiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9jc3MtZGFyay1t b2RlL3ByZWZlcnMtY29sb3Itc2NoZW1lLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRm b3JtL2d0ay9jc3MtZGFyay1tb2RlL3ByZWZlcnMtY29sb3Itc2NoZW1lLWV4cGVjdGVkLnR4dApp bmRleCBhMjgyNTMzMjc3ZC4uMDJkMDBiZWVhOTUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3Bs YXRmb3JtL2d0ay9jc3MtZGFyay1tb2RlL3ByZWZlcnMtY29sb3Itc2NoZW1lLWV4cGVjdGVkLnR4 dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvY3NzLWRhcmstbW9kZS9wcmVmZXJzLWNv bG9yLXNjaGVtZS1leHBlY3RlZC50eHQKQEAgLTIsNiArMiw2IEBACiBQQVNTIEVsZW1lbnQgY29s b3JzIGFyZSBjb3JyZWN0IGluIGxpZ2h0IGNvbG9yIHNjaGVtZSAKIFBBU1MgRWxlbWVudCBjb2xv cnMgYXJlIGNvcnJlY3QgaW4gbGlnaHQgY29sb3Igc2NoZW1lIHdpdGggYm9vbGVhbiBjb250ZXh0 IHF1ZXJ5IAogUEFTUyBEYXJrIGNvbG9yIHNjaGVtZSBlbmFibGVkIAotRkFJTCBFbGVtZW50IGNv bG9ycyBhcmUgY29ycmVjdCBpbiBkYXJrIGNvbG9yIHNjaGVtZSBhc3NlcnRfZXF1YWxzOiBleHBl Y3RlZCAicmdiKDAsIDAsIDApIiBidXQgZ290ICJyZ2IoMjU1LCAyNTUsIDI1NSkiCi1GQUlMIEVs ZW1lbnQgY29sb3JzIGFyZSBjb3JyZWN0IGluIGRhcmsgY29sb3Igc2NoZW1lIHdpdGggYm9vbGVh biBjb250ZXh0IHF1ZXJ5IGFzc2VydF9lcXVhbHM6IGV4cGVjdGVkICJyZ2IoMCwgMCwgMCkiIGJ1 dCBnb3QgInJnYigyNTUsIDI1NSwgMjU1KSIKK1BBU1MgRWxlbWVudCBjb2xvcnMgYXJlIGNvcnJl Y3QgaW4gZGFyayBjb2xvciBzY2hlbWUgCitQQVNTIEVsZW1lbnQgY29sb3JzIGFyZSBjb3JyZWN0 IGluIGRhcmsgY29sb3Igc2NoZW1lIHdpdGggYm9vbGVhbiBjb250ZXh0IHF1ZXJ5IAogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4 IDk3ZmE0ZTIxZjk4Li4wMjFkNjkwZGU4MyAxMDA2NDQKLS0tIGEvU291cmNlL1dURi9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dURi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAyMC0wMS0y OCAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAgICAg W0dUS10gU2hvdWxkIHVzZSBsaWdodCB0aGVtZSB1bmxlc3Mgd2Vic2l0ZSBkZWNsYXJlcyBzdXBw b3J0IGZvciBkYXJrIHRoZW1lcyBpbiBjb2xvci1zY2hlbWVzIHByb3BlcnR5CisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xOTc5NDcKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEbyBub3QgZGVmaW5lIEhBVkVf T1NfREFSS19NT0RFX1NVUFBPUlQgZm9yIHRoZSBHVEsgcG9ydC4KKworICAgICAgICAqIHd0Zi9Q bGF0Zm9ybUhhdmUuaDoKKwogMjAyMC0wMS0yNyAgSm9uYXRoYW4gQmVkYXJkICA8amJlZGFyZEBh cHBsZS5jb20+CiAKICAgICAgICAgV2ViQ29yZTogUmVtb3ZlIGlPUyAxMSBtYWNyb3MgZnJvbSBS ZW5kZXJUaGVtZUlPUy5tbQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGxhdGZvcm1IYXZl LmggYi9Tb3VyY2UvV1RGL3d0Zi9QbGF0Zm9ybUhhdmUuaAppbmRleCA0MzQ0YTRkNjc2OC4uMGJk OWM4NjIzNzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtSGF2ZS5oCisrKyBi L1NvdXJjZS9XVEYvd3RmL1BsYXRmb3JtSGF2ZS5oCkBAIC0zNzMsNyArMzczLDcgQEAKICNkZWZp bmUgSEFWRV9OU0hUVFBDT09LSUVTVE9SQUdFX19JTklUV0lUSElERU5USUZJRVJfV0lUSF9JTkFD Q1VSQVRFX05VTExBQklMSVRZIDEKICNlbmRpZgogCi0jaWYgKFBMQVRGT1JNKE1BQykgJiYgX19N QUNfT1NfWF9WRVJTSU9OX01JTl9SRVFVSVJFRCA+PSAxMDE0MDApIHx8IFBMQVRGT1JNKElPUykg fHwgUExBVEZPUk0oTUFDQ0FUQUxZU1QpIHx8IFBMQVRGT1JNKEdUSykKKyNpZiAoUExBVEZPUk0o TUFDKSAmJiBfX01BQ19PU19YX1ZFUlNJT05fTUlOX1JFUVVJUkVEID49IDEwMTQwMCkgfHwgUExB VEZPUk0oSU9TKSB8fCBQTEFURk9STShNQUNDQVRBTFlTVCkKICNkZWZpbmUgSEFWRV9PU19EQVJL X01PREVfU1VQUE9SVCAxCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDg0ZjAxMzJmNWUxLi4xNjk4 MGYyYzNiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDIwLTAxLTI4ICBDYXJsb3Mg R2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBTaG91 bGQgdXNlIGxpZ2h0IHRoZW1lIHVubGVzcyB3ZWJzaXRlIGRlY2xhcmVzIHN1cHBvcnQgZm9yIGRh cmsgdGhlbWVzIGluIGNvbG9yLXNjaGVtZXMgcHJvcGVydHkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5Nzk0NworCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkRvY3VtZW50Ojp1c2VEYXJrQXBwZWFyYW5jZSBjb25zdCk6IFJlbW92ZSBIQVZF KE9TX0RBUktfTU9ERV9TVVBQT1JUKSBiZWNhdXNlIEVOQUJMRShEQVJLX01PREVfQ1NTKQorICAg ICAgICBndWFkcyBzaG91bGQgYmUgZW5vdWdoLgorICAgICAgICAqIHBhZ2UvRnJhbWVWaWV3LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lVmlldzo6dXBkYXRlQmFja2dyb3VuZFJlY3Vyc2l2 ZWx5KTogUmV2ZXJ0IGNoYW5nZXMgbWFkZSBpbiByMjQ0NjM1LgorICAgICAgICAqIHBhZ2UvUGFn ZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQYWdlOjplZmZlY3RpdmVBcHBlYXJhbmNlRGlkQ2hh bmdlKTogVXNlIEVOQUJMRShEQVJLX01PREVfQ1NTKSBpbnN0ZWFkIG9mIEhBVkUoT1NfREFSS19N T0RFX1NVUFBPUlQpLgorICAgICAgICAoV2ViQ29yZTo6UGFnZTo6dXNlRGFya0FwcGVhcmFuY2Ug Y29uc3QpOiBEaXR0by4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyVGhlbWVHdGsuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyVGhlbWVHdGs6OnN5c3RlbUNvbG9yIGNvbnN0KTogUmV2 ZXJ0IGNoYW5nZXMgbWFkZSBpbiByMjQ0NjM1LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJU aGVtZUd0ay5oOgorICAgICAgICAqIHRlc3RpbmcvSW50ZXJuYWxTZXR0aW5ncy5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpJbnRlcm5hbFNldHRpbmdzOjpzZXRVc2VEYXJrQXBwZWFyYW5jZUludGVy bmFsKTogUmV2ZXJ0IGNoYW5nZXMgbWFkZSBpbiByMjQ0NjM1LgorCiAyMDIwLTAxLTI3ICBOb2Ft IFJvc2VudGhhbCAgPG5vYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICAtd2Via2l0LWltYWdlLXNl dCBzaG91bGQgc3VwcG9ydCByZXNvbHV0aW9uIHVuaXRzIG90aGVyIHRoYW4gJ3gnCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcAppbmRleCBiNGRhMjRlYzhlYS4uYTc4YmNmN2E0YWEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcApAQCAtNzA4NCw3ICs3MDg0LDYgQEAgYm9vbCBEb2N1bWVudDo6dXNlU3lz dGVtQXBwZWFyYW5jZSgpIGNvbnN0CiAKIGJvb2wgRG9jdW1lbnQ6OnVzZURhcmtBcHBlYXJhbmNl KGNvbnN0IFJlbmRlclN0eWxlKiBzdHlsZSkgY29uc3QKIHsKLSNpZiBIQVZFKE9TX0RBUktfTU9E RV9TVVBQT1JUKQogI2lmIEVOQUJMRShEQVJLX01PREVfQ1NTKQogICAgIE9wdGlvblNldDxDb2xv clNjaGVtZT4gY29sb3JTY2hlbWU7CiAKQEAgLTcxMTMsOSArNzExMiw2IEBAIGJvb2wgRG9jdW1l bnQ6OnVzZURhcmtBcHBlYXJhbmNlKGNvbnN0IFJlbmRlclN0eWxlKiBzdHlsZSkgY29uc3QKICAg ICBpZiAoY29sb3JTY2hlbWUuY29udGFpbnMoQ29sb3JTY2hlbWU6OkRhcmspKQogICAgICAgICBy ZXR1cm4gcGFnZVVzZXNEYXJrQXBwZWFyYW5jZTsKICNlbmRpZgotI2Vsc2UKLSAgICBVTlVTRURf UEFSQU0oc3R5bGUpOwotI2VuZGlmCiAKICAgICByZXR1cm4gZmFsc2U7CiB9CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdl L0ZyYW1lVmlldy5jcHAKaW5kZXggN2NjYTlmNzJkYjMuLmEzYWI1OTI3NzM2IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGFnZS9GcmFtZVZpZXcuY3BwCkBAIC0zMDMxLDEyICszMDMxLDcgQEAgdm9pZCBGcmFtZVZpZXc6 OnNldEJhc2VCYWNrZ3JvdW5kQ29sb3IoY29uc3QgQ29sb3ImIGJhY2tncm91bmRDb2xvcikKIHZv aWQgRnJhbWVWaWV3Ojp1cGRhdGVCYWNrZ3JvdW5kUmVjdXJzaXZlbHkoY29uc3QgT3B0aW9uYWw8 Q29sb3I+JiBiYWNrZ3JvdW5kQ29sb3IpCiB7CiAjaWYgSEFWRShPU19EQVJLX01PREVfU1VQUE9S VCkKLSNpZiBQTEFURk9STShDT0NPQSkKLSAgICBzdGF0aWMgY29uc3QgYXV0byBjc3NWYWx1ZUNv bnRyb2xCYWNrZ3JvdW5kID0gQ1NTVmFsdWVBcHBsZVN5c3RlbUNvbnRyb2xCYWNrZ3JvdW5kOwot I2Vsc2UKLSAgICBzdGF0aWMgY29uc3QgYXV0byBjc3NWYWx1ZUNvbnRyb2xCYWNrZ3JvdW5kID0g Q1NTVmFsdWVXaW5kb3c7Ci0jZW5kaWYKLSAgICBDb2xvciBiYXNlQmFja2dyb3VuZENvbG9yID0g YmFja2dyb3VuZENvbG9yLnZhbHVlT3IoUmVuZGVyVGhlbWU6OnNpbmdsZXRvbigpLnN5c3RlbUNv bG9yKGNzc1ZhbHVlQ29udHJvbEJhY2tncm91bmQsIHN0eWxlQ29sb3JPcHRpb25zKCkpKTsKKyAg ICBDb2xvciBiYXNlQmFja2dyb3VuZENvbG9yID0gYmFja2dyb3VuZENvbG9yLnZhbHVlT3IoUmVu ZGVyVGhlbWU6OnNpbmdsZXRvbigpLnN5c3RlbUNvbG9yKENTU1ZhbHVlQXBwbGVTeXN0ZW1Db250 cm9sQmFja2dyb3VuZCwgc3R5bGVDb2xvck9wdGlvbnMoKSkpOwogI2Vsc2UKICAgICBDb2xvciBi YXNlQmFja2dyb3VuZENvbG9yID0gYmFja2dyb3VuZENvbG9yLnZhbHVlT3IoQ29sb3I6OndoaXRl KTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9QYWdlLmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvUGFnZS5jcHAKaW5kZXggMjNhY2NjMDZkZmUuLjBlM2Y3MjE5MTNh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BhZ2UuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvUGFnZS5jcHAKQEAgLTI3MjcsNyArMjcyNyw3IEBAIHZvaWQgUGFnZTo6c2V0 VXNlU3lzdGVtQXBwZWFyYW5jZShib29sIHZhbHVlKQogCiB2b2lkIFBhZ2U6OmVmZmVjdGl2ZUFw cGVhcmFuY2VEaWRDaGFuZ2UoYm9vbCB1c2VEYXJrQXBwZWFyYW5jZSwgYm9vbCB1c2VFbGV2YXRl ZFVzZXJJbnRlcmZhY2VMZXZlbCkKIHsKLSNpZiBIQVZFKE9TX0RBUktfTU9ERV9TVVBQT1JUKQor I2lmIEVOQUJMRShEQVJLX01PREVfQ1NTKQogICAgIGlmIChtX3VzZURhcmtBcHBlYXJhbmNlID09 IHVzZURhcmtBcHBlYXJhbmNlICYmIG1fdXNlRWxldmF0ZWRVc2VySW50ZXJmYWNlTGV2ZWwgPT0g dXNlRWxldmF0ZWRVc2VySW50ZXJmYWNlTGV2ZWwpCiAgICAgICAgIHJldHVybjsKIApAQCAtMjc1 MSw3ICsyNzUxLDcgQEAgdm9pZCBQYWdlOjplZmZlY3RpdmVBcHBlYXJhbmNlRGlkQ2hhbmdlKGJv b2wgdXNlRGFya0FwcGVhcmFuY2UsIGJvb2wgdXNlRWxldmF0ZWQKIAogYm9vbCBQYWdlOjp1c2VE YXJrQXBwZWFyYW5jZSgpIGNvbnN0CiB7Ci0jaWYgSEFWRShPU19EQVJLX01PREVfU1VQUE9SVCkK KyNpZiBFTkFCTEUoREFSS19NT0RFX0NTUykKICAgICBGcmFtZVZpZXcqIHZpZXcgPSBtYWluRnJh bWUoKS52aWV3KCk7CiAgICAgaWYgKCF2aWV3IHx8ICFlcXVhbExldHRlcnNJZ25vcmluZ0FTQ0lJ Q2FzZSh2aWV3LT5tZWRpYVR5cGUoKSwgInNjcmVlbiIpKQogICAgICAgICByZXR1cm4gZmFsc2U7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGhlbWVHdGsuY3Bw IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRoZW1lR3RrLmNwcAppbmRleCAwN2U3 YTMyMzdhNi4uMWFiYTM1YmNkOGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJUaGVtZUd0ay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl clRoZW1lR3RrLmNwcApAQCAtMTI0LDIyICsxMjQsNiBAQCBpbnQgUmVuZGVyVGhlbWVHdGs6OnNs aWRlclRpY2tPZmZzZXRGcm9tVHJhY2tDZW50ZXIoKSBjb25zdAogfQogI2VuZGlmCiAKLXN0YXRp YyB2b2lkIHRoZW1lQ2hhbmdlZENhbGxiYWNrKCkKLXsKLSAgICBQYWdlOjp1cGRhdGVTdHlsZUZv ckFsbFBhZ2VzQWZ0ZXJHbG9iYWxDaGFuZ2VJbkVudmlyb25tZW50KCk7Ci19Ci0KLVJlbmRlclRo ZW1lR3RrOjpSZW5kZXJUaGVtZUd0aygpCi17Ci0gICAgc3RhdGljIGJvb2wgdGhlbWVNb25pdG9y SW5pdGlhbGl6ZWQgPSBmYWxzZTsKLSAgICBpZiAoIXRoZW1lTW9uaXRvckluaXRpYWxpemVkKSB7 Ci0gICAgICAgIEd0a1NldHRpbmdzKiBzZXR0aW5ncyA9IGd0a19zZXR0aW5nc19nZXRfZGVmYXVs dCgpOwotICAgICAgICBnX3NpZ25hbF9jb25uZWN0KHNldHRpbmdzLCAibm90aWZ5OjpndGstdGhl bWUtbmFtZSIsIEdfQ0FMTEJBQ0sodGhlbWVDaGFuZ2VkQ2FsbGJhY2spLCBudWxscHRyKTsKLSAg ICAgICAgZ19zaWduYWxfY29ubmVjdChzZXR0aW5ncywgIm5vdGlmeTo6Z3RrLWNvbG9yLXNjaGVt ZSIsIEdfQ0FMTEJBQ0sodGhlbWVDaGFuZ2VkQ2FsbGJhY2spLCBudWxscHRyKTsKLSAgICAgICAg dGhlbWVNb25pdG9ySW5pdGlhbGl6ZWQgPSB0cnVlOwotICAgIH0KLX0KLQogZW51bSBSZW5kZXJU aGVtZVBhcnQgewogICAgIEVudHJ5LAogICAgIEVudHJ5U2VsZWN0aW9uLApAQCAtOTUxLDE3ICs5 MzUsNiBAQCBDb2xvciBSZW5kZXJUaGVtZUd0azo6c3lzdGVtQ29sb3IoQ1NTVmFsdWVJRCBjc3NW YWx1ZUlkLCBPcHRpb25TZXQ8U3R5bGVDb2xvcjo6TwogICAgICAgICByZXR1cm4gc3R5bGVDb2xv cihFbnRyeSwgR1RLX1NUQVRFX0ZMQUdfQUNUSVZFLCBTdHlsZUNvbG9yRm9yZWdyb3VuZCk7CiAg ICAgY2FzZSBDU1NWYWx1ZUdyYXl0ZXh0OgogICAgICAgICByZXR1cm4gc3R5bGVDb2xvcihFbnRy eSwgR1RLX1NUQVRFX0ZMQUdfSU5TRU5TSVRJVkUsIFN0eWxlQ29sb3JGb3JlZ3JvdW5kKTsKLSAg ICBjYXNlIENTU1ZhbHVlV2Via2l0Q29udHJvbEJhY2tncm91bmQ6Ci0gICAgICAgIHJldHVybiBz dHlsZUNvbG9yKEVudHJ5LCBHVEtfU1RBVEVfRkxBR19BQ1RJVkUsIFN0eWxlQ29sb3JCYWNrZ3Jv dW5kKTsKLSAgICBjYXNlIENTU1ZhbHVlV2luZG93OiB7Ci0gICAgICAgIC8vIE9ubHkgZ2V0IHdp bmRvdyBjb2xvciBmcm9tIHRoZSB0aGVtZSBpbiBkYXJrIG1vZGUuCi0gICAgICAgIGdib29sZWFu IHByZWZlckRhcmtUaGVtZSA9IEZBTFNFOwotICAgICAgICBpZiAoYXV0byogc2V0dGluZ3MgPSBn dGtfc2V0dGluZ3NfZ2V0X2RlZmF1bHQoKSkKLSAgICAgICAgICAgIGdfb2JqZWN0X2dldChzZXR0 aW5ncywgImd0ay1hcHBsaWNhdGlvbi1wcmVmZXItZGFyay10aGVtZSIsICZwcmVmZXJEYXJrVGhl bWUsIG51bGxwdHIpOwotICAgICAgICBpZiAocHJlZmVyRGFya1RoZW1lKQotICAgICAgICAgICAg cmV0dXJuIHN0eWxlQ29sb3IoV2luZG93LCBHVEtfU1RBVEVfRkxBR19BQ1RJVkUsIFN0eWxlQ29s b3JCYWNrZ3JvdW5kKTsKLSAgICAgICAgYnJlYWs7Ci0gICAgfQogICAgIGRlZmF1bHQ6CiAgICAg ICAgIGJyZWFrOwogICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJUaGVtZUd0ay5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRoZW1lR3Rr LmgKaW5kZXggOWY1YmYyNDZmZTIuLjg3YzNhYWQ1OGJhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyVGhlbWVHdGsuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyVGhlbWVHdGsuaApAQCAtMTA0LDcgKzEwNCw2IEBAIHB1YmxpYzoKICAgICBi b29sIHNob3VsZEhhdmVDYXBzTG9ja0luZGljYXRvcihjb25zdCBIVE1MSW5wdXRFbGVtZW50Jikg Y29uc3Qgb3ZlcnJpZGU7CiAKIHByaXZhdGU6Ci0gICAgUmVuZGVyVGhlbWVHdGsoKTsKICAgICB2 aXJ0dWFsIH5SZW5kZXJUaGVtZUd0aygpOwogCiAgICAgYm9vbCBwYWludENoZWNrYm94KGNvbnN0 IFJlbmRlck9iamVjdCYsIGNvbnN0IFBhaW50SW5mbyYsIGNvbnN0IEludFJlY3QmKSBvdmVycmlk ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Rlc3RpbmcvSW50ZXJuYWxTZXR0aW5ncy5j cHAgYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVybmFsU2V0dGluZ3MuY3BwCmluZGV4IGJi MDhmNWM2NWI1Li41MWU0NjRkYzA5MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvdGVzdGlu Zy9JbnRlcm5hbFNldHRpbmdzLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS90ZXN0aW5nL0ludGVy bmFsU2V0dGluZ3MuY3BwCkBAIC01MSwxMCArNTEsNiBAQAogI2luY2x1ZGUgIlNvdXBOZXR3b3Jr U2Vzc2lvbi5oIgogI2VuZGlmCiAKLSNpZiBQTEFURk9STShHVEspCi0jaW5jbHVkZSA8Z3RrL2d0 ay5oPgotI2VuZGlmCi0KIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogSW50ZXJuYWxTZXR0aW5nczo6 QmFja3VwOjpCYWNrdXAoU2V0dGluZ3MmIHNldHRpbmdzKQpAQCAtNTQ1LDE2ICs1NDEsNiBAQCBF eGNlcHRpb25Pcjxib29sPiBJbnRlcm5hbFNldHRpbmdzOjpzaG91bGREaXNwbGF5VHJhY2tLaW5k KGNvbnN0IFN0cmluZyYga2luZCkKIAogdm9pZCBJbnRlcm5hbFNldHRpbmdzOjpzZXRVc2VEYXJr QXBwZWFyYW5jZUludGVybmFsKGJvb2wgdXNlRGFya0FwcGVhcmFuY2UpCiB7Ci0jaWYgUExBVEZP Uk0oR1RLKQotICAgIC8vIEdUSyBkb2Vzbid0IGFsbG93IHRvIGNoYW5nZSB0aGUgdGhlbWUgZnJv bSB0aGUgd2ViIHByb2Nlc3MsIGJ1dCB0ZXN0cyBuZWVkIHRvIGRvIGl0LCBzbwotICAgIC8vIHdl IGRvIGl0IGhlcmUgb25seSBmb3IgdGVzdHMuCi0gICAgaWYgKGF1dG8qIHNldHRpbmdzID0gZ3Rr X3NldHRpbmdzX2dldF9kZWZhdWx0KCkpIHsKLSAgICAgICAgZ2Jvb2xlYW4gcHJlZmVyRGFya1Ro ZW1lOwotICAgICAgICBnX29iamVjdF9nZXQoc2V0dGluZ3MsICJndGstYXBwbGljYXRpb24tcHJl ZmVyLWRhcmstdGhlbWUiLCAmcHJlZmVyRGFya1RoZW1lLCBudWxscHRyKTsKLSAgICAgICAgaWYg KHByZWZlckRhcmtUaGVtZSAhPSB1c2VEYXJrQXBwZWFyYW5jZSkKLSAgICAgICAgICAgIGdfb2Jq ZWN0X3NldChzZXR0aW5ncywgImd0ay1hcHBsaWNhdGlvbi1wcmVmZXItZGFyay10aGVtZSIsIHVz ZURhcmtBcHBlYXJhbmNlLCBudWxscHRyKTsKLSAgICB9Ci0jZW5kaWYKICAgICBBU1NFUlQobV9w YWdlKTsKICAgICBtX3BhZ2UtPmVmZmVjdGl2ZUFwcGVhcmFuY2VEaWRDaGFuZ2UodXNlRGFya0Fw cGVhcmFuY2UsIG1fcGFnZS0+dXNlRWxldmF0ZWRVc2VySW50ZXJmYWNlTGV2ZWwoKSk7CiB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdl TG9nCmluZGV4IGZhN2Q5NmI0YjZjLi4wNzc5ZmEzY2YyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0 MCBAQAorMjAyMC0wMS0yOCAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5j b20+CisKKyAgICAgICAgW0dUS10gU2hvdWxkIHVzZSBsaWdodCB0aGVtZSB1bmxlc3Mgd2Vic2l0 ZSBkZWNsYXJlcyBzdXBwb3J0IGZvciBkYXJrIHRoZW1lcyBpbiBjb2xvci1zY2hlbWVzIHByb3Bl cnR5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xOTc5 NDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBIYW5k bGUgdGhlIHRoZW1lIGNoYW5nZXMgaW4gdGhlIFVJIHByb2Nlc3MsIGNvbnZlcnRpbmcgZGFyayB2 YXJpYW50IHRvIHRoZSBsaWdodCBvbmUgYmVmb3JlIHNlbmRpbmcgdGhlIHRoZW1lCisgICAgICAg IG5hbWUgdG8gdGhlIHdlYiBwcm9jZXNzLiBUaGUgd2ViIHByb2Nlc3MgaXMgc3RpbGwgbm90aWZp ZWQgd2hlbiBhIGRhcmsgdGhlbWUgaXMgaW4gdXNlLCBzbyB0aGF0IGlmIHdlYnNpdGUKKyAgICAg ICAgcHJlZmVycyBhIGRhcmsgY29sb3Igc2NoZW1lIGl0IHdpbGwgYmUgdXNlZCwgYnV0IHRoZSBn dGsgdGhlbWUgdGhhdCB3aWxsIGJlIHVzZWQgZm9yIGNvbnRyb2xzIHN0eWxpbmcgd2lsbAorICAg ICAgICBhbHdheXMgYmUgbGlnaHQuCisKKyAgICAgICAgKiBTaGFyZWQvV2ViUGFnZUNyZWF0aW9u UGFyYW1ldGVycy5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VDcmVhdGlvblBhcmFtZXRl cnM6OmVuY29kZSBjb25zdCk6IEVuY29kZSB0aGVtZU5hbWUuCisgICAgICAgIChXZWJLaXQ6Oldl YlBhZ2VDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZSk6IERlY29kZSB0aGVtZU5hbWUuCisgICAg ICAgICogU2hhcmVkL1dlYlBhZ2VDcmVhdGlvblBhcmFtZXRlcnMuaDoKKyAgICAgICAgKiBVSVBy b2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OlBhZ2VD bGllbnRJbXBsOjp0aGVtZU5hbWUgY29uc3QpOiBHZXQgdGhlIHRoZW1lIG5hbWUgdGhhdCBzaG91 bGQgYmUgdXNlZCBieSB0aGUgd2ViIHByb2Nlc3MuCisgICAgICAgICogVUlQcm9jZXNzL0FQSS9n dGsvUGFnZUNsaWVudEltcGwuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRX ZWJWaWV3QmFzZS5jcHA6CisgICAgICAgICh0aGVtZUNoYW5nZWQpOiBDYWxsIFdlYlBhZ2VQcm94 eTo6dGhlbWVEaWRDaGFuZ2UoKS4KKyAgICAgICAgKGFwcGxpY2F0aW9uUHJlZmVyRGFya1RoZW1l Q2hhbmdlZCk6CisgICAgICAgICh3ZWJraXRXZWJWaWV3QmFzZVNldFRvcGxldmVsT25TY3JlZW5X aW5kb3cpOiBVc2UgYSBkaWZmZXJlbnQgY2FsbGJhY2sgZm9yIHRoZSB0aGVtZSBuYW1lIGNoYW5n ZS4KKyAgICAgICAgKiBVSVByb2Nlc3MvUGFnZUNsaWVudC5oOgorICAgICAgICAqIFVJUHJvY2Vz cy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaDoK KyAgICAgICAgKiBVSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94eUd0ay5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlBhZ2VQcm94eTo6dGhlbWVEaWRDaGFuZ2UpOiBTZW5kIFRoZW1lRGlkQ2hhbmdl IG1lc3NhZ2UgdG8gdGhlIHdlYiBwcm9jZXNzIHdpdGggdGhlIHRoZW1lIG5hbWUgdG8gdXNlLgor ICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcDoKKyAgICAgICAgKFdlYktp dDo6V2ViUGFnZTo6V2ViUGFnZSk6IEluaXRpYWxpemUgdGhlIHRoZW1lIG5hbWUuCisgICAgICAg IChXZWJLaXQ6OldlYlBhZ2U6OmVmZmVjdGl2ZUFwcGVhcmFuY2VEaWRDaGFuZ2UpOiBVc2UgdGhp cyBub3cgZm9yIEdUSyBwb3J0IHRvby4KKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2Vi UGFnZS5oOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmlu OiBBZGQgVGhlbWVEaWRDaGFuZ2UgbWVzc2FnZS4KKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBh Z2UvZ3RrL1dlYlBhZ2VHdGsuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlOjp0aGVtZURp ZENoYW5nZSk6IFNldCB0aGUgdGhlbWUgZ2l2ZW4gbmFtZSBpbiBndGsgc2V0dGluZ3MuCisgICAg ICAgICogV2ViUHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc01haW5HdGsuY3BwOgorCiAyMDIwLTAxLTI4 ICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAgICAgICBb R1RLXVtXUEVdIFFSIGNvZGUgbm90IGxvYWRlZCBpbiB3ZWIud2hhdHNhcHAuY29tCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJQYWdlQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcCBi L1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlBhZ2VDcmVhdGlvblBhcmFtZXRlcnMuY3BwCmluZGV4 IDZiZmE5OWYyMTNmLi45MDg1OTk1ZDZmYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFy ZWQvV2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9TaGFy ZWQvV2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycy5jcHAKQEAgLTE0Miw2ICsxNDIsMTAgQEAgdm9p ZCBXZWJQYWdlQ3JlYXRpb25QYXJhbWV0ZXJzOjplbmNvZGUoSVBDOjpFbmNvZGVyJiBlbmNvZGVy KSBjb25zdAogICAgIGVuY29kZXIgPDwgc2hvdWxkQ2FwdHVyZVZpZGVvSW5VSVByb2Nlc3M7CiAg ICAgZW5jb2RlciA8PCBzaG91bGRDYXB0dXJlVmlkZW9JbkdQVVByb2Nlc3M7CiAgICAgZW5jb2Rl ciA8PCBzaG91bGRDYXB0dXJlRGlzcGxheUluVUlQcm9jZXNzOworCisjaWYgUExBVEZPUk0oR1RL KQorICAgIGVuY29kZXIgPDwgdGhlbWVOYW1lOworI2VuZGlmCiB9CiAKIE9wdGlvbmFsPFdlYlBh Z2VDcmVhdGlvblBhcmFtZXRlcnM+IFdlYlBhZ2VDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZShJ UEM6OkRlY29kZXImIGRlY29kZXIpCkBAIC00MzgsNiArNDQyLDExIEBAIE9wdGlvbmFsPFdlYlBh Z2VDcmVhdGlvblBhcmFtZXRlcnM+IFdlYlBhZ2VDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZShJ UEM6OkRlY29kCiAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXJhbWV0ZXJzLnNob3VsZENhcHR1 cmVEaXNwbGF5SW5VSVByb2Nlc3MpKQogICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OwogCisj aWYgUExBVEZPUk0oR1RLKQorICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy50aGVt ZU5hbWUpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworI2VuZGlmCisKICAgICByZXR1 cm4gcGFyYW1ldGVyczsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2Vi UGFnZUNyZWF0aW9uUGFyYW1ldGVycy5oIGIvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViUGFnZUNy ZWF0aW9uUGFyYW1ldGVycy5oCmluZGV4IGE4NTU1MTQ3MWFhLi5hYTA1NzE0ZTdhMyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycy5oCisr KyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlBhZ2VDcmVhdGlvblBhcmFtZXRlcnMuaApAQCAt MjEzLDYgKzIxMywxMCBAQCBzdHJ1Y3QgV2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycyB7CiAgICAg Ym9vbCBzaG91bGRDYXB0dXJlVmlkZW9JblVJUHJvY2VzcyB7IGZhbHNlIH07CiAgICAgYm9vbCBz aG91bGRDYXB0dXJlVmlkZW9JbkdQVVByb2Nlc3MgeyBmYWxzZSB9OwogICAgIGJvb2wgc2hvdWxk Q2FwdHVyZURpc3BsYXlJblVJUHJvY2VzcyB7IGZhbHNlIH07CisKKyNpZiBQTEFURk9STShHVEsp CisgICAgU3RyaW5nIHRoZW1lTmFtZTsKKyNlbmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi S2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGll bnRJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudElt cGwuY3BwCmluZGV4IGIxMjUyZGFmNzQyLi44YTZiZGE5NWE2MSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNl L1dlYktpdC9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5jcHAKQEAgLTU4Myw0ICs1 ODMsMjEgQEAgdm9pZCBQYWdlQ2xpZW50SW1wbDo6ZGlkQ2hhbmdlV2ViUGFnZUlEKCkgY29uc3QK ICAgICAgICAgd2Via2l0V2ViVmlld0RpZENoYW5nZVBhZ2VJRChXRUJLSVRfV0VCX1ZJRVcobV92 aWV3V2lkZ2V0KSk7CiB9CiAKK1N0cmluZyBQYWdlQ2xpZW50SW1wbDo6dGhlbWVOYW1lKCkgY29u c3QKK3sKKyAgICBpZiAoYXV0byogdGhlbWVOYW1lRW52ID0gZ19nZXRlbnYoIkdUS19USEVNRSIp KSB7CisgICAgICAgIFN0cmluZyBuYW1lID0gU3RyaW5nOjpmcm9tVVRGOCh0aGVtZU5hbWVFbnYp OworICAgICAgICBpZiAobmFtZS5lbmRzV2l0aCgiLWRhcmsiKSB8fCBuYW1lLmVuZHNXaXRoKCI6 ZGFyayIpKQorICAgICAgICAgICAgcmV0dXJuIG5hbWUuc3Vic3RyaW5nKDAsIG5hbWUubGVuZ3Ro KCkgLSA1KTsKKyAgICAgICAgcmV0dXJuIG5hbWU7CisgICAgfQorCisgICAgR1VuaXF1ZU91dFB0 cjxjaGFyPiB0aGVtZU5hbWVTZXR0aW5nOworICAgIGdfb2JqZWN0X2dldChndGtfd2lkZ2V0X2dl dF9zZXR0aW5ncyhtX3ZpZXdXaWRnZXQpLCAiZ3RrLXRoZW1lLW5hbWUiLCAmdGhlbWVOYW1lU2V0 dGluZy5vdXRQdHIoKSwgbnVsbHB0cik7CisgICAgU3RyaW5nIG5hbWUgPSBTdHJpbmc6OmZyb21V VEY4KHRoZW1lTmFtZVNldHRpbmcuZ2V0KCkpOworICAgIGlmIChuYW1lLmVuZHNXaXRoKCItZGFy ayIpKQorICAgICAgICByZXR1cm4gbmFtZS5zdWJzdHJpbmcoMCwgbmFtZS5sZW5ndGgoKSAtIDUp OworICAgIHJldHVybiBuYW1lOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaCBiL1Nv dXJjZS9XZWJLaXQvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaAppbmRleCBkN2M5 MDRhNTEyYS4uNWQwMzBlNjhmMjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNz L0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmgKQEAgLTE3NCw2ICsxNzQsOCBAQCBwcml2YXRlOgogCiAg ICAgdm9pZCBkaWRDaGFuZ2VXZWJQYWdlSUQoKSBjb25zdCBvdmVycmlkZTsKIAorICAgIFN0cmlu ZyB0aGVtZU5hbWUoKSBjb25zdCBvdmVycmlkZTsKKwogICAgIC8vIE1lbWJlcnMgb2YgUGFnZUNs aWVudEltcGwgY2xhc3MKICAgICBHdGtXaWRnZXQqIG1fdmlld1dpZGdldDsKICAgICBEZWZhdWx0 VW5kb0NvbnRyb2xsZXIgbV91bmRvQ29udHJvbGxlcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL0FQSS9ndGsvV2ViS2l0V2ViVmlld0Jhc2UuY3BwIGIvU291cmNlL1dlYktp dC9VSVByb2Nlc3MvQVBJL2d0ay9XZWJLaXRXZWJWaWV3QmFzZS5jcHAKaW5kZXggMGQ1OGJiMzY2 OWQuLmRjM2VmODVjNWFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9BUEkv Z3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9B UEkvZ3RrL1dlYktpdFdlYlZpZXdCYXNlLmNwcApAQCAtMjk0LDYgKzI5NCwxMSBAQCBzdGF0aWMg Z2Jvb2xlYW4gdG9wbGV2ZWxXaW5kb3dTdGF0ZUV2ZW50KEd0a1dpZGdldCosIEdka0V2ZW50V2lu ZG93U3RhdGUqIGV2ZW50LAogfQogCiBzdGF0aWMgdm9pZCB0aGVtZUNoYW5nZWQoV2ViS2l0V2Vi Vmlld0Jhc2UqIHdlYlZpZXdCYXNlKQoreworICAgIHdlYlZpZXdCYXNlLT5wcml2LT5wYWdlUHJv eHktPnRoZW1lRGlkQ2hhbmdlKCk7Cit9CisKK3N0YXRpYyB2b2lkIGFwcGxpY2F0aW9uUHJlZmVy RGFya1RoZW1lQ2hhbmdlZChXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmlld0Jhc2UpCiB7CiAgICAg d2ViVmlld0Jhc2UtPnByaXYtPnBhZ2VQcm94eS0+ZWZmZWN0aXZlQXBwZWFyYW5jZURpZENoYW5n ZSgpOwogfQpAQCAtMzc0LDcgKzM3OSw3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdFdlYlZpZXdCYXNl U2V0VG9wbGV2ZWxPblNjcmVlbldpbmRvdyhXZWJLaXRXZWJWaWV3QmFzZSogd2ViVmllCiAgICAg cHJpdi0+dGhlbWVDaGFuZ2VkSUQgPQogICAgICAgICBnX3NpZ25hbF9jb25uZWN0X3N3YXBwZWQo c2V0dGluZ3MsICJub3RpZnk6Omd0ay10aGVtZS1uYW1lIiwgR19DQUxMQkFDSyh0aGVtZUNoYW5n ZWQpLCB3ZWJWaWV3QmFzZSk7CiAgICAgcHJpdi0+YXBwbGljYXRpb25QcmVmZXJEYXJrVGhlbWVJ RCA9Ci0gICAgICAgIGdfc2lnbmFsX2Nvbm5lY3Rfc3dhcHBlZChzZXR0aW5ncywgIm5vdGlmeTo6 Z3RrLWFwcGxpY2F0aW9uLXByZWZlci1kYXJrLXRoZW1lIiwgR19DQUxMQkFDSyh0aGVtZUNoYW5n ZWQpLCB3ZWJWaWV3QmFzZSk7CisgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3Rfc3dhcHBlZChzZXR0 aW5ncywgIm5vdGlmeTo6Z3RrLWFwcGxpY2F0aW9uLXByZWZlci1kYXJrLXRoZW1lIiwgR19DQUxM QkFDSyhhcHBsaWNhdGlvblByZWZlckRhcmtUaGVtZUNoYW5nZWQpLCB3ZWJWaWV3QmFzZSk7CiAK ICAgICBpZiAoZ3RrX3dpZGdldF9nZXRfcmVhbGl6ZWQoR1RLX1dJREdFVCh3aW5kb3cpKSkKICAg ICAgICAgZ3RrX3dpZGdldF9yZWFsaXplKEdUS19XSURHRVQod2ViVmlld0Jhc2UpKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaCBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAppbmRleCA5Y2I3ODBmNDA3Zi4uZGMxMWEyMjUyN2Mg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1BhZ2VDbGllbnQuaAorKysgYi9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9QYWdlQ2xpZW50LmgKQEAgLTUxOCw2ICs1MTgsMTAgQEAg cHVibGljOgogI2VuZGlmCiAKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ2hhbmdlV2ViUGFnZUlEKCkg Y29uc3QgeyB9CisKKyNpZiBQTEFURk9STShHVEspCisgICAgdmlydHVhbCBTdHJpbmcgdGhlbWVO YW1lKCkgY29uc3QgPSAwOworI2VuZGlmCiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCmluZGV4IDA3NzYyYWMwN2ZmLi44 OTY0MmE0MTRlYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuY3BwCkBA IC03NjE4LDYgKzc2MTgsMTAgQEAgV2ViUGFnZUNyZWF0aW9uUGFyYW1ldGVycyBXZWJQYWdlUHJv eHk6OmNyZWF0aW9uUGFyYW1ldGVycyhXZWJQcm9jZXNzUHJveHkmIHByb2MKICAgICBwYXJhbWV0 ZXJzLnNob3VsZENhcHR1cmVWaWRlb0luR1BVUHJvY2VzcyA9IG1fcHJvY2Vzcy0+cHJvY2Vzc1Bv b2woKS5jb25maWd1cmF0aW9uKCkuc2hvdWxkQ2FwdHVyZVZpZGVvSW5HUFVQcm9jZXNzKCk7CiAg ICAgcGFyYW1ldGVycy5zaG91bGRDYXB0dXJlRGlzcGxheUluVUlQcm9jZXNzID0gbV9wcm9jZXNz LT5wcm9jZXNzUG9vbCgpLmNvbmZpZ3VyYXRpb24oKS5zaG91bGRDYXB0dXJlRGlzcGxheUluVUlQ cm9jZXNzKCk7CiAKKyNpZiBQTEFURk9STShHVEspCisgICAgcGFyYW1ldGVycy50aGVtZU5hbWUg PSBwYWdlQ2xpZW50KCkudGhlbWVOYW1lKCk7CisjZW5kaWYKKwogICAgIHJldHVybiBwYXJhbWV0 ZXJzOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQYWdlUHJv eHkuaCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCmluZGV4IDVkNGE3 MWQzMzA3Li4xMzU4Y2M4MjA3YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9VSVByb2Nlc3Mv V2ViUGFnZVByb3h5LmgKKysrIGIvU291cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUGFnZVByb3h5 LmgKQEAgLTg2OSw2ICs4NjksNyBAQCBwdWJsaWM6CiAjaWYgUExBVEZPUk0oR1RLKQogICAgIFBs YXRmb3JtVmlld1dpZGdldCB2aWV3V2lkZ2V0KCk7CiAgICAgYm9vbCBtYWtlR0xDb250ZXh0Q3Vy cmVudCgpOworICAgIHZvaWQgdGhlbWVEaWRDaGFuZ2UoKTsKICNlbmRpZgogCiAgICAgY29uc3Qg T3B0aW9uYWw8V2ViQ29yZTo6Q29sb3I+JiBiYWNrZ3JvdW5kQ29sb3IoKSBjb25zdCB7IHJldHVy biBtX2JhY2tncm91bmRDb2xvcjsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9VSVByb2Nl c3MvZ3RrL1dlYlBhZ2VQcm94eUd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9ndGsv V2ViUGFnZVByb3h5R3RrLmNwcAppbmRleCA4ZWU4NmZhMWJlYS4uZTk4YjA1MjM2MTcgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwCkBAIC0x ODQsNCArMTg0LDEzIEBAIHZvaWQgV2ViUGFnZVByb3h5OjpzZW5kTWVzc2FnZVRvV2ViVmlldyhV c2VyTWVzc2FnZSYmIG1lc3NhZ2UpCiAgICAgc2VuZE1lc3NhZ2VUb1dlYlZpZXdXaXRoUmVwbHko V1RGTW92ZShtZXNzYWdlKSwgW10oVXNlck1lc3NhZ2UmJikgeyB9KTsKIH0KIAordm9pZCBXZWJQ YWdlUHJveHk6OnRoZW1lRGlkQ2hhbmdlKCkKK3sKKyAgICBpZiAoIWhhc1J1bm5pbmdQcm9jZXNz KCkpCisgICAgICAgIHJldHVybjsKKworICAgIHNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6OlRoZW1l RGlkQ2hhbmdlKHBhZ2VDbGllbnQoKS50aGVtZU5hbWUoKSkpOworICAgIGVmZmVjdGl2ZUFwcGVh cmFuY2VEaWRDaGFuZ2UoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmNwcCBiL1NvdXJjZS9X ZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuY3BwCmluZGV4IGJkMzQxMDY4ZmI3Li5l NjUzNjFhNGUwYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2Uv V2ViUGFnZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFn ZS5jcHAKQEAgLTU5Myw2ICs1OTMsMTAgQEAgV2ViUGFnZTo6V2ViUGFnZShQYWdlSWRlbnRpZmll ciBwYWdlSUQsIFdlYlBhZ2VDcmVhdGlvblBhcmFtZXRlcnMmJiBwYXJhbWV0ZXJzKQogICAgIHNl dEdhcEJldHdlZW5QYWdlcyhwYXJhbWV0ZXJzLmdhcEJldHdlZW5QYWdlcyk7CiAgICAgc2V0UGFn aW5hdGlvbkxpbmVHcmlkRW5hYmxlZChwYXJhbWV0ZXJzLnBhZ2luYXRpb25MaW5lR3JpZEVuYWJs ZWQpOwogCisjaWYgUExBVEZPUk0oR1RLKQorICAgIHRoZW1lRGlkQ2hhbmdlKFdURk1vdmUocGFy YW1ldGVycy50aGVtZU5hbWUpKTsKKyNlbmRpZgorCiAgICAgZWZmZWN0aXZlQXBwZWFyYW5jZURp ZENoYW5nZShwYXJhbWV0ZXJzLnVzZURhcmtBcHBlYXJhbmNlLCBwYXJhbWV0ZXJzLnVzZUVsZXZh dGVkVXNlckludGVyZmFjZUxldmVsKTsKIAogICAgIGlmIChwYXJhbWV0ZXJzLmlzRWRpdGFibGUp CkBAIC00NzA5LDEyICs0NzEzLDEwIEBAIHZvaWQgV2ViUGFnZTo6c2V0VXNlU3lzdGVtQXBwZWFy YW5jZShib29sIHVzZVN5c3RlbUFwcGVhcmFuY2UpCiAKICNlbmRpZgogCi0jaWYgIVBMQVRGT1JN KEdUSykKIHZvaWQgV2ViUGFnZTo6ZWZmZWN0aXZlQXBwZWFyYW5jZURpZENoYW5nZShib29sIHVz ZURhcmtBcHBlYXJhbmNlLCBib29sIHVzZUVsZXZhdGVkVXNlckludGVyZmFjZUxldmVsKQogewog ICAgIGNvcmVQYWdlKCktPmVmZmVjdGl2ZUFwcGVhcmFuY2VEaWRDaGFuZ2UodXNlRGFya0FwcGVh cmFuY2UsIHVzZUVsZXZhdGVkVXNlckludGVyZmFjZUxldmVsKTsKIH0KLSNlbmRpZgogCiB2b2lk IFdlYlBhZ2U6OmZyZWV6ZUxheWVyVHJlZUR1ZVRvU3dpcGVBbmltYXRpb24oKQogewpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oIGIvU291cmNl L1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oCmluZGV4IGQ1NDAwODFmMWQzLi5h Mjc1Mzc2ZjkxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2Uv V2ViUGFnZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2Uu aApAQCAtNzk2LDYgKzc5Niw4IEBAIHB1YmxpYzoKICAgICB2b2lkIHNob3dFbW9qaVBpY2tlcihX ZWJDb3JlOjpGcmFtZSYpOwogCiAgICAgdm9pZCBnZXRDZW50ZXJGb3Jab29tR2VzdHVyZShjb25z dCBXZWJDb3JlOjpJbnRQb2ludCYgY2VudGVySW5WaWV3Q29vcmRpbmF0ZXMsIENvbXBsZXRpb25I YW5kbGVyPHZvaWQoV2ViQ29yZTo6SW50UG9pbnQmJik+JiYpOworCisgICAgdm9pZCB0aGVtZURp ZENoYW5nZShTdHJpbmcmJik7CiAjZW5kaWYKIAogICAgIHZvaWQgZGlkQXBwbHlTdHlsZSgpOwpA QCAtMjA0NCw2ICsyMDQ2LDEwIEBAIHByaXZhdGU6CiAjZW5kaWYKIAogICAgIFN0cmluZyBtX292 ZXJyaWRkZW5NZWRpYVR5cGU7CisKKyNpZiBQTEFURk9STShHVEspCisgICAgU3RyaW5nIG1fdGhl bWVOYW1lOworI2VuZGlmCiB9OwogCiAjaWYgIVBMQVRGT1JNKElPU19GQU1JTFkpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmlu IGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdlcy5pbgpp bmRleCBkNjFkZjgwM2IyMy4uZTlhZDYwZjYxMTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv V2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UubWVzc2FnZXMuaW4KKysrIGIvU291cmNlL1dlYktp dC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdlcy5pbgpAQCAtNTA2LDYgKzUwNiwx MCBAQCBHZW5lcmF0ZVN5bnRoZXRpY0VkaXRpbmdDb21tYW5kKGVudW06dWludDhfdCBXZWJLaXQ6 OlN5bnRoZXRpY0VkaXRpbmdDb21tYW5kVHlwZQogCiAgICAgRWZmZWN0aXZlQXBwZWFyYW5jZURp ZENoYW5nZShib29sIHVzZURhcmtBcHBlYXJhbmNlLCBib29sIHVzZUVsZXZhdGVkVXNlckludGVy ZmFjZUxldmVsKTsKIAorI2lmIFBMQVRGT1JNKEdUSykKKyAgICBUaGVtZURpZENoYW5nZShTdHJp bmcgdGhlbWVOYW1lKQorI2VuZGlmCisKICNpZiBQTEFURk9STShDT0NPQSkKICAgICBSZXF1ZXN0 QWN0aXZlTm93UGxheWluZ1Nlc3Npb25JbmZvKFdlYktpdDo6Q2FsbGJhY2tJRCBjYWxsYmFja0lE KQogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9n dGsvV2ViUGFnZUd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9ndGsv V2ViUGFnZUd0ay5jcHAKaW5kZXggODlkYzExYjg5M2YuLjhlODZlZDNiMTJhIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9ndGsvV2ViUGFnZUd0ay5jcHAKKysr IGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvZ3RrL1dlYlBhZ2VHdGsuY3BwCkBA IC0xNTcsMTEgKzE1NywxNCBAQCB2b2lkIFdlYlBhZ2U6OnNob3dFbW9qaVBpY2tlcihGcmFtZSYg ZnJhbWUpCiAgICAgc2VuZFdpdGhBc3luY1JlcGx5KE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OlNo b3dFbW9qaVBpY2tlcihmcmFtZS52aWV3KCktPmNvbnRlbnRzVG9Sb290VmlldyhmcmFtZS5zZWxl Y3Rpb24oKS5hYnNvbHV0ZUNhcmV0Qm91bmRzKCkpKSwgV1RGTW92ZShjb21wbGV0aW9uSGFuZGxl cikpOwogfQogCi12b2lkIFdlYlBhZ2U6OmVmZmVjdGl2ZUFwcGVhcmFuY2VEaWRDaGFuZ2UoYm9v bCB1c2VEYXJrQXBwZWFyYW5jZSwgYm9vbCB1c2VJbmFjdGl2ZUFwcGVhcmFuY2UpCit2b2lkIFdl YlBhZ2U6OnRoZW1lRGlkQ2hhbmdlKFN0cmluZyYmIHRoZW1lTmFtZSkKIHsKLSAgICBpZiAoYXV0 byogc2V0dGluZ3MgPSBndGtfc2V0dGluZ3NfZ2V0X2RlZmF1bHQoKSkKLSAgICAgICAgZ19vYmpl Y3Rfc2V0KHNldHRpbmdzLCAiZ3RrLWFwcGxpY2F0aW9uLXByZWZlci1kYXJrLXRoZW1lIiwgdXNl RGFya0FwcGVhcmFuY2UsIG51bGxwdHIpOwotICAgIGNvcmVQYWdlKCktPmVmZmVjdGl2ZUFwcGVh cmFuY2VEaWRDaGFuZ2UodXNlRGFya0FwcGVhcmFuY2UsIHVzZUluYWN0aXZlQXBwZWFyYW5jZSk7 CisgICAgaWYgKG1fdGhlbWVOYW1lID09IHRoZW1lTmFtZSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgbV90aGVtZU5hbWUgPSBXVEZNb3ZlKHRoZW1lTmFtZSk7CisgICAgZ19vYmplY3Rfc2V0KGd0 a19zZXR0aW5nc19nZXRfZGVmYXVsdCgpLCAiZ3RrLXRoZW1lLW5hbWUiLCBtX3RoZW1lTmFtZS51 dGY4KCkuZGF0YSgpLCBudWxscHRyKTsKKyAgICBQYWdlOjp1cGRhdGVTdHlsZUZvckFsbFBhZ2Vz QWZ0ZXJHbG9iYWxDaGFuZ2VJbkVudmlyb25tZW50KCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdl YktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL2d0ay9XZWJQcm9jZXNz TWFpbkd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvZ3RrL1dlYlByb2Nlc3NNYWlu R3RrLmNwcAppbmRleCA0NWY0ZDI5NjEwMS4uYWY2Njc5OTk1M2QgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvV2ViUHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc01haW5HdGsuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvV2ViUHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc01haW5HdGsuY3BwCkBAIC01Myw2ICs1 MywxMCBAQCBwdWJsaWM6CiAjaWYgKFVTRShDT09SRElOQVRFRF9HUkFQSElDUykgfHwgVVNFKEdT VFJFQU1FUl9HTCkpICYmIFBMQVRGT1JNKFgxMSkKICAgICAgICAgWEluaXRUaHJlYWRzKCk7CiAj ZW5kaWYKKworICAgICAgICAvLyBJZ25vcmUgdGhlIEdUS19USEVNRSBlbnZpcm9ubWVudCB2YXJp YWJsZSwgdGhlIHRoZW1lIGlzIGFsd2F5cyBzZXQgYnkgdGhlIFVJIHByb2Nlc3Mgbm93LgorICAg ICAgICBnX3Vuc2V0ZW52KCJHVEtfVEhFTUUiKTsKKwogICAgICAgICBndGtfaW5pdChudWxscHRy LCBudWxscHRyKTsKIAogICAgICAgICBiaW5kdGV4dGRvbWFpbihHRVRURVhUX1BBQ0tBR0UsIExP Q0FMRURJUik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvY21ha2UvT3B0aW9uc0dUSy5jbWFrZSBiL1Nv dXJjZS9jbWFrZS9PcHRpb25zR1RLLmNtYWtlCmluZGV4IDkwNGUzNzlhY2Q4Li5mMWZmY2FlM2Qw MiAxMDA2NDQKLS0tIGEvU291cmNlL2NtYWtlL09wdGlvbnNHVEsuY21ha2UKKysrIGIvU291cmNl L2NtYWtlL09wdGlvbnNHVEsuY21ha2UKQEAgLTIxMSw3ICsyMTEsNiBAQCBzZXQoR0RLX0xJQlJB UklFUyAke0dESzNfTElCUkFSSUVTfSkKIHNldChHREtfSU5DTFVERV9ESVJTICR7R0RLM19JTkNM VURFX0RJUlN9KQogCiBTRVRfQU5EX0VYUE9TRV9UT19CVUlMRChIQVZFX0dUS19VTklYX1BSSU5U SU5HICR7R1RLVW5peFByaW50X0ZPVU5EfSkKLVNFVF9BTkRfRVhQT1NFX1RPX0JVSUxEKEhBVkVf T1NfREFSS19NT0RFX1NVUFBPUlQgMSkKIAogaWYgKFVTRV9XUEVfUkVOREVSRVIpCiAgICAgZmlu ZF9wYWNrYWdlKFdQRSAxLjMuMCkK