Linux: App windows with frame: chrome and no color are now native.

apps/ui/views/app_window_frame_view.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/ui/views/app_window_frame_view.h"
 
-#include "apps/ui/native_app_window.h"
 #include "base/strings/utf_string_conversions.h"
 #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 "third_party/skia/include/core/SkRegion.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"
 #include "ui/views/widget/widget_delegate.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #endif
 
 namespace {
 // Height of the chrome-style caption, in pixels.
 const int kCaptionHeight = 25;
 }  // namespace
 
 namespace apps {
 
 const char AppWindowFrameView::kViewClassName[] =
     "browser/ui/views/extensions/AppWindowFrameView";
 
-AppWindowFrameView::AppWindowFrameView(NativeAppWindow* window)
-    : window_(window),
-      widget_(NULL),
+AppWindowFrameView::AppWindowFrameView()
+    : widget_(NULL),
+      draggable_region_(NULL),
       close_button_(NULL),
       maximize_button_(NULL),
       restore_button_(NULL),
       minimize_button_(NULL),
       resize_inside_bounds_size_(0),
       resize_outside_bounds_size_(0),
       resize_area_corner_size_(0) {}
 
 AppWindowFrameView::~AppWindowFrameView() {}
 
 void AppWindowFrameView::Init(views::Widget* widget,
+                              bool draw_frame,
                               const SkColor& frame_color,
+                              const SkRegion* draggable_region,
                               int resize_inside_bounds_size,
                               int resize_outside_bounds_size,
                               int resize_outside_scale_for_touch,
                               int resize_area_corner_size) {
   widget_ = widget;
+  draw_frame_ = draw_frame;
   frame_color_ = frame_color;
+  draggable_region_ = draggable_region;
   resize_inside_bounds_size_ = resize_inside_bounds_size;
   resize_outside_bounds_size_ = resize_outside_bounds_size;
   resize_area_corner_size_ = resize_area_corner_size;
 
-  if (!window_->IsFrameless()) {
+  if (draw_frame) {
     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,
@@ skipping 42 matching lines @@
         rb.GetNativeImageNamed(IDR_APP_WINDOW_MINIMIZE_P).ToImageSkia());
     minimize_button_->SetAccessibleName(
         l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MINIMIZE));
     AddChildView(minimize_button_);
   }
 }
 
 // views::NonClientFrameView implementation.
 
 gfx::Rect AppWindowFrameView::GetBoundsForClientView() const {
-  if (window_->IsFrameless() || widget_->IsFullscreen())
+  if (!draw_frame_ || widget_->IsFullscreen())
     return bounds();
   return gfx::Rect(
       0, kCaptionHeight, width(), std::max(0, height() - kCaptionHeight));
 }
 
 gfx::Rect AppWindowFrameView::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
