Add temporary TabStripWrapper interface that is implemented by both TabStrip ...

chrome/browser/views/frame/browser_view.cc

 // Copyright (c) 2006-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 "chrome/browser/views/frame/browser_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 413 matching lines @@
   if (UILayoutIsRightToLeft())
     bounding_box.set_x(bounding_box.x() + scrollbar_width);
 
   return bounding_box;
 }
 
 int BrowserView::GetTabStripHeight() const {
   // We want to return tabstrip_->height(), but we might be called in the midst
   // of layout, when that hasn't yet been updated to reflect the current state.
   // So return what the tabstrip height _ought_ to be right now.
-  views::View* tabstrip =
-      TabStrip2::Enabled() ? static_cast<views::View*>(bts_)
-                           : static_cast<views::View*>(tabstrip_);
-  return IsTabStripVisible() ? tabstrip->GetPreferredSize().height() : 0;
+  return IsTabStripVisible() ? tabstrip_->GetView()->GetPreferredSize().height()
+                             : 0;
 }
 
 gfx::Rect BrowserView::GetTabStripBounds() const {
   return frame_->GetBoundsForTabStrip(tabstrip_);
 }
 
 bool BrowserView::IsToolbarVisible() const {
   return browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
          browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
 }
@@ skipping 490 matching lines @@
 
 void BrowserView::ShowHTMLDialog(HtmlDialogUIDelegate* delegate,
                                  gfx::NativeWindow parent_window) {
   // Default to using our window as the parent if the argument is not specified.
   gfx::NativeWindow parent = parent_window ? parent_window
                                            : GetNativeHandle();
   browser::ShowHtmlDialogView(parent, browser_.get(), delegate);
 }
 
 void BrowserView::ContinueDraggingDetachedTab(const gfx::Rect& tab_bounds) {
-  DCHECK(TabStrip2::Enabled());
-  bts_->SetDraggedTabBounds(0, tab_bounds);
+  tabstrip_->SetDraggedTabBounds(0, tab_bounds);
   frame_->ContinueDraggingDetachedTab();
 }
 
 void BrowserView::UserChangedTheme() {
   frame_->GetWindow()->FrameTypeChanged();
   GetRootView()->ThemeChanged();
   GetRootView()->SchedulePaint();
 }
 
 int BrowserView::GetExtraRenderViewHeight() const {
@@ skipping 261 matching lines @@
   set_window(window);
   return this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, views::ClientView overrides:
 
 bool BrowserView::CanClose() const {
   // You cannot close a frame for which there is an active originating drag
   // session.
-  if (!TabStrip2::Enabled() && tabstrip_->IsDragSessionActive())
+  if (tabstrip_->IsDragSessionActive())
     return false;
 
   // Give beforeunload handlers the chance to cancel the close before we hide
   // the window below.
   if (!browser_->ShouldCloseWindow())
     return false;
 
   if (!browser_->tabstrip_model()->empty()) {
     // Tab strip isn't empty.  Hide the frame (so it appears to have closed
     // immediately) and close all the tabs, allowing the renderers to shut
@@ skipping 37 matching lines @@
 #endif
   }
 
   // Determine if the TabStrip exists and is capable of being clicked on. We
   // might be a popup window without a TabStrip.
   if (IsTabStripVisible()) {
     gfx::Point point_in_view_coords(point);
     View::ConvertPointToView(GetParent(), this, &point_in_view_coords);
 
     // See if the mouse pointer is within the bounds of the TabStrip.
-    if (!TabStrip2::Enabled()) {
-      gfx::Point point_in_tabstrip_coords(point);
-      View::ConvertPointToView(GetParent(), tabstrip_, &point_in_tabstrip_coords);
-      if (tabstrip_->HitTest(point_in_tabstrip_coords)) {
-        if (tabstrip_->PointIsWithinWindowCaption(point_in_tabstrip_coords))
-          return HTCAPTION;
-        return HTCLIENT;
-      }
+    gfx::Point point_in_tabstrip_coords(point);
+    View::ConvertPointToView(GetParent(), tabstrip_->GetView(),
+                             &point_in_tabstrip_coords);
+    if (tabstrip_->GetView()->HitTest(point_in_tabstrip_coords)) {
+      if (tabstrip_->PointIsWithinWindowCaption(point_in_tabstrip_coords))
+        return HTCAPTION;
+      return HTCLIENT;
     }
 
     // The top few pixels of the TabStrip are a drop-shadow - as we're pretty
     // starved of dragable area, let's give it to window dragging (this also
     // makes sense visually).
-    if (!TabStrip2::Enabled() && !IsMaximized() &&
-        (point_in_view_coords.y() < tabstrip_->y() + kTabShadowSize)) {
+    if (!IsMaximized() &&
+        (point_in_view_coords.y() <
+         (tabstrip_->GetView()->y() + kTabShadowSize))) {
       // We return HTNOWHERE as this is a signal to our containing
       // NonClientView that it should figure out what the correct hit-test
       // code is given the mouse position...
       return HTNOWHERE;
     }
   }
 
   // If the point's y coordinate is below the top of the toolbar and otherwise
   // within the bounds of this view, the point is considered to be within the
   // client area.
   gfx::Rect bv_bounds = bounds();
-  if (TabStrip2::Enabled()) {
-    bv_bounds.Offset(0, bts_->y());
-    bv_bounds.set_height(bv_bounds.height() - bts_->y());
-  } else {
-    bv_bounds.Offset(0, toolbar_->y());
-    bv_bounds.set_height(bv_bounds.height() - toolbar_->y());
-  }
+  bv_bounds.Offset(0, toolbar_->y());
+  bv_bounds.set_height(bv_bounds.height() - toolbar_->y());
   if (bv_bounds.Contains(point))
     return HTCLIENT;
 
   // If the point's y coordinate is above the top of the toolbar, but not in
   // the tabstrip (per previous checking in this function), then we consider it
   // in the window caption (e.g. the area to the right of the tabstrip
   // underneath the window controls). However, note that we DO NOT return
   // HTCAPTION here, because when the window is maximized the window controls
   // will fall into this space (since the BrowserView is sized to entire size
   // of the window at that point), and the HTCAPTION value will cause the
   // window controls not to work. So we return HTNOWHERE so that the caller
   // will hit-test the window controls before finally falling back to
   // HTCAPTION.
   bv_bounds = bounds();
   bv_bounds.set_height(toolbar_->y());
   if (bv_bounds.Contains(point))
     return HTNOWHERE;
 
   // If the point is somewhere else, delegate to the default implementation.
   return views::ClientView::NonClientHitTest(point);
 }
 
 gfx::Size BrowserView::GetMinimumSize() {
-  views::View* tabstrip =
-      TabStrip2::Enabled() ? static_cast<views::View*>(bts_)
-                           : static_cast<views::View*>(tabstrip_);
   // TODO(noname): In theory the tabstrip width should probably be
   // (OTR + tabstrip + caption buttons) width.
   gfx::Size tabstrip_size(
       browser_->SupportsWindowFeature(Browser::FEATURE_TABSTRIP) ?
-      tabstrip->GetMinimumSize() : gfx::Size());
+      tabstrip_->GetView()->GetMinimumSize() : gfx::Size());
   gfx::Size toolbar_size(
       (browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
        browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR)) ?
       toolbar_->GetMinimumSize() : gfx::Size());
   if (tabstrip_size.height() && toolbar_size.height())
     toolbar_size.Enlarge(0, -kToolbarTabStripVerticalOverlap);
   gfx::Size bookmark_bar_size;
   if (active_bookmark_bar_ &&
       browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR)) {
     bookmark_bar_size = active_bookmark_bar_->GetMinimumSize();
@@ skipping 68 matching lines @@
   // Start a hung plugin window detector for this browser object (as long as
   // hang detection is not disabled).
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
     InitHangMonitor();
   }
 
   LoadAccelerators();
   SetAccessibleName(l10n_util::GetString(IDS_PRODUCT_NAME));
 
-  if (TabStrip2::Enabled()) {
-    bts_ = new BrowserTabStrip(browser_->tabstrip_model());
-    AddChildView(bts_);
-  } else {
-    tabstrip_ = new TabStrip(browser_->tabstrip_model());
-    tabstrip_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_TABSTRIP));
-    AddChildView(tabstrip_);
-    tabstrip_->InitTabStripButtons();
-    frame_->TabStripCreated(tabstrip_);
-  }
+  tabstrip_ = TabStripWrapper::CreateTabStrip(browser_->tabstrip_model());
+  tabstrip_->GetView()->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_TABSTRIP));
+  AddChildView(tabstrip_->GetView());
+  frame_->TabStripCreated(tabstrip_);
 
   toolbar_ = new ToolbarView(browser_.get());
   AddChildView(toolbar_);
   toolbar_->SetID(VIEW_ID_TOOLBAR);
   toolbar_->Init(browser_->profile());
   toolbar_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_TOOLBAR));
 
   infobar_container_ = new InfoBarContainer(this);
   AddChildView(infobar_container_);
 
