Hack webapp to request keyboard events on connection.

chrome/browser/ui/exclusive_access/fullscreen_controller.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/exclusive_access/fullscreen_controller.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/exclusive_access/exclusive_access_context.h"
+#include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_within_tab_helper.h"
 #include "chrome/browser/ui/status_bubble.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/web_contents_sizer.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/extension.h"
 
 #if !defined(OS_MACOSX)
 #include "base/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #endif
 
 using base::UserMetricsAction;
 using content::RenderViewHost;
 using content::WebContents;
 
-FullscreenController::FullscreenController(ExclusiveAccessManager* manager,
-                                           Browser* browser)
-    : ExclusiveAccessControllerBase(manager, browser),
+FullscreenController::FullscreenController(ExclusiveAccessManager* manager)
+    : ExclusiveAccessControllerBase(manager),
       state_prior_to_tab_fullscreen_(STATE_INVALID),
       tab_fullscreen_accepted_(false),
       toggled_into_fullscreen_(false),
       reentrant_window_state_change_call_check_(false),
       is_privileged_fullscreen_for_testing_(false),
       ptr_factory_(this) {
 }
 
 FullscreenController::~FullscreenController() {
 }
 
 bool FullscreenController::IsFullscreenForBrowser() const {
-  return browser()->window()->IsFullscreen() && !IsFullscreenCausedByTab();
+  return exclusive_access_manager()
+             ->exclusive_access_context()
+             ->IsFullscreen() &&
+         !IsFullscreenCausedByTab();
 }
 
 void FullscreenController::ToggleBrowserFullscreenMode() {
   extension_caused_fullscreen_ = GURL();
   ToggleFullscreenModeInternal(BROWSER);
 }
 
 void FullscreenController::ToggleBrowserFullscreenWithToolbar() {
   ToggleFullscreenModeInternal(BROWSER_WITH_TOOLBAR);
 }
