Aura Overlay Scrollbars appear when mouse hovers over scroller edge

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 75 matching lines @@
 namespace content {
 namespace {
 
 bool GetSwitchValueAsInt(const base::CommandLine& command_line,
                          const std::string& switch_string,
                          int min_value,
                          int max_value,
                          int* result) {
   std::string string_value = command_line.GetSwitchValueASCII(switch_string);
   int int_value;
-  if (base::StringToInt(string_value, &int_value) &&
-      int_value >= min_value && int_value <= max_value) {
+  if (base::StringToInt(string_value, &int_value) && int_value >= min_value &&
+      int_value <= max_value) {
     *result = int_value;
     return true;
   } else {
-    LOG(WARNING) << "Failed to parse switch " << switch_string  << ": " <<
-        string_value;
+    LOG(WARNING) << "Failed to parse switch " << switch_string << ": "
+                 << string_value;
     return false;
   }
 }
 
 cc::LayerSelectionBound ConvertWebSelectionBound(
     const WebSelection& web_selection,
     bool is_start) {
   cc::LayerSelectionBound cc_bound;
   if (web_selection.isNone())
     return cc_bound;
@@ skipping 183 matching lines @@
                         std::numeric_limits<int>::max(),
                         &max_untiled_layer_width);
   }
   int max_untiled_layer_height = settings.max_untiled_layer_size.height();
   if (cmd.HasSwitch(switches::kMaxUntiledLayerHeight)) {
     GetSwitchValueAsInt(cmd, switches::kMaxUntiledLayerHeight, 1,
                         std::numeric_limits<int>::max(),
                         &max_untiled_layer_height);
   }
 
-  settings.max_untiled_layer_size = gfx::Size(max_untiled_layer_width,
-                                           max_untiled_layer_height);
+  settings.max_untiled_layer_size =
+      gfx::Size(max_untiled_layer_width, max_untiled_layer_height);
 
   settings.gpu_rasterization_msaa_sample_count =
       compositor_deps->GetGpuRasterizationMSAASampleCount();
   settings.gpu_rasterization_forced =
       compositor_deps->IsGpuRasterizationForced();
   settings.async_worker_context_enabled =
       compositor_deps->IsAsyncWorkerContextEnabled();
 
   settings.can_use_lcd_text = compositor_deps->IsLcdTextEnabled();
   settings.use_distance_field_text =
@@ skipping 61 matching lines @@
   settings.using_synchronous_renderer_compositor = using_synchronous_compositor;
   if (using_synchronous_compositor) {
     // Android WebView uses system scrollbars, so make ours invisible.
     // http://crbug.com/677348: This can't be done using hide_scrollbars
     // setting because supporting -webkit custom scrollbars is still desired
     // on sublayers.
     settings.scrollbar_animator = cc::LayerTreeSettings::NO_ANIMATOR;
     settings.solid_color_scrollbar_color = SK_ColorTRANSPARENT;
   } else {
     settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
-    settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(300);
-    settings.scrollbar_fade_resize_delay =
+    settings.scrollbar_fade_out_delay = base::TimeDelta::FromMilliseconds(300);
+    settings.scrollbar_fade_out_resize_delay =
         base::TimeDelta::FromMilliseconds(2000);
-    settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
+    settings.scrollbar_fade_out_duration =
+        base::TimeDelta::FromMilliseconds(300);
     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
   }
   settings.renderer_settings.highp_threshold_min = 2048;
   // Android WebView handles root layer flings itself.
   settings.ignore_root_layer_flings = using_synchronous_compositor;
   // Memory policy on Android WebView does not depend on whether device is
   // low end, so always use default policy.
   bool use_low_memory_policy =
       base::SysInfo::IsLowEndDevice() && !using_synchronous_compositor;
   if (use_low_memory_policy) {
@@ skipping 15 matching lines @@
   // Webview does not own the surface so should not clear it.
   settings.renderer_settings.should_clear_root_render_pass =
       !using_synchronous_compositor;
 
   // TODO(danakj): Only do this on low end devices.
   settings.create_low_res_tiling = true;
 #else  // defined(OS_ANDROID)
 #if !defined(OS_MACOSX)
   if (ui::IsOverlayScrollbarEnabled()) {
     settings.scrollbar_animator = cc::LayerTreeSettings::AURA_OVERLAY;
-    settings.scrollbar_fade_delay = ui::kOverlayScrollbarFadeOutDelay;
-    settings.scrollbar_fade_resize_delay =
+    settings.scrollbar_fade_in_delay = ui::kOverlayScrollbarFadeInDelay;
+    settings.scrollbar_fade_out_delay = ui::kOverlayScrollbarFadeOutDelay;
+    settings.scrollbar_fade_out_resize_delay =
         ui::kOverlayScrollbarFadeOutDelay;
-    settings.scrollbar_fade_duration =
-        ui::kOverlayScrollbarFadeOutDuration;
+    settings.scrollbar_fade_out_duration = ui::kOverlayScrollbarFadeOutDuration;
     settings.scrollbar_thinning_duration =
         ui::kOverlayScrollbarThinningDuration;
   } else {
     // TODO(bokan): This section is probably unneeded? We don't use scrollbar
     // animations for non overlay scrollbars.
     settings.scrollbar_animator = cc::LayerTreeSettings::ANDROID_OVERLAY;
     settings.solid_color_scrollbar_color = SkColorSetARGB(128, 128, 128, 128);
-    settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(500);
-    settings.scrollbar_fade_resize_delay =
+    settings.scrollbar_fade_out_delay = base::TimeDelta::FromMilliseconds(500);
+    settings.scrollbar_fade_out_resize_delay =
         base::TimeDelta::FromMilliseconds(500);
-    settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
+    settings.scrollbar_fade_out_duration =
+        base::TimeDelta::FromMilliseconds(300);
   }
 #endif  // !defined(OS_MACOSX)
 
   // On desktop, if there's over 4GB of memory on the machine, increase the
   // image decode budget to 256MB for both gpu and software.
   const int kImageDecodeMemoryThresholdMB = 4 * 1024;
   if (base::SysInfo::AmountOfPhysicalMemoryMB() >=
       kImageDecodeMemoryThresholdMB) {
     settings.gpu_decoded_image_budget_bytes = 256 * 1024 * 1024;
     settings.software_decoded_image_budget_bytes = 256 * 1024 * 1024;
@@ skipping 232 matching lines @@
 }
 
 void RenderWidgetCompositor::setVisible(bool visible) {
   if (never_visible_)
     return;
 
   layer_tree_host_->SetVisible(visible);
 }
 
 void RenderWidgetCompositor::setPageScaleFactorAndLimits(
-    float page_scale_factor, float minimum, float maximum) {
+    float page_scale_factor,
+    float minimum,
+    float maximum) {
   layer_tree_host_->SetPageScaleFactorAndLimits(page_scale_factor, minimum,
                                                 maximum);
 }
 
 void RenderWidgetCompositor::startPageScaleAnimation(
     const blink::WebPoint& destination,
     bool use_anchor,
     float new_page_scale,
     double duration_sec) {
   base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
@@ skipping 28 matching lines @@
     const blink::WebLayer* overscrollElasticityLayer,
     const blink::WebLayer* pageScaleLayer,
     const blink::WebLayer* innerViewportScrollLayer,
     const blink::WebLayer* outerViewportScrollLayer) {
   layer_tree_host_->RegisterViewportLayers(
       // TODO(bokan): This check can probably be removed now, but it looks
       // like overscroll elasticity may still be NULL until VisualViewport
       // registers its layers.
       // The scroll elasticity layer will only exist when using pinch virtual
       // viewports.
-      overscrollElasticityLayer
-          ? static_cast<const cc_blink::WebLayerImpl*>(
-                overscrollElasticityLayer)
-                ->layer()
-          : NULL,
+      overscrollElasticityLayer ? static_cast<const cc_blink::WebLayerImpl*>(
+                                      overscrollElasticityLayer)
+                                      ->layer()
+                                : NULL,
       static_cast<const cc_blink::WebLayerImpl*>(pageScaleLayer)->layer(),
       static_cast<const cc_blink::WebLayerImpl*>(innerViewportScrollLayer)
           ->layer(),
       // TODO(bokan): This check can probably be removed now, but it looks
       // like overscroll elasticity may still be NULL until VisualViewport
       // registers its layers.
       // The outer viewport layer will only exist when using pinch virtual
       // viewports.
       outerViewportScrollLayer
           ? static_cast<const cc_blink::WebLayerImpl*>(outerViewportScrollLayer)
@@ skipping 242 matching lines @@
 }
 
 void RenderWidgetCompositor::setBottomControlsHeight(float height) {
   layer_tree_host_->SetBottomControlsHeight(height);
 }
 
 void RenderWidgetCompositor::WillBeginMainFrame() {
   delegate_->WillBeginCompositorFrame();
 }
 
-void RenderWidgetCompositor::DidBeginMainFrame() {
-}
+void RenderWidgetCompositor::DidBeginMainFrame() {}
 
 void RenderWidgetCompositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
   compositor_deps_->GetRendererScheduler()->WillBeginFrame(args);
   double frame_time_sec = (args.frame_time - base::TimeTicks()).InSecondsF();
   delegate_->BeginMainFrame(frame_time_sec);
 }
 
 void RenderWidgetCompositor::BeginMainFrameNotExpectedSoon() {
   compositor_deps_->GetRendererScheduler()->BeginFrameNotExpectedSoon();
 }
@@ skipping 79 matching lines @@
 void RenderWidgetCompositor::DidSubmitCompositorFrame() {}
 
 void RenderWidgetCompositor::DidLoseCompositorFrameSink() {}
 
 void RenderWidgetCompositor::SetFrameSinkId(
     const cc::FrameSinkId& frame_sink_id) {
   frame_sink_id_ = frame_sink_id;
   layer_tree_host_->SetFrameSinkId(frame_sink_id);
 }
 
-void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
-    float device_scale) {
+void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(float device_scale) {
   layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::SetDeviceColorSpace(
     const gfx::ColorSpace& color_space) {
   layer_tree_host_->SetDeviceColorSpace(color_space);
 }
 
 void RenderWidgetCompositor::SetIsForOopif(bool is_for_oopif) {
   is_for_oopif_ = is_for_oopif;
 }
 
 }  // namespace content