Refactoring of tabbed-pane component so it can be ported to Linux toolkit_view.

BUG=None
TEST=Make sure the Options dialog still works as expected (tab selection, focus traversal...)
Review URL: http://codereview.chromium.org/155668

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@21189 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 386 insertions, 121 deletions

diff --git a/views/controls/tabbed_pane.cc b/views/controls/tabbed_pane/native_tabbed_pane_win.cc
index b7c41bc..8ae054c 100644
--- a/views/controls/tabbed_pane.cc
+++ b/views/controls/tabbed_pane/native_tabbed_pane_win.cc
@@ -1,8 +1,8 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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 "views/controls/tabbed_pane.h"
+#include "views/controls/tabbed_pane/native_tabbed_pane_win.h"
 
 #include <vssym32.h>
 
@@ -13,9 +13,7 @@
 #include "base/gfx/native_theme.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
-#include "skia/ext/skia_utils_win.h"
-#include "third_party/skia/include/core/SkColor.h"
-#include "views/background.h"
+#include "views/controls/tabbed_pane/tabbed_pane.h"
 #include "views/fill_layout.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_win.h"
@@ -45,29 +43,37 @@ class TabBackground : public Background {
   }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(TabBackground);
+  DISALLOW_COPY_AND_ASSIGN(TabBackground);
 };
 
