Create windows for new app window bounds API

apps/app_window.cc

 // Copyright 2014 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/app_window.h"
 
+#include <algorithm>
+
 #include "apps/app_window_geometry_cache.h"
 #include "apps/app_window_registry.h"
 #include "apps/apps_client.h"
 #include "apps/size_constraints.h"
 #include "apps/ui/native_app_window.h"
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 71 matching lines @@
   SetConstraintProperty("minWidth", min_size.width(), bounds_properties.get());
   SetConstraintProperty(
       "minHeight", min_size.height(), bounds_properties.get());
   SetConstraintProperty("maxWidth", max_size.width(), bounds_properties.get());
   SetConstraintProperty(
       "maxHeight", max_size.height(), bounds_properties.get());
 
   window_properties->Set(bounds_name, bounds_properties.release());
 }
 
+// Combines the constraints of the content and window, and returns constraints
+// for the window.
+gfx::Size GetCombinedWindowConstraints(const gfx::Size& window_constraints,
+                                       const gfx::Size& content_constraints,
+                                       const gfx::Insets& frame_insets) {
+  gfx::Size combined_constraints(window_constraints);
+  if (content_constraints.width() > 0) {
+    combined_constraints.set_width(
+        content_constraints.width() + frame_insets.width());
+  }
+  if (content_constraints.height() > 0) {
+    combined_constraints.set_height(
+        content_constraints.height() + frame_insets.height());
+  }
+  return combined_constraints;
+}
+
+// Combines the constraints of the content and window, and returns constraints
+// for the content.
+gfx::Size GetCombinedContentConstraints(const gfx::Size& window_constraints,
+                                        const gfx::Size& content_constraints,
+                                        const gfx::Insets& frame_insets) {
+  gfx::Size combined_constraints(content_constraints);
+  if (window_constraints.width() > 0) {
+    combined_constraints.set_width(
+        std::max(0, window_constraints.width() - frame_insets.width()));
+  }
+  if (window_constraints.height() > 0) {
+    combined_constraints.set_height(
+        std::max(0, window_constraints.height() - frame_insets.height()));
+  }
+  return combined_constraints;
+}
+
 }  // namespace
 
+// AppWindow::BoundsSpecification
+
+const int AppWindow::BoundsSpecification::kUnspecifiedPosition = INT_MIN;
+
+AppWindow::BoundsSpecification::BoundsSpecification()
+    : bounds(kUnspecifiedPosition, kUnspecifiedPosition, 0, 0) {}
+
+AppWindow::BoundsSpecification::~BoundsSpecification() {}
+
+void AppWindow::BoundsSpecification::ResetBounds() {
+  bounds.SetRect(kUnspecifiedPosition, kUnspecifiedPosition, 0, 0);
+}
+
+// AppWindow::CreateParams
+
 AppWindow::CreateParams::CreateParams()
     : window_type(AppWindow::WINDOW_TYPE_DEFAULT),
       frame(AppWindow::FRAME_CHROME),
       has_frame_color(false),
       transparent_background(false),
-      bounds(INT_MIN, INT_MIN, 0, 0),
       creator_process_id(0),
       state(ui::SHOW_STATE_DEFAULT),
       hidden(false),
       resizable(true),
       focused(true),
       always_on_top(false) {}
 
 AppWindow::CreateParams::~CreateParams() {}
 
