Call ScrollableArea::ShowOverlayScrollbars for explicit scrolls only.

third_party/WebKit/Source/platform/scroll/Scrollbar.cpp

 /*
  * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 526 matching lines @@
   if (scrollable_area_)
     scrollable_area_->SetScrollbarsHidden(hidden);
 }
 
 void Scrollbar::SetEnabled(bool e) {
   if (enabled_ == e)
     return;
   enabled_ = e;
   GetTheme().UpdateEnabledState(*this);
 
-  ScrollbarPart invalid_parts = GetTheme().InvalidateOnEnabledChange();
-  SetNeedsPaintInvalidation(invalid_parts);
+  // We can skip thumb/track repaint when hiding an overlay scrollbar, but not
+  // when showing (since the proportions may have changed while hidden).
+  bool skipPartsRepaint = IsOverlayScrollbar() && scrollable_area_ &&
+                          scrollable_area_->ScrollbarsHidden();
+  SetNeedsPaintInvalidation(skipPartsRepaint ? kNoPart : kAllParts);

[bokan, 2017/04/25 23:21:17]

On the CC side (for Aura anyway) we only need to paint once since we draw a 9
patch resource. This will cause us to upload a new texture to CC everytime we
fade in, right? Though, maybe that's ok for now - I can't think of a way to keep
the main thread and impl sides working in a clean way.

[skobes, 2017/04/26 01:28:58]

I think ideally we would not repurpose the enabled state for hiding.  The
problem is that painting while hidden stores a blank thumb resource, since
ScrollbarThemeOverlay::PaintThumb passes kStateDisabled.

If we made the part-repaints from cc ignore the hidden state (i.e. paint
resource as if visible) we could probably avoid the invalidations here and in
SetProportion.

[bokan, 2017/04/26 11:51:09]

It's an unfortunate quirk of main-thread painting that it reuses enabled state
for hiding/showing overlays. The CC side hides using opacity without requiring a
repaint but if the main thread invalidates it we'll repaint on the next update.
Unfortunately, we have to disable the scrollbar from CC while its hidden so this
will cause us to repaint on fade in. 

 }
 
 int Scrollbar::ScrollbarThickness() const {
   int thickness = Orientation() == kHorizontalScrollbar ? Height() : Width();
   if (!thickness || !chrome_client_)
     return thickness;
   return chrome_client_->WindowToViewportScalar(theme_scrollbar_thickness_);
 }
 
 bool Scrollbar::IsOverlayScrollbar() const {
@@ skipping 75 matching lines @@
     invalid_parts = kAllParts;
   if (invalid_parts & ~kThumbPart)
     track_needs_repaint_ = true;
   if (invalid_parts & kThumbPart)
     thumb_needs_repaint_ = true;
   if (scrollable_area_)
     scrollable_area_->SetScrollbarNeedsPaintInvalidation(Orientation());
 }
 
 }  // namespace blink