apps: Move chrome's ShellWindowFrameView into apps/

apps/ui/views/shell_window_frame_view.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/views/extensions/shell_window_frame_view.h"
+#include "apps/ui/views/shell_window_frame_view.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/views/apps/native_app_window_views.h"

[stevenjb, 2013/10/12 00:16:42]

Is the intention to check this in with the chrome dependency, or to fix that
first? It looks like this could take a apps::NativeAppWindow* instead of a
NativeAppWindowViews* with just a couple of minor additions to the
NativeAppWindowViews interface, which seems worth doing to avoid the dependency,
even if we just end up removing them later when we move NativeAppWindowViews to
ui/. (Although less dependency on ui/ isn't bad anyway).

 #include "extensions/common/draggable_region.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_strings.h"  // Accessibility names
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/path.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 
-#if defined(OS_WIN) && !defined(USE_AURA)
-#include "chrome/browser/shell_integration.h"
-#include "chrome/browser/web_applications/web_app.h"
-#include "ui/base/win/shell.h"
-#endif
-
-#if defined(USE_ASH)
-#include "ash/ash_constants.h"
-#include "chrome/browser/ui/ash/ash_util.h"
+#if defined(USE_AURA)
 #include "ui/aura/env.h"
-#endif
-
-#if defined(USE_AURA)
 #include "ui/aura/window.h"
 #endif
 
 namespace {
-const int kResizeInsideBoundsSize = 5;
-const int kResizeAreaCornerSize = 16;
-
 // Height of the chrome-style caption, in pixels.
 const int kCaptionHeight = 25;
 }  // namespace
 
+namespace apps {
 
 const char ShellWindowFrameView::kViewClassName[] =
     "browser/ui/views/extensions/ShellWindowFrameView";
 
 ShellWindowFrameView::ShellWindowFrameView(NativeAppWindowViews* window)
     : window_(window),
       frame_(NULL),
-      close_button_(NULL) {
+      close_button_(NULL),
+      maximize_button_(NULL),
+      restore_button_(NULL),
+      minimize_button_(NULL),
+      resize_inside_bounds_size_(0),
+      resize_area_corner_size_(0) {
 }
 
 ShellWindowFrameView::~ShellWindowFrameView() {
 }
 
-void ShellWindowFrameView::Init(views::Widget* frame) {
+void ShellWindowFrameView::Init(views::Widget* frame,
+                                int resize_inside_bounds_size,
+                                int resize_outside_bounds_size,
+                                int resize_outside_scale_for_touch,
+                                int resize_area_corner_size) {
   frame_ = frame;
+  resize_inside_bounds_size_ = resize_inside_bounds_size;
+  resize_area_corner_size_ = resize_area_corner_size;
 
   if (!window_->frameless()) {
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     close_button_ = new views::ImageButton(this);
     close_button_->SetImage(views::CustomButton::STATE_NORMAL,
         rb.GetNativeImageNamed(IDR_APP_WINDOW_CLOSE).ToImageSkia());
     close_button_->SetImage(views::CustomButton::STATE_HOVERED,
         rb.GetNativeImageNamed(IDR_APP_WINDOW_CLOSE_H).ToImageSkia());
     close_button_->SetImage(views::CustomButton::STATE_PRESSED,
         rb.GetNativeImageNamed(IDR_APP_WINDOW_CLOSE_P).ToImageSkia());
@@ skipping 28 matching lines @@
     minimize_button_->SetImage(views::CustomButton::STATE_HOVERED,
         rb.GetNativeImageNamed(IDR_APP_WINDOW_MINIMIZE_H).ToImageSkia());
     minimize_button_->SetImage(views::CustomButton::STATE_PRESSED,
         rb.GetNativeImageNamed(IDR_APP_WINDOW_MINIMIZE_P).ToImageSkia());
     minimize_button_->SetAccessibleName(
         l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MINIMIZE));
     AddChildView(minimize_button_);
   }
 
 #if defined(USE_AURA)
-  int resize_inside_bounds_size = kResizeInsideBoundsSize;
   aura::Window* window = frame->GetNativeWindow();
-#if defined(USE_ASH)
-  if (chrome::IsNativeWindowInAsh(window)) {
-    gfx::Insets mouse_insets = gfx::Insets(-ash::kResizeOutsideBoundsSize,
-                                           -ash::kResizeOutsideBoundsSize,
-                                           -ash::kResizeOutsideBoundsSize,
-                                           -ash::kResizeOutsideBoundsSize);
-    gfx::Insets touch_insets = mouse_insets.Scale(
-        ash::kResizeOutsideBoundsScaleForTouch);
+  // Some Aura implementations (Ash) allow resize handles outside the window.
+  if (resize_outside_bounds_size > 0) {
+    gfx::Insets mouse_insets = gfx::Insets(-resize_outside_bounds_size,
+                                           -resize_outside_bounds_size,
+                                           -resize_outside_bounds_size,
+                                           -resize_outside_bounds_size);
+    gfx::Insets touch_insets =
+        mouse_insets.Scale(resize_outside_scale_for_touch);
     // Ensure we get resize cursors for a few pixels outside our bounds.
     window->SetHitTestBoundsOverrideOuter(mouse_insets, touch_insets);
-
-    // If the window is in ash, the inside area used for resizing will be
-    // smaller due to the fact that outside area is also used for resizing.
-    resize_inside_bounds_size = ash::kResizeInsideBoundsSize;
   }
-#endif
   // Ensure we get resize cursors just inside our bounds as well.
   // TODO(jeremya): do we need to update these when in fullscreen/maximized?
   window->set_hit_test_bounds_override_inner(
-      gfx::Insets(resize_inside_bounds_size, resize_inside_bounds_size,
-                  resize_inside_bounds_size, resize_inside_bounds_size));
+      gfx::Insets(resize_inside_bounds_size_, resize_inside_bounds_size_,
+                  resize_inside_bounds_size_, resize_inside_bounds_size_));
 #endif
 }
 
 // views::NonClientFrameView implementation.
 
 gfx::Rect ShellWindowFrameView::GetBoundsForClientView() const {
   if (window_->frameless() || frame_->IsFullscreen())
     return bounds();
   return gfx::Rect(0, kCaptionHeight, width(),
       std::max(0, height() - kCaptionHeight));
@@ skipping 19 matching lines @@
   return gfx::Rect(client_bounds.x(),
                    std::max(0, client_bounds.y() - kCaptionHeight),
                    std::max(header_width, client_bounds.width()),
                    client_bounds.height() + kCaptionHeight);
 }
 
 int ShellWindowFrameView::NonClientHitTest(const gfx::Point& point) {
   if (frame_->IsFullscreen())
     return HTCLIENT;
 
-  int resize_inside_bounds_size = kResizeInsideBoundsSize;
-  int resize_area_corner_size = kResizeAreaCornerSize;
-
-#if defined(USE_ASH)
+  gfx::Rect expanded_bounds = bounds();
+#if defined(USE_AURA)
+  // Some Aura implementations (Ash) optionally allow resize handles just
+  // outside the window bounds.
   aura::Window* window = frame_->GetNativeWindow();
-  if (chrome::IsNativeWindowInAsh(window)) {
-    gfx::Rect expanded_bounds = bounds();
-    int outside_bounds = ash::kResizeOutsideBoundsSize;
-    if (aura::Env::GetInstance()->is_touch_down())
-      outside_bounds *= ash::kResizeOutsideBoundsScaleForTouch;
-    expanded_bounds.Inset(-outside_bounds, -outside_bounds);
-    if (!expanded_bounds.Contains(point))

[James Cook, 2013/10/11 23:05:06]

This was subtly wrong - the code should have been doing a bounds check even in
the non-Ash case.  See c/b/ui/views/frame/opaque_browser_frame_view.cc for
example.

-      return HTNOWHERE;
-
-    resize_inside_bounds_size = ash::kResizeInsideBoundsSize;
-    resize_area_corner_size = ash::kResizeAreaCornerSize;
-  }
+  if (aura::Env::GetInstance()->is_touch_down())
+    expanded_bounds.Inset(window->hit_test_bounds_override_outer_touch());

[James Cook, 2013/10/11 23:05:06]

These bounds override insets are 0 in the normal (non-Ash) case, so it's safe to
always apply them.

+  else
+    expanded_bounds.Inset(window->hit_test_bounds_override_outer_mouse());
 #endif
+  // Points outside the (possibly expanded) bounds can be discarded.
+  if (!expanded_bounds.Contains(point))
+    return HTNOWHERE;
 
   // Check the frame first, as we allow a small area overlapping the contents
   // to be used for resize handles.
   bool can_ever_resize = frame_->widget_delegate() ?
       frame_->widget_delegate()->CanResize() :
       false;
   // Don't allow overlapping resize handles when the window is maximized or
   // fullscreen, as it can't be resized in those states.
   int resize_border =
       (frame_->IsMaximized() || frame_->IsFullscreen()) ? 0 :
-      resize_inside_bounds_size;
+      resize_inside_bounds_size_;
   int frame_component = GetHTComponentForFrame(point,
                                                resize_border,
                                                resize_border,
-                                               resize_area_corner_size,
-                                               resize_area_corner_size,
+                                               resize_area_corner_size_,
+                                               resize_area_corner_size_,
                                                can_ever_resize);
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   // Check for possible draggable region in the client area for the frameless
   // window.
   if (window_->frameless() &&
       window_->draggable_region() &&
       window_->draggable_region()->contains(point.x(), point.y()))
     return HTCAPTION;
@@ skipping 144 matching lines @@
   DCHECK(!window_->frameless());
   if (sender == close_button_)
     frame_->Close();
   else if (sender == maximize_button_)
     frame_->Maximize();
   else if (sender == restore_button_)
     frame_->Restore();
   else if (sender == minimize_button_)
     frame_->Minimize();
 }
+
+}  // namespace apps