Move ShowState-related code from PlatformWindowMus to NativeWidgetMus

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/macros.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
 #include "components/mus/public/interfaces/cursor.mojom.h"
+#include "components/mus/public/interfaces/window_manager.mojom.h"
+#include "components/mus/public/interfaces/window_manager_constants.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/aura/client/default_capture_client.h"
 #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/gfx/canvas.h"
@@ skipping 266 matching lines @@
   if (app_icon.isNull())
     return SkBitmap();
   return app_icon.GetRepresentation(1.f).sk_bitmap();
 }
 
 }  // namespace
 
 class NativeWidgetMus::MusWindowObserver : public mus::WindowObserver {
  public:
   explicit MusWindowObserver(NativeWidgetMus* native_widget_mus)
-      : native_widget_mus_(native_widget_mus) {
+      : native_widget_mus_(native_widget_mus),
+        show_state_(mus::mojom::ShowState::DEFAULT) {
     mus_window()->AddObserver(this);
   }
 
   ~MusWindowObserver() override {
     mus_window()->RemoveObserver(this);
   }
 
   // mus::WindowObserver:
   void OnWindowVisibilityChanging(mus::Window* window) override {
     native_widget_mus_->OnMusWindowVisibilityChanging(window);
   }
   void OnWindowVisibilityChanged(mus::Window* window) override {
     native_widget_mus_->OnMusWindowVisibilityChanged(window);
   }
   void OnWindowBoundsChanged(mus::Window* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override {
     platform_window_delegate()->OnBoundsChanged(new_bounds);
   }
+  void OnWindowSharedPropertyChanged(
+      mus::Window* window,
+      const std::string& name,
+      const std::vector<uint8_t>* old_data,
+      const std::vector<uint8_t>* new_data) override {
+    if (name != mus::mojom::WindowManager::kShowState_Property)
+      return;
+    mus::mojom::ShowState show_state =
+        static_cast<mus::mojom::ShowState>(window->GetSharedProperty<int32_t>(
+            mus::mojom::WindowManager::kShowState_Property));
+    if (show_state == show_state_)
+      return;
+    show_state_ = show_state;
+    ui::PlatformWindowState state = ui::PLATFORM_WINDOW_STATE_UNKNOWN;
+    switch (show_state_) {
+      case mus::mojom::ShowState::MINIMIZED:
+        state = ui::PLATFORM_WINDOW_STATE_MINIMIZED;
+        break;
+      case mus::mojom::ShowState::MAXIMIZED:
+        state = ui::PLATFORM_WINDOW_STATE_MAXIMIZED;
+        break;
+      case mus::mojom::ShowState::DEFAULT:
+      case mus::mojom::ShowState::INACTIVE:
+      case mus::mojom::ShowState::NORMAL:
+      case mus::mojom::ShowState::DOCKED:
+        // TODO(sky): support docked.
+        state = ui::PLATFORM_WINDOW_STATE_NORMAL;
+        break;
+      case mus::mojom::ShowState::FULLSCREEN:
+        state = ui::PLATFORM_WINDOW_STATE_FULLSCREEN;
+        break;
+    }
+    platform_window_delegate()->OnWindowStateChanged(state);
+  }
 
  private:
   mus::Window* mus_window() { return native_widget_mus_->window(); }
   WindowTreeHostMus* window_tree_host() {
     return native_widget_mus_->window_tree_host();
   }
   ui::PlatformWindowDelegate* platform_window_delegate() {
     return static_cast<ui::PlatformWindowDelegate*>(

[sadrul, 2016/05/11 05:35:33]

btw: this static_cast<> isn't necessary, is it?

[Mark Dittmer, 2016/05/11 13:37:37]

It is not. I was thinking downcast when it's an upcast.

         native_widget_mus_->window_tree_host());
   }
 
   NativeWidgetMus* native_widget_mus_;
+  mus::mojom::ShowState show_state_;
 
   DISALLOW_COPY_AND_ASSIGN(MusWindowObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMus, public:
 
 NativeWidgetMus::NativeWidgetMus(internal::NativeWidgetDelegate* delegate,
                                  shell::Connector* connector,
                                  mus::Window* window,
@@ skipping 506 matching lines @@
 bool NativeWidgetMus::IsAlwaysOnTop() const {
   // NOTIMPLEMENTED();
   return false;
 }
 
 void NativeWidgetMus::SetVisibleOnAllWorkspaces(bool always_visible) {
   // NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::Maximize() {
-  if (window_tree_host_)
-    window_tree_host_->platform_window()->Maximize();
+  if (!(window_ && window_tree_host_))
+    return;
+
+  window_tree_host_->platform_window()->Maximize();

[sadrul, 2016/05/11 05:12:47]

Remove these calls to platform_window()

[Mark Dittmer, 2016/05/11 13:37:37]

Done.

+  SetShowState(mus::mojom::ShowState::MAXIMIZED);
 }
 
 void NativeWidgetMus::Minimize() {
-  if (window_tree_host_)
-    window_tree_host_->platform_window()->Minimize();
+  if (!(window_ && window_tree_host_))
+    return;
+
+  window_tree_host_->platform_window()->Minimize();
+  SetShowState(mus::mojom::ShowState::MINIMIZED);
 }
 
 bool NativeWidgetMus::IsMaximized() const {
   return window_tree_host_ &&
          window_tree_host_->show_state() == ui::PLATFORM_WINDOW_STATE_MAXIMIZED;

[sadrul, 2016/05/11 05:12:47]

We should look at |mus_window_obserer_->show_state()|, instead of depending on
WTH here (ditto for IsMinimized())

[Mark Dittmer, 2016/05/11 13:37:37]

Done.

 }
 
 bool NativeWidgetMus::IsMinimized() const {
   return window_tree_host_ &&
          window_tree_host_->show_state() == ui::PLATFORM_WINDOW_STATE_MINIMIZED;
 }
 
 void NativeWidgetMus::Restore() {
-  if (window_tree_host_)
-    window_tree_host_->platform_window()->Restore();
+  if (!(window_ && window_tree_host_))
+    return;
+
+  window_tree_host_->platform_window()->Restore();
+  SetShowState(mus::mojom::ShowState::NORMAL);
 }
 
 void NativeWidgetMus::SetFullscreen(bool fullscreen) {
   if (!window_tree_host_ || IsFullscreen() == fullscreen)
     return;
   if (fullscreen) {
     show_state_before_fullscreen_ = window_tree_host_->show_state();
     window_tree_host_->platform_window()->ToggleFullscreen();
   } else {
     switch (show_state_before_fullscreen_) {
@@ skipping 198 matching lines @@
 }
 
 bool NativeWidgetMus::HasHitTestMask() const {
   return native_widget_delegate_->HasHitTestMask();
 }
 
 void NativeWidgetMus::GetHitTestMask(gfx::Path* mask) const {
   native_widget_delegate_->GetHitTestMask(mask);
 }
 
+void NativeWidgetMus::SetShowState(mus::mojom::ShowState show_state) {
+  window_->SetSharedProperty<int32_t>(
+      mus::mojom::WindowManager::kShowState_Property,
+      static_cast<int32_t>(show_state));
+}
+
 void NativeWidgetMus::OnKeyEvent(ui::KeyEvent* event) {
   if (event->is_char()) {
     // If a ui::InputMethod object is attached to the root window, character
     // events are handled inside the object and are not passed to this function.
     // If such object is not attached, character events might be sent (e.g. on
     // Windows). In this case, we just skip these.
     return;
   }
   // Renderer may send a key event back to us if the key event wasn't handled,
   // and the window may be invisible by that time.
@@ skipping 45 matching lines @@
     GetNativeWindow()->Show();
   } else {
     window_tree_host_->Hide();
     window_->SetVisible(false);
     GetNativeWindow()->Hide();
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(window->visible());
 }
 
 }  // namespace views