ExclusiveAccessBubbleViews: Remove unused code for old style.

chrome/browser/ui/views/exclusive_access_bubble_views.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/exclusive_access_bubble_views.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/views/exclusive_access_bubble_views_context.h"
 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/notification_service.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/canvas.h"
-#include "ui/native_theme/native_theme.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/bubble/bubble_border.h"
-#include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/link_listener.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "ui/base/l10n/l10n_util_win.h"
 #endif
 
 // ExclusiveAccessView ---------------------------------------------------------
 
 namespace {
 
-// Space between the site info label and the buttons / link.
+// Space between the site info label and the link.
 const int kMiddlePaddingPx = 30;
 
 const int kOuterPaddingHorizPx = 40;
 const int kOuterPaddingVertPx = 8;
 
 // Partially-transparent background color.
 const SkColor kBackgroundColor = SkColorSetARGB(0xcc, 0x28, 0x2c, 0x32);
 
-class ButtonView : public views::View {
- public:
-  ButtonView(views::ButtonListener* listener, int between_button_spacing);
-  ~ButtonView() override;
-
-  views::LabelButton* accept_button() const { return accept_button_; }
-  views::LabelButton* deny_button() const { return deny_button_; }
-
- private:
-  views::LabelButton* accept_button_;
-  views::LabelButton* deny_button_;
-  DISALLOW_COPY_AND_ASSIGN(ButtonView);
-};
-
-ButtonView::ButtonView(views::ButtonListener* listener,
-                       int between_button_spacing)
-    : accept_button_(nullptr), deny_button_(nullptr) {
-  accept_button_ = new views::LabelButton(listener, base::string16());
-  accept_button_->SetStyle(views::Button::STYLE_BUTTON);
-  accept_button_->SetFocusBehavior(FocusBehavior::NEVER);
-  AddChildView(accept_button_);
-
-  deny_button_ = new views::LabelButton(listener, base::string16());
-  deny_button_->SetStyle(views::Button::STYLE_BUTTON);
-  deny_button_->SetFocusBehavior(FocusBehavior::NEVER);
-  AddChildView(deny_button_);
-
-  SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0,
-                                        between_button_spacing));
-}
-
-ButtonView::~ButtonView() {
-}
-
 // Class containing the exit instruction text. Contains fancy styling on the
 // keyboard key (not just a simple label).
 class InstructionView : public views::View {
  public:
   // Creates an InstructionView with specific text. |text| may contain a single
   // segment delimited by a pair of pipes ('|'); this segment will be displayed
   // as a keyboard key. e.g., "Press |Esc| to exit" will have "Esc" rendered as
   // a key.
   InstructionView(const base::string16& text,
                   const gfx::FontList& font_list,
@@ skipping 76 matching lines @@
   key_name_label_->SetText(segments[1]);
   key_name_->SetVisible(true);
   after_key_->SetVisible(true);
   after_key_->SetText(segments[2]);
 }
 
 }  // namespace
 
 class ExclusiveAccessBubbleViews::ExclusiveAccessView
     : public views::View,
-      public views::ButtonListener,
       public views::LinkListener {
  public:
   ExclusiveAccessView(ExclusiveAccessBubbleViews* bubble,
                       const base::string16& accelerator,
-                      const GURL& url,
                       ExclusiveAccessBubbleType bubble_type);
   ~ExclusiveAccessView() override;
 
-  // views::ButtonListener
-  void ButtonPressed(views::Button* sender, const ui::Event& event) override;
-
   // views::LinkListener
   void LinkClicked(views::Link* source, int event_flags) override;
 
-  void UpdateContent(const GURL& url, ExclusiveAccessBubbleType bubble_type);
+  void UpdateContent(ExclusiveAccessBubbleType bubble_type);
 
  private:
   ExclusiveAccessBubbleViews* bubble_;
 
   // Clickable hint text for exiting fullscreen mode. (Non-simplified mode
   // only.)
   views::Link* link_;
-  // Informational label: 'www.foo.com has gone fullscreen'. (Non-simplified
-  // mode only.)
-  views::Label* message_label_;
-  // Clickable buttons to exit fullscreen. (Non-simplified mode only.)
-  // TODO(mgiuca): Delete this; it is no longer used on any code path.
-  ButtonView* button_view_;
   // Instruction for exiting fullscreen / mouse lock. Only present if there is
-  // no link or button (always present in simplified mode).
+  // no link (always present in simplified mode).
   InstructionView* exit_instruction_;
   const base::string16 browser_fullscreen_exit_accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(ExclusiveAccessView);
 };
 
 ExclusiveAccessBubbleViews::ExclusiveAccessView::ExclusiveAccessView(
     ExclusiveAccessBubbleViews* bubble,
     const base::string16& accelerator,
-    const GURL& url,
     ExclusiveAccessBubbleType bubble_type)
     : bubble_(bubble),
       link_(nullptr),
