Fix up fullscreen exit bubble messages to suggest Esc instead of F11 where appropriate.

chrome/browser/ui/views/fullscreen_exit_bubble_views.cc

 // Copyright (c) 2011 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/fullscreen_exit_bubble_views.h"
 
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/views/bubble/bubble.h"
 #include "grit/generated_resources.h"
+#include "grit/ui_strings.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/screen.h"
 #include "views/bubble/bubble_border.h"
 #include "views/controls/button/text_button.h"
 #include "views/controls/link.h"
 #include "views/widget/widget.h"
@@ skipping 28 matching lines @@
   void UpdateContent(const GURL& url, FullscreenExitBubbleType bubble_type);
 
  private:
   // views::View
   virtual void Layout();
 
   FullscreenExitBubbleViews* bubble_;
 
   // 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_;
   views::NativeTextButton* accept_button_;
   views::NativeTextButton* deny_button_;
-  string16 browser_fullscreen_exit_text_;
+  const string16 browser_fullscreen_exit_accelerator_;
 };
 
 FullscreenExitBubbleViews::FullscreenExitView::FullscreenExitView(
     FullscreenExitBubbleViews* bubble,
     const string16& accelerator,
     const GURL& url,
     FullscreenExitBubbleType bubble_type)
     : bubble_(bubble),
       accept_button_(NULL),
