Moves mash/wm into ash/mus

ash/mus/non_client_frame_controller.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 "mash/wm/non_client_frame_controller.h"
+#include "ash/mus/non_client_frame_controller.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "ash/mus/bridge/wm_window_mus.h"
+#include "ash/mus/frame/frame_border_hit_test_controller.h"
+#include "ash/mus/frame/move_event_handler.h"
+#include "ash/mus/frame/non_client_frame_view_mash.h"
+#include "ash/mus/property_util.h"
+#include "ash/mus/shadow.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_manager_delegate.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
-#include "mash/wm/bridge/wm_window_mus.h"
-#include "mash/wm/frame/frame_border_hit_test_controller.h"
-#include "mash/wm/frame/move_event_handler.h"
-#include "mash/wm/frame/non_client_frame_view_mash.h"
-#include "mash/wm/property_util.h"
-#include "mash/wm/shadow.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/views/mus/native_widget_mus.h"
 #include "ui/views/widget/widget.h"
 
-namespace mash {
-namespace wm {
+namespace ash {
+namespace mus {
 namespace {
 
 // LayoutManager associated with the window created by WindowTreeHost. Resizes
 // all children of the parent to match the bounds of the parent. Additionally
 // handles sizing of a Shadow.
 class ContentWindowLayoutManager : public aura::LayoutManager {
  public:
   ContentWindowLayoutManager(aura::Window* window, Shadow* shadow)
       : window_(window), shadow_(shadow) {
     OnWindowResized();
@@ skipping 34 matching lines @@
   aura::Window* window_;
   Shadow* shadow_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentWindowLayoutManager);
 };
 
 class WmNativeWidgetMus : public views::NativeWidgetMus {
  public:
   WmNativeWidgetMus(views::internal::NativeWidgetDelegate* delegate,
                     shell::Connector* connector,
-                    mus::Window* window,
-                    mus::WindowManagerClient* window_manager_client)
+                    ::mus::Window* window,
+                    ::mus::WindowManagerClient* window_manager_client)
       : NativeWidgetMus(delegate,
                         connector,
                         window,
-                        mus::mojom::SurfaceType::UNDERLAY),
+                        ::mus::mojom::SurfaceType::UNDERLAY),
         window_manager_client_(window_manager_client) {}
-  ~WmNativeWidgetMus() override {
-  }
+  ~WmNativeWidgetMus() override {}
 
   // NativeWidgetMus:
   views::NonClientFrameView* CreateNonClientFrameView() override {
     views::Widget* widget =
         static_cast<views::internal::NativeWidgetPrivate*>(this)->GetWidget();
     NonClientFrameViewMash* frame_view =
         new NonClientFrameViewMash(widget, window());
     move_event_handler_.reset(new MoveEventHandler(
         window(), window_manager_client_, GetNativeView()));
     return frame_view;
@@ skipping 29 matching lines @@
     // This pushes the client area to the WS. We don't want to do that as
     // the client area should come from the client, not us.
   }
 
  private:
   // The shadow, may be null.
   std::unique_ptr<Shadow> shadow_;
 
   std::unique_ptr<MoveEventHandler> move_event_handler_;
 
-  mus::WindowManagerClient* window_manager_client_;
+  ::mus::WindowManagerClient* window_manager_client_;
 
   DISALLOW_COPY_AND_ASSIGN(WmNativeWidgetMus);
 };
 
 class ClientViewMus : public views::ClientView {
  public:
   ClientViewMus(views::Widget* widget,
                 views::View* contents_view,
                 NonClientFrameController* frame_controller)
       : views::ClientView(widget, contents_view),
@@ skipping 13 matching lines @@
   NonClientFrameController* frame_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientViewMus);
 };
 
 }  // namespace
 
 // static
 void NonClientFrameController::Create(
     shell::Connector* connector,
-    mus::Window* parent,
-    mus::Window* window,
-    mus::WindowManagerClient* window_manager_client) {
+    ::mus::Window* parent,
+    ::mus::Window* window,
+    ::mus::WindowManagerClient* window_manager_client) {
   new NonClientFrameController(connector, parent, window,
                                window_manager_client);
 }
 
 // static
 gfx::Insets NonClientFrameController::GetPreferredClientAreaInsets() {
   return NonClientFrameViewMash::GetPreferredClientAreaInsets();
 }
 
 // static
 int NonClientFrameController::GetMaxTitleBarButtonWidth() {
   return NonClientFrameViewMash::GetMaxTitleBarButtonWidth();
 }
 
 NonClientFrameController::NonClientFrameController(
     shell::Connector* connector,
-    mus::Window* parent,
-    mus::Window* window,
-    mus::WindowManagerClient* window_manager_client)
+    ::mus::Window* parent,
+    ::mus::Window* window,
+    ::mus::WindowManagerClient* window_manager_client)
     : widget_(new views::Widget), window_(window) {
   WmWindowMus* wm_window = WmWindowMus::Get(window);
   wm_window->set_widget(widget_, WmWindowMus::WidgetCreationType::FOR_CLIENT);
   window_->AddObserver(this);
 
   // To simplify things this code creates a Widget. While a Widget is created
   // we need to ensure we don't inadvertently change random properties of the
   // underlying mus::Window. For example, showing the Widget shouldn't change
   // the bounds of the mus::Window in anyway.
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
@@ skipping 18 matching lines @@
       window, gfx::Vector2d(shadow_inset, shadow_inset), extended_hit_region);
 }
 
 NonClientFrameController::~NonClientFrameController() {
   if (window_)
     window_->RemoveObserver(this);
 }
 
 base::string16 NonClientFrameController::GetWindowTitle() const {
   if (!window_->HasSharedProperty(
-          mus::mojom::WindowManager::kWindowTitle_Property)) {
+          ::mus::mojom::WindowManager::kWindowTitle_Property)) {
     return base::string16();
   }
 
   base::string16 title = window_->GetSharedProperty<base::string16>(
-      mus::mojom::WindowManager::kWindowTitle_Property);
+      ::mus::mojom::WindowManager::kWindowTitle_Property);
 
   if (IsWindowJanky(window_))
     title += base::ASCIIToUTF16(" !! Not responding !!");
 
   return title;
 }
 
 views::View* NonClientFrameController::GetContentsView() {
   return this;
 }
 
 bool NonClientFrameController::CanResize() const {
   return window_ &&
-         (GetResizeBehavior(window_) & mus::mojom::kResizeBehaviorCanResize) !=
-             0;
+         (GetResizeBehavior(window_) &
+          ::mus::mojom::kResizeBehaviorCanResize) != 0;
 }
 
 bool NonClientFrameController::CanMaximize() const {
   return window_ &&
          (GetResizeBehavior(window_) &
-          mus::mojom::kResizeBehaviorCanMaximize) != 0;
+          ::mus::mojom::kResizeBehaviorCanMaximize) != 0;
 }
 
 bool NonClientFrameController::CanMinimize() const {
   return window_ &&
          (GetResizeBehavior(window_) &
-          mus::mojom::kResizeBehaviorCanMinimize) != 0;
+          ::mus::mojom::kResizeBehaviorCanMinimize) != 0;
 }
 
 bool NonClientFrameController::ShouldShowWindowTitle() const {
   // Only draw the title if the client hasn't declared any additional client
   // areas which might conflict with it.
   return window_ && window_->additional_client_areas().empty();
 }
 
 views::ClientView* NonClientFrameController::CreateClientView(
     views::Widget* widget) {
   return new ClientViewMus(widget, GetContentsView(), this);
 }
 
 void NonClientFrameController::OnWindowSharedPropertyChanged(
-    mus::Window* window,
+    ::mus::Window* window,
     const std::string& name,
     const std::vector<uint8_t>* old_data,
     const std::vector<uint8_t>* new_data) {
-  if (name == mus::mojom::WindowManager::kResizeBehavior_Property)
+  if (name == ::mus::mojom::WindowManager::kResizeBehavior_Property)
     widget_->OnSizeConstraintsChanged();
-  else if (name == mus::mojom::WindowManager::kWindowTitle_Property)
+  else if (name == ::mus::mojom::WindowManager::kWindowTitle_Property)
     widget_->UpdateWindowTitle();
 }
 
 void NonClientFrameController::OnWindowLocalPropertyChanged(
-    mus::Window* window,
+    ::mus::Window* window,
     const void* key,
     intptr_t old) {
   if (IsWindowJankyProperty(key)) {
     widget_->UpdateWindowTitle();
     widget_->non_client_view()->frame_view()->SchedulePaint();
   }
 }
 
-void NonClientFrameController::OnWindowDestroyed(mus::Window* window) {
+void NonClientFrameController::OnWindowDestroyed(::mus::Window* window) {
   window_->RemoveObserver(this);
   window_ = nullptr;
 }
 
-}  // namespace wm
-}  // namespace mash
+}  // namespace mus
+}  // namespace ash