-      message_label_(nullptr),
-      button_view_(nullptr),
       exit_instruction_(nullptr),
       browser_fullscreen_exit_accelerator_(accelerator) {
   const SkColor kForegroundColor = SK_ColorWHITE;
 
   std::unique_ptr<views::BubbleBorder> bubble_border(new views::BubbleBorder(
       views::BubbleBorder::NONE, views::BubbleBorder::NO_ASSETS,
       kBackgroundColor));
   set_background(new views::BubbleBackground(bubble_border.get()));
   SetBorder(std::move(bubble_border));
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   const gfx::FontList& font_list =
       rb.GetFontList(ui::ResourceBundle::MediumFont);
 
-  if (!ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()) {
-    message_label_ = new views::Label(base::string16(), font_list);
-    message_label_->SetEnabledColor(kForegroundColor);
-    message_label_->SetBackgroundColor(kBackgroundColor);
-  }
-
   exit_instruction_ = new InstructionView(base::string16(), font_list,
                                           kForegroundColor, kBackgroundColor);
 
   link_ = new views::Link();
   link_->SetFocusBehavior(FocusBehavior::NEVER);
 #if defined(OS_CHROMEOS)
   // On CrOS, the link text doesn't change, since it doesn't show the shortcut.
   link_->SetText(l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE));
 #endif
   link_->set_listener(this);
   link_->SetFontList(font_list);
   link_->SetPressedColor(kForegroundColor);
   link_->SetEnabledColor(kForegroundColor);
   link_->SetBackgroundColor(kBackgroundColor);
   link_->SetVisible(false);
 
-  button_view_ = new ButtonView(this, kPaddingPx);
-
   int outer_padding_horiz = kOuterPaddingHorizPx;
   int outer_padding_vert = kOuterPaddingVertPx;
-  if (!ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()) {
-    DCHECK(message_label_);
-    AddChildView(message_label_);
-  }
-  AddChildView(button_view_);
   AddChildView(exit_instruction_);
   AddChildView(link_);
 
   views::BoxLayout* layout =
       new views::BoxLayout(views::BoxLayout::kHorizontal, outer_padding_horiz,
                            outer_padding_vert, kMiddlePaddingPx);
   SetLayoutManager(layout);
 
-  UpdateContent(url, bubble_type);
+  UpdateContent(bubble_type);
 }
 
 ExclusiveAccessBubbleViews::ExclusiveAccessView::~ExclusiveAccessView() {
 }
 
-void ExclusiveAccessBubbleViews::ExclusiveAccessView::ButtonPressed(
-    views::Button* sender,
-    const ui::Event& event) {
-  if (sender == button_view_->accept_button())
-    bubble_->Accept();
-  else
-    bubble_->Cancel();
-}
-
 void ExclusiveAccessBubbleViews::ExclusiveAccessView::LinkClicked(
     views::Link* link,
     int event_flags) {
   bubble_->ExitExclusiveAccess();
 }
 
 void ExclusiveAccessBubbleViews::ExclusiveAccessView::UpdateContent(
-    const GURL& url,
     ExclusiveAccessBubbleType bubble_type) {
   DCHECK_NE(EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE, bubble_type);
 
   bool link_visible =
       !ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled();
   base::string16 accelerator;
   if (bubble_type ==
           EXCLUSIVE_ACCESS_BUBBLE_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION ||
       bubble_type ==
           EXCLUSIVE_ACCESS_BUBBLE_TYPE_EXTENSION_FULLSCREEN_EXIT_INSTRUCTION) {
     accelerator = browser_fullscreen_exit_accelerator_;
   } else {
     accelerator = l10n_util::GetStringUTF16(IDS_APP_ESC_KEY);
     if (bubble_type !=
         EXCLUSIVE_ACCESS_BUBBLE_TYPE_FULLSCREEN_EXIT_INSTRUCTION) {
       link_visible = false;
     }
   }
 #if !defined(OS_CHROMEOS)
   if (link_visible) {
     link_->SetText(l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE) +
                    base::UTF8ToUTF16(" ") +
                    l10n_util::GetStringFUTF16(
                        IDS_EXIT_FULLSCREEN_MODE_ACCELERATOR, accelerator));
   }
 #endif
   link_->SetVisible(link_visible);
   exit_instruction_->SetText(bubble_->GetInstructionText(accelerator));
   exit_instruction_->SetVisible(!link_visible);
