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

chrome/browser/ui/views/tabs/tab.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.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 80 matching lines @@
 const double kSelectedTabOpacity = 0.3;
 
 // Inactive selected tabs have their throb value scaled by this.
 const double kSelectedTabThrobScale = 0.95 - kSelectedTabOpacity;
 
 // Max number of images to cache. This has to be at least two since rounding
 // errors may lead to tabs in the same tabstrip having different sizes.
 // 8 = normal/incognito, active/inactive, 2 sizes within tabstrip.
 const size_t kMaxImageCacheSize = 8;
 
-// Height of the miniature tab strip in immersive mode.
-const int kImmersiveTabHeight = 3;
-
-// Height of the small tab indicator rectangles in immersive mode.
-const int kImmersiveBarHeight = 2;
-
-// Color for active and inactive tabs in the immersive mode light strip. These
-// should be a little brighter than the color of the normal art assets for tabs,
-// which for active tabs is 230, 230, 230 and for inactive is 184, 184, 184.
-const SkColor kImmersiveActiveTabColor = SkColorSetRGB(235, 235, 235);
-const SkColor kImmersiveInactiveTabColor = SkColorSetRGB(190, 190, 190);
-
-// The minimum opacity (out of 1) when a tab (either active or inactive) is
-// throbbing in the immersive mode light strip.
-const double kImmersiveTabMinThrobOpacity = 0.66;
-
-// Number of steps in the immersive mode loading animation.
-const int kImmersiveLoadingStepCount = 32;
-
 const char kTabCloseButtonName[] = "TabCloseButton";
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntryMetadata
 //
 // All metadata necessary to uniquely identify a cached image.
 struct ImageCacheEntryMetadata {
   ImageCacheEntryMetadata(SkColor fill_color,
                           SkColor stroke_color,
                           bool use_fill_and_stroke_images,
@@ skipping 401 matching lines @@
 
 // static
 const char Tab::kViewClassName[] = "Tab";
 
 Tab::Tab(TabController* controller, gfx::AnimationContainer* container)
     : controller_(controller),
       closing_(false),
       dragging_(false),
       detached_(false),
       favicon_hiding_offset_(0),
-      immersive_loading_step_(0),
       should_display_crashed_favicon_(false),
       pulse_animation_(new gfx::ThrobAnimation(this)),
       crash_icon_animation_(new FaviconCrashAnimation(this)),
       animation_container_(container),
       throbber_(nullptr),
       alert_indicator_button_(nullptr),
       close_button_(nullptr),
       title_(new views::Label()),
       tab_activated_with_last_tap_down_(false),
       hover_controller_(this),
@@ skipping 188 matching lines @@
   return kTouchWidth;
 }
 
 // static
 int Tab::GetPinnedWidth() {
   constexpr int kTabPinnedContentWidth = 23;
   return GetMinimumInactiveSize().width() + kTabPinnedContentWidth;
 }
 
 // static
-int Tab::GetImmersiveHeight() {
-  return kImmersiveTabHeight;
-}
-
-// static
 float Tab::GetInverseDiagonalSlope() {
   // This is computed from the border path as follows:
   // * The unscaled endcap width is enough for the whole stroke outer curve,
   //   i.e. the side diagonal plus the curves on both its ends.
   // * The bottom and top curve are each (2 * scale) px wide, so the diagonal is
   //   (unscaled endcap width - 2 - 2) * scale px wide.
   // * The bottom and top curve are each 1.5 px high.  Additionally, there is an
   //   extra 1 px below the bottom curve and (scale - 1) px above the top curve,
   //   so the diagonal is ((height - 1.5 - 1.5) * scale - 1 - (scale - 1)) px
   //   high.
@@ skipping 83 matching lines @@
   // only happen during animations).
   if (width() < GetMinimumInactiveSize().width() && !data().pinned)
     return;
 
   gfx::Path clip;
   if (!controller_->ShouldPaintTab(
           this, base::Bind(&GetBorderPath, canvas->image_scale(), true, false),
           &clip))
     return;
 
-  if (controller_->IsImmersiveStyle())
-    PaintImmersiveTab(canvas);
-  else
-    PaintTab(canvas, clip);
+  PaintTab(canvas, clip);
 }
 
 void Tab::Layout() {
   const gfx::Rect lb = GetContentsBounds();
   showing_icon_ = ShouldShowIcon();
   // See comments in IconCapacity().
   const int extra_padding =
       (controller_->ShouldHideCloseButtonForInactiveTabs() ||
        (IconCapacity() < 3)) ? 0 : kExtraLeftPaddingToBalanceCloseButtonPadding;
   const int start = lb.x() + extra_padding;
@@ skipping 291 matching lines @@
       PaintTabBackgroundUsingFillId(canvas, canvas, true, kActiveTabFillId,
                                     y_offset);
       canvas->Restore();
     }
   }
 
   if (showing_icon_)
     PaintIcon(canvas);
 }
 
