Finish eliminating PlatformWindowMus

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 "base/callback.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 10 matching lines @@
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/mojo/geometry_type_converters.h"
+#include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/path.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/platform_window/platform_window_delegate.h"
-#include "ui/views/mus/platform_window_mus.h"
 #include "ui/views/mus/surface_context_factory.h"
 #include "ui/views/mus/window_manager_constants_converters.h"
 #include "ui/views/mus/window_manager_frame_values.h"
 #include "ui/views/mus/window_tree_host_mus.h"
 #include "ui/views/widget/native_widget_aura.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/cursor_manager.h"
@@ skipping 361 matching lines @@
       case mus::mojom::ShowState::FULLSCREEN:
         state = ui::PLATFORM_WINDOW_STATE_FULLSCREEN;
         break;
     }
     platform_window_delegate()->OnWindowStateChanged(state);
   }
   void OnWindowDestroyed(mus::Window* window) override {
     DCHECK_EQ(mus_window(), window);
     platform_window_delegate()->OnClosed();
   }
+  void OnWindowBoundsChanging(mus::Window* window,
+                              const gfx::Rect& old_bounds,
+                              const gfx::Rect& new_bounds) override {
+    DCHECK_EQ(window, mus_window());
+    window_tree_host()->SetBounds(new_bounds);
+  }
   void OnWindowFocusChanged(mus::Window* gained_focus,
                             mus::Window* lost_focus) override {
     if (gained_focus == mus_window())
       platform_window_delegate()->OnActivationChanged(true);
     else if (lost_focus == mus_window())
       platform_window_delegate()->OnActivationChanged(false);
   }
   void OnRequestClose(mus::Window* window) override {
     platform_window_delegate()->OnCloseRequest();
   }
@@ skipping 206 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMus, internal::NativeWidgetPrivate implementation:
 
 NonClientFrameView* NativeWidgetMus::CreateNonClientFrameView() {
   return new ClientSideNonClientFrameView(GetWidget());
 }
 
 void NativeWidgetMus::InitNativeWidget(const Widget::InitParams& params) {
   NativeWidgetAura::RegisterNativeWidgetForWindow(this, content_);
+  aura::Window* hosted_window = window_tree_host_->window();
 
   ownership_ = params.ownership;
   window_->SetCanFocus(params.activatable ==
                        Widget::InitParams::ACTIVATABLE_YES);
 
   window_tree_host_->AddObserver(this);
   window_tree_host_->InitHost();
-  window_tree_host_->window()->SetProperty(kMusWindow, window_);
+  hosted_window->SetProperty(kMusWindow, window_);
 
   focus_client_.reset(
-      new wm::FocusController(new FocusRulesImpl(window_tree_host_->window())));
+      new wm::FocusController(new FocusRulesImpl(hosted_window)));
 
-  aura::client::SetFocusClient(window_tree_host_->window(),
-                               focus_client_.get());
-  aura::client::SetActivationClient(window_tree_host_->window(),
-                                    focus_client_.get());
+  aura::client::SetFocusClient(hosted_window, focus_client_.get());
+  aura::client::SetActivationClient(hosted_window, focus_client_.get());
   screen_position_client_.reset(new ScreenPositionClientMus(window_));
