Made fullscreen bubble text non-transparent.

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 "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 26 matching lines @@
 #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;
 
-// Gets the opacity of the bubble when not animating.
-int GetMaximumOpacity() {
-  return ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled() ? 180 : 255;
+float GetBackgroundOpacity() {
+  return ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled() ? 0.7 : 1.0;
 }
 
 class ButtonView : public views::View {
  public:
   ButtonView(views::ButtonListener* listener, int between_button_spacing);
   ~ButtonView() override;
 
   // Returns an empty size when the view is not visible.
   gfx::Size GetPreferredSize() const override;
 
@@ skipping 42 matching lines @@
                       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;
 
+  // views::View
+  gfx::Size GetPreferredSize() const override;
+  void Layout() override;
+
   void UpdateContent(const GURL& url, ExclusiveAccessBubbleType bubble_type);
 
  private:
   ExclusiveAccessBubbleViews* bubble_;
 
+  // Background and border (semi-transparent).
+  views::View* background_;

[msw, 2015/10/22 22:03:44]

Why do we need new container views to set the opacity? Can't we just set the
Bubble[Border|Background] colors with the desired opacity and make this view
paint to a layer that doesn't fill the bounds opaquely?

[Matt Giuca, 2015/10/26 03:10:38]

O_o why didn't I think of that?

Thanks, fixed.

Also this prompted me to fix the border; now it uses NO_ASSETS so it is a solid
edge rather than a soft black edge. See
https://code.google.com/p/chromium/issues/detail?id=352425#c89 for comparison
shots.

+  // Container for all text, button and link views.
+  views::View* contents_;
+
   // Clickable hint text for exiting fullscreen mode.
   views::Link* link_;
   // Instruction for exiting mouse lock.
   views::Label* mouse_lock_exit_instruction_;
   // Informational label: 'www.foo.com has gone fullscreen'.
   views::Label* message_label_;
   ButtonView* button_view_;
   const base::string16 browser_fullscreen_exit_accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(ExclusiveAccessView);
@@ skipping 18 matching lines @@
   shadow_type = views::BubbleBorder::SMALL_SHADOW;
 #endif
   if (ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled())
     shadow_type = views::BubbleBorder::NO_SHADOW;
 
   ui::NativeTheme* theme = ui::NativeTheme::instance();
   SkColor background_color =
       ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()
           ? SK_ColorBLACK
           : theme->GetSystemColor(ui::NativeTheme::kColorId_BubbleBackground);
+  SkColor label_background_color =
+      ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()
+          ? SK_ColorTRANSPARENT
+          : background_color;
   SkColor foreground_color =
       ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()
           ? SK_ColorWHITE
           : theme->GetSystemColor(ui::NativeTheme::kColorId_LabelEnabledColor);
 
-  scoped_ptr<views::BubbleBorder> bubble_border(new views::BubbleBorder(
-      views::BubbleBorder::NONE, shadow_type, background_color));
-  set_background(new views::BubbleBackground(bubble_border.get()));
-  SetBorder(bubble_border.Pass());
   SetFocusable(false);
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   const gfx::FontList& medium_font_list =
       rb.GetFontList(ui::ResourceBundle::MediumFont);
 
+  background_ = new views::View();
+  scoped_ptr<views::BubbleBorder> bubble_border(new views::BubbleBorder(
+      views::BubbleBorder::NONE, shadow_type, background_color));
+  background_->set_background(new views::BubbleBackground(bubble_border.get()));
+  background_->SetBorder(bubble_border.Pass());
+
   if (!ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()) {
     message_label_ = new views::Label(base::string16(), medium_font_list);
     message_label_->SetEnabledColor(foreground_color);
-    message_label_->SetBackgroundColor(background_color);
+    message_label_->SetBackgroundColor(label_background_color);
   }
 
   mouse_lock_exit_instruction_ =
       new views::Label(bubble_->GetInstructionText(), medium_font_list);
   mouse_lock_exit_instruction_->set_collapse_when_hidden(true);
 
   mouse_lock_exit_instruction_->SetEnabledColor(foreground_color);
-  mouse_lock_exit_instruction_->SetBackgroundColor(background_color);
+  mouse_lock_exit_instruction_->SetBackgroundColor(label_background_color);
 
   link_ = new views::Link();
   link_->set_collapse_when_hidden(true);
   link_->SetFocusable(false);
 #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(medium_font_list);
   link_->SetPressedColor(foreground_color);
   link_->SetEnabledColor(foreground_color);
-  link_->SetBackgroundColor(background_color);
+  link_->SetBackgroundColor(label_background_color);
   link_->SetVisible(false);
 
   button_view_ = new ButtonView(this, kPaddingPx);
 
-  views::GridLayout* layout = new views::GridLayout(this);
+  contents_ = new views::View();
+  views::GridLayout* layout = new views::GridLayout(contents_);
   views::ColumnSet* columns = layout->AddColumnSet(0);
   if (!ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()) {
     // In the simplified UI, do not show the message label, only the exit
     // instruction.
     columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0,
                        views::GridLayout::USE_PREF, 0, 0);
     columns->AddPaddingColumn(1, kMiddlePaddingPx);
   }
   columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0,
                      views::GridLayout::USE_PREF, 0, 0);
   columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0,
                      views::GridLayout::USE_PREF, 0, 0);
   columns->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER, 0,
                      views::GridLayout::USE_PREF, 0, 0);
 
   layout->StartRow(0, 0);
   if (!ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled()) {
     DCHECK(message_label_);
     layout->AddView(message_label_);
   }
   layout->AddView(button_view_);
   layout->AddView(mouse_lock_exit_instruction_);
   layout->AddView(link_);
 
   gfx::Insets padding(kPaddingPx, kPaddingPx, kPaddingPx, kPaddingPx);
   padding += GetInsets();
   layout->SetInsets(padding);
