Move ShowState-related code from PlatformWindowMus to NativeWidgetMus

ui/views/mus/platform_window_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/platform_window_mus.h"
 
 #include "base/message_loop/message_loop.h"
 #include "build/build_config.h"
 #include "components/bitmap_uploader/bitmap_uploader.h"
 #include "components/mus/public/cpp/property_type_converters.h"
@@ skipping 50 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(EventAckHandler);
 };
 
 }  // namespace
 
 PlatformWindowMus::PlatformWindowMus(ui::PlatformWindowDelegate* delegate,
                                      shell::Connector* connector,
                                      mus::Window* mus_window)
     : delegate_(delegate),
       mus_window_(mus_window),
-      show_state_(mus::mojom::ShowState::DEFAULT),
       last_cursor_(mus::mojom::Cursor::CURSOR_NULL),
       mus_window_destroyed_(false) {
   DCHECK(delegate_);
   DCHECK(mus_window_);
   mus_window_->AddObserver(this);
   mus_window_->set_input_event_handler(this);
 
   // We need accelerated widget numbers to be different for each
   // window and fit in the smallest sizeof(AcceleratedWidget) uint32_t
   // has this property.
@@ skipping 57 matching lines @@
 }
 
 void PlatformWindowMus::ReleaseCapture() {
   mus_window_->ReleaseCapture();
 }
 
 void PlatformWindowMus::ToggleFullscreen() {
   NOTIMPLEMENTED();
 }
 
-void PlatformWindowMus::Maximize() {
-  SetShowState(mus::mojom::ShowState::MAXIMIZED);
-}
+void PlatformWindowMus::Maximize() {}
 
-void PlatformWindowMus::Minimize() {
-  SetShowState(mus::mojom::ShowState::MINIMIZED);
-}
+void PlatformWindowMus::Minimize() {}
 
-void PlatformWindowMus::Restore() {
-  SetShowState(mus::mojom::ShowState::NORMAL);
-}
+void PlatformWindowMus::Restore() {}
 
 void PlatformWindowMus::SetCursor(ui::PlatformCursor cursor) {
   NOTIMPLEMENTED();
 }
 
 void PlatformWindowMus::MoveCursorTo(const gfx::Point& location) {
   NOTIMPLEMENTED();
 }
 
 void PlatformWindowMus::ConfineCursorToBounds(const gfx::Rect& bounds) {
   NOTIMPLEMENTED();
 }
 
 ui::PlatformImeController* PlatformWindowMus::GetPlatformImeController() {
   return nullptr;
 }
 
-void PlatformWindowMus::SetShowState(mus::mojom::ShowState show_state) {
-  mus_window_->SetSharedProperty<int32_t>(
-      mus::mojom::WindowManager::kShowState_Property,
-      static_cast<int32_t>(show_state));
-}
-
 void PlatformWindowMus::OnWindowDestroyed(mus::Window* window) {
   DCHECK_EQ(mus_window_, window);
   mus_window_destroyed_ = true;
 #ifndef NDEBUG
   weak_factory_.reset(new base::WeakPtrFactory<PlatformWindowMus>(this));
   base::WeakPtr<PlatformWindowMus> weak_ptr = weak_factory_->GetWeakPtr();
 #endif
   delegate_->OnClosed();
   // |this| has been destroyed at this point.
 #ifndef NDEBUG
   DCHECK(!weak_ptr);
 #endif
 }
 
 void PlatformWindowMus::OnWindowFocusChanged(mus::Window* gained_focus,
                                              mus::Window* lost_focus) {
   if (gained_focus == mus_window_)
     delegate_->OnActivationChanged(true);
   else if (lost_focus == mus_window_)
     delegate_->OnActivationChanged(false);
 }
 
 void PlatformWindowMus::OnWindowPredefinedCursorChanged(
     mus::Window* window,
     mus::mojom::Cursor cursor) {
   DCHECK_EQ(window, mus_window_);
   last_cursor_ = cursor;
 }
 
-void PlatformWindowMus::OnWindowSharedPropertyChanged(
-    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::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;
-  }
-  delegate_->OnWindowStateChanged(state);
-}
-
 void PlatformWindowMus::OnRequestClose(mus::Window* window) {
   delegate_->OnCloseRequest();
 }
 
 void PlatformWindowMus::OnWindowInputEvent(
     mus::Window* view,
     const ui::Event& event_in,
     std::unique_ptr<base::Callback<void(EventResult)>>* ack_callback) {
   // Take ownership of the callback, indicating that we will handle it.
   EventAckHandler ack_handler(std::move(*ack_callback));
 
   std::unique_ptr<ui::Event> event = ui::Event::Clone(event_in);
   delegate_->DispatchEvent(event.get());
   // NOTE: |this| may be deleted.
 
   ack_handler.set_handled(event->handled());
   // |ack_handler| acks the event on destruction if necessary.
 }
 
 }  // namespace views