Move apps::SizeConstraints to extensions

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 <string>
 #include <vector>
 
 #include "apps/app_delegate.h"
 #include "apps/app_web_contents_helper.h"
 #include "apps/app_window_geometry_cache.h"
 #include "apps/app_window_registry.h"
-#include "apps/size_constraints.h"
 #include "apps/ui/apps_client.h"
 #include "apps/ui/native_app_window.h"
 #include "apps/ui/web_contents_sizer.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"
 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/extensions/suggest_permission_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #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/content_switches.h"
 #include "content/public/common/media_stream_request.h"
+#include "extensions/browser/app_window/size_constraints.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/draggable_region.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "extensions/common/permissions/permissions_data.h"
@@ skipping 17 matching lines @@
 namespace apps {
 
 namespace {
 
 const int kDefaultWidth = 512;
 const int kDefaultHeight = 384;
 
 void SetConstraintProperty(const std::string& name,
                            int value,
                            base::DictionaryValue* bounds_properties) {
-  if (value != SizeConstraints::kUnboundedSize)
+  if (value != extensions::SizeConstraints::kUnboundedSize)
     bounds_properties->SetInteger(name, value);
   else
     bounds_properties->Set(name, base::Value::CreateNullValue());
 }
 
 void SetBoundsProperties(const gfx::Rect& bounds,
                          const gfx::Size& min_size,
                          const gfx::Size& max_size,
                          const std::string& bounds_name,
                          base::DictionaryValue* window_properties) {
@@ skipping 94 matching lines @@
   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(
+  extensions::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(
@@ skipping 439 matching lines @@
 void AppWindow::OSFullscreen() {
   SetFullscreen(FULLSCREEN_TYPE_OS, true);
 }
 
 void AppWindow::ForcedFullscreen() {
   SetFullscreen(FULLSCREEN_TYPE_FORCED, true);
 }
 
 void AppWindow::SetContentSizeConstraints(const gfx::Size& min_size,
                                           const gfx::Size& max_size) {
-  SizeConstraints constraints(min_size, max_size);
+  extensions::SizeConstraints constraints(min_size, max_size);
   native_app_window_->SetContentSizeConstraints(constraints.GetMinimumSize(),
                                                 constraints.GetMaximumSize());
 
   gfx::Rect bounds = GetClientBounds();
   gfx::Size constrained_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);
   }
@@ skipping 88 matching lines @@
   gfx::Size content_min_size = native_app_window_->GetContentMinimumSize();
   gfx::Size content_max_size = native_app_window_->GetContentMaximumSize();
   SetBoundsProperties(content_bounds,
                       content_min_size,
                       content_max_size,
                       "innerBounds",
                       properties);
 
   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);
+  gfx::Size frame_min_size = extensions::SizeConstraints::AddFrameToConstraints(
+      content_min_size, frame_insets);
+  gfx::Size frame_max_size = extensions::SizeConstraints::AddFrameToConstraints(
+      content_max_size, frame_insets);
   SetBoundsProperties(frame_bounds,
                       frame_min_size,
                       frame_max_size,
                       "outerBounds",
                       properties);
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
@@ skipping 290 matching lines @@
     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()));
+      extensions::SizeConstraints constraints(
+          params.GetWindowMinimumSize(gfx::Insets()),
+          params.GetWindowMaximumSize(gfx::Insets()));
       AdjustBoundsToBeVisibleOnScreen(cached_bounds,
                                       cached_screen_bounds,
                                       current_screen_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();
@@ skipping 16 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