-  SetLayoutManager(layout);
+  contents_->SetLayoutManager(layout);
+
+  background_->SetPaintToLayer(true);

[msw, 2015/10/22 22:03:44]

Shouldn't these values be contingent on the new UI?

[Matt Giuca, 2015/10/26 03:10:39]

N/A

+  background_->SetFillsBoundsOpaquely(false);
+  background_->layer()->SetOpacity(GetBackgroundOpacity());
+  contents_->SetPaintToLayer(true);
+  contents_->SetFillsBoundsOpaquely(false);
+  AddChildView(background_);
+  AddChildView(contents_);
 
   UpdateContent(url, 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();
 }
 
+gfx::Size ExclusiveAccessBubbleViews::ExclusiveAccessView::GetPreferredSize()
+    const {
+  return contents_->GetPreferredSize();
+}
+
+void ExclusiveAccessBubbleViews::ExclusiveAccessView::Layout() {
+  // The background's bounds rect must extend out beyond its parent's bounds, to
+  // account for the border.
+  gfx::Rect background_rect(GetContentsBounds());
+  background_rect.Inset(-background_->GetInsets());
+  background_->SetBoundsRect(background_rect);
+  contents_->SetBoundsRect(GetContentsBounds());
+}
+
 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());
   }
 
@@ skipping 74 matching lines @@
   params.parent =
       bubble_view_context_->GetBubbleAssociatedWidget()->GetNativeView();
   // The simplified UI just shows a notice; clicks should go through to the
   // underlying window.
   params.accept_events =
       !ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled();
   popup_->Init(params);
   popup_->SetContentsView(view_);
   gfx::Size size = GetPopupRect(true).size();
   popup_->SetBounds(GetPopupRect(false));
-  popup_->SetOpacity(GetMaximumOpacity());
   // We set layout manager to nullptr to prevent the widget from sizing its
   // contents to the same size as itself. This prevents the widget contents from
   // shrinking while we animate the height of the popup to give the impression
   // that it is sliding off the top of the screen.
   popup_->GetRootView()->SetLayoutManager(nullptr);
   view_->SetBounds(0, 0, size.width(), size.height());
   if (!ExclusiveAccessManager::IsSimplifiedFullscreenUIEnabled())
     popup_->ShowInactive();  // This does not activate the popup.
 
   popup_->AddObserver(this);
@@ skipping 83 matching lines @@
     // 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(GetMaximumOpacity());
+      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, GetMaximumOpacity());
+    int opacity = animation_->CurrentValueBetween(0, 255);
     if (opacity == 0) {
       popup_->Hide();
     } else {
       popup_->Show();
       popup_->SetOpacity(opacity);
     }
   } else {
     if (GetPopupRect(false).IsEmpty()) {
       popup_->Hide();
     } else {
@@ skipping 28 matching lines @@
     // - The top container height is always zero in non-immersive fullscreen.
     // - 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 desired_top = kPopupTopPx - view_->border()->GetInsets().top();
+  // |desired_top| is the top of the bubble area excluding the shadow.
+  int desired_top = kPopupTopPx;
   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 41 matching lines @@
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
   UpdateForImmersiveState();
 }
 
 void ExclusiveAccessBubbleViews::OnWidgetVisibilityChanged(
     views::Widget* widget,
     bool visible) {
   UpdateMouseWatcher();
 }