Makes windowmanager draw non-client area

ui/views/mus/native_widget_mus.cc

 // Copyright 2015 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 "ui/views/mus/native_widget_mus.h"
 
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
+#include "ui/base/hit_test.h"
+#include "ui/compositor/clip_transform_recorder.h"
+#include "ui/compositor/paint_recorder.h"
+#include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme_aura.h"
+#include "ui/views/mus/window_manager_client_area_insets.h"
 #include "ui/views/mus/window_tree_host_mus.h"
 #include "ui/views/widget/widget_delegate.h"
+#include "ui/views/window/custom_frame_view.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/capture_controller.h"
 #include "ui/wm/core/focus_controller.h"
 
 namespace views {
 namespace {
 
+WindowManagerClientAreaInsets* window_manager_client_area_insets = nullptr;
+
 // TODO: figure out what this should be.
 class FocusRulesImpl : public wm::BaseFocusRules {
  public:
   FocusRulesImpl() {}
   ~FocusRulesImpl() override {}
 
   bool SupportsChildActivation(aura::Window* window) const override {
     return true;
   }
 
@@ skipping 21 matching lines @@
                       const gfx::Rect& requested_bounds) override {
     SetChildBoundsDirect(child, requested_bounds);
   }
 
   aura::Window* outer_;
   aura::Window* inner_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentWindowLayoutManager);
 };
 
+// As the window manager renderers the non-client decorations this class does
+// very little but honor the client area insets from the window manager.
+class ClientSideNonClientFrameView : public NonClientFrameView {
+ public:
+  explicit ClientSideNonClientFrameView(views::Widget* widget)
+      : widget_(widget) {}
+  ~ClientSideNonClientFrameView() override {}
+
+ private:
+  // Returns the default values of client area insets from the window manager.
+  static gfx::Insets GetDefaultWindowManagerInsets(bool is_maximized) {
+    if (!window_manager_client_area_insets)
+      return gfx::Insets();
+    return is_maximized ? window_manager_client_area_insets->maximized_insets
+                        : window_manager_client_area_insets->normal_insets;
+  }
+
+  // NonClientFrameView:
+  gfx::Rect GetBoundsForClientView() const override {
+    gfx::Rect result(GetLocalBounds());
+    result.Inset(GetDefaultWindowManagerInsets(widget_->IsMaximized()));
+    return result;
+  }
+  gfx::Rect GetWindowBoundsForClientBounds(
+      const gfx::Rect& client_bounds) const override {
+    const gfx::Insets insets(
+        GetDefaultWindowManagerInsets(widget_->IsMaximized()));
+    return gfx::Rect(client_bounds.x() - insets.left(),
+                     client_bounds.y() - insets.top(),
+                     client_bounds.width() + insets.width(),
+                     client_bounds.height() + insets.height());
+  }
+  int NonClientHitTest(const gfx::Point& point) override { return HTNOWHERE; }
+  void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask) override {
+    // The window manager provides the shape; do nothing.
+  }
+  void ResetWindowControls() override {
+    // TODO(sky): push to wm?
+  }
+  void UpdateWindowIcon() override {
+    // NOTIMPLEMENTED();
+  }
+  void UpdateWindowTitle() override {
+    // NOTIMPLEMENTED();
+  }
+  void SizeConstraintsChanged() override {
+    // NOTIMPLEMENTED();
+  }
+
+  views::Widget* widget_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClientSideNonClientFrameView);
+};
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMus, public:
 
 NativeWidgetMus::NativeWidgetMus(internal::NativeWidgetDelegate* delegate,
                                  mojo::Shell* shell,
                                  mus::Window* window,
                                  mus::mojom::SurfaceType surface_type)
     : window_(window),
       shell_(shell),
       native_widget_delegate_(delegate),
       surface_type_(surface_type),
       show_state_before_fullscreen_(mus::mojom::SHOW_STATE_RESTORED),
       content_(new aura::Window(this)) {}
 NativeWidgetMus::~NativeWidgetMus() {}
 
