Remove non-MD code from ShelfButton

ash/common/shelf/shelf_button.cc

 // Copyright 2013 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 "ash/common/shelf/shelf_button.h"
 
 #include <algorithm>
 
 #include "ash/common/ash_constants.h"
-#include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/ink_drop_button_listener.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_view.h"
 #include "ash/common/shelf/wm_shelf.h"
-#include "ash/resources/grit/ash_resources.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "skia/ext/image_operations.h"
 #include "ui/accessibility/ax_node_data.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/events/event_constants.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/vector2d.h"
-#include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/animation/ink_drop_impl.h"
 #include "ui/views/animation/square_ink_drop_ripple.h"
 #include "ui/views/controls/image_view.h"
 
 namespace {
 
 // Size of the bar. This is along the opposite axis of the shelf. For example,
 // if the shelf is aligned horizontally then this is the height of the bar.
 const int kBarSize = 3;
 const int kIconSize = 32;
 const int kAttentionThrobDurationMS = 800;
 const int kMaxAnimationSeconds = 10;
 const int kIndicatorOffsetFromBottom = 2;
 const int kIndicatorRadius = 2;
 const SkColor kIndicatorColor = SK_ColorWHITE;
 // Canvas scale to ensure that the activity indicator is not pixelated even at
 // the highest possible device scale factors.
 const int kIndicatorCanvasScale = 5;
 
 // Shelf item ripple constants.
 const int kInkDropSmallSize = 48;
 const int kInkDropLargeSize = 60;
 
 // Padding from the edge of the shelf to the application icon when the shelf
 // is horizontally and vertically aligned, respectively.
-const int kIconPaddingHorizontal = 5;
-const int kIconPaddingHorizontalMD = 7;
-const int kIconPaddingVertical = 6;
-const int kIconPaddingVerticalMD = 8;
+const int kIconPaddingHorizontal = 7;
+const int kIconPaddingVertical = 8;
 
 // Paints an activity indicator on |canvas| whose |size| is specified in DIP.
 void PaintIndicatorOnCanvas(gfx::Canvas* canvas, const gfx::Size& size) {
   cc::PaintFlags flags;
   flags.setColor(kIndicatorColor);
   flags.setFlags(cc::PaintFlags::kAntiAlias_Flag);
   canvas->DrawCircle(
       gfx::Point(size.width() / 2,
                  size.height() - kIndicatorOffsetFromBottom - kIndicatorRadius),
       kIndicatorRadius, flags);
@@ skipping 180 matching lines @@
 
 ShelfButton::ShelfButton(InkDropButtonListener* listener, ShelfView* shelf_view)
     : CustomButton(nullptr),
       listener_(listener),
       shelf_view_(shelf_view),
       icon_view_(new views::ImageView()),
       bar_(new BarView(shelf_view->wm_shelf())),
       state_(STATE_NORMAL),
       destroyed_flag_(nullptr) {
   SetFocusBehavior(FocusBehavior::ACCESSIBLE_ONLY);
-  if (ash::MaterialDesignController::IsShelfMaterial()) {
-    SetInkDropMode(InkDropMode::ON);
-    set_ink_drop_base_color(kShelfInkDropBaseColor);
-    set_ink_drop_visible_opacity(kShelfInkDropVisibleOpacity);
-  }
+  SetInkDropMode(InkDropMode::ON);
+  set_ink_drop_base_color(kShelfInkDropBaseColor);
+  set_ink_drop_visible_opacity(kShelfInkDropVisibleOpacity);
 
   const gfx::ShadowValue kShadows[] = {
       gfx::ShadowValue(gfx::Vector2d(0, 2), 0, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 3), 1, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 0), 1, SkColorSetARGB(0x54, 0, 0, 0)),
   };
   icon_shadows_.assign(kShadows, kShadows + arraysize(kShadows));
 
   // TODO: refactor the layers so each button doesn't require 2.
   icon_view_->SetPaintToLayer();
@@ skipping 121 matching lines @@
 
 void ShelfButton::GetAccessibleNodeData(ui::AXNodeData* node_data) {
   node_data->role = ui::AX_ROLE_BUTTON;
   node_data->SetName(shelf_view_->GetTitleForView(this));
 }
 
 void ShelfButton::Layout() {
   const gfx::Rect button_bounds(GetContentsBounds());
   WmShelf* wm_shelf = shelf_view_->wm_shelf();
   const bool is_horizontal_shelf = wm_shelf->IsHorizontalAlignment();
-  const int icon_pad = ash::MaterialDesignController::IsShelfMaterial()
-                           ? (is_horizontal_shelf ? kIconPaddingHorizontalMD
-                                                  : kIconPaddingVerticalMD)
-                           : (is_horizontal_shelf ? kIconPaddingHorizontal
-                                                  : kIconPaddingVertical);
+  const int icon_pad =
+      is_horizontal_shelf ? kIconPaddingHorizontal : kIconPaddingVertical;
   int x_offset = is_horizontal_shelf ? 0 : icon_pad;
   int y_offset = is_horizontal_shelf ? icon_pad : 0;
 
   int icon_width = std::min(kIconSize, button_bounds.width() - x_offset);
   int icon_height = std::min(kIconSize, button_bounds.height() - y_offset);
 
   // If on the left or top 'invert' the inset so the constant gap is on
   // the interior (towards the center of display) edge of the shelf.
   if (SHELF_ALIGNMENT_LEFT == wm_shelf->GetAlignment())
     x_offset = button_bounds.width() - (kIconSize + icon_pad);
@@ skipping 117 matching lines @@
   icon_view_->SetHorizontalAlignment(is_horizontal_shelf
                                          ? views::ImageView::CENTER
                                          : views::ImageView::LEADING);
   icon_view_->SetVerticalAlignment(is_horizontal_shelf
                                        ? views::ImageView::LEADING
                                        : views::ImageView::CENTER);
   SchedulePaint();
 }
 
 void ShelfButton::UpdateBar() {
-  if (state_ & STATE_HIDDEN) {
-    bar_->SetVisible(false);
-    return;
-  }
+  bool draw_bar = !(state_ & STATE_HIDDEN) &&
+                  (state_ & STATE_ACTIVE || state_ & STATE_ATTENTION ||
+                   state_ & STATE_RUNNING);
 
-  int bar_id = 0;
-  if (state_ & (STATE_ACTIVE))
-    bar_id = IDR_ASH_SHELF_UNDERLINE_ACTIVE;
-  else if (state_ & STATE_ATTENTION)
-    bar_id = IDR_ASH_SHELF_UNDERLINE_ATTENTION;
-  else if (state_ & STATE_RUNNING)
-    bar_id = IDR_ASH_SHELF_UNDERLINE_RUNNING;
-
-  if (bar_id != 0) {
+  if (draw_bar) {
     WmShelf* wm_shelf = shelf_view_->wm_shelf();
     gfx::ImageSkia image;
-    if (ash::MaterialDesignController::IsShelfMaterial()) {
-      if (wm_shelf->IsVisible()) {
-        gfx::Size size(GetShelfConstant(SHELF_BUTTON_SIZE),
-                       GetShelfConstant(SHELF_SIZE));
-        gfx::Canvas canvas(size, kIndicatorCanvasScale, true /* is_opaque */);
-        PaintIndicatorOnCanvas(&canvas, size);
-        image = gfx::ImageSkia(canvas.ExtractImageRep());
-      }
-    } else {
-      ResourceBundle* rb = &ResourceBundle::GetSharedInstance();
-      image = *rb->GetImageNamed(bar_id).ToImageSkia();
+    if (wm_shelf->IsVisible()) {
+      gfx::Size size(kShelfButtonSize, GetShelfConstant(SHELF_SIZE));
+      gfx::Canvas canvas(size, kIndicatorCanvasScale, true /* is_opaque */);
+      PaintIndicatorOnCanvas(&canvas, size);
+      image = gfx::ImageSkia(canvas.ExtractImageRep());
     }
     ShelfAlignment shelf_alignment = wm_shelf->GetAlignment();
     if (!wm_shelf->IsHorizontalAlignment()) {
       image = gfx::ImageSkiaOperations::CreateRotatedImage(
           image, shelf_alignment == SHELF_ALIGNMENT_LEFT
                      ? SkBitmapOperations::ROTATION_90_CW
                      : SkBitmapOperations::ROTATION_270_CW);
     }
     bar_->SetImage(image);
     switch (shelf_alignment) {
       case SHELF_ALIGNMENT_BOTTOM:
       case SHELF_ALIGNMENT_BOTTOM_LOCKED:
         bar_->SetHorizontalAlignment(views::ImageView::CENTER);
         bar_->SetVerticalAlignment(views::ImageView::TRAILING);
         break;
       case SHELF_ALIGNMENT_LEFT:
         bar_->SetHorizontalAlignment(views::ImageView::LEADING);
         bar_->SetVerticalAlignment(views::ImageView::CENTER);
         break;
       case SHELF_ALIGNMENT_RIGHT:
         bar_->SetHorizontalAlignment(views::ImageView::TRAILING);
         bar_->SetVerticalAlignment(views::ImageView::CENTER);
         break;
     }
     bar_->SchedulePaint();
   }
-  bar_->SetVisible(bar_id != 0 && state_ != STATE_NORMAL);
+
+  bar_->SetVisible(draw_bar);
 }
 
 }  // namespace ash