Add extension API to change window show state using chrome.windows.update().

chrome/browser/extensions/extension_tabs_module.cc

 // Copyright (c) 2011 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/extension_tabs_module.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 452 matching lines @@
         extension_id = GetExtension()->id();
       } else if (type_str == keys::kWindowTypeValuePanel) {
         if (CommandLine::ForCurrentProcess()->HasSwitch(
                 switches::kDisablePanels)) {
           window_type = Browser::TYPE_POPUP;
         } else {
           window_type = Browser::TYPE_PANEL;
         }
         extension_id = GetExtension()->id();
       } else if (type_str != keys::kWindowTypeValueNormal) {
-        EXTENSION_FUNCTION_VALIDATE(false);
+        EXTENSION_FUNCTION_ERROR(keys::kInvalidWindowTypeError);
       }
     }
   }
 
   // Unlike other window types, Panels do not take focus by default.
   if (!saw_focus_key && window_type == Browser::TYPE_PANEL)
     focused = false;
 
   Browser* new_window;
   if (extension_id.empty()) {
@@ skipping 39 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   Browser* browser = GetBrowserInProfileWithId(profile(), window_id,
                                                include_incognito(), &error_);
   if (!browser || !browser->window()) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kWindowNotFoundError, base::IntToString(window_id));
     return false;
   }
 
+  ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;  // No change.
+  std::string state_str;
+  if (update_props->HasKey(keys::kShowStateKey)) {
+    EXTENSION_FUNCTION_VALIDATE(update_props->GetString(keys::kShowStateKey,
+                                                        &state_str));
+    if (state_str == keys::kShowStateValueNormal)
+      show_state = ui::SHOW_STATE_NORMAL;
+    else if (state_str == keys::kShowStateValueMinimized)
+      show_state = ui::SHOW_STATE_MINIMIZED;
+    else if (state_str == keys::kShowStateValueMaximized)
+      show_state = ui::SHOW_STATE_MAXIMIZED;
+    else
+      EXTENSION_FUNCTION_ERROR(keys::kInvalidWindowStateError);
+  }
+
+  switch (show_state) {
+    case ui::SHOW_STATE_MINIMIZED:
+      browser->window()->Minimize();
+      break;
+    case ui::SHOW_STATE_MAXIMIZED:
+      browser->window()->Maximize();
+      break;
+    case ui::SHOW_STATE_NORMAL:
+      browser->window()->Restore();
+      break;
+    default:
+      break;
+  }
+
   gfx::Rect bounds = browser->window()->GetRestoredBounds();
   bool set_bounds = false;
+
   // Any part of the bounds can optionally be set by the caller.
   int bounds_val;
   if (update_props->HasKey(keys::kLeftKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
         keys::kLeftKey,
         &bounds_val));
     bounds.set_x(bounds_val);
     set_bounds = true;
   }
 
@@ skipping 13 matching lines @@
     set_bounds = true;
   }
 
   if (update_props->HasKey(keys::kHeightKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
         keys::kHeightKey,
         &bounds_val));
     bounds.set_height(bounds_val);
     set_bounds = true;
   }
-  if (set_bounds)
-    browser->window()->SetBounds(bounds);
+
+  if (set_bounds) {
+    if (show_state == ui::SHOW_STATE_MINIMIZED ||
+        show_state == ui::SHOW_STATE_MAXIMIZED)
+      EXTENSION_FUNCTION_ERROR(keys::kInvalidWindowStateError);
+    else
+      browser->window()->SetBounds(bounds);
+  }
 
   bool active_val = false;
   if (update_props->HasKey(keys::kFocusedKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kFocusedKey, &active_val));
-    if (active_val)
-      browser->window()->Activate();
-    else
-      browser->window()->Deactivate();
+    if (active_val) {
+      if (show_state == ui::SHOW_STATE_MINIMIZED)
+        EXTENSION_FUNCTION_ERROR(keys::kInvalidWindowStateError);
+      else
+        browser->window()->Activate();
+    } else {
+      if (show_state == ui::SHOW_STATE_MAXIMIZED)
+        EXTENSION_FUNCTION_ERROR(keys::kInvalidWindowStateError);

[asargent_no_longer_on_chrome, 2011/11/21 19:04:05]

nit: EXTENSION_FUNCTION_ERROR sets bad_message_ = true, which ends up killing
the renderer process. The idea here is this should only be used for cases where
we got data that should have already been caught by the schema validation in the
renderer process (eg a missing param that isn't marked optional in
extension_api.json). For cases where we just want to return an error message but
not terminate the renderer, the right thing to do is:


error_ = keys::kInvalidWindowStateError;
return false;


(Also we have the ExtensionErrorUtils::FormatErrorMessage function for cases
where you want to have a paramaeterized error message)

+      else
+        browser->window()->Deactivate();
+    }
   }
 
   bool draw_attention = false;
   if (update_props->HasKey(keys::kDrawAttentionKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kDrawAttentionKey, &draw_attention));
     if (draw_attention)
         browser->window()->FlashFrame();
   }
 
@@ skipping 978 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }