Enable immersive fullscreen on Windows Ash.

chrome/browser/ui/views/frame/browser_view.cc

 // Copyright 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/frame/browser_view.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 911 matching lines @@
 
 void BrowserView::Restore() {
   frame_->Restore();
 }
 
 void BrowserView::EnterFullscreen(
     const GURL& url, FullscreenExitBubbleType bubble_type) {
   if (IsFullscreen())
     return;  // Nothing to do.
 
-  ProcessFullscreen(true, FOR_DESKTOP, url, bubble_type);
+  ProcessFullscreen(true, NORMAL_FULLSCREEN, url, bubble_type);
 }
 
 void BrowserView::ExitFullscreen() {
   if (!IsFullscreen())
     return;  // Nothing to do.
 
-  ProcessFullscreen(false, FOR_DESKTOP, GURL(), FEB_TYPE_NONE);
+  ProcessFullscreen(false, NORMAL_FULLSCREEN, GURL(), FEB_TYPE_NONE);
 }
 
 void BrowserView::UpdateFullscreenExitBubbleContent(
     const GURL& url,
     FullscreenExitBubbleType bubble_type) {
   // Immersive mode has no exit bubble because it has a visible strip at the
   // top that gives the user a hover target.
   // TODO(jamescook): Figure out what to do with mouse-lock.
   if (bubble_type == FEB_TYPE_NONE || ShouldUseImmersiveFullscreenForUrl(url)) {
     fullscreen_bubble_.reset();
@@ skipping 17 matching lines @@
   return frame_->IsFullscreen();
 }
 
 bool BrowserView::IsFullscreenBubbleVisible() const {
   return fullscreen_bubble_ != NULL;
 }
 
 #if defined(OS_WIN)
 void BrowserView::SetMetroSnapMode(bool enable) {
   HISTOGRAM_COUNTS("Metro.SnapModeToggle", enable);
-  ProcessFullscreen(enable, FOR_METRO, GURL(), FEB_TYPE_NONE);
+  ProcessFullscreen(enable, METRO_SNAP_FULLSCREEN, GURL(), FEB_TYPE_NONE);
 }
 
 bool BrowserView::IsInMetroSnapMode() const {
   return false;
 }
 #endif  // defined(OS_WIN)
 
 void BrowserView::RestoreFocus() {
   WebContents* selected_web_contents = GetActiveWebContents();
   if (selected_web_contents)
     selected_web_contents->GetView()->RestoreFocus();
 }
 
 void BrowserView::SetWindowSwitcherButton(views::Button* button) {
   if (window_switcher_button_)
     RemoveChildView(window_switcher_button_);
   window_switcher_button_ = button;
 }
 
 void BrowserView::FullscreenStateChanged() {
   CHECK(!IsFullscreen());
-  ProcessFullscreen(false, FOR_DESKTOP, GURL(), FEB_TYPE_NONE);
+  ProcessFullscreen(false, NORMAL_FULLSCREEN, GURL(), FEB_TYPE_NONE);
 }
 
 void BrowserView::ToolbarSizeChanged(bool is_animating) {
   // The call to InfoBarContainer::SetMaxTopArrowHeight() below can result in
   // reentrancy; |call_state| tracks whether we're reentrant.  We can't just
   // early-return in this case because we need to layout again so the infobar
   // container's bounds are set correctly.
   static CallState call_state = NORMAL;
 
   // A reentrant call can (and should) use the fast resize path unless both it
@@ skipping 1172 matching lines @@
 void BrowserView::UpdateUIForContents(WebContents* contents) {
   bool needs_layout = MaybeShowBookmarkBar(contents);
   // TODO(jamescook): This function always returns true. Remove it and figure
   // out when layout is actually required.
   needs_layout |= MaybeShowInfoBar(contents);
   if (needs_layout)
     Layout();
 }
 
 void BrowserView::ProcessFullscreen(bool fullscreen,
-                                    FullscreenType type,
+                                    FullscreenMode mode,
                                     const GURL& url,
                                     FullscreenExitBubbleType bubble_type) {
   if (in_process_fullscreen_)
     return;
   in_process_fullscreen_ = true;
 
   // Reduce jankiness during the following position changes by:
   //   * Hiding the window until it's in the final position
   //   * Ignoring all intervening Layout() calls, which resize the webpage and
   //     thus are slow and look ugly (enforced via |in_process_fullscreen_|).
   LocationBarView* location_bar = GetLocationBarView();
 
-  if (type == FOR_METRO || !fullscreen) {
+  if (mode == METRO_SNAP_FULLSCREEN || !fullscreen) {
     // Hide the fullscreen bubble as soon as possible, since the mode toggle can
     // take enough time for the user to notice.
     fullscreen_bubble_.reset();
   }
 
   if (fullscreen) {
     // Move focus out of the location bar if necessary.
     views::FocusManager* focus_manager = GetFocusManager();
     DCHECK(focus_manager);
     // Look for focus in the location bar itself or any child view.
     if (location_bar->Contains(focus_manager->GetFocusedView()))
       focus_manager->ClearFocus();
   }
 
   // Toggle fullscreen mode.
   frame_->SetFullscreen(fullscreen);
 
   // Enable immersive before the browser refreshes its list of enabled commands.
-  if (ShouldUseImmersiveFullscreenForUrl(url))
+  if (mode != METRO_SNAP_FULLSCREEN && ShouldUseImmersiveFullscreenForUrl(url))
     immersive_mode_controller_->SetEnabled(fullscreen);
 
   browser_->WindowFullscreenStateChanged();
 
-  if (fullscreen && !chrome::IsRunningInAppMode() && type != FOR_METRO)
+  if (fullscreen && !chrome::IsRunningInAppMode() &&
+      mode != METRO_SNAP_FULLSCREEN) {
     UpdateFullscreenExitBubbleContent(url, bubble_type);
+  }
 
   // Undo our anti-jankiness hacks and force a re-layout. We also need to
   // recompute the height of the infobar top arrow because toggling in and out
   // of fullscreen changes it. Calling ToolbarSizeChanged() will do both these
   // things since it computes the arrow height directly and forces a layout
   // indirectly via UpdateUIForContents(). Reset |in_process_fullscreen_| in
   // order to let the layout occur.
   in_process_fullscreen_ = false;
   ToolbarSizeChanged(false);
 }
 
 bool BrowserView::ShouldUseImmersiveFullscreenForUrl(const GURL& url) const {
 #if defined(OS_CHROMEOS)
   // Kiosk mode needs the whole screen.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
     return false;
-  bool is_browser_fullscreen = url.is_empty();
-  if (ash::switches::UseImmersiveFullscreenForAllWindows())
-    return is_browser_fullscreen;
-  else
-    return is_browser_fullscreen && IsBrowserTypeNormal();
-#else
+#endif
+
+#if defined(USE_ASH)
+  if (browser()->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH) {
+    bool is_browser_fullscreen = url.is_empty();
+    if (ash::switches::UseImmersiveFullscreenForAllWindows())
+      return is_browser_fullscreen;
+    else

[sky, 2014/03/13 22:08:25]

nit: style says no else after a return.

+      return is_browser_fullscreen && IsBrowserTypeNormal();
+  }
+#endif
+
   return false;
-#endif
 }
 
 void BrowserView::LoadAccelerators() {
   views::FocusManager* focus_manager = GetFocusManager();
   DCHECK(focus_manager);
 
   // Let's fill our own accelerator table.
   const bool is_app_mode = chrome::IsRunningInForcedAppMode();
   const std::vector<chrome::AcceleratorMapping> accelerator_list(
       chrome::GetAcceleratorList());
@@ skipping 312 matching lines @@
       !GetLocationBar()->GetOmniboxView()->model()->popup_model()->IsOpen()) {
     gfx::Point icon_bottom(
         toolbar_->location_bar()->GetLocationBarAnchorPoint());
     ConvertPointToTarget(toolbar_->location_bar(), this, &icon_bottom);
     gfx::Point infobar_top(0, infobar_container_->GetVerticalOverlap(NULL));
     ConvertPointToTarget(infobar_container_, this, &infobar_top);
     top_arrow_height = infobar_top.y() - icon_bottom.y();
   }
   return top_arrow_height;
 }