Reduce views::Border creation verbosity by promoting factory functions

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 132 matching lines @@
     view_.reset();
   }
 
  protected:
   std::unique_ptr<views::View> view_;
   sk_sp<MockCanvas> sk_canvas_;
   std::unique_ptr<gfx::Canvas> canvas_;
 };
 
 TEST_F(BorderTest, NullBorder) {
-  std::unique_ptr<Border> border(Border::NullBorder());
+  std::unique_ptr<Border> border(NullBorder());
   EXPECT_FALSE(border);
 }
 
 TEST_F(BorderTest, SolidBorder) {
-  std::unique_ptr<Border> border(Border::CreateSolidBorder(3, SK_ColorBLUE));
+  std::unique_ptr<Border> border(CreateSolidBorder(3, 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());
 
   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());
 
   EXPECT_TRUE(sk_canvas_->draw_rrect_calls().empty());
 }
 
 TEST_F(BorderTest, RoundedRectBorder) {
-  std::unique_ptr<Border> border(
-      Border::CreateRoundedRectBorder(3, 4, SK_ColorBLUE));
+  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);
   EXPECT_TRUE(sk_canvas_->draw_rect_calls().empty());
   std::vector<MockCanvas::DrawRRectCall> draw_rrect_calls =
       sk_canvas_->draw_rrect_calls();
   ASSERT_EQ(1u, draw_rrect_calls.size());
   EXPECT_EQ(expected_rrect, draw_rrect_calls[0].rrect);
   EXPECT_EQ(3, draw_rrect_calls[0].paint.getStrokeWidth());
   EXPECT_EQ(SK_ColorBLUE, draw_rrect_calls[0].paint.getColor());
   EXPECT_EQ(SkPaint::kStroke_Style, draw_rrect_calls[0].paint.getStyle());
   EXPECT_TRUE(draw_rrect_calls[0].paint.isAntiAlias());
 }
 
 TEST_F(BorderTest, EmptyBorder) {
   const gfx::Insets kInsets(1, 2, 3, 4);
 
-  std::unique_ptr<Border> border(Border::CreateEmptyBorder(
+  std::unique_ptr<Border> border(CreateEmptyBorder(
       kInsets.top(), kInsets.left(), kInsets.bottom(), kInsets.right()));
   // The EmptyBorder has no minimum size despite nonzero insets.
   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(Border::CreateEmptyBorder(kInsets));
+  std::unique_ptr<Border> border2(CreateEmptyBorder(kInsets));
   EXPECT_EQ(kInsets, border2->GetInsets());
 }
 
 TEST_F(BorderTest, SolidSidedBorder) {
   const gfx::Insets kInsets(1, 2, 3, 4);
 
-  std::unique_ptr<Border> border(Border::CreateSolidSidedBorder(
-      kInsets.top(), kInsets.left(), kInsets.bottom(), kInsets.right(),
-      SK_ColorBLUE));
+  std::unique_ptr<Border> border(
+      CreateSolidSidedBorder(kInsets.top(), kInsets.left(), kInsets.bottom(),
+                             kInsets.right(), SK_ColorBLUE));
   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());
 
   EXPECT_TRUE(sk_canvas_->draw_rrect_calls().empty());
 }
 
 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(
-      Border::CreateBorderPainter(std::move(painter), kInsets));
+      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