Move implementation of linux scrollbars from webkit using new

WebThemeEngine api. Also implement chromeos specific version.

BUG=chromium-os:6857
TEST=Verify that both linux and chromeos scrollbars look right.

Review URL: http://codereview.chromium.org/3618014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@62068 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 577 insertions, 0 deletions

diff --git a/gfx/gfx.gyp b/gfx/gfx.gyp
index ba3d9e6..67cd8c1 100644
--- a/gfx/gfx.gyp
+++ b/gfx/gfx.gyp
@@ -82,6 +82,7 @@
         '../third_party/libpng/libpng.gyp:libpng',
         '../third_party/sqlite/sqlite.gyp:sqlite',
         '../third_party/zlib/zlib.gyp:zlib',
+        'gfx_resources',
       ],
       'sources': [
         'blit.cc',
@@ -167,6 +168,8 @@
             'gtk_native_view_id_manager.h',
             'gtk_util.cc',
             'gtk_util.h',
+            'native_theme_linux.cc',
+            'native_theme_linux.h',
             'native_widget_types_gtk.cc',
           ],
         }],
diff --git a/gfx/native_theme_linux.cc b/gfx/native_theme_linux.cc
new file mode 100644
index 0000000..d23cac4c
--- /dev/null
+++ b/gfx/native_theme_linux.cc
@@ -0,0 +1,399 @@
+// Copyright (c) 2010 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 "gfx/native_theme_linux.h"
+
+#include "base/logging.h"
+#include "gfx/size.h"
+#include "gfx/rect.h"
+
+namespace gfx {
+
+unsigned int NativeThemeLinux::button_length_ = 14;
+unsigned int NativeThemeLinux::scrollbar_width_ = 15;
+unsigned int NativeThemeLinux::thumb_inactive_color_ = 0xf0ebe5;
+unsigned int NativeThemeLinux::thumb_active_color_ = 0xfaf8f5;
+unsigned int NativeThemeLinux::track_color_ = 0xe3ddd8;
+
+#if !defined(OS_CHROMEOS)
+// Chromeos has a different look.
+// static
+NativeThemeLinux* NativeThemeLinux::instance() {
+  // The global NativeThemeLinux instance.
+  static NativeThemeLinux s_native_theme;
+  return &s_native_theme;
+}
+#endif
+
+NativeThemeLinux::NativeThemeLinux() {
+}
+
+NativeThemeLinux::~NativeThemeLinux() {
+}
+
+gfx::Size NativeThemeLinux::GetSize(Part part) const {
+  switch (part) {
+    case kScrollbarDownArrow:
+    case kScrollbarUpArrow:
+      return gfx::Size(scrollbar_width_, button_length_);
+    case kScrollbarLeftArrow:
+    case kScrollbarRightArrow:
+      return gfx::Size(button_length_, scrollbar_width_);
+    case kScrollbarHorizontalThumb:
+      // This matches Firefox on Linux.
+      return gfx::Size(2 * scrollbar_width_, scrollbar_width_);
+    case kScrollbarVerticalThumb:
+      // This matches Firefox on Linux.
+      return gfx::Size(scrollbar_width_, 2 * scrollbar_width_);
+      break;
+    case kScrollbarHorizontalTrack:
+      return gfx::Size(0, scrollbar_width_);
+    case kScrollbarVerticalTrack:
+      return gfx::Size(scrollbar_width_, 0);
+  }
+  return gfx::Size();
+}
+
+void NativeThemeLinux::PaintArrowButton(
+    skia::PlatformCanvas* canvas,
+    const gfx::Rect& rect, Part direction, State state) {
+  int widthMiddle, lengthMiddle;
+  SkPaint paint;
+  if (direction == kScrollbarUpArrow || direction == kScrollbarDownArrow) {
+    widthMiddle = rect.width() / 2 + 1;
+    lengthMiddle = rect.height() / 2 + 1;
+  } else {
+    lengthMiddle = rect.width() / 2 + 1;
+    widthMiddle = rect.height() / 2 + 1;
+  }
+
+  // Calculate button color.
+  SkScalar trackHSV[3];
+  SkColorToHSV(track_color_, trackHSV);
+  SkColor buttonColor = SaturateAndBrighten(trackHSV, 0, 0.2);
+  SkColor backgroundColor = buttonColor;
+  if (state == kPressed) {
+    SkScalar buttonHSV[3];
+    SkColorToHSV(buttonColor, buttonHSV);
+    buttonColor = SaturateAndBrighten(buttonHSV, 0, -0.1);
+  } else if (state == kHover) {
+    SkScalar buttonHSV[3];
+    SkColorToHSV(buttonColor, buttonHSV);
+    buttonColor = SaturateAndBrighten(buttonHSV, 0, 0.05);
+  }
+
+  SkIRect skrect;
+  skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y()
+      + rect.height());
+  // Paint the background (the area visible behind the rounded corners).
+  paint.setColor(backgroundColor);
+  canvas->drawIRect(skrect, paint);
+
+  // Paint the button's outline and fill the middle
+  SkPath outline;
+  switch (direction) {
+    case kScrollbarUpArrow:
+      outline.moveTo(rect.x() + 0.5, rect.y() + rect.height() + 0.5);
+      outline.rLineTo(0, -(rect.height() - 2));
+      outline.rLineTo(2, -2);
+      outline.rLineTo(rect.width() - 5, 0);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(0, rect.height() - 2);
+      break;
+    case kScrollbarDownArrow:
+      outline.moveTo(rect.x() + 0.5, rect.y() - 0.5);
+      outline.rLineTo(0, rect.height() - 2);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(rect.width() - 5, 0);
+      outline.rLineTo(2, -2);
+      outline.rLineTo(0, -(rect.height() - 2));
+      break;
+    case kScrollbarRightArrow:
+      outline.moveTo(rect.x() - 0.5, rect.y() + 0.5);
+      outline.rLineTo(rect.width() - 2, 0);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(0, rect.height() - 5);
+      outline.rLineTo(-2, 2);
+      outline.rLineTo(-(rect.width() - 2), 0);
+      break;
+    case kScrollbarLeftArrow:
+      outline.moveTo(rect.x() + rect.width() + 0.5, rect.y() + 0.5);
+      outline.rLineTo(-(rect.width() - 2), 0);
+      outline.rLineTo(-2, 2);
+      outline.rLineTo(0, rect.height() - 5);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(rect.width() - 2, 0);
+      break;
+    default:
+      break;
+  }
+  outline.close();
+
+  paint.setStyle(SkPaint::kFill_Style);
+  paint.setColor(buttonColor);
+  canvas->drawPath(outline, paint);
+
+  paint.setAntiAlias(true);
+  paint.setStyle(SkPaint::kStroke_Style);
+  SkScalar thumbHSV[3];
+  SkColorToHSV(thumb_inactive_color_, thumbHSV);
+  paint.setColor(OutlineColor(trackHSV, thumbHSV));
+  canvas->drawPath(outline, paint);
+
+  // If the button is disabled or read-only, the arrow is drawn with the
+  // outline color.
+  if (state != kDisabled)
+    paint.setColor(SK_ColorBLACK);
+
+  paint.setAntiAlias(false);
+  paint.setStyle(SkPaint::kFill_Style);
+
+  SkPath path;
+  // The constants in this block of code are hand-tailored to produce good
+  // looking arrows without anti-aliasing.
+  switch (direction) {
+    case kScrollbarUpArrow:
+      path.moveTo(rect.x() + widthMiddle - 4, rect.y() + lengthMiddle + 2);
+      path.rLineTo(7, 0);
+      path.rLineTo(-4, -4);
+      break;
+    case kScrollbarDownArrow:
+      path.moveTo(rect.x() + widthMiddle - 4, rect.y() + lengthMiddle - 3);
+      path.rLineTo(7, 0);
+      path.rLineTo(-4, 4);
+      break;
+    case kScrollbarRightArrow:
+      path.moveTo(rect.x() + lengthMiddle - 3, rect.y() + widthMiddle - 4);
+      path.rLineTo(0, 7);
+      path.rLineTo(4, -4);
+      break;
+    case kScrollbarLeftArrow:
+      path.moveTo(rect.x() + lengthMiddle + 1, rect.y() + widthMiddle - 5);
+      path.rLineTo(0, 9);
+      path.rLineTo(-4, -4);
+      break;
+    default:
+      break;
+  }
+  path.close();
+
+  canvas->drawPath(path, paint);
+}
+
+void NativeThemeLinux::Paint(skia::PlatformCanvas* canvas,
+                             Part part,
+                             State state,
+                             const gfx::Rect& rect,
+                             const ExtraParams& extra) {
+  switch (part) {
+    case kScrollbarDownArrow:
+    case kScrollbarUpArrow:
+    case kScrollbarLeftArrow:
+    case kScrollbarRightArrow:
+      PaintArrowButton(canvas, rect, part, state);
+      break;
+    case kScrollbarHorizontalThumb:
+    case kScrollbarVerticalThumb:
+      PaintThumb(canvas, part, state, rect);
+      break;
+    case kScrollbarHorizontalTrack:
+    case kScrollbarVerticalTrack:
+      PaintTrack(canvas, part, state, extra.scrollbar_track, rect);
+      break;
+  }
+}
+
+void NativeThemeLinux::PaintTrack(skia::PlatformCanvas* canvas,
+                                  Part part,
+                                  State state,
+                                  const ScrollbarTrackExtraParams& extra_params,
+                                  const gfx::Rect& rect) {
+  SkPaint paint;
+  SkIRect skrect;
+
+  skrect.set(rect.x(), rect.y(), rect.right(), rect.bottom());
+  SkScalar track_hsv[3];
+  SkColorToHSV(track_color_, track_hsv);
+  paint.setColor(SaturateAndBrighten(track_hsv, 0, 0));
+  canvas->drawIRect(skrect, paint);
+
+  SkScalar thumb_hsv[3];
+  SkColorToHSV(thumb_inactive_color_, thumb_hsv);
+
+  paint.setColor(OutlineColor(track_hsv, thumb_hsv));
+  DrawBox(canvas, rect, paint);
+}
+
+void NativeThemeLinux::PaintThumb(skia::PlatformCanvas* canvas,
+                                  Part part,
+                                  State state,
+                                  const gfx::Rect& rect) {
+  const bool hovered = state == kHover;
+  const int midx = rect.x() + rect.width() / 2;
+  const int midy = rect.y() + rect.height() / 2;
+  const bool vertical = part == kScrollbarVerticalThumb;
+
+  SkScalar thumb[3];
+  SkColorToHSV(hovered ? thumb_active_color_ : thumb_inactive_color_, thumb);
+
+  SkPaint paint;
+  paint.setColor(SaturateAndBrighten(thumb, 0, 0.02));
+
+  SkIRect skrect;
+  if (vertical)
+    skrect.set(rect.x(), rect.y(), midx + 1, rect.y() + rect.height());
+  else
+    skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), midy + 1);
+
+  canvas->drawIRect(skrect, paint);
+
+  paint.setColor(SaturateAndBrighten(thumb, 0, -0.02));
+
+  if (vertical) {
+    skrect.set(
+        midx + 1, rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
+  } else {
+    skrect.set(
+        rect.x(), midy + 1, rect.x() + rect.width(), rect.y() + rect.height());
+  }
+
+  canvas->drawIRect(skrect, paint);
+
+  SkScalar track[3];
+  SkColorToHSV(track_color_, track);
+  paint.setColor(OutlineColor(track, thumb));
+  DrawBox(canvas, rect, paint);
+
+  if (rect.height() > 10 && rect.width() > 10) {
+    const int grippy_half_width = 2;
+    const int inter_grippy_offset = 3;
+    if (vertical) {
+      DrawHorizLine(canvas,
+                    midx - grippy_half_width,
+                    midx + grippy_half_width,
+                    midy - inter_grippy_offset,
+                    paint);
+      DrawHorizLine(canvas,
+                    midx - grippy_half_width,
+                    midx + grippy_half_width,
+                    midy,
+                    paint);
+      DrawHorizLine(canvas,
+                    midx - grippy_half_width,
+                    midx + grippy_half_width,
+                    midy + inter_grippy_offset,
+                    paint);
+    } else {
+      DrawVertLine(canvas,
+                   midx - inter_grippy_offset,
+                   midy - grippy_half_width,
+                   midy + grippy_half_width,
+                   paint);
+      DrawVertLine(canvas,
+                   midx,
+                   midy - grippy_half_width,
+                   midy + grippy_half_width,
+                   paint);
+      DrawVertLine(canvas,
+                   midx + inter_grippy_offset,
+                   midy - grippy_half_width,
+                   midy + grippy_half_width,
+                   paint);
+    }
+  }
+}
+
+void NativeThemeLinux::DrawVertLine(SkCanvas* canvas,
+                                    int x,
+                                    int y1,
+                                    int y2,
+                                    const SkPaint& paint) const {
+  SkIRect skrect;
+  skrect.set(x, y1, x + 1, y2 + 1);
+  canvas->drawIRect(skrect, paint);
+}
+
+void NativeThemeLinux::DrawHorizLine(SkCanvas* canvas,
+                                     int x1,
+                                     int x2,
+                                     int y,
+                                     const SkPaint& paint) const {
+  SkIRect skrect;
+  skrect.set(x1, y, x2 + 1, y + 1);
+  canvas->drawIRect(skrect, paint);
+}
+
+void NativeThemeLinux::DrawBox(SkCanvas* canvas,
+                               const gfx::Rect& rect,
+                               const SkPaint& paint) const {
+  const int right = rect.x() + rect.width() - 1;
+  const int bottom = rect.y() + rect.height() - 1;
+  DrawHorizLine(canvas, rect.x(), right, rect.y(), paint);
+  DrawVertLine(canvas, right, rect.y(), bottom, paint);
+  DrawHorizLine(canvas, rect.x(), right, bottom, paint);
+  DrawVertLine(canvas, rect.x(), rect.y(), bottom, paint);
+}
+
+SkScalar NativeThemeLinux::Clamp(SkScalar value,
+                                 SkScalar min,
+                                 SkScalar max) const {
+  return std::min(std::max(value, min), max);
+}
+
+SkColor NativeThemeLinux::SaturateAndBrighten(SkScalar* hsv,
+                                              SkScalar saturate_amount,
+                                              SkScalar brighten_amount) const {
+  SkScalar color[3];
+  color[0] = hsv[0];
+  color[1] = Clamp(hsv[1] + saturate_amount, 0.0, 1.0);
+  color[2] = Clamp(hsv[2] + brighten_amount, 0.0, 1.0);
+  return SkHSVToColor(color);
+}
+
+SkColor NativeThemeLinux::OutlineColor(SkScalar* hsv1, SkScalar* hsv2) const {
+  // GTK Theme engines have way too much control over the layout of
+  // the scrollbar. We might be able to more closely approximate its
+  // look-and-feel, if we sent whole images instead of just colors
+  // from the browser to the renderer. But even then, some themes
+  // would just break.
+  //
+  // So, instead, we don't even try to 100% replicate the look of
+  // the native scrollbar. We render our own version, but we make
+  // sure to pick colors that blend in nicely with the system GTK
+  // theme. In most cases, we can just sample a couple of pixels
+  // from the system scrollbar and use those colors to draw our
+  // scrollbar.
+  //
+  // This works fine for the track color and the overall thumb
+  // color. But it fails spectacularly for the outline color used
+  // around the thumb piece.  Not all themes have a clearly defined
+  // outline. For some of them it is partially transparent, and for
+  // others the thickness is very unpredictable.
+  //
+  // So, instead of trying to approximate the system theme, we
+  // instead try to compute a reasonable looking choice based on the
+  // known color of the track and the thumb piece. This is difficult
+  // when trying to deal both with high- and low-contrast themes,
+  // and both with positive and inverted themes.
+  //
+  // The following code has been tested to look OK with all of the
+  // default GTK themes.
+  SkScalar min_diff = Clamp((hsv1[1] + hsv2[1]) * 1.2, 0.2, 0.5);
+  SkScalar diff = Clamp(fabs(hsv1[2] - hsv2[2]) / 2, min_diff, 0.5);
+
+  if (hsv1[2] + hsv2[2] > 1.0)
+    diff = -diff;
+
+  return SaturateAndBrighten(hsv2, -0.2, diff);
+}
+
+void NativeThemeLinux::SetScrollbarColors(unsigned inactive_color,
+                                          unsigned active_color,
+                                          unsigned track_color) const {
+  thumb_inactive_color_ = inactive_color;
+  thumb_active_color_ = active_color;
+  track_color_ = track_color;
+}
+
+}  // namespace gfx
diff --git a/gfx/native_theme_linux.h b/gfx/native_theme_linux.h
new file mode 100644
index 0000000..62a84e9
--- /dev/null
+++ b/gfx/native_theme_linux.h
@@ -0,0 +1,125 @@
+// Copyright (c) 2010 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.
+
+#ifndef GFX_NATIVE_THEME_LINUX_H_
+#define GFX_NATIVE_THEME_LINUX_H_
+
+#include "base/basictypes.h"
+#include "skia/ext/platform_canvas.h"
+
+namespace skia {
+class PlatformCanvas;
+}
+
+namespace gfx {
+class Rect;
+class Size;
+
+// Linux theming API.
+class NativeThemeLinux {
+ public:
+  // Gets our singleton instance.
+  static NativeThemeLinux* instance();
+
+  // The part to be painted / sized.
+  enum Part {
+    kScrollbarDownArrow,
+    kScrollbarLeftArrow,
+    kScrollbarRightArrow,
+    kScrollbarUpArrow,
+    kScrollbarHorizontalThumb,
+    kScrollbarVerticalThumb,
+    kScrollbarHorizontalTrack,
+    kScrollbarVerticalTrack
+  };
+
+  // The state of the part.
+  enum State {
+    kDisabled,
+    kHover,
+    kNormal,
+    kPressed,
+  };
+
+  // Extra data needed to draw scrollbar track correctly.
+  struct ScrollbarTrackExtraParams {
+    int track_x;
+    int track_y;
+    int track_width;
+    int track_height;
+  };
+
+  union ExtraParams {
+    ScrollbarTrackExtraParams scrollbar_track;
+  };
+
+  // Return the size of the part.
+  virtual gfx::Size GetSize(Part part) const;
+  // Paint the part to the canvas.
+  virtual void Paint(skia::PlatformCanvas* canvas,
+                     Part part,
+                     State state,
+                     const gfx::Rect& rect,
+                     const ExtraParams& extra);
+  // Supports theme specific colors.
+  void SetScrollbarColors(unsigned inactive_color,
+                          unsigned active_color,
+                          unsigned track_color) const;
+
+ protected:
+  NativeThemeLinux();
+  virtual ~NativeThemeLinux();
+
+  // Draw the arrow.
+  virtual void PaintArrowButton(
+      skia::PlatformCanvas* gc,
+      const gfx::Rect& rect,
+      Part direction,
+      State state);
+  // Paint the track. Done before the thumb so that it can contain alpha.
+  virtual void PaintTrack(skia::PlatformCanvas* canvas,
+                  Part part,
+                  State state,
+                  const ScrollbarTrackExtraParams& extra_params,
+                  const gfx::Rect& rect);
+  // Draw the thumb over the track.
+  virtual void PaintThumb(skia::PlatformCanvas* canvas,
+                  Part part,
+                  State state,
+                  const gfx::Rect& rect);
+
+ private:
+  void DrawVertLine(SkCanvas* canvas,
+                    int x,
+                    int y1,
+                    int y2,
+                    const SkPaint& paint) const;
+  void DrawHorizLine(SkCanvas* canvas,
+                     int x1,
+                     int x2,
+                     int y,
+                     const SkPaint& paint) const;
+  void DrawBox(SkCanvas* canvas,
+               const gfx::Rect& rect,
+               const SkPaint& paint) const;
+  SkScalar Clamp(SkScalar value,
+                 SkScalar min,
+                 SkScalar max) const;
+  SkColor SaturateAndBrighten(SkScalar* hsv,
+                              SkScalar saturate_amount,
+                              SkScalar brighten_amount) const;
+  SkColor OutlineColor(SkScalar* hsv1, SkScalar* hsv2) const;
+
+  static unsigned int scrollbar_width_;
+  static unsigned int button_length_;
+  static unsigned int thumb_inactive_color_;
+  static unsigned int thumb_active_color_;
+  static unsigned int track_color_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeThemeLinux);
+};
+
+}  // namespace gfx
+
+#endif  // GFX_NATIVE_THEME_LINUX_H_
diff --git a/gfx/skbitmap_operations.cc b/gfx/skbitmap_operations.cc
index b8cec11..6899553 100644
--- a/gfx/skbitmap_operations.cc
+++ b/gfx/skbitmap_operations.cc
@@ -695,3 +695,27 @@ SkBitmap SkBitmapOperations::UnPreMultiply(const SkBitmap& bitmap) {
   opaque_bitmap.setIsOpaque(true);
   return opaque_bitmap;
 }