@@ skipping 28 matching lines @@
     BuildSystemMenuForPopupWindow();
   system_menu_.reset(
       new views::NativeMenuWin(system_menu_contents_.get(),
                                frame_->GetWindow()->GetNativeWindow()));
   system_menu_->Rebuild();
 }
 #endif
 
 int BrowserView::LayoutTabStrip() {
   gfx::Rect tabstrip_bounds;
-  if (TabStrip2::Enabled()) {
-    tabstrip_bounds = gfx::Rect(0, 0, width(),
-                                bts_->GetPreferredSize().height());
-  } else {
-    tabstrip_bounds = frame_->GetBoundsForTabStrip(tabstrip_);
-    tabstrip_->SetBackgroundOffset(
-        gfx::Point(tabstrip_bounds.x(), tabstrip_bounds.y()));
-  }
+  tabstrip_bounds = frame_->GetBoundsForTabStrip(tabstrip_);
+  tabstrip_->SetBackgroundOffset(
+      gfx::Point(tabstrip_bounds.x(), tabstrip_bounds.y()));
   gfx::Point tabstrip_origin = tabstrip_bounds.origin();
   ConvertPointToView(GetParent(), this, &tabstrip_origin);
   tabstrip_bounds.set_origin(tabstrip_origin);
   bool visible = IsTabStripVisible();
   int y = visible ? tabstrip_bounds.y() : 0;
   int height = visible ? tabstrip_bounds.height() : 0;
   int bottom = y + height;
-  if (TabStrip2::Enabled()) {
-    gfx::Size btsps = bts_->GetPreferredSize();
-    bts_->SetBounds(tabstrip_bounds.x(), y, width(), btsps.height());
-  } else {
-    tabstrip_->SetVisible(visible);
-    tabstrip_->SetBounds(tabstrip_bounds.x(), y, tabstrip_bounds.width(), height);
-  }
+  tabstrip_->GetView()->SetVisible(visible);
+  tabstrip_->GetView()->SetBounds(tabstrip_bounds.x(), y,
+                                  tabstrip_bounds.width(), height);
   return bottom;
 }
 
 int BrowserView::LayoutToolbar(int top) {
   int browser_view_width = width();
   bool visible = IsToolbarVisible();
   toolbar_->location_bar()->SetFocusable(visible);
   int y = top -
       ((visible && IsTabStripVisible()) ? kToolbarTabStripVerticalOverlap : 0);
   int height = visible ? toolbar_->GetPreferredSize().height() : 0;
@@ skipping 296 matching lines @@
 #endif
 }
 
 void BrowserView::LoadingAnimationCallback() {
   if (browser_->type() == Browser::TYPE_NORMAL) {
     // Loading animations are shown in the tab for tabbed windows.  We check the
     // browser type instead of calling IsTabStripVisible() because the latter
     // will return false for fullscreen windows, but we still need to update
     // their animations (so that when they come out of fullscreen mode they'll
     // be correct).
-    if (!TabStrip2::Enabled())
-      tabstrip_->UpdateLoadingAnimations();
+    tabstrip_->UpdateLoadingAnimations();
   } else if (ShouldShowWindowIcon()) {
     // ... or in the window icon area for popups and app windows.
     TabContents* tab_contents = browser_->GetSelectedTabContents();
     // GetSelectedTabContents can return NULL for example under Purify when
     // the animations are running slowly and this function is called on a timer
     // through LoadingAnimationCallback.
     frame_->UpdateThrobber(tab_contents && tab_contents->is_loading());
   }
 }
 
@@ skipping 43 matching lines @@
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }
 
 // static
 void BrowserList::AllBrowsersClosed() {
   views::Window::CloseAllSecondaryWindows();
 }