Save and restore State for ShellWindows, including panels

chrome/browser/extensions/api/app_window/app_window_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/app_window/app_window_api.h"
 
 #include "base/command_line.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/ui/extensions/native_app_window.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/app_window.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "googleurl/src/gurl.h"
+#include "ui/base/ui_base_types.h"
 #include "ui/gfx/rect.h"
 
 #if defined(USE_ASH)
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #endif
 
 namespace app_window = extensions::api::app_window;
@@ skipping 40 matching lines @@
     DCHECK(type == content::NOTIFICATION_LOAD_STOP);
     delayed_create_function_->SendDelayedResponse();
     delete this;
   }
 
  private:
   scoped_refptr<AppWindowCreateFunction> delayed_create_function_;
   content::NotificationRegistrar registrar_;
 };
 
+void SetCreateResultFromShellWindow(ShellWindow* window,
+                                    base::DictionaryValue* result) {
+  result->SetBoolean("fullscreen", window->GetBaseWindow()->IsFullscreen());
+  result->SetBoolean("minimized", window->GetBaseWindow()->IsMinimized());
+  result->SetBoolean("maximized", window->GetBaseWindow()->IsMaximized());
+  DictionaryValue* boundsValue = new DictionaryValue();
+  gfx::Rect bounds = window->GetClientBounds();
+  boundsValue->SetInteger("left", bounds.x());
+  boundsValue->SetInteger("top", bounds.y());
+  boundsValue->SetInteger("width", bounds.width());
+  boundsValue->SetInteger("height", bounds.height());
+  result->Set("bounds", boundsValue);
+}
+
 }  // namespace
 
 void AppWindowCreateFunction::SendDelayedResponse() {
   SendResponse(true);
 }
 
 bool AppWindowCreateFunction::RunImpl() {
   scoped_ptr<Create::Params> params(Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
@@ skipping 38 matching lines @@
               window->web_contents()->GetRenderViewHost();
           int view_id = MSG_ROUTING_NONE;
           if (render_view_host_->GetProcess()->GetID() ==
               created_view->GetProcess()->GetID()) {
             view_id = created_view->GetRoutingID();
           }
 
           window->GetBaseWindow()->Show();
           base::DictionaryValue* result = new base::DictionaryValue;
           result->Set("viewId", base::Value::CreateIntegerValue(view_id));
+          SetCreateResultFromShellWindow(window, result);

[benwells, 2013/05/03 08:52:03]

Why is this now being done here?

(Wow this is a long function. Nice to see something get factored out of it :))

[stevenjb, 2013/05/03 17:41:14]

This code path occurs if we call app.window.create() with an existing singleton
id. While it may not be unreasonable to only populate "viewId",
"existingWindow", and "injectTitlebar", it seems more reasonable to me to also
set the bounds and state properties of the result, the same as if a new window
had been created.

If there is a reason why this wouldn't be desired, I can add a comment and
remove this.

           result->SetBoolean("existingWindow", true);
           result->SetBoolean("injectTitlebar", false);
           SetResult(result);
           SendResponse(true);
           return true;
         }
       }
     }
 
     // TODO(jeremya): remove these, since they do the same thing as
@@ skipping 70 matching lines @@
 
     if (options->resizable.get())
       create_params.resizable = *options->resizable.get();
 
     if (options->type != extensions::api::app_window::WINDOW_TYPE_PANEL) {
       switch (options->state) {
         case extensions::api::app_window::STATE_NONE:
         case extensions::api::app_window::STATE_NORMAL:
           break;
         case extensions::api::app_window::STATE_FULLSCREEN:
-          create_params.state = ShellWindow::CreateParams::STATE_FULLSCREEN;
+          create_params.state = ui::SHOW_STATE_FULLSCREEN;
           break;
         case extensions::api::app_window::STATE_MAXIMIZED:
-          create_params.state = ShellWindow::CreateParams::STATE_MAXIMIZED;
+          create_params.state = ui::SHOW_STATE_MAXIMIZED;
           break;
         case extensions::api::app_window::STATE_MINIMIZED:
-          create_params.state = ShellWindow::CreateParams::STATE_MINIMIZED;
+          create_params.state = ui::SHOW_STATE_MINIMIZED;
           break;
       }
     } else {
       force_maximize = false;
     }
   }
 
   create_params.creator_process_id =
       render_view_host_->GetProcess()->GetID();
 
   // Rather then maximizing the window after it was created, we maximize it
   // immediately - that way the initial presentation is much smoother (no odd
   // rectangles are shown temporarily in the added space). Note that suppressing
   // animations does not help to remove the shown artifacts.
 #if USE_ASH
   if (force_maximize && !create_params.maximum_size.IsEmpty()) {
     // Check that the application is able to fill the monitor - if not don't
     // maximize.
     // TODO(skuhne): In case of multi monitor usage we should find out in
     // advance on which monitor the window will be displayed (or be happy with
     // a temporary bad frame upon creation).
     gfx::Size size = ash::Shell::GetPrimaryRootWindow()->bounds().size();
     if (size.width() > create_params.maximum_size.width() ||
         size.height() > create_params.maximum_size.height())
       force_maximize = false;
   }
  #endif
 
   if (force_maximize)
-    create_params.state = ShellWindow::CreateParams::STATE_MAXIMIZED;
+    create_params.state = ui::SHOW_STATE_MINIMIZED;

[benwells, 2013/05/03 08:52:03]

Why is this changing? Seems counter intuitive. Maybe a comment would help.

[stevenjb, 2013/05/03 17:41:14]

typo. Thanks for catching.

 
   ShellWindow* shell_window =
       ShellWindow::Create(profile(), GetExtension(), url, create_params);
 
   if (chrome::ShouldForceFullscreenApp())
     shell_window->Fullscreen();
 
   content::RenderViewHost* created_view =
       shell_window->web_contents()->GetRenderViewHost();
   int view_id = MSG_ROUTING_NONE;
   if (create_params.creator_process_id == created_view->GetProcess()->GetID())
     view_id = created_view->GetRoutingID();
 
   base::DictionaryValue* result = new base::DictionaryValue;
   result->Set("viewId", base::Value::CreateIntegerValue(view_id));
   result->Set("injectTitlebar",
       base::Value::CreateBooleanValue(inject_html_titlebar));
   result->Set("id", base::Value::CreateStringValue(shell_window->window_key()));
-  DictionaryValue* boundsValue = new DictionaryValue();
-  gfx::Rect bounds = shell_window->GetClientBounds();
-  boundsValue->SetInteger("left", bounds.x());
-  boundsValue->SetInteger("top", bounds.y());
-  boundsValue->SetInteger("width", bounds.width());
-  boundsValue->SetInteger("height", bounds.height());
-  result->Set("bounds", boundsValue);
+  SetCreateResultFromShellWindow(shell_window, result);
   SetResult(result);
 
   if (ShellWindowRegistry::Get(profile())->HadDevToolsAttached(created_view)) {
     new DevToolsRestorer(this, created_view);
     return true;
   }
 
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions