Fix appearance of task manager border at fractional scale factors.

ui/views/border_unittest.cc

 // Copyright 2016 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/border.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <utility>
@@ skipping 54 matching lines @@
     return std::vector<DrawRectCall>(draw_rect_calls_.begin(),
                                      draw_rect_calls_.end());
   }
 
   // Return calls in sorted order.
   std::vector<DrawRRectCall> draw_rrect_calls() {
     return std::vector<DrawRRectCall>(draw_rrect_calls_.begin(),
                                       draw_rrect_calls_.end());
   }
 
+  const std::vector<SkPaint>& draw_paint_calls() const {
+    return draw_paint_calls_;
+  }
+
+  const SkRect& last_clip_bounds() const { return last_clip_bounds_; }
+
   // SkCanvas overrides:
   void onDrawRect(const SkRect& rect, const SkPaint& paint) override {
     draw_rect_calls_.insert(DrawRectCall(rect, paint));
   }
 
   void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {
     draw_rrect_calls_.insert(DrawRRectCall(rrect, paint));
   }
 
+  void onDrawPaint(const SkPaint& paint) override {
+    draw_paint_calls_.push_back(paint);
+  }
+
+  void onClipRect(const SkRect& rect,
+                  SkClipOp op,
+                  ClipEdgeStyle edge_style) override {
+    last_clip_bounds_ = rect;
+  }
+
  private:
   // Stores all the calls for querying by the test, in sorted order.
   std::set<DrawRectCall> draw_rect_calls_;
   std::set<DrawRRectCall> draw_rrect_calls_;
 
+  // Stores the onDrawPaint calls in chronological order.

[Matt Giuca, 2017/02/22 03:29:09]

I suppose the reason for this being a vector and not a set is that (unlike the
rects we had previously), if we did get more than one draw here we *would* care
about the order?

[Evan Stade, 2017/02/22 16:59:23]

It's hard to hypothesize about what we would want if there were more than one
draw call. A set seemed overkill because then I'd have to think up and implement
some way of sorting SkPaints which is something we don't actually need at this
point.

+  std::vector<SkPaint> draw_paint_calls_;
+  SkRect last_clip_bounds_;
+
   DISALLOW_COPY_AND_ASSIGN(MockCanvas);
 };
 
 // Simple Painter that will be used to test BorderPainter.
 class MockPainter : public views::Painter {
  public:
   MockPainter() {}
 
   // Gets the canvas given to the last call to Paint().
   gfx::Canvas* given_canvas() const { return given_canvas_; }
@@ skipping 49 matching lines @@
   std::unique_ptr<MockCanvas> sk_canvas_;
   std::unique_ptr<gfx::Canvas> canvas_;
 };
 
 TEST_F(BorderTest, NullBorder) {
   std::unique_ptr<Border> border(NullBorder());
   EXPECT_FALSE(border);
 }
 
 TEST_F(BorderTest, SolidBorder) {
-  std::unique_ptr<Border> border(CreateSolidBorder(3, SK_ColorBLUE));
+  const SkColor kBorderColor = SK_ColorMAGENTA;

[Matt Giuca, 2017/02/22 03:29:09]

Any reason to change this to magenta?

(Perhaps just to have different tests drawing different colours to test that it
isn't just hard-coded to BLUE?)

[Evan Stade, 2017/02/22 16:59:23]

no real reason. I guess I thought it was less likely to be used in any real life
scenario.

[Peter Kasting, 2017/02/22 19:07:12]

Choose border color using random number generator?  :)

[Matt Giuca, 2017/02/22 22:36:13]

And choose the expected border color with a 98% chance to be the same as the set
one. A little puzzle for the sheriffs :)

+  std::unique_ptr<Border> border(CreateSolidBorder(3, kBorderColor));
   EXPECT_EQ(gfx::Size(6, 6), border->GetMinimumSize());
   EXPECT_EQ(gfx::Insets(3, 3, 3, 3), border->GetInsets());
   border->Paint(*view_, canvas_.get());
 
-  std::vector<MockCanvas::DrawRectCall> draw_rect_calls =
-      sk_canvas_->draw_rect_calls();
-  ASSERT_EQ(4u, draw_rect_calls.size());
-  EXPECT_EQ(SkRect::MakeLTRB(0, 0, 100, 3), draw_rect_calls[0].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[0].paint.getColor());
-  EXPECT_EQ(SkRect::MakeLTRB(0, 3, 3, 47), draw_rect_calls[1].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[1].paint.getColor());
-  EXPECT_EQ(SkRect::MakeLTRB(0, 47, 100, 50), draw_rect_calls[2].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[2].paint.getColor());
-  EXPECT_EQ(SkRect::MakeLTRB(97, 3, 100, 47), draw_rect_calls[3].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[3].paint.getColor());
+  gfx::Rect bounds = view_->GetLocalBounds();
+  bounds.Inset(border->GetInsets());
 
