Extension window.create API accepts state.

chrome/browser/extensions/api/tabs/tabs_api.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/extensions/api/tabs/tabs_api.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 163 matching lines @@
 }
 
 template <typename T>
 void AssignOptionalValue(const scoped_ptr<T>& source,
                          scoped_ptr<T>& destination) {
   if (source.get()) {
     destination.reset(new T(*source.get()));
   }
 }
 
+ui::WindowShowState ConvertToWindowShowState(windows::State state) {
+  switch (state) {
+    case windows::STATE_NORMAL:
+      return ui::SHOW_STATE_NORMAL;
+    case windows::STATE_MINIMIZED:
+      return ui::SHOW_STATE_MINIMIZED;
+    case windows::STATE_MAXIMIZED:
+      return ui::SHOW_STATE_MAXIMIZED;
+    case windows::STATE_FULLSCREEN:
+      return ui::SHOW_STATE_FULLSCREEN;
+    case windows::STATE_NONE:
+      return ui::SHOW_STATE_DEFAULT;
+  }
+  NOTREACHED();
+  return ui::SHOW_STATE_DEFAULT;
+}
+
 }  // namespace
 
 void ZoomModeToZoomSettings(ZoomController::ZoomMode zoom_mode,
                             api::tabs::ZoomSettings* zoom_settings) {
   DCHECK(zoom_settings);
   switch (zoom_mode) {
     case ZoomController::ZOOM_MODE_DEFAULT:
       zoom_settings->mode = api::tabs::ZoomSettings::MODE_AUTOMATIC;
       zoom_settings->scope = api::tabs::ZoomSettings::SCOPE_PER_ORIGIN;
       break;
@@ skipping 358 matching lines @@
     create_params.initial_bounds = window_bounds;
   } else {
     create_params = Browser::CreateParams::CreateForApp(
         web_app::GenerateApplicationNameFromExtensionId(extension_id),
         false /* trusted_source */,
         window_bounds,
         window_profile,
         host_desktop_type);
   }
   create_params.initial_show_state = ui::SHOW_STATE_NORMAL;
+  if (create_data && create_data->state) {
+    create_params.initial_show_state =
+        ConvertToWindowShowState(create_data->state);
+  }
   create_params.host_desktop_type = chrome::GetActiveDesktop();
 
   Browser* new_window = new Browser(create_params);
 
   for (std::vector<GURL>::iterator i = urls.begin(); i != urls.end(); ++i) {
     WebContents* tab = chrome::AddSelectedTabWithURL(
         new_window, *i, ui::PAGE_TRANSITION_LINK);
     if (create_panel) {
       TabHelper::FromWebContents(tab)->SetExtensionAppIconById(extension_id);
     }
@@ skipping 16 matching lines @@
   // tab when it is intended to create an empty popup.
   if (!contents && urls.empty() && window_type != Browser::TYPE_POPUP) {
     chrome::NewTab(new_window);
   }
   chrome::SelectNumberedTab(new_window, 0);
 
   // Unlike other window types, Panels do not take focus by default.
   if (!saw_focus_key && create_panel)
     focused = false;
 
+  WindowController* controller = new_window->extension_window_controller();
+  // Start being fullscreen before Show(). This make the window looks like
+  // initialy fullscreen.
+  if (create_params.initial_show_state == ui::SHOW_STATE_FULLSCREEN)
+    controller->SetFullscreenMode(true, extension()->url());
+
   if (focused)
     new_window->window()->Show();
   else
     new_window->window()->ShowInactive();
 
+  // Make window minimized. Because Window can't be initially minimized.
+  if (create_params.initial_show_state == ui::SHOW_STATE_MINIMIZED)
+    new_window->window()->Minimize();

[tapted, 2015/04/01 03:41:55]

These additions still don't look right to me.

On Mac, BrowserWindowCocoa::Show() checks for initial_show_state_ being
MINIMIZED or FULLSCREEN, so it should be dealt with on the ->Show() call just
above.

On non-Mac, views::Widget::Show() checks for saved_show_state_ being maximized,
and for IsFullscreen(). saved_show_state_ is set in Widget::SetInitialBounds()
using GetSavedWindowPlacement() which uses
widget_delegate_->GetSavedWindowPlacement(). On non-Mac, BrowserView implements
WidgetDelegate in this case, and BrowserView::GetSavedWindowPlacement() calls
chrome::GetSavedWindowBoundsAndShowState() and other things, ending up in

WindowSizer::DetermineWindowBoundsAndShowState()

here, there's a `#if defined(USE_ASH)` which is probably out of date, since
that's now true on everything but Mac -- the code in this function below that
#ifdef is probably dead code. Ignoring that, it still does 

`*show_state = GetWindowDefaultShowState();`

GetWindowDefaultShowState() returns browser_->initial_show_state(), and this
should be the value that's passed in on line 585 above.

So why isn't BrowserWindowCocoa::Show() or views::Widget::Show() already
handling this?

Having separate calls after the call to Show() will result in in-between states
-- really it needs to be dealt with properly on the initial Show(), using either
NativeWidget::ShowMaximizedWithBounds() or NativeWidget::ShowWithWindowState()

[limasdf, 2015/04/01 23:59:45]

Yeah. views::Widget::Show() make newly made window visible.(minimzie->normal). 
but BrowserWindowCocoa::Show() doesn't.

I'll create new issue. and try to fix it first for ideal implementation!

Thank you for detail information.

[limasdf, 2015/04/02 16:57:48]

I found that minimized window creation from X11 is not implemented yet.
so it act like "normal" state.
I filed an issue, crbug.com/473228

[tapted, 2015/04/15 00:36:12]

So is it just X11 that's affected?

reading DesktopWindowTreeHostX11::MapWindow() it sounds like these lines would
never have worked reliably on X11, since minimize/maximize hints may be ignored
until the window is mapped, which happens asynchronously.

So, if you take out the calls here to Minimize() and SetFullscreenMode(), does
the CL work everywhere except desktop linux?

IMO it's OK to leave desktop linux as a TODO - just disable the test there and
reference http://crbug.com/473228 . Then a follow-up can make necessary changes
to DesktopWindowTreeHostX11 to give minimize/fullscreen the same treatment as
maximize (e.g. similar to DesktopWindowTreeHostX11::should_maximize_after_map_).

[limasdf, 2015/04/15 23:34:49]

About creation of minimized window, Only X11 doesn't work.
About creation of fullscreen window, Both X11 and Windows doesn't work.
(I can see HWNDMessageHandler::ShowWindowWithState doesn't handle fullscreen
state http://goo.gl/Kxh31O ).
I think creation of fullscreen window also should be implemented from both X11
and Windows. Let me file an issue about it.

[tapted, 2015/04/16 00:31:03]

For Windows and fullscreen, I've seen this too. See
https://code.google.com/p/chromium/codesearch#chromium/src/ui/views/widget/wi...
for my solution. The bug is already filed -- http://crbug.com/475813

i.e. the window is full-screened, but doesn't update the show state. If you can
verify that this CL experiences the same on Windows once the extra
SetFullscreenMode call is removed, then I would just put an #if defined(OS_WIN)
in the test case, with a check for whatever Windows currently reports.

+
   if (new_window->profile()->IsOffTheRecord() &&
       !GetProfile()->IsOffTheRecord() && !include_incognito()) {
     // Don't expose incognito windows if extension itself works in non-incognito
     // profile and CanCrossIncognito isn't allowed.
     SetResult(base::Value::CreateNullValue());
   } else {
-    SetResult(
-        new_window->extension_window_controller()->CreateWindowValueWithTabs(
-            extension()));
+    SetResult(controller->CreateWindowValueWithTabs(extension()));
   }
 
   return true;
 }
 
 bool WindowsUpdateFunction::RunSync() {
   scoped_ptr<windows::Update::Params> params(
       windows::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                             &controller))
     return false;
 
-  ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;  // No change.
-  switch (params->update_info.state) {
-    case windows::Update::Params::UpdateInfo::STATE_NORMAL:
-      show_state = ui::SHOW_STATE_NORMAL;
-      break;
-    case windows::Update::Params::UpdateInfo::STATE_MINIMIZED:
-      show_state = ui::SHOW_STATE_MINIMIZED;
-      break;
-    case windows::Update::Params::UpdateInfo::STATE_MAXIMIZED:
-      show_state = ui::SHOW_STATE_MAXIMIZED;
-      break;
-    case windows::Update::Params::UpdateInfo::STATE_FULLSCREEN:
-      show_state = ui::SHOW_STATE_FULLSCREEN;
-      break;
-    case windows::Update::Params::UpdateInfo::STATE_NONE:
-      break;
-    default:
-      error_ = keys::kInvalidWindowStateError;
-      return false;
-  }
+  ui::WindowShowState show_state =
+      ConvertToWindowShowState(params->update_info.state);
 
   if (show_state != ui::SHOW_STATE_FULLSCREEN &&
       show_state != ui::SHOW_STATE_DEFAULT)
     controller->SetFullscreenMode(false, extension()->url());
 
   switch (show_state) {
     case ui::SHOW_STATE_MINIMIZED:
       controller->window()->Minimize();
       break;
     case ui::SHOW_STATE_MAXIMIZED:
@@ skipping 1296 matching lines @@
   ZoomController::ZoomMode zoom_mode = zoom_controller->zoom_mode();
   api::tabs::ZoomSettings zoom_settings;
   ZoomModeToZoomSettings(zoom_mode, &zoom_settings);
 
   results_ = api::tabs::GetZoomSettings::Results::Create(zoom_settings);
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions