Rename PanelStrip to DockedPanelStrip and PanelOverflowStrip to OverflowPanelStrip.

BUG=none
TEST=existsing tests due to no functionality change


Review URL: http://codereview.chromium.org/9117047

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

10 files changed, 485 insertions, 484 deletions

diff --git a/chrome/browser/notifications/balloon_collection_impl.cc b/chrome/browser/notifications/balloon_collection_impl.cc
index b12548f..105a309 100644
--- a/chrome/browser/notifications/balloon_collection_impl.cc
+++ b/chrome/browser/notifications/balloon_collection_impl.cc
@@ -11,9 +11,9 @@
 #include "chrome/browser/notifications/balloon_host.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
-#include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ -406,8 +406,8 @@ gfx::Size BalloonCollectionImpl::Layout::ConstrainToSizeLimits(
 
 bool BalloonCollectionImpl::Layout::ComputeOffsetToMoveAbovePanels(
     const gfx::Rect& panel_bounds) {
-  const PanelStrip::Panels& panels =
-      PanelManager::GetInstance()->panel_strip()->panels();
+  const DockedPanelStrip::Panels& panels =
+      PanelManager::GetInstance()->docked_strip()->panels();
   int offset_to_move_above_panels = 0;
 
   // The offset is the maximum height of panels that could overlap with the
@@ -421,7 +421,8 @@ bool BalloonCollectionImpl::Layout::ComputeOffsetToMoveAbovePanels(
       return false;
     }
 
-    for (PanelStrip::Panels::const_reverse_iterator iter = panels.rbegin();
+    for (DockedPanelStrip::Panels::const_reverse_iterator iter =
+             panels.rbegin();
          iter != panels.rend(); ++iter) {
       // No need to check panels beyond the area occupied by the balloons.
       if ((*iter)->GetBounds().x() >= work_area_.x() + max_balloon_width())
@@ -440,7 +441,7 @@ bool BalloonCollectionImpl::Layout::ComputeOffsetToMoveAbovePanels(
       return false;
     }
 
-    for (PanelStrip::Panels::const_iterator iter = panels.begin();
+    for (DockedPanelStrip::Panels::const_iterator iter = panels.begin();
          iter != panels.end(); ++iter) {
       // No need to check panels beyond the area occupied by the balloons.
       if ((*iter)->GetBounds().right() <=
diff --git a/chrome/browser/ui/panels/panel_strip.cc b/chrome/browser/ui/panels/docked_panel_strip.cc
index d2cc30f..bafa6f5 100644
--- a/chrome/browser/ui/panels/panel_strip.cc
+++ b/chrome/browser/ui/panels/docked_panel_strip.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/ui/panels/panel_strip.h"
+#include "chrome/browser/ui/panels/docked_panel_strip.h"
 
 #include <algorithm>
 
@@ -10,9 +10,9 @@
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/panels/overflow_panel_strip.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
-#include "chrome/browser/ui/panels/panel_overflow_strip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
@@ -47,10 +47,10 @@ const int kMillisecondsBeforeCollapsingFromTitleOnlyState = 0;
 }  // namespace
 
 // static
-const int PanelStrip::kPanelMinWidth = 100;
-const int PanelStrip::kPanelMinHeight = 20;
+const int DockedPanelStrip::kPanelMinWidth = 100;
+const int DockedPanelStrip::kPanelMinHeight = 20;
 
-PanelStrip::PanelStrip(PanelManager* panel_manager)
+DockedPanelStrip::DockedPanelStrip(PanelManager* panel_manager)
     : panel_manager_(panel_manager),
       minimized_panel_count_(0),
       are_titlebars_up_(false),
@@ -60,14 +60,14 @@ PanelStrip::PanelStrip(PanelManager* panel_manager)
       titlebar_action_factory_(this) {
 }
 
-PanelStrip::~PanelStrip() {
+DockedPanelStrip::~DockedPanelStrip() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
   DCHECK(panels_in_temporary_layout_.empty());
   DCHECK_EQ(0, minimized_panel_count_);
 }
 
-void PanelStrip::SetDisplayArea(const gfx::Rect& new_area) {
+void DockedPanelStrip::SetDisplayArea(const gfx::Rect& new_area) {
   if (display_area_ == new_area)
     return;
 
@@ -80,7 +80,7 @@ void PanelStrip::SetDisplayArea(const gfx::Rect& new_area) {
   Rearrange();
 }
 
-void PanelStrip::AddPanel(Panel* panel) {
+void DockedPanelStrip::AddPanel(Panel* panel) {
   DCHECK_NE(Panel::IN_OVERFLOW, panel->expansion_state());
 
   // Always update limits, even for exiting panels, in case the maximums changed
@@ -141,7 +141,7 @@ void PanelStrip::AddPanel(Panel* panel) {
       panel->set_draggable(false);
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
-          base::Bind(&PanelStrip::DelayedMovePanelToOverflow,
+          base::Bind(&DockedPanelStrip::DelayedMovePanelToOverflow,
                      base::Unretained(this),
                      panel),
                      PanelManager::AdjustTimeInterval(
@@ -157,24 +157,24 @@ void PanelStrip::AddPanel(Panel* panel) {
     panels_.push_back(panel);
 }
 
-int PanelStrip::GetMaxPanelWidth() const {
+int DockedPanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
-int PanelStrip::GetMaxPanelHeight() const {
+int DockedPanelStrip::GetMaxPanelHeight() const {
   return display_area_.height();
 }
 
-int PanelStrip::StartingRightPosition() const {
+int DockedPanelStrip::StartingRightPosition() const {
   return display_area_.right();
 }
 
-int PanelStrip::GetRightMostAvailablePosition() const {
+int DockedPanelStrip::GetRightMostAvailablePosition() const {
   return panels_.empty() ? StartingRightPosition() :
       (panels_.back()->GetBounds().x() - kPanelsHorizontalSpacing);
 }
 
-bool PanelStrip::Remove(Panel* panel) {
+bool DockedPanelStrip::Remove(Panel* panel) {
   if (panel->has_temporary_layout()) {
     panels_in_temporary_layout_.erase(panel);
     return true;
@@ -199,14 +199,14 @@ bool PanelStrip::Remove(Panel* panel) {
   return true;
 }
 
-void PanelStrip::DelayedRemove() {
+void DockedPanelStrip::DelayedRemove() {
   for (size_t i = 0; i < panels_pending_to_remove_.size(); ++i)
     DoRemove(panels_pending_to_remove_[i]);
   panels_pending_to_remove_.clear();
   Rearrange();
 }
 
-bool PanelStrip::DoRemove(Panel* panel) {
+bool DockedPanelStrip::DoRemove(Panel* panel) {
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
   if (iter == panels_.end())
     return false;
@@ -220,7 +220,7 @@ bool PanelStrip::DoRemove(Panel* panel) {
   return true;
 }
 
-void PanelStrip::StartDragging(Panel* panel) {
+void DockedPanelStrip::StartDragging(Panel* panel) {
   for (size_t i = 0; i < panels_.size(); ++i) {
     if (panels_[i] == panel) {
       dragging_panel_index_ = i;
@@ -231,7 +231,7 @@ void PanelStrip::StartDragging(Panel* panel) {
   }
 }
 
-void PanelStrip::Drag(int delta_x) {
+void DockedPanelStrip::Drag(int delta_x) {
   DCHECK(dragging_panel_index_ != kInvalidPanelIndex);
 
   if (!delta_x)
@@ -250,7 +250,7 @@ void PanelStrip::Drag(int delta_x) {
     DragLeft();
 }
 
-void PanelStrip::DragLeft() {
+void DockedPanelStrip::DragLeft() {
   Panel* dragging_panel = panels_[dragging_panel_index_];
 
   // This is the left corner of the dragging panel. We use it to check against
@@ -293,7 +293,7 @@ void PanelStrip::DragLeft() {
   }
 }
 
-void PanelStrip::DragRight() {
+void DockedPanelStrip::DragRight() {
   Panel* dragging_panel = panels_[dragging_panel_index_];
 
   // This is the right corner of the dragging panel. We use it to check against
@@ -335,7 +335,7 @@ void PanelStrip::DragRight() {
   }
 }
 
-void PanelStrip::EndDragging(bool cancelled) {
+void DockedPanelStrip::EndDragging(bool cancelled) {
   DCHECK(dragging_panel_index_ != kInvalidPanelIndex);
 
   if (cancelled) {
@@ -351,12 +351,12 @@ void PanelStrip::EndDragging(bool cancelled) {
   DelayedRemove();
 }
 
-void PanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
+void DockedPanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
   gfx::Size size = panel->restored_size();
   Panel::ExpansionState expansion_state = panel->expansion_state();
   Panel::ExpansionState old_state = panel->old_expansion_state();
   if (old_state == Panel::IN_OVERFLOW) {
-    panel_manager_->panel_overflow_strip()->Remove(panel);
+    panel_manager_->overflow_strip()->Remove(panel);
     AddPanel(panel);
     panel->SetAppIconVisibility(true);
     panel->set_draggable(true);
@@ -394,21 +394,21 @@ void PanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
                 size.height()));
 }
 
-void PanelStrip::IncrementMinimizedPanels() {
+void DockedPanelStrip::IncrementMinimizedPanels() {
   minimized_panel_count_++;
   if (minimized_panel_count_ == 1)
     panel_manager_->mouse_watcher()->AddObserver(this);
   DCHECK_LE(minimized_panel_count_, num_panels());
 }
 
-void PanelStrip::DecrementMinimizedPanels() {
+void DockedPanelStrip::DecrementMinimizedPanels() {
   minimized_panel_count_--;
   DCHECK_GE(minimized_panel_count_, 0);
   if (minimized_panel_count_ == 0)
     panel_manager_->mouse_watcher()->RemoveObserver(this);
 }
 
-void PanelStrip::OnWindowSizeChanged(
+void DockedPanelStrip::OnWindowSizeChanged(
     Panel* panel, const gfx::Size& preferred_window_size) {
   // The panel width:
   // * cannot grow or shrink to go beyond [min_width, max_width]
@@ -455,7 +455,7 @@ void PanelStrip::OnWindowSizeChanged(
     Rearrange();
 }
 
-bool PanelStrip::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
+bool DockedPanelStrip::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
   // We should always bring up the titlebar if the mouse is over the
   // visible auto-hiding bottom bar.
   AutoHidingDesktopBar* desktop_bar = panel_manager_->auto_hiding_desktop_bar();
@@ -492,7 +492,7 @@ bool PanelStrip::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
   return false;
 }
 
-void PanelStrip::BringUpOrDownTitlebars(bool bring_up) {
+void DockedPanelStrip::BringUpOrDownTitlebars(bool bring_up) {
   if (are_titlebars_up_ == bring_up)
     return;
   are_titlebars_up_ = bring_up;
@@ -540,12 +540,12 @@ void PanelStrip::BringUpOrDownTitlebars(bool bring_up) {
   titlebar_action_factory_.InvalidateWeakPtrs();
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&PanelStrip::DelayedBringUpOrDownTitlebarsCheck,
+      base::Bind(&DockedPanelStrip::DelayedBringUpOrDownTitlebarsCheck,
                  titlebar_action_factory_.GetWeakPtr()),
                  PanelManager::AdjustTimeInterval(task_delay_milliseconds));
 }
 
-void PanelStrip::DelayedBringUpOrDownTitlebarsCheck() {
+void DockedPanelStrip::DelayedBringUpOrDownTitlebarsCheck() {
   // Task was already processed or cancelled - bail out.
   if (delayed_titlebar_action_ == NO_ACTION)
     return;
@@ -563,7 +563,7 @@ void PanelStrip::DelayedBringUpOrDownTitlebarsCheck() {
   DoBringUpOrDownTitlebars(need_to_bring_up_titlebars);
 }
 
-void PanelStrip::DoBringUpOrDownTitlebars(bool bring_up) {
+void DockedPanelStrip::DoBringUpOrDownTitlebars(bool bring_up) {
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
@@ -582,7 +582,7 @@ void PanelStrip::DoBringUpOrDownTitlebars(bool bring_up) {
   }
 }
 
-int PanelStrip::GetBottomPositionForExpansionState(
+int DockedPanelStrip::GetBottomPositionForExpansionState(
     Panel::ExpansionState expansion_state) const {
   int bottom = display_area_.bottom();
   // If there is an auto-hiding desktop bar aligned to the bottom edge, we need
@@ -596,13 +596,13 @@ int PanelStrip::GetBottomPositionForExpansionState(
   return bottom;
 }
 
-void PanelStrip::OnMouseMove(const gfx::Point& mouse_position) {
+void DockedPanelStrip::OnMouseMove(const gfx::Point& mouse_position) {
   bool bring_up_titlebars = ShouldBringUpTitlebars(mouse_position.x(),
                                                    mouse_position.y());
   BringUpOrDownTitlebars(bring_up_titlebars);
 }
 
-void PanelStrip::OnAutoHidingDesktopBarVisibilityChanged(
+void DockedPanelStrip::OnAutoHidingDesktopBarVisibilityChanged(
     AutoHidingDesktopBar::Alignment alignment,
     AutoHidingDesktopBar::Visibility visibility) {
   if (delayed_titlebar_action_ == NO_ACTION)
@@ -618,12 +618,12 @@ void PanelStrip::OnAutoHidingDesktopBarVisibilityChanged(
   delayed_titlebar_action_ = NO_ACTION;
 }
 
-void PanelStrip::OnFullScreenModeChanged(bool is_full_screen) {
+void DockedPanelStrip::OnFullScreenModeChanged(bool is_full_screen) {
   for (size_t i = 0; i < panels_.size(); ++i)
     panels_[i]->FullScreenModeChanged(is_full_screen);
 }
 
-void PanelStrip::Rearrange() {
+void DockedPanelStrip::Rearrange() {
   int rightmost_position = StartingRightPosition();
 
   size_t panel_index = 0;
@@ -660,7 +660,7 @@ void PanelStrip::Rearrange() {
       panels_[overflow_index]->SetExpansionState(Panel::IN_OVERFLOW);
   } else {
     // Attempt to add more panels from overflow to the strip.
-    PanelOverflowStrip* overflow_strip = panel_manager_->panel_overflow_strip();
+    OverflowPanelStrip* overflow_strip = panel_manager_->overflow_strip();
     Panel* overflow_panel;
     while ((overflow_panel = overflow_strip->first_panel()) &&
            GetRightMostAvailablePosition() >=
@@ -679,14 +679,14 @@ void PanelStrip::Rearrange() {
 #endif
 }
 
-void PanelStrip::DelayedMovePanelToOverflow(Panel* panel) {
+void DockedPanelStrip::DelayedMovePanelToOverflow(Panel* panel) {
   if (panels_in_temporary_layout_.erase(panel)) {
       DCHECK(panel->has_temporary_layout());
       panel->SetExpansionState(Panel::IN_OVERFLOW);
   }
 }
 
-void PanelStrip::RemoveAll() {
+void DockedPanelStrip::RemoveAll() {
   // This should only be called at the end of tests to clean up.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
   DCHECK(panels_in_temporary_layout_.empty());
@@ -700,6 +700,6 @@ void PanelStrip::RemoveAll() {
     (*iter)->Close();
 }
 
-bool PanelStrip::is_dragging_panel() const {
+bool DockedPanelStrip::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }
diff --git a/chrome/browser/ui/panels/panel_strip.h b/chrome/browser/ui/panels/docked_panel_strip.h
index ef732df..61e0e31 100644
--- a/chrome/browser/ui/panels/panel_strip.h
+++ b/chrome/browser/ui/panels/docked_panel_strip.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_UI_PANELS_PANEL_STRIP_H_
-#define CHROME_BROWSER_UI_PANELS_PANEL_STRIP_H_
+#ifndef CHROME_BROWSER_UI_PANELS_DOCKED_PANEL_STRIP_H_
+#define CHROME_BROWSER_UI_PANELS_DOCKED_PANEL_STRIP_H_
 #pragma once
 
 #include <set>
@@ -22,12 +22,12 @@ class PanelManager;
 // positioning the panels and controlling how they are displayed.
 // Panels in the strip appear minimized, showing title-only or expanded.
 // All panels in the strip are contained within the bounds of the strip.
-class PanelStrip : public PanelMouseWatcherObserver {
+class DockedPanelStrip : public PanelMouseWatcherObserver {
  public:
   typedef std::vector<Panel*> Panels;
 
-  explicit PanelStrip(PanelManager* panel_manager);
-  virtual ~PanelStrip();
+  explicit DockedPanelStrip(PanelManager* panel_manager);
+  virtual ~DockedPanelStrip();
 
   // Sets the bounds of the panel strip.
   // |area| is in screen coordinates.
@@ -172,7 +172,7 @@ class PanelStrip : public PanelMouseWatcherObserver {
   TitlebarAction delayed_titlebar_action_;
 
   // Owned by MessageLoop after posting.
-  base::WeakPtrFactory<PanelStrip> titlebar_action_factory_;
+  base::WeakPtrFactory<DockedPanelStrip> titlebar_action_factory_;
 
   static const int kPanelsHorizontalSpacing = 4;
 
@@ -182,7 +182,7 @@ class PanelStrip : public PanelMouseWatcherObserver {
   static const int kPanelMinWidth;
   static const int kPanelMinHeight;
 
-  DISALLOW_COPY_AND_ASSIGN(PanelStrip);
+  DISALLOW_COPY_AND_ASSIGN(DockedPanelStrip);
 };
 
-#endif  // CHROME_BROWSER_UI_PANELS_PANEL_STRIP_H_
+#endif  // CHROME_BROWSER_UI_PANELS_DOCKED_PANEL_STRIP_H_
diff --git a/chrome/browser/ui/panels/panel_overflow_strip.cc b/chrome/browser/ui/panels/overflow_panel_strip.cc
index d56bcd4..fd71d08 100644
--- a/chrome/browser/ui/panels/panel_overflow_strip.cc
+++ b/chrome/browser/ui/panels/overflow_panel_strip.cc
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/ui/panels/panel_overflow_strip.h"
+#include "chrome/browser/ui/panels/overflow_panel_strip.h"
 
 #include "base/logging.h"
+#include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
 #include "chrome/browser/ui/panels/panel_overflow_indicator.h"
-#include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "ui/base/animation/slide_animation.h"
@@ -31,7 +31,7 @@ const double kHeightRatioForMaxVisibleOverflowPanelsOnHover = 0.67;
 const int kOverflowHoverAnimationMs = 180;
 }
 
-PanelOverflowStrip::PanelOverflowStrip(PanelManager* panel_manager)
+OverflowPanelStrip::OverflowPanelStrip(PanelManager* panel_manager)
     : panel_manager_(panel_manager),
       current_display_width_(0),
       max_visible_panels_(kMaxVisibleOverflowPanels),
@@ -41,12 +41,12 @@ PanelOverflowStrip::PanelOverflowStrip(PanelManager* panel_manager)
       overflow_hover_animator_end_width_(0) {
 }
 
-PanelOverflowStrip::~PanelOverflowStrip() {
+OverflowPanelStrip::~OverflowPanelStrip() {
   DCHECK(panels_.empty());
   DCHECK(!overflow_indicator_.get());
 }
 
-void PanelOverflowStrip::SetDisplayArea(const gfx::Rect& display_area) {
+void OverflowPanelStrip::SetDisplayArea(const gfx::Rect& display_area) {
   if (display_area_ == display_area)
     return;
   display_area_ = display_area;
@@ -62,7 +62,7 @@ void PanelOverflowStrip::SetDisplayArea(const gfx::Rect& display_area) {
   Refresh();
 }
 
-void PanelOverflowStrip::UpdateMaxVisiblePanelsOnHover() {
+void OverflowPanelStrip::UpdateMaxVisiblePanelsOnHover() {
   // No need to recompute this value.
   if (max_visible_panels_on_hover_ || panels_.empty())
     return;
@@ -73,12 +73,12 @@ void PanelOverflowStrip::UpdateMaxVisiblePanelsOnHover() {
       panels_.front()->IconOnlySize().height();
 }
 
-void PanelOverflowStrip::UpdateCurrentWidth() {
+void OverflowPanelStrip::UpdateCurrentWidth() {
   current_display_width_ = are_overflow_titles_shown_ ? kOverflowAreaHoverWidth
                                                       : display_area_.width();
 }
 
-void PanelOverflowStrip::AddPanel(Panel* panel) {
+void OverflowPanelStrip::AddPanel(Panel* panel) {
   // TODO(jianli): consider using other container to improve the perf for
   // inserting to the front. http://crbug.com/106222
   DCHECK_EQ(Panel::IN_OVERFLOW, panel->expansion_state());
@@ -110,7 +110,7 @@ void PanelOverflowStrip::AddPanel(Panel* panel) {
   }
 }
 
-bool PanelOverflowStrip::Remove(Panel* panel) {
+bool OverflowPanelStrip::Remove(Panel* panel) {
   size_t index = 0;
   Panels::iterator iter = panels_.begin();
   for (; iter != panels_.end(); ++iter, ++index)
@@ -136,7 +136,7 @@ bool PanelOverflowStrip::Remove(Panel* panel) {
   return true;
 }
 
-void PanelOverflowStrip::RemoveAll() {
+void OverflowPanelStrip::RemoveAll() {
   // Make a copy of the iterator as closing panels can modify the vector.
   Panels panels_copy = panels_;
 
@@ -146,29 +146,29 @@ void PanelOverflowStrip::RemoveAll() {
     (*iter)->Close();
 }
 
-void PanelOverflowStrip::OnPanelExpansionStateChanged(Panel* panel) {
+void OverflowPanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
   // Only care about new state being overflow.
   if (panel->expansion_state() != Panel::IN_OVERFLOW)
     return;
 
-  panel_manager_->panel_strip()->Remove(panel);
+  panel_manager_->docked_strip()->Remove(panel);
   AddPanel(panel);
   panel->SetAppIconVisibility(false);
   panel->set_draggable(false);
 }
 
-void PanelOverflowStrip::OnPanelAttentionStateChanged(Panel* panel) {
+void OverflowPanelStrip::OnPanelAttentionStateChanged(Panel* panel) {
   DCHECK(panel->expansion_state() == Panel::IN_OVERFLOW);
   UpdateOverflowIndicatorAttention();
 }
 
-void PanelOverflowStrip::Refresh() {
+void OverflowPanelStrip::Refresh() {
   if (panels_.empty())
     return;
   DoRefresh(0, panels_.size() - 1);
 }
 
-void PanelOverflowStrip::DoRefresh(size_t start_index, size_t end_index) {
+void OverflowPanelStrip::DoRefresh(size_t start_index, size_t end_index) {
   if (panels_.empty() || start_index == panels_.size())
     return;
 
@@ -182,7 +182,7 @@ void PanelOverflowStrip::DoRefresh(size_t start_index, size_t end_index) {
   }
 }
 
-void PanelOverflowStrip::UpdateOverflowIndicatorCount() {
+void OverflowPanelStrip::UpdateOverflowIndicatorCount() {
   if (!overflow_indicator_.get())
     return;
 
@@ -208,7 +208,7 @@ void PanelOverflowStrip::UpdateOverflowIndicatorCount() {
   UpdateOverflowIndicatorAttention();
 }
 
-void PanelOverflowStrip::UpdateOverflowIndicatorAttention() {
+void OverflowPanelStrip::UpdateOverflowIndicatorAttention() {
   if (!overflow_indicator_.get())
     return;
 
@@ -229,7 +229,7 @@ void PanelOverflowStrip::UpdateOverflowIndicatorAttention() {
     overflow_indicator_->StopDrawingAttention();
 }
 
-gfx::Rect PanelOverflowStrip::ComputeLayout(
+gfx::Rect OverflowPanelStrip::ComputeLayout(
     size_t index, const gfx::Size& iconified_size) const {
   DCHECK(index != kInvalidPanelIndex);
 
@@ -251,12 +251,12 @@ gfx::Rect PanelOverflowStrip::ComputeLayout(
   return bounds;
 }
 
-void PanelOverflowStrip::OnMouseMove(const gfx::Point& mouse_position) {
+void OverflowPanelStrip::OnMouseMove(const gfx::Point& mouse_position) {
   bool show_overflow_titles = ShouldShowOverflowTitles(mouse_position);
   ShowOverflowTitles(show_overflow_titles);
 }
 
-bool PanelOverflowStrip::ShouldShowOverflowTitles(
+bool OverflowPanelStrip::ShouldShowOverflowTitles(
     const gfx::Point& mouse_position) const {
   if (panels_.empty())
     return false;
@@ -268,7 +268,7 @@ bool PanelOverflowStrip::ShouldShowOverflowTitles(
          mouse_position.y() <= display_area_.bottom();
 }
 
-void PanelOverflowStrip::ShowOverflowTitles(bool show_overflow_titles) {
+void OverflowPanelStrip::ShowOverflowTitles(bool show_overflow_titles) {
   if (show_overflow_titles == are_overflow_titles_shown_)
     return;
   are_overflow_titles_shown_ = show_overflow_titles;
@@ -308,14 +308,14 @@ void PanelOverflowStrip::ShowOverflowTitles(bool show_overflow_titles) {
   UpdateOverflowIndicatorCount();
 }
 
-void PanelOverflowStrip::AnimationEnded(const ui::Animation* animation) {
+void OverflowPanelStrip::AnimationEnded(const ui::Animation* animation) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
-      content::Source<PanelOverflowStrip>(this),
+      content::Source<OverflowPanelStrip>(this),
       content::NotificationService::NoDetails());
 }
 
-void PanelOverflowStrip::AnimationProgressed(const ui::Animation* animation) {
+void OverflowPanelStrip::AnimationProgressed(const ui::Animation* animation) {
   int current_display_width = overflow_hover_animator_->CurrentValueBetween(
       overflow_hover_animator_start_width_, overflow_hover_animator_end_width_);
   bool end_of_shrinking = current_display_width == display_area_.width();
@@ -347,7 +347,7 @@ void PanelOverflowStrip::AnimationProgressed(const ui::Animation* animation) {
   }
 }
 
-void PanelOverflowStrip::OnFullScreenModeChanged(bool is_full_screen) {
+void OverflowPanelStrip::OnFullScreenModeChanged(bool is_full_screen) {
   for (size_t i = 0; i < panels_.size(); ++i)
     panels_[i]->FullScreenModeChanged(is_full_screen);
 }
diff --git a/chrome/browser/ui/panels/panel_overflow_strip.h b/chrome/browser/ui/panels/overflow_panel_strip.h
index 7231fda..372cfa7 100644
--- a/chrome/browser/ui/panels/panel_overflow_strip.h
+++ b/chrome/browser/ui/panels/overflow_panel_strip.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_UI_PANELS_PANEL_OVERFLOW_STRIP_H_
-#define CHROME_BROWSER_UI_PANELS_PANEL_OVERFLOW_STRIP_H_
+#ifndef CHROME_BROWSER_UI_PANELS_OVERFLOW_PANEL_STRIP_H_
+#define CHROME_BROWSER_UI_PANELS_OVERFLOW_PANEL_STRIP_H_
 #pragma once
 
 #include <vector>
@@ -19,13 +19,13 @@ class SlideAnimation;
 }
 
 // Manipulates all the panels that are placed on the left-most overflow area.
-class PanelOverflowStrip : public PanelMouseWatcherObserver,
+class OverflowPanelStrip : public PanelMouseWatcherObserver,
                            public ui::AnimationDelegate {
  public:
   typedef std::vector<Panel*> Panels;
 
-  explicit PanelOverflowStrip(PanelManager* panel_manager);
-  virtual ~PanelOverflowStrip();
+  explicit OverflowPanelStrip(PanelManager* panel_manager);
+  virtual ~OverflowPanelStrip();
 
   // Sets the display area of the overflow strip.
   // |display_area| is in screen coordinates.
@@ -107,7 +107,7 @@ class PanelOverflowStrip : public PanelMouseWatcherObserver,
                                       : max_visible_panels_;
   }
 
-  // Weak pointer since PanelManager owns PanelOverflowStrip instance.
+  // Weak pointer since PanelManager owns OverflowPanelStrip instance.
   PanelManager* panel_manager_;
 
   // The queue for storing all panels.
@@ -143,7 +143,7 @@ class PanelOverflowStrip : public PanelMouseWatcherObserver,
   // Invalid panel index.
   static const size_t kInvalidPanelIndex = static_cast<size_t>(-1);
 
-  DISALLOW_COPY_AND_ASSIGN(PanelOverflowStrip);
+  DISALLOW_COPY_AND_ASSIGN(OverflowPanelStrip);
 };
 
-#endif  // CHROME_BROWSER_UI_PANELS_PANEL_OVERFLOW_STRIP_H_
+#endif  // CHROME_BROWSER_UI_PANELS_OVERFLOW_PANEL_STRIP_H_
diff --git a/chrome/browser/ui/panels/panel_browsertest.cc b/chrome/browser/ui/panels/panel_browsertest.cc
index 17afe21..01b50550 100644
--- a/chrome/browser/ui/panels/panel_browsertest.cc
+++ b/chrome/browser/ui/panels/panel_browsertest.cc
@@ -23,11 +23,11 @@
 #include "chrome/browser/ui/find_bar/find_bar.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/panels/base_panel_browser_test.h"
+#include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/native_panel.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_settings_menu_model.h"
-#include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/browser/ui/panels/test_panel_mouse_watcher.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
diff --git a/chrome/browser/ui/panels/panel_manager.cc b/chrome/browser/ui/panels/panel_manager.cc
index 25ca6e0..8925fca 100644
--- a/chrome/browser/ui/panels/panel_manager.cc
+++ b/chrome/browser/ui/panels/panel_manager.cc
@@ -10,9 +10,9 @@
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/panels/docked_panel_strip.h"
+#include "chrome/browser/ui/panels/overflow_panel_strip.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
-#include "chrome/browser/ui/panels/panel_overflow_strip.h"
-#include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
@@ -63,8 +63,8 @@ PanelManager::PanelManager()
     : panel_mouse_watcher_(PanelMouseWatcher::Create()),
       auto_sizing_enabled_(true),
       is_full_screen_(false) {
-  panel_strip_.reset(new PanelStrip(this));
-  panel_overflow_strip_.reset(new PanelOverflowStrip(this));
+  docked_strip_.reset(new DockedPanelStrip(this));
+  overflow_strip_.reset(new OverflowPanelStrip(this));
   auto_hiding_desktop_bar_ = AutoHidingDesktopBar::Create(this);
   OnDisplayChanged();
 }
@@ -96,24 +96,24 @@ void PanelManager::SetWorkArea(const gfx::Rect& work_area) {
 void PanelManager::Layout() {
   int height =
       static_cast<int>(adjusted_work_area_.height() * kPanelStripHeightFactor);
-  gfx::Rect panel_strip_bounds;
-  panel_strip_bounds.set_x(adjusted_work_area_.x() + kPanelStripLeftMargin);
-  panel_strip_bounds.set_y(adjusted_work_area_.bottom() - height);
-  panel_strip_bounds.set_width(adjusted_work_area_.width() -
-                               kPanelStripLeftMargin - kPanelStripRightMargin);
-  panel_strip_bounds.set_height(height);
-  panel_strip_->SetDisplayArea(panel_strip_bounds);
+  gfx::Rect docked_strip_bounds;
+  docked_strip_bounds.set_x(adjusted_work_area_.x() + kPanelStripLeftMargin);
+  docked_strip_bounds.set_y(adjusted_work_area_.bottom() - height);
+  docked_strip_bounds.set_width(adjusted_work_area_.width() -
+                                kPanelStripLeftMargin - kPanelStripRightMargin);
+  docked_strip_bounds.set_height(height);
+  docked_strip_->SetDisplayArea(docked_strip_bounds);
 
   gfx::Rect overflow_area(adjusted_work_area_);
   overflow_area.set_width(kOverflowStripThickness);
-  panel_overflow_strip_->SetDisplayArea(overflow_area);
+  overflow_strip_->SetDisplayArea(overflow_area);
 }
 
 Panel* PanelManager::CreatePanel(Browser* browser) {
   int width = browser->override_bounds().width();
   int height = browser->override_bounds().height();
   Panel* panel = new Panel(browser, gfx::Size(width, height));
-  panel_strip_->AddPanel(panel);
+  docked_strip_->AddPanel(panel);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_ADDED,
@@ -135,7 +135,7 @@ Panel* PanelManager::CreatePanel(Browser* browser) {
 }
 
 int PanelManager::StartingRightPosition() const {
-  return panel_strip_->StartingRightPosition();
+  return docked_strip_->StartingRightPosition();
 }
 
 void PanelManager::CheckFullScreenMode() {
@@ -143,8 +143,8 @@ void PanelManager::CheckFullScreenMode() {
   if (is_full_screen_ == is_full_screen_new)
     return;
   is_full_screen_ = is_full_screen_new;
-  panel_strip_->OnFullScreenModeChanged(is_full_screen_);
-  panel_overflow_strip_->OnFullScreenModeChanged(is_full_screen_);
+  docked_strip_->OnFullScreenModeChanged(is_full_screen_);
+  overflow_strip_->OnFullScreenModeChanged(is_full_screen_);
 }
 
 void PanelManager::Remove(Panel* panel) {
@@ -153,9 +153,9 @@ void PanelManager::Remove(Panel* panel) {
     full_screen_mode_timer_.Stop();
 #endif
 
-  if (panel_strip_->Remove(panel))
+  if (docked_strip_->Remove(panel))
     return;
-  bool removed = panel_overflow_strip_->Remove(panel);
+  bool removed = overflow_strip_->Remove(panel);
   DCHECK(removed);
 }
 
@@ -167,32 +167,32 @@ void PanelManager::OnPanelRemoved(Panel* panel) {
 }
 
 void PanelManager::StartDragging(Panel* panel) {
-  panel_strip_->StartDragging(panel);
+  docked_strip_->StartDragging(panel);
 }
 
 void PanelManager::Drag(int delta_x) {
-  panel_strip_->Drag(delta_x);
+  docked_strip_->Drag(delta_x);
 }
 
 void PanelManager::EndDragging(bool cancelled) {
-  panel_strip_->EndDragging(cancelled);
+  docked_strip_->EndDragging(cancelled);
 }
 
 void PanelManager::OnPanelExpansionStateChanged(Panel* panel) {
-  panel_strip_->OnPanelExpansionStateChanged(panel);
-  panel_overflow_strip_->OnPanelExpansionStateChanged(panel);
+  docked_strip_->OnPanelExpansionStateChanged(panel);
+  overflow_strip_->OnPanelExpansionStateChanged(panel);
 }
 
 void PanelManager::OnPanelAttentionStateChanged(Panel* panel) {
   if (panel->expansion_state() == Panel::IN_OVERFLOW)
-    panel_overflow_strip_->OnPanelAttentionStateChanged(panel);
+    overflow_strip_->OnPanelAttentionStateChanged(panel);
 }
 
 void PanelManager::OnPreferredWindowSizeChanged(
     Panel* panel, const gfx::Size& preferred_window_size) {
   if (!auto_sizing_enabled_)
     return;
-  panel_strip_->OnWindowSizeChanged(panel, preferred_window_size);
+  docked_strip_->OnWindowSizeChanged(panel, preferred_window_size);
 }
 
 void PanelManager::ResizePanel(Panel* panel, const gfx::Size& new_size) {
@@ -202,15 +202,15 @@ void PanelManager::ResizePanel(Panel* panel, const gfx::Size& new_size) {
     LOG(INFO) << "Resizing auto-resizable Panels is not supported yet.";
     return;
   }
-  panel_strip_->OnWindowSizeChanged(panel, new_size);
+  docked_strip_->OnWindowSizeChanged(panel, new_size);
 }
 
 bool PanelManager::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
-  return panel_strip_->ShouldBringUpTitlebars(mouse_x, mouse_y);
+  return docked_strip_->ShouldBringUpTitlebars(mouse_x, mouse_y);
 }
 
 void PanelManager::BringUpOrDownTitlebars(bool bring_up) {
-  panel_strip_->BringUpOrDownTitlebars(bring_up);
+  docked_strip_->BringUpOrDownTitlebars(bring_up);
 }
 
 void PanelManager::AdjustWorkAreaForAutoHidingDesktopBars() {
@@ -252,23 +252,23 @@ void PanelManager::OnAutoHidingDesktopBarThicknessChanged() {
 void PanelManager::OnAutoHidingDesktopBarVisibilityChanged(
     AutoHidingDesktopBar::Alignment alignment,
     AutoHidingDesktopBar::Visibility visibility) {
-  panel_strip_->OnAutoHidingDesktopBarVisibilityChanged(alignment, visibility);
+  docked_strip_->OnAutoHidingDesktopBarVisibilityChanged(alignment, visibility);
 }
 
 void PanelManager::RemoveAll() {
-  panel_strip_->RemoveAll();
-  panel_overflow_strip_->RemoveAll();
+  docked_strip_->RemoveAll();
+  overflow_strip_->RemoveAll();
 }
 
 int PanelManager::num_panels() const {
-  return panel_strip_->num_panels() + panel_overflow_strip_->num_panels();
+  return docked_strip_->num_panels() + overflow_strip_->num_panels();
 }
 
 std::vector<Panel*> PanelManager::panels() const {
-  std::vector<Panel*> panels = panel_strip_->panels();
-  for (PanelOverflowStrip::Panels::const_iterator iter =
-           panel_overflow_strip_->panels().begin();
-       iter != panel_overflow_strip_->panels().end(); ++iter)
+  std::vector<Panel*> panels = docked_strip_->panels();
+  for (OverflowPanelStrip::Panels::const_iterator iter =
+           overflow_strip_->panels().begin();
+       iter != overflow_strip_->panels().end(); ++iter)
     panels.push_back(*iter);
   return panels;
 }
diff --git a/chrome/browser/ui/panels/panel_manager.h b/chrome/browser/ui/panels/panel_manager.h
index 3815813..f5c9ccf 100644
--- a/chrome/browser/ui/panels/panel_manager.h
+++ b/chrome/browser/ui/panels/panel_manager.h
@@ -17,8 +17,8 @@
 
 class Browser;
 class PanelMouseWatcher;
-class PanelOverflowStrip;
-class PanelStrip;
+class OverflowPanelStrip;
+class DockedPanelStrip;
 
 // This class manages a set of panels.
 class PanelManager : public AutoHidingDesktopBar::Observer {
@@ -86,13 +86,13 @@ class PanelManager : public AutoHidingDesktopBar::Observer {
     return panel_mouse_watcher_.get();
   }
 
-  PanelStrip* panel_strip() const {
-    return panel_strip_.get();
+  DockedPanelStrip* docked_strip() const {
+    return docked_strip_.get();
   }
 
   bool is_full_screen() const { return is_full_screen_; }
-  PanelOverflowStrip* panel_overflow_strip() const {
-    return panel_overflow_strip_.get();
+  OverflowPanelStrip* overflow_strip() const {
+    return overflow_strip_.get();
   }
 
   // Reduces time interval in tests to shorten test run time.
@@ -162,8 +162,8 @@ class PanelManager : public AutoHidingDesktopBar::Observer {
   // Tests may want to shorten time intervals to reduce running time.
   static bool shorten_time_intervals_;
 
-  scoped_ptr<PanelStrip> panel_strip_;
-  scoped_ptr<PanelOverflowStrip> panel_overflow_strip_;
+  scoped_ptr<DockedPanelStrip> docked_strip_;
+  scoped_ptr<OverflowPanelStrip> overflow_strip_;
 
   // Use a mouse watcher to know when to bring up titlebars to "peek" at
   // minimized panels. Mouse movement is only tracked when there is a minimized
diff --git a/chrome/browser/ui/panels/panel_overflow_browsertest.cc b/chrome/browser/ui/panels/panel_overflow_browsertest.cc
index 920dab1..e7b6b06 100644
--- a/chrome/browser/ui/panels/panel_overflow_browsertest.cc
+++ b/chrome/browser/ui/panels/panel_overflow_browsertest.cc
@@ -5,13 +5,13 @@
 #include <vector>
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/panels/base_panel_browser_test.h"
+#include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/native_panel.h"
+#include "chrome/browser/ui/panels/overflow_panel_strip.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_overflow_indicator.h"
-#include "chrome/browser/ui/panels/panel_overflow_strip.h"
 #include "chrome/browser/ui/panels/panel_settings_menu_model.h"
-#include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/browser/ui/panels/test_panel_mouse_watcher.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/test/base/ui_test_utils.h"
@@ -89,9 +89,9 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
     BasePanelBrowserTest::SetUpOnMainThread();
 
     PanelManager* panel_manager = PanelManager::GetInstance();
-    panel_manager->panel_overflow_strip()->set_max_visible_panels(
+    panel_manager->overflow_strip()->set_max_visible_panels(
         kMaxVisibleOverflowPanelsForTesting);
-    panel_manager->panel_overflow_strip()->set_max_visible_panels_on_hover(
+    panel_manager->overflow_strip()->set_max_visible_panels_on_hover(
         kMaxVisibleOverflowPanelsOnHoverForTesting);
 
     PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
@@ -102,11 +102,11 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
   }
 
  protected:
-  static PanelDataList GetAllNormalPanelData() {
+  static PanelDataList GetAllDockedPanelData() {
     PanelDataList panel_data_list;
-    PanelStrip::Panels panels =
-        PanelManager::GetInstance()->panel_strip()->panels();
-    for (PanelStrip::Panels::const_iterator iter = panels.begin();
+    DockedPanelStrip::Panels panels =
+        PanelManager::GetInstance()->docked_strip()->panels();
+    for (DockedPanelStrip::Panels::const_iterator iter = panels.begin();
          iter != panels.end(); ++iter) {
       Panel* panel = *iter;
       panel_data_list.push_back(PanelData(panel));
@@ -116,9 +116,9 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
 
   static PanelDataList GetAllOverflowPanelData() {
     PanelDataList panel_data_list;
-    PanelOverflowStrip::Panels panels =
-        PanelManager::GetInstance()->panel_overflow_strip()->panels();
-    for (PanelOverflowStrip::Panels::const_iterator iter = panels.begin();
+    OverflowPanelStrip::Panels panels =
+        PanelManager::GetInstance()->overflow_strip()->panels();
+    for (OverflowPanelStrip::Panels::const_iterator iter = panels.begin();
          iter != panels.end(); ++iter) {
       Panel* panel = *iter;
       panel_data_list.push_back(PanelData(panel));
@@ -130,8 +130,8 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
       const gfx::Point& position) {
     ui_test_utils::WindowedNotificationObserver signal(
         chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
-        content::Source<PanelOverflowStrip>(
-            PanelManager::GetInstance()->panel_overflow_strip()));
+        content::Source<OverflowPanelStrip>(
+            PanelManager::GetInstance()->overflow_strip()));
     MoveMouse(position);
     signal.Wait();
   }
@@ -141,8 +141,8 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
   }
 
   static bool IsPanelInOverflowStrip(Panel* panel) {
-    PanelOverflowStrip* overflow_strip =
-        PanelManager::GetInstance()->panel_overflow_strip();
+    OverflowPanelStrip* overflow_strip =
+        PanelManager::GetInstance()->overflow_strip();
     int expected_x = overflow_strip->display_area().x();
     gfx::Size expected_size(overflow_strip->current_display_width(),
                             panel->IconOnlySize().height());
@@ -152,15 +152,15 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
     return expected_x == bounds.x() && expected_size == bounds.size();
   }
 
-  std::vector<Panel*> CreateOverflowPanels(int num_normal_panels,
+  std::vector<Panel*> CreateOverflowPanels(int num_docked_panales,
                                            int num_overflow_panels,
                                            const int* panel_widths) {
     const int kTestPanelHeight = 200;
     std::vector<Panel*> panels;
 
-    // First, create normal panels to fill the panel strip.
+    // First, create panels to fill the docked strip.
     int i = 0;
-    for (; i < num_normal_panels; ++i) {
+    for (; i < num_docked_panales; ++i) {
       CreatePanelParams params(
           MakePanelName(i),
           gfx::Rect(0, 0, panel_widths[i], kTestPanelHeight),
@@ -170,7 +170,7 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
     }
 
     // Then, create panels that would be placed in the overflow strip.
-    int num_panels = num_normal_panels + num_overflow_panels;
+    int num_panels = num_docked_panales + num_overflow_panels;
     for (; i < num_panels; ++i) {
       CreatePanelParams params(
           MakePanelName(i),
@@ -195,7 +195,7 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
 // http://crbug.com/107230
 #define MAYBE_CreatePanelOnDelayedOverflow CreatePanelOnDelayedOverflow
 #define MAYBE_CloseOverflowPanels CloseOverflowPanels
-#define MAYBE_CloseNormalPanels CloseNormalPanels
+#define MAYBE_CloseDockedPanels CloseDockedPanels
 #define MAYBE_CloseWithDelayedOverflow CloseWithDelayedOverflow
 #define MAYBE_ActivateOverflowPanels ActivateOverflowPanels
 #define MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate \
@@ -216,7 +216,7 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
 #define MAYBE_CreateMoreOverflowPanels DISABLED_CreateMoreOverflowPanels
 #define MAYBE_CreatePanelOnDelayedOverflow DISABLED_CreatePanelOnDelayedOverflow
 #define MAYBE_CloseOverflowPanels DISABLED_CloseOverflowPanels
-#define MAYBE_CloseNormalPanels DISABLED_CloseNormalPanels
+#define MAYBE_CloseDockedPanels DISABLED_CloseDockedPanels
 #define MAYBE_CloseWithDelayedOverflow DISABLED_CloseWithDelayedOverflow
 #define MAYBE_ActivateOverflowPanels DISABLED_ActivateOverflowPanels
 #define MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate \
@@ -280,24 +280,24 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_UpdateDraggableStatus) {
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelStrip* panel_strip = panel_manager->panel_strip();
-  PanelOverflowStrip* panel_overflow_strip =
-      panel_manager->panel_overflow_strip();
+  DockedPanelStrip* docked_strip = panel_manager->docked_strip();
+  OverflowPanelStrip* overflow_strip =
+      panel_manager->overflow_strip();
 
   EXPECT_EQ(0, panel_manager->num_panels());
-  EXPECT_EQ(0, panel_strip->num_panels());
-  EXPECT_EQ(0, panel_overflow_strip->num_panels());
-  EXPECT_FALSE(panel_overflow_strip->overflow_indicator());
+  EXPECT_EQ(0, docked_strip->num_panels());
+  EXPECT_EQ(0, overflow_strip->num_panels());
+  EXPECT_FALSE(overflow_strip->overflow_indicator());
 
-  // Create 3 normal panels.
+  // Create 3 docked panels.
   Panel* panel0 = CreatePanelWithBounds("Panel0", gfx::Rect(0, 0, 250, 200));
   Panel* panel1 = CreatePanelWithBounds("Panel1", gfx::Rect(0, 0, 260, 200));
   Panel* panel2 = CreatePanelWithBounds("Panel2", gfx::Rect(0, 0, 200, 200));
 
   EXPECT_EQ(3, panel_manager->num_panels());
-  EXPECT_EQ(3, panel_strip->num_panels());
-  EXPECT_EQ(0, panel_overflow_strip->num_panels());
-  EXPECT_FALSE(panel_overflow_strip->overflow_indicator());
+  EXPECT_EQ(3, docked_strip->num_panels());
+  EXPECT_EQ(0, overflow_strip->num_panels());
+  EXPECT_FALSE(overflow_strip->overflow_indicator());
   EXPECT_EQ(Panel::EXPANDED, panel0->expansion_state());
   EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state());
   EXPECT_EQ(Panel::EXPANDED, panel2->expansion_state());
@@ -309,9 +309,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) {
   WaitForExpansionStateChanged(panel3, Panel::IN_OVERFLOW);
 
   EXPECT_EQ(4, panel_manager->num_panels());
-  EXPECT_EQ(3, panel_strip->num_panels());
-  EXPECT_EQ(1, panel_overflow_strip->num_panels());
-  EXPECT_FALSE(panel_overflow_strip->overflow_indicator());
+  EXPECT_EQ(3, docked_strip->num_panels());
+  EXPECT_EQ(1, overflow_strip->num_panels());
+  EXPECT_FALSE(overflow_strip->overflow_indicator());
   EXPECT_TRUE(IsPanelVisible(panel3));
   EXPECT_TRUE(IsPanelInOverflowStrip(panel3));
   EXPECT_EQ(gfx::Size(255, 200), panel3->restored_size());
@@ -322,9 +322,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) {
   WaitForExpansionStateChanged(panel4, Panel::IN_OVERFLOW);
 
   EXPECT_EQ(5, panel_manager->num_panels());
-  EXPECT_EQ(3, panel_strip->num_panels());
-  EXPECT_EQ(2, panel_overflow_strip->num_panels());
-  EXPECT_FALSE(panel_overflow_strip->overflow_indicator());
+  EXPECT_EQ(3, docked_strip->num_panels());
+  EXPECT_EQ(2, overflow_strip->num_panels());
+  EXPECT_FALSE(overflow_strip->overflow_indicator());
   EXPECT_TRUE(IsPanelVisible(panel4));
 
   PanelManager::GetInstance()->RemoveAll();
@@ -333,12 +333,12 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) {
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
                        MAYBE_CreateMoreOverflowPanels) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelStrip* panel_strip = panel_manager->panel_strip();
-  PanelOverflowStrip* panel_overflow_strip =
-      panel_manager->panel_overflow_strip();
+  DockedPanelStrip* docked_strip = panel_manager->docked_strip();
+  OverflowPanelStrip* overflow_strip =
+      panel_manager->overflow_strip();
 
   const int panel_widths[] = {
-      250, 260, 200,  // normal
+      250, 260, 200,  // docked
       255, 220, 210,  // overflow
       220, 230        // overflow-on-overflow
   };
@@ -346,9 +346,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
 
   std::vector<Panel*> panels = panel_manager->panels();
   ASSERT_EQ(8u, panels.size());
-  EXPECT_EQ(3, panel_strip->num_panels());
-  EXPECT_EQ(5, panel_overflow_strip->num_panels());
-  EXPECT_EQ(2, panel_overflow_strip->overflow_indicator()->GetCount());
+  EXPECT_EQ(3, docked_strip->num_panels());
+  EXPECT_EQ(5, overflow_strip->num_panels());
+  EXPECT_EQ(2, overflow_strip->overflow_indicator()->GetCount());
   EXPECT_EQ(Panel::IN_OVERFLOW, panels[3]->expansion_state());
   EXPECT_TRUE(IsPanelVisible(panels[3]));
   EXPECT_EQ(Panel::IN_OVERFLOW, panels[4]->expansion_state());
@@ -392,29 +392,29 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelStrip* panel_strip = panel_manager->panel_strip();
-  PanelOverflowStrip* panel_overflow_strip =
-      panel_manager->panel_overflow_strip();
+  DockedPanelStrip* docked_strip = panel_manager->docked_strip();
+  OverflowPanelStrip* overflow_strip =
+      panel_manager->overflow_strip();
 
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5
   //   overflow-on-overflow: P6, P7
-  int num_normal_panels = 3;
+  int num_docked_panales = 3;
   int num_overflow_panels = 5;
   const int panel_widths[] = {
-      260, 250, 200,  // normal
+      260, 250, 200,  // docked
       255, 260, 120,  // overflow
       240, 210        // overflow-on-overflow
   };
   std::vector<Panel*> panels = CreateOverflowPanels(
-      num_normal_panels, num_overflow_panels, panel_widths);
+      num_docked_panales, num_overflow_panels, panel_widths);
 
-  PanelDataList expected_normal_list;
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  PanelDataList expected_docked_list;
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   PanelDataList expected_overflow_list;
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -425,17 +425,17 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
   // Close an overflow-on-overflow panel. Expect only that panel is closed.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5,
   //   overflow-on-overflow: P7
   CloseWindowAndWait(panels[6]->browser());
   num_overflow_panels--;
-  ASSERT_EQ(num_normal_panels + num_overflow_panels,
+  ASSERT_EQ(num_docked_panales + num_overflow_panels,
             panel_manager->num_panels());
-  EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
-  EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
+  EXPECT_EQ(num_docked_panales, docked_strip->num_panels());
+  EXPECT_EQ(num_overflow_panels, overflow_strip->num_panels());
 
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -446,16 +446,16 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
 
   // Close an overflow panel. Expect an overflow-on-overflow panel to become
   // visible in the overflow strip.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P5, P7
   CloseWindowAndWait(panels[4]->browser());
   num_overflow_panels--;
-  ASSERT_EQ(num_normal_panels + num_overflow_panels,
+  ASSERT_EQ(num_docked_panales + num_overflow_panels,
             panel_manager->num_panels());
-  EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
-  EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
+  EXPECT_EQ(num_docked_panales, docked_strip->num_panels());
+  EXPECT_EQ(num_overflow_panels, overflow_strip->num_panels());
 
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -464,16 +464,16 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
   // Close an overflow panel. Expect only that panel is closed.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P5, P7
   CloseWindowAndWait(panels[3]->browser());
   num_overflow_panels--;
-  ASSERT_EQ(num_normal_panels + num_overflow_panels,
+  ASSERT_EQ(num_docked_panales + num_overflow_panels,
             panel_manager->num_panels());
-  EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
-  EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
+  EXPECT_EQ(num_docked_panales, docked_strip->num_panels());
+  EXPECT_EQ(num_overflow_panels, overflow_strip->num_panels());
 
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false);
@@ -483,31 +483,31 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   panel_manager->RemoveAll();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseDockedPanels) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelStrip* panel_strip = panel_manager->panel_strip();
-  PanelOverflowStrip* panel_overflow_strip =
-      panel_manager->panel_overflow_strip();
+  DockedPanelStrip* docked_strip = panel_manager->docked_strip();
+  OverflowPanelStrip* overflow_strip =
+      panel_manager->overflow_strip();
 
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5
   //   overflow-on-overflow: P6, P7, P8
-  int num_normal_panels = 3;
+  int num_docked_panales = 3;
   int num_overflow_panels = 6;
   const int panel_widths[] = {
-      260, 250, 200,  // normal
+      260, 250, 200,  // docked
       255, 260, 120,  // overflow
       240, 210, 258   // overflow-on-overflow
   };
   std::vector<Panel*> panels = CreateOverflowPanels(
-      num_normal_panels, num_overflow_panels, panel_widths);
+      num_docked_panales, num_overflow_panels, panel_widths);
 
-  PanelDataList expected_normal_list;
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  PanelDataList expected_docked_list;
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   PanelDataList expected_overflow_list;
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -518,23 +518,23 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   expected_overflow_list.Add(panels[8], Panel::IN_OVERFLOW, false, false);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Close a normal panel. Expect an overflow panel to move over and an
+  // Close a docked panel. Expect an overflow panel to move over and an
   // overflow-on-overflow panel to become visible.
-  //   normal:               P0, P2, P3
+  //   docked:               P0, P2, P3
   //   overflow:             P4, P5, P6
   //   overflow-on-overflow: P7, P8
   CloseWindowAndWait(panels[1]->browser());
   num_overflow_panels--;
-  ASSERT_EQ(num_normal_panels + num_overflow_panels,
+  ASSERT_EQ(num_docked_panales + num_overflow_panels,
             panel_manager->num_panels());
-  EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
-  EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
+  EXPECT_EQ(num_docked_panales, docked_strip->num_panels());
+  EXPECT_EQ(num_overflow_panels, overflow_strip->num_panels());
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[3], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[3], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false);
@@ -544,42 +544,42 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   expected_overflow_list.Add(panels[8], Panel::IN_OVERFLOW, false, false);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Close another normal panel. Remaining overflow panels cannot move over
+  // Close another docked panel. Remaining overflow panels cannot move over
   // due to not enough room.
-  //   normal:               P0, P3
+  //   docked:               P0, P3
   //   overflow:             P4, P5, P6
   //   overflow-on-overflow: P7, P8
   CloseWindowAndWait(panels[2]->browser());
-  num_normal_panels--;
-  ASSERT_EQ(num_normal_panels + num_overflow_panels,
+  num_docked_panales--;
+  ASSERT_EQ(num_docked_panales + num_overflow_panels,
             panel_manager->num_panels());
-  EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
-  EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
+  EXPECT_EQ(num_docked_panales, docked_strip->num_panels());
+  EXPECT_EQ(num_overflow_panels, overflow_strip->num_panels());
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[3], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[3], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Close one more normal panel. Expect two overflow panels to move over and
+  // Close one more docked panel. Expect two overflow panels to move over and
   // two overflow-on-overflow panels to become visible.
-  //   normal:               P0, P4, P5
+  //   docked:               P0, P4, P5
   //   overflow:             P6, P7, P8
   CloseWindowAndWait(panels[3]->browser());
-  num_normal_panels++;
+  num_docked_panales++;
   num_overflow_panels -= 2;
-  ASSERT_EQ(num_normal_panels + num_overflow_panels,
+  ASSERT_EQ(num_docked_panales + num_overflow_panels,
             panel_manager->num_panels());
-  EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
-  EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
+  EXPECT_EQ(num_docked_panales, docked_strip->num_panels());
+  EXPECT_EQ(num_overflow_panels, overflow_strip->num_panels());
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[4], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[5], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[4], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[5], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, true, false);
@@ -587,21 +587,21 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   expected_overflow_list.Add(panels[8], Panel::IN_OVERFLOW, true, false);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Close another normal panel. Expect one overflow panel to move over.
-  //   normal:               P4, P5, P6
+  // Close another docked panel. Expect one overflow panel to move over.
+  //   docked:               P4, P5, P6
   //   overflow:             P7, P8
   CloseWindowAndWait(panels[0]->browser());
   num_overflow_panels--;
-  ASSERT_EQ(num_normal_panels + num_overflow_panels,
+  ASSERT_EQ(num_docked_panales + num_overflow_panels,
             panel_manager->num_panels());
-  EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
-  EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
+  EXPECT_EQ(num_docked_panales, docked_strip->num_panels());
+  EXPECT_EQ(num_overflow_panels, overflow_strip->num_panels());
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[4], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[5], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[6], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[4], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[5], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[6], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, true, false);
@@ -614,7 +614,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
                        MAYBE_CloseWithDelayedOverflow) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelStrip* panel_strip = panel_manager->panel_strip();
+  DockedPanelStrip* docked_strip = panel_manager->docked_strip();
 
   // Create 2 big panels.
   Panel* panel0 = CreatePanelWithBounds("Panel0", gfx::Rect(0, 0, 260, 200));
@@ -625,20 +625,20 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
       "Panel2", gfx::Rect(0, 0, 255, 200), SHOW_AS_INACTIVE);
   params.wait_for_fully_created = false;
   Panel* overflow_panel = CreatePanelWithParams(params);
-  EXPECT_EQ(2, panel_strip->num_panels());
-  EXPECT_EQ(1, panel_strip->num_temporary_layout_panels());
+  EXPECT_EQ(2, docked_strip->num_panels());
+  EXPECT_EQ(1, docked_strip->num_temporary_layout_panels());
   EXPECT_TRUE(overflow_panel->has_temporary_layout());
 
   // Close the overflow panel while it is still in temporary layout.
   CloseWindowAndWait(overflow_panel->browser());
-  EXPECT_EQ(2, panel_strip->num_panels());
-  EXPECT_EQ(0, panel_strip->num_temporary_layout_panels());
+  EXPECT_EQ(2, docked_strip->num_panels());
+  EXPECT_EQ(0, docked_strip->num_temporary_layout_panels());
 
   // Create another overflow panel without waiting for it to move to overflow.
   params.name = "Panel3";
   overflow_panel = CreatePanelWithParams(params);
-  EXPECT_EQ(2, panel_strip->num_panels());
-  EXPECT_EQ(1, panel_strip->num_temporary_layout_panels());
+  EXPECT_EQ(2, docked_strip->num_panels());
+  EXPECT_EQ(1, docked_strip->num_temporary_layout_panels());
   EXPECT_TRUE(overflow_panel->has_temporary_layout());
 
   // Close one of the non-overflow panels. Expect the delayed overflow
@@ -646,18 +646,18 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   // Hack. Pretend to close panel by removing it directly. Cannot use
   // CloseWindowAndWait() here because it will allow the delayed overflow
   // to complete.
-  panel_strip->Remove(panel1);
-  EXPECT_EQ(1, panel_strip->num_panels());
-  EXPECT_EQ(1, panel_strip->num_temporary_layout_panels());
+  docked_strip->Remove(panel1);
+  EXPECT_EQ(1, docked_strip->num_panels());
+  EXPECT_EQ(1, docked_strip->num_temporary_layout_panels());
   EXPECT_TRUE(overflow_panel->has_temporary_layout());
 
   // Make sure the overflow panel actually moves to overflow.
   WaitForExpansionStateChanged(overflow_panel, Panel::IN_OVERFLOW);
-  EXPECT_EQ(0, panel_strip->num_temporary_layout_panels());
+  EXPECT_EQ(0, docked_strip->num_temporary_layout_panels());
 
   // Hack. Put the "falsely closed" panel back into the panel strip
   // so we can properly close it to wrap up this test.
-  panel_strip->AddPanel(panel1);
+  docked_strip->AddPanel(panel1);
 
   panel0->Close();
   panel1->Close();
@@ -665,22 +665,22 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5
   //   overflow-on-overflow: P6, P7
   const int panel_widths[] = {
-      250, 260, 200,  // normal
+      250, 260, 200,  // docked
       210, 260, 230,  // overflow
       255, 210        // overflow-on-overflow
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 5, panel_widths);
 
-  PanelDataList expected_normal_list;
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  PanelDataList expected_docked_list;
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   PanelDataList expected_overflow_list;
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -690,20 +690,20 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Activate an overflow panel. Expect one normal panel is swapped into the
+  // Activate an overflow panel. Expect one docked panel is swapped into the
   // overflow strip.
-  //   normal:               P0, P1, P3
+  //   docked:               P0, P1, P3
   //   overflow:             P2, P4, P5
   //   overflow-on-overflow: P6, P7
   panels[3]->Activate();
   WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE);
   WaitForExpansionStateChanged(panels[3], Panel::EXPANDED);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false);
@@ -713,9 +713,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Activate an overflow panel. Expect two normal panels are swapped into the
+  // Activate an overflow panel. Expect two docked panels are swapped into the
   // overflow strip and one overflow panel to become hidden.
-  //   normal:               P0, P4
+  //   docked:               P0, P4
   //   overflow:             P1, P3, P2
   //   overflow-on-overflow: P5, P6, P7
   panels[4]->Activate();
@@ -723,10 +723,10 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   WaitForExpansionStateChanged(panels[4], Panel::EXPANDED);
   WaitForPanelActiveState(panels[3], SHOW_AS_INACTIVE);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[4], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[4], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[1], Panel::IN_OVERFLOW, true, false);
@@ -737,9 +737,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Activate an overflow-on-overflow panel. Expect one normal panel is swapped
+  // Activate an overflow-on-overflow panel. Expect one docked panel is swapped
   // into the overflow strip.
-  //   normal:               P0, P6
+  //   docked:               P0, P6
   //   overflow:             P4, P1, P3,
   //   overflow-on-overflow: P2, P5, P7
   panels[6]->Activate();
@@ -747,10 +747,10 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   WaitForExpansionStateChanged(panels[6], Panel::EXPANDED);
   WaitForPanelActiveState(panels[4], SHOW_AS_INACTIVE);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[6], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[6], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false);
@@ -761,9 +761,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
-  // Activate an overflow-on-overflow panel. No normal panel is swapped
+  // Activate an overflow-on-overflow panel. No docked panel is swapped
   // since there has already been enough space in the panel strip.
-  //   normal:               P0, P6, P7
+  //   docked:               P0, P6, P7
   //   overflow:             P4, P1, P3,
   //   overflow-on-overflow: P2, P5
   panels[7]->Activate();
@@ -771,11 +771,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   WaitForExpansionStateChanged(panels[7], Panel::EXPANDED);
   WaitForPanelActiveState(panels[6], SHOW_AS_INACTIVE);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[6], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[7], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[6], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[7], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false);
@@ -791,39 +791,39 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
 IN_PROC_BROWSER_TEST_F(
     PanelOverflowBrowserTest,
     MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate) {
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4
   const int panel_widths[] = {
-      250, 260, 200,  // normal
+      250, 260, 200,  // docked
       210, 260        // overflow
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 2, panel_widths);
 
-  PanelDataList expected_normal_list;
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  PanelDataList expected_docked_list;
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   PanelDataList expected_overflow_list;
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
   expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false);
 
-  // Minimize a normal panel and then bump it to overflow by activating an
+  // Minimize a docked panel and then bump it to overflow by activating an
   // overflow panel.
-  //   normal:               P0, P1, P3
+  //   docked:               P0, P1, P3
   //   overflow:             P2, P4
   panels[2]->SetExpansionState(Panel::MINIMIZED);
   panels[3]->Activate();
   WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE);
   WaitForExpansionStateChanged(panels[3], Panel::EXPANDED);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false);
@@ -832,17 +832,17 @@ IN_PROC_BROWSER_TEST_F(
 
   // Reactivate the formerly minimized panel. It will return to the panel
   // strip in expanded state.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4
   panels[2]->Activate();
   WaitForPanelActiveState(panels[2], SHOW_AS_ACTIVE);
   WaitForExpansionStateChanged(panels[2], Panel::EXPANDED);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -850,18 +850,18 @@ IN_PROC_BROWSER_TEST_F(
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
   // Minimize a panel to title only mode, then bump it to overflow.
-  //   normal:               P0, P1, P3
+  //   docked:               P0, P1, P3
   //   overflow:             P2, P4
   panels[2]->SetExpansionState(Panel::TITLE_ONLY);
   panels[3]->Activate();
   WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE);
   WaitForExpansionStateChanged(panels[3], Panel::EXPANDED);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false);
@@ -870,17 +870,17 @@ IN_PROC_BROWSER_TEST_F(
 
   // Reactivate the formerly minimized panel. It will return to the panel
   // strip in expanded state.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4
   panels[2]->Activate();
   WaitForPanelActiveState(panels[2], SHOW_AS_ACTIVE);
   WaitForExpansionStateChanged(panels[2], Panel::EXPANDED);
 
-  expected_normal_list.clear();
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, true);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  expected_docked_list.clear();
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, true);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   expected_overflow_list.clear();
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -895,20 +895,20 @@ IN_PROC_BROWSER_TEST_F(
     MAYBE_MoveMinimizedPanelToOverflowAndBringBackByCloseOrResize) {
   PanelManager* panel_manager = PanelManager::GetInstance();
 
-  // Create normal and overflow panels.
-  //   normal:   P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:   P0, P1, P2
   //   overflow: P3, P4, P5
   const int panel_widths[] = {
-      240, 240, 120, // normal
+      240, 240, 120, // docked
       240, 240, 240  // overflow
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 3, panel_widths);
 
-  PanelDataList expected_normal_list;
-  expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-  expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false);
-  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+  PanelDataList expected_docked_list;
+  expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+  expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false);
+  EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
   PanelDataList expected_overflow_list;
   expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false);
@@ -917,20 +917,20 @@ IN_PROC_BROWSER_TEST_F(
 
   // Test case 1: restoring minimized to minimized.
   {
-    // Minimize a normal panel and then bump it to overflow by activating an
+    // Minimize a docked panel and then bump it to overflow by activating an
     // overflow panel.
-    //   normal:   P0, P1, P3
+    //   docked:   P0, P1, P3
     //   overflow: P2, P4, P5
     panels[2]->SetExpansionState(Panel::MINIMIZED);
     panels[3]->Activate();
     WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE);
     WaitForExpansionStateChanged(panels[3], Panel::EXPANDED);
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false);
@@ -940,16 +940,16 @@ IN_PROC_BROWSER_TEST_F(
 
     // Bring back the formerly minimized panel by closing a panel. It will
     // return to the panel strip in the minimized state.
-    //   normal:   P0, P1, P2
+    //   docked:   P0, P1, P2
     //   overflow: P4, P5
     CloseWindowAndWait(panels[3]->browser());
     WaitForExpansionStateChanged(panels[2], Panel::MINIMIZED);
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[2], Panel::MINIMIZED, true, false);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[2], Panel::MINIMIZED, true, false);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false);
@@ -960,17 +960,17 @@ IN_PROC_BROWSER_TEST_F(
   // Test case 2: restoring minimized to title-only.
   {
     // Bump the minimized panel to overflow by activating an overflow panel.
-    //   normal:   P0, P1, P4
+    //   docked:   P0, P1, P4
     //   overflow: P2, P5
     panels[4]->Activate();
     WaitForPanelActiveState(panels[4], SHOW_AS_ACTIVE);
     WaitForExpansionStateChanged(panels[4], Panel::EXPANDED);
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[4], Panel::EXPANDED, true, true);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[4], Panel::EXPANDED, true, true);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false);
@@ -987,16 +987,16 @@ IN_PROC_BROWSER_TEST_F(
 
     // Bring back the formerly minimized panel by closing a panel. It will
     // return to the panel strip in the title-only state.
-    //   normal:   P0, P1, P2
+    //   docked:   P0, P1, P2
     //   overflow: P5
     CloseWindowAndWait(panels[4]->browser());
     WaitForExpansionStateChanged(panels[2], Panel::TITLE_ONLY);
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[2], Panel::TITLE_ONLY, true, false);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[2], Panel::TITLE_ONLY, true, false);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false);
@@ -1006,17 +1006,17 @@ IN_PROC_BROWSER_TEST_F(
   // Test case 3: restoring title-only to title-only.
   {
     // Bump the title-only panel to overflow by activating an overflow panel.
-    //   normal:   P0, P1, P5
+    //   docked:   P0, P1, P5
     //   overflow: P2
     panels[5]->Activate();
     WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE);
     WaitForExpansionStateChanged(panels[5], Panel::EXPANDED);
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false);
@@ -1024,17 +1024,17 @@ IN_PROC_BROWSER_TEST_F(
 
     // Bring back the formerly title-only panel by shrinking a panel. It will
     // return to the panel strip in the title-only state.
-    //   normal:   P0, P1, P5, P2
+    //   docked:   P0, P1, P5, P2
     panel_manager->ResizePanel(panels[5], gfx::Size(
         panels[5]->GetBounds().width() / 2,
         panels[5]->GetBounds().height() / 2));
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true);
-    expected_normal_list.Add(panels[2], Panel::TITLE_ONLY, true, false);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true);
+    expected_docked_list.Add(panels[2], Panel::TITLE_ONLY, true, false);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
@@ -1043,17 +1043,17 @@ IN_PROC_BROWSER_TEST_F(
   // Test case 4: restoring title-only to minimized.
   {
     // Bump the minimized panel to overflow by enlarging a panel.
-    //   normal:   P0, P1, P5
+    //   docked:   P0, P1, P5
     //   overflow: P2
     panel_manager->ResizePanel(panels[5], gfx::Size(
         panels[5]->GetBounds().width() * 2,
         panels[5]->GetBounds().height() * 2));
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false);
@@ -1067,17 +1067,17 @@ IN_PROC_BROWSER_TEST_F(
 
     // Bring back the formerly title-only panel by shrinking a panel. It will
     // return to the panel strip in the minimized state.
-    //   normal:   P0, P1, P5, P2
+    //   docked:   P0, P1, P5, P2
     panel_manager->ResizePanel(panels[5], gfx::Size(
         panels[5]->GetBounds().width() / 2,
         panels[5]->GetBounds().height() / 2));
 
-    expected_normal_list.clear();
-    expected_normal_list.Add(panels[0], Panel::MINIMIZED, true, false);
-    expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false);
-    expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true);
-    expected_normal_list.Add(panels[2], Panel::MINIMIZED, true, false);
-    EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+    expected_docked_list.clear();
+    expected_docked_list.Add(panels[0], Panel::MINIMIZED, true, false);
+    expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false);
+    expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true);
+    expected_docked_list.Add(panels[2], Panel::MINIMIZED, true, false);
+    EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
 
     expected_overflow_list.clear();
     EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
@@ -1089,15 +1089,15 @@ IN_PROC_BROWSER_TEST_F(
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
                        MAYBE_HoverOverOverflowAreaWithoutOverflowOfOverflow) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelOverflowStrip* panel_overflow_strip =
-      panel_manager->panel_overflow_strip();
-  int iconified_width = panel_overflow_strip->current_display_width();
+  OverflowPanelStrip* overflow_strip =
+      panel_manager->overflow_strip();
+  int iconified_width = overflow_strip->current_display_width();
 
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4
   const int panel_widths[] = {
-      250, 260, 200,  // normal
+      250, 260, 200,  // docked
       255, 220        // overflow
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 2, panel_widths);
@@ -1106,25 +1106,25 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   // Expect the overflow area remains shrunk.
   MoveMouse(gfx::Point(panels[4]->GetBounds().right() + 1,
                        panels[4]->GetBounds().y()));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
 
   // Move mouse above the top overflow panel. Expect the overflow area
   // remains shrunk.
   MoveMouse(gfx::Point(panels[4]->GetBounds().x(),
                        panels[4]->GetBounds().y() - 1));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
 
   // Move mouse below the bottom overflow panel. Expect the overflow area
   // remains shrunk.
   MoveMouse(gfx::Point(panels[3]->GetBounds().right(),
                        panels[3]->GetBounds().bottom() + 1));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
 
   // Move mouse to the origin of an overflow panel. Expect the overflow area
   // gets expanded.
   MoveMouseAndWaitForOverflowAnimationEnded(
       panels[4]->GetBounds().origin());
-  int hover_width = panel_overflow_strip->current_display_width();
+  int hover_width = overflow_strip->current_display_width();
   EXPECT_GT(hover_width, iconified_width);
   EXPECT_EQ(hover_width, panels[3]->GetBounds().width());
   EXPECT_EQ(hover_width, panels[4]->GetBounds().width());
@@ -1132,25 +1132,25 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   // Move mouse to the origin of another overflow panel. Expect the overflow
   // area remains expanded.
   MoveMouse(panels[3]->GetBounds().origin());
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
 
   // Move mouse beyond the left edge of an overflow panel. Expect the overflow
   // area remains expanded.
   MoveMouse(gfx::Point(panels[4]->GetBounds().x() - 5,
                        panels[4]->GetBounds().y()));
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
 
   // Move mouse to the bottom-right corner of the bottom overflow panel.
   // Expect the overflow area remains expanded.
   MoveMouse(gfx::Point(panels[3]->GetBounds().right(),
                        panels[3]->GetBounds().bottom()));
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
 
   // Move mouse beyond the right edge of the hover panel. Expect the overflow
   // area gets shrunk.
   MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
       panels[4]->GetBounds().right() + 5, panels[4]->GetBounds().y()));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
   EXPECT_EQ(iconified_width, panels[3]->GetBounds().width());
   EXPECT_EQ(iconified_width, panels[4]->GetBounds().width());
 
@@ -1160,16 +1160,16 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
                        MAYBE_HoverOverOverflowAreaWithOverflowOfOverflow) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelOverflowStrip* panel_overflow_strip =
-      panel_manager->panel_overflow_strip();
-  int iconified_width = panel_overflow_strip->current_display_width();
+  OverflowPanelStrip* overflow_strip =
+      panel_manager->overflow_strip();
+  int iconified_width = overflow_strip->current_display_width();
 
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5
   //   overflow-on-overflow: P6, P7
   const int panel_widths[] = {
-      250, 260, 200,  // normal
+      250, 260, 200,  // docked
       255, 220, 260,  // overflow
       140, 210        // overflow-on-overflow
   };
@@ -1179,25 +1179,25 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   // Expect the overflow area remains shrunk.
   MoveMouse(gfx::Point(panels[5]->GetBounds().right() + 1,
                        panels[5]->GetBounds().y()));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
 
   // Move mouse above the top overflow panel. Expect the overflow area
   // remains shrunk.
   MoveMouse(gfx::Point(panels[5]->GetBounds().x(),
                        panels[5]->GetBounds().y() - 1));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
 
   // Move mouse below the bottom overflow panel. Expect the overflow area
   // remains shrunk.
   MoveMouse(gfx::Point(panels[3]->GetBounds().right(),
                        panels[3]->GetBounds().bottom() + 1));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
 
   // Move mouse to the origin of an overflow panel. Expect the overflow area
   // gets expanded.
   MoveMouseAndWaitForOverflowAnimationEnded(
       panels[4]->GetBounds().origin());
-  int hover_width = panel_overflow_strip->current_display_width();
+  int hover_width = overflow_strip->current_display_width();
   EXPECT_GT(hover_width, iconified_width);
   EXPECT_EQ(hover_width, panels[3]->GetBounds().width());
   EXPECT_EQ(hover_width, panels[4]->GetBounds().width());
@@ -1208,30 +1208,30 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   // Move mouse to the origin of another overflow panel. Expect the overflow
   // area remains expanded.
   MoveMouse(panels[5]->GetBounds().origin());
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
 
   // Move mouse beyond the left edge of an overflow panel. Expect the overflow
   // area remains expanded.
   MoveMouse(gfx::Point(panels[5]->GetBounds().x() - 5,
                        panels[5]->GetBounds().y()));
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
 
   // Move mouse to the origin of the top overflow-on-overflow panel. Expect the
   // overflow area remains expanded.
   MoveMouse(panels[7]->GetBounds().origin());
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
 
   // Move mouse to the bottom-right corner of the bottom overflow panel.
   // Expect the overflow area remains expanded.
   MoveMouse(gfx::Point(panels[3]->GetBounds().right(),
                        panels[3]->GetBounds().bottom()));
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
 
   // Move mouse beyond the right edge of the hover panel. Expect the overflow
   // area gets shrunk.
   MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
       panels[4]->GetBounds().right() + 5, panels[4]->GetBounds().y()));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
   EXPECT_EQ(iconified_width, panels[3]->GetBounds().width());
   EXPECT_EQ(iconified_width, panels[4]->GetBounds().width());
   EXPECT_EQ(iconified_width, panels[5]->GetBounds().width());
@@ -1242,7 +1242,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   // area gets expanded.
   MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
       panels[4]->GetBounds().x() - 5, panels[4]->GetBounds().y()));
-  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, overflow_strip->current_display_width());
   EXPECT_EQ(hover_width, panels[3]->GetBounds().width());
   EXPECT_EQ(hover_width, panels[4]->GetBounds().width());
   EXPECT_EQ(hover_width, panels[5]->GetBounds().width());
@@ -1253,7 +1253,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   // area gets shrunk.
   MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
       panels[7]->GetBounds().x(), panels[7]->GetBounds().y() - 1));
-  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, overflow_strip->current_display_width());
   EXPECT_EQ(iconified_width, panels[3]->GetBounds().width());
   EXPECT_EQ(iconified_width, panels[4]->GetBounds().width());
   EXPECT_EQ(iconified_width, panels[5]->GetBounds().width());
@@ -1266,106 +1266,106 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   panel_manager->enable_auto_sizing(true);
-  PanelStrip* panel_strip = panel_manager->panel_strip();
-  PanelOverflowStrip* overflow_strip = panel_manager->panel_overflow_strip();
+  DockedPanelStrip* docked_strip = panel_manager->docked_strip();
+  OverflowPanelStrip* overflow_strip = panel_manager->overflow_strip();
 
   // Create 4 panels that fit.
-  // normal: P1 (250), P2 (200), P3 (100), P4 (100)
+  // docked: P1 (250), P2 (200), P3 (100), P4 (100)
   // overflow: empty
   Panel* panel1 = CreatePanelWithBounds("1", gfx::Rect(0, 0, 250, 200));
   Panel* panel2 = CreatePanelWithBounds("2", gfx::Rect(0, 0, 200, 200));
   Panel* panel3 = CreatePanelWithBounds("3", gfx::Rect(0, 0, 100, 200));
   Panel* panel4 = CreatePanelWithBounds("4", gfx::Rect(0, 0, 100, 200));
-  EXPECT_EQ(4, panel_strip->num_panels());
+  EXPECT_EQ(4, docked_strip->num_panels());
   EXPECT_EQ(0, overflow_strip->num_panels());
 
   // Resize last panel so that it is too big to fit and overflows.
-  // normal: P1 (250), P2 (200), P3 (100)
+  // docked: P1 (250), P2 (200), P3 (100)
   // overflow: P4 (250)*
   gfx::Size new_size(250, 200);
   panel_manager->OnPreferredWindowSizeChanged(panel4, new_size);
-  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(3, docked_strip->num_panels());
   EXPECT_EQ(1, overflow_strip->num_panels());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());
   EXPECT_TRUE(IsPanelInOverflowStrip(panel4));
   EXPECT_EQ(new_size, panel4->restored_size());
 
   // Open another panel that will fit.
-  // normal: P1 (250), P2 (200), P3 (100), P5 (100)*
+  // docked: P1 (250), P2 (200), P3 (100), P5 (100)*
   // overflow: P4 (250)
   Panel* panel5 = CreatePanelWithBounds("5", gfx::Rect(0, 0, 100, 200));
-  EXPECT_EQ(4, panel_strip->num_panels());
+  EXPECT_EQ(4, docked_strip->num_panels());
   EXPECT_EQ(1, overflow_strip->num_panels());
   EXPECT_EQ(Panel::EXPANDED, panel5->expansion_state());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());  // no change
 
   // Resize a panel from the middle of the strip so that it causes a
   // panel to overflow.
-  // normal: P1 (250), P2 (200), P3 (250)*
+  // docked: P1 (250), P2 (200), P3 (250)*
   // overflow: P5 (100), P4 (250)
   panel_manager->OnPreferredWindowSizeChanged(panel3, gfx::Size(250, 200));
-  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(3, docked_strip->num_panels());
   EXPECT_EQ(2, overflow_strip->num_panels());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel5->expansion_state());
-  const PanelOverflowStrip::Panels& overflow = overflow_strip->panels();
+  const OverflowPanelStrip::Panels& overflow = overflow_strip->panels();
   EXPECT_EQ(panel5, overflow[0]);  // new overflow panel is first
   EXPECT_EQ(panel4, overflow[1]);
 
   // Resize panel smaller so that panel from overflow can fit.
-  // normal: P1 (250), P2 (200), P3 (100)*, P5 (100)
+  // docked: P1 (250), P2 (200), P3 (100)*, P5 (100)
   // overflow: P4 (250)
   panel_manager->OnPreferredWindowSizeChanged(panel3, gfx::Size(100, 200));
-  EXPECT_EQ(4, panel_strip->num_panels());
+  EXPECT_EQ(4, docked_strip->num_panels());
   EXPECT_EQ(1, overflow_strip->num_panels());
   EXPECT_EQ(Panel::EXPANDED, panel5->expansion_state());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());
 
   // Resize smaller again but not small enough to fit overflow panel.
-  // normal: P1 (250), P2 (100)*, P3 (100), P5 (100)
+  // docked: P1 (250), P2 (100)*, P3 (100), P5 (100)
   // overflow: P4 (250)
   panel_manager->OnPreferredWindowSizeChanged(panel2, gfx::Size(100, 200));
-  EXPECT_EQ(4, panel_strip->num_panels());
+  EXPECT_EQ(4, docked_strip->num_panels());
   EXPECT_EQ(1, overflow_strip->num_panels());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());  // no change
 
   // Resize overflow panel bigger. It should stay in overflow and bounds
   // should not change.
-  // normal: P1 (250), P2 (100), P3 (100), P5 (100)
+  // docked: P1 (250), P2 (100), P3 (100), P5 (100)
   // overflow: P4 (251)*
   gfx::Rect bounds_before_resize = panel4->GetBounds();
   new_size.SetSize(251, 200);
   panel_manager->OnPreferredWindowSizeChanged(panel4, new_size);
-  EXPECT_EQ(4, panel_strip->num_panels());
+  EXPECT_EQ(4, docked_strip->num_panels());
   EXPECT_EQ(1, overflow_strip->num_panels());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());
   EXPECT_EQ(bounds_before_resize, panel4->GetBounds());
   EXPECT_EQ(new_size, panel4->restored_size());
 
   // Resize overflow panel to make it fit.
-  // normal: P1 (250), P2 (100), P3 (100), P5 (100), P4 (100)*
+  // docked: P1 (250), P2 (100), P3 (100), P5 (100), P4 (100)*
   // overflow: empty
   panel_manager->OnPreferredWindowSizeChanged(panel4, gfx::Size(100, 200));
-  EXPECT_EQ(5, panel_strip->num_panels());
+  EXPECT_EQ(5, docked_strip->num_panels());
   EXPECT_EQ(0, overflow_strip->num_panels());
   EXPECT_EQ(Panel::EXPANDED, panel4->expansion_state());
 
   // Resize a panel bigger, but not enough to cause overflow.
-  // normal: P1 (250), P2 (100), P3 (150)*, P5 (100), P4 (100)
+  // docked: P1 (250), P2 (100), P3 (150)*, P5 (100), P4 (100)
   // overflow: empty
   panel_manager->OnPreferredWindowSizeChanged(panel3, gfx::Size(150, 200));
-  EXPECT_EQ(5, panel_strip->num_panels());
+  EXPECT_EQ(5, docked_strip->num_panels());
   EXPECT_EQ(0, overflow_strip->num_panels());
 
   // Resize a panel to bump more than one panel to overflow.
-  // normal: P1 (250), P2 (250)*, P3 (150)
+  // docked: P1 (250), P2 (250)*, P3 (150)
   // overflow: P5 (100), P4 (100)
   panel_manager->OnPreferredWindowSizeChanged(panel2, gfx::Size(250, 200));
-  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(3, docked_strip->num_panels());
   EXPECT_EQ(2, overflow_strip->num_panels());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());
   EXPECT_EQ(Panel::IN_OVERFLOW, panel5->expansion_state());
-  const PanelOverflowStrip::Panels& overflow2 = overflow_strip->panels();
+  const OverflowPanelStrip::Panels& overflow2 = overflow_strip->panels();
   EXPECT_EQ(panel5, overflow2[0]);  // strip order is preserved
   EXPECT_EQ(panel4, overflow2[1]);
 
@@ -1378,13 +1378,13 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelOverflowStrip* overflow_strip = panel_manager->panel_overflow_strip();
+  OverflowPanelStrip* overflow_strip = panel_manager->overflow_strip();
 
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5
   const int panel_widths[] = {
-      250, 250, 210,  // normal
+      250, 250, 210,  // docked
       250, 250, 260   // overflow
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 3, panel_widths);
@@ -1392,7 +1392,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
   EXPECT_FALSE(overflow_strip->overflow_indicator());
 
   // Create 5 overflow-on-overflow panels.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5, (P6, P7, P8, P9, P10)
   // The panels enclosed in parentheses are hidden.
   int num_existing_panels = panel_manager->num_panels();
@@ -1409,7 +1409,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
 
   // Expand the overflow area by moving mouse over it.
   // Expect the overflow indicator count gets updated.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P3, P4, P5, P6, P7, P8, (P9, P10)
   MoveMouseAndWaitForOverflowAnimationEnded(panels[3]->GetBounds().origin());
   EXPECT_TRUE(IsPanelVisible(panels[6]));
@@ -1421,7 +1421,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
 
   // Close an overflow panel that makes one overflow-on-overflow panel become
   // visible. Expect the overflow indicator count gets decreased by 1.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P4, P5, P6, P7, P8, P9, (P10)
   CloseWindowAndWait(panels[3]->browser());
   EXPECT_TRUE(IsPanelVisible(panels[6]));
@@ -1433,7 +1433,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
 
   // Shrink the overflow area by stopping hovering the mouse over the overflow
   // area. Expect the overflow indicator count gets updated.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P4, P5, P6, (P7, P8, P9, P10)
   MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
       panels[4]->GetBounds().right() + 5, panels[4]->GetBounds().y()));
@@ -1446,7 +1446,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
 
   // Close an overflow panel.
   // Expect the overflow indicator count gets decreased by 1.
-  //   normal:               P0, P1, P2
+  //   docked:               P0, P1, P2
   //   overflow:             P5, P6, P7, (P8, P9, P10)
   CloseWindowAndWait(panels[4]->browser());
   EXPECT_TRUE(IsPanelVisible(panels[6]));
@@ -1456,11 +1456,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
   EXPECT_FALSE(IsPanelVisible(panels[10]));
   EXPECT_EQ(3, overflow_strip->overflow_indicator()->GetCount());
 
-  // Activating a big overflow panel will cause 2 normal panels to move to the
+  // Activating a big overflow panel will cause 2 docked panels to move to the
   // oevrflow area and also get the top visible overflow panel bumped to the
   // overflow-on-overflow.
   // Expect the overflow indicator count gets increased by 1.
-  //   normal:               P0, P5
+  //   docked:               P0, P5
   //   overflow:             P1, P2, P6, (P7, P8, P9, P10)
   panels[5]->Activate();
   WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE);
@@ -1477,28 +1477,28 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelStrip* panel_strip = panel_manager->panel_strip();
-  PanelOverflowStrip* overflow_strip = panel_manager->panel_overflow_strip();
+  DockedPanelStrip* docked_strip = panel_manager->docked_strip();
+  OverflowPanelStrip* overflow_strip = panel_manager->overflow_strip();
 
-  // Create normal and overflow panels.
-  //   normal:               P0, P1, P2, P3
+  // Create docked and overflow panels.
+  //   docked:               P0, P1, P2, P3
   //   overflow:             P4, P5, P6, (P7, P8, P9, P10, P11)
   // The panels enclosed in parentheses are hidden.
   const int panel_widths[] = {
-      100, 210, 210, 210,  // normal
+      100, 210, 210, 210,  // docked
       210, 260, 210,       // overflow
       210, 210, 210,       // overflow-on-overflow on shrunk
       210, 210             // overflow-on-overflow on expanded
   };
   std::vector<Panel*> panels = CreateOverflowPanels(4, 8, panel_widths);
-  EXPECT_EQ(4, panel_strip->num_panels());
+  EXPECT_EQ(4, docked_strip->num_panels());
   EXPECT_EQ(8, overflow_strip->num_panels());
   PanelOverflowIndicator* overflow_indicator =
       overflow_strip->overflow_indicator();
 
   // Draw attention for a visible overflow panel.
   // Expect no impact to the overflow indicator.
-  //   normal:               P0, P1, P2, P3
+  //   docked:               P0, P1, P2, P3
   //   overflow:             P4, *P5, P6, (P7, P8, P9, P10, P11)
   EXPECT_FALSE(panels[5]->IsDrawingAttention());
   panels[5]->FlashFrame(true);
@@ -1507,7 +1507,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
 
   // Activating this overflow panel will clear its attention.
   // Expect no impact to the overflow indicator.
-  //   normal:               P0, P1, P2, P5
+  //   docked:               P0, P1, P2, P5
   //   overflow:             P3, P4, P6, (P7, P8, P9, P10, P11)
   panels[5]->Activate();
   WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE);
@@ -1516,7 +1516,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
 
   // Draw attention for an overflow-on-overflow panel.
   // Expect the overflow indicator is showing attention.
-  //   normal:               P0, P1, P2, P5
+  //   docked:               P0, P1, P2, P5
   //   overflow:             P3, P4, P6, (P7, *P8, P9, P10, P11)
   EXPECT_FALSE(panels[8]->IsDrawingAttention());
   panels[8]->FlashFrame(true);
@@ -1525,7 +1525,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
 
   // Draw attention for another overflow-on-overflow panel.
   // Expect the overflow indicator is still showing attention.
-  //   normal:               P0, P1, P2, P5
+  //   docked:               P0, P1, P2, P5
   //   overflow:             P3, P4, P6, (P7, *P8, P9, *P10, P11)
   EXPECT_FALSE(panels[10]->IsDrawingAttention());
   panels[10]->FlashFrame(true);
@@ -1534,7 +1534,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
 
   // Stop drawing attention for an overflow-on-overflow panel by activating it.
   // Expect the overflow indicator is still showing attention.
-  //   normal:               P0, P1, P2, P8
+  //   docked:               P0, P1, P2, P8
   //   overflow:             P5, P3, P4, (P6, P7, P9, *P10, P11)
   panels[8]->Activate();
   WaitForPanelActiveState(panels[8], SHOW_AS_ACTIVE);
@@ -1543,7 +1543,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
 
   // Stop drawing attention for another overflow-on-overflow panel by activating
   // it. Expect the overflow indicator is not showing attention.
-  //   normal:               P0, P1, P2, P10
+  //   docked:               P0, P1, P2, P10
   //   overflow:             P8, P5, P3, (P4, P6, P7, P9, P11)
   panels[10]->Activate();
   WaitForPanelActiveState(panels[10], SHOW_AS_ACTIVE);
@@ -1552,7 +1552,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
 
   // Draw attention for the top overflow panel.
   // Expect no impact to the overflow indicator.
-  //   normal:               P0, P1, P2, P10
+  //   docked:               P0, P1, P2, P10
   //   overflow:             P8, P5, *P3, (P4, P6, P7, P9, P11)
   EXPECT_TRUE(IsPanelVisible(panels[3]));
   EXPECT_FALSE(panels[3]->IsDrawingAttention());
@@ -1560,16 +1560,16 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
   EXPECT_TRUE(panels[3]->IsDrawingAttention());
   EXPECT_FALSE(overflow_indicator->IsDrawingAttention());
 
-  // Activating a big overflow panel will cause 2 normal panels to move to the
+  // Activating a big overflow panel will cause 2 docked panels to move to the
   // overflow area and also get the top visible overflow panel bumped to the
   // overflow-on-overflow.
   // Expect the overflow indicator is showing attention.
-  //   normal:               P0, P1, P5
+  //   docked:               P0, P1, P5
   //   overflow:             P2, P10, P8, (*P3, P4, P6, P7, P9, P11)
   panels[5]->Activate();
   WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE);
   WaitForExpansionStateChanged(panels[5], Panel::EXPANDED);
-  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(3, docked_strip->num_panels());
   EXPECT_EQ(9, overflow_strip->num_panels());
   EXPECT_FALSE(IsPanelVisible(panels[3]));
   EXPECT_TRUE(panels[3]->IsDrawingAttention());
@@ -1577,10 +1577,10 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
 
   // Close an overflow panel that would move the first oveflow-on-overflow panel
   // to become visible. Expect the overflow indicator is not showing attention.
-  //   normal:               P0, P1, P5
+  //   docked:               P0, P1, P5
   //   overflow:             P2, P10, P3, (P4, P6, P7, P9, P11)
   CloseWindowAndWait(panels[8]->browser());
-  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(3, docked_strip->num_panels());
   EXPECT_EQ(8, overflow_strip->num_panels());
   EXPECT_TRUE(panels[3]->IsDrawingAttention());
   EXPECT_FALSE(overflow_indicator->IsDrawingAttention());
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 5d6f53a7..6fe302e 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -3260,6 +3260,10 @@
         'browser/ui/panels/panel_browser_window_cocoa.mm',
         'browser/ui/panels/panel_browser_window_gtk.cc',
         'browser/ui/panels/panel_browser_window_gtk.h',
+        'browser/ui/panels/docked_panel_strip.cc',
+        'browser/ui/panels/docked_panel_strip.h',
+        'browser/ui/panels/overflow_panel_strip.cc',
+        'browser/ui/panels/overflow_panel_strip.h',
         'browser/ui/panels/panel_manager.cc',
         'browser/ui/panels/panel_manager.h',
         'browser/ui/panels/panel_mouse_watcher.cc',
@@ -3273,12 +3277,8 @@
         'browser/ui/panels/panel_overflow_indicator_gtk.h',
         'browser/ui/panels/panel_overflow_indicator_view.cc',
         'browser/ui/panels/panel_overflow_indicator_view.h',
-        'browser/ui/panels/panel_overflow_strip.cc',
-        'browser/ui/panels/panel_overflow_strip.h',
         'browser/ui/panels/panel_settings_menu_model.cc',
         'browser/ui/panels/panel_settings_menu_model.h',
-        'browser/ui/panels/panel_strip.cc',
-        'browser/ui/panels/panel_strip.h',
         'browser/ui/panels/panel_titlebar_view_cocoa.h',
         'browser/ui/panels/panel_titlebar_view_cocoa.mm',
         'browser/ui/panels/panel_window_controller_cocoa.h',