Makes MaterialDesignController initialization explicit

chrome/browser/ui/libgtk2ui/gtk2_ui.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/libgtk2ui/gtk2_ui.h"
 
 #include <math.h>
 #include <pango/pango.h>
 #include <set>
 #include <utility>
@@ skipping 498 matching lines @@
   // We must build this after GTK gets initialized.
   gconf_listener_.reset(new GConfListener(this));
 #endif  // defined(USE_GCONF)
 
   indicators_count = 0;
 
   // Instantiate the singleton instance of Gtk2EventLoop.
   Gtk2EventLoop::GetInstance();
 }
 
+void Gtk2UI::UpdateWithLocalState() {
+  UpdateColors();
+}
+
 Gtk2UI::~Gtk2UI() {
   ClearAllThemeData();
 }
 
 gfx::Image Gtk2UI::GetThemeImageNamed(int id) const {
   // Try to get our cached version:
   ImageCache::const_iterator it = gtk_images_.find(id);
   if (it != gtk_images_.end())
     return it->second;
 
@@ skipping 365 matching lines @@
   colors_[ThemeProperties::COLOR_BOOKMARK_TEXT] = label_color;
 
   UpdateDefaultFont();
 
   // Build the various icon tints.
   GetNormalButtonTintHSL(&button_tint_);
   GetNormalEntryForegroundHSL(&entry_tint_);
   GetSelectedEntryForegroundHSL(&selected_entry_tint_);
   SkColor frame_color = BuildFrameColors();
 
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
-        color_utils::BlendTowardOppositeLuma(label_color, 50);
-  } else {
-    // The inactive frame color never occurs naturally in the theme, as it is a
-    // tinted version of |frame_color|. We generate another color based on the
-    // background tab color, with the lightness and saturation moved in the
-    // opposite direction. (We don't touch the hue, since there should be subtle
-    // hints of the color in the text.)
-    color_utils::HSL inactive_tab_text_hsl;
-    color_utils::SkColorToHSL(
-        theme->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground),
-        &inactive_tab_text_hsl);
-    inactive_tab_text_hsl.s = kInactiveLuminance;
-    inactive_tab_text_hsl.l = kInactiveSaturation;
+  // The inactive frame color never occurs naturally in the theme, as it is a
+  // tinted version of |frame_color|. We generate another color based on the
+  // background tab color, with the lightness and saturation moved in the
+  // opposite direction. (We don't touch the hue, since there should be subtle
+  // hints of the color in the text.)
+  color_utils::HSL inactive_tab_text_hsl;
+  color_utils::SkColorToHSL(
+      theme->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground),
+      &inactive_tab_text_hsl);
+  inactive_tab_text_hsl.s = kInactiveLuminance;
+  inactive_tab_text_hsl.l = kInactiveSaturation;
 
-    colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
-        color_utils::HSLToSkColor(inactive_tab_text_hsl, 255);
-  }
+  colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
+      color_utils::HSLToSkColor(inactive_tab_text_hsl, 255);
 
   // We pick the text and background colors for the NTP out of the colors for a
   // GtkEntry. We do this because GtkEntries background color is never the same
   // as |toolbar_color|, is usually a white, and when it isn't a white,
   // provides sufficient contrast to |toolbar_color|. Try this out with
   // Darklooks, HighContrastInverse or ThinIce.
 
   SkColor ntp_background =
       theme->GetSystemColor(
           ui::NativeTheme::kColorId_TextfieldDefaultBackground);
@@ skipping 40 matching lines @@
   inactive_selection_fg_color_ =
       theme->GetSystemColor(
           ui::NativeTheme::kColorId_TextfieldReadOnlyColor);
 
   colors_[ThemeProperties::COLOR_TAB_THROBBER_SPINNING] =
       theme->GetSystemColor(ui::NativeTheme::kColorId_ThrobberSpinningColor);
   colors_[ThemeProperties::COLOR_TAB_THROBBER_WAITING] =
       theme->GetSystemColor(ui::NativeTheme::kColorId_ThrobberWaitingColor);
 }
 
+void Gtk2UI::UpdateColors() {
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    NativeThemeGtk2* theme = NativeThemeGtk2::instance();
+    SkColor label_color =
+        theme->GetSystemColor(ui::NativeTheme::kColorId_LabelEnabledColor);
+    colors_[ThemeProperties::COLOR_BACKGROUND_TAB_TEXT] =
+        color_utils::BlendTowardOppositeLuma(label_color, 50);
+  }
+}
+
 SkColor Gtk2UI::BuildFrameColors() {
   NativeThemeGtk2* theme = NativeThemeGtk2::instance();
   SkColor frame_color =
       theme->GetSystemColor(ui::NativeTheme::kColorId_WindowBackground);
   SkColor temp_color;
 
 #if GTK_MAJOR_VERSION == 2
   color_utils::HSL kDefaultFrameShift = { -1, -1, 0.4 };
   GtkStyle* style = gtk_rc_get_style(theme->GetWindow());
 
@@ skipping 359 matching lines @@
   if (pango_font_description_get_style(desc) == PANGO_STYLE_ITALIC)
     query.style |= gfx::Font::ITALIC;
 
   default_font_render_params_ =
       gfx::GetFontRenderParams(query, &default_font_family_);
   default_font_style_ = query.style;
 }
 
 void Gtk2UI::ResetStyle() {
   ClearAllThemeData();
   LoadGtkValues();

[Evan Stade, 2016/04/01 23:24:18]

wouldn't you have to UpdateColors here to?

I'm not too fond of the name of UpdateColors (or UpdateWithLocalState).

In general, this approach seems fragile because it's incredibly subtle that in
some random parts of this file you can't call IsModeMaterial and some you can. I
don't know if this bug is worth trying to fix because on linux it's really easy
to pass a command line flag (which does work). I'd be in favor of just removing
the about:flags entry on Linux since it's broken.

[varkha, 2016/04/01 23:55:40]

Yes I would.
I didn't want to bring MD into the names and couldn't think of anything better.
UpdateWithLocalState -> CommandLineReady ? Not sure if I like it any better
though.
I think it is wrong to treat Linux any different as long as we support this
platform. Also it is currently just as fragile on Windows, we just haven't
broken it yet.
I think a better approach would be to land this and then refactor
MaterialDesignController to replace lazy initialization with explicit and assert
on any GetMode being called before the explicit init. Then we won't be breaking
it unknowingly.
I think LoadChromeResources or some place up the stack would be right to init
MD.

   NativeThemeGtk2::instance()->NotifyObservers();
 }
 
 void Gtk2UI::UpdateDeviceScaleFactor(float device_scale_factor) {
   device_scale_factor_ = device_scale_factor;
   UpdateDefaultFont();
 }
 
 float Gtk2UI::GetDeviceScaleFactor() const {
   if (gfx::Display::HasForceDeviceScaleFactor())
     return gfx::Display::GetForcedDeviceScaleFactor();
   const int kCSSDefaultDPI = 96;
   const float scale = GetDPI() / kCSSDefaultDPI;
 
   // Blacklist scaling factors <130% (crbug.com/484400) and round
   // to 1 decimal to prevent rendering problems (crbug.com/485183).
   return scale < 1.3f ? 1.0f : roundf(scale * 10) / 10;
 }
 
 }  // namespace libgtk2ui
 
 views::LinuxUI* BuildGtk2UI() {
   return new libgtk2ui::Gtk2UI;
 }