Do not restore corrupt cached app window bounds.

apps/shell_window.cc

 // Copyright 2013 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 "apps/shell_window.h"
 
 #include "apps/shell_window_geometry_cache.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 90 matching lines @@
   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;
+  CreateParams new_params = params;
+
+  // Load cached state if it exists.
   if (!params.window_key.empty()) {
     window_key_ = params.window_key;
 
     ShellWindowGeometryCache* cache = ShellWindowGeometryCache::Get(profile());
 
     gfx::Rect cached_bounds;
     gfx::Rect cached_screen_bounds;
+    ui::WindowShowState cached_state = ui::SHOW_STATE_DEFAULT;
     if (cache->GetGeometry(extension()->id(), params.window_key, &cached_bounds,
                            &cached_screen_bounds, &cached_state)) {
-      bounds = cached_bounds;
       // App window has cached screen bounds, make sure it fits on screen in
       // case the screen resolution changed.
-      if (!cached_screen_bounds.IsEmpty()) {
-        gfx::Screen* screen = gfx::Screen::GetNativeScreen();
-        gfx::Display display = screen->GetDisplayMatching(cached_bounds);
-        gfx::Rect current_screen_bounds = display.work_area();
-        AdjustBoundsToBeVisibleOnScreen(cached_bounds,
-                                        cached_screen_bounds,
-                                        current_screen_bounds,
-                                        params.minimum_size,
-                                        &bounds);
-      }
+      AdjustBoundsToBeVisibleOnScreen(cached_bounds,
+                                      cached_screen_bounds,
+                                      params.minimum_size,
+                                      &bounds);
+      new_params.state = cached_state;
     }
   }
 
-  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));
 
   if (!new_params.hidden) {
     if (window_type_is_panel())
       GetBaseWindow()->ShowInactive();  // Panels are not activated by default.
     else
       GetBaseWindow()->Show();
   }
 
   if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
@@ skipping 405 matching lines @@
   cache->SaveGeometry(extension()->id(),
                       window_key_,
                       bounds,
                       screen_bounds,
                       window_state);
 }
 
 void ShellWindow::AdjustBoundsToBeVisibleOnScreen(
     const gfx::Rect& cached_bounds,
     const gfx::Rect& cached_screen_bounds,
-    const gfx::Rect& current_screen_bounds,
     const gfx::Size& minimum_size,
     gfx::Rect* bounds) const {
-  if (!bounds)
-    return;
+  *bounds = cached_bounds;
 
-  *bounds = cached_bounds;
+  gfx::Screen* screen = gfx::Screen::GetNativeScreen();
+  gfx::Display display = screen->GetDisplayMatching(cached_bounds);
+  gfx::Rect current_screen_bounds = display.work_area();
 
   // Reposition and resize the bounds if the cached_screen_bounds is different
   // from the current screen bounds and the current screen bounds doesn't
   // completely contain the bounds.
-  if (!cached_screen_bounds.IsEmpty() &&
-      cached_screen_bounds != current_screen_bounds &&
+  if (cached_screen_bounds != current_screen_bounds &&
       !current_screen_bounds.Contains(cached_bounds)) {
     bounds->set_width(
         std::max(minimum_size.width(),
                  std::min(bounds->width(), current_screen_bounds.width())));
     bounds->set_height(
         std::max(minimum_size.height(),
                  std::min(bounds->height(), current_screen_bounds.height())));
     bounds->set_x(
         std::max(current_screen_bounds.x(),
                  std::min(bounds->x(),
@@ skipping 17 matching lines @@
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }
 
 }  // namespace apps