+gfx::Rect AppWindow::CreateParams::GetInitialWindowBounds(
+    const gfx::Insets& frame_insets) const {
+  // Combine into a single window bounds.
+  gfx::Rect combined_bounds(window_spec.bounds);
+  if (content_spec.bounds.x() != BoundsSpecification::kUnspecifiedPosition)
+    combined_bounds.set_x(content_spec.bounds.x() - frame_insets.left());
+  if (content_spec.bounds.y() != BoundsSpecification::kUnspecifiedPosition)
+    combined_bounds.set_y(content_spec.bounds.y() - frame_insets.top());
+  if (content_spec.bounds.width() > 0) {
+    combined_bounds.set_width(
+        content_spec.bounds.width() + frame_insets.width());
+  }
+  if (content_spec.bounds.height() > 0) {
+    combined_bounds.set_height(
+        content_spec.bounds.height() + frame_insets.height());
+  }
+
+  // Constrain the bounds.
+  SizeConstraints constraints(
+      GetCombinedWindowConstraints(
+          window_spec.minimum_size, content_spec.minimum_size, frame_insets),
+      GetCombinedWindowConstraints(
+          window_spec.maximum_size, content_spec.maximum_size, frame_insets));
+  combined_bounds.set_size(constraints.ClampSize(combined_bounds.size()));
+
+  return combined_bounds;
+}
+
+gfx::Size AppWindow::CreateParams::GetContentMinimumSize(
+    const gfx::Insets& frame_insets) const {
+  return GetCombinedContentConstraints(window_spec.minimum_size,
+                                       content_spec.minimum_size,
+                                       frame_insets);
+}
+
+gfx::Size AppWindow::CreateParams::GetContentMaximumSize(
+    const gfx::Insets& frame_insets) const {
+  return GetCombinedContentConstraints(window_spec.maximum_size,
+                                       content_spec.maximum_size,
+                                       frame_insets);
+}
+
+gfx::Size AppWindow::CreateParams::GetWindowMinimumSize(
+    const gfx::Insets& frame_insets) const {
+  return GetCombinedWindowConstraints(window_spec.minimum_size,
+                                      content_spec.minimum_size,
+                                      frame_insets);
+}
+
+gfx::Size AppWindow::CreateParams::GetWindowMaximumSize(
+    const gfx::Insets& frame_insets) const {
+  return GetCombinedWindowConstraints(window_spec.maximum_size,
+                                      content_spec.maximum_size,
+                                      frame_insets);
+}
+
+// AppWindow::Delegate
+
 AppWindow::Delegate::~Delegate() {}
 
+// AppWindow
+
 AppWindow::AppWindow(BrowserContext* context,
                      Delegate* delegate,
                      const extensions::Extension* extension)
     : browser_context_(context),
       extension_(extension),
       extension_id_(extension->id()),
       window_type_(WINDOW_TYPE_DEFAULT),
       delegate_(delegate),
       image_loader_ptr_factory_(this),
       fullscreen_types_(FULLSCREEN_TYPE_NONE),
@@ skipping 20 matching lines @@
   delegate_->InitWebContents(web_contents);
   WebContentsModalDialogManager::CreateForWebContents(web_contents);
   extensions::ExtensionWebContentsObserver::CreateForWebContents(web_contents);
 
   web_contents->SetDelegate(this);
   WebContentsModalDialogManager::FromWebContents(web_contents)
       ->SetDelegate(this);
   extensions::SetViewType(web_contents, extensions::VIEW_TYPE_APP_WINDOW);
 
   // Initialize the window
-  CreateParams new_params = LoadDefaultsAndConstrain(params);
+  CreateParams new_params = LoadDefaults(params);
   window_type_ = new_params.window_type;
   window_key_ = new_params.window_key;
 
   // Windows cannot be always-on-top in fullscreen mode for security reasons.
   cached_always_on_top_ = new_params.always_on_top;
   if (new_params.state == ui::SHOW_STATE_FULLSCREEN)
     new_params.always_on_top = false;
 
   native_app_window_.reset(delegate_->CreateNativeAppWindow(this, new_params));
 
@@ skipping 33 matching lines @@
                      client->GetOriginalContext(browser_context_)));
 
   app_window_contents_->LoadContents(new_params.creator_process_id);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAppsShowOnFirstPaint)) {
     // We want to show the window only when the content has been painted. For
     // that to happen, we need to define a size for the content, otherwise the
     // layout will happen in a 0x0 area.
     // Note: WebContents::GetView() is guaranteed to be non-null.
-    web_contents->GetView()->SizeContents(new_params.bounds.size());
+    gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
+    gfx::Rect initial_bounds = new_params.GetInitialWindowBounds(frame_insets);
+    initial_bounds.Inset(frame_insets);
+    web_contents->GetView()->SizeContents(initial_bounds.size());
   }
 
   // Prevent the browser process from shutting down while this window is open.
   AppsClient::Get()->IncrementKeepAliveCount();
 
   UpdateExtensionAppIcon();
 
   AppWindowRegistry::Get(browser_context_)->AddAppWindow(this);
 }
 