+// static
+void NativeWidgetMus::SetWindowManagerClientAreaInsets(
+    const WindowManagerClientAreaInsets& insets) {
+  delete window_manager_client_area_insets;
+  // This is called early on, so we don't bother trying to relayout existing
+  // NativeWidgetMus. When we support restarting the WM we'll need to do that.
+  window_manager_client_area_insets = new WindowManagerClientAreaInsets(insets);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMus, private:
 
 void NativeWidgetMus::UpdateClientAreaInWindowManager() {
   NonClientView* non_client_view =
       native_widget_delegate_->AsWidget()->non_client_view();
   if (!non_client_view || !non_client_view->client_view())
     return;
 
-  window_->SetClientArea(non_client_view->client_view()->bounds());
+  const gfx::Rect client_area_rect(non_client_view->client_view()->bounds());
+  window_->SetClientArea(gfx::Insets(
+      client_area_rect.y(), client_area_rect.x(),
+      non_client_view->bounds().height() - client_area_rect.bottom(),
+      non_client_view->bounds().width() - client_area_rect.right()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMus, internal::NativeWidgetPrivate implementation:
 
+NonClientFrameView* NativeWidgetMus::CreateNonClientFrameView() {
+  return new ClientSideNonClientFrameView(GetWidget());
+}
+
 void NativeWidgetMus::InitNativeWidget(const Widget::InitParams& params) {
   window_tree_host_.reset(
       new WindowTreeHostMus(shell_, window_, surface_type_));
   window_tree_host_->InitHost();
 
   focus_client_.reset(new wm::FocusController(new FocusRulesImpl));
 
   aura::client::SetFocusClient(window_tree_host_->window(),
                                focus_client_.get());
   aura::client::SetActivationClient(window_tree_host_->window(),
                                     focus_client_.get());
   window_tree_host_->window()->AddPreTargetHandler(focus_client_.get());
   window_tree_host_->window()->SetLayoutManager(
       new ContentWindowLayoutManager(window_tree_host_->window(), content_));
   capture_client_.reset(
       new aura::client::DefaultCaptureClient(window_tree_host_->window()));
 
   content_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   content_->Init(ui::LAYER_TEXTURED);
   content_->SetTransparent(true);
   content_->SetFillsBoundsCompletely(false);
 
   window_tree_host_->window()->AddChild(content_);
   // TODO(beng): much else, see [Desktop]NativeWidgetAura.
 }
 
-NonClientFrameView* NativeWidgetMus::CreateNonClientFrameView() {
-  // NOTIMPLEMENTED();
-  return nullptr;
-}
-
 bool NativeWidgetMus::ShouldUseNativeFrame() const {
   // NOTIMPLEMENTED();
   return false;
 }
 
 bool NativeWidgetMus::ShouldWindowContentsBeTransparent() const {
   // NOTIMPLEMENTED();
   return true;
 }
 
@@ skipping 242 matching lines @@
 void NativeWidgetMus::RunShellDrag(
     View* view,
     const ui::OSExchangeData& data,
     const gfx::Point& location,
     int operation,
     ui::DragDropTypes::DragEventSource source) {
   // NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::SchedulePaintInRect(const gfx::Rect& rect) {
-  // NOTIMPLEMENTED();
+  content_->SchedulePaintInRect(rect);
 }
 
 void NativeWidgetMus::SetCursor(gfx::NativeCursor cursor) {
   // NOTIMPLEMENTED();
 }
 
 bool NativeWidgetMus::IsMouseEventsEnabled() const {
   // NOTIMPLEMENTED();
   return true;
 }
@@ skipping 175 matching lines @@
   } else {
     native_widget_delegate_->OnScrollEvent(event);
   }
 }
 
 void NativeWidgetMus::OnGestureEvent(ui::GestureEvent* event) {
   native_widget_delegate_->OnGestureEvent(event);
 }
 
 }  // namespace views