Changes look for scrollbars on windows (2)

ui/native_theme/native_theme_base.cc

 // Copyright (c) 2012 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 "ui/native_theme/native_theme_base.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 229 matching lines @@
 }
 
 NativeThemeBase::NativeThemeBase()
     : scrollbar_width_(kDefaultScrollbarWidth),
       scrollbar_button_length_(kDefaultScrollbarButtonLength) {
 }
 
 NativeThemeBase::~NativeThemeBase() {
 }
 
+// static
+scoped_ptr<gfx::Canvas> NativeThemeBase::CreateCanvas(SkCanvas* sk_canvas) {
+  // TODO(pkotwicz): Do something better and don't infer device
+  // scale factor from canvas scale.
+  SkMatrix m = sk_canvas->getTotalMatrix();
+  float device_scale = static_cast<float>(SkScalarAbs(m.getScaleX()));
+  return scoped_ptr<gfx::Canvas>(
+      gfx::Canvas::CreateCanvasWithoutScaling(sk_canvas, device_scale));
+}
+
 void NativeThemeBase::PaintArrowButton(
     SkCanvas* canvas,
     const gfx::Rect& rect, Part direction, State state) const {
-  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.2f);
   SkColor backgroundColor = buttonColor;
   if (state == kPressed) {
     SkScalar buttonHSV[3];
     SkColorToHSV(buttonColor, buttonHSV);
     buttonColor = SaturateAndBrighten(buttonHSV, 0, -0.1f);
@@ skipping 54 matching lines @@
   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);
+  PaintArrow(canvas, rect, direction, GetArrowColor(state));
+}
 
+void NativeThemeBase::PaintArrow(SkCanvas* gc,
+                                 const gfx::Rect& rect,
+                                 Part direction,
+                                 SkColor color) const {
+  int width_middle, length_middle;
+  if (direction == kScrollbarUpArrow || direction == kScrollbarDownArrow) {
+    width_middle = rect.width() / 2 + 1;
+    length_middle = rect.height() / 2 + 1;
+  } else {
+    length_middle = rect.width() / 2 + 1;
+    width_middle = rect.height() / 2 + 1;
+  }
+
+  SkPaint paint;
+  paint.setColor(color);
   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.moveTo(rect.x() + width_middle - 4, rect.y() + length_middle + 2);
       path.rLineTo(7, 0);
       path.rLineTo(-4, -4);
       break;
     case kScrollbarDownArrow:
-      path.moveTo(rect.x() + widthMiddle - 4, rect.y() + lengthMiddle - 3);
+      path.moveTo(rect.x() + width_middle - 4, rect.y() + length_middle - 3);
       path.rLineTo(7, 0);
       path.rLineTo(-4, 4);
       break;
     case kScrollbarRightArrow:
-      path.moveTo(rect.x() + lengthMiddle - 3, rect.y() + widthMiddle - 4);
+      path.moveTo(rect.x() + length_middle - 3, rect.y() + width_middle - 4);
       path.rLineTo(0, 7);
       path.rLineTo(4, -4);
       break;
     case kScrollbarLeftArrow:
-      path.moveTo(rect.x() + lengthMiddle + 1, rect.y() + widthMiddle - 5);
+      path.moveTo(rect.x() + length_middle + 1, rect.y() + width_middle - 5);
       path.rLineTo(0, 9);
       path.rLineTo(-4, -4);
       break;
     default:
       break;
   }
   path.close();
 
-  canvas->drawPath(path, paint);
+  gc->drawPath(path, paint);
 }
 
 void NativeThemeBase::PaintScrollbarTrack(SkCanvas* canvas,
     Part part,
     State state,
     const ScrollbarTrackExtraParams& extra_params,
     const gfx::Rect& rect) const {
   SkPaint paint;
   SkIRect skrect;
 
@@ skipping 608 matching lines @@
   SkRect clip;
   return canvas->getClipBounds(&clip) &&
       clip.intersect(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x + w),
                      SkIntToScalar(y + h));
 }
 
 void NativeThemeBase::DrawImageInt(
     SkCanvas* sk_canvas, const gfx::ImageSkia& image,
     int src_x, int src_y, int src_w, int src_h,
     int dest_x, int dest_y, int dest_w, int dest_h) const {
-  // TODO(pkotwicz): Do something better and don't infer device
-  // scale factor from canvas scale.
-  SkMatrix m = sk_canvas->getTotalMatrix();
-  float device_scale = static_cast<float>(SkScalarAbs(m.getScaleX()));
-  scoped_ptr<gfx::Canvas> canvas(gfx::Canvas::CreateCanvasWithoutScaling(
-      sk_canvas, device_scale));
+  scoped_ptr<gfx::Canvas> canvas(CreateCanvas(sk_canvas));
   canvas->DrawImageInt(image, src_x, src_y, src_w, src_h,
       dest_x, dest_y, dest_w, dest_h, true);
 }
 
 void NativeThemeBase::DrawTiledImage(SkCanvas* sk_canvas,
     const gfx::ImageSkia& image,
     int src_x, int src_y, float tile_scale_x, float tile_scale_y,
     int dest_x, int dest_y, int w, int h) const {
-  // TODO(pkotwicz): Do something better and don't infer device
-  // scale factor from canvas scale.
-  SkMatrix m = sk_canvas->getTotalMatrix();
-  float device_scale = static_cast<float>(SkScalarAbs(m.getScaleX()));
-  scoped_ptr<gfx::Canvas> canvas(gfx::Canvas::CreateCanvasWithoutScaling(
-      sk_canvas, device_scale));
+  scoped_ptr<gfx::Canvas> canvas(CreateCanvas(sk_canvas));
   canvas->TileImageInt(image, src_x, src_y, tile_scale_x,
       tile_scale_y, dest_x, dest_y, w, h);
 }
 
 SkColor NativeThemeBase::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 NativeThemeBase::GetArrowColor(State state) const {
+  if (state != kDisabled)
+    return SK_ColorBLACK;
+
+  SkScalar track_hsv[3];
+  SkColorToHSV(track_color_, track_hsv);
+  SkScalar thumb_hsv[3];
+  SkColorToHSV(thumb_inactive_color_, thumb_hsv);
+  return OutlineColor(track_hsv, thumb_hsv);
+}
+
 void NativeThemeBase::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);
 }
 
@@ skipping 55 matching lines @@
   SkScalar min_diff = Clamp((hsv1[1] + hsv2[1]) * 1.2f, 0.28f, 0.5f);
   SkScalar diff = Clamp(fabs(hsv1[2] - hsv2[2]) / 2, min_diff, 0.5f);
 
   if (hsv1[2] + hsv2[2] > 1.0)
     diff = -diff;
 
   return SaturateAndBrighten(hsv2, -0.2f, diff);
 }
 
 }  // namespace ui