+
+// static
+SkBitmap SkBitmapOperations::CreateTransposedBtmap(const SkBitmap& image) {
+  DCHECK(image.config() == SkBitmap::kARGB_8888_Config);
+
+  SkAutoLockPixels lock_image(image);
+
+  SkBitmap transposed;
+  transposed.setConfig(
+      SkBitmap::kARGB_8888_Config, image.height(), image.width(), 0);
+  transposed.allocPixels();
+  transposed.eraseARGB(0, 0, 0, 0);
+
+  for (int y = 0; y < image.height(); ++y) {
+    uint32* image_row = image.getAddr32(0, y);
+    for (int x = 0; x < image.width(); ++x) {
+      uint32* dst = transposed.getAddr32(y, x);
+      *dst = image_row[x];
+    }
+  }
+
+  return transposed;
+}
+
diff --git a/gfx/skbitmap_operations.h b/gfx/skbitmap_operations.h
index eb56761..e64c1aa 100644
--- a/gfx/skbitmap_operations.h
+++ b/gfx/skbitmap_operations.h
@@ -89,6 +89,9 @@ class SkBitmapOperations {
   // doesn't expect premultiplied colors.
   static SkBitmap UnPreMultiply(const SkBitmap& bitmap);
 
+  // Transpose the pixels in |bitmap| by swapping x and y.
+  static SkBitmap CreateTransposedBtmap(const SkBitmap& bitmap);
+
  private:
   SkBitmapOperations();  // Class for scoping only.
 
diff --git a/gfx/skbitmap_operations_unittest.cc b/gfx/skbitmap_operations_unittest.cc
index 83b732a0..bcad287 100644
--- a/gfx/skbitmap_operations_unittest.cc
+++ b/gfx/skbitmap_operations_unittest.cc
@@ -492,3 +492,26 @@ TEST(SkBitmapOperationsTest, UnPreMultiply) {
   EXPECT_EQ(0xFF00CC88, *result.getAddr32(0, 1));
   EXPECT_EQ(0x00000000u, *result.getAddr32(1, 1));  // "Division by zero".
 }
+
+TEST(SkBitmapOperationsTest, CreateTransposedBtmap) {
+  SkBitmap input;
+  input.setConfig(SkBitmap::kARGB_8888_Config, 2, 3);
+  input.allocPixels();
+
+  for (int x = 0; x < input.width(); ++x) {
+    for (int y = 0; y < input.height(); ++y) {
+      *input.getAddr32(x, y) = x * input.width() + y;
+    }
+  }
+
+  SkBitmap result = SkBitmapOperations::CreateTransposedBtmap(input);
+  EXPECT_EQ(3, result.width());
+  EXPECT_EQ(2, result.height());
+
+  SkAutoLockPixels lock(result);
+  for (int x = 0; x < input.width(); ++x) {
+    for (int y = 0; y < input.height(); ++y) {
+      EXPECT_EQ(*input.getAddr32(x, y), *result.getAddr32(y, x));
+    }
+  }
+}