Change the GetSelectedTab method of the NativeTabbedPaneView to return the tab contents.

ui/views/controls/tabbed_pane/tabbed_pane_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/message_loop.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/views/controls/tabbed_pane/tabbed_pane.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace views {
 
 // A view for testing that takes a fixed preferred size upon construction.
 class FixedSizeView : public View {
  public:
   explicit FixedSizeView(const gfx::Size& size)
     : size_(size) {}
 
   // Overridden from View:
   virtual gfx::Size GetPreferredSize() OVERRIDE {
     return size_;
   }
 
  private:
   const gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedSizeView);
 };
 
-class TabbedPaneTest : public ViewsTestBase,
-                       public WidgetDelegate {
+class TabbedPaneTest : public ViewsTestBase {
  public:
   TabbedPaneTest() {}
 
-  TabbedPane* tabbed_pane_;
+  void TestSizeAndLayout(TabbedPane* tabbed_pane);
+
+  void TestAddRemove(TabbedPane* tabbed_pane);
+
+  TabbedPane* tabbed_pane_;  // Owned by the |widget_|'s root View.
+
+#if defined(OS_WIN) && !defined(USE_AURA)
+  TabbedPane* tabbed_pane_win_;  // Owned by the |widget_|'s root View.
+#endif
 
  private:
-  virtual void SetUp() OVERRIDE {
-    ViewsTestBase::SetUp();
-    tabbed_pane_ = new TabbedPane();
-    tabbed_pane_->set_use_native_win_control(true);
-    window_ = Widget::CreateWindowWithBounds(this, gfx::Rect(0, 0, 100, 100));
-    window_->Show();
-  }
+  virtual void SetUp() OVERRIDE;
 
-  virtual void TearDown() OVERRIDE {
-    window_->Close();
-    ViewsTestBase::TearDown();
-  }
-
-  virtual views::View* GetContentsView() OVERRIDE {
-    return tabbed_pane_;
-  }
-  virtual views::Widget* GetWidget() OVERRIDE {
-    return tabbed_pane_->GetWidget();
-  }
-  virtual const views::Widget* GetWidget() const OVERRIDE {
-    return tabbed_pane_->GetWidget();
-  }
-
-  Widget* window_;
+  scoped_ptr<Widget> widget_;
 
   DISALLOW_COPY_AND_ASSIGN(TabbedPaneTest);
 };
 
-// Tests that TabbedPane::GetPreferredSize() and TabbedPane::Layout().
-TEST_F(TabbedPaneTest, SizeAndLayout) {
+void TabbedPaneTest::SetUp() {
+  ViewsTestBase::SetUp();
+  tabbed_pane_ = new TabbedPane();
+  widget_.reset(new Widget());
+  Widget::InitParams params(Widget::InitParams::TYPE_POPUP);
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.bounds = gfx::Rect(0, 0, 100, 100);
+  widget_->Init(params);
+  // In order to properly initialize the |TabbedPane| it must be added to a
+  // parent view (see the ViewHierarchyChanged method of the |TabbedPane|).
+  widget_->GetRootView()->AddChildView(tabbed_pane_);
+
+#if defined(OS_WIN) && !defined(USE_AURA)
+  tabbed_pane_win_ = new TabbedPane();
+  tabbed_pane_win_->set_use_native_win_control(true);
+  widget_->GetRootView()->AddChildView(tabbed_pane_win_);
+#endif
+}
+
+void TabbedPaneTest::TestSizeAndLayout(TabbedPane* tabbed_pane) {
   View* child1 = new FixedSizeView(gfx::Size(20, 10));
-  tabbed_pane_->AddTab(ASCIIToUTF16("tab1"), child1);
+  tabbed_pane->AddTab(ASCIIToUTF16("tab1"), child1);
   View* child2 = new FixedSizeView(gfx::Size(5, 5));
-  tabbed_pane_->AddTab(ASCIIToUTF16("tab2"), child2);
-  tabbed_pane_->SelectTabAt(0);
+  tabbed_pane->AddTab(ASCIIToUTF16("tab2"), child2);
+  tabbed_pane->SelectTabAt(0);
 
   // Check that the preferred size is larger than the largest child.
-  gfx::Size pref(tabbed_pane_->GetPreferredSize());
-  EXPECT_GT(pref.width(), 20);
+  gfx::Size pref(tabbed_pane->GetPreferredSize());
+  // The |tabbed_pane_| has no border. Therefore it should be as wide as the

[msw, 2012/07/27 18:09:18]

Sorry for changing my advice, but this comment should probably be merged with
the semi-contradictory one above.

Alternatively, (though I'm not sure this is really beneficial) you could split
the check and comments up by platform to check GT and EQUAL... Then we could
just delete the NTPW case lalter...

Whichever option you choose, do the same below.

[markusheintz_, 2012/07/30 10:15:44]

Uups I merged the two comments.
It's not possible (without further chagnes)  to use "if-defs" in this method as
this method is used to test both the NTPW and NTPV on Windows.

I could add a bool flag that is set to true when we use the native win control. 
But then we would start adding more code to cover special cases.

+  // widest tab.
+  EXPECT_GE(pref.width(), 20);
   EXPECT_GT(pref.height(), 10);
 
   // The bounds of our children should be smaller than the tabbed pane's bounds.
-  tabbed_pane_->SetBounds(0, 0, 100, 200);
+  tabbed_pane->SetBounds(0, 0, 100, 200);
   RunPendingMessages();
   gfx::Rect bounds(child1->bounds());
   EXPECT_GT(bounds.width(), 0);
-  EXPECT_LT(bounds.width(), 100);
+  // The |tabbed_pane_| has no border. Therefore the children should be as wide
+  // as the |tabbed_pane_|.
+  EXPECT_LE(bounds.width(), 100);
   EXPECT_GT(bounds.height(), 0);
   EXPECT_LT(bounds.height(), 200);
 
   // If we switch to the other tab, it should get assigned the same bounds.
-  tabbed_pane_->SelectTabAt(1);
+  tabbed_pane->SelectTabAt(1);
   EXPECT_EQ(bounds, child2->bounds());
 }
 
-TEST_F(TabbedPaneTest, AddRemove) {
+void TabbedPaneTest::TestAddRemove(TabbedPane* tabbed_pane) {
   View* tab0 = new View;
-  tabbed_pane_->AddTab(ASCIIToUTF16("tab0"), tab0);
-  EXPECT_EQ(tab0, tabbed_pane_->GetSelectedTab());
-  EXPECT_EQ(0, tabbed_pane_->GetSelectedTabIndex());
+  tabbed_pane->AddTab(ASCIIToUTF16("tab0"), tab0);
+  EXPECT_EQ(tab0, tabbed_pane->GetSelectedTab());
+  EXPECT_EQ(0, tabbed_pane->GetSelectedTabIndex());
 
   // Add more 3 tabs.
-  tabbed_pane_->AddTab(ASCIIToUTF16("tab1"), new View);
-  tabbed_pane_->AddTab(ASCIIToUTF16("tab2"), new View);
-  tabbed_pane_->AddTab(ASCIIToUTF16("tab3"), new View);
-  EXPECT_EQ(4, tabbed_pane_->GetTabCount());
+  tabbed_pane->AddTab(ASCIIToUTF16("tab1"), new View);
+  tabbed_pane->AddTab(ASCIIToUTF16("tab2"), new View);
+  tabbed_pane->AddTab(ASCIIToUTF16("tab3"), new View);
+  EXPECT_EQ(4, tabbed_pane->GetTabCount());
 
   // Note: AddTab() doesn't select a tab if the tabbed pane isn't empty.
 
   // Select the last one.
-  tabbed_pane_->SelectTabAt(tabbed_pane_->GetTabCount() - 1);
-  EXPECT_EQ(3, tabbed_pane_->GetSelectedTabIndex());
+  tabbed_pane->SelectTabAt(tabbed_pane->GetTabCount() - 1);
+  EXPECT_EQ(3, tabbed_pane->GetSelectedTabIndex());
 
   // Remove the last one.
-  delete tabbed_pane_->RemoveTabAtIndex(3);
-  EXPECT_EQ(3, tabbed_pane_->GetTabCount());
+  delete tabbed_pane->RemoveTabAtIndex(3);
+  EXPECT_EQ(3, tabbed_pane->GetTabCount());
 
   // After removing the last tab, check if the tabbed pane selected the previous
   // tab.
-  EXPECT_EQ(2, tabbed_pane_->GetSelectedTabIndex());
+  EXPECT_EQ(2, tabbed_pane->GetSelectedTabIndex());
 
-  tabbed_pane_->AddTabAtIndex(0, ASCIIToUTF16("tab4"), new View, true);
+  tabbed_pane->AddTabAtIndex(0, ASCIIToUTF16("tab4"), new View, true);
 
   // Assert that even adding a new tab, the tabbed pane doesn't change the
   // selection, i.e., it doesn't select the new one.
   // The last tab should remains selected, instead of the tab added at index 0.
-  EXPECT_EQ(3, tabbed_pane_->GetSelectedTabIndex());
+  EXPECT_EQ(3, tabbed_pane->GetSelectedTabIndex());
 
   // Now change the selected tab.
-  tabbed_pane_->SelectTabAt(1);
-  EXPECT_EQ(1, tabbed_pane_->GetSelectedTabIndex());
+  tabbed_pane->SelectTabAt(1);
+  EXPECT_EQ(1, tabbed_pane->GetSelectedTabIndex());
 
   // Remove the first one.
-  delete tabbed_pane_->RemoveTabAtIndex(0);
-  EXPECT_EQ(0, tabbed_pane_->GetSelectedTabIndex());
+  delete tabbed_pane->RemoveTabAtIndex(0);
+  EXPECT_EQ(0, tabbed_pane->GetSelectedTabIndex());
+}
+
+// Tests that TabbedPane::GetPreferredSize() and TabbedPane::Layout().

[msw, 2012/07/27 18:09:18]

nit: remove "that" or extrapolate.

[markusheintz_, 2012/07/30 10:15:44]

Done.

+TEST_F(TabbedPaneTest, SizeAndLayout) {
+  TestSizeAndLayout(tabbed_pane_);
+  // TODO(markusheintz): Once replacing NativeTabbedPaneWin with
+  // NativeTabbedPaneView is completed (http://crbug.com/138059), then the
+  // TestSizeAndLayout method should be inlined here again and the "ifdef" part
+  // should be deleted.
+#if defined(OS_WIN) && !defined(USE_AURA)
+  TestSizeAndLayout(tabbed_pane_win_);
+#endif
+}
+
+TEST_F(TabbedPaneTest, AddRemove) {
+  TestAddRemove(tabbed_pane_);
+  // TODO(markusheintz): Once replacing NativeTabbedPaneWin with
+  // NativeTabbedPaneView is completed (http://crbug.com/138059), then the
+  // TestAddRemove method should be inlined here again and the "ifdef" part
+  // should be deleted.
+#if defined(OS_WIN) && !defined(USE_AURA)
+  TestAddRemove(tabbed_pane_win_);
+#endif
 }
 
 } // namespace views