@@ skipping 19 matching lines @@
 }
 
 bool FullscreenController::IsUserAcceptedFullscreen() const {
   return tab_fullscreen_accepted_;
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending(
     const WebContents* web_contents) const {
   if (web_contents == exclusive_access_tab()) {
     DCHECK(web_contents ==
-           browser()->tab_strip_model()->GetActiveWebContents());
+           exclusive_access_manager()
+               ->exclusive_access_context()
+               ->GetActiveWebContents());
     DCHECK(web_contents->GetCapturerCount() == 0);
     return true;
   }
   return IsFullscreenForCapturedTab(web_contents);
 }
 
 bool FullscreenController::IsFullscreenCausedByTab() const {
   return state_prior_to_tab_fullscreen_ == STATE_NORMAL;
 }
 
 void FullscreenController::EnterFullscreenModeForTab(WebContents* web_contents,
                                                      const GURL& origin) {
   DCHECK(web_contents);
 
   if (MaybeToggleFullscreenForCapturedTab(web_contents, true)) {
     // During tab capture of fullscreen-within-tab views, the browser window
     // fullscreen state is unchanged, so return now.
     return;
   }
 
-  if (web_contents != browser()->tab_strip_model()->GetActiveWebContents() ||
+  if (web_contents !=
+          exclusive_access_manager()
+              ->exclusive_access_context()
+              ->GetActiveWebContents() ||
       IsWindowFullscreenForTabOrPending()) {
       return;
   }
 
 #if defined(OS_WIN)
   // For now, avoid breaking when initiating full screen tab mode while in
   // a metro snap.
   // TODO(robertshield): Find a way to reconcile tab-initiated fullscreen
   //                     modes with metro snap.
   if (IsInMetroSnapMode())
     return;
 #endif
 
   SetTabWithExclusiveAccess(web_contents);
   fullscreened_origin_ = origin;
 
-  BrowserWindow* window = browser()->window();
+  ExclusiveAccessContext* exclusive_access_context =
+      exclusive_access_manager()->exclusive_access_context();
 
-  if (!window->IsFullscreen()) {
+  if (!exclusive_access_context->IsFullscreen()) {
     // Normal -> Tab Fullscreen.
     state_prior_to_tab_fullscreen_ = STATE_NORMAL;
     ToggleFullscreenModeInternal(TAB);
     return;
   }
 
-  if (window->IsFullscreenWithToolbar()) {
+  if (exclusive_access_context->IsFullscreenWithToolbar()) {
     // Browser Fullscreen with Toolbar -> Tab Fullscreen (no toolbar).
-    window->UpdateFullscreenWithToolbar(false);
+    exclusive_access_context->UpdateFullscreenWithToolbar(false);
     state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_WITH_TOOLBAR;
   } else {
     // Browser Fullscreen without Toolbar -> Tab Fullscreen.
     state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_NO_TOOLBAR;
   }
 
   // We need to update the fullscreen exit bubble, e.g., going from browser
   // fullscreen to tab fullscreen will need to show different content.
   if (!tab_fullscreen_accepted_) {
     tab_fullscreen_accepted_ = GetFullscreenSetting() == CONTENT_SETTING_ALLOW;
@@ skipping 19 matching lines @@
 
 #if defined(OS_WIN)
   // For now, avoid breaking when initiating full screen tab mode while in
   // a metro snap.
   // TODO(robertshield): Find a way to reconcile tab-initiated fullscreen
   //                     modes with metro snap.
   if (IsInMetroSnapMode())
     return;
 #endif
 
-  BrowserWindow* window = browser()->window();
-  if (!window->IsFullscreen())
+  ExclusiveAccessContext* exclusive_access_context =
+      exclusive_access_manager()->exclusive_access_context();
+
+  if (!exclusive_access_context->IsFullscreen())
     return;
 
   if (IsFullscreenCausedByTab()) {
     // Tab Fullscreen -> Normal.
     ToggleFullscreenModeInternal(TAB);
     return;
   }
 
   // Tab Fullscreen -> Browser Fullscreen (with or without toolbar).
   if (state_prior_to_tab_fullscreen_ == STATE_BROWSER_FULLSCREEN_WITH_TOOLBAR) {
     // Tab Fullscreen (no toolbar) -> Browser Fullscreen with Toolbar.
-    window->UpdateFullscreenWithToolbar(true);
+    exclusive_access_context->UpdateFullscreenWithToolbar(true);
   }
 
 #if defined(OS_MACOSX)
   // Clear the bubble URL, which forces the Mac UI to redraw.
   exclusive_access_manager()->UpdateExclusiveAccessExitBubbleContent();
 #endif  // defined(OS_MACOSX)
 
   // If currently there is a tab in "tab fullscreen" mode and fullscreen
   // was not caused by it (i.e., previously it was in "browser fullscreen"
   // mode), we need to switch back to "browser fullscreen" mode. In this
   // case, all we have to do is notifying the tab that it has exited "tab
   // fullscreen" mode.
   NotifyTabExclusiveAccessLost();
 
   // This is only a change between Browser and Tab fullscreen. We generate
   // a fullscreen notification now because there is no window change.
   PostFullscreenChangeNotification(true);
 }
 
 bool FullscreenController::IsInMetroSnapMode() {
-#if defined(OS_WIN)
-  return browser()->window()->IsInMetroSnapMode();
-#else
-  return false;
-#endif
+  return exclusive_access_manager()
+      ->exclusive_access_context()
+      ->IsInMetroSnapMode();
 }
 
 #if defined(OS_WIN)
 void FullscreenController::SetMetroSnapMode(bool enable) {
   reentrant_window_state_change_call_check_ = false;
 
   toggled_into_fullscreen_ = false;
-  browser()->window()->SetMetroSnapMode(enable);
+  exclusive_access_manager()->exclusive_access_context()->SetMetroSnapMode(
+      enable);
 
   // FullscreenController unit tests for metro snap assume that on Windows calls
   // to WindowFullscreenStateChanged are reentrant. If that assumption is
   // invalidated, the tests must be updated to maintain coverage.
   CHECK(reentrant_window_state_change_call_check_);
 }
 #endif  // defined(OS_WIN)
 
 void FullscreenController::OnTabDetachedFromView(WebContents* old_contents) {
   if (!IsFullscreenForCapturedTab(old_contents))
@@ skipping 30 matching lines @@
 void FullscreenController::OnTabClosing(WebContents* web_contents) {
   if (IsFullscreenForCapturedTab(web_contents)) {
     web_contents->ExitFullscreen();
   } else {
     ExclusiveAccessControllerBase::OnTabClosing(web_contents);
   }
 }
 
 void FullscreenController::WindowFullscreenStateChanged() {
   reentrant_window_state_change_call_check_ = true;
-
-  BrowserWindow* const window = browser()->window();
-  bool exiting_fullscreen = !window->IsFullscreen();
+  ExclusiveAccessContext* const exclusive_access_context =
+      exclusive_access_manager()->exclusive_access_context();
+  bool exiting_fullscreen = !exclusive_access_context->IsFullscreen();
 
   PostFullscreenChangeNotification(!exiting_fullscreen);
   if (exiting_fullscreen) {
     toggled_into_fullscreen_ = false;
     extension_caused_fullscreen_ = GURL();
     NotifyTabExclusiveAccessLost();
   }
-  if (exiting_fullscreen) {
-    window->GetDownloadShelf()->Unhide();
-  } else {
-    window->GetDownloadShelf()->Hide();
-    if (window->GetStatusBubble())
-      window->GetStatusBubble()->Hide();
-  }
+  exclusive_access_context->UpdateDownloadShelf(exiting_fullscreen);
 }
 
 bool FullscreenController::HandleUserPressedEscape() {
-  WebContents* const active_web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
+  WebContents* const active_web_contents = exclusive_access_manager()
+                                               ->exclusive_access_context()
+                                               ->GetActiveWebContents();
   if (IsFullscreenForCapturedTab(active_web_contents)) {
     active_web_contents->ExitFullscreen();
     return true;
   } else if (IsWindowFullscreenForTabOrPending()) {
     ExitExclusiveAccessIfNecessary();
     return true;
   }
 
   return false;
 }
@@ skipping 29 matching lines @@
     // embeds youtube.com in an iframe, which is then ALLOWED to go fullscreen.
     GURL requester = GetRequestingOrigin();
     GURL embedder = GetEmbeddingOrigin();
     ContentSettingsPattern primary_pattern =
         ContentSettingsPattern::FromURLNoWildcard(requester);
     ContentSettingsPattern secondary_pattern =
         ContentSettingsPattern::FromURLNoWildcard(embedder);
 
     // ContentSettings requires valid patterns and the patterns might be invalid
     // in some edge cases like if the current frame is about:blank.
-    //
     // Do not store preference on file:// URLs, they don't have a clean
     // origin policy.
     // TODO(estark): Revisit this when crbug.com/455882 is fixed.
     if (!requester.SchemeIsFile() && !embedder.SchemeIsFile() &&
         primary_pattern.IsValid() && secondary_pattern.IsValid()) {
-      HostContentSettingsMap* settings_map =
-          profile()->GetHostContentSettingsMap();
+      HostContentSettingsMap* settings_map = exclusive_access_manager()
+                                                 ->exclusive_access_context()
+                                                 ->GetProfile()
+                                                 ->GetHostContentSettingsMap();
       settings_map->SetContentSetting(
           primary_pattern, secondary_pattern, CONTENT_SETTINGS_TYPE_FULLSCREEN,
           std::string(), CONTENT_SETTING_ALLOW);
     }
     tab_fullscreen_accepted_ = true;
     return true;
   }
 
   return false;
 }
@@ skipping 49 matching lines @@
 }
 
 void FullscreenController::ToggleFullscreenModeInternal(
     FullscreenInternalOption option) {
 #if defined(OS_WIN)
   // When in Metro snap mode, toggling in and out of fullscreen is prevented.
   if (IsInMetroSnapMode())
     return;
 #endif
 
-  BrowserWindow* const window = browser()->window();
-  bool enter_fullscreen = !window->IsFullscreen();
+  ExclusiveAccessContext* const exclusive_access_context =
+      exclusive_access_manager()->exclusive_access_context();
+  bool enter_fullscreen = !exclusive_access_context->IsFullscreen();
 
   // When a Mac user requests a toggle they may be toggling between
   // FullscreenWithoutChrome and FullscreenWithToolbar.
-  if (window->IsFullscreen() && !IsWindowFullscreenForTabOrPending() &&
-      window->SupportsFullscreenWithToolbar()) {
+  if (exclusive_access_context->IsFullscreen() &&
+      !IsWindowFullscreenForTabOrPending() &&
+      exclusive_access_context->SupportsFullscreenWithToolbar()) {
     if (option == BROWSER_WITH_TOOLBAR) {
-      enter_fullscreen = enter_fullscreen || !window->IsFullscreenWithToolbar();
+      enter_fullscreen = enter_fullscreen ||
+                         !exclusive_access_context->IsFullscreenWithToolbar();
     } else {
-      enter_fullscreen = enter_fullscreen || window->IsFullscreenWithToolbar();
+      enter_fullscreen = enter_fullscreen ||
+                         exclusive_access_context->IsFullscreenWithToolbar();
     }
   }
 
   // In kiosk mode, we always want to be fullscreen. When the browser first
   // starts we're not yet fullscreen, so let the initial toggle go through.
-  if (chrome::IsRunningInAppMode() && window->IsFullscreen())
+  if (chrome::IsRunningInAppMode() && exclusive_access_context->IsFullscreen())
     return;
 
 #if !defined(OS_MACOSX)
   // Do not enter fullscreen mode if disallowed by pref. This prevents the user
   // from manually entering fullscreen mode and also disables kiosk mode on
   // desktop platforms.
   if (enter_fullscreen &&
-      !profile()->GetPrefs()->GetBoolean(prefs::kFullscreenAllowed)) {
+      !exclusive_access_context->GetProfile()->GetPrefs()->GetBoolean(
+          prefs::kFullscreenAllowed)) {
     return;
   }
 #endif
 
   if (enter_fullscreen)
     EnterFullscreenModeInternal(option);
   else
     ExitFullscreenModeInternal();
 }
 
 void FullscreenController::EnterFullscreenModeInternal(
     FullscreenInternalOption option) {
   toggled_into_fullscreen_ = true;
   GURL url;
   if (option == TAB) {
     url = GetRequestingOrigin();
     tab_fullscreen_accepted_ = GetFullscreenSetting() == CONTENT_SETTING_ALLOW;
   } else {
     if (!extension_caused_fullscreen_.is_empty())
       url = extension_caused_fullscreen_;
   }
 
   if (option == BROWSER)
     content::RecordAction(UserMetricsAction("ToggleFullscreen"));
   // TODO(scheib): Record metrics for WITH_TOOLBAR, without counting transitions
   // from tab fullscreen out to browser with toolbar.
 
-  browser()->window()->EnterFullscreen(
+  exclusive_access_manager()->exclusive_access_context()->EnterFullscreen(
       url, exclusive_access_manager()->GetExclusiveAccessExitBubbleType(),
       option == BROWSER_WITH_TOOLBAR);
 
   exclusive_access_manager()->UpdateExclusiveAccessExitBubbleContent();
 
   // Once the window has become fullscreen it'll call back to
   // WindowFullscreenStateChanged(). We don't do this immediately as
   // BrowserWindow::EnterFullscreen() asks for bookmark_bar_state_, so we let
   // the BrowserWindow invoke WindowFullscreenStateChanged when appropriate.
 }
 
 void FullscreenController::ExitFullscreenModeInternal() {
   toggled_into_fullscreen_ = false;
 #if defined(OS_MACOSX)
   // Mac windows report a state change instantly, and so we must also clear
   // state_prior_to_tab_fullscreen_ to match them else other logic using
   // state_prior_to_tab_fullscreen_ will be incorrect.
   NotifyTabExclusiveAccessLost();
 #endif
-  browser()->window()->ExitFullscreen();
+  exclusive_access_manager()->exclusive_access_context()->ExitFullscreen();
   extension_caused_fullscreen_ = GURL();
 
   exclusive_access_manager()->UpdateExclusiveAccessExitBubbleContent();
 }
 
 ContentSetting FullscreenController::GetFullscreenSetting() const {
   DCHECK(exclusive_access_tab());
 
   GURL url = GetRequestingOrigin();
 
   // Always ask on file:// URLs, since we can't meaningfully make the
   // decision stick for a particular origin.
   // TODO(estark): Revisit this when crbug.com/455882 is fixed.
   if (url.SchemeIsFile())
     return CONTENT_SETTING_ASK;
 
   if (IsPrivilegedFullscreenForTab())
     return CONTENT_SETTING_ALLOW;
 
   // If the permission was granted to the website with no embedder, it should
   // always be allowed, even if embedded.
-  if (profile()->GetHostContentSettingsMap()->GetContentSetting(
-          url, url, CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string()) ==
-      CONTENT_SETTING_ALLOW) {
+  if (exclusive_access_manager()
+          ->exclusive_access_context()
+          ->GetProfile()
+          ->GetHostContentSettingsMap()
+          ->GetContentSetting(url, url, CONTENT_SETTINGS_TYPE_FULLSCREEN,
+                              std::string()) == CONTENT_SETTING_ALLOW) {
     return CONTENT_SETTING_ALLOW;
   }
 
   // See the comment above the call to |SetContentSetting()| for how the
   // requesting and embedding origins interact with each other wrt permissions.
-  return profile()->GetHostContentSettingsMap()->GetContentSetting(
-      url, GetEmbeddingOrigin(), CONTENT_SETTINGS_TYPE_FULLSCREEN,
-      std::string());
+  return exclusive_access_manager()
+      ->exclusive_access_context()
+      ->GetProfile()
+      ->GetHostContentSettingsMap()
+      ->GetContentSetting(url, GetEmbeddingOrigin(),
+                          CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
 }
 
 bool FullscreenController::IsPrivilegedFullscreenForTab() const {
   const bool embedded_widget_present =
       exclusive_access_tab() &&
       exclusive_access_tab()->GetFullscreenRenderWidgetHostView();
   return embedded_widget_present || is_privileged_fullscreen_for_testing_;
 }
 
 void FullscreenController::SetPrivilegedFullscreenForTesting(
@@ skipping 42 matching lines @@
     return fullscreened_origin_;
 
   return exclusive_access_tab()->GetLastCommittedURL();
 }
 
 GURL FullscreenController::GetEmbeddingOrigin() const {
   DCHECK(exclusive_access_tab());
 
   return exclusive_access_tab()->GetLastCommittedURL();
 }