-      deny_button_(NULL) {
-#if !defined(OS_CHROMEOS)
-  browser_fullscreen_exit_text_ =
-      l10n_util::GetStringFUTF16(IDS_EXIT_FULLSCREEN_MODE, accelerator);
-#else
-  browser_fullscreen_exit_text_ =
-      l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE);
-#endif
-
+      deny_button_(NULL),
+      browser_fullscreen_exit_accelerator_(accelerator) {
   views::BubbleBorder* bubble_border =
       new views::BubbleBorder(views::BubbleBorder::NONE);
   bubble_border->set_background_color(Bubble::kBackgroundColor);
   set_background(new views::BubbleBackground(bubble_border));
   set_border(bubble_border);
   set_focusable(false);
 
   message_label_.set_parent_owned(false);
   message_label_.SetFont(ResourceBundle::GetSharedInstance().GetFont(
       ResourceBundle::MediumFont));
 
+  mouse_lock_exit_instruction_.set_parent_owned(false);
+  mouse_lock_exit_instruction_.SetText(bubble_->GetInstructionText());
+  mouse_lock_exit_instruction_.SetFont(
+      ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::MediumFont));
+
   link_.set_parent_owned(false);
   link_.set_collapse_when_hidden(false);
   link_.set_focusable(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(bubble);
   link_.SetFont(ResourceBundle::GetSharedInstance().GetFont(
       ResourceBundle::MediumFont));
   link_.SetPressedColor(message_label_.enabled_color());
   link_.SetEnabledColor(message_label_.enabled_color());
   link_.SetVisible(false);
 
   link_.SetBackgroundColor(background()->get_color());
   message_label_.SetBackgroundColor(background()->get_color());
+  mouse_lock_exit_instruction_.SetBackgroundColor(background()->get_color());
   AddChildView(&message_label_);
+  AddChildView(&mouse_lock_exit_instruction_);
   AddChildView(&link_);
 
   accept_button_ = new views::NativeTextButton(
       this, bubble->GetAllowButtonText());
   accept_button_->set_focusable(false);
   AddChildView(accept_button_);
 
   deny_button_ = new views::NativeTextButton(this);
   deny_button_->set_focusable(false);
   AddChildView(deny_button_);
 
   UpdateContent(url, bubble_type);
 }
 
 FullscreenExitBubbleViews::FullscreenExitView::~FullscreenExitView() {
 }
 
 void FullscreenExitBubbleViews::FullscreenExitView::ButtonPressed(
     views::Button* sender, const views::Event& event) {
   if (sender == accept_button_)
     bubble_->Accept();
   else
     bubble_->Cancel();
 }
 
 gfx::Size FullscreenExitBubbleViews::FullscreenExitView::GetPreferredSize() {
   gfx::Size message_size(message_label_.GetPreferredSize());
 
   gfx::Size button_instruction_area;
-  if (link_.IsVisible()) {
+  if (mouse_lock_exit_instruction_.IsVisible()) {
+    button_instruction_area = mouse_lock_exit_instruction_.GetPreferredSize();
+  } else if (link_.IsVisible()) {
     button_instruction_area = link_.GetPreferredSize();
   } else {
     gfx::Size accept_size(accept_button_->GetPreferredSize());
     gfx::Size deny_size(deny_button_->GetPreferredSize());
     button_instruction_area.set_height(accept_size.height());
     button_instruction_area.set_width(
         accept_size.width() + kPaddingPx + deny_size.width());
   }
 
   gfx::Insets insets(GetInsets());
   gfx::Size result(
       message_size.width() + kMiddlePaddingPx + button_instruction_area.width(),
       std::max(message_size.height(), button_instruction_area.height()));
   result.Enlarge(insets.width() + 2 * kPaddingPx,
                  insets.height() + 2 * kPaddingPx);
   return result;
 }
 
 void FullscreenExitBubbleViews::FullscreenExitView::UpdateContent(
     const GURL& url,
     FullscreenExitBubbleType bubble_type) {
   DCHECK_NE(FEB_TYPE_NONE, bubble_type);
 
   message_label_.SetText(bubble_->GetCurrentMessageText());
   if (fullscreen_bubble::ShowButtonsForType(bubble_type)) {
     link_.SetVisible(false);
+    mouse_lock_exit_instruction_.SetVisible(false);
     accept_button_->SetVisible(true);
     deny_button_->SetText(bubble_->GetCurrentDenyButtonText());
     deny_button_->SetVisible(true);
     deny_button_->ClearMaxTextSize();
   } else {
-    if (bubble_type == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION)
-      link_.SetText(browser_fullscreen_exit_text_);
-    else
-      link_.SetText(bubble_->GetInstructionText());
-    link_.SetVisible(true);
+    bool link_visible = true;
+    string16 accelerator;
+    if (bubble_type == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION) {
+      accelerator = browser_fullscreen_exit_accelerator_;
+    } else if (bubble_type == FEB_TYPE_FULLSCREEN_EXIT_INSTRUCTION) {
+      accelerator = l10n_util::GetStringUTF16(IDS_APP_ESC_KEY);
+    } else {
+      link_visible = false;
+    }
+#if !defined(OS_CHROMEOS)
+    if (link_visible) {
+      link_.SetText(
+          l10n_util::GetStringUTF16(IDS_EXIT_FULLSCREEN_MODE) +
+          UTF8ToUTF16(" ") +
+          l10n_util::GetStringFUTF16(IDS_EXIT_FULLSCREEN_MODE_ACCELERATOR,
+              accelerator));
+    }
+#endif
+    link_.SetVisible(link_visible);
+    mouse_lock_exit_instruction_.SetVisible(!link_visible);
     accept_button_->SetVisible(false);
     deny_button_->SetVisible(false);
   }
 }
 
 void FullscreenExitBubbleViews::FullscreenExitView::Layout() {
   // TODO(thakis): Use a LayoutManager instead of doing manual layout.
   gfx::Size message_size(message_label_.GetPreferredSize());
   gfx::Insets insets(GetInsets());
   int x = insets.left() + kPaddingPx;
   int inner_height = height() - insets.height();
 
   message_label_.SetBounds(
       x, insets.top() + (inner_height - message_size.height()) / 2,
       message_size.width(), message_size.height());
   x += message_size.width() + kMiddlePaddingPx;
 
-  if (link_.IsVisible()) {
+  if (mouse_lock_exit_instruction_.IsVisible()) {
+    gfx::Size instruction_size(mouse_lock_exit_instruction_.GetPreferredSize());
+    mouse_lock_exit_instruction_.SetBounds(
+        x, insets.top() + (inner_height - instruction_size.height()) / 2,
+        instruction_size.width(), instruction_size.height());
+  } else if (link_.IsVisible()) {
     gfx::Size link_size(link_.GetPreferredSize());
     link_.SetBounds(x, insets.top() + (inner_height - link_size.height()) / 2,
                     link_size.width(), link_size.height());
   } else {
     gfx::Size accept_size(accept_button_->GetPreferredSize());
     gfx::Size deny_size(deny_button_->GetPreferredSize());
     int button_y = insets.top() + (inner_height - accept_size.height()) / 2;
     accept_button_->SetBounds(
         x, button_y, accept_size.width(), accept_size.height());
     x += accept_size.width() + kPaddingPx;
@@ skipping 147 matching lines @@
     size.set_height(size.height() - popup_bottom + y_offset);
     origin.set_y(origin.y() - y_offset);
   }
   return gfx::Rect(origin, size);
 }
 
 void FullscreenExitBubbleViews::StartWatchingMouseIfNecessary() {
   if (!fullscreen_bubble::ShowButtonsForType(bubble_type_))
     StartWatchingMouse();
 }