Move remaining mus::WindowObserver lifecycle callbacks from PlatformWindowMus to NativeWidgetMus::M…

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 53 matching lines @@
 }  // namespace
 
 PlatformWindowMus::PlatformWindowMus(ui::PlatformWindowDelegate* delegate,
                                      shell::Connector* connector,
                                      mus::Window* mus_window)
     : delegate_(delegate),
       mus_window_(mus_window),
       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.
 #if defined(OS_WIN) || defined(OS_ANDROID)
   gfx::AcceleratedWidget accelerated_widget =
       reinterpret_cast<gfx::AcceleratedWidget>(accelerated_widget_count++);
 #else
   gfx::AcceleratedWidget accelerated_widget =
       static_cast<gfx::AcceleratedWidget>(accelerated_widget_count++);
 #endif
   delegate_->OnAcceleratedWidgetAvailable(
       accelerated_widget, mus_window_->viewport_metrics().device_pixel_ratio);
 
   bitmap_uploader_.reset(new bitmap_uploader::BitmapUploader(mus_window_));
   bitmap_uploader_->Init(connector);
   prop_.reset(new ui::ViewProp(
       accelerated_widget, bitmap_uploader::kBitmapUploaderForAcceleratedWidget,
       bitmap_uploader_.get()));
 }
 
 PlatformWindowMus::~PlatformWindowMus() {
   if (!mus_window_)
     return;
-  mus_window_->RemoveObserver(this);
   mus_window_->set_input_event_handler(nullptr);
-  if (!mus_window_destroyed_)
-    mus_window_->Destroy();
 }
 
 void PlatformWindowMus::Show() {}
 
 void PlatformWindowMus::Hide() {}
 
 void PlatformWindowMus::Close() {
   NOTIMPLEMENTED();
 }
 
@@ skipping 34 matching lines @@
 }
 
 void PlatformWindowMus::ConfineCursorToBounds(const gfx::Rect& bounds) {
   NOTIMPLEMENTED();
 }
 
 ui::PlatformImeController* PlatformWindowMus::GetPlatformImeController() {
   return nullptr;
 }
 
-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::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