Implement fullscreen info bubble on Win and Mac

chrome/browser/ui/browser.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/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 16 matching lines @@
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/autofill/autofill_manager.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/character_encoding.h"
+#include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/register_protocol_handler_infobar_delegate.h"
 #include "chrome/browser/debugger/devtools_toggle_action.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_started_animation.h"
 #include "chrome/browser/extensions/crx_installer.h"
@@ skipping 692 matching lines @@
     browser::Navigate(&params);
     contents = params.target_contents->tab_contents();
   }
 
   // TODO(skerner):  If we are already in full screen mode, and the user
   // set the app to open as a regular or pinned tab, what should happen?
   // Today we open the tab, but stay in full screen mode.  Should we leave
   // full screen mode in this case?
   if (launch_type == ExtensionPrefs::LAUNCH_FULLSCREEN &&
       !browser->window()->IsFullscreen())
-    browser->ToggleFullscreenMode();
+    browser->ToggleFullscreenMode(false);
 
   return contents;
 }
 
 // static
 void Browser::OpenBookmarkManagerWindow(Profile* profile) {
   Browser* browser = Browser::Create(profile);
   browser->OpenBookmarkManager();
   browser->window()->Show();
 }
@@ skipping 880 matching lines @@
 void Browser::ConvertPopupToTabbedBrowser() {
   UserMetrics::RecordAction(UserMetricsAction("ShowAsTab"));
   int tab_strip_index = tab_handler_->GetTabStripModel()->active_index();
   TabContentsWrapper* contents =
       tab_handler_->GetTabStripModel()->DetachTabContentsAt(tab_strip_index);
   Browser* browser = Browser::Create(profile_);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
-void Browser::ToggleFullscreenMode() {
+// TODO(koz): Change |for_tab| to an enum.
+void Browser::ToggleFullscreenMode(bool for_tab) {
+  bool entering_fullscreen = !window_->IsFullscreen();
+
 #if !defined(OS_MACOSX)
   // 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 (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode) &&
       window_->IsFullscreen())
     return;
 #endif
 
   UserMetrics::RecordAction(UserMetricsAction("ToggleFullscreen"));
-  window_->SetFullscreen(!window_->IsFullscreen());
+  GURL url;
+  bool ask_permission = false;
+  if (for_tab) {
+    url = GetSelectedTabContents()->GetURL();
+    ask_permission = !url.SchemeIsFile() &&
+        (GetFullscreenSetting(url) == CONTENT_SETTING_ASK);
+  }
+  if (entering_fullscreen) {
+    window_->EnterFullscreen(url, ask_permission);
+  } else {
+    window_->ExitFullscreen();
+  }
 
   // Once the window has become fullscreen it'll call back to
   // WindowFullscreenStateChanged(). We don't do this immediately as
-  // BrowserWindow::SetFullscreen() asks for bookmark_bar_state_, so we let the
-  // BrowserWindow invoke WindowFullscreenStateChanged when appropriate.
+  // BrowserWindow::EnterFullscreen() asks for bookmark_bar_state_, so we let
+  // the BrowserWindow invoke WindowFullscreenStateChanged when appropriate.
 
   // TODO: convert mac to invoke WindowFullscreenStateChanged once it updates
   // the necessary state of the frame.
 #if defined(OS_MACOSX)
   WindowFullscreenStateChanged();
 #endif
 }
 
 void Browser::NotifyTabOfFullscreenExitIfNecessary() {
   if (fullscreened_tab_)
     fullscreened_tab_->ExitFullscreenMode();
   fullscreened_tab_ = NULL;
   tab_caused_fullscreen_ = false;
 }
 
 #if defined(OS_MACOSX)
-void Browser::TogglePresentationMode() {
-  window_->SetPresentationMode(!window_->InPresentationMode());
+void Browser::TogglePresentationMode(bool for_tab) {
+  bool entering_fullscreen = !window_->InPresentationMode();
+  GURL url;
+  bool ask_permission = false;
+  if (for_tab) {
+    url = GetSelectedTabContents()->GetURL();
+    ask_permission = !url.SchemeIsFile() &&
+        (GetFullscreenSetting(url) == CONTENT_SETTING_ASK);
+  }
+  window_->SetPresentationMode(entering_fullscreen, url, ask_permission);
   WindowFullscreenStateChanged();
 }
 #endif
 
 #if defined(OS_CHROMEOS)
 void Browser::Search() {
   // Exit fullscreen to show omnibox.
   if (window_->IsFullscreen()) {
-    ToggleFullscreenMode();
+    ToggleFullscreenMode(false);
     // ToggleFullscreenMode is asynchronous, so we don't have omnibox
     // visible at this point. Wait for next event cycle which toggles
     // the visibility of omnibox before creating new tab.
     MessageLoop::current()->PostTask(
         FROM_HERE, method_factory_.NewRunnableMethod(&Browser::Search));
     return;
   }
 
   const GURL& url = GetSelectedTabContents()->GetURL();
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
@@ skipping 906 matching lines @@
     case IDC_SELECT_TAB_4:
     case IDC_SELECT_TAB_5:
     case IDC_SELECT_TAB_6:
     case IDC_SELECT_TAB_7:          SelectNumberedTab(id - IDC_SELECT_TAB_0);
                                                                       break;
     case IDC_SELECT_LAST_TAB:       SelectLastTab();                  break;
     case IDC_DUPLICATE_TAB:         DuplicateTab();                   break;
     case IDC_RESTORE_TAB:           RestoreTab();                     break;
     case IDC_COPY_URL:              WriteCurrentURLToClipboard();     break;
     case IDC_SHOW_AS_TAB:           ConvertPopupToTabbedBrowser();    break;
-    case IDC_FULLSCREEN:            ToggleFullscreenMode();           break;
+    case IDC_FULLSCREEN:            ToggleFullscreenMode(false);      break;
 #if defined(OS_MACOSX)
-    case IDC_PRESENTATION_MODE:     TogglePresentationMode();         break;
+    case IDC_PRESENTATION_MODE:     TogglePresentationMode(false);    break;
 #endif
     case IDC_EXIT:                  Exit();                           break;
 #if defined(OS_CHROMEOS)
     case IDC_SEARCH:                Search();                         break;
     case IDC_SHOW_KEYBOARD_OVERLAY: ShowKeyboardOverlay();            break;
 #endif
 
     // Page-related commands
     case IDC_SAVE_PAGE:             SavePage();                       break;
     case IDC_BOOKMARK_PAGE:         BookmarkCurrentPage();            break;
@@ skipping 1155 matching lines @@
     in_correct_mode_for_tab_fullscreen = window_->InPresentationMode();
 #else
     in_correct_mode_for_tab_fullscreen = window_->IsFullscreen();
 #endif
     if (!in_correct_mode_for_tab_fullscreen)
       tab_caused_fullscreen_ = true;
   }
 
   if (tab_caused_fullscreen_) {
 #if defined(OS_MACOSX)
-    TogglePresentationMode();
+    TogglePresentationMode(true);
 #else
-    ToggleFullscreenMode();
+    ToggleFullscreenMode(true);
 #endif
   } else if (!enter_fullscreen) {
     // 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.
     NotifyTabOfFullscreenExitIfNecessary();
   }
 }
 
@@ skipping 55 matching lines @@
   FindReplyHelper(tab, request_id, number_of_matches, selection_rect,
                   active_match_ordinal, final_update);
 }
 
 void Browser::CrashedPlugin(TabContents* tab, const FilePath& plugin_path) {
   CrashedPluginHelper(tab, plugin_path);
 }
 
 void Browser::ExitTabbedFullscreenModeIfNecessary() {
   if (tab_caused_fullscreen_)
-    ToggleFullscreenMode();
+    ToggleFullscreenMode(false);
   else
     NotifyTabOfFullscreenExitIfNecessary();
 }
 
 void Browser::UpdatePreferredSize(TabContents* source,
                                   const gfx::Size& pref_size) {
   window_->UpdatePreferredSize(source, pref_size);
 }
 
+void Browser::OnAcceptFullscreenPermission(const GURL& url) {
+  HostContentSettingsMap* settings_map = profile()->GetHostContentSettingsMap();
+
+  settings_map->SetContentSetting(
+      ContentSettingsPattern::FromString(url.host()),
+      ContentSettingsPattern::Wildcard(), CONTENT_SETTINGS_TYPE_FULLSCREEN,
+      std::string(), CONTENT_SETTING_ALLOW);
+}
+
+void Browser::OnDenyFullscreenPermission() {
+  ExitTabbedFullscreenModeIfNecessary();
+}
+
+ContentSetting Browser::GetFullscreenSetting(const GURL& url) {
+  HostContentSettingsMap* settings_map = profile()->GetHostContentSettingsMap();
+  return settings_map->GetContentSetting(url, url,
+      CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabContentsWrapperDelegate implementation:
 
 void Browser::OnDidGetApplicationInfo(TabContentsWrapper* source,
                                       int32 page_id) {
   if (GetSelectedTabContentsWrapper() != source)
     return;
 
   NavigationEntry* entry = source->controller().GetLastCommittedEntry();
   if (!entry || (entry->page_id() != page_id))
@@ skipping 1394 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else if (is_type_tabbed()) {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }