Place newly created app windows on screen.

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 "apps/shell_window_geometry_cache.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/app_window_contents.h"
@@ skipping 28 matching lines @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/media_stream_request.h"
 #include "extensions/browser/view_type_utils.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/screen.h"
 
 #if defined(USE_ASH)
 #include "ash/launcher/launcher_types.h"
 #endif
 
 using content::ConsoleMessageLevel;
 using content::WebContents;
 using extensions::APIPermission;
 using web_modal::WebContentsModalDialogHost;
 using web_modal::WebContentsModalDialogManager;
@@ skipping 94 matching lines @@
   // 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;
 
     apps::ShellWindowGeometryCache* cache =
         apps::ShellWindowGeometryCache::Get(profile());
 
     gfx::Rect cached_bounds;
-    if (cache->GetGeometry(extension()->id(), params.window_key,
-                           &cached_bounds, &cached_state)) {
+    gfx::Rect cached_screen_bounds;
+    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 of the screen resolution changed before show on windows platform.

[benwells, 2013/06/22 00:56:02]

nit: in case the screen ... (delete of).

[scheib, 2013/06/23 04:43:37]

Done.

+      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);
+      }
     }
   }
 
   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.
@@ skipping 435 matching lines @@
   if (window_key_.empty())
     return;
   if (!native_app_window_)
     return;
 
   apps::ShellWindowGeometryCache* cache =
       apps::ShellWindowGeometryCache::Get(profile());
 
   gfx::Rect bounds = native_app_window_->GetRestoredBounds();
   bounds.Inset(native_app_window_->GetFrameInsets());
+  gfx::Rect screen_bounds =
+      gfx::Screen::GetNativeScreen()->GetDisplayMatching(bounds).work_area();
   ui::WindowShowState window_state = native_app_window_->GetRestoredState();
-  cache->SaveGeometry(extension()->id(), window_key_, bounds, window_state);
+  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;
+
+  // 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 &&
+      !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(),
+                          current_screen_bounds.right() - bounds->width())));
+    bounds->set_y(
+        std::max(current_screen_bounds.y(),
+                 std::min(bounds->y(),
+                          current_screen_bounds.bottom() - bounds->height())));
+  }
 }
 
 // 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;
 }
 
 void ShellWindow::DisableExternalOpenForTesting() {
   disable_external_open_for_testing_ = true;
 }