Fix error in flex_layout_internal

Method was never implemented.

Change-Id: Ide33c82c110888e0b4075eb7403f2cbb067e524f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1696342
Commit-Queue: Dana Fried <dfried@chromium.org>
Reviewed-by: Bret Sepulveda <bsep@chromium.org>
Cr-Commit-Position: refs/heads/master@{#676226}

ui/views/BUILD.gn

@@ -1042,6 +1042,7 @@ test("views_unittests") {
     "focus/focus_traversal_unittest.cc",
     "layout/box_layout_unittest.cc",
     "layout/fill_layout_unittest.cc",
+    "layout/flex_layout_types_internal_unittest.cc",
     "layout/flex_layout_unittest.cc",
     "layout/grid_layout_unittest.cc",
     "layout/interpolating_layout_manager_unittest.cc",

ui/views/layout/flex_layout_types_internal.cc

@@ -206,6 +206,7 @@ void NormalizedRect::SetRect(int origin_main,
   origin_.SetPoint(origin_main, origin_cross);
   size_.SetSize(size_main, size_cross);
 }
+
 void NormalizedRect::SetByBounds(int origin_main,
                                  int origin_cross,
                                  int max_main,
@@ -214,17 +215,25 @@ void NormalizedRect::SetByBounds(int origin_main,
   size_.SetSize(std::max(0, max_main - origin_main),
                 std::max(0, max_cross - origin_cross));
 }
+
 void NormalizedRect::Inset(const NormalizedInsets& insets) {
   Inset(insets.main_leading(), insets.cross_leading(), insets.main_trailing(),
         insets.cross_trailing());
 }
+
 void NormalizedRect::Inset(int main, int cross) {
   Inset(main, cross, main, cross);
 }
+
 void NormalizedRect::Inset(int main_leading,
                            int cross_leading,
                            int main_trailing,
-                           int cross_trailing) {}
+                           int cross_trailing) {
+  origin_.Offset(main_leading, cross_leading);
+  size_.Enlarge(-(main_leading + main_trailing),
+                -(cross_leading + cross_trailing));
+}
+
 void NormalizedRect::Offset(int main, int cross) {
   origin_.Offset(main, cross);
 }

ui/views/layout/flex_layout_types_internal.h

@@ -9,6 +9,7 @@
 
 #include "base/optional.h"
 #include "ui/views/layout/flex_layout_types.h"
+#include "ui/views/views_export.h"
 
 namespace gfx {
 class Insets;
@@ -23,10 +24,13 @@ class SizeBounds;
 
 namespace internal {
 
+// NOTE: classes in this namespace are marked as VIEWS_EXPORT for unit testing
+// purposes only and should not be used outside the views library.
+
 // Represents a point in layout space - that is, a point on the main and cross
 // axes of the layout (regardless of whether it is vertically or horizontally
 // oriented.
-class NormalizedPoint {
+class VIEWS_EXPORT NormalizedPoint {
  public:
   constexpr NormalizedPoint() = default;
   constexpr NormalizedPoint(int main, int cross) : main_(main), cross_(cross) {}
@@ -54,7 +58,7 @@ class NormalizedPoint {
 // Represents a size in layout space - that is, a size on the main and cross
 // axes of the layout (regardless of whether it is vertically or horizontally
 // oriented.
-class NormalizedSize {
+class VIEWS_EXPORT NormalizedSize {
  public:
   constexpr NormalizedSize() = default;
   constexpr NormalizedSize(int main, int cross) : main_(main), cross_(cross) {}
@@ -88,7 +92,7 @@ class NormalizedSize {
 // Represents insets in layout space - that is, insets on the main and cross
 // axes of the layout (regardless of whether it is vertically or horizontally
 // oriented.
-class NormalizedInsets {
+class VIEWS_EXPORT NormalizedInsets {
  public:
   constexpr NormalizedInsets() = default;
   constexpr explicit NormalizedInsets(int all) : main_(all), cross_(all) {}
@@ -145,7 +149,7 @@ class NormalizedInsets {
 // Represents size bounds in layout space - that is, a set of size bounds using
 // the main and cross axes of the layout (regardless of whether it is vertically
 // or horizontally oriented).
-class NormalizedSizeBounds {
+class VIEWS_EXPORT NormalizedSizeBounds {
  public:
   NormalizedSizeBounds();
   NormalizedSizeBounds(const base::Optional<int>& main,
@@ -176,7 +180,7 @@ class NormalizedSizeBounds {
 // Represents a rectangle in layout space - that is, a rectangle whose
 // dimensions align with the main and cross axis of the layout (regardless of
 // whether the layout is vertically or horizontally oriented).
-class NormalizedRect {
+class VIEWS_EXPORT NormalizedRect {
  public:
   constexpr NormalizedRect() = default;
   constexpr NormalizedRect(const NormalizedPoint& origin,

ui/views/layout/flex_layout_types_internal_unittest.cc

+// Copyright (c) 2018 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/layout/flex_layout_types_internal.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace views {
+namespace internal {
+
+TEST(NormalizedRectTest, Inset_NormalizedInsets) {
+  NormalizedRect rect(1, 2, 10, 11);
+  constexpr NormalizedInsets kInsets(1, 2, 3, 4);
+  rect.Inset(kInsets);
+  EXPECT_EQ(2, rect.origin_main());
+  EXPECT_EQ(4, rect.origin_cross());
+  EXPECT_EQ(6, rect.size_main());
+  EXPECT_EQ(5, rect.size_cross());
+}
+
+TEST(NormalizedRectTest, Inset_FourValue) {
+  NormalizedRect rect(1, 2, 10, 11);
+  rect.Inset(1, 2, 3, 4);
+  EXPECT_EQ(2, rect.origin_main());
+  EXPECT_EQ(4, rect.origin_cross());
+  EXPECT_EQ(6, rect.size_main());
+  EXPECT_EQ(5, rect.size_cross());
+}
+
+TEST(NormalizedRectTest, Inset_TwoValue) {
+  NormalizedRect rect(1, 2, 10, 11);
+  rect.Inset(3, 4);
+  EXPECT_EQ(4, rect.origin_main());
+  EXPECT_EQ(6, rect.origin_cross());
+  EXPECT_EQ(4, rect.size_main());
+  EXPECT_EQ(3, rect.size_cross());
+}
+
+TEST(NormalizedRectTest, Inset_Negative) {
+  NormalizedRect rect(1, 2, 10, 11);
+  rect.Inset(-1, -2, -3, -4);
+  EXPECT_EQ(0, rect.origin_main());
+  EXPECT_EQ(0, rect.origin_cross());
+  EXPECT_EQ(14, rect.size_main());
+  EXPECT_EQ(17, rect.size_cross());
+}
+
+}  // namespace internal
+}  // namespace views