-void Tab::PaintImmersiveTab(gfx::Canvas* canvas) {
-  // Use transparency for the draw-attention animation.
-  int alpha = 255;
-  if (pulse_animation_->is_animating() && !data().pinned) {
-    alpha = pulse_animation_->CurrentValueBetween(
-        255, gfx::ToRoundedInt(255 * kImmersiveTabMinThrobOpacity));
-  }
-
-  // Draw a gray rectangle to represent the tab. This works for pinned tabs as
-  // well as regular ones. The active tab has a brigher bar.
-  SkColor color =
-      IsActive() ? kImmersiveActiveTabColor : kImmersiveInactiveTabColor;
-  gfx::Rect bar_rect = GetImmersiveBarRect();
-  canvas->FillRect(bar_rect, SkColorSetA(color, alpha));
-
-  // Paint network activity indicator.
-  // TODO(jamescook): Replace this placeholder animation with a real one.
-  // For now, let's go with a Cylon eye effect, but in blue.
-  if (data().network_state != TabRendererData::NETWORK_STATE_NONE &&
-      data().network_state != TabRendererData::NETWORK_STATE_ERROR) {
-    const SkColor kEyeColor = SkColorSetARGB(alpha, 71, 138, 217);
-    int eye_width = bar_rect.width() / 3;
-    int eye_offset = bar_rect.width() * immersive_loading_step_ /
-        kImmersiveLoadingStepCount;
-    if (eye_offset + eye_width < bar_rect.width()) {
-      // Draw a single indicator strip because it fits inside |bar_rect|.
-      gfx::Rect eye_rect(
-          bar_rect.x() + eye_offset, 0, eye_width, kImmersiveBarHeight);
-      canvas->FillRect(eye_rect, kEyeColor);
-    } else {
-      // Draw two indicators to simulate the eye "wrapping around" to the left
-      // side. The first part fills the remainder of the bar.
-      int right_eye_width = bar_rect.width() - eye_offset;
-      gfx::Rect right_eye_rect(
-          bar_rect.x() + eye_offset, 0, right_eye_width, kImmersiveBarHeight);
-      canvas->FillRect(right_eye_rect, kEyeColor);
-      // The second part parts the remaining |eye_width| on the left.
-      int left_eye_width = eye_offset + eye_width - bar_rect.width();
-      gfx::Rect left_eye_rect(
-          bar_rect.x(), 0, left_eye_width, kImmersiveBarHeight);
-      canvas->FillRect(left_eye_rect, kEyeColor);
-    }
-  }
-}
-
 void Tab::PaintInactiveTabBackground(gfx::Canvas* canvas,
                                      const gfx::Path& clip) {
   bool has_custom_image;
   int fill_id = controller_->GetBackgroundResourceId(&has_custom_image);
   const ui::ThemeProvider* tp = GetThemeProvider();
 
   // We only cache the image when it's the default image and we're not hovered,
   // to avoid caching a background image that isn't the same for all tabs.
   if (has_custom_image) {
     // If the theme is providing a custom background image, then its top edge
@@ skipping 194 matching lines @@
     PaintPinnedTabTitleChangedIndicatorAndIcon(canvas, bounds);
   } else if (!favicon_.isNull()) {
     canvas->DrawImageInt(favicon_, 0, 0, bounds.width(), bounds.height(),
                          bounds.x(), bounds.y(), bounds.width(),
                          bounds.height(), false);
   }
 }
 
 void Tab::AdvanceLoadingAnimation() {
   const TabRendererData::NetworkState state = data().network_state;
-  if (controller_->IsImmersiveStyle()) {
-    throbber_->SetVisible(false);
-    if (state == TabRendererData::NETWORK_STATE_WAITING) {
-      // Waiting steps backwards.
-      immersive_loading_step_ =
-          (immersive_loading_step_ - 1 + kImmersiveLoadingStepCount) %
-          kImmersiveLoadingStepCount;
-    } else if (state == TabRendererData::NETWORK_STATE_LOADING) {
-      immersive_loading_step_ =
-          (immersive_loading_step_ + 1) % kImmersiveLoadingStepCount;
-    } else {
-      immersive_loading_step_ = 0;
-    }
-
-    SchedulePaintInRect(GetImmersiveBarRect());
-    return;
-  }
-
   if (state == TabRendererData::NETWORK_STATE_NONE ||
       state == TabRendererData::NETWORK_STATE_ERROR) {
     throbber_->ResetStartTimes();
     throbber_->SetVisible(false);
     ScheduleIconPaint();
     return;
   }
 
   // Since the throbber can animate for a long time, paint to a separate layer
   // when possible to reduce repaint overhead.
@@ skipping 117 matching lines @@
   gfx::Rect bounds = favicon_bounds_;
   if (bounds.IsEmpty())
     return;
 
   // Extends the area to the bottom when the crash animation is in progress.
   if (crash_icon_animation_->is_animating())
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
-
-gfx::Rect Tab::GetImmersiveBarRect() const {
-  // The main bar is as wide as the normal tab's horizontal top line.
-  gfx::Rect contents = GetContentsBounds();
-  contents.set_y(0);
-  contents.set_height(kImmersiveBarHeight);
-  return contents;
-}