fullscreen in apps v2 ShellWindow via app.window.create.

chrome/browser/ui/extensions/shell_window.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/extensions/shell_window.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/app_window_contents.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
@@ skipping 55 matching lines @@
 const int kPreferredIconSize = extension_misc::EXTENSION_ICON_SMALL;
 #endif
 
 }  // namespace
 
 ShellWindow::CreateParams::CreateParams()
   : window_type(ShellWindow::WINDOW_TYPE_DEFAULT),
     frame(ShellWindow::FRAME_CHROME),
     transparent_background(false),
     bounds(INT_MIN, INT_MIN, 0, 0),
-    creator_process_id(0), hidden(false), resizable(true), focused(true) {
+    creator_process_id(0),
+    state(STATE_NORMAL),
+    hidden(false),
+    resizable(true),
+    focused(true) {
 }
 
 ShellWindow::CreateParams::~CreateParams() {
 }
 
 ShellWindow* ShellWindow::Create(Profile* profile,
                                  const extensions::Extension* extension,
                                  const GURL& url,
                                  const CreateParams& params) {
   // This object will delete itself when the window is closed.
   ShellWindow* window = new ShellWindow(profile, extension);
   window->Init(url, new AppWindowContents(window), params);
   extensions::ShellWindowRegistry::Get(profile)->AddShellWindow(window);
   return window;
 }
 
 ShellWindow::ShellWindow(Profile* profile,
                          const extensions::Extension* extension)
     : profile_(profile),
       extension_(extension),
       window_type_(WINDOW_TYPE_DEFAULT),
-      ALLOW_THIS_IN_INITIALIZER_LIST(image_loader_ptr_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(image_loader_ptr_factory_(this)),
+      fullscreen_for_window_api_(false),
+      fullscreen_for_tab_(false) {
 }
 
 void ShellWindow::Init(const GURL& url,
                        ShellWindowContents* shell_window_contents,
                        const ShellWindow::CreateParams& params) {
   // Initialize the render interface and web contents
   shell_window_contents_.reset(shell_window_contents);
   shell_window_contents_->Initialize(profile(), url);
   WebContents* web_contents = shell_window_contents_->GetWebContents();
   WebContentsModalDialogManager::CreateForWebContents(web_contents);
@@ skipping 47 matching lines @@
   if (maximum_size.height() && bounds.height() > maximum_size.height())
     bounds.set_height(maximum_size.height());
   if (bounds.height() != INT_MIN && bounds.height() < minimum_size.height())
     bounds.set_height(minimum_size.height());
 
   new_params.bounds = bounds;
 
   native_app_window_.reset(NativeAppWindow::Create(this, new_params));
   OnNativeWindowChanged();
 
+  switch (params.state) {
+    case CreateParams::STATE_NORMAL:
+      break;
+    case CreateParams::STATE_FULLSCREEN:
+      Fullscreen();
+      break;
+    case CreateParams::STATE_MAXIMIZED:
+      Maximize();
+      break;
+    case CreateParams::STATE_MINIMIZED:
+      Minimize();
+      break;
+  }

[jeremya, 2013/04/05 20:00:35]

default: NOTREACHED()?

Are these all okay to do before the window is shown?

[scheib, 2013/04/05 21:47:52]

Google code style suggests NOT having a default if you intend to handle all
enumerations. It is a compiler error to not handle all enum values, so when a
new one is introduced you have a compile error until you fix all switch use
locations.
Empirically, yes.

[jeremya, 2013/04/08 17:13:54]

I hope nobody ever upcasts an int into that enum, then :/

+
   if (!params.hidden) {
     if (window_type_is_panel())
       GetBaseWindow()->ShowInactive();  // Panels are not activated by default.
     else
       GetBaseWindow()->Show();
   }
 
   // When the render view host is changed, the native window needs to know
   // about it in case it has any setup to do to make the renderer appear
   // properly. In particular, on Windows, the view's clickthrough region needs
@@ skipping 197 matching lines @@
 }
 
 void ShellWindow::UpdateAppIcon(const gfx::Image& image) {
   if (image.IsEmpty())
     return;
   app_icon_ = image;
   native_app_window_->UpdateWindowIcon();
   extensions::ShellWindowRegistry::Get(profile_)->ShellWindowIconChanged(this);
 }
 
+void ShellWindow::Fullscreen() {
+  fullscreen_for_window_api_ = true;
+  GetBaseWindow()->SetFullscreen(true);
+}
+
+void ShellWindow::Maximize() {
+  GetBaseWindow()->Maximize();
+}
+
+void ShellWindow::Minimize() {
+  GetBaseWindow()->Minimize();
+}
+
+void ShellWindow::Restore() {
+  fullscreen_for_window_api_ = false;
+  fullscreen_for_tab_ = false;
+  if (GetBaseWindow()->IsFullscreenOrPending()) {
+    GetBaseWindow()->SetFullscreen(false);
+  } else {
+    GetBaseWindow()->Restore();
+  }
+}
+
 //------------------------------------------------------------------------------
 // Private methods
 
 void ShellWindow::OnImageLoaded(const gfx::Image& image) {
   UpdateAppIcon(image);
 }
 
 void ShellWindow::DidDownloadFavicon(int id,
                                      const GURL& image_url,
                                      int requested_size,
@@ skipping 53 matching lines @@
 void ShellWindow::NavigationStateChanged(
     const content::WebContents* source, unsigned changed_flags) {
   if (changed_flags & content::INVALIDATE_TYPE_TITLE)
     native_app_window_->UpdateWindowTitle();
   else if (changed_flags & content::INVALIDATE_TYPE_TAB)
     native_app_window_->UpdateWindowIcon();
 }
 
 void ShellWindow::ToggleFullscreenModeForTab(content::WebContents* source,
                                              bool enter_fullscreen) {
-  bool has_permission = IsExtensionWithPermissionOrSuggestInConsole(
+  if (!IsExtensionWithPermissionOrSuggestInConsole(
       APIPermission::kFullscreen,
       extension_,
-      source->GetRenderViewHost());
+      source->GetRenderViewHost())) {
+    return;
+  }
 
-  if (has_permission)
-    native_app_window_->SetFullscreen(enter_fullscreen);
+  fullscreen_for_tab_ = enter_fullscreen;
+
+  if (enter_fullscreen) {
+    native_app_window_->SetFullscreen(true);
+  } else if (!fullscreen_for_window_api_) {

[jeremya, 2013/04/05 20:00:35]

fdsdsffasafdsf.

There must be a better way :(

[scheib, 2013/04/05 21:47:52]

I haven't thought of it. We can fold these two variables into an enum with 4
states, they're all valid:

enum {
  NOT_FULLSCREEN,
  FULLSCREEN_TAB,
  FULLSCREEN_WINDOW,
  FULLSCREEN_TAB_AND_WINDOW
}

but I don't see what that gets us here. (In fullscreen_controller, I think it is
a win, because there are many other complicating states).

[jeremya, 2013/04/08 17:13:54]

I guess there's no way to combine it all into one bool, possibly changing
behaviour? Perhaps we'd be better off hacking blink to allow us to create pages
in fullscreen mode, rather than adding Yet Another Fullscreen Mode.

+    native_app_window_->SetFullscreen(false);
+  }
 }
 
 bool ShellWindow::IsFullscreenForTabOrPending(
     const content::WebContents* source) const {
-  return native_app_window_->IsFullscreenOrPending();
+  return fullscreen_for_tab_;
 }
 
 void ShellWindow::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
       // TODO(jianli): once http://crbug.com/123007 is fixed, we'll no longer
       // need to make the native window (ShellWindowViews specially) update
       // the clickthrough region for the new RVH.
@@ skipping 54 matching lines @@
     const extensions::DraggableRegion& region = *iter;
     sk_region->op(
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }