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;
+    default:

[not at google - send to devlin, 2015/03/19 15:43:45]

No default case; have the NOTREACHED() outside the switch statement. Better
compiler errors.

[limasdf, 2015/03/19 17:40:13]

Done.

+      NOTREACHED();
+  }
+  return ui::SHOW_STATE_DEFAULT;
+}
+
+bool IsValidStateForWindowCreateFunction(
+    const windows::Create::Params::CreateData* create_data) {
+  if (!create_data)
+    return true;
+
+  windows::State state = create_data->state;
+  if (create_data->focused) {
+    if (*create_data->focused) {
+      if (state == windows::STATE_MINIMIZED) {
+        return false;
+      }
+    } else {
+      if ((state == windows::STATE_MAXIMIZED ||
+           state == windows::STATE_FULLSCREEN)) {
+        return false;
+      }
+    }
+  }
+  bool has_bound = create_data->left || create_data->top ||
+                   create_data->width || create_data->height;
+  if (has_bound &&
+      (state == windows::STATE_MINIMIZED || state == windows::STATE_MAXIMIZED ||
+       state == windows::STATE_FULLSCREEN)) {
+    return false;
+  }
+  bool is_panel =
+      create_data->type == windows::Create::Params::CreateData::TYPE_PANEL ||
+      create_data->type ==
+          windows::Create::Params::CreateData::TYPE_DETACHED_PANEL;
+  if (is_panel &&
+      (state == windows::STATE_MINIMIZED || state == windows::STATE_MAXIMIZED ||
+       state == windows::STATE_FULLSCREEN)) {
+    return false;
+  }
+  return true;
+}
 }  // 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 203 matching lines @@
                     GetProfile(),
                     include_incognito(),
                     NULL,
                     &source_tab_strip,
                     NULL,
                     &tab_index,
                     &error_))
       return false;
   }
 
+  if (!IsValidStateForWindowCreateFunction(create_data)) {
+    error_ = keys::kInvalidWindowStateError;
+    return false;
+  }
+
   Profile* window_profile = GetProfile();
   Browser::Type window_type = Browser::TYPE_TABBED;
   bool create_panel = false;
 
   // panel_create_mode only applies if create_panel = true
   PanelManager::CreateMode panel_create_mode = PanelManager::CREATE_AS_DOCKED;
 
   gfx::Rect window_bounds;
   bool focused = true;
   bool saw_focus_key = false;
@@ skipping 135 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();
+  if (create_params.initial_show_state == ui::SHOW_STATE_FULLSCREEN)
+    controller->SetFullscreenMode(true, extension()->url());
+
+  if (create_params.initial_show_state == ui::SHOW_STATE_MINIMIZED)
+    focused = false;
+
   if (focused)
     new_window->window()->Show();
   else
     new_window->window()->ShowInactive();
 
   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