cros-md: Remove the non-MD immersive mode code paths

chrome/browser/ui/views/tabs/tab_strip.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 577 matching lines @@
       current_inactive_width_(Tab::GetStandardSize().width()),
       current_active_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       in_tab_close_(false),
       animation_container_(new gfx::AnimationContainer()),
       bounds_animator_(this),
       stacked_layout_(false),
       adjust_layout_(false),
       reset_to_shrink_on_exit_(false),
       mouse_move_count_(0),
-      immersive_style_(false) {
+      offscreen_(false) {
   Init();
   SetEventTargeter(
       std::unique_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
 }
 
 TabStrip::~TabStrip() {
   for (TabStripObserver& observer : observers_)
     observer.TabStripDeleted(this);
 
   // The animations may reference the tabs. Shut down the animation before we
@@ skipping 403 matching lines @@
   // processed for them.
   return false;
 }
 
 void TabStrip::SetBackgroundOffset(const gfx::Point& offset) {
   for (int i = 0; i < tab_count(); ++i)
     tab_at(i)->set_background_offset(offset);
   newtab_button_->set_background_offset(offset);
 }
 
-void TabStrip::SetImmersiveStyle(bool enable) {
-  if (immersive_style_ == enable)
-    return;
-  immersive_style_ = enable;
-}
-
 SkAlpha TabStrip::GetInactiveAlpha(bool for_new_tab_button) const {
 #if defined(USE_ASH)
   static const SkAlpha kInactiveTabAlphaAsh = 230;
   const SkAlpha base_alpha = kInactiveTabAlphaAsh;
 #else
   static const SkAlpha kInactiveTabAlphaGlass = 200;
   static const SkAlpha kInactiveTabAlphaOpaque = 255;
   const SkAlpha base_alpha = GetWidget()->ShouldWindowContentsBeTransparent() ?
       kInactiveTabAlphaGlass : kInactiveTabAlphaOpaque;
 #endif  // USE_ASH
@@ skipping 121 matching lines @@
     const ui::ListSelectionModel& original_selection) {
   // Don't accidentally start any drag operations during animations if the
   // mouse is down... during an animation tabs are being resized automatically,
   // so the View system can misinterpret this easily if the mouse is down that
   // the user is dragging.
   if (IsAnimating() || tab->closing() ||
       controller_->HasAvailableDragActions() == 0) {
     return;
   }
 
-  // Do not do any dragging of tabs when using the super short immersive style.
-  if (IsImmersiveStyle())
-    return;
-
   int model_index = GetModelIndexOfTab(tab);
   if (!IsValidModelIndex(model_index)) {
     CHECK(false);
     return;
   }
   Tabs tabs;
   int size_to_selected = 0;
   int x = tab->GetMirroredXInView(event.x());
   int y = event.y();
   // Build the set of selected tabs to drag and calculate the offset from the
@@ skipping 119 matching lines @@
       *clip = border_callback.Run(tab_at(index - 1)->size());
       clip->offset(SkIntToScalar(previous_x - current_x), 0);
     }
   }
   return true;
 }
 
 bool TabStrip::CanPaintThrobberToLayer() const {
   // Disable layer-painting of throbbers if dragging, if any tab animation is in
   // progress, or if stacked tabs are enabled. Also disable in fullscreen: when
-  // "immersive" the tab strip could be sliding in or out while transitioning to
-  // or away from |immersive_style_| and, for other modes, there's no tab strip.
+  // "immersive" the tab strip could be sliding in or out; for other modes,
+  // there's no tab strip.
   const bool dragging = drag_controller_ && drag_controller_->started_drag();
   const views::Widget* widget = GetWidget();
   return widget && !touch_layout_ && !dragging && !IsAnimating() &&
          !widget->IsFullscreen();
 }
 
-bool TabStrip::IsImmersiveStyle() const {
-  return immersive_style_;
-}
-
 SkColor TabStrip::GetToolbarTopSeparatorColor() const {
   return controller_->GetToolbarTopSeparatorColor();
 }
 
 // Returns the accessible tab name for the tab.
 base::string16 TabStrip::GetAccessibleTabName(const Tab* tab) const {
   int model_index = GetModelIndexOfTab(tab);
   if (IsValidModelIndex(model_index))
     return controller_->GetAccessibleTabName(tab);
   return base::string16();
@@ skipping 175 matching lines @@
       needed_tab_width -= (tab_count() - 1) * Tab::kOverlap;
 
     // Don't let the tabstrip shrink smaller than is necessary to show one tab,
     // and don't force it to be larger than is necessary to show 20 tabs.
     const int largest_min_tab_width =
         min_selected_width + 19 * (min_unselected_width - Tab::kOverlap);
     needed_tab_width = std::min(
         std::max(needed_tab_width, min_selected_width), largest_min_tab_width);
   }
   return gfx::Size(needed_tab_width + GetNewTabButtonWidth(),
-                   immersive_style_ ? Tab::GetImmersiveHeight()
-                                    : Tab::GetMinimumInactiveSize().height());
+                   offscreen_ ? 0 : Tab::GetMinimumInactiveSize().height());

[sky, 2017/02/14 22:40:57]

Why do you need to change this? I'm wondering why you can't always return
GetMinimumInactiveSize()?

[Qiang(Joe) Xu, 2017/02/15 05:57:02]

If always return GetMinimumInactiveSize, that will be 29 as shown here:
https://cs.chromium.org/chromium/src/chrome/browser/ui/layout_constants.cc?ty...,

which will set tabstrip height to 29 here:
https://cs.chromium.org/chromium/src/chrome/browser/ui/views/frame/browser_vi...,
because GetBoundsForTabStripInBrowserView calls TabStrip::GetPreferredSize here.

[sky, 2017/02/15 16:30:08]

Sure, but why does this matter? Isn't the tabstrip effectively not shown so that
it's height doesn't really matter?

[Qiang(Joe) Xu, 2017/02/15 23:24:14]

I updated this patch. Two main changes in new patch: (1) update
ImmersiveModeController::GetTopContainerVerticalOffset, (2) update
BrowserNonClientFrameView::GetTopInset.

I documented BrowserNonClientFrameView::GetTopInset.

 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
   // Force animations to stop, otherwise it makes the index calculation tricky.
   StopAnimating(true);
 
   UpdateDropIndex(event);
 
   GURL url;
   base::string16 title;
@@ skipping 79 matching lines @@
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetTooltipHandler(this, tab, point);
   }
   return this;
 }
 
-// static
-int TabStrip::GetImmersiveHeight() {
-  return Tab::GetImmersiveHeight();
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   // So we get enter/exit on children to switch stacked layout on and off.
   set_notify_enter_exit_on_child(true);
 
   newtab_button_bounds_.set_size(GetLayoutSize(NEW_TAB_BUTTON));
   newtab_button_bounds_.Inset(0, 0, 0, -GetNewTabButtonTopOffset());
@@ skipping 1168 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }