Harmony - manually draw combobox arrows.

ui/views/controls/combobox/combobox.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/views/controls/combobox/combobox.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 388 matching lines @@
       size_to_largest_label_(style_ == STYLE_NORMAL),
       weak_ptr_factory_(this) {
   ModelChanged();
 #if defined(OS_MACOSX)
   SetFocusBehavior(FocusBehavior::ACCESSIBLE_ONLY);
 #else
   SetFocusBehavior(FocusBehavior::ALWAYS);
 #endif
 
   UpdateBorder();
-  arrow_image_ = PlatformStyle::CreateComboboxArrow(enabled(), style);
   // set_background() takes ownership but takes a raw pointer.
   std::unique_ptr<Background> b =
       PlatformStyle::CreateComboboxBackground(GetArrowContainerWidth());
   set_background(b.release());
 
   // Initialize the button images.
   Button::ButtonState button_states[] = {
     Button::STATE_DISABLED,
     Button::STATE_NORMAL,
     Button::STATE_HOVERED,
     Button::STATE_PRESSED,
   };
   for (int i = 0; i < 2; i++) {
     for (size_t state_index = 0; state_index < arraysize(button_states);
          state_index++) {
       Button::ButtonState state = button_states[state_index];
       size_t num;
       bool focused = !!i;
       const int* ids = GetBodyButtonImageIds(focused, state, &num);
       body_button_painters_[focused][state].reset(
           Painter::CreateImageGridPainter(ids));
       menu_button_images_[focused][state] = GetMenuButtonImages(focused, state);
     }
   }
 
   text_button_->SetVisible(true);
   arrow_button_->SetVisible(true);
   AddChildView(text_button_);
   AddChildView(arrow_button_);
+
+  // A layer is applied to make sure that canvas bounds are snapped to pixel

[sky, 2016/09/06 23:20:41]

ugh!

+  // boundaries (for the sake of drawing the arrow).
+  if (UseMd()) {
+    SetPaintToLayer(true);
+    layer()->SetFillsBoundsOpaquely(false);
+  } else {
+    arrow_image_ = PlatformStyle::CreateComboboxArrow(enabled(), style);
+  }
 }
 
 Combobox::~Combobox() {
   if (GetInputMethod() && selector_.get()) {
     // Combobox should have been blurred before destroy.
     DCHECK(selector_.get() != GetInputMethod()->GetTextInputClient());
   }
 }
 
 // static
@@ skipping 332 matching lines @@
   gfx::Rect text_bounds(x, y, text_width, text_height);
   AdjustBoundsForRTLUI(&text_bounds);
   canvas->DrawStringRect(text, font_list, text_color, text_bounds);
 
   gfx::Rect arrow_bounds(disclosure_arrow_offset, 0, GetArrowContainerWidth(),
                          height());
   arrow_bounds =
       PositionArrowWithinContainer(arrow_bounds, ArrowSize(), style_);
   AdjustBoundsForRTLUI(&arrow_bounds);
 
-  canvas->DrawImageInt(arrow_image_, arrow_bounds.x(), arrow_bounds.y());
+  if (UseMd()) {
+    // Since this is a core piece of UI and vector icons don't handle fractional
+    // scale factors particularly well, manually draw an arrow and make sure it
+    // looks good at all scale factors.
+    float dsf = canvas->UndoDeviceScaleFactor();
+    SkScalar x = std::ceil(arrow_bounds.x() * dsf);
+    SkScalar y = std::ceil(arrow_bounds.y() * dsf);
+    SkScalar height = std::floor(arrow_bounds.height() * dsf);
+    SkPath path;
+    // This epsilon makes sure that all the aliasing pixels are slightly more
+    // than half full. Otherwise, rounding issues cause some to be considered
+    // slightly less than half full and come out a little lighter.
+    const SkScalar kEpsilon = 0.0001f;
+    path.moveTo(x - kEpsilon, y);
+    path.rLineTo(height, height);
+    path.rLineTo(2 * kEpsilon, 0);
+    path.rLineTo(height, -height);
+    path.close();
+    SkPaint paint;
+    paint.setColor(GetNativeTheme()->GetSystemColor(
+        ui::NativeTheme::kColorId_ButtonEnabledColor));
+    paint.setAntiAlias(true);
+    canvas->DrawPath(path, paint);
+  } else {
+    canvas->DrawImageInt(arrow_image_, arrow_bounds.x(), arrow_bounds.y());
+  }
 }
 
 void Combobox::PaintButtons(gfx::Canvas* canvas) {
   DCHECK(style_ == STYLE_ACTION);
 
   gfx::ScopedRTLFlipCanvas scoped_canvas(canvas, width());
 
   bool focused = HasFocus();
   const std::vector<const gfx::ImageSkia*>& arrow_button_images =
       menu_button_images_[focused][
@@ skipping 100 matching lines @@
   // This combobox may be deleted by the listener.
   base::WeakPtr<Combobox> weak_ptr = weak_ptr_factory_.GetWeakPtr();
   if (listener_)
     listener_->OnPerformAction(this);
 
   if (weak_ptr && style_ == STYLE_ACTION)
     selected_index_ = 0;
 }
 
 gfx::Size Combobox::ArrowSize() const {
-  return arrow_image_.size();
+  return UseMd() ? gfx::Size(8, 4) : arrow_image_.size();
 }
 
 gfx::Size Combobox::GetContentSize() const {
   const gfx::FontList& font_list = GetFontList();
 
   int width = 0;
   for (int i = 0; i < model()->GetItemCount(); ++i) {
     if (model_->IsItemSeparatorAt(i))
       continue;
 
@@ skipping 12 matching lines @@
 }
 
 int Combobox::GetArrowContainerWidth() const {
   int padding = style_ == STYLE_NORMAL
                     ? PlatformStyle::kComboboxNormalArrowPadding * 2
                     : kActionLeftPadding + kActionRightPadding;
   return ArrowSize().width() + padding;
 }
 
 }  // namespace views