Fixing the dynamic positioning (move with anchor) for the app launcher

ui/views/bubble/bubble_delegate_unittest.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 "base/run_loop.h"
 #include "ui/base/hit_test.h"
 #include "ui/views/bubble/bubble_delegate.h"
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/test/test_widget_observer.h"
 #include "ui/views/test/views_test_base.h"
@@ skipping 16 matching lines @@
     view_->set_focusable(true);
     AddChildView(view_);
   }
   virtual ~TestBubbleDelegateView() {}
 
   // BubbleDelegateView overrides:
   virtual View* GetInitiallyFocusedView() OVERRIDE { return view_; }
   virtual gfx::Size GetPreferredSize() OVERRIDE { return gfx::Size(200, 200); }
   virtual int GetFadeDuration() OVERRIDE { return 1; }
 
+  // Accessors for the protected anchor functionality - avoiding making them

[msw, 2013/09/06 16:32:00]

nit: make the test a friend instead of wrapping these accessors.

[Mr4D (OOO till 08-26), 2013/09/06 17:57:31]

I was trying to not touch the class and instead add what is needed here. It
feels much cleaner to let tests change what they need in their realm then
changing class declarations for production code. But due to your other change
request this isn't necessary anyways. Removed.

[msw, 2013/09/06 18:18:41]

Moot, but I hoped you could add that friend test decl here (test code).

+  // public.
+  void set_anchor_view_for_test(View* anchor_view) {
+    set_anchor_view(anchor_view);
+  }
+  void set_anchor_rect_for_test(const gfx::Rect& rect) {
+    set_anchor_rect(rect);
+  }
+  void set_anchor_offset_for_test(const gfx::Point& offset) {
+    set_anchor_offset(offset);
+  }
+
  private:
   View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(TestBubbleDelegateView);
 };
 
 class BubbleDelegateTest : public ViewsTestBase {
  public:
   BubbleDelegateTest() {}
   virtual ~BubbleDelegateTest() {}
@@ skipping 97 matching lines @@
   //            aura::test::TestActivationClient::OnWindowDestroyed().
   scoped_ptr<Widget> smoke_and_mirrors_widget(CreateTestWidget());
   EXPECT_FALSE(bubble_observer.widget_closed());
 #endif
 
   // Ensure that closing the parent widget also closes the bubble itself.
   parent_widget->CloseNow();
   EXPECT_TRUE(bubble_observer.widget_closed());
 }
 
+TEST_F(BubbleDelegateTest, OffsetAnchorCoordinates) {
+  scoped_ptr<Widget> anchor_widget(CreateTestWidget());
+  TestBubbleDelegateView* bubble_delegate = new TestBubbleDelegateView(
+      anchor_widget->GetContentsView());
+
+  // If no anchor is given the provided anchor rectangle should get returned and
+  // the offset should get ignored.
+  bubble_delegate->set_anchor_offset_for_test(gfx::Point(20, 20));
+  bubble_delegate->set_anchor_view_for_test(NULL);
+  gfx::Rect static_anchor_rect(20, 20, 30, 30);
+  bubble_delegate->set_anchor_rect_for_test(static_anchor_rect);
+  EXPECT_EQ(static_anchor_rect.ToString(),

[msw, 2013/09/06 16:32:00]

Doesn't Rect have an equality operator? Why do you need ToString? Ditto below.

[Mr4D (OOO till 08-26), 2013/09/06 17:57:31]

Yes, it does - but when you get a failure it also tells you what is and what is
expected which is much more helpful then only "it failed".

[msw, 2013/09/06 18:18:41]

Moot, but EXPECT_EQ does actually output mismatching rect values, albeit it's
not printed very pretty. I just ran a quick experiment:

  const gfx::Rect expected_rect(1, 2, 3, 4);
  const gfx::Rect actual_rect(5, 6, 7, 8);
  EXPECT_EQ(expected_rect, actual_rect);

That outputs: ..._unittest.cc(160): error: Value of: actual_rect
  Actual: 16-byte object <05-00 00-00 06-00 00-00 07-00 00-00 08-00 00-00>
Expected: expected_rect
Which is: 16-byte object <01-00 00-00 02-00 00-00 03-00 00-00 04-00 00-00>

+            bubble_delegate->GetAnchorRect().ToString());
+  bubble_delegate->set_anchor_offset_for_test(gfx::Point(0, 0));
+  EXPECT_EQ(static_anchor_rect.ToString(),
+            bubble_delegate->GetAnchorRect().ToString());
+
+  // If an anchor view is provided, its coordinates should get returned.
+  gfx::Rect widget_bounds(
+      anchor_widget->GetContentsView()->GetBoundsInScreen());
+  bubble_delegate->set_anchor_view_for_test(anchor_widget->GetContentsView());
+  EXPECT_EQ(widget_bounds.ToString(),
+            bubble_delegate->GetAnchorRect().ToString());
+
+  // If the offset is provided, it should get added to the bounds of the widget.
+  bubble_delegate->set_anchor_offset_for_test(gfx::Point(20, 20));
+  EXPECT_EQ(gfx::Rect(widget_bounds.x() + 20,
+                      widget_bounds.y() + 20,
+                      widget_bounds.width(),
+                      widget_bounds.height()).ToString(),
+            bubble_delegate->GetAnchorRect().ToString());
+}
+
 TEST_F(BubbleDelegateTest, InitiallyFocusedView) {
   scoped_ptr<Widget> anchor_widget(CreateTestWidget());
   BubbleDelegateView* bubble_delegate = new BubbleDelegateView(
       anchor_widget->GetContentsView(), BubbleBorder::NONE);
   Widget* bubble_widget = BubbleDelegateView::CreateBubble(bubble_delegate);
   EXPECT_EQ(bubble_delegate->GetInitiallyFocusedView(),
             bubble_widget->GetFocusManager()->GetFocusedView());
   bubble_widget->CloseNow();
 }
 
@@ skipping 75 matching lines @@
             bubble_widget->GetFocusManager()->GetFocusedView());
 
   Observe(bubble_widget);
 
   bubble_delegate->StartFade(false);
   RunNestedLoop();
   EXPECT_TRUE(bubble_destroyed());
 }
 
 }  // namespace views