Extension window.create API accepts state.

chrome/browser/extensions/api/tabs/tabs_api.cc

Index: chrome/browser/extensions/api/tabs/tabs_api.cc
diff --git a/chrome/browser/extensions/api/tabs/tabs_api.cc b/chrome/browser/extensions/api/tabs/tabs_api.cc
index 229d89aaed2445c1b428504800768e261b4dedac..f7052324d63bc67c8978b2f1b76728736f6db8b2 100644
--- a/chrome/browser/extensions/api/tabs/tabs_api.cc
+++ b/chrome/browser/extensions/api/tabs/tabs_api.cc
@@ -181,6 +181,23 @@ void AssignOptionalValue(const scoped_ptr<T>& source,
   }
 }
 
+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,
@@ -559,6 +576,10 @@ bool WindowsCreateFunction::RunSync() {
         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);
@@ -595,20 +616,28 @@ bool WindowsCreateFunction::RunSync() {
   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;
@@ -624,26 +653,8 @@ bool WindowsUpdateFunction::RunSync() {
                                             &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)