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());

[Mr4D (OOO till 08-26), 2013/05/06 21:40:16]

I see here are lots of constants for the result (as well as in "old code" like
line 160). Should we "collect them" in a constants section?

[stevenjb, 2013/05/07 16:06:32]

The precedent is split in extensions/api between named constants - Set*(k - and
inlined strings - Set*(". I'd prefer not to change the pattern for this file
with this CL.

+  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);
           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_MAXIMIZED;
 
   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