-TabbedPane::TabbedPane() : content_window_(NULL), listener_(NULL) {
+////////////////////////////////////////////////////////////////////////////////
+// NativeTabbedPaneWin, public:
+
+NativeTabbedPaneWin::NativeTabbedPaneWin(TabbedPane* tabbed_pane)
+    : NativeControlWin(),
+      tabbed_pane_(tabbed_pane),
+      content_window_(NULL) {
+  // Associates the actual HWND with the tabbed-pane so the tabbed-pane is
+  // the one considered as having the focus (not the wrapper) when the HWND is
+  // focused directly (with a click for example).
+  set_focus_view(tabbed_pane);
 }
 
-TabbedPane::~TabbedPane() {
+NativeTabbedPaneWin::~NativeTabbedPaneWin() {
   // We own the tab views, let's delete them.
   STLDeleteContainerPointers(tab_views_.begin(), tab_views_.end());
 }
 
-void TabbedPane::SetListener(Listener* listener) {
-  listener_ = listener;
-}
+////////////////////////////////////////////////////////////////////////////////
+// NativeTabbedPaneWin, NativeTabbedPaneWrapper implementation:
 
-void TabbedPane::AddTab(const std::wstring& title, View* contents) {
+void NativeTabbedPaneWin::AddTab(const std::wstring& title, View* contents) {
   AddTabAtIndex(static_cast<int>(tab_views_.size()), title, contents, true);
 }
 
-void TabbedPane::AddTabAtIndex(int index,
-                               const std::wstring& title,
-                               View* contents,
-                               bool select_if_first_tab) {
+void NativeTabbedPaneWin::AddTabAtIndex(int index, const std::wstring& title,
+                                        View* contents,
+                                        bool select_if_first_tab) {
   DCHECK(index <= static_cast<int>(tab_views_.size()));
   contents->SetParentOwned(false);
   tab_views_.insert(tab_views_.begin() + index, contents);
@@ -82,12 +88,11 @@ void TabbedPane::AddTabAtIndex(int index,
   }
 
   tcitem.pszText = const_cast<wchar_t*>(title.c_str());
-  int result = TabCtrl_InsertItem(tab_control_, index, &tcitem);
+  int result = TabCtrl_InsertItem(native_view(), index, &tcitem);
   DCHECK(result != -1);
 
-  if (!contents->background()) {
+  if (!contents->background())
     contents->set_background(new TabBackground);
-  }
 
   if (tab_views_.size() == 1 && select_if_first_tab) {
     // If this is the only tab displayed, make sure the contents is set.
@@ -95,10 +100,10 @@ void TabbedPane::AddTabAtIndex(int index,
   }
 
   // The newly added tab may have made the contents window smaller.
-  ResizeContents(tab_control_);
+  ResizeContents();
 }
 
-View* TabbedPane::RemoveTabAtIndex(int index) {
+View* NativeTabbedPaneWin::RemoveTabAtIndex(int index) {
   int tab_count = static_cast<int>(tab_views_.size());
   DCHECK(index >= 0 && index < tab_count);
 
@@ -114,10 +119,10 @@ View* TabbedPane::RemoveTabAtIndex(int index) {
       content_window_->GetRootView()->RemoveAllChildViews(false);
     }
   }
-  TabCtrl_DeleteItem(tab_control_, index);
+  TabCtrl_DeleteItem(native_view(), index);
 
   // The removed tab may have made the contents window bigger.
-  ResizeContents(tab_control_);
+  ResizeContents();
 
   std::vector<View*>::iterator iter = tab_views_.begin() + index;
   View* removed_tab = *iter;
@@ -126,21 +131,41 @@ View* TabbedPane::RemoveTabAtIndex(int index) {
   return removed_tab;
 }
 
-void TabbedPane::SelectTabAt(int index) {
+void NativeTabbedPaneWin::SelectTabAt(int index) {
   DCHECK((index >= 0) && (index < static_cast<int>(tab_views_.size())));
-  TabCtrl_SetCurSel(tab_control_, index);
+  TabCtrl_SetCurSel(native_view(), index);
   DoSelectTabAt(index);
 }
 
-void TabbedPane::SelectTabForContents(const View* contents) {
-  SelectTabAt(GetIndexForContents(contents));
+int NativeTabbedPaneWin::GetTabCount() {
+  return TabCtrl_GetItemCount(native_view());
+}
+
+int NativeTabbedPaneWin::GetSelectedTabIndex() {
+  return TabCtrl_GetCurSel(native_view());
+}
+
+View* NativeTabbedPaneWin::GetSelectedTab() {
+  return content_window_->GetRootView()->GetChildViewAt(0);
 }
 
-int TabbedPane::GetTabCount() {
-  return TabCtrl_GetItemCount(tab_control_);
+View* NativeTabbedPaneWin::GetView() {
+  return this;
 }
 
-HWND TabbedPane::CreateNativeControl(HWND parent_container) {
+void NativeTabbedPaneWin::SetFocus() {
+  // Focus the associated HWND.
+  Focus();
+}
+
+gfx::NativeView NativeTabbedPaneWin::GetTestingHandle() const {
+  return native_view();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NativeTabbedPaneWin, NativeControlWin override:
+
+void NativeTabbedPaneWin::CreateNativeControl() {
   // Create the tab control.
   //
   // Note that we don't follow the common convention for NativeControl
@@ -159,27 +184,27 @@ HWND TabbedPane::CreateNativeControl(HWND parent_container) {
   // contents will use an RTL layout correctly (by virtue of the mirroring
   // infrastructure in views doing the right thing with each View we put
   // in the tab).
-  tab_control_ = ::CreateWindowEx(0,
-                                  WC_TABCONTROL,
-                                  L"",
-                                  WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,
-                                  0, 0, width(), height(),
-                                  parent_container, NULL, NULL, NULL);
+  HWND tab_control = ::CreateWindowEx(0,
+                                      WC_TABCONTROL,
+                                      L"",
+                                      WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,
+                                      0, 0, width(), height(),
+                                      GetWidget()->GetNativeView(), NULL, NULL,
+                                      NULL);
 
   HFONT font = ResourceBundle::GetSharedInstance().
       GetFont(ResourceBundle::BaseFont).hfont();
-  SendMessage(tab_control_, WM_SETFONT, reinterpret_cast<WPARAM>(font), FALSE);
+  SendMessage(tab_control, WM_SETFONT, reinterpret_cast<WPARAM>(font), FALSE);
 
   // Create the view container which is a child of the TabControl.
   content_window_ = new WidgetWin();
-  content_window_->Init(tab_control_, gfx::Rect());
+  content_window_->Init(tab_control, gfx::Rect());
 
   // Explicitly setting the WS_EX_LAYOUTRTL property for the HWND (see above
   // for a thorough explanation regarding why we waited until |content_window_|
   // if created before we set this property for the tabbed pane's HWND).
-  if (UILayoutIsRightToLeft()) {
-    l10n_util::HWNDSetRTLLayout(tab_control_);
-  }
+  if (UILayoutIsRightToLeft())
+    l10n_util::HWNDSetRTLLayout(tab_control);
 
   RootView* root_view = content_window_->GetRootView();
   root_view->SetLayoutManager(new FillLayout());
@@ -189,21 +214,53 @@ HWND TabbedPane::CreateNativeControl(HWND parent_container) {
   root_view->set_background(Background::CreateSolidBackground(color));
 
   content_window_->SetFocusTraversableParentView(this);
-  ResizeContents(tab_control_);
-  return tab_control_;
+  ResizeContents();
+
+  NativeControlCreated(tab_control);
 }
 
-LRESULT TabbedPane::OnNotify(int w_param, LPNMHDR l_param) {
-  if (static_cast<LPNMHDR>(l_param)->code == TCN_SELCHANGE) {
-    int selected_tab = TabCtrl_GetCurSel(tab_control_);
+bool NativeTabbedPaneWin::ProcessMessage(UINT message,
+                                         WPARAM w_param,
+                                         LPARAM l_param,
+                                         LRESULT* result) {
+  if (message == WM_NOTIFY &&
+      reinterpret_cast<LPNMHDR>(l_param)->code == TCN_SELCHANGE) {
+    int selected_tab = TabCtrl_GetCurSel(native_view());
     DCHECK(selected_tab != -1);
     DoSelectTabAt(selected_tab);
     return TRUE;
   }
-  return FALSE;
+  return NativeControlWin::ProcessMessage(message, w_param, l_param, result);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// View override:
+
+void NativeTabbedPaneWin::Layout() {
+  NativeControlWin::Layout();
+  ResizeContents();
+}
+
+FocusTraversable* NativeTabbedPaneWin::GetFocusTraversable() {
+  return content_window_;
+}
+
+void NativeTabbedPaneWin::ViewHierarchyChanged(bool is_add,
+                                               View *parent,
+                                               View *child) {
+  NativeControlWin::ViewHierarchyChanged(is_add, parent, child);
+
+  if (is_add && (child == this) && content_window_) {
+    // We have been added to a view hierarchy, update the FocusTraversable
+    // parent.
+    content_window_->SetFocusTraversableParent(GetRootView());
+  }
 }
 
-void TabbedPane::DoSelectTabAt(int index) {
+////////////////////////////////////////////////////////////////////////////////
+// NativeTabbedPaneWin, private:
+
+void NativeTabbedPaneWin::DoSelectTabAt(int index) {
   RootView* content_root = content_window_->GetRootView();
 
   // Clear the focus if the focused view was on the tab.
@@ -216,49 +273,28 @@ void TabbedPane::DoSelectTabAt(int index) {
   content_root->RemoveAllChildViews(false);
   content_root->AddChildView(tab_views_[index]);
   content_root->Layout();
-  if (listener_)
-    listener_->TabSelectedAt(index);
-}
-
-int TabbedPane::GetIndexForContents(const View* contents) const {
-  std::vector<View*>::const_iterator i =
-      std::find(tab_views_.begin(), tab_views_.end(), contents);
-  DCHECK(i != tab_views_.end());
-  return static_cast<int>(i - tab_views_.begin());
-}
-
-void TabbedPane::Layout() {
-  NativeControl::Layout();
-  ResizeContents(GetNativeControlHWND());
-}
-
-RootView* TabbedPane::GetContentsRootView() {
-  return content_window_->GetRootView();
-}
 
-FocusTraversable* TabbedPane::GetFocusTraversable() {
-  return content_window_;
-}
-
-void TabbedPane::ViewHierarchyChanged(bool is_add, View *parent, View *child) {
-  NativeControl::ViewHierarchyChanged(is_add, parent, child);
-
-  if (is_add && (child == this) && content_window_) {
-    // We have been added to a view hierarchy, update the FocusTraversable
-    // parent.
-    content_window_->SetFocusTraversableParent(GetRootView());
-  }
+  if (tabbed_pane_->listener())
+    tabbed_pane_->listener()->TabSelectedAt(index);
 }
 
-void TabbedPane::ResizeContents(HWND tab_control) {
-  DCHECK(tab_control);
+void NativeTabbedPaneWin::ResizeContents() {
   CRect content_bounds;
-  if (!GetClientRect(tab_control, &content_bounds))
+  if (!GetClientRect(native_view(), &content_bounds))
     return;
-  TabCtrl_AdjustRect(tab_control, FALSE, &content_bounds);
+  TabCtrl_AdjustRect(native_view(), FALSE, &content_bounds);
   content_window_->MoveWindow(content_bounds.left, content_bounds.top,
                               content_bounds.Width(), content_bounds.Height(),
                               TRUE);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// NativeTabbedPaneWrapper, public:
+
+// static
+NativeTabbedPaneWrapper* NativeTabbedPaneWrapper::CreateNativeWrapper(
+    TabbedPane* tabbed_pane) {
+  return new NativeTabbedPaneWin(tabbed_pane);
+}
+
 }  // namespace views
diff --git a/views/controls/tabbed_pane/native_tabbed_pane_win.h b/views/controls/tabbed_pane/native_tabbed_pane_win.h
new file mode 100644
index 0000000..be55d15
--- /dev/null
+++ b/views/controls/tabbed_pane/native_tabbed_pane_win.h
@@ -0,0 +1,69 @@
+// Copyright (c) 2009 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.
+
+#ifndef VIEWS_CONTROLS_TABBED_PANE_NATIVE_TABBED_PANE_WIN_H_
+#define VIEWS_CONTROLS_TABBED_PANE_NATIVE_TABBED_PANE_WIN_H_
+
+#include "views/controls/native_control_win.h"
+#include "views/controls/tabbed_pane/native_tabbed_pane_wrapper.h"
+
+namespace views {
+
+class WidgetWin;
+
+class NativeTabbedPaneWin : public NativeControlWin,
+                            public NativeTabbedPaneWrapper {
+ public:
+  explicit NativeTabbedPaneWin(TabbedPane* tabbed_pane);
+  virtual ~NativeTabbedPaneWin();
+
+  // NativeTabbedPaneWrapper implementation:
+  virtual void AddTab(const std::wstring& title, View* contents);
+  virtual void AddTabAtIndex(int index,
+                             const std::wstring& title,
+                             View* contents,
+                             bool select_if_first_tab);
+  virtual View* RemoveTabAtIndex(int index);
+  virtual void SelectTabAt(int index);
+  virtual int GetTabCount();
+  virtual int GetSelectedTabIndex();
+  virtual View* GetSelectedTab();
+  virtual View* GetView();
+  virtual void SetFocus();
+  virtual gfx::NativeView GetTestingHandle() const;
+
+  // NativeControlWin overrides.
+  virtual void CreateNativeControl();
+  virtual bool ProcessMessage(UINT message,
+                              WPARAM w_param,
+                              LPARAM l_param,
+                              LRESULT* result);
+
+  // View overrides:
+  virtual void Layout();
+  virtual FocusTraversable* GetFocusTraversable();
+  virtual void ViewHierarchyChanged(bool is_add, View *parent, View *child);
+
+ private:
+  // Changes the contents view to the view associated with the tab at |index|.
+  void DoSelectTabAt(int index);
+
+  // Resizes the HWND control to macth the size of the containing view.
+  void ResizeContents();
+
+  // The tabbed-pane we are bound to.
+  TabbedPane* tabbed_pane_;
+
+  // The views associated with the different tabs.
+  std::vector<View*> tab_views_;
+
+  // The window displayed in the tab.
+  WidgetWin* content_window_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeTabbedPaneWin);
+};
+
+}  // namespace views
+
+#endif  // VIEWS_CONTROLS_TABBED_PANE_NATIVE_TABBED_PANE_WIN_H_
diff --git a/views/controls/tabbed_pane/native_tabbed_pane_wrapper.h b/views/controls/tabbed_pane/native_tabbed_pane_wrapper.h
new file mode 100644
index 0000000..a051898
--- /dev/null
+++ b/views/controls/tabbed_pane/native_tabbed_pane_wrapper.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2009 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.
+
+#ifndef VIEWS_CONTROLS_TABBED_PANE_NATIVE_TABBED_PANE_WRAPPER_H_
+#define VIEWS_CONTROLS_TABBED_PANE_NATIVE_TABBED_PANE_WRAPPER_H_
+
+namespace views {
+
+class TabbedPane;
+class View;
+
+// An interface implemented by an object that provides a platform-native
+// tabbed-pane.
+class NativeTabbedPaneWrapper {
+ public:
+  // The TabbedPane calls this when it is destroyed to clean up the wrapper
+  // object.
+  virtual ~NativeTabbedPaneWrapper() { }
+
+  // Adds a new tab at the end of this TabbedPane with the specified |title|.
+  // |contents| is the view displayed when the tab is selected and is owned by
+  // the TabbedPane.
+  virtual void AddTab(const std::wstring& title, View* contents) = 0;
+
+  // Adds a new tab at the specified |index| with the specified |title|.
+  // |contents| is the view displayed when the tab is selected and is owned by
+  // the TabbedPane. If |select_if_first_tab| is true and the tabbed pane is
+  // currently empty, the new tab is selected. If you pass in false for
+  // |select_if_first_tab| you need to explicitly invoke SelectTabAt, otherwise
+  // the tabbed pane will not have a valid selection.
+  virtual void AddTabAtIndex(int index,
+                             const std::wstring& title,
+                             View* contents,
+                             bool select_if_first_tab) = 0;
+
+  // Removes the tab at the specified |index| and returns the associated content
+  // view.  The caller becomes the owner of the returned view.
+  virtual View* RemoveTabAtIndex(int index) = 0;
+
+  // Selects the tab at the specified |index|, which must be valid.
+  virtual void SelectTabAt(int index) = 0;
+
+  // Returns the number of tabs.
+  virtual int GetTabCount() = 0;
+
+  // Returns the index of the selected tab.
+  virtual int GetSelectedTabIndex() = 0;
+
+  // Returns the contents of the selected tab.
+  virtual View* GetSelectedTab() = 0;
+
+  // Retrieves the views::View that hosts the native control.
+  virtual View* GetView() = 0;
+
+  // Sets the focus to the tabbed pane native view.
+  virtual void SetFocus() = 0;
+
+  // Returns a handle to the underlying native view for testing.
+  virtual gfx::NativeView GetTestingHandle() const = 0;
+
+  // Creates an appropriate NativeTabbedPaneWrapper for the platform.
+  static NativeTabbedPaneWrapper* CreateNativeWrapper(TabbedPane* tabbed_pane);
+};
+
+}  // namespace views
+
+#endif  // VIEWS_CONTROLS_TABBED_PANE_NATIVE_TABBED_PANE_WRAPPER_H_
diff --git a/views/controls/tabbed_pane/tabbed_pane.cc b/views/controls/tabbed_pane/tabbed_pane.cc
new file mode 100644
index 0000000..20a2e7a
--- /dev/null
+++ b/views/controls/tabbed_pane/tabbed_pane.cc
@@ -0,0 +1,89 @@
+// Copyright (c) 2006-2008 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 "views/controls/tabbed_pane/tabbed_pane.h"
+
+#include "views/controls/tabbed_pane/native_tabbed_pane_wrapper.h"
+
+namespace views {
+
+// static
+const char TabbedPane::kViewClassName[] = "views/TabbedPane";
+
+TabbedPane::TabbedPane() : native_tabbed_pane_(NULL), listener_(NULL) {
+  SetFocusable(true);
+}
+
+TabbedPane::~TabbedPane() {
+}
+
+void TabbedPane::SetListener(Listener* listener) {
+  listener_ = listener;
+}
+
+void TabbedPane::AddTab(const std::wstring& title, View* contents) {
+  native_tabbed_pane_->AddTab(title, contents);
+}
+
+void TabbedPane::AddTabAtIndex(int index,
+                               const std::wstring& title,
+                               View* contents,
+                               bool select_if_first_tab) {
+  native_tabbed_pane_->AddTabAtIndex(index, title, contents,
+                                     select_if_first_tab);
+}
+
+int TabbedPane::GetSelectedTabIndex() {
+  return native_tabbed_pane_->GetSelectedTabIndex();
+}
+
+View* TabbedPane::GetSelectedTab() {
+  return native_tabbed_pane_->GetSelectedTab();
+}
+
+View* TabbedPane::RemoveTabAtIndex(int index) {
+  return native_tabbed_pane_->RemoveTabAtIndex(index);
+}
+
+void TabbedPane::SelectTabAt(int index) {
+   native_tabbed_pane_->SelectTabAt(index);
+}
+
+int TabbedPane::GetTabCount() {
+  return native_tabbed_pane_->GetTabCount();
+}
+
+void TabbedPane::CreateWrapper() {
+  native_tabbed_pane_ = NativeTabbedPaneWrapper::CreateNativeWrapper(this);
+}
+
+// View overrides:
+std::string TabbedPane::GetClassName() const {
+  return kViewClassName;
+}
+
+void TabbedPane::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
+  if (is_add && !native_tabbed_pane_ && GetWidget()) {
+    CreateWrapper();
+    AddChildView(native_tabbed_pane_->GetView());
+  }
+}
+
+void TabbedPane::Layout() {
+  if (native_tabbed_pane_) {
+    native_tabbed_pane_->GetView()->SetBounds(0, 0, width(), height());
+    native_tabbed_pane_->GetView()->Layout();
+  }
+}
+
+void TabbedPane::Focus() {
+  // Forward the focus to the wrapper.
+  if (native_tabbed_pane_)
+    native_tabbed_pane_->SetFocus();
+  else
+    View::Focus();  // Will focus the RootView window (so we still get keyboard
+                    // messages).
+}
+
+}  // namespace views
diff --git a/views/controls/tabbed_pane.h b/views/controls/tabbed_pane/tabbed_pane.h
index 528a2d5..f0eb5a5 100644
--- a/views/controls/tabbed_pane.h
+++ b/views/controls/tabbed_pane/tabbed_pane.h
@@ -1,20 +1,21 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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.
 
 #ifndef VIEWS_CONTROLS_TABBED_PANE_H_
 #define VIEWS_CONTROLS_TABBED_PANE_H_
 
-#include "views/controls/native_control.h"
+#include "views/view.h"
 
 namespace views {
 
+class NativeTabbedPaneWrapper;
+
 // The TabbedPane class is a view that shows tabs.  When the user clicks on a
 // tab, the associated view is displayed.
 // TODO (jcampan): implement GetPreferredSize().
-class WidgetWin;
 
-class TabbedPane : public NativeControl {
+class TabbedPane : public View {
  public:
   TabbedPane();
   virtual ~TabbedPane();
@@ -28,6 +29,15 @@ class TabbedPane : public NativeControl {
   };
   void SetListener(Listener* listener);
 
+  // Returns the number of tabs.
+  int GetTabCount();
+
+  // Returns the index of the selected tab.
+  int GetSelectedTabIndex();
+
+  // Returns the contents of the selected tab.
+  View* GetSelectedTab();
+
   // Adds a new tab at the end of this TabbedPane with the specified |title|.
   // |contents| is the view displayed when the tab is selected and is owned by
   // the TabbedPane.
@@ -51,44 +61,32 @@ class TabbedPane : public NativeControl {
   // Selects the tab at the specified |index|, which must be valid.
   void SelectTabAt(int index);
 
-  // Selects the tab containing the specified |contents|, which must be valid.
-  void SelectTabForContents(const View* contents);
-
-  // Returns the number of tabs.
-  int GetTabCount();
-
-  virtual HWND CreateNativeControl(HWND parent_container);
-  virtual LRESULT OnNotify(int w_param, LPNMHDR l_param);
+  Listener* listener() const { return listener_; }
 
+  // View overrides:
+  virtual void ViewHierarchyChanged(bool is_add, View* parent, View* child);
+  virtual std::string GetClassName() const;
   virtual void Layout();
+  virtual void Focus();
 
-  virtual RootView* GetContentsRootView();
-  virtual FocusTraversable* GetFocusTraversable();
-  virtual void ViewHierarchyChanged(bool is_add, View *parent, View *child);
+ protected:
+  // The object that actually implements the tabbed-pane.
+  // Protected for tests access.
+  NativeTabbedPaneWrapper* native_tabbed_pane_;
 
  private:
-  // Changes the contents view to the view associated with the tab at |index|.
-  void DoSelectTabAt(int index);
-
-  // Returns the index of the tab containing the specified |contents|.
-  int GetIndexForContents(const View* contents) const;
-
-  void ResizeContents(HWND tab_control);
-
-  HWND tab_control_;
-
-  // The views associated with the different tabs.
-  std::vector<View*> tab_views_;
+  // The tabbed-pane's class name.
+  static const char kViewClassName[];
 
-  // The window displayed in the tab.
-  WidgetWin* content_window_;
+  // Creates the native wrapper.
+  void CreateWrapper();
 
   // The listener we notify about tab selection changes.
   Listener* listener_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(TabbedPane);
+  DISALLOW_COPY_AND_ASSIGN(TabbedPane);
 };
 
 }  // namespace views
 
-#endif  // #define VIEWS_CONTROLS_TABBED_PANE_H_
+#endif  // VIEWS_CONTROLS_TABBED_PANE_H_
diff --git a/views/focus/focus_manager_unittest.cc b/views/focus/focus_manager_unittest.cc
index 64410c4..2ae52e1 100644
--- a/views/focus/focus_manager_unittest.cc
+++ b/views/focus/focus_manager_unittest.cc
@@ -21,8 +21,10 @@
 #include "views/controls/combobox/native_combobox_wrapper.h"
 #include "views/controls/label.h"
 #include "views/controls/link.h"
+#include "views/controls/native_control.h"
 #include "views/controls/scroll_view.h"
-#include "views/controls/tabbed_pane.h"
+#include "views/controls/tabbed_pane/native_tabbed_pane_wrapper.h"
+#include "views/controls/tabbed_pane/tabbed_pane.h"
 #include "views/controls/textfield/textfield.h"
 #include "views/widget/accelerator_handler.h"
 #include "views/widget/root_view.h"
@@ -273,7 +275,7 @@ class FocusTraversalTest : public FocusManagerTest {
     View* view = GetContentsView()->GetViewByID(id);
     if (view)
       return view;
-    view = style_tab_->GetContentsRootView()->GetViewByID(id);
+    view = style_tab_->GetSelectedTab()->GetViewByID(id);
     if (view)
       return view;
     view = search_border_view_->GetContentsRootView()->GetViewByID(id);
@@ -744,8 +746,8 @@ class TestCombobox : public Combobox, public Combobox::Model {
 class TestTabbedPane : public TabbedPane {
  public:
   TestTabbedPane() { }
-  virtual HWND TestGetNativeControlHWND() {
-    return GetNativeControlHWND();
+  virtual HWND TestGetNativeComponent() {
+    return native_tabbed_pane_->GetTestingHandle();
   }
 };
 
@@ -785,7 +787,7 @@ TEST_F(FocusManagerTest, FocusNativeControls) {
   ::SendMessage(combobox->TestGetNativeComponent(), WM_SETFOCUS, NULL, NULL);
   EXPECT_EQ(combobox, GetFocusManager()->GetFocusedView());
 
-  ::SendMessage(tabbed_pane->TestGetNativeControlHWND(), WM_SETFOCUS,
+  ::SendMessage(tabbed_pane->TestGetNativeComponent(), WM_SETFOCUS,
                 NULL, NULL);
   EXPECT_EQ(tabbed_pane, GetFocusManager()->GetFocusedView());
 
diff --git a/views/views.gyp b/views/views.gyp
index 4504f99..a9b09d3 100644
--- a/views/views.gyp
+++ b/views/views.gyp
@@ -146,8 +146,11 @@
         'controls/separator.h',
         'controls/single_split_view.cc',
         'controls/single_split_view.h',
-        'controls/tabbed_pane.cc',
-        'controls/tabbed_pane.h',
+        'controls/tabbed_pane/tabbed_pane.cc',
+        'controls/tabbed_pane/tabbed_pane.h',
+        'controls/tabbed_pane/native_tabbed_pane_win.cc',
+        'controls/tabbed_pane/native_tabbed_pane_win.h',
+        'controls/tabbed_pane/native_tabbed_pane_wrapper.h',
         'controls/table/group_table_view.cc',
         'controls/table/group_table_view.h',
         'controls/table/table_view.cc',