@@ skipping 290 matching lines @@
 #endif
   fullscreen_types_ |= FULLSCREEN_TYPE_OS;
   SetNativeWindowFullscreen();
 }
 
 void AppWindow::ForcedFullscreen() {
   fullscreen_types_ |= FULLSCREEN_TYPE_FORCED;
   SetNativeWindowFullscreen();
 }
 
-void AppWindow::SetMinimumSize(const gfx::Size& min_size) {
-  native_app_window_->SetMinimumSize(min_size);
+void AppWindow::SetContentMinimumSize(const gfx::Size& min_size) {
+  native_app_window_->SetContentMinimumSize(min_size);
   OnSizeConstraintsChanged();
 }
 
-void AppWindow::SetMaximumSize(const gfx::Size& max_size) {
-  native_app_window_->SetMaximumSize(max_size);
+void AppWindow::SetContentMaximumSize(const gfx::Size& max_size) {
+  native_app_window_->SetContentMaximumSize(max_size);
   OnSizeConstraintsChanged();
 }
 
 void AppWindow::Show(ShowType show_type) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAppsShowOnFirstPaint)) {
     show_on_first_paint_ = true;
 
     if (!first_paint_complete_) {
       delayed_show_type_ = show_type;
@@ skipping 42 matching lines @@
 
   properties->SetBoolean("fullscreen",
                          native_app_window_->IsFullscreenOrPending());
   properties->SetBoolean("minimized", native_app_window_->IsMinimized());
   properties->SetBoolean("maximized", native_app_window_->IsMaximized());
   properties->SetBoolean("alwaysOnTop", IsAlwaysOnTop());
   properties->SetBoolean("hasFrameColor", native_app_window_->HasFrameColor());
   properties->SetInteger("frameColor", native_app_window_->FrameColor());
 
   gfx::Rect content_bounds = GetClientBounds();
+  gfx::Size content_min_size = native_app_window_->GetContentMinimumSize();
+  gfx::Size content_max_size = native_app_window_->GetContentMaximumSize();
   SetBoundsProperties(content_bounds,
-                      native_app_window_->GetMinimumSize(),
-                      native_app_window_->GetMaximumSize(),
+                      content_min_size,
+                      content_max_size,
                       "innerBounds",
                       properties);
 
-  // TODO(tmdiep): Frame constraints will be implemented in a future patch.
+  gfx::Insets frame_insets = native_app_window_->GetFrameInsets();
   gfx::Rect frame_bounds = native_app_window_->GetBounds();
+  gfx::Size frame_min_size =
+      SizeConstraints::AddFrameToConstraints(content_min_size, frame_insets);
+  gfx::Size frame_max_size =
+      SizeConstraints::AddFrameToConstraints(content_max_size, frame_insets);
   SetBoundsProperties(frame_bounds,
-                      gfx::Size(),
-                      gfx::Size(),
+                      frame_min_size,
+                      frame_max_size,
                       "outerBounds",
                       properties);
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
 void AppWindow::UpdateBadgeIcon(const gfx::Image& image) {
   badge_icon_ = image;
   native_app_window_->UpdateBadgeIcon();
@@ skipping 44 matching lines @@
                                 delegate_->PreferredIconSize(),
                                 extensions::IconsInfo::GetDefaultAppIcon(),
                                 this));
 
   // Triggers actual image loading with 1x resources. The 2x resource will
   // be handled by IconImage class when requested.
   app_icon_image_->image_skia().GetRepresentation(1.0f);
 }
 
 void AppWindow::OnSizeConstraintsChanged() {
-  SizeConstraints size_constraints(native_app_window_->GetMinimumSize(),
-                                   native_app_window_->GetMaximumSize());
+  SizeConstraints size_constraints(native_app_window_->GetContentMinimumSize(),
+                                   native_app_window_->GetContentMaximumSize());
   gfx::Rect bounds = GetClientBounds();
   gfx::Size constrained_size = size_constraints.ClampSize(bounds.size());
   if (bounds.size() != constrained_size) {
     bounds.set_size(constrained_size);
+    bounds.Inset(-native_app_window_->GetFrameInsets());
     native_app_window_->SetBounds(bounds);
   }
   OnNativeWindowChanged();
 }
 
 void AppWindow::SetNativeWindowFullscreen() {
   native_app_window_->SetFullscreen(fullscreen_types_);
 
   if (cached_always_on_top_)
     UpdateNativeAlwaysOnTop();
@@ skipping 163 matching lines @@
 void AppWindow::SaveWindowPosition() {
   if (window_key_.empty())
     return;
   if (!native_app_window_)
     return;
 
   AppWindowGeometryCache* cache =
       AppWindowGeometryCache::Get(browser_context());
 
   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, screen_bounds, window_state);
 }
 
 void AppWindow::AdjustBoundsToBeVisibleOnScreen(
     const gfx::Rect& cached_bounds,
     const gfx::Rect& cached_screen_bounds,
@@ skipping 17 matching lines @@
         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())));
   }
 }
 
