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()) {
-    gfx::Rect window_bounds = client_bounds;
+  gfx::Rect window_bounds = client_bounds;
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  // Get the difference between the widget's client area bounds and window
+  // bounds, and grow |window_bounds| by that amount.
+  gfx::Insets native_frame_insets =
+      widget_->GetClientAreaBoundsInScreen().InsetsFrom(
+          widget_->GetWindowBoundsInScreen());
+  window_bounds.Inset(native_frame_insets);
+#endif
+  if (!draw_frame_) {
     // 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;
   }
 
   int closeButtonOffsetX = (kCaptionHeight - close_button_->height()) / 2;
   int header_width = close_button_->width() + closeButtonOffsetX * 2;
-  return gfx::Rect(client_bounds.x(),
-                   client_bounds.y() - kCaptionHeight,
-                   std::max(header_width, client_bounds.width()),
-                   client_bounds.height() + kCaptionHeight);
+  return gfx::Rect(window_bounds.x(),
+                   window_bounds.y() - kCaptionHeight,
+                   std::max(header_width, window_bounds.width()),
+                   window_bounds.height() + kCaptionHeight);
 }
 
 int AppWindowFrameView::NonClientHitTest(const gfx::Point& point) {
   if (widget_->IsFullscreen())
     return HTCLIENT;
 
   gfx::Rect expanded_bounds = bounds();
   if (resize_outside_bounds_size_) {
     expanded_bounds.Inset(gfx::Insets(-resize_outside_bounds_size_,
                                       -resize_outside_bounds_size_,
@@ skipping 18 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()))
-      return HTCAPTION;
-  }
+  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)) {
     return HTCLOSE;
   }
@@ skipping 21 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