-  EXPECT_TRUE(sk_canvas_->draw_rrect_calls().empty());
+  ASSERT_EQ(1u, sk_canvas_->draw_paint_calls().size());
+  EXPECT_EQ(kBorderColor, sk_canvas_->draw_paint_calls()[0].getColor());
+  EXPECT_EQ(gfx::RectF(bounds),
+            gfx::SkRectToRectF(sk_canvas_->last_clip_bounds()));
 }
 
 TEST_F(BorderTest, RoundedRectBorder) {
   std::unique_ptr<Border> border(CreateRoundedRectBorder(3, 4, SK_ColorBLUE));
   EXPECT_EQ(gfx::Size(6, 6), border->GetMinimumSize());
   EXPECT_EQ(gfx::Insets(3, 3, 3, 3), border->GetInsets());
   border->Paint(*view_, canvas_.get());
 
   SkRRect expected_rrect;
   expected_rrect.setRectXY(SkRect::MakeLTRB(1.5, 1.5, 98.5, 48.5), 4, 4);
@@ skipping 17 matching lines @@
   EXPECT_EQ(gfx::Size(), border->GetMinimumSize());
   EXPECT_EQ(kInsets, border->GetInsets());
   // Should have no effect.
   border->Paint(*view_, canvas_.get());
 
   std::unique_ptr<Border> border2(CreateEmptyBorder(kInsets));
   EXPECT_EQ(kInsets, border2->GetInsets());
 }
 
 TEST_F(BorderTest, SolidSidedBorder) {
+  const SkColor kBorderColor = SK_ColorMAGENTA;
   const gfx::Insets kInsets(1, 2, 3, 4);
 
   std::unique_ptr<Border> border(
       CreateSolidSidedBorder(kInsets.top(), kInsets.left(), kInsets.bottom(),
-                             kInsets.right(), SK_ColorBLUE));
+                             kInsets.right(), kBorderColor));
   EXPECT_EQ(gfx::Size(6, 4), border->GetMinimumSize());
   EXPECT_EQ(kInsets, border->GetInsets());
   border->Paint(*view_, canvas_.get());
 
-  std::vector<MockCanvas::DrawRectCall> draw_rect_calls =
-      sk_canvas_->draw_rect_calls();
-  ASSERT_EQ(4u, draw_rect_calls.size());
-  EXPECT_EQ(SkRect::MakeLTRB(0, 0, 100, 1), draw_rect_calls[0].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[0].paint.getColor());
-  EXPECT_EQ(SkRect::MakeLTRB(0, 1, 2, 47), draw_rect_calls[1].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[1].paint.getColor());
-  EXPECT_EQ(SkRect::MakeLTRB(0, 47, 100, 50), draw_rect_calls[2].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[2].paint.getColor());
-  EXPECT_EQ(SkRect::MakeLTRB(96, 1, 100, 47), draw_rect_calls[3].rect);
-  EXPECT_EQ(SK_ColorBLUE, draw_rect_calls[3].paint.getColor());
+  gfx::Rect bounds = view_->GetLocalBounds();
+  bounds.Inset(border->GetInsets());
 
-  EXPECT_TRUE(sk_canvas_->draw_rrect_calls().empty());
+  ASSERT_EQ(1u, sk_canvas_->draw_paint_calls().size());
+  EXPECT_EQ(kBorderColor, sk_canvas_->draw_paint_calls()[0].getColor());
+  EXPECT_EQ(gfx::RectF(bounds),
+            gfx::SkRectToRectF(sk_canvas_->last_clip_bounds()));
 }
 
 TEST_F(BorderTest, BorderPainter) {
   const gfx::Insets kInsets(1, 2, 3, 4);
 
   std::unique_ptr<MockPainter> painter(new MockPainter());
   MockPainter* painter_ptr = painter.get();
   std::unique_ptr<Border> border(
       CreateBorderPainter(std::move(painter), kInsets));
   EXPECT_EQ(gfx::Size(60, 40), border->GetMinimumSize());
   EXPECT_EQ(kInsets, border->GetInsets());
 
   border->Paint(*view_, canvas_.get());
 
   // Expect that the Painter was called with our canvas and the view's size.
   EXPECT_EQ(canvas_.get(), painter_ptr->given_canvas());
   EXPECT_EQ(view_->size(), painter_ptr->given_size());
 }
 
 }  // namespace views