-AppWindow::CreateParams AppWindow::LoadDefaultsAndConstrain(CreateParams params)
+AppWindow::CreateParams AppWindow::LoadDefaults(CreateParams params)
     const {
-  if (params.bounds.width() == 0)
-    params.bounds.set_width(kDefaultWidth);
-  if (params.bounds.height() == 0)
-    params.bounds.set_height(kDefaultHeight);
+  // Ensure width and height are specified.
+  if (params.content_spec.bounds.width() == 0 &&
+      params.window_spec.bounds.width() == 0) {
+    params.content_spec.bounds.set_width(kDefaultWidth);
+  }
+  if (params.content_spec.bounds.height() == 0 &&
+      params.window_spec.bounds.height() == 0) {
+    params.content_spec.bounds.set_height(kDefaultHeight);
+  }
 
   // If left and top are left undefined, the native app window will center
   // the window on the main screen in a platform-defined manner.
 
   // Load cached state if it exists.
   if (!params.window_key.empty()) {
     AppWindowGeometryCache* cache =
         AppWindowGeometryCache::Get(browser_context());
 
     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)) {
+
       // App window has cached screen bounds, make sure it fits on screen in
       // case the screen resolution changed.
       gfx::Screen* screen = gfx::Screen::GetNativeScreen();
       gfx::Display display = screen->GetDisplayMatching(cached_bounds);
       gfx::Rect current_screen_bounds = display.work_area();
+      SizeConstraints constraints(params.GetWindowMinimumSize(gfx::Insets()),
+                                  params.GetWindowMaximumSize(gfx::Insets()));
       AdjustBoundsToBeVisibleOnScreen(cached_bounds,
                                       cached_screen_bounds,
                                       current_screen_bounds,
-                                      params.minimum_size,
-                                      &params.bounds);
+                                      constraints.GetMinimumSize(),
+                                      &params.window_spec.bounds);
       params.state = cached_state;
+
+      // Since we are restoring a cached state, reset the content bounds spec to
+      // ensure it is not used.
+      params.content_spec.ResetBounds();
     }
   }
 
-  SizeConstraints size_constraints(params.minimum_size, params.maximum_size);
-  params.bounds.set_size(size_constraints.ClampSize(params.bounds.size()));
-  params.minimum_size = size_constraints.GetMinimumSize();
-  params.maximum_size = size_constraints.GetMaximumSize();
-
   return params;
 }
 
 // static
 SkRegion* AppWindow::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;
 }
 
 }  // namespace apps