Save and restore State for ShellWindows, including panels

chrome/browser/ui/extensions/shell_window.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/ui/extensions/shell_window.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/app_window_contents.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
@@ skipping 54 matching lines @@
 #endif
 
 }  // namespace
 
 ShellWindow::CreateParams::CreateParams()
   : window_type(ShellWindow::WINDOW_TYPE_DEFAULT),
     frame(ShellWindow::FRAME_CHROME),
     transparent_background(false),
     bounds(INT_MIN, INT_MIN, 0, 0),
     creator_process_id(0),
-    state(STATE_NORMAL),
+    state(ui::SHOW_STATE_DEFAULT),
     hidden(false),
     resizable(true),
     focused(true) {
 }
 
 ShellWindow::CreateParams::~CreateParams() {
 }
 
 ShellWindow* ShellWindow::Create(Profile* profile,
                                  const extensions::Extension* extension,
@@ skipping 11 matching lines @@
     : profile_(profile),
       extension_(extension),
       window_type_(WINDOW_TYPE_DEFAULT),
       ALLOW_THIS_IN_INITIALIZER_LIST(image_loader_ptr_factory_(this)),
       fullscreen_for_window_api_(false),
       fullscreen_for_tab_(false) {
 }
 
 void ShellWindow::Init(const GURL& url,
                        ShellWindowContents* shell_window_contents,
-                       const ShellWindow::CreateParams& params) {
+                       const CreateParams& params) {
   // Initialize the render interface and web contents
   shell_window_contents_.reset(shell_window_contents);
   shell_window_contents_->Initialize(profile(), url);
   WebContents* web_contents = shell_window_contents_->GetWebContents();
   WebContentsModalDialogManager::CreateForWebContents(web_contents);
   FaviconTabHelper::CreateForWebContents(web_contents);
 
   web_contents->SetDelegate(this);
   WebContentsModalDialogManager::FromWebContents(web_contents)->
       set_delegate(this);
   extensions::SetViewType(web_contents, extensions::VIEW_TYPE_APP_SHELL);
 
   // Initialize the window
   window_type_ = params.window_type;
 
   gfx::Rect bounds = params.bounds;
 
   if (bounds.width() == 0)
     bounds.set_width(kDefaultWidth);
   if (bounds.height() == 0)
     bounds.set_height(kDefaultHeight);
 
   // If left and top are left undefined, the native shell window will center
   // the window on the main screen in a platform-defined manner.
 
+  ui::WindowShowState cached_state = ui::SHOW_STATE_DEFAULT;
   if (!params.window_key.empty()) {
     window_key_ = params.window_key;
 
     extensions::ShellWindowGeometryCache* cache =
         extensions::ExtensionSystem::Get(profile())->
           shell_window_geometry_cache();
     gfx::Rect cached_bounds;
     if (cache->GetGeometry(extension()->id(), params.window_key,
-                           &cached_bounds))
+                           &cached_bounds, &cached_state)) {
       bounds = cached_bounds;
+    }
   }
 
-  ShellWindow::CreateParams new_params = params;
+  CreateParams new_params = params;
 
   gfx::Size& minimum_size = new_params.minimum_size;
   gfx::Size& maximum_size = new_params.maximum_size;
 
   // In the case that minimum size > maximum size, we consider the minimum
   // size to be more important.
   if (maximum_size.width() && maximum_size.width() < minimum_size.width())
     maximum_size.set_width(minimum_size.width());
   if (maximum_size.height() && maximum_size.height() < minimum_size.height())
     maximum_size.set_height(minimum_size.height());
 
   if (maximum_size.width() && bounds.width() > maximum_size.width())
     bounds.set_width(maximum_size.width());
   if (bounds.width() != INT_MIN && bounds.width() < minimum_size.width())
     bounds.set_width(minimum_size.width());
 
   if (maximum_size.height() && bounds.height() > maximum_size.height())
     bounds.set_height(maximum_size.height());
   if (bounds.height() != INT_MIN && bounds.height() < minimum_size.height())
     bounds.set_height(minimum_size.height());
 
   new_params.bounds = bounds;
 
+  if (cached_state != ui::SHOW_STATE_DEFAULT)
+    new_params.state = cached_state;
+
   native_app_window_.reset(NativeAppWindow::Create(this, new_params));
   OnNativeWindowChanged();
 
-  switch (params.state) {
-    case CreateParams::STATE_NORMAL:
-      break;
-    case CreateParams::STATE_FULLSCREEN:
-      Fullscreen();
-      break;
-    case CreateParams::STATE_MAXIMIZED:
-      Maximize();
-      break;
-    case CreateParams::STATE_MINIMIZED:
-      Minimize();
-      break;
-  }
+  if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
+    Fullscreen();
+  else if (new_params.state == ui::SHOW_STATE_MAXIMIZED)
+    Maximize();
+  else if (new_params.state == ui::SHOW_STATE_MINIMIZED)
+    Minimize();
 
   if (!params.hidden) {
     if (window_type_is_panel())
       GetBaseWindow()->ShowInactive();  // Panels are not activated by default.
     else
       GetBaseWindow()->Show();
   }
 
   // When the render view host is changed, the native window needs to know
   // about it in case it has any setup to do to make the renderer appear
@@ skipping 367 matching lines @@
     return;
   if (!native_app_window_)
     return;
 
   extensions::ShellWindowGeometryCache* cache =
       extensions::ExtensionSystem::Get(profile())->
           shell_window_geometry_cache();
 
   gfx::Rect bounds = native_app_window_->GetRestoredBounds();
   bounds.Inset(native_app_window_->GetFrameInsets());
-  cache->SaveGeometry(extension()->id(), window_key_, bounds);
+  ui::WindowShowState window_state;
+  if (GetBaseWindow()->IsFullscreen())
+    window_state = ui::SHOW_STATE_FULLSCREEN;
+  else if (GetBaseWindow()->IsMaximized())
+    window_state = ui::SHOW_STATE_MAXIMIZED;
+  else if (GetBaseWindow()->IsMinimized())
+    window_state = ui::SHOW_STATE_MINIMIZED;
+  else if (GetBaseWindow()->IsDetached())
+    window_state = ui::SHOW_STATE_DETACHED;
+  else
+    window_state = ui::SHOW_STATE_NORMAL;
+  cache->SaveGeometry(extension()->id(), window_key_, bounds, window_state);
 }
 
 // static
 SkRegion* ShellWindow::RawDraggableRegionsToSkRegion(
       const std::vector<extensions::DraggableRegion>& regions) {
   SkRegion* sk_region = new SkRegion;
   for (std::vector<extensions::DraggableRegion>::const_iterator iter =
            regions.begin();
        iter != regions.end(); ++iter) {
     const extensions::DraggableRegion& region = *iter;
     sk_region->op(
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }