Fullscreen / mouselock bubble: Use new theming even when flag disabled.

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"

[Evan Stade, 2016/05/17 00:23:23]

you can remove this now

[Matt Giuca, 2016/05/17 00:58:01]

Sorry, I realised this after the CL went through. But it is getting removed in
the next CL (https://codereview.chromium.org/1971033003) which is in the CQ now.

 #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.
 const int kMiddlePaddingPx = 30;
 
 const int kOuterPaddingHorizPx = 40;
 const int kOuterPaddingVertPx = 8;
 
-// Partially-transparent background color. Only used with
-// IsSimplifiedFullscreenUIEnabled.
+// 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_; }
 
@@ skipping 139 matching lines @@
  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).
   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) {
-  views::BubbleBorder::Shadow shadow_type = views::BubbleBorder::BIG_SHADOW;
-#if defined(OS_LINUX)
-  // Use a smaller shadow on Linux (including ChromeOS) as the shadow assets can
-  // overlap each other in a fullscreen notification bubble.
-  // See http://crbug.com/462983.
-  shadow_type = views::BubbleBorder::SMALL_SHADOW;
-#endif
-  if (ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled())
-    shadow_type = views::BubbleBorder::NO_ASSETS;
-
-  // TODO(estade): don't use this static instance. See http://crbug.com/558162
-  ui::NativeTheme* theme = ui::NativeTheme::GetInstanceForWeb();
-  SkColor background_color =
-      ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()
-          ? kBackgroundColor
-          : theme->GetSystemColor(ui::NativeTheme::kColorId_BubbleBackground);
-  SkColor foreground_color =
-      ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()
-          ? SK_ColorWHITE
-          : theme->GetSystemColor(ui::NativeTheme::kColorId_LabelEnabledColor);
+  const SkColor kForegroundColor = SK_ColorWHITE;
 
   std::unique_ptr<views::BubbleBorder> bubble_border(new views::BubbleBorder(
-      views::BubbleBorder::NONE, shadow_type, background_color));
+      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(foreground_color);
-    message_label_->SetBackgroundColor(background_color);
+    message_label_->SetEnabledColor(kForegroundColor);
+    message_label_->SetBackgroundColor(kBackgroundColor);
   }
 
   exit_instruction_ = new InstructionView(base::string16(), font_list,
-                                          foreground_color, background_color);
+                                          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(foreground_color);
-  link_->SetEnabledColor(foreground_color);
-  link_->SetBackgroundColor(background_color);
+  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_);
-
-    outer_padding_horiz = kPaddingPx;
-    outer_padding_vert = kPaddingPx;
   }
   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);
 
@@ skipping 16 matching lines @@
     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);
 
-  if (!ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()) {
-    DCHECK(message_label_);
-    message_label_->SetText(bubble_->GetCurrentMessageText());
+  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 (exclusive_access_bubble::ShowButtonsForType(bubble_type)) {
-    link_->SetVisible(false);
-    exit_instruction_->SetVisible(false);
-    button_view_->SetVisible(true);
-    button_view_->deny_button()->SetText(bubble_->GetCurrentDenyButtonText());
-    button_view_->deny_button()->SetMinSize(gfx::Size());
-    button_view_->accept_button()->SetText(
-        bubble_->GetCurrentAllowButtonText());
-    button_view_->accept_button()->SetMinSize(gfx::Size());
-  } else {
-    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));
-    }
+  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);
-  }
+  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,
@@ skipping 98 matching lines @@
   if (popup_->IsVisible())
     UpdateBounds();
 }
 
 views::View* ExclusiveAccessBubbleViews::GetView() {
   return view_;
 }
 
 ExclusiveAccessBubbleViews::AnimatedAttribute
 ExclusiveAccessBubbleViews::ExpectedAnimationAttribute() {
-  return ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled() ||
-                 bubble_view_context_->IsImmersiveModeEnabled()
-             ? ANIMATED_ATTRIBUTE_OPACITY
-             : ANIMATED_ATTRIBUTE_BOUNDS;
+  // 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();
 
@@ skipping 79 matching lines @@
     // - Querying the top container height may return the height before entering
     //   fullscreen because layout is disabled while entering fullscreen.
     // A visual glitch due to the delayed layout is avoided in immersive
     // 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 popup_top = ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()
-                      ? kSimplifiedPopupTopPx
-                      : kPopupTopPx;
-  int desired_top = popup_top - view_->border()->GetInsets().top();
+  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;
   }
@@ skipping 36 matching lines @@
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
   UpdateForImmersiveState();
 }
 
 void ExclusiveAccessBubbleViews::OnWidgetVisibilityChanged(
     views::Widget* widget,
     bool visible) {
   UpdateMouseWatcher();
 }