firefox-gtk3-20.patch

   1 diff -up firefox-48.0/widget/gtk/gtk3drawing.cpp.gtk3-20 firefox-48.0/widget/gtk/gtk3drawing.cpp
   2 --- firefox-48.0/widget/gtk/gtk3drawing.cpp.gtk3-20     2016-07-25 22:22:07.000000000 +0200
   3 +++ firefox-48.0/widget/gtk/gtk3drawing.cpp     2016-07-29 09:15:11.822285857 +0200
   4 @@ -18,15 +18,9 @@
   5
   6  #include <math.h>
   7
   8 -static GtkWidget* gProtoWindow;
   9  static GtkWidget* gProtoLayout;
  10 -static GtkWidget* gButtonWidget;
  11 -static GtkWidget* gToggleButtonWidget;
  12 -static GtkWidget* gButtonArrowWidget;
  13 -static GtkWidget* gSpinWidget;
  14  static GtkWidget* gHScaleWidget;
  15  static GtkWidget* gVScaleWidget;
  16 -static GtkWidget* gEntryWidget;
  17  static GtkWidget* gComboBoxWidget;
  18  static GtkWidget* gComboBoxButtonWidget;
  19  static GtkWidget* gComboBoxArrowWidget;
  20 @@ -35,30 +29,15 @@ static GtkWidget* gComboBoxEntryWidget;
  21  static GtkWidget* gComboBoxEntryTextareaWidget;
  22  static GtkWidget* gComboBoxEntryButtonWidget;
  23  static GtkWidget* gComboBoxEntryArrowWidget;
  24 -static GtkWidget* gHandleBoxWidget;
  25 -static GtkWidget* gToolbarWidget;
  26 -static GtkWidget* gFrameWidget;
  27 -static GtkWidget* gProgressWidget;
  28  static GtkWidget* gTabWidget;
  29 -static GtkWidget* gTextViewWidget;
  30 -static GtkWidget* gTooltipWidget;
  31 -static GtkWidget* gMenuBarWidget;
  32 -static GtkWidget* gMenuBarItemWidget;
  33 -static GtkWidget* gMenuPopupWidget;
  34 -static GtkWidget* gMenuItemWidget;
  35  static GtkWidget* gImageMenuItemWidget;
  36  static GtkWidget* gCheckMenuItemWidget;
  37  static GtkWidget* gTreeViewWidget;
  38  static GtkTreeViewColumn* gMiddleTreeViewColumn;
  39  static GtkWidget* gTreeHeaderCellWidget;
  40  static GtkWidget* gTreeHeaderSortArrowWidget;
  41 -static GtkWidget* gExpanderWidget;
  42 -static GtkWidget* gToolbarSeparatorWidget;
  43 -static GtkWidget* gMenuSeparatorWidget;
  44  static GtkWidget* gHPanedWidget;
  45  static GtkWidget* gVPanedWidget;
  46 -static GtkWidget* gScrolledWindowWidget;
  47 -static GtkWidget* gInfoBar;
  48
  49  static style_prop_t style_prop_func;
  50  static gboolean have_arrow_scaling;
  51 @@ -94,15 +73,6 @@ GetStateFlagsFromGtkWidgetState(GtkWidge
  52      return stateFlags;
  53  }
  54
  55 -/* Because we have such an unconventional way of drawing widgets, signal to the GTK theme engine
  56 -   that they are drawing for Mozilla instead of a conventional GTK app so they can do any specific
  57 -   things they may want to do. */
  58 -static void
  59 -moz_gtk_set_widget_name(GtkWidget* widget)
  60 -{
  61 -    gtk_widget_set_name(widget, "MozillaGtkWidget");
  62 -}
  63 -
  64  gint
  65  moz_gtk_enable_style_props(style_prop_t styleGetProp)
  66  {
  67 @@ -111,15 +81,6 @@ moz_gtk_enable_style_props(style_prop_t
  68  }
  69
  70  static gint
  71 -ensure_window_widget()
  72 -{
  73 -    if (!gProtoWindow) {
  74 -        gProtoWindow = GetWidget(MOZ_GTK_WINDOW);
  75 -    }
  76 -    return MOZ_GTK_SUCCESS;
  77 -}
  78 -
  79 -static gint
  80  setup_widget_prototype(GtkWidget* widget)
  81  {
  82      if (!gProtoLayout) {
  83 @@ -130,16 +91,6 @@ setup_widget_prototype(GtkWidget* widget
  84  }
  85
  86  static gint
  87 -ensure_button_widget()
  88 -{
  89 -    if (!gButtonWidget) {
  90 -        gButtonWidget = gtk_button_new_with_label("M");
  91 -        setup_widget_prototype(gButtonWidget);
  92 -    }
  93 -    return MOZ_GTK_SUCCESS;
  94 -}
  95 -
  96 -static gint
  97  ensure_hpaned_widget()
  98  {
  99      if (!gHPanedWidget) {
 100 @@ -160,40 +111,6 @@ ensure_vpaned_widget()
 101  }
 102
 103  static gint
 104 -ensure_toggle_button_widget()
 105 -{
 106 -    if (!gToggleButtonWidget) {
 107 -        gToggleButtonWidget = gtk_toggle_button_new();
 108 -        setup_widget_prototype(gToggleButtonWidget);
 109 -  }
 110 -  return MOZ_GTK_SUCCESS;
 111 -}
 112 -
 113 -static gint
 114 -ensure_button_arrow_widget()
 115 -{
 116 -    if (!gButtonArrowWidget) {
 117 -        ensure_toggle_button_widget();
 118 -
 119 -        gButtonArrowWidget = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 120 -        gtk_container_add(GTK_CONTAINER(gToggleButtonWidget), gButtonArrowWidget);
 121 -        gtk_widget_realize(gButtonArrowWidget);
 122 -        gtk_widget_show(gButtonArrowWidget);
 123 -    }
 124 -    return MOZ_GTK_SUCCESS;
 125 -}
 126 -
 127 -static gint
 128 -ensure_spin_widget()
 129 -{
 130 -  if (!gSpinWidget) {
 131 -    gSpinWidget = gtk_spin_button_new(NULL, 1, 0);
 132 -    setup_widget_prototype(gSpinWidget);
 133 -  }
 134 -  return MOZ_GTK_SUCCESS;
 135 -}
 136 -
 137 -static gint
 138  ensure_scale_widget()
 139  {
 140    if (!gHScaleWidget) {
 141 @@ -207,16 +124,6 @@ ensure_scale_widget()
 142    return MOZ_GTK_SUCCESS;
 143  }
 144
 145 -static gint
 146 -ensure_entry_widget()
 147 -{
 148 -    if (!gEntryWidget) {
 149 -        gEntryWidget = gtk_entry_new();
 150 -        setup_widget_prototype(gEntryWidget);
 151 -    }
 152 -    return MOZ_GTK_SUCCESS;
 153 -}
 154 -
 155  /* We need to have pointers to the inner widgets (button, separator, arrow)
 156   * of the ComboBox to get the correct rendering from theme engines which
 157   * special cases their look. Since the inner layout can change, we ask GTK
 158 @@ -225,7 +132,7 @@ ensure_entry_widget()
 159   * g_object_add_weak_pointer().
 160   * Note that if we don't find the inner widgets (which shouldn't happen), we
 161   * fallback to use generic "non-inner" widgets, and they don't need that kind
 162 - * of weak pointer since they are explicit children of gProtoWindow and as
 163 + * of weak pointer since they are explicit children of gProtoLayout and as
 164   * such GTK holds a strong reference to them. */
 165  static void
 166  moz_gtk_get_combo_box_inner_button(GtkWidget *widget, gpointer client_data)
 167 @@ -297,16 +204,14 @@ ensure_combo_box_widgets()
 168          /* Shouldn't be reached with current internal gtk implementation; we
 169           * use a generic toggle button as last resort fallback to avoid
 170           * crashing. */
 171 -        ensure_toggle_button_widget();
 172 -        gComboBoxButtonWidget = gToggleButtonWidget;
 173 +        gComboBoxButtonWidget = GetWidget(MOZ_GTK_TOGGLE_BUTTON);
 174      }
 175
 176      if (!gComboBoxArrowWidget) {
 177          /* Shouldn't be reached with current internal gtk implementation;
 178           * we gButtonArrowWidget as last resort fallback to avoid
 179           * crashing. */
 180 -        ensure_button_arrow_widget();
 181 -        gComboBoxArrowWidget = gButtonArrowWidget;
 182 +        gComboBoxArrowWidget = GetWidget(MOZ_GTK_BUTTON_ARROW);
 183      }
 184
 185      /* We don't test the validity of gComboBoxSeparatorWidget since there
 186 @@ -316,15 +221,6 @@ ensure_combo_box_widgets()
 187      return MOZ_GTK_SUCCESS;
 188  }
 189
 190 -static void
 191 -ensure_info_bar()
 192 -{
 193 -  if (!gInfoBar) {
 194 -      gInfoBar = gtk_info_bar_new();
 195 -      setup_widget_prototype(gInfoBar);
 196 -  }
 197 -}
 198 -
 199  /* We need to have pointers to the inner widgets (entry, button, arrow) of
 200   * the ComboBoxEntry to get the correct rendering from theme engines which
 201   * special cases their look. Since the inner layout can change, we ask GTK
 202 @@ -333,7 +229,7 @@ ensure_info_bar()
 203   * g_object_add_weak_pointer().
 204   * Note that if we don't find the inner widgets (which shouldn't happen), we
 205   * fallback to use generic "non-inner" widgets, and they don't need that kind
 206 - * of weak pointer since they are explicit children of gProtoWindow and as
 207 + * of weak pointer since they are explicit children of gProtoLayout and as
 208   * such GTK holds a strong reference to them. */
 209  static void
 210  moz_gtk_get_combo_box_entry_inner_widgets(GtkWidget *widget,
 211 @@ -385,8 +281,7 @@ ensure_combo_box_entry_widgets()
 212                           NULL);
 213
 214      if (!gComboBoxEntryTextareaWidget) {
 215 -        ensure_entry_widget();
 216 -        gComboBoxEntryTextareaWidget = gEntryWidget;
 217 +        gComboBoxEntryTextareaWidget = GetWidget(MOZ_GTK_ENTRY);
 218      }
 219
 220      if (gComboBoxEntryButtonWidget) {
 221 @@ -412,68 +307,19 @@ ensure_combo_box_entry_widgets()
 222          /* Shouldn't be reached with current internal gtk implementation;
 223           * we use a generic toggle button as last resort fallback to avoid
 224           * crashing. */
 225 -        ensure_toggle_button_widget();
 226 -        gComboBoxEntryButtonWidget = gToggleButtonWidget;
 227 +        gComboBoxEntryButtonWidget = GetWidget(MOZ_GTK_TOGGLE_BUTTON);
 228      }
 229
 230      if (!gComboBoxEntryArrowWidget) {
 231          /* Shouldn't be reached with current internal gtk implementation;
 232           * we gButtonArrowWidget as last resort fallback to avoid
 233           * crashing. */
 234 -        ensure_button_arrow_widget();
 235 -        gComboBoxEntryArrowWidget = gButtonArrowWidget;
 236 +        gComboBoxEntryArrowWidget = GetWidget(MOZ_GTK_BUTTON_ARROW);
 237      }
 238
 239      return MOZ_GTK_SUCCESS;
 240  }
 241
 242 -
 243 -static gint
 244 -ensure_handlebox_widget()
 245 -{
 246 -    if (!gHandleBoxWidget) {
 247 -        gHandleBoxWidget = gtk_handle_box_new();
 248 -        setup_widget_prototype(gHandleBoxWidget);
 249 -    }
 250 -    return MOZ_GTK_SUCCESS;
 251 -}
 252 -
 253 -static gint
 254 -ensure_toolbar_widget()
 255 -{
 256 -    if (!gToolbarWidget) {
 257 -        ensure_handlebox_widget();
 258 -        gToolbarWidget = gtk_toolbar_new();
 259 -        gtk_container_add(GTK_CONTAINER(gHandleBoxWidget), gToolbarWidget);
 260 -        gtk_widget_realize(gToolbarWidget);
 261 -    }
 262 -    return MOZ_GTK_SUCCESS;
 263 -}
 264 -
 265 -static gint
 266 -ensure_toolbar_separator_widget()
 267 -{
 268 -    if (!gToolbarSeparatorWidget) {
 269 -        ensure_toolbar_widget();
 270 -        gToolbarSeparatorWidget = GTK_WIDGET(gtk_separator_tool_item_new());
 271 -        setup_widget_prototype(gToolbarSeparatorWidget);
 272 -    }
 273 -    return MOZ_GTK_SUCCESS;
 274 -}
 275 -
 276 -static gint
 277 -ensure_tooltip_widget()
 278 -{
 279 -    if (!gTooltipWidget) {
 280 -        gTooltipWidget = gtk_window_new(GTK_WINDOW_POPUP);
 281 -        GtkStyleContext* style = gtk_widget_get_style_context(gTooltipWidget);
 282 -        gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLTIP);
 283 -        gtk_widget_realize(gTooltipWidget);
 284 -        moz_gtk_set_widget_name(gTooltipWidget);
 285 -    }
 286 -    return MOZ_GTK_SUCCESS;
 287 -}
 288 -
 289  static gint
 290  ensure_tab_widget()
 291  {
 292 @@ -485,81 +331,11 @@ ensure_tab_widget()
 293  }
 294
 295  static gint
 296 -ensure_progress_widget()
 297 -{
 298 -    if (!gProgressWidget) {
 299 -        gProgressWidget = gtk_progress_bar_new();
 300 -        setup_widget_prototype(gProgressWidget);
 301 -    }
 302 -    return MOZ_GTK_SUCCESS;
 303 -}
 304 -
 305 -static gint
 306 -ensure_frame_widget()
 307 -{
 308 -    if (!gFrameWidget) {
 309 -        gFrameWidget = gtk_frame_new(NULL);
 310 -        setup_widget_prototype(gFrameWidget);
 311 -    }
 312 -    return MOZ_GTK_SUCCESS;
 313 -}
 314 -
 315 -static gint
 316 -ensure_menu_bar_widget()
 317 -{
 318 -    if (!gMenuBarWidget) {
 319 -        gMenuBarWidget = gtk_menu_bar_new();
 320 -        setup_widget_prototype(gMenuBarWidget);
 321 -    }
 322 -    return MOZ_GTK_SUCCESS;
 323 -}
 324 -
 325 -static gint
 326 -ensure_menu_bar_item_widget()
 327 -{
 328 -    if (!gMenuBarItemWidget) {
 329 -        ensure_menu_bar_widget();
 330 -        gMenuBarItemWidget = gtk_menu_item_new();
 331 -        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuBarWidget),
 332 -                              gMenuBarItemWidget);
 333 -        gtk_widget_realize(gMenuBarItemWidget);
 334 -    }
 335 -    return MOZ_GTK_SUCCESS;
 336 -}
 337 -
 338 -static gint
 339 -ensure_menu_popup_widget()
 340 -{
 341 -    if (!gMenuPopupWidget) {
 342 -        ensure_window_widget();
 343 -        gMenuPopupWidget = gtk_menu_new();
 344 -        gtk_menu_attach_to_widget(GTK_MENU(gMenuPopupWidget), gProtoWindow,
 345 -                                  NULL);
 346 -        gtk_widget_realize(gMenuPopupWidget);
 347 -    }
 348 -    return MOZ_GTK_SUCCESS;
 349 -}
 350 -
 351 -static gint
 352 -ensure_menu_item_widget()
 353 -{
 354 -    if (!gMenuItemWidget) {
 355 -        ensure_menu_popup_widget();
 356 -        gMenuItemWidget = gtk_menu_item_new_with_label("M");
 357 -        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
 358 -                              gMenuItemWidget);
 359 -        gtk_widget_realize(gMenuItemWidget);
 360 -    }
 361 -    return MOZ_GTK_SUCCESS;
 362 -}
 363 -
 364 -static gint
 365  ensure_image_menu_item_widget()
 366  {
 367      if (!gImageMenuItemWidget) {
 368 -        ensure_menu_popup_widget();
 369          gImageMenuItemWidget = gtk_image_menu_item_new();
 370 -        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
 371 +        gtk_menu_shell_append(GTK_MENU_SHELL(GetWidget(MOZ_GTK_MENUPOPUP)),
 372                                gImageMenuItemWidget);
 373          gtk_widget_realize(gImageMenuItemWidget);
 374      }
 375 @@ -567,25 +343,11 @@ ensure_image_menu_item_widget()
 376  }
 377
 378  static gint
 379 -ensure_menu_separator_widget()
 380 -{
 381 -    if (!gMenuSeparatorWidget) {
 382 -        ensure_menu_popup_widget();
 383 -        gMenuSeparatorWidget = gtk_separator_menu_item_new();
 384 -        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
 385 -                              gMenuSeparatorWidget);
 386 -        gtk_widget_realize(gMenuSeparatorWidget);
 387 -    }
 388 -    return MOZ_GTK_SUCCESS;
 389 -}
 390 -
 391 -static gint
 392  ensure_check_menu_item_widget()
 393  {
 394      if (!gCheckMenuItemWidget) {
 395 -        ensure_menu_popup_widget();
 396 -        gCheckMenuItemWidget = gtk_check_menu_item_new_with_label("M");
 397 -        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
 398 +        gCheckMenuItemWidget = gtk_check_menu_item_new();
 399 +        gtk_menu_shell_append(GTK_MENU_SHELL(GetWidget(MOZ_GTK_MENUPOPUP)),
 400                                gCheckMenuItemWidget);
 401          gtk_widget_realize(gCheckMenuItemWidget);
 402      }
 403 @@ -646,37 +408,6 @@ ensure_tree_header_cell_widget()
 404      return MOZ_GTK_SUCCESS;
 405  }
 406
 407 -static gint
 408 -ensure_expander_widget()
 409 -{
 410 -    if (!gExpanderWidget) {
 411 -        gExpanderWidget = gtk_expander_new("M");
 412 -        setup_widget_prototype(gExpanderWidget);
 413 -    }
 414 -    return MOZ_GTK_SUCCESS;
 415 -}
 416 -
 417 -static gint
 418 -ensure_scrolled_window_widget()
 419 -{
 420 -    if (!gScrolledWindowWidget) {
 421 -        gScrolledWindowWidget = gtk_scrolled_window_new(NULL, NULL);
 422 -        setup_widget_prototype(gScrolledWindowWidget);
 423 -    }
 424 -    return MOZ_GTK_SUCCESS;
 425 -}
 426 -
 427 -static void
 428 -ensure_text_view_widget()
 429 -{
 430 -    if (gTextViewWidget)
 431 -        return;
 432 -
 433 -    gTextViewWidget = gtk_text_view_new();
 434 -    ensure_scrolled_window_widget();
 435 -    gtk_container_add(GTK_CONTAINER(gScrolledWindowWidget), gTextViewWidget);
 436 -}
 437 -
 438  gint
 439  moz_gtk_init()
 440  {
 441 @@ -729,26 +460,21 @@ moz_gtk_get_focus_outline_size(gint* foc
 442  {
 443      GtkBorder border;
 444      GtkBorder padding;
 445 -    GtkStyleContext *style;
 446 -
 447 -    ensure_entry_widget();
 448 -    style = gtk_widget_get_style_context(gEntryWidget);
 449 -
 450 +    GtkStyleContext *style = ClaimStyleContext(MOZ_GTK_ENTRY);
 451      gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
 452      gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
 453      *focus_h_width = border.left + padding.left;
 454      *focus_v_width = border.top + padding.top;
 455 +    ReleaseStyleContext(style);
 456      return MOZ_GTK_SUCCESS;
 457  }
 458
 459  gint
 460  moz_gtk_menuitem_get_horizontal_padding(gint* horizontal_padding)
 461  {
 462 -    ensure_menu_item_widget();
 463 -
 464 -    gtk_style_context_get_style(gtk_widget_get_style_context(gMenuItemWidget),
 465 -                                "horizontal-padding", horizontal_padding,
 466 -                                NULL);
 467 +    gtk_widget_style_get(GetWidget(MOZ_GTK_MENUITEM),
 468 +                         "horizontal-padding", horizontal_padding,
 469 +                         nullptr);
 470
 471      return MOZ_GTK_SUCCESS;
 472  }
 473 @@ -771,10 +497,11 @@ moz_gtk_button_get_default_overflow(gint
 474  {
 475      GtkBorder* default_outside_border;
 476
 477 -    ensure_button_widget();
 478 -    gtk_style_context_get_style(gtk_widget_get_style_context(gButtonWidget),
 479 +    GtkStyleContext *style = ClaimStyleContext(MOZ_GTK_BUTTON);
 480 +    gtk_style_context_get_style(style,
 481                                  "default-outside-border", &default_outside_border,
 482                                  NULL);
 483 +    ReleaseStyleContext(style);
 484
 485      if (default_outside_border) {
 486          *border_top = default_outside_border->top;
 487 @@ -794,10 +521,11 @@ moz_gtk_button_get_default_border(gint*
 488  {
 489      GtkBorder* default_border;
 490
 491 -    ensure_button_widget();
 492 -    gtk_style_context_get_style(gtk_widget_get_style_context(gButtonWidget),
 493 +    GtkStyleContext *style = ClaimStyleContext(MOZ_GTK_BUTTON);
 494 +    gtk_style_context_get_style(style,
 495                                  "default-border", &default_border,
 496                                  NULL);
 497 +    ReleaseStyleContext(style);
 498
 499      if (default_border) {
 500          *border_top = default_border->top;
 501 @@ -831,17 +559,15 @@ static gint
 502  moz_gtk_window_paint(cairo_t *cr, GdkRectangle* rect,
 503                       GtkTextDirection direction)
 504  {
 505 -    GtkStyleContext* style;
 506 -
 507 -    ensure_window_widget();
 508 -    gtk_widget_set_direction(gProtoWindow, direction);
 509 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_WINDOW, direction);
 510
 511 -    style = gtk_widget_get_style_context(gProtoWindow);
 512      gtk_style_context_save(style);
 513      gtk_style_context_add_class(style, GTK_STYLE_CLASS_BACKGROUND);
 514      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 515      gtk_style_context_restore(style);
 516
 517 +    ReleaseStyleContext(style);
 518 +
 519      return MOZ_GTK_SUCCESS;
 520  }
 521
 522 @@ -1118,6 +844,36 @@ moz_gtk_scrollbar_button_paint(cairo_t *
 523      return MOZ_GTK_SUCCESS;
 524  }
 525
 526 +static void
 527 +moz_gtk_update_scrollbar_style(GtkStyleContext* style,
 528 +                               WidgetNodeType widget,
 529 +                               GtkTextDirection direction)
 530 +{
 531 +    if (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) {
 532 +        gtk_style_context_add_class(style, GTK_STYLE_CLASS_BOTTOM);
 533 +    } else {
 534 +        if (direction == GTK_TEXT_DIR_LTR) {
 535 +            gtk_style_context_add_class(style, GTK_STYLE_CLASS_RIGHT);
 536 +            gtk_style_context_remove_class(style, GTK_STYLE_CLASS_LEFT);
 537 +        } else {
 538 +            gtk_style_context_add_class(style, GTK_STYLE_CLASS_LEFT);
 539 +            gtk_style_context_remove_class(style, GTK_STYLE_CLASS_RIGHT);
 540 +        }
 541 +    }
 542 +}
 543 +
 544 +static void
 545 +moz_gtk_draw_styled_frame(GtkStyleContext* style, cairo_t *cr,
 546 +                          GdkRectangle* rect, bool drawFocus)
 547 +{
 548 +    gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 549 +    gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 550 +    if (drawFocus) {
 551 +        gtk_render_focus(style, cr,
 552 +                         rect->x, rect->y, rect->width, rect->height);
 553 +    }
 554 +}
 555 +
 556  static gint
 557  moz_gtk_scrollbar_trough_paint(WidgetNodeType widget,
 558                                 cairo_t *cr, GdkRectangle* rect,
 559 @@ -1126,26 +882,34 @@ moz_gtk_scrollbar_trough_paint(WidgetNod
 560                                 GtkTextDirection direction)
 561  {
 562      if (flags & MOZ_GTK_TRACK_OPAQUE) {
 563 -        GtkStyleContext* style =
 564 -            gtk_widget_get_style_context(GTK_WIDGET(gProtoWindow));
 565 -        gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 566 +        GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_WINDOW, direction);
 567 +        gtk_render_background(style, cr,
 568 +                              rect->x, rect->y, rect->width, rect->height);
 569 +        ReleaseStyleContext(style);
 570      }
 571
 572 -    GtkStyleContext* style =
 573 -        ClaimStyleContext(widget == MOZ_GTK_SCROLLBAR_HORIZONTAL ?
 574 -                          MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL :
 575 -                          MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL,
 576 -                          direction);
 577 -    // TODO - integate with ClaimStyleContext()?
 578 -    gtk_style_context_set_direction(style, direction);
 579 +    bool isHorizontal = (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL);
 580 +    GtkStyleContext* style;
 581
 582 -    gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 583 -    gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 584 +    // Draw all child CSS Nodes for Gtk >= 3.20
 585 +    if (gtk_check_version(3, 20, 0) == nullptr) {
 586 +        style = ClaimStyleContext(widget, direction);
 587 +        moz_gtk_update_scrollbar_style(style, widget, direction);
 588 +        moz_gtk_draw_styled_frame(style, cr, rect, state->focused);
 589 +        ReleaseStyleContext(style);
 590
 591 -    if (state->focused) {
 592 -        gtk_render_focus(style, cr,
 593 -                         rect->x, rect->y, rect->width, rect->height);
 594 +        style = ClaimStyleContext(isHorizontal ?
 595 +                                  MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL :
 596 +                                  MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL,
 597 +                                  direction);
 598 +        moz_gtk_draw_styled_frame(style, cr, rect, state->focused);
 599 +        ReleaseStyleContext(style);
 600      }
 601 +    style = ClaimStyleContext(isHorizontal ?
 602 +                              MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL :
 603 +                              MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL,
 604 +                              direction);
 605 +    moz_gtk_draw_styled_frame(style, cr, rect, state->focused);
 606      ReleaseStyleContext(style);
 607
 608      return MOZ_GTK_SUCCESS;
 609 @@ -1160,12 +924,7 @@ moz_gtk_scrollbar_thumb_paint(WidgetNode
 610      GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
 611      GtkBorder margin;
 612
 613 -    GtkStyleContext* style = ClaimStyleContext(widget, direction);
 614 -
 615 -    // TODO - integate those with ClaimStyleContext()?
 616 -    gtk_style_context_set_state(style, state_flags);
 617 -    gtk_style_context_set_direction(style, direction);
 618 -
 619 +    GtkStyleContext* style = ClaimStyleContext(widget, direction, state_flags);
 620      gtk_style_context_get_margin (style, state_flags, &margin);
 621
 622      gtk_render_slider(style, cr,
 623 @@ -1185,17 +944,10 @@ static gint
 624  moz_gtk_spin_paint(cairo_t *cr, GdkRectangle* rect,
 625                     GtkTextDirection direction)
 626  {
 627 -    GtkStyleContext* style;
 628 -
 629 -    ensure_spin_widget();
 630 -    gtk_widget_set_direction(gSpinWidget, direction);
 631 -    style = gtk_widget_get_style_context(gSpinWidget);
 632 -    gtk_style_context_save(style);
 633 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_SPINBUTTON);
 634 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_SPINBUTTON, direction);
 635      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 636      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 637 -    gtk_style_context_restore(style);
 638 -
 639 +    ReleaseStyleContext(style);
 640      return MOZ_GTK_SUCCESS;
 641  }
 642
 643 @@ -1204,21 +956,14 @@ moz_gtk_spin_updown_paint(cairo_t *cr, G
 644                            gboolean isDown, GtkWidgetState* state,
 645                            GtkTextDirection direction)
 646  {
 647 -    GdkRectangle arrow_rect;
 648 -    GtkStyleContext* style;
 649 -
 650 -    ensure_spin_widget();
 651 -    style = gtk_widget_get_style_context(gSpinWidget);
 652 -    gtk_style_context_save(style);
 653 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_SPINBUTTON);
 654 -    gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
 655 -    gtk_widget_set_direction(gSpinWidget, direction);
 656 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_SPINBUTTON, direction,
 657 +                                 GetStateFlagsFromGtkWidgetState(state));
 658
 659      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 660      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 661
 662 -
 663      /* hard code these values */
 664 +    GdkRectangle arrow_rect;
 665      arrow_rect.width = 6;
 666      arrow_rect.height = 6;
 667      arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
 668 @@ -1229,7 +974,8 @@ moz_gtk_spin_updown_paint(cairo_t *cr, G
 669                      isDown ? ARROW_DOWN : ARROW_UP,
 670                      arrow_rect.x, arrow_rect.y,
 671                      arrow_rect.width);
 672 -    gtk_style_context_restore(style);
 673 +
 674 +    ReleaseStyleContext(style);
 675      return MOZ_GTK_SUCCESS;
 676  }
 677
 678 @@ -1295,8 +1041,8 @@ moz_gtk_scale_thumb_paint(cairo_t *cr, G
 679    gtk_widget_set_direction(widget, direction);
 680
 681    style = gtk_widget_get_style_context(widget);
 682 -  gtk_style_context_add_class(style, GTK_STYLE_CLASS_SLIDER);
 683    gtk_style_context_save(style);
 684 +  gtk_style_context_add_class(style, GTK_STYLE_CLASS_SLIDER);
 685    gtk_style_context_set_state(style, state_flags);
 686    /* determine the thumb size, and position the thumb in the center in the opposite axis
 687    */
 688 @@ -1321,20 +1067,12 @@ moz_gtk_gripper_paint(cairo_t *cr, GdkRe
 689                        GtkWidgetState* state,
 690                        GtkTextDirection direction)
 691  {
 692 -    GtkStyleContext* style;
 693 -
 694 -    ensure_handlebox_widget();
 695 -    gtk_widget_set_direction(gHandleBoxWidget, direction);
 696 -
 697 -    style = gtk_widget_get_style_context(gHandleBoxWidget);
 698 -    gtk_style_context_save(style);
 699 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_GRIP);
 700 -    gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
 701 -
 702 +    GtkStyleContext* style =
 703 +            ClaimStyleContext(MOZ_GTK_GRIPPER, direction,
 704 +                              GetStateFlagsFromGtkWidgetState(state));
 705      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 706      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 707 -    gtk_style_context_restore(style);
 708 -
 709 +    ReleaseStyleContext(style);
 710      return MOZ_GTK_SUCCESS;
 711  }
 712
 713 @@ -1435,6 +1173,38 @@ moz_gtk_entry_paint(cairo_t *cr, GdkRect
 714      return MOZ_GTK_SUCCESS;
 715  }
 716
 717 +static gint
 718 +moz_gtk_text_view_paint(cairo_t *cr, GdkRectangle* rect,
 719 +                        GtkWidgetState* state,
 720 +                        GtkTextDirection direction)
 721 +{
 722 +    GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
 723 +
 724 +    GtkStyleContext* style_frame =
 725 +        ClaimStyleContext(MOZ_GTK_SCROLLED_WINDOW, direction, state_flags);
 726 +    gtk_render_frame(style_frame, cr, rect->x, rect->y, rect->width, rect->height);
 727 +
 728 +    GtkBorder border, padding;
 729 +    gtk_style_context_get_border(style_frame, state_flags, &border);
 730 +    gtk_style_context_get_padding(style_frame, state_flags, &padding);
 731 +    ReleaseStyleContext(style_frame);
 732 +
 733 +    GtkStyleContext* style =
 734 +        ClaimStyleContext(MOZ_GTK_TEXT_VIEW, direction, state_flags);
 735 +
 736 +    gint xthickness = border.left + padding.left;
 737 +    gint ythickness = border.top + padding.top;
 738 +
 739 +    gtk_render_background(style, cr,
 740 +                          rect->x + xthickness, rect->y + ythickness,
 741 +                          rect->width - 2 * xthickness,
 742 +                          rect->height - 2 * ythickness);
 743 +
 744 +    ReleaseStyleContext(style);
 745 +
 746 +    return MOZ_GTK_SUCCESS;
 747 +}
 748 +
 749  static gint
 750  moz_gtk_treeview_paint(cairo_t *cr, GdkRectangle* rect,
 751                         GtkWidgetState* state,
 752 @@ -1447,18 +1217,13 @@ moz_gtk_treeview_paint(cairo_t *cr, GdkR
 753      GtkBorder border;
 754
 755      ensure_tree_view_widget();
 756 -    ensure_scrolled_window_widget();
 757 -
 758      gtk_widget_set_direction(gTreeViewWidget, direction);
 759 -    gtk_widget_set_direction(gScrolledWindowWidget, direction);
 760
 761      /* only handle disabled and normal states, otherwise the whole background
 762       * area will be painted differently with other states */
 763      state_flags = state->disabled ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL;
 764
 765 -    style = gtk_widget_get_style_context(gScrolledWindowWidget);
 766 -    gtk_style_context_save(style);
 767 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
 768 +    style = ClaimStyleContext(MOZ_GTK_SCROLLED_WINDOW, direction);
 769      gtk_style_context_get_border(style, state_flags, &border);
 770      xthickness = border.left;
 771      ythickness = border.top;
 772 @@ -1473,7 +1238,7 @@ moz_gtk_treeview_paint(cairo_t *cr, GdkR
 773                            rect->height - 2 * ythickness);
 774      gtk_render_frame(style, cr,
 775                       rect->x, rect->y, rect->width, rect->height);
 776 -    gtk_style_context_restore(style);
 777 +    ReleaseStyleContext(style);
 778      gtk_style_context_restore(style_tree);
 779      return MOZ_GTK_SUCCESS;
 780  }
 781 @@ -1648,20 +1413,9 @@ moz_gtk_arrow_paint(cairo_t *cr, GdkRect
 782                      GtkWidgetState* state,
 783                      GtkArrowType arrow_type, GtkTextDirection direction)
 784  {
 785 -    GtkStyleContext* style;
 786 -    GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
 787      GdkRectangle arrow_rect;
 788      gdouble arrow_angle;
 789
 790 -    ensure_button_arrow_widget();
 791 -    style = gtk_widget_get_style_context(gButtonArrowWidget);
 792 -    gtk_style_context_save(style);
 793 -    gtk_style_context_set_state(style, state_flags);
 794 -    gtk_widget_set_direction(gButtonArrowWidget, direction);
 795 -
 796 -    calculate_arrow_rect(gButtonArrowWidget, rect, &arrow_rect,
 797 -                         direction);
 798 -
 799      if (direction == GTK_TEXT_DIR_RTL) {
 800          arrow_type = (arrow_type == GTK_ARROW_LEFT) ?
 801                           GTK_ARROW_RIGHT : GTK_ARROW_LEFT;
 802 @@ -1680,10 +1434,17 @@ moz_gtk_arrow_paint(cairo_t *cr, GdkRect
 803          arrow_angle = ARROW_UP;
 804          break;
 805      }
 806 -    if (arrow_type != GTK_ARROW_NONE)
 807 -        gtk_render_arrow(style, cr, arrow_angle,
 808 -                         arrow_rect.x, arrow_rect.y, arrow_rect.width);
 809 -    gtk_style_context_restore(style);
 810 +    if (arrow_type == GTK_ARROW_NONE)
 811 +        return MOZ_GTK_SUCCESS;
 812 +
 813 +    calculate_arrow_rect(GetWidget(MOZ_GTK_BUTTON_ARROW), rect, &arrow_rect,
 814 +                         direction);
 815 +    GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
 816 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_BUTTON_ARROW,
 817 +                                               direction, state_flags);
 818 +    gtk_render_arrow(style, cr, arrow_angle,
 819 +                     arrow_rect.x, arrow_rect.y, arrow_rect.width);
 820 +    ReleaseStyleContext(style);
 821      return MOZ_GTK_SUCCESS;
 822  }
 823
 824 @@ -1776,19 +1537,10 @@ static gint
 825  moz_gtk_toolbar_paint(cairo_t *cr, GdkRectangle* rect,
 826                        GtkTextDirection direction)
 827  {
 828 -    GtkStyleContext* style;
 829 -
 830 -    ensure_toolbar_widget();
 831 -    gtk_widget_set_direction(gToolbarWidget, direction);
 832 -
 833 -    style = gtk_widget_get_style_context(gToolbarWidget);
 834 -    gtk_style_context_save(style);
 835 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLBAR);
 836 -
 837 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_TOOLBAR, direction);
 838      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 839      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 840 -    gtk_style_context_restore(style);
 841 -
 842 +    ReleaseStyleContext(style);
 843      return MOZ_GTK_SUCCESS;
 844  }
 845
 846 @@ -1798,7 +1550,6 @@ static gint
 847  moz_gtk_toolbar_separator_paint(cairo_t *cr, GdkRectangle* rect,
 848                                  GtkTextDirection direction)
 849  {
 850 -    GtkStyleContext* style;
 851      gint     separator_width;
 852      gint     paint_width;
 853      gboolean wide_separators;
 854 @@ -1807,16 +1558,14 @@ moz_gtk_toolbar_separator_paint(cairo_t
 855      const double start_fraction = 0.2;
 856      const double end_fraction = 0.8;
 857
 858 -    ensure_toolbar_separator_widget();
 859 -    gtk_widget_set_direction(gToolbarSeparatorWidget, direction);
 860 -
 861 -    style = gtk_widget_get_style_context(gToolbarSeparatorWidget);
 862 -
 863 -    gtk_style_context_get_style(gtk_widget_get_style_context(gToolbarWidget),
 864 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_TOOLBAR);
 865 +    gtk_style_context_get_style(style,
 866                                  "wide-separators", &wide_separators,
 867                                  "separator-width", &separator_width,
 868                                  NULL);
 869 +    ReleaseStyleContext(style);
 870
 871 +    style = ClaimStyleContext(MOZ_GTK_TOOLBAR_SEPARATOR, direction);
 872      if (wide_separators) {
 873          if (separator_width > rect->width)
 874              separator_width = rect->width;
 875 @@ -1840,7 +1589,7 @@ moz_gtk_toolbar_separator_paint(cairo_t
 876                          rect->x + (rect->width - paint_width) / 2,
 877                          rect->y + rect->height * end_fraction);
 878      }
 879 -
 880 +    ReleaseStyleContext(style);
 881      return MOZ_GTK_SUCCESS;
 882  }
 883
 884 @@ -1848,14 +1597,10 @@ static gint
 885  moz_gtk_tooltip_paint(cairo_t *cr, GdkRectangle* rect,
 886                        GtkTextDirection direction)
 887  {
 888 -    GtkStyleContext* style;
 889 -
 890 -    ensure_tooltip_widget();
 891 -    gtk_widget_set_direction(gTooltipWidget, direction);
 892 -
 893 -    style = gtk_widget_get_style_context(gTooltipWidget);
 894 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_TOOLTIP, direction);
 895      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 896      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 897 +    ReleaseStyleContext(style);
 898      return MOZ_GTK_SUCCESS;
 899  }
 900
 901 @@ -1870,14 +1615,11 @@ moz_gtk_resizer_paint(cairo_t *cr, GdkRe
 902      // GTK_STYLE_CLASS_VIEW to match the background with textarea elements.
 903      // The resizer is drawn with shaded variants of the background color, and
 904      // so a transparent background would lead to a transparent resizer.
 905 -    ensure_text_view_widget();
 906 -    gtk_widget_set_direction(gTextViewWidget, GTK_TEXT_DIR_LTR);
 907 -
 908 -    style = gtk_widget_get_style_context(gTextViewWidget);
 909 -    gtk_style_context_save(style);
 910 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_VIEW);
 911 +    style = ClaimStyleContext(MOZ_GTK_TEXT_VIEW, GTK_TEXT_DIR_LTR,
 912 +                              GetStateFlagsFromGtkWidgetState(state));
 913 +    // TODO - we need to save/restore style when gtk 3.20 CSS node path
 914 +    // is used
 915      gtk_style_context_add_class(style, GTK_STYLE_CLASS_GRIP);
 916 -    gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
 917
 918      // Workaround unico not respecting the text direction for resizers.
 919      // See bug 1174248.
 920 @@ -1891,7 +1633,7 @@ moz_gtk_resizer_paint(cairo_t *cr, GdkRe
 921
 922      gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height);
 923      cairo_restore(cr);
 924 -    gtk_style_context_restore(style);
 925 +    ReleaseStyleContext(style);
 926
 927      return MOZ_GTK_SUCCESS;
 928  }
 929 @@ -1900,16 +1642,9 @@ static gint
 930  moz_gtk_frame_paint(cairo_t *cr, GdkRectangle* rect,
 931                      GtkTextDirection direction)
 932  {
 933 -    GtkStyleContext* style;
 934 -
 935 -    ensure_frame_widget();
 936 -    gtk_widget_set_direction(gFrameWidget, direction);
 937 -    style = gtk_widget_get_style_context(gFrameWidget);
 938 -    gtk_style_context_save(style);
 939 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
 940 -
 941 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_FRAME, direction);
 942      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 943 -    gtk_style_context_restore(style);
 944 +    ReleaseStyleContext(style);
 945      return MOZ_GTK_SUCCESS;
 946  }
 947
 948 @@ -1917,18 +1652,11 @@ static gint
 949  moz_gtk_progressbar_paint(cairo_t *cr, GdkRectangle* rect,
 950                            GtkTextDirection direction)
 951  {
 952 -    GtkStyleContext* style;
 953 -
 954 -    ensure_progress_widget();
 955 -    gtk_widget_set_direction(gProgressWidget, direction);
 956 -
 957 -    style = gtk_widget_get_style_context(gProgressWidget);
 958 -    gtk_style_context_save(style);
 959 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_TROUGH);
 960 -
 961 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_PROGRESS_TROUGH,
 962 +                                               direction);
 963      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
 964      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
 965 -    gtk_style_context_restore(style);
 966 +    ReleaseStyleContext(style);
 967
 968      return MOZ_GTK_SUCCESS;
 969  }
 970 @@ -1940,13 +1668,15 @@ moz_gtk_progress_chunk_paint(cairo_t *cr
 971  {
 972      GtkStyleContext* style;
 973
 974 -    ensure_progress_widget();
 975 -    gtk_widget_set_direction(gProgressWidget, direction);
 976 -
 977 -    style = gtk_widget_get_style_context(gProgressWidget);
 978 -    gtk_style_context_save(style);
 979 -    gtk_style_context_remove_class(style, GTK_STYLE_CLASS_TROUGH);
 980 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_PROGRESSBAR);
 981 +    if (gtk_check_version(3, 20, 0) != nullptr) {
 982 +      /* Ask for MOZ_GTK_PROGRESS_TROUGH instead of MOZ_GTK_PROGRESSBAR
 983 +       * because ClaimStyleContext() saves/restores that style */
 984 +      style = ClaimStyleContext(MOZ_GTK_PROGRESS_TROUGH, direction);
 985 +      gtk_style_context_remove_class(style, GTK_STYLE_CLASS_TROUGH);
 986 +      gtk_style_context_add_class(style, GTK_STYLE_CLASS_PROGRESSBAR);
 987 +    } else {
 988 +      style = ClaimStyleContext(MOZ_GTK_PROGRESS_CHUNK, direction);
 989 +    }
 990
 991      if (widget == MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE ||
 992          widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE) {
 993 @@ -1990,7 +1720,7 @@ moz_gtk_progress_chunk_paint(cairo_t *cr
 994      } else {
 995        gtk_render_activity(style, cr, rect->x, rect->y, rect->width, rect->height);
 996      }
 997 -    gtk_style_context_restore(style);
 998 +    ReleaseStyleContext(style);
 999
1000      return MOZ_GTK_SUCCESS;
1001  }
1002 @@ -2324,10 +2054,10 @@ moz_gtk_menu_bar_paint(cairo_t *cr, GdkR
1003  {
1004      GtkStyleContext* style;
1005
1006 -    ensure_menu_bar_widget();
1007 -    gtk_widget_set_direction(gMenuBarWidget, direction);
1008 +    GtkWidget* widget = GetWidget(MOZ_GTK_MENUBAR);
1009 +    gtk_widget_set_direction(widget, direction);
1010
1011 -    style = gtk_widget_get_style_context(gMenuBarWidget);
1012 +    style = gtk_widget_get_style_context(widget);
1013      gtk_style_context_save(style);
1014      gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
1015      gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);
1016 @@ -2343,14 +2073,14 @@ moz_gtk_menu_popup_paint(cairo_t *cr, Gd
1017  {
1018      GtkStyleContext* style;
1019
1020 -    ensure_menu_popup_widget();
1021 -    gtk_widget_set_direction(gMenuPopupWidget, direction);
1022 +    GtkWidget* widget = GetWidget(MOZ_GTK_MENUPOPUP);
1023 +    gtk_widget_set_direction(widget, direction);
1024
1025      // Draw a backing toplevel. This fixes themes that don't provide a menu
1026      // background, and depend on the GtkMenu's implementation window to provide it.
1027      moz_gtk_window_paint(cr, rect, direction);
1028
1029 -    style = gtk_widget_get_style_context(gMenuPopupWidget);
1030 +    style = gtk_widget_get_style_context(widget);
1031      gtk_style_context_save(style);
1032      gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENU);
1033
1034 @@ -2373,12 +2103,10 @@ moz_gtk_menu_separator_paint(cairo_t *cr
1035      gint x, y, w;
1036      GtkBorder padding;
1037
1038 -    ensure_menu_separator_widget();
1039 -    gtk_widget_set_direction(gMenuSeparatorWidget, direction);
1040 -
1041 -    border_width = gtk_container_get_border_width(GTK_CONTAINER(gMenuSeparatorWidget));
1042 -
1043 -    style = gtk_widget_get_style_context(gMenuSeparatorWidget);
1044 +    border_width =
1045 +        gtk_container_get_border_width(GTK_CONTAINER(
1046 +                                       GetWidget(MOZ_GTK_MENUSEPARATOR)));
1047 +    style = ClaimStyleContext(MOZ_GTK_MENUSEPARATOR, direction);
1048      gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
1049
1050      x = rect->x + border_width;
1051 @@ -2408,42 +2136,36 @@ moz_gtk_menu_separator_paint(cairo_t *cr
1052      }
1053
1054      gtk_style_context_restore(style);
1055 +    ReleaseStyleContext(style);
1056
1057      return MOZ_GTK_SUCCESS;
1058  }
1059
1060  // See gtk_menu_item_draw() for reference.
1061  static gint
1062 -moz_gtk_menu_item_paint(cairo_t *cr, GdkRectangle* rect,
1063 -                        GtkWidgetState* state,
1064 -                        gint flags, GtkTextDirection direction)
1065 +moz_gtk_menu_item_paint(WidgetNodeType widget, cairo_t *cr, GdkRectangle* rect,
1066 +                        GtkWidgetState* state, GtkTextDirection direction)
1067  {
1068 -    GtkStyleContext* style;
1069 -    GtkWidget* item_widget;
1070 -    guint border_width;
1071      gint x, y, w, h;
1072
1073      if (state->inHover && !state->disabled) {
1074 -        if (flags & MOZ_TOPLEVEL_MENU_ITEM) {
1075 -            ensure_menu_bar_item_widget();
1076 -            item_widget = gMenuBarItemWidget;
1077 -        } else {
1078 -            ensure_menu_item_widget();
1079 -            item_widget = gMenuItemWidget;
1080 -        }
1081 -        style = gtk_widget_get_style_context(item_widget);
1082 -        gtk_style_context_save(style);
1083 +        guint border_width =
1084 +            gtk_container_get_border_width(GTK_CONTAINER(GetWidget(widget)));
1085 +        GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
1086 +        GtkStyleContext* style =
1087 +            ClaimStyleContext(widget, direction, state_flags);
1088
1089 -        if (flags & MOZ_TOPLEVEL_MENU_ITEM) {
1090 -            gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
1091 +        bool pre_3_6 = gtk_check_version(3, 6, 0) != nullptr;
1092 +        if (pre_3_6) {
1093 +            // GTK+ 3.4 saves the style context and adds the menubar class to
1094 +            // menubar children, but does each of these only when drawing, not
1095 +            // during layout.
1096 +            gtk_style_context_save(style);
1097 +            if (widget == MOZ_GTK_MENUBARITEM) {
1098 +                gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
1099 +            }
1100          }
1101
1102 -        gtk_widget_set_direction(item_widget, direction);
1103 -        gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUITEM);
1104 -        gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
1105 -
1106 -        border_width = gtk_container_get_border_width(GTK_CONTAINER(item_widget));
1107 -
1108          x = rect->x + border_width;
1109          y = rect->y + border_width;
1110          w = rect->width - border_width * 2;
1111 @@ -2451,7 +2173,11 @@ moz_gtk_menu_item_paint(cairo_t *cr, Gdk
1112
1113          gtk_render_background(style, cr, x, y, w, h);
1114          gtk_render_frame(style, cr, x, y, w, h);
1115 -        gtk_style_context_restore(style);
1116 +
1117 +        if (pre_3_6) {
1118 +            gtk_style_context_restore(style);
1119 +        }
1120 +        ReleaseStyleContext(style);
1121      }
1122
1123      return MOZ_GTK_SUCCESS;
1124 @@ -2462,21 +2188,13 @@ moz_gtk_menu_arrow_paint(cairo_t *cr, Gd
1125                           GtkWidgetState* state,
1126                           GtkTextDirection direction)
1127  {
1128 -    GtkStyleContext* style;
1129      GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
1130 -
1131 -    ensure_menu_item_widget();
1132 -    gtk_widget_set_direction(gMenuItemWidget, direction);
1133 -
1134 -    style = gtk_widget_get_style_context(gMenuItemWidget);
1135 -    gtk_style_context_save(style);
1136 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUITEM);
1137 -    gtk_style_context_set_state(style, state_flags);
1138 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_MENUITEM,
1139 +                                               direction, state_flags);
1140      gtk_render_arrow(style, cr,
1141                      (direction == GTK_TEXT_DIR_LTR) ? ARROW_RIGHT : ARROW_LEFT,
1142                      rect->x, rect->y, rect->width);
1143 -    gtk_style_context_restore(style);
1144 -
1145 +    ReleaseStyleContext(style);
1146      return MOZ_GTK_SUCCESS;
1147  }
1148
1149 @@ -2494,7 +2212,7 @@ moz_gtk_check_menu_item_paint(cairo_t *c
1150      gint indicator_size, horizontal_padding;
1151      gint x, y;
1152
1153 -    moz_gtk_menu_item_paint(cr, rect, state, FALSE, direction);
1154 +    moz_gtk_menu_item_paint(MOZ_GTK_MENUITEM, cr, rect, state, direction);
1155
1156      ensure_check_menu_item_widget();
1157      gtk_widget_set_direction(gCheckMenuItemWidget, direction);
1158 @@ -2545,21 +2263,13 @@ static gint
1159  moz_gtk_info_bar_paint(cairo_t *cr, GdkRectangle* rect,
1160                         GtkWidgetState* state)
1161  {
1162 -    GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
1163 -    GtkStyleContext *style;
1164 -    ensure_info_bar();
1165 -
1166 -    style = gtk_widget_get_style_context(gInfoBar);
1167 -    gtk_style_context_save(style);
1168 -
1169 -    gtk_style_context_set_state(style, state_flags);
1170 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_INFO);
1171 -
1172 +    GtkStyleContext *style =
1173 +        ClaimStyleContext(MOZ_GTK_INFO_BAR, GTK_TEXT_DIR_LTR,
1174 +                          GetStateFlagsFromGtkWidgetState(state));
1175      gtk_render_background(style, cr, rect->x, rect->y, rect->width,
1176                            rect->height);
1177      gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);
1178 -
1179 -    gtk_style_context_restore(style);
1180 +    ReleaseStyleContext(style);
1181
1182      return MOZ_GTK_SUCCESS;
1183  }
1184 @@ -2605,18 +2315,18 @@ moz_gtk_get_widget_border(WidgetNodeType
1185      case MOZ_GTK_BUTTON:
1186      case MOZ_GTK_TOOLBAR_BUTTON:
1187          {
1188 -            ensure_button_widget();
1189 -            style = gtk_widget_get_style_context(gButtonWidget);
1190 +            style = ClaimStyleContext(MOZ_GTK_BUTTON);
1191
1192 -            *left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(gButtonWidget));
1193 +            *left = *top = *right = *bottom =
1194 +                gtk_container_get_border_width(GTK_CONTAINER(GetWidget(MOZ_GTK_BUTTON)));
1195
1196              if (widget == MOZ_GTK_TOOLBAR_BUTTON) {
1197                  gtk_style_context_save(style);
1198                  gtk_style_context_add_class(style, "image-button");
1199              }
1200 -
1201 +
1202              moz_gtk_add_style_padding(style, left, top, right, bottom);
1203 -
1204 +
1205              if (widget == MOZ_GTK_TOOLBAR_BUTTON)
1206                  gtk_style_context_restore(style);
1207
1208 @@ -2624,12 +2334,13 @@ moz_gtk_get_widget_border(WidgetNodeType
1209              // -moz-focus-inner border (Bug 1228281).
1210              *left -= 1; *top -= 1; *right -= 1; *bottom -= 1;
1211              moz_gtk_add_style_border(style, left, top, right, bottom);
1212 +
1213 +            ReleaseStyleContext(style);
1214              return MOZ_GTK_SUCCESS;
1215          }
1216      case MOZ_GTK_ENTRY:
1217          {
1218 -            ensure_entry_widget();
1219 -            style = gtk_widget_get_style_context(gEntryWidget);
1220 +            style = ClaimStyleContext(MOZ_GTK_ENTRY);
1221
1222              // XXX: Subtract 1 pixel from the padding to account for the default
1223              // padding in forms.css. See bug 1187385.
1224 @@ -2637,16 +2348,15 @@ moz_gtk_get_widget_border(WidgetNodeType
1225              moz_gtk_add_style_padding(style, left, top, right, bottom);
1226              moz_gtk_add_style_border(style, left, top, right, bottom);
1227
1228 +            ReleaseStyleContext(style);
1229              return MOZ_GTK_SUCCESS;
1230          }
1231 +    case MOZ_GTK_TEXT_VIEW:
1232      case MOZ_GTK_TREEVIEW:
1233          {
1234 -            ensure_scrolled_window_widget();
1235 -            style = gtk_widget_get_style_context(gScrolledWindowWidget);
1236 -            gtk_style_context_save(style);
1237 -            gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
1238 +            style = ClaimStyleContext(MOZ_GTK_SCROLLED_WINDOW);
1239              moz_gtk_add_style_border(style, left, top, right, bottom);
1240 -            gtk_style_context_restore(style);
1241 +            ReleaseStyleContext(style);
1242              return MOZ_GTK_SUCCESS;
1243          }
1244      case MOZ_GTK_TREE_HEADER_CELL:
1245 @@ -2726,14 +2436,12 @@ moz_gtk_get_widget_border(WidgetNodeType
1246          w = gTabWidget;
1247          break;
1248      case MOZ_GTK_PROGRESSBAR:
1249 -        ensure_progress_widget();
1250 -        w = gProgressWidget;
1251 +        w = GetWidget(MOZ_GTK_PROGRESSBAR);
1252          break;
1253      case MOZ_GTK_SPINBUTTON_ENTRY:
1254      case MOZ_GTK_SPINBUTTON_UP:
1255      case MOZ_GTK_SPINBUTTON_DOWN:
1256 -        ensure_spin_widget();
1257 -        w = gSpinWidget;
1258 +        w = GetWidget(MOZ_GTK_SPINBUTTON);
1259          break;
1260      case MOZ_GTK_SCALE_HORIZONTAL:
1261          ensure_scale_widget();
1262 @@ -2744,8 +2452,7 @@ moz_gtk_get_widget_border(WidgetNodeType
1263          w = gVScaleWidget;
1264          break;
1265      case MOZ_GTK_FRAME:
1266 -        ensure_frame_widget();
1267 -        w = gFrameWidget;
1268 +        w = GetWidget(MOZ_GTK_FRAME);
1269          break;
1270      case MOZ_GTK_CHECKBUTTON_CONTAINER:
1271      case MOZ_GTK_RADIOBUTTON_CONTAINER:
1272 @@ -2761,19 +2468,17 @@ moz_gtk_get_widget_border(WidgetNodeType
1273              return MOZ_GTK_SUCCESS;
1274          }
1275      case MOZ_GTK_MENUPOPUP:
1276 -        ensure_menu_popup_widget();
1277 -        w = gMenuPopupWidget;
1278 +        w = GetWidget(MOZ_GTK_MENUPOPUP);
1279          break;
1280 +    case MOZ_GTK_MENUBARITEM:
1281      case MOZ_GTK_MENUITEM:
1282      case MOZ_GTK_CHECKMENUITEM:
1283      case MOZ_GTK_RADIOMENUITEM:
1284          {
1285 -            if (widget == MOZ_GTK_MENUITEM) {
1286 -                ensure_menu_item_widget();
1287 -                ensure_menu_bar_item_widget();
1288 -                w = gMenuItemWidget;
1289 -            }
1290 -            else {
1291 +            if (widget == MOZ_GTK_MENUBARITEM || widget == MOZ_GTK_MENUITEM) {
1292 +                // Bug 1274143 for MOZ_GTK_MENUBARITEM
1293 +                w = GetWidget(MOZ_GTK_MENUITEM);
1294 +            } else {
1295                  ensure_check_menu_item_widget();
1296                  w = gCheckMenuItemWidget;
1297              }
1298 @@ -2784,9 +2489,16 @@ moz_gtk_get_widget_border(WidgetNodeType
1299              return MOZ_GTK_SUCCESS;
1300          }
1301      case MOZ_GTK_INFO_BAR:
1302 -        ensure_info_bar();
1303 -        w = gInfoBar;
1304 +        w = GetWidget(MOZ_GTK_INFO_BAR);
1305          break;
1306 +    case MOZ_GTK_TOOLTIP:
1307 +        {
1308 +            style = ClaimStyleContext(MOZ_GTK_TOOLTIP);
1309 +            moz_gtk_add_style_border(style, left, top, right, bottom);
1310 +            moz_gtk_add_style_padding(style, left, top, right, bottom);
1311 +            ReleaseStyleContext(style);
1312 +            return MOZ_GTK_SUCCESS;
1313 +        }
1314      /* These widgets have no borders, since they are not containers. */
1315      case MOZ_GTK_CHECKBUTTON_LABEL:
1316      case MOZ_GTK_RADIOBUTTON_LABEL:
1317 @@ -2810,7 +2522,6 @@ moz_gtk_get_widget_border(WidgetNodeType
1318      case MOZ_GTK_MENUSEPARATOR:
1319      /* These widgets have no borders.*/
1320      case MOZ_GTK_SPINBUTTON:
1321 -    case MOZ_GTK_TOOLTIP:
1322      case MOZ_GTK_WINDOW:
1323      case MOZ_GTK_RESIZER:
1324      case MOZ_GTK_MENUARROW:
1325 @@ -2908,8 +2619,7 @@ moz_gtk_get_arrow_size(WidgetNodeType wi
1326              widget = gComboBoxArrowWidget;
1327              break;
1328          default:
1329 -            ensure_button_arrow_widget();
1330 -            widget = gButtonArrowWidget;
1331 +            widget = GetWidget(MOZ_GTK_BUTTON_ARROW);
1332              break;
1333      }
1334
1335 @@ -2924,11 +2634,9 @@ moz_gtk_get_toolbar_separator_width(gint
1336  {
1337      gboolean wide_separators;
1338      gint separator_width;
1339 -    GtkStyleContext* style;
1340      GtkBorder border;
1341
1342 -    ensure_toolbar_widget();
1343 -    style = gtk_widget_get_style_context(gToolbarWidget);
1344 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_TOOLBAR);
1345      gtk_style_context_get_style(style,
1346                                  "space-size", size,
1347                                  "wide-separators",  &wide_separators,
1348 @@ -2937,17 +2645,18 @@ moz_gtk_get_toolbar_separator_width(gint
1349      /* Just in case... */
1350      gtk_style_context_get_border(style, GTK_STATE_FLAG_NORMAL, &border);
1351      *size = MAX(*size, (wide_separators ? separator_width : border.left));
1352 +    ReleaseStyleContext(style);
1353      return MOZ_GTK_SUCCESS;
1354  }
1355
1356  gint
1357  moz_gtk_get_expander_size(gint* size)
1358  {
1359 -    ensure_expander_widget();
1360 -    gtk_style_context_get_style(gtk_widget_get_style_context(gExpanderWidget),
1361 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_EXPANDER);
1362 +    gtk_style_context_get_style(style,
1363                                  "expander-size", size,
1364                                  NULL);
1365 -
1366 +    ReleaseStyleContext(style);
1367      return MOZ_GTK_SUCCESS;
1368  }
1369
1370 @@ -2972,11 +2681,11 @@ moz_gtk_get_menu_separator_height(gint *
1371      GtkStyleContext* style;
1372      guint border_width;
1373
1374 -    ensure_menu_separator_widget();
1375 -
1376 -    border_width = gtk_container_get_border_width(GTK_CONTAINER(gMenuSeparatorWidget));
1377 +    border_width =
1378 +        gtk_container_get_border_width(GTK_CONTAINER(
1379 +                                       GetWidget(MOZ_GTK_MENUSEPARATOR)));
1380
1381 -    style = gtk_widget_get_style_context(gMenuSeparatorWidget);
1382 +    style = ClaimStyleContext(MOZ_GTK_MENUSEPARATOR);
1383      gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
1384
1385      gtk_style_context_save(style);
1386 @@ -2988,6 +2697,7 @@ moz_gtk_get_menu_separator_height(gint *
1387                                  NULL);
1388
1389      gtk_style_context_restore(style);
1390 +    ReleaseStyleContext(style);
1391
1392      *size = padding.top + padding.bottom + border_width*2;
1393      *size += (wide_separators) ? separator_height : 1;
1394 @@ -2998,8 +2708,7 @@ moz_gtk_get_menu_separator_height(gint *
1395  void
1396  moz_gtk_get_entry_min_height(gint* height)
1397  {
1398 -    ensure_entry_widget();
1399 -    GtkStyleContext* style = gtk_widget_get_style_context(gEntryWidget);
1400 +    GtkStyleContext* style = ClaimStyleContext(MOZ_GTK_ENTRY);
1401      if (!gtk_check_version(3, 20, 0)) {
1402          gtk_style_context_get(style, gtk_style_context_get_state(style),
1403                                "min-height", height,
1404 @@ -3014,6 +2723,7 @@ moz_gtk_get_entry_min_height(gint* heigh
1405      gtk_style_context_get_padding(style, GTK_STATE_FLAG_NORMAL, &padding);
1406
1407      *height += (border.top + border.bottom + padding.top + padding.bottom);
1408 +    ReleaseStyleContext(style);
1409  }
1410
1411  void
1412 @@ -3094,8 +2804,7 @@ moz_gtk_images_in_buttons()
1413      gboolean result;
1414      GtkSettings* settings;
1415
1416 -    ensure_button_widget();
1417 -    settings = gtk_widget_get_settings(gButtonWidget);
1418 +    settings = gtk_widget_get_settings(GetWidget(MOZ_GTK_BUTTON));
1419
1420      g_object_get(settings, "gtk-button-images", &result, NULL);
1421      return result;
1422 @@ -3116,14 +2825,14 @@ moz_gtk_widget_paint(WidgetNodeType widg
1423      case MOZ_GTK_BUTTON:
1424      case MOZ_GTK_TOOLBAR_BUTTON:
1425          if (state->depressed) {
1426 -            ensure_toggle_button_widget();
1427              return moz_gtk_button_paint(cr, rect, state,
1428                                          (GtkReliefStyle) flags,
1429 -                                        gToggleButtonWidget, direction);
1430 +                                        GetWidget(MOZ_GTK_TOGGLE_BUTTON),
1431 +                                        direction);
1432          }
1433 -        ensure_button_widget();
1434          return moz_gtk_button_paint(cr, rect, state,
1435 -                                    (GtkReliefStyle) flags, gButtonWidget,
1436 +                                    (GtkReliefStyle) flags,
1437 +                                    GetWidget(MOZ_GTK_BUTTON),
1438                                      direction);
1439          break;
1440      case MOZ_GTK_CHECKBUTTON:
1441 @@ -3171,9 +2880,9 @@ moz_gtk_widget_paint(WidgetNodeType widg
1442                                           state, direction);
1443          break;
1444      case MOZ_GTK_SPINBUTTON_ENTRY:
1445 -        ensure_spin_widget();
1446 +        // TODO - use MOZ_GTK_SPINBUTTON_ENTRY style directly
1447          return moz_gtk_entry_paint(cr, rect, state,
1448 -                                   gSpinWidget, direction);
1449 +                                   GetWidget(MOZ_GTK_SPINBUTTON), direction);
1450          break;
1451      case MOZ_GTK_GRIPPER:
1452          return moz_gtk_gripper_paint(cr, rect, state,
1453 @@ -3198,9 +2907,11 @@ moz_gtk_widget_paint(WidgetNodeType widg
1454                                                 (GtkExpanderStyle) flags, direction);
1455          break;
1456      case MOZ_GTK_ENTRY:
1457 -        ensure_entry_widget();
1458 -        return moz_gtk_entry_paint(cr, rect, state,
1459 -                                   gEntryWidget, direction);
1460 +        return moz_gtk_entry_paint(cr, rect, state, GetWidget(MOZ_GTK_ENTRY),
1461 +                                   direction);
1462 +        break;
1463 +    case MOZ_GTK_TEXT_VIEW:
1464 +        return moz_gtk_text_view_paint(cr, rect, state, direction);
1465          break;
1466      case MOZ_GTK_DROPDOWN:
1467          return moz_gtk_combo_box_paint(cr, rect, state, direction);
1468 @@ -3271,9 +2982,9 @@ moz_gtk_widget_paint(WidgetNodeType widg
1469          return moz_gtk_menu_separator_paint(cr, rect,
1470                                              direction);
1471          break;
1472 +    case MOZ_GTK_MENUBARITEM:
1473      case MOZ_GTK_MENUITEM:
1474 -        return moz_gtk_menu_item_paint(cr, rect, state, flags,
1475 -                                       direction);
1476 +        return moz_gtk_menu_item_paint(widget, cr, rect, state, direction);
1477          break;
1478      case MOZ_GTK_MENUARROW:
1479          return moz_gtk_menu_arrow_paint(cr, rect, state,
1480 @@ -3333,25 +3044,16 @@ gboolean moz_gtk_has_scrollbar_buttons(v
1481  gint
1482  moz_gtk_shutdown()
1483  {
1484 -    if (gTooltipWidget)
1485 -        gtk_widget_destroy(gTooltipWidget);
1486      /* This will destroy all of our widgets */
1487 -
1488      ResetWidgetCache();
1489
1490      /* TODO - replace it with appropriate widget */
1491      if (gTreeHeaderSortArrowWidget)
1492          gtk_widget_destroy(gTreeHeaderSortArrowWidget);
1493
1494 -    gProtoWindow = NULL;
1495      gProtoLayout = NULL;
1496 -    gButtonWidget = NULL;
1497 -    gToggleButtonWidget = NULL;
1498 -    gButtonArrowWidget = NULL;
1499 -    gSpinWidget = NULL;
1500      gHScaleWidget = NULL;
1501      gVScaleWidget = NULL;
1502 -    gEntryWidget = NULL;
1503      gComboBoxWidget = NULL;
1504      gComboBoxButtonWidget = NULL;
1505      gComboBoxSeparatorWidget = NULL;
1506 @@ -3360,29 +3062,15 @@ moz_gtk_shutdown()
1507      gComboBoxEntryButtonWidget = NULL;
1508      gComboBoxEntryArrowWidget = NULL;
1509      gComboBoxEntryTextareaWidget = NULL;
1510 -    gHandleBoxWidget = NULL;
1511 -    gToolbarWidget = NULL;
1512 -    gFrameWidget = NULL;
1513 -    gProgressWidget = NULL;
1514      gTabWidget = NULL;
1515 -    gTextViewWidget = nullptr;
1516 -    gTooltipWidget = NULL;
1517 -    gMenuBarWidget = NULL;
1518 -    gMenuBarItemWidget = NULL;
1519 -    gMenuPopupWidget = NULL;
1520 -    gMenuItemWidget = NULL;
1521      gImageMenuItemWidget = NULL;
1522      gCheckMenuItemWidget = NULL;
1523      gTreeViewWidget = NULL;
1524      gMiddleTreeViewColumn = NULL;
1525      gTreeHeaderCellWidget = NULL;
1526      gTreeHeaderSortArrowWidget = NULL;
1527 -    gExpanderWidget = NULL;
1528 -    gToolbarSeparatorWidget = NULL;
1529 -    gMenuSeparatorWidget = NULL;
1530      gHPanedWidget = NULL;
1531      gVPanedWidget = NULL;
1532 -    gScrolledWindowWidget = NULL;
1533
1534      is_initialized = FALSE;
1535
1536 diff -up firefox-48.0/widget/gtk/gtkdrawing.h.gtk3-20 firefox-48.0/widget/gtk/gtkdrawing.h
1537 --- firefox-48.0/widget/gtk/gtkdrawing.h.gtk3-20        2016-07-25 22:22:07.000000000 +0200
1538 +++ firefox-48.0/widget/gtk/gtkdrawing.h        2016-07-29 09:15:11.822285857 +0200
1539 @@ -69,12 +69,6 @@ typedef enum {
1540    MOZ_GTK_TAB_SELECTED        = 1 << 10
1541  } GtkTabFlags;
1542
1543 -/** flags for menuitems **/
1544 -typedef enum {
1545 -  /* menuitem is part of the menubar */
1546 -  MOZ_TOPLEVEL_MENU_ITEM      = 1 << 0
1547 -} GtkMenuItemFlags;
1548 -
1549  /* function type for moz_gtk_enable_style_props */
1550  typedef gint (*style_prop_t)(GtkStyle*, const gchar*, gint);
1551
1552 @@ -93,6 +87,10 @@ typedef enum {
1553    MOZ_GTK_BUTTON,
1554    /* Paints a button with image and no text */
1555    MOZ_GTK_TOOLBAR_BUTTON,
1556 +  /* Paints a toggle button */
1557 +  MOZ_GTK_TOGGLE_BUTTON,
1558 +  /* Paints a button arrow */
1559 +  MOZ_GTK_BUTTON_ARROW,
1560
1561    /* Paints the container part of a GtkCheckButton. */
1562    MOZ_GTK_CHECKBUTTON_CONTAINER,
1563 @@ -115,6 +113,7 @@ typedef enum {
1564
1565    /* Horizontal GtkScrollbar counterparts */
1566    MOZ_GTK_SCROLLBAR_HORIZONTAL,
1567 +  MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL,
1568    /* Paints the trough (track) of a GtkScrollbar. */
1569    MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL,
1570    /* Paints the slider (thumb) of a GtkScrollbar. */
1571 @@ -122,6 +121,7 @@ typedef enum {
1572
1573    /* Vertical GtkScrollbar counterparts */
1574    MOZ_GTK_SCROLLBAR_VERTICAL,
1575 +  MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL,
1576    MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL,
1577    MOZ_GTK_SCROLLBAR_THUMB_VERTICAL,
1578
1579 @@ -140,6 +140,10 @@ typedef enum {
1580    MOZ_GTK_GRIPPER,
1581    /* Paints a GtkEntry. */
1582    MOZ_GTK_ENTRY,
1583 +  /* Paints a GtkExpander. */
1584 +  MOZ_GTK_EXPANDER,
1585 +  /* Paints a GtkTextView. */
1586 +  MOZ_GTK_TEXT_VIEW,
1587    /* Paints a GtkOptionMenu. */
1588    MOZ_GTK_DROPDOWN,
1589    /* Paints a dropdown arrow (a GtkButton containing a down GtkArrow). */
1590 @@ -159,6 +163,8 @@ typedef enum {
1591    MOZ_GTK_RESIZER,
1592    /* Paints a GtkProgressBar. */
1593    MOZ_GTK_PROGRESSBAR,
1594 +  /* Paints a trough (track) of a GtkProgressBar */
1595 +  MOZ_GTK_PROGRESS_TROUGH,
1596    /* Paints a progress chunk of a GtkProgressBar. */
1597    MOZ_GTK_PROGRESS_CHUNK,
1598    /* Paints a progress chunk of an indeterminated GtkProgressBar. */
1599 @@ -187,7 +193,9 @@ typedef enum {
1600    MOZ_GTK_MENUARROW,
1601    /* Paints an arrow in a toolbar button. flags is a GtkArrowType. */
1602    MOZ_GTK_TOOLBARBUTTON_ARROW,
1603 -  /* Paints items of menubar and popups. */
1604 +  /* Paints items of menubar. */
1605 +  MOZ_GTK_MENUBARITEM,
1606 +  /* Paints items of popup menus. */
1607    MOZ_GTK_MENUITEM,
1608    MOZ_GTK_CHECKMENUITEM,
1609    MOZ_GTK_RADIOMENUITEM,
1610 @@ -202,6 +210,8 @@ typedef enum {
1611    MOZ_GTK_WINDOW_CONTAINER,
1612    /* Paints a GtkInfoBar, for notifications. */
1613    MOZ_GTK_INFO_BAR,
1614 +  /* Used for scrolled window shell. */
1615 +  MOZ_GTK_SCROLLED_WINDOW,
1616
1617    MOZ_GTK_WIDGET_NODE_COUNT
1618  } WidgetNodeType;
1619 diff -up firefox-48.0/widget/gtk/mozgtk/mozgtk.c.gtk3-20 firefox-48.0/widget/gtk/mozgtk/mozgtk.c
1620 --- firefox-48.0/widget/gtk/mozgtk/mozgtk.c.gtk3-20     2016-07-25 22:22:07.000000000 +0200
1621 +++ firefox-48.0/widget/gtk/mozgtk/mozgtk.c     2016-07-29 09:15:11.823285862 +0200
1622 @@ -517,6 +517,7 @@ STUB(gdk_event_get_source_device)
1623  STUB(gdk_window_get_type)
1624  STUB(gdk_x11_window_get_xid)
1625  STUB(gdk_x11_display_get_type)
1626 +STUB(gtk_box_new)
1627  STUB(gtk_cairo_should_draw_window)
1628  STUB(gtk_cairo_transform_to_window)
1629  STUB(gtk_combo_box_text_append)
1630 @@ -570,6 +571,7 @@ STUB(gtk_tree_view_column_get_button)
1631  STUB(gtk_widget_get_preferred_size)
1632  STUB(gtk_widget_get_state_flags)
1633  STUB(gtk_widget_get_style_context)
1634 +STUB(gtk_widget_path_append_for_widget)
1635  STUB(gtk_widget_path_append_type)
1636  STUB(gtk_widget_path_copy)
1637  STUB(gtk_widget_path_free)
1638 @@ -587,6 +589,10 @@ STUB(gtk_color_chooser_get_type)
1639  STUB(gtk_color_chooser_set_rgba)
1640  STUB(gtk_color_chooser_get_rgba)
1641  STUB(gtk_color_chooser_set_use_alpha)
1642 +STUB(gtk_check_menu_item_new)
1643 +STUB(gtk_style_context_get_direction)
1644 +STUB(gtk_style_context_invalidate)
1645 +STUB(gtk_tooltip_get_type)
1646  #endif
1647
1648  #ifdef GTK2_SYMBOLS
1649 diff -up firefox-48.0/widget/gtk/nsLookAndFeel.cpp.gtk3-20 firefox-48.0/widget/gtk/nsLookAndFeel.cpp
1650 --- firefox-48.0/widget/gtk/nsLookAndFeel.cpp.gtk3-20   2016-06-01 06:11:44.000000000 +0200
1651 +++ firefox-48.0/widget/gtk/nsLookAndFeel.cpp   2016-07-29 09:15:54.943459700 +0200
1652 @@ -31,6 +31,7 @@
1653
1654  #if MOZ_WIDGET_GTK != 2
1655  #include <cairo-gobject.h>
1656 +#include "WidgetStyleCache.h"
1657  #endif
1658
1659  using mozilla::LookAndFeel;
1660 @@ -1135,15 +1136,24 @@ nsLookAndFeel::Init()
1661      gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
1662      sMozWindowText = GDK_RGBA_TO_NS_RGBA(color);
1663      gtk_style_context_restore(style);
1664 +    g_object_unref(style);
1665
1666      // tooltip foreground and background
1667 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLTIP);
1668 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_BACKGROUND);
1669 +    style = ClaimStyleContext(MOZ_GTK_TOOLTIP);
1670      gtk_style_context_get_background_color(style, GTK_STATE_FLAG_NORMAL, &color);
1671      sInfoBackground = GDK_RGBA_TO_NS_RGBA(color);
1672 -    gtk_style_context_get_color(style, GTK_STATE_FLAG_NORMAL, &color);
1673 +    {
1674 +        GtkStyleContext* boxStyle =
1675 +            CreateStyleForWidget(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0),
1676 +                                 style);
1677 +        GtkStyleContext* labelStyle =
1678 +            CreateStyleForWidget(gtk_label_new(nullptr), boxStyle);
1679 +        gtk_style_context_get_color(labelStyle, GTK_STATE_FLAG_NORMAL, &color);
1680 +        g_object_unref(labelStyle);
1681 +        g_object_unref(boxStyle);
1682 +    }
1683      sInfoText = GDK_RGBA_TO_NS_RGBA(color);
1684 -    g_object_unref(style);
1685 +    ReleaseStyleContext(style);
1686
1687      // menu foreground & menu background
1688      GtkWidget *accel_label = gtk_accel_label_new("M");
1689 diff -up firefox-48.0/widget/gtk/nsNativeThemeGTK.cpp.gtk3-20 firefox-48.0/widget/gtk/nsNativeThemeGTK.cpp
1690 --- firefox-48.0/widget/gtk/nsNativeThemeGTK.cpp.gtk3-20        2016-07-25 22:22:07.000000000 +0200
1691 +++ firefox-48.0/widget/gtk/nsNativeThemeGTK.cpp        2016-07-29 09:15:11.824285865 +0200
1692 @@ -354,10 +354,8 @@ nsNativeThemeGTK::GetGtkWidgetAndState(u
1693
1694            if (isTopLevel) {
1695              aState->inHover = menuFrame->IsOpen();
1696 -            *aWidgetFlags |= MOZ_TOPLEVEL_MENU_ITEM;
1697            } else {
1698              aState->inHover = CheckBooleanAttr(aFrame, nsGkAtoms::menuactive);
1699 -            *aWidgetFlags &= ~MOZ_TOPLEVEL_MENU_ITEM;
1700            }
1701
1702            aState->active = FALSE;
1703 @@ -510,8 +508,14 @@ nsNativeThemeGTK::GetGtkWidgetAndState(u
1704      break;
1705    case NS_THEME_NUMBER_INPUT:
1706    case NS_THEME_TEXTFIELD:
1707 +    aGtkWidgetType = MOZ_GTK_ENTRY;
1708 +    break;
1709    case NS_THEME_TEXTFIELD_MULTILINE:
1710 +#if (MOZ_WIDGET_GTK == 3)
1711 +    aGtkWidgetType = MOZ_GTK_TEXT_VIEW;
1712 +#else
1713      aGtkWidgetType = MOZ_GTK_ENTRY;
1714 +#endif
1715      break;
1716    case NS_THEME_LISTBOX:
1717    case NS_THEME_TREEVIEW:
1718 @@ -673,6 +677,13 @@ nsNativeThemeGTK::GetGtkWidgetAndState(u
1719      aGtkWidgetType = MOZ_GTK_MENUPOPUP;
1720      break;
1721    case NS_THEME_MENUITEM:
1722 +    {
1723 +      nsMenuFrame *menuFrame = do_QueryFrame(aFrame);
1724 +      if (menuFrame && menuFrame->IsOnMenuBar()) {
1725 +        aGtkWidgetType = MOZ_GTK_MENUBARITEM;
1726 +        break;
1727 +      }
1728 +    }
1729      aGtkWidgetType = MOZ_GTK_MENUITEM;
1730      break;
1731    case NS_THEME_MENUSEPARATOR:
1732 diff -up firefox-48.0/widget/gtk/WidgetStyleCache.cpp.gtk3-20 firefox-48.0/widget/gtk/WidgetStyleCache.cpp
1733 --- firefox-48.0/widget/gtk/WidgetStyleCache.cpp.gtk3-20        2016-07-25 22:22:07.000000000 +0200
1734 +++ firefox-48.0/widget/gtk/WidgetStyleCache.cpp        2016-07-29 09:15:11.825285869 +0200
1735 @@ -22,7 +22,7 @@ static bool sStyleContextNeedsRestore;
1736  static GtkStyleContext* sCurrentStyleContext;
1737  #endif
1738  static GtkStyleContext*
1739 -GetStyleInternal(WidgetNodeType aNodeType);
1740 +GetCssNodeStyleInternal(WidgetNodeType aNodeType);
1741
1742  static GtkWidget*
1743  CreateWindowWidget()
1744 @@ -67,12 +67,175 @@ CreateCheckboxWidget()
1745  static GtkWidget*
1746  CreateRadiobuttonWidget()
1747  {
1748 -  GtkWidget* widget = gtk_radio_button_new_with_label(NULL, "M");
1749 +  GtkWidget* widget = gtk_radio_button_new_with_label(nullptr, "M");
1750    AddToWindowContainer(widget);
1751    return widget;
1752  }
1753
1754  static GtkWidget*
1755 +CreateMenuBarWidget()
1756 +{
1757 +  GtkWidget* widget = gtk_menu_bar_new();
1758 +  AddToWindowContainer(widget);
1759 +  return widget;
1760 +}
1761 +
1762 +static GtkWidget*
1763 +CreateMenuPopupWidget()
1764 +{
1765 +  GtkWidget* widget = gtk_menu_new();
1766 +  gtk_menu_attach_to_widget(GTK_MENU(widget), GetWidget(MOZ_GTK_WINDOW),
1767 +                            nullptr);
1768 +  return widget;
1769 +}
1770 +
1771 +static GtkWidget*
1772 +CreateMenuItemWidget(WidgetNodeType aShellType)
1773 +{
1774 +  GtkWidget* widget = gtk_menu_item_new();
1775 +  gtk_menu_shell_append(GTK_MENU_SHELL(GetWidget(aShellType)), widget);
1776 +  return widget;
1777 +}
1778 +
1779 +static GtkWidget*
1780 +CreateProgressWidget()
1781 +{
1782 +  GtkWidget* widget = gtk_progress_bar_new();
1783 +  AddToWindowContainer(widget);
1784 +  return widget;
1785 +}
1786 +
1787 +static GtkWidget*
1788 +CreateTooltipWidget()
1789 +{
1790 +  MOZ_ASSERT(gtk_check_version(3, 20, 0) != nullptr,
1791 +             "CreateTooltipWidget should be used for Gtk < 3.20 only.");
1792 +  GtkWidget* widget = CreateWindowWidget();
1793 +  GtkStyleContext* style = gtk_widget_get_style_context(widget);
1794 +  gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLTIP);
1795 +  return widget;
1796 +}
1797 +
1798 +static GtkWidget*
1799 +CreateExpanderWidget()
1800 +{
1801 +  GtkWidget* widget = gtk_expander_new("M");
1802 +  AddToWindowContainer(widget);
1803 +  return widget;
1804 +}
1805 +
1806 +static GtkWidget*
1807 +CreateFrameWidget()
1808 +{
1809 +  GtkWidget* widget = gtk_frame_new(nullptr);
1810 +  AddToWindowContainer(widget);
1811 +  return widget;
1812 +}
1813 +
1814 +static GtkWidget*
1815 +CreateGripperWidget()
1816 +{
1817 +  GtkWidget* widget = gtk_handle_box_new();
1818 +  AddToWindowContainer(widget);
1819 +  return widget;
1820 +}
1821 +
1822 +static GtkWidget*
1823 +CreateToolbarWidget()
1824 +{
1825 +  GtkWidget* widget = gtk_toolbar_new();
1826 +  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_GRIPPER)), widget);
1827 +  gtk_widget_realize(widget);
1828 +  return widget;
1829 +}
1830 +
1831 +static GtkWidget*
1832 +CreateToolbarSeparatorWidget()
1833 +{
1834 +  GtkWidget* widget = GTK_WIDGET(gtk_separator_tool_item_new());
1835 +  AddToWindowContainer(widget);
1836 +  return widget;
1837 +}
1838 +
1839 +static GtkWidget*
1840 +CreateInfoBarWidget()
1841 +{
1842 +  GtkWidget* widget = gtk_info_bar_new();
1843 +  AddToWindowContainer(widget);
1844 +  return widget;
1845 +}
1846 +
1847 +static GtkWidget*
1848 +CreateButtonWidget()
1849 +{
1850 +  GtkWidget* widget = gtk_button_new_with_label("M");
1851 +  AddToWindowContainer(widget);
1852 +  return widget;
1853 +}
1854 +
1855 +static GtkWidget*
1856 +CreateToggleButtonWidget()
1857 +{
1858 +  GtkWidget* widget = gtk_toggle_button_new();
1859 +  AddToWindowContainer(widget);
1860 +  return widget;
1861 +}
1862 +
1863 +static GtkWidget*
1864 +CreateButtonArrowWidget()
1865 +{
1866 +  GtkWidget* widget = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
1867 +  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_TOGGLE_BUTTON)), widget);
1868 +  gtk_widget_realize(widget);
1869 +  gtk_widget_show(widget);
1870 +  return widget;
1871 +}
1872 +
1873 +static GtkWidget*
1874 +CreateSpinWidget()
1875 +{
1876 +  GtkWidget* widget = gtk_spin_button_new(nullptr, 1, 0);
1877 +  AddToWindowContainer(widget);
1878 +  return widget;
1879 +}
1880 +
1881 +static GtkWidget*
1882 +CreateEntryWidget()
1883 +{
1884 +  GtkWidget* widget = gtk_entry_new();
1885 +  AddToWindowContainer(widget);
1886 +  return widget;
1887 +}
1888 +
1889 +static GtkWidget*
1890 +CreateScrolledWindowWidget()
1891 +{
1892 +  GtkWidget* widget = gtk_scrolled_window_new(nullptr, nullptr);
1893 +  AddToWindowContainer(widget);
1894 +  return widget;
1895 +}
1896 +
1897 +static GtkWidget*
1898 +CreateTextViewWidget()
1899 +{
1900 +  GtkWidget* widget = gtk_text_view_new();
1901 +  gtk_container_add(GTK_CONTAINER(GetWidget(MOZ_GTK_SCROLLED_WINDOW)),
1902 +                    widget);
1903 +  return widget;
1904 +}
1905 +
1906 +static GtkWidget*
1907 +CreateMenuSeparatorWidget()
1908 +{
1909 +  GtkWidget* widget = gtk_separator_menu_item_new();
1910 +  gtk_menu_shell_append(GTK_MENU_SHELL(GetWidget(MOZ_GTK_MENUPOPUP)),
1911 +                        widget);
1912 +  gtk_widget_realize(widget);
1913 +  return widget;
1914 +}
1915 +
1916 +
1917 +static GtkWidget*
1918  CreateWidget(WidgetNodeType aWidgetType)
1919  {
1920    switch (aWidgetType) {
1921 @@ -80,16 +243,54 @@ CreateWidget(WidgetNodeType aWidgetType)
1922        return CreateWindowWidget();
1923      case MOZ_GTK_WINDOW_CONTAINER:
1924        return CreateWindowContainerWidget();
1925 +    case MOZ_GTK_CHECKBUTTON_CONTAINER:
1926 +      return CreateCheckboxWidget();
1927 +    case MOZ_GTK_PROGRESSBAR:
1928 +      return CreateProgressWidget();
1929 +    case MOZ_GTK_RADIOBUTTON_CONTAINER:
1930 +      return CreateRadiobuttonWidget();
1931      case MOZ_GTK_SCROLLBAR_HORIZONTAL:
1932        return CreateScrollbarWidget(aWidgetType,
1933                                     GTK_ORIENTATION_HORIZONTAL);
1934      case MOZ_GTK_SCROLLBAR_VERTICAL:
1935        return CreateScrollbarWidget(aWidgetType,
1936                                     GTK_ORIENTATION_VERTICAL);
1937 -    case MOZ_GTK_CHECKBUTTON_CONTAINER:
1938 -      return CreateCheckboxWidget();
1939 -    case MOZ_GTK_RADIOBUTTON_CONTAINER:
1940 -      return CreateRadiobuttonWidget();
1941 +    case MOZ_GTK_MENUBAR:
1942 +      return CreateMenuBarWidget();
1943 +    case MOZ_GTK_MENUPOPUP:
1944 +      return CreateMenuPopupWidget();
1945 +    case MOZ_GTK_MENUBARITEM:
1946 +      return CreateMenuItemWidget(MOZ_GTK_MENUBAR);
1947 +    case MOZ_GTK_MENUITEM:
1948 +      return CreateMenuItemWidget(MOZ_GTK_MENUPOPUP);
1949 +    case MOZ_GTK_MENUSEPARATOR:
1950 +      return CreateMenuSeparatorWidget();
1951 +    case MOZ_GTK_EXPANDER:
1952 +      return CreateExpanderWidget();
1953 +    case MOZ_GTK_FRAME:
1954 +      return CreateFrameWidget();
1955 +    case MOZ_GTK_GRIPPER:
1956 +      return CreateGripperWidget();
1957 +    case MOZ_GTK_TOOLBAR:
1958 +      return CreateToolbarWidget();
1959 +    case MOZ_GTK_TOOLBAR_SEPARATOR:
1960 +      return CreateToolbarSeparatorWidget();
1961 +    case MOZ_GTK_INFO_BAR:
1962 +      return CreateInfoBarWidget();
1963 +    case MOZ_GTK_SPINBUTTON:
1964 +      return CreateSpinWidget();
1965 +    case MOZ_GTK_BUTTON:
1966 +      return CreateButtonWidget();
1967 +    case MOZ_GTK_TOGGLE_BUTTON:
1968 +      return CreateToggleButtonWidget();
1969 +    case MOZ_GTK_BUTTON_ARROW:
1970 +      return CreateButtonArrowWidget();
1971 +    case MOZ_GTK_ENTRY:
1972 +      return CreateEntryWidget();
1973 +    case MOZ_GTK_SCROLLED_WINDOW:
1974 +      return CreateScrolledWindowWidget();
1975 +    case MOZ_GTK_TEXT_VIEW:
1976 +      return CreateTextViewWidget();
1977      default:
1978        /* Not implemented */
1979        return nullptr;
1980 @@ -107,17 +308,42 @@ GetWidget(WidgetNodeType aWidgetType)
1981    return widget;
1982  }
1983
1984 -static GtkStyleContext*
1985 -CreateCSSNode(const char* aName, GtkStyleContext *aParentStyle)
1986 +GtkStyleContext*
1987 +CreateStyleForWidget(GtkWidget* aWidget, GtkStyleContext* aParentStyle)
1988 +{
1989 +  GtkWidgetPath* path = aParentStyle ?
1990 +    gtk_widget_path_copy(gtk_style_context_get_path(aParentStyle)) :
1991 +    gtk_widget_path_new();
1992 +
1993 +  // Work around https://bugzilla.gnome.org/show_bug.cgi?id=767312
1994 +  // which exists in GTK+ 3.20.
1995 +  gtk_widget_get_style_context(aWidget);
1996 +
1997 +  gtk_widget_path_append_for_widget(path, aWidget);
1998 +  // Release any floating reference on aWidget.
1999 +  g_object_ref_sink(aWidget);
2000 +  g_object_unref(aWidget);
2001 +
2002 +  GtkStyleContext *context = gtk_style_context_new();
2003 +  gtk_style_context_set_path(context, path);
2004 +  gtk_style_context_set_parent(context, aParentStyle);
2005 +  gtk_widget_path_unref(path);
2006 +
2007 +  return context;
2008 +}
2009 +
2010 +GtkStyleContext*
2011 +CreateCSSNode(const char* aName, GtkStyleContext* aParentStyle, GType aType)
2012  {
2013    static auto sGtkWidgetPathIterSetObjectName =
2014      reinterpret_cast<void (*)(GtkWidgetPath *, gint, const char *)>
2015      (dlsym(RTLD_DEFAULT, "gtk_widget_path_iter_set_object_name"));
2016
2017 -  GtkWidgetPath* path =
2018 -    gtk_widget_path_copy(gtk_style_context_get_path(aParentStyle));
2019 +  GtkWidgetPath* path = aParentStyle ?
2020 +    gtk_widget_path_copy(gtk_style_context_get_path(aParentStyle)) :
2021 +    gtk_widget_path_new();
2022
2023 -  gtk_widget_path_append_type(path, G_TYPE_NONE);
2024 +  gtk_widget_path_append_type(path, aType);
2025
2026    (*sGtkWidgetPathIterSetObjectName)(path, -1, aName);
2027
2028 @@ -130,95 +356,168 @@ CreateCSSNode(const char* aName, GtkStyl
2029  }
2030
2031  static GtkStyleContext*
2032 -GetChildNodeStyle(WidgetNodeType aStyleType,
2033 -                  WidgetNodeType aWidgetType,
2034 -                  const gchar*   aStyleClass,
2035 -                  WidgetNodeType aParentNodeType)
2036 +CreateChildCSSNode(const char* aName, WidgetNodeType aParentNodeType)
2037  {
2038 -  GtkStyleContext* style;
2039 -
2040 -  if (gtk_check_version(3, 20, 0) != nullptr) {
2041 -    style = gtk_widget_get_style_context(sWidgetStorage[aWidgetType]);
2042 -
2043 -    gtk_style_context_save(style);
2044 -    MOZ_ASSERT(!sStyleContextNeedsRestore);
2045 -    sStyleContextNeedsRestore = true;
2046 -
2047 -    gtk_style_context_add_class(style, aStyleClass);
2048 -  }
2049 -  else {
2050 -    style = sStyleStorage[aStyleType];
2051 -    if (!style) {
2052 -      style = CreateCSSNode(aStyleClass, GetStyleInternal(aParentNodeType));
2053 -      MOZ_ASSERT(!sStyleContextNeedsRestore);
2054 -      sStyleStorage[aStyleType] = style;
2055 -    }
2056 -  }
2057 +  return CreateCSSNode(aName, GetCssNodeStyleInternal(aParentNodeType));
2058 +}
2059
2060 +static GtkStyleContext*
2061 +GetWidgetStyleWithClass(WidgetNodeType aWidgetType, const gchar* aStyleClass)
2062 +{
2063 +  GtkStyleContext* style = gtk_widget_get_style_context(GetWidget(aWidgetType));
2064 +  gtk_style_context_save(style);
2065 +  MOZ_ASSERT(!sStyleContextNeedsRestore);
2066 +  sStyleContextNeedsRestore = true;
2067 +  gtk_style_context_add_class(style, aStyleClass);
2068    return style;
2069  }
2070
2071 +/* GetCssNodeStyleInternal is used by Gtk >= 3.20 */
2072  static GtkStyleContext*
2073 -GetStyleInternal(WidgetNodeType aNodeType)
2074 +GetCssNodeStyleInternal(WidgetNodeType aNodeType)
2075  {
2076 +  GtkStyleContext* style = sStyleStorage[aNodeType];
2077 +  if (style)
2078 +    return style;
2079 +
2080    switch (aNodeType) {
2081 -    case MOZ_GTK_SCROLLBAR_HORIZONTAL:
2082 -      /* Root CSS node / widget for scrollbars */
2083 +    case MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL:
2084 +      style = CreateChildCSSNode("contents",
2085 +                                 MOZ_GTK_SCROLLBAR_HORIZONTAL);
2086        break;
2087      case MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL:
2088 -      return GetChildNodeStyle(aNodeType,
2089 -                               MOZ_GTK_SCROLLBAR_HORIZONTAL,
2090 -                               GTK_STYLE_CLASS_TROUGH,
2091 -                               MOZ_GTK_SCROLLBAR_HORIZONTAL);
2092 -
2093 +      style = CreateChildCSSNode(GTK_STYLE_CLASS_TROUGH,
2094 +                                 MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL);
2095 +      break;
2096      case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL:
2097 -      return GetChildNodeStyle(aNodeType,
2098 -                               MOZ_GTK_SCROLLBAR_HORIZONTAL,
2099 -                               GTK_STYLE_CLASS_SLIDER,
2100 -                               MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL);
2101 -
2102 -    case MOZ_GTK_SCROLLBAR_VERTICAL:
2103 -      /* Root CSS node / widget for scrollbars */
2104 +      style = CreateChildCSSNode(GTK_STYLE_CLASS_SLIDER,
2105 +                                 MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL);
2106 +      break;
2107 +    case MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL:
2108 +      style = CreateChildCSSNode("contents",
2109 +                                 MOZ_GTK_SCROLLBAR_VERTICAL);
2110        break;
2111      case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL:
2112 -      return GetChildNodeStyle(aNodeType,
2113 -                               MOZ_GTK_SCROLLBAR_VERTICAL,
2114 -                               GTK_STYLE_CLASS_TROUGH,
2115 -                               MOZ_GTK_SCROLLBAR_VERTICAL);
2116 -
2117 +      style = CreateChildCSSNode(GTK_STYLE_CLASS_TROUGH,
2118 +                                 MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL);
2119 +      break;
2120      case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
2121 -      return GetChildNodeStyle(aNodeType,
2122 -                               MOZ_GTK_SCROLLBAR_VERTICAL,
2123 -                               GTK_STYLE_CLASS_SLIDER,
2124 -                               MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL);
2125 -
2126 -    case MOZ_GTK_RADIOBUTTON_CONTAINER:
2127 -      /* Root CSS node / widget for checkboxes */
2128 +      style = CreateChildCSSNode(GTK_STYLE_CLASS_SLIDER,
2129 +                                 MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL);
2130        break;
2131      case MOZ_GTK_RADIOBUTTON:
2132 -      return GetChildNodeStyle(aNodeType,
2133 -                               MOZ_GTK_RADIOBUTTON_CONTAINER,
2134 -                               GTK_STYLE_CLASS_RADIO,
2135 -                               MOZ_GTK_RADIOBUTTON_CONTAINER);
2136 -    case MOZ_GTK_CHECKBUTTON_CONTAINER:
2137 -      /* Root CSS node / widget for radiobuttons */
2138 +      style = CreateChildCSSNode(GTK_STYLE_CLASS_RADIO,
2139 +                                 MOZ_GTK_RADIOBUTTON_CONTAINER);
2140        break;
2141      case MOZ_GTK_CHECKBUTTON:
2142 -      return GetChildNodeStyle(aNodeType,
2143 -                               MOZ_GTK_CHECKBUTTON_CONTAINER,
2144 -                               GTK_STYLE_CLASS_CHECK,
2145 -                               MOZ_GTK_CHECKBUTTON_CONTAINER);
2146 -    default:
2147 +      style = CreateChildCSSNode(GTK_STYLE_CLASS_CHECK,
2148 +                                 MOZ_GTK_CHECKBUTTON_CONTAINER);
2149 +      break;
2150 +    case MOZ_GTK_PROGRESS_TROUGH:
2151 +      /* Progress bar background (trough) */
2152 +      style = CreateChildCSSNode(GTK_STYLE_CLASS_TROUGH,
2153 +                                 MOZ_GTK_PROGRESSBAR);
2154 +      break;
2155 +    case MOZ_GTK_PROGRESS_CHUNK:
2156 +      style = CreateChildCSSNode("progress",
2157 +                                 MOZ_GTK_PROGRESS_TROUGH);
2158        break;
2159 +    case MOZ_GTK_TOOLTIP:
2160 +      // We create this from the path because GtkTooltipWindow is not public.
2161 +      style = CreateCSSNode("tooltip", nullptr, GTK_TYPE_TOOLTIP);
2162 +      gtk_style_context_add_class(style, GTK_STYLE_CLASS_BACKGROUND);
2163 +      break;
2164 +    case MOZ_GTK_GRIPPER:
2165 +      // TODO - create from CSS node
2166 +      return GetWidgetStyleWithClass(MOZ_GTK_GRIPPER,
2167 +                                     GTK_STYLE_CLASS_GRIP);
2168 +    case MOZ_GTK_INFO_BAR:
2169 +      // TODO - create from CSS node
2170 +      return GetWidgetStyleWithClass(MOZ_GTK_INFO_BAR,
2171 +                                     GTK_STYLE_CLASS_INFO);
2172 +    case MOZ_GTK_SPINBUTTON_ENTRY:
2173 +      // TODO - create from CSS node
2174 +      return GetWidgetStyleWithClass(MOZ_GTK_SPINBUTTON,
2175 +                                     GTK_STYLE_CLASS_ENTRY);
2176 +    case MOZ_GTK_SCROLLED_WINDOW:
2177 +      // TODO - create from CSS node
2178 +      return GetWidgetStyleWithClass(MOZ_GTK_SCROLLED_WINDOW,
2179 +                                     GTK_STYLE_CLASS_FRAME);
2180 +    case MOZ_GTK_TEXT_VIEW:
2181 +      // TODO - create from CSS node
2182 +      return GetWidgetStyleWithClass(MOZ_GTK_TEXT_VIEW,
2183 +                                     GTK_STYLE_CLASS_VIEW);
2184 +    default:
2185 +      // TODO - create style from style path
2186 +      GtkWidget* widget = GetWidget(aNodeType);
2187 +      return gtk_widget_get_style_context(widget);
2188    }
2189
2190 -  GtkWidget* widget = GetWidget(aNodeType);
2191 -  if (widget) {
2192 -    return gtk_widget_get_style_context(widget);
2193 -  }
2194 +  MOZ_ASSERT(style, "missing style context for node type");
2195 +  sStyleStorage[aNodeType] = style;
2196 +  return style;
2197 +}
2198
2199 -  MOZ_ASSERT_UNREACHABLE("missing style context for node type");
2200 -  return nullptr;
2201 +/* GetWidgetStyleInternal is used by Gtk < 3.20 */
2202 +static GtkStyleContext*
2203 +GetWidgetStyleInternal(WidgetNodeType aNodeType)
2204 +{
2205 +  switch (aNodeType) {
2206 +    case MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL:
2207 +      return GetWidgetStyleWithClass(MOZ_GTK_SCROLLBAR_HORIZONTAL,
2208 +                                     GTK_STYLE_CLASS_TROUGH);
2209 +    case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL:
2210 +      return GetWidgetStyleWithClass(MOZ_GTK_SCROLLBAR_HORIZONTAL,
2211 +                                     GTK_STYLE_CLASS_SLIDER);
2212 +    case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL:
2213 +      return GetWidgetStyleWithClass(MOZ_GTK_SCROLLBAR_VERTICAL,
2214 +                                     GTK_STYLE_CLASS_TROUGH);
2215 +    case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
2216 +      return GetWidgetStyleWithClass(MOZ_GTK_SCROLLBAR_VERTICAL,
2217 +                                     GTK_STYLE_CLASS_SLIDER);
2218 +    case MOZ_GTK_RADIOBUTTON:
2219 +      return GetWidgetStyleWithClass(MOZ_GTK_RADIOBUTTON_CONTAINER,
2220 +                                     GTK_STYLE_CLASS_RADIO);
2221 +    case MOZ_GTK_CHECKBUTTON:
2222 +      return GetWidgetStyleWithClass(MOZ_GTK_CHECKBUTTON_CONTAINER,
2223 +                                     GTK_STYLE_CLASS_CHECK);
2224 +    case MOZ_GTK_PROGRESS_TROUGH:
2225 +      return GetWidgetStyleWithClass(MOZ_GTK_PROGRESSBAR,
2226 +                                     GTK_STYLE_CLASS_TROUGH);
2227 +    case MOZ_GTK_TOOLTIP: {
2228 +      GtkStyleContext* style = sStyleStorage[aNodeType];
2229 +      if (style)
2230 +        return style;
2231 +
2232 +      // The tooltip style class is added first in CreateTooltipWidget() so
2233 +      // that gtk_widget_path_append_for_widget() in CreateStyleForWidget()
2234 +      // will find it.
2235 +      GtkWidget* tooltipWindow = CreateTooltipWidget();
2236 +      style = CreateStyleForWidget(tooltipWindow, nullptr);
2237 +      gtk_widget_destroy(tooltipWindow); // Release GtkWindow self-reference.
2238 +      sStyleStorage[aNodeType] = style;
2239 +      return style;
2240 +    }
2241 +    case MOZ_GTK_GRIPPER:
2242 +      return GetWidgetStyleWithClass(MOZ_GTK_GRIPPER,
2243 +                                     GTK_STYLE_CLASS_GRIP);
2244 +    case MOZ_GTK_INFO_BAR:
2245 +      return GetWidgetStyleWithClass(MOZ_GTK_INFO_BAR,
2246 +                                     GTK_STYLE_CLASS_INFO);
2247 +    case MOZ_GTK_SPINBUTTON_ENTRY:
2248 +      return GetWidgetStyleWithClass(MOZ_GTK_SPINBUTTON,
2249 +                                     GTK_STYLE_CLASS_ENTRY);
2250 +    case MOZ_GTK_SCROLLED_WINDOW:
2251 +      return GetWidgetStyleWithClass(MOZ_GTK_SCROLLED_WINDOW,
2252 +                                     GTK_STYLE_CLASS_FRAME);
2253 +    case MOZ_GTK_TEXT_VIEW:
2254 +      return GetWidgetStyleWithClass(MOZ_GTK_TEXT_VIEW,
2255 +                                     GTK_STYLE_CLASS_VIEW);
2256 +    default:
2257 +      GtkWidget* widget = GetWidget(aNodeType);
2258 +      MOZ_ASSERT(widget);
2259 +      return gtk_widget_get_style_context(widget);
2260 +  }
2261  }
2262
2263  void
2264 @@ -245,13 +544,39 @@ ResetWidgetCache(void)
2265
2266  GtkStyleContext*
2267  ClaimStyleContext(WidgetNodeType aNodeType, GtkTextDirection aDirection,
2268 -                  StyleFlags aFlags)
2269 +                  GtkStateFlags aStateFlags, StyleFlags aFlags)
2270  {
2271 -  GtkStyleContext* style = GetStyleInternal(aNodeType);
2272 +  MOZ_ASSERT(!sStyleContextNeedsRestore);
2273 +  GtkStyleContext* style;
2274 +  if (gtk_check_version(3, 20, 0) != nullptr) {
2275 +    style = GetWidgetStyleInternal(aNodeType);
2276 +  } else {
2277 +    style = GetCssNodeStyleInternal(aNodeType);
2278 +  }
2279  #ifdef DEBUG
2280    MOZ_ASSERT(!sCurrentStyleContext);
2281    sCurrentStyleContext = style;
2282  #endif
2283 +  GtkStateFlags oldState = gtk_style_context_get_state(style);
2284 +  GtkTextDirection oldDirection = gtk_style_context_get_direction(style);
2285 +  if (oldState != aStateFlags || oldDirection != aDirection) {
2286 +    // From GTK 3.8, set_state() will overwrite the direction, so set
2287 +    // direction after state.
2288 +    gtk_style_context_set_state(style, aStateFlags);
2289 +    gtk_style_context_set_direction(style, aDirection);
2290 +
2291 +    // This invalidate is necessary for unsaved style contexts from GtkWidgets
2292 +    // in pre-3.18 GTK, because automatic invalidation of such contexts
2293 +    // was delayed until a resize event runs.
2294 +    //
2295 +    // https://bugzilla.mozilla.org/show_bug.cgi?id=1272194#c7
2296 +    //
2297 +    // Avoid calling invalidate on saved contexts to avoid performing
2298 +    // build_properties() (in 3.16 stylecontext.c) unnecessarily early.
2299 +    if (!sStyleContextNeedsRestore) {
2300 +      gtk_style_context_invalidate(style);
2301 +    }
2302 +  }
2303    return style;
2304  }
2305
2306 diff -up firefox-48.0/widget/gtk/WidgetStyleCache.h.gtk3-20 firefox-48.0/widget/gtk/WidgetStyleCache.h
2307 --- firefox-48.0/widget/gtk/WidgetStyleCache.h.gtk3-20  2016-07-25 22:22:07.000000000 +0200
2308 +++ firefox-48.0/widget/gtk/WidgetStyleCache.h  2016-07-29 09:15:11.825285869 +0200
2309 @@ -21,10 +21,24 @@ enum : StyleFlags {
2310  GtkWidget*
2311  GetWidget(WidgetNodeType aNodeType);
2312
2313 +/*
2314 + * Return a new style context based on aWidget, as a child of aParentStyle.
2315 + * If aWidget still has a floating reference, then it is sunk and released.
2316 + */
2317 +GtkStyleContext*
2318 +CreateStyleForWidget(GtkWidget* aWidget, GtkStyleContext* aParentStyle);
2319 +
2320 +// CreateCSSNode is implemented for gtk >= 3.20 only.
2321 +GtkStyleContext*
2322 +CreateCSSNode(const char*      aName,
2323 +              GtkStyleContext* aParentStyle,
2324 +              GType            aType = G_TYPE_NONE);
2325 +
2326  // Callers must call ReleaseStyleContext() on the returned context.
2327  GtkStyleContext*
2328  ClaimStyleContext(WidgetNodeType aNodeType,
2329                    GtkTextDirection aDirection = GTK_TEXT_DIR_LTR,
2330 +                  GtkStateFlags aStateFlags = GTK_STATE_FLAG_NORMAL,
2331                    StyleFlags aFlags = NO_STYLE_FLAGS);
2332  void
2333  ReleaseStyleContext(GtkStyleContext* style);