-  aura::client::SetScreenPositionClient(window_tree_host_->window(),
+  aura::client::SetScreenPositionClient(hosted_window,
                                         screen_position_client_.get());
 
   // TODO(erg): Remove this check when mash/wm/frame/move_event_handler.cc's
   // direct usage of mus::Window::SetPredefinedCursor() is switched to a
   // private method on WindowManagerClient.
   if (surface_type_ == mus::mojom::SurfaceType::DEFAULT) {
     cursor_manager_.reset(new wm::CursorManager(
         base::WrapUnique(new NativeCursorManagerMus(window_))));
-    aura::client::SetCursorClient(window_tree_host_->window(),
-                                  cursor_manager_.get());
+    aura::client::SetCursorClient(hosted_window, cursor_manager_.get());
   }
 
   window_tree_client_.reset(
-      new NativeWidgetMusWindowTreeClient(window_tree_host_->window()));
-  window_tree_host_->window()->AddPreTargetHandler(focus_client_.get());
-  window_tree_host_->window()->SetLayoutManager(
-      new ContentWindowLayoutManager(window_tree_host_->window(), content_));
-  capture_client_.reset(
-      new MusCaptureClient(window_tree_host_->window(), content_, window_));
+      new NativeWidgetMusWindowTreeClient(hosted_window));
+  hosted_window->AddPreTargetHandler(focus_client_.get());
+  hosted_window->SetLayoutManager(
+      new ContentWindowLayoutManager(hosted_window, content_));
+  capture_client_.reset(new MusCaptureClient(hosted_window, content_, window_));
 
   content_->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   content_->Init(ui::LAYER_TEXTURED);
   if (window_->visible())
     content_->Show();
   content_->SetTransparent(true);
   content_->SetFillsBoundsCompletely(false);
-  window_tree_host_->window()->AddChild(content_);
+  hosted_window->AddChild(content_);
 
   // Set-up transiency if appropriate.
   if (params.parent && !params.child) {
     aura::Window* parent_root = params.parent->GetRootWindow();
     mus::Window* parent_mus = parent_root->GetProperty(kMusWindow);
     if (parent_mus)
       parent_mus->AddTransientWindow(window_);
   }
 
   if (params.parent_mus)
@@ skipping 186 matching lines @@
 void NativeWidgetMus::SetBounds(const gfx::Rect& bounds) {
   if (!(window_ && window_tree_host_))
     return;
 
   gfx::Size size(bounds.size());
   const gfx::Size min_size = GetMinimumSize();
   const gfx::Size max_size = GetMaximumSize();
   if (!max_size.IsEmpty())
     size.SetToMin(max_size);
   size.SetToMax(min_size);
-  window_tree_host_->SetBounds(gfx::Rect(bounds.origin(), size));
   window_->SetBounds(gfx::Rect(bounds.origin(), size));
 }
 
 void NativeWidgetMus::SetSize(const gfx::Size& size) {
   if (!window_tree_host_)
     return;
 
   gfx::Rect bounds = window_tree_host_->GetBounds();
   SetBounds(gfx::Rect(bounds.origin(), size));
 }
@@ skipping 119 matching lines @@
 bool NativeWidgetMus::IsMinimized() const {
   return mus_window_observer_ &&
       mus_window_observer_->show_state() == mus::mojom::ShowState::MINIMIZED;
 }
 
 void NativeWidgetMus::Restore() {
   SetShowState(mus::mojom::ShowState::NORMAL);
 }
 
 void NativeWidgetMus::SetFullscreen(bool fullscreen) {
-  if (!window_tree_host_ || IsFullscreen() == fullscreen)
+  if (IsFullscreen() == fullscreen)
     return;
   if (fullscreen) {
     show_state_before_fullscreen_ = mus_window_observer_->show_state();
-    window_tree_host_->platform_window()->ToggleFullscreen();
+    // TODO(markdittmer): Fullscreen not implemented in mus::Window.
   } else {
     switch (show_state_before_fullscreen_) {
       case mus::mojom::ShowState::MAXIMIZED:
         Maximize();
         break;
       case mus::mojom::ShowState::MINIMIZED:
         Minimize();
         break;
       case mus::mojom::ShowState::DEFAULT:
       case mus::mojom::ShowState::NORMAL:
@@ skipping 311 matching lines @@
 
   gfx::Path mask_path;
   native_widget_delegate_->GetHitTestMask(&mask_path);
   // TODO(jamescook): Use the full path for the mask.
   gfx::Rect mask_rect =
       gfx::ToEnclosingRect(gfx::SkRectToRectF(mask_path.getBounds()));
   window_->SetHitTestMask(mask_rect);
 }
 
 }  // namespace views