-  button_view_->SetVisible(false);
 }
 
 // ExclusiveAccessBubbleViews --------------------------------------------------
 
 ExclusiveAccessBubbleViews::ExclusiveAccessBubbleViews(
     ExclusiveAccessBubbleViewsContext* context,
     const GURL& url,
     ExclusiveAccessBubbleType bubble_type)
     : ExclusiveAccessBubble(context->GetExclusiveAccessManager(),
                             url,
                             bubble_type),
       bubble_view_context_(context),
       popup_(nullptr),
-      animation_(new gfx::SlideAnimation(this)),
-      animated_attribute_(ExpectedAnimationAttribute()) {
+      animation_(new gfx::SlideAnimation(this)) {
   // With the simplified fullscreen UI flag, initially hide the bubble;
   // otherwise, initially show it.
   double initial_value =
       ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled() ? 0 : 1;
   animation_->Reset(initial_value);
 
   // Create the contents view.
   ui::Accelerator accelerator(ui::VKEY_UNKNOWN, ui::EF_NONE);
   bool got_accelerator =
       bubble_view_context_->GetAcceleratorProvider()
           ->GetAcceleratorForCommandId(IDC_FULLSCREEN, &accelerator);
   DCHECK(got_accelerator);
-  view_ = new ExclusiveAccessView(this, accelerator.GetShortcutText(), url,
+  view_ = new ExclusiveAccessView(this, accelerator.GetShortcutText(),
                                   bubble_type_);
 
   // TODO(yzshen): Change to use the new views bubble, BubbleDelegateView.
   // TODO(pkotwicz): When this becomes a views bubble, make sure that this
   // bubble is ignored by ImmersiveModeControllerAsh::BubbleManager.
   // Initialize the popup.
   popup_ = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
@@ skipping 44 matching lines @@
 
 void ExclusiveAccessBubbleViews::UpdateContent(
     const GURL& url,
     ExclusiveAccessBubbleType bubble_type) {
   DCHECK_NE(EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE, bubble_type);
   if (bubble_type_ == bubble_type && url_ == url)
     return;
 
   url_ = url;
   bubble_type_ = bubble_type;
-  view_->UpdateContent(url_, bubble_type_);
+  view_->UpdateContent(bubble_type_);
 
   gfx::Size size = GetPopupRect(true).size();
   view_->SetSize(size);
   popup_->SetBounds(GetPopupRect(false));
   Show();
 
   // Stop watching the mouse even if UpdateMouseWatcher() will start watching
   // it again so that the popup with the new content is visible for at least
   // |kInitialDelayMs|.
   StopWatchingMouse();
 
   UpdateMouseWatcher();
 }
 
 void ExclusiveAccessBubbleViews::RepositionIfVisible() {
   if (popup_->IsVisible())
     UpdateBounds();
 }
 
 views::View* ExclusiveAccessBubbleViews::GetView() {
   return view_;
 }
 
-ExclusiveAccessBubbleViews::AnimatedAttribute
-ExclusiveAccessBubbleViews::ExpectedAnimationAttribute() {
-  // TODO(mgiuca): Delete this function.
-  return ANIMATED_ATTRIBUTE_OPACITY;
-}
-
 void ExclusiveAccessBubbleViews::UpdateMouseWatcher() {
-  bool should_watch_mouse = false;
-  if (popup_->IsVisible())
-    should_watch_mouse =
-        !exclusive_access_bubble::ShowButtonsForType(bubble_type_);
-  else
-    should_watch_mouse = CanMouseTriggerSlideIn();
+  bool should_watch_mouse = popup_->IsVisible() || CanMouseTriggerSlideIn();
 
   if (should_watch_mouse == IsWatchingMouse())
     return;
 
   if (should_watch_mouse)
     StartWatchingMouse();
   else
     StopWatchingMouse();
 }
 
 void ExclusiveAccessBubbleViews::UpdateForImmersiveState() {

[msw, 2016/05/16 17:17:13]

optional nit: remove this, inline the UpdateMouseWatcher call.

[Matt Giuca, 2016/05/17 00:52:34]

Done.

-  AnimatedAttribute expected_animated_attribute = ExpectedAnimationAttribute();
-  if (animated_attribute_ != expected_animated_attribute) {
-    // If an animation is currently in progress, skip to the end because
-    // switching the animated attribute midway through the animation looks
-    // weird.
-    animation_->End();
-
-    animated_attribute_ = expected_animated_attribute;
-
-    // We may have finished hiding |popup_|. However, the bounds animation
-    // assumes |popup_| has the opacity when it is fully shown and the opacity
-    // animation assumes |popup_| has the bounds when |popup_| is fully shown.
-    if (animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS)
-      popup_->SetOpacity(255);
-    else
-      UpdateBounds();
-  }
-
   UpdateMouseWatcher();
 }
 
 void ExclusiveAccessBubbleViews::UpdateBounds() {
   gfx::Rect popup_rect(GetPopupRect(false));
   if (!popup_rect.IsEmpty()) {
     popup_->SetBounds(popup_rect);
     view_->SetY(popup_rect.height() - view_->height());
   }
 }
 
 views::View* ExclusiveAccessBubbleViews::GetBrowserRootView() const {
   return bubble_view_context_->GetBubbleAssociatedWidget()->GetRootView();
 }
 
 void ExclusiveAccessBubbleViews::AnimationProgressed(
     const gfx::Animation* animation) {
-  if (animated_attribute_ == ANIMATED_ATTRIBUTE_OPACITY) {
-    int opacity = animation_->CurrentValueBetween(0, 255);
-    if (opacity == 0) {
-      popup_->Hide();
-    } else {
-      popup_->Show();
-      popup_->SetOpacity(opacity);
-    }
+  int opacity = animation_->CurrentValueBetween(0, 255);
+  if (opacity == 0) {
+    popup_->Hide();
   } else {
-    if (GetPopupRect(false).IsEmpty()) {
-      popup_->Hide();
-    } else {
-      UpdateBounds();
-      popup_->Show();
-    }
+    popup_->Show();
+    popup_->SetOpacity(opacity);
   }
 }
 
 void ExclusiveAccessBubbleViews::AnimationEnded(
     const gfx::Animation* animation) {
   AnimationProgressed(animation);
 }
 
 gfx::Rect ExclusiveAccessBubbleViews::GetPopupRect(
     bool ignore_animation_state) const {
@@ skipping 12 matching lines @@
     // fullscreen because entering fullscreen starts with the top container
     // revealed. When revealed, the top container has the same height as before
     // entering fullscreen.
     top_container_bottom =
         bubble_view_context_->GetTopContainerBoundsInScreen().bottom();
   }
   // |desired_top| is the top of the bubble area including the shadow.
   int desired_top = kSimplifiedPopupTopPx - view_->border()->GetInsets().top();
   int y = top_container_bottom + desired_top;
 
-  if (!ignore_animation_state &&
-      animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS) {
-    int total_height = size.height() + desired_top;
-    int popup_bottom = animation_->CurrentValueBetween(total_height, 0);
-    int y_offset = std::min(popup_bottom, desired_top);
-    size.set_height(size.height() - popup_bottom + y_offset);
-    y -= y_offset;
-  }
   return gfx::Rect(gfx::Point(x, y), size);
 }
 
 gfx::Point ExclusiveAccessBubbleViews::GetCursorScreenPoint() {
   return bubble_view_context_->GetCursorPointInParent();
 }
 
 bool ExclusiveAccessBubbleViews::WindowContainsPoint(gfx::Point pos) {
   return GetBrowserRootView()->HitTestPoint(pos);
 }
@@ skipping 26 matching lines @@
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
   UpdateForImmersiveState();
 }
 
 void ExclusiveAccessBubbleViews::OnWidgetVisibilityChanged(
     views::Widget* widget,
     bool visible) {
   UpdateMouseWatcher();
 }