Refactor away the Browser* dependency in exclusive_access

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"
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
-#include "chrome/browser/ui/views/frame/browser_view.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/gfx/screen.h"
@@ skipping 26 matching lines @@
 
   // Returns an empty size when the view is not visible.
   gfx::Size GetPreferredSize() const 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_(NULL), deny_button_(NULL) {
   accept_button_ = new views::LabelButton(listener, base::string16());
   accept_button_->SetStyle(views::Button::STYLE_BUTTON);
   accept_button_->SetFocusable(false);
   AddChildView(accept_button_);
@@ skipping 179 matching lines @@
 #endif
     link_->SetVisible(link_visible);
     mouse_lock_exit_instruction_->SetVisible(!link_visible);
     button_view_->SetVisible(false);
   }
 }
 
 // ExclusiveAccessBubbleViews --------------------------------------------------
 
 ExclusiveAccessBubbleViews::ExclusiveAccessBubbleViews(
-    BrowserView* browser_view,
+    ExclusiveAccessBubbleViewsContext* context,
     const GURL& url,
     ExclusiveAccessBubbleType bubble_type)
-    : ExclusiveAccessBubble(browser_view->browser(), url, bubble_type),
-      browser_view_(browser_view),
+    : ExclusiveAccessBubble(context->GetExclusiveAccessManager(),
+                            url,
+                            bubble_type),
+      bubble_view_context_(context),
       popup_(NULL),
       animation_(new gfx::SlideAnimation(this)),
       animated_attribute_(ANIMATED_ATTRIBUTE_BOUNDS) {
   animation_->Reset(1);
 
   // Create the contents view.
   ui::Accelerator accelerator(ui::VKEY_UNKNOWN, ui::EF_NONE);
-  bool got_accelerator =
-      browser_view_->GetWidget()->GetAccelerator(IDC_FULLSCREEN, &accelerator);
-  DCHECK(got_accelerator);
+  // Obtain accelerator to exit fullscreen (default ESC) if it is defined. There
+  // is accelerator defined to escape out of fullscreen for packaged apps.

[scheib, 2015/02/25 22:31:51]

Thanks for explanation. You intended "is no accelerator".

Hmm, there is an ESC default unless app.window.fullscreen.overrideEsc is added.
So this comment is sort of true but also confusing.

If you hit the DCHECK with other code in this patch then it's fine to just drop
it without comment in the code, the current comment will be correct "... if it
is defined". 

If this patch isn't hitting the DCHECK, wait until the patch that does hit it to
remove it.

[Sriram, 2015/02/25 23:15:59]

This is not hit in current patch but with patch that integrates the change with
apps and running with app that actually overrides ESC. I have reverted this for
now.

+  bubble_view_context_->GetWidget()->GetAccelerator(IDC_FULLSCREEN,
+                                                    &accelerator);
   view_ = new ExclusiveAccessView(this, accelerator.GetShortcutText(), url,
                                   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;
-  params.parent = browser_view_->GetWidget()->GetNativeView();
+  params.parent = bubble_view_context_->GetWidget()->GetNativeView();
   params.bounds = GetPopupRect(false);
   popup_->Init(params);
   gfx::Size size = GetPopupRect(true).size();
   popup_->SetContentsView(view_);
   // We set layout manager to NULL 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(NULL);
   view_->SetBounds(0, 0, size.width(), size.height());
   popup_->ShowInactive();  // This does not activate the popup.
 
   popup_->AddObserver(this);
 
-  registrar_.Add(
-      this, chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-      content::Source<FullscreenController>(browser_view_->browser()
-                                                ->exclusive_access_manager()
-                                                ->fullscreen_controller()));
+  registrar_.Add(this, chrome::NOTIFICATION_FULLSCREEN_CHANGED,
+                 content::Source<FullscreenController>(
+                     bubble_view_context_->GetExclusiveAccessManager()
+                         ->fullscreen_controller()));
 
   UpdateForImmersiveState();
 }
 
 ExclusiveAccessBubbleViews::~ExclusiveAccessBubbleViews() {
   popup_->RemoveObserver(this);
 
   // This is tricky.  We may be in an ATL message handler stack, in which case
   // the popup cannot be deleted yet.  We also can't set the popup's ownership
   // model to NATIVE_WIDGET_OWNS_WIDGET because if the user closed the last tab
@@ skipping 48 matching lines @@
     return;
 
   if (should_watch_mouse)
     StartWatchingMouse();
   else
     StopWatchingMouse();
 }
 
 void ExclusiveAccessBubbleViews::UpdateForImmersiveState() {
   AnimatedAttribute expected_animated_attribute =
-      browser_view_->immersive_mode_controller()->IsEnabled()
+      bubble_view_context_->IsImmersiveModeEnabled()
           ? ANIMATED_ATTRIBUTE_OPACITY
           : ANIMATED_ATTRIBUTE_BOUNDS;
   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;
 
@@ skipping 11 matching lines @@
 
 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 browser_view_->GetWidget()->GetRootView();
+  return bubble_view_context_->GetWidget()->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();
@@ skipping 12 matching lines @@
 void ExclusiveAccessBubbleViews::AnimationEnded(
     const gfx::Animation* animation) {
   AnimationProgressed(animation);
 }
 
 gfx::Rect ExclusiveAccessBubbleViews::GetPopupRect(
     bool ignore_animation_state) const {
   gfx::Size size(view_->GetPreferredSize());
   // NOTE: don't use the bounds of the root_view_. On linux GTK changing window
   // size is async. Instead we use the size of the screen.
-  gfx::Screen* screen =
-      gfx::Screen::GetScreenFor(browser_view_->GetWidget()->GetNativeView());
+  gfx::Screen* screen = gfx::Screen::GetScreenFor(
+      bubble_view_context_->GetWidget()->GetNativeView());
   gfx::Rect screen_bounds =
       screen->GetDisplayNearestWindow(
-                  browser_view_->GetWidget()->GetNativeView()).bounds();
+                  bubble_view_context_->GetWidget()->GetNativeView()).bounds();
   int x = screen_bounds.x() + (screen_bounds.width() - size.width()) / 2;
 
   int top_container_bottom = screen_bounds.y();
-  if (browser_view_->immersive_mode_controller()->IsEnabled()) {
+  if (bubble_view_context_->IsImmersiveModeEnabled()) {
     // Skip querying the top container height in non-immersive fullscreen
     // because:
     // - 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 =
-        browser_view_->top_container()->GetBoundsInScreen().bottom();
+        bubble_view_context_->GetTopContainerBoundsInScreen().bottom();
   }
   int y = top_container_bottom + kPopupTopPx;
 
   if (!ignore_animation_state &&
       animated_attribute_ == ANIMATED_ATTRIBUTE_BOUNDS) {
     int total_height = size.height() + kPopupTopPx;
     int popup_bottom = animation_->CurrentValueBetween(total_height, 0);
     int y_offset = std::min(popup_bottom, kPopupTopPx);
     size.set_height(size.height() - popup_bottom + y_offset);
     y -= y_offset;
   }
   return gfx::Rect(gfx::Point(x, y), size);
 }
 
 gfx::Point ExclusiveAccessBubbleViews::GetCursorScreenPoint() {
   gfx::Point cursor_pos =
-      gfx::Screen::GetScreenFor(browser_view_->GetWidget()->GetNativeView())
+      gfx::Screen::GetScreenFor(
+          bubble_view_context_->GetWidget()->GetNativeView())
           ->GetCursorScreenPoint();
   views::View::ConvertPointFromScreen(GetBrowserRootView(), &cursor_pos);
   return cursor_pos;
 }
 
 bool ExclusiveAccessBubbleViews::WindowContainsPoint(gfx::Point pos) {
   return GetBrowserRootView()->HitTestPoint(pos);
 }
 
 bool ExclusiveAccessBubbleViews::IsWindowActive() {
-  return browser_view_->GetWidget()->IsActive();
+  return bubble_view_context_->GetWidget()->IsActive();
 }
 
 void ExclusiveAccessBubbleViews::Hide() {
   animation_->SetSlideDuration(kSlideOutDurationMs);
   animation_->Hide();
 }
 
 void ExclusiveAccessBubbleViews::Show() {
   animation_->SetSlideDuration(kSlideInDurationMs);
   animation_->Show();
 }
 
 bool ExclusiveAccessBubbleViews::IsAnimating() {
   return animation_->is_animating();
 }
 
 bool ExclusiveAccessBubbleViews::CanMouseTriggerSlideIn() const {
-  return !browser_view_->immersive_mode_controller()->IsEnabled();
+  return !bubble_view_context_->IsImmersiveModeEnabled();
 }
 
 void ExclusiveAccessBubbleViews::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_FULLSCREEN_CHANGED, type);
   UpdateForImmersiveState();
 }
 
 void ExclusiveAccessBubbleViews::OnWidgetVisibilityChanged(
     views::Widget* widget,
     bool visible) {
   UpdateMouseWatcher();
 }