Hardcode scrollbar rendering for Android

cc/hardcoded_scrollbar.cc

Index: cc/hardcoded_scrollbar.cc
diff --git a/cc/hardcoded_scrollbar.cc b/cc/hardcoded_scrollbar.cc
new file mode 100644
index 0000000000000000000000000000000000000000..41ed4798e2606a15667cc4b9523d56e2359c6e6d
--- /dev/null
+++ b/cc/hardcoded_scrollbar.cc
@@ -0,0 +1,181 @@
+// Copyright 2011 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 "cc/hardcoded_scrollbar.h"
+
+#include "cc/layer_impl.h"
+#include "cc/layer_tree_host_impl.h"
+#include "cc/layer_tree_impl.h"
+#include "cc/render_pass.h"
+#include "cc/shared_quad_state.h"
+#include "cc/solid_color_draw_quad.h"
+#include "ui/gfx/rect_conversions.h"
+
+namespace cc {
+
+#if defined(OS_ANDROID)
+
+static const int kScrollbarWidth = 8;
+static const int kScrollbarMargin = 5;
+static const int kFadeoutDelayMs = 300;
+static const int kFadeoutLengthMs = 300;
+
+HardcodedScrollbar::HardcodedScrollbar(LayerTreeHostImpl* layer_tree_host_impl)
+    : layer_tree_host_impl_(layer_tree_host_impl)
+    , opacity_(0)
+    , pinch_in_effect_(false)
+{
+}
+
+void HardcodedScrollbar::Animate(base::TimeTicks monotonic_time)
+{
+  if (!layer_tree_host_impl_->rootScrollLayer())
+    return;
+
+  const base::TimeDelta fadeout_delay =
+      base::TimeDelta::FromMilliseconds(kFadeoutDelayMs);
+  const base::TimeDelta fadeout_length =
+      base::TimeDelta::FromMilliseconds(kFadeoutLengthMs);
+
+  if (pinch_in_effect_)
+    last_awaken_time_ = monotonic_time;
+
+  LayerImpl* scroll_layer = layer_tree_host_impl_->rootScrollLayer();
+  gfx::Vector2dF scroll_offset = scroll_layer->scrollOffset() +
+                                 scroll_layer->scrollDelta();
+
+  if (last_scroll_offset_ != scroll_offset) {
+    last_scroll_offset_ = scroll_offset;
+    last_awaken_time_ = monotonic_time;
+  }
+
+  if (!last_awaken_time_.is_null() &&
+      last_awaken_time_ + fadeout_delay >= monotonic_time)
+    opacity_ = 1;
+  else if (!last_awaken_time_.is_null() &&
+      last_awaken_time_ + fadeout_delay + fadeout_length > monotonic_time) {
+    opacity_ = (last_awaken_time_ + fadeout_delay + fadeout_length -
+                monotonic_time).InMillisecondsF() / kFadeoutLengthMs;
+  } else
+    opacity_ = 0;
+
+  if (opacity_)
+    layer_tree_host_impl_->setNeedsRedraw();
+}
+
+static void PrependRect(QuadList* quad_list,
+                        SharedQuadState* quad_state,
+                        const gfx::Rect& rect,
+                        const SkColor& color)
+{
+  scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+  quad->SetAll(quad_state,
+               rect,
+               gfx::Rect(),
+               rect,
+               true,
+               color);
+  quad_list->insert(quad_list->begin(),
+                    quad.PassAs<DrawQuad>());
+}
+
+static void PrependSmoothEdgedRect(QuadList* quad_list,
+                                   SharedQuadState* quad_state,
+                                   const gfx::Rect& rect,
+                                   const SkColor& color)
+{
+  if (rect.width() < 2 || rect.height() < 2)
+    return;
+
+  SkColor half_color = SkColorSetA(color, SkColorGetA(color) / 2);
+
+  gfx::Rect top_rect(rect.x() + 1, rect.y(), rect.width() - 2, 1);
+  PrependRect(quad_list, quad_state, top_rect, half_color);
+  gfx::Rect left_rect(rect.x(), rect.y() + 1, 1, rect.height() - 2);
+  PrependRect(quad_list, quad_state, left_rect, half_color);
+  gfx::Rect center_rect(rect.x() + 1, rect.y() + 1,
+                        rect.width() - 2, rect.height() - 2);
+  PrependRect(quad_list, quad_state, center_rect, color);
+  gfx::Rect right_rect(rect.right() - 1, rect.y() + 1, 1, rect.height() - 2);
+  PrependRect(quad_list, quad_state, right_rect, half_color);
+  gfx::Rect bottom_rect(rect.x() + 1, rect.bottom() - 1, rect.width() - 2, 1);
+  PrependRect(quad_list, quad_state, bottom_rect, half_color);
+}
+
+void HardcodedScrollbar::PrependQuads(RenderPass* render_pass)
+{

[danakj, 2013/02/05 17:55:02]

{ on previous line

+  if (!opacity_ || !layer_tree_host_impl_->rootScrollLayer())
+    return;
+
+  gfx::Rect screen_rect(layer_tree_host_impl_->deviceViewportSize());
+
+  render_pass->shared_quad_state_list.push_back(SharedQuadState::Create());
+  SharedQuadState* quad_state = render_pass->shared_quad_state_list.back();
+  quad_state->SetAll(gfx::Transform(),
+                     screen_rect,
+                     screen_rect,
+                     false,
+                     opacity_);
+
+  LayerImpl* scroll_layer = layer_tree_host_impl_->rootScrollLayer();
+  gfx::Size scrollable_size =
+      layer_tree_host_impl_->activeTree()->ScrollableSize();
+  gfx::SizeF scrollable_viewport_size =
+      layer_tree_host_impl_->activeTree()->ScrollableViewportSize();
+
+  gfx::RectF normalized_visible_content_rect = ScaleRect(
+      gfx::RectF(gfx::PointF() + last_scroll_offset_, scrollable_viewport_size),
+      1.0 / scrollable_size.width(),
+      1.0 / scrollable_size.height());
+  normalized_visible_content_rect.Intersect(gfx::RectF(0, 0, 1, 1));
+
+  int scrollbar_width = kScrollbarWidth *
+      layer_tree_host_impl_->deviceScaleFactor();
+  int scrollbar_margin = kScrollbarMargin *
+      layer_tree_host_impl_->deviceScaleFactor();
+
+  gfx::Rect thumb_position = ToEnclosingRect(ScaleRect(
+      normalized_visible_content_rect,
+      screen_rect.width() - scrollbar_margin * 4 - scrollbar_width,
+      screen_rect.height() - 2 * scrollbar_margin));
+  thumb_position.Offset(scrollbar_margin, scrollbar_margin);
+
+  gfx::Rect horizontal_scrollbar_rect(
+      thumb_position.x(),
+      screen_rect.bottom() - scrollbar_margin - scrollbar_width,
+      thumb_position.width(),
+      scrollbar_width);
+  PrependSmoothEdgedRect(&render_pass->quad_list, quad_state,
+      horizontal_scrollbar_rect, SkColorSetARGB(128, 128, 128, 128));
+
+  gfx::Rect vertical_scrollbar_rect(
+      screen_rect.right() - scrollbar_margin - scrollbar_width,
+      thumb_position.y(),
+      scrollbar_width,
+      thumb_position.height());
+  PrependSmoothEdgedRect(&render_pass->quad_list, quad_state,
+      vertical_scrollbar_rect, SkColorSetARGB(128, 128, 128, 128));
+}
+
+void HardcodedScrollbar::DidPinchGestureUpdate(base::TimeTicks monotonic_time)
+{
+  pinch_in_effect_ = true;
+  Animate(monotonic_time);
+}
+
+void HardcodedScrollbar::DidPinchGestureEnd(base::TimeTicks monotonic_time)
+{
+  pinch_in_effect_ = false;
+  last_awaken_time_ = monotonic_time;
+  Animate(monotonic_time);
+}
+
+void HardcodedScrollbar::DidUpdateScrollOffset(base::TimeTicks monotonic_time)
+{
+  Animate(monotonic_time);
+}
+
+#endif
+
+}  // namespace cc