Full screen info bubble after |Accept| should exit with link click

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"
@@ skipping 37 matching lines @@
   virtual void ButtonPressed(views::Button* sender, const views::Event& event);
 
   void UpdateContent(const GURL& url, FullscreenExitBubbleType bubble_type);
 
  private:
   // views::View
   virtual void Layout();
 
   FullscreenExitBubbleViews* bubble_;
 
-  // Clickable hint text for exiting browser fullscreen mode.
+  // Clickable hint text for exiting fullscreen mode.
   views::Link link_;
-  // Instruction for exiting tab fullscreen mode.
-  views::Label instruction_label_;
   views::Label message_label_;
   views::NativeTextButton* accept_button_;
   views::NativeTextButton* deny_button_;
+  string16 browser_fullscreen_exit_text_;
 };
 
 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
+
   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));
 
-  instruction_label_.set_parent_owned(false);
-  instruction_label_.SetText(bubble_->GetInstructionText());
-  instruction_label_.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)
-  link_.SetText(
-      l10n_util::GetStringFUTF16(IDS_EXIT_FULLSCREEN_MODE,
-                                 accelerator));
-#else
-  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());
-  instruction_label_.SetBackgroundColor(background()->get_color());
   AddChildView(&message_label_);
-  AddChildView(&instruction_label_);
   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 (instruction_label_.IsVisible()) {
-    button_instruction_area = instruction_label_.GetPreferredSize();
-  } else if (link_.IsVisible()) {
+  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)) {

[Peter Kasting, 2011/11/09 23:32:52]

Nit: This whole block can be shortened, assuming the "bubble_->GetXXX()" calls
won't checkfail or similar:

  link_.SetText((bubble_type == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION) ?
      browser_fullscreen_exit_text_ : bubble_->GetInstructionText());
  deny_button_->SetText(bubble_->GetCurrentDenyButtonText());
  deny_button_->ClearMaxTextSize();
  bool show_buttons = fullscreen_bubble::ShowButtonsForType(bubble_type);
  link_.SetVisible(show_buttons);
  accept_button_->SetVisible(show_buttons);
  deny_button_->SetVisible(show_buttons);

     link_.SetVisible(false);
-    instruction_label_.SetVisible(false);
     accept_button_->SetVisible(true);
     deny_button_->SetText(bubble_->GetCurrentDenyButtonText());
     deny_button_->SetVisible(true);
     deny_button_->ClearMaxTextSize();
   } else {
-    bool link_visible =
-        bubble_type == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION;
-    link_.SetVisible(link_visible);
-    instruction_label_.SetVisible(!link_visible);
+    if (bubble_type == FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION)
+      link_.SetText(browser_fullscreen_exit_text_);
+    else
+      link_.SetText(bubble_->GetInstructionText());
+    link_.SetVisible(true);
     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 (instruction_label_.IsVisible()) {
-    gfx::Size instruction_size(instruction_label_.GetPreferredSize());
-    instruction_label_.SetBounds(
-        x, insets.top() + (inner_height - instruction_size.height()) / 2,
-        instruction_size.width(), instruction_size.height());
-  } else if (link_.IsVisible()) {
+  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();
 }