-  if (window_->IsFrameless()) {
+  if (!draw_frame_) {
     gfx::Rect window_bounds = client_bounds;
     // Enforce minimum size (1, 1) in case that client_bounds is passed with
     // empty size. This could occur when the frameless window is being
     // initialized.
     if (window_bounds.IsEmpty()) {
       window_bounds.set_width(1);
       window_bounds.set_height(1);
     }
     return window_bounds;
   }
@@ skipping 35 matching lines @@
                                                resize_border,
                                                resize_border,
                                                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_->IsFrameless()) {
-    SkRegion* draggable_region = window_->GetDraggableRegion();
-    if (draggable_region && draggable_region->contains(point.x(), point.y()))
+  if (!draw_frame_) {

[Matt Giuca, 2014/03/27 06:39:38]

This part is a bit weird. On Linux, a native window will enter this code path
and create draggable regions. Is the intention that even if an app window
requests draggable regions, they are ignored if we have a window frame?

In that case, we will need another Boolean in here, frameless, which will add
extra confusion. (!draw_frame && !frameless means don't draw a frame, but there
is a frame, so don't do draggable regions.)

Since it's a minor concern, leaving it for now. I'm going to have to deal with
draggable regions on Linux anyway (I just discovered they are broken), so I'll
look into this in more detail in a follow-up CL.

[benwells, 2014/03/27 08:53:45]

Yes, only frameless windows should have draggable regions. I think it would be
cleaner here to just have if (draggable_region_) and only set it if the window
is frameless.

Turns out this will always be the case anyway, see
https://code.google.com/p/chromium/codesearch#chromium/src/apps/ui/views/nati....

[Matt Giuca, 2014/03/27 09:16:27]

Done.

Note: I did not "only set it if the window is frameless". I was going to change
the call to Init to say "IsFrameless() ? GetDraggableRegion() : NULL", but then
I realised since we've already got code that says "if not frameless prevent
setting draggable region", it would be bad to have a second check. (Keeping a
single point where that policy decision is made, in case we ever want to change
it.)

+    if (draggable_region_ && draggable_region_->contains(point.x(), point.y()))
       return HTCAPTION;
   }
 
   int client_component = widget_->client_view()->NonClientHitTest(point);
   if (client_component != HTNOWHERE)
     return client_component;
 
   // Then see if the point is within any of the window controls.
   if (close_button_ && close_button_->visible() &&
       close_button_->GetMirroredBounds().Contains(point)) {
@@ skipping 23 matching lines @@
 
 gfx::Size AppWindowFrameView::GetPreferredSize() {
   gfx::Size pref = widget_->client_view()->GetPreferredSize();
   gfx::Rect bounds(0, 0, pref.width(), pref.height());
   return widget_->non_client_view()
       ->GetWindowBoundsForClientBounds(bounds)
       .size();
 }
 
 void AppWindowFrameView::Layout() {
-  if (window_->IsFrameless())
+  if (!draw_frame_)
     return;
   gfx::Size close_size = close_button_->GetPreferredSize();
   const int kButtonOffsetY = 0;
   const int kButtonSpacing = 1;
   const int kRightMargin = 3;
 
   close_button_->SetBounds(width() - kRightMargin - close_size.width(),
                            kButtonOffsetY,
                            close_size.width(),
                            close_size.height());
@@ skipping 26 matching lines @@
   gfx::Size minimize_size = minimize_button_->GetPreferredSize();
   minimize_button_->SetState(views::CustomButton::STATE_NORMAL);
   minimize_button_->SetBounds(
       maximize_button_->x() - kButtonSpacing - minimize_size.width(),
       kButtonOffsetY,
       minimize_size.width(),
       minimize_size.height());
 }
 
 void AppWindowFrameView::OnPaint(gfx::Canvas* canvas) {
-  if (window_->IsFrameless())
+  if (!draw_frame_)
     return;
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (ShouldPaintAsActive()) {
     close_button_->SetImage(
         views::CustomButton::STATE_NORMAL,
         rb.GetNativeImageNamed(IDR_APP_WINDOW_CLOSE).ToImageSkia());
   } else {
     close_button_->SetImage(
         views::CustomButton::STATE_NORMAL,
@@ skipping 11 matching lines @@
   path.lineTo(width(), kCaptionHeight);
   path.lineTo(0, kCaptionHeight);
   path.close();
   canvas->DrawPath(path, paint);
 }
 
 const char* AppWindowFrameView::GetClassName() const { return kViewClassName; }
 
 gfx::Size AppWindowFrameView::GetMinimumSize() {
   gfx::Size min_size = widget_->client_view()->GetMinimumSize();
-  if (window_->IsFrameless())
+  if (!draw_frame_)
     return min_size;
 
   // Ensure we can display the top of the caption area.
   gfx::Rect client_bounds = GetBoundsForClientView();
   min_size.Enlarge(0, client_bounds.y());
   // Ensure we have enough space for the window icon and buttons.  We allow
   // the title string to collapse to zero width.
   int closeButtonOffsetX = (kCaptionHeight - close_button_->height()) / 2;
   int header_width = close_button_->width() + closeButtonOffsetX * 2;
   if (header_width > min_size.width())
@@ skipping 11 matching lines @@
   if (max_size.height())
     max_size.Enlarge(0, height() - client_size.height());
 
   return max_size;
 }
 
 // views::ButtonListener implementation.
 
 void AppWindowFrameView::ButtonPressed(views::Button* sender,
                                        const ui::Event& event) {
-  DCHECK(!window_->IsFrameless());
+  DCHECK(draw_frame_);
   if (sender == close_button_)
     widget_->Close();
   else if (sender == maximize_button_)
     widget_->Maximize();
   else if (sender == restore_button_)
     widget_->Restore();
   else if (sender == minimize_button_)
     widget_->Minimize();
 }
 
 }  // namespace apps