Converts focusmanager from delegate to observer

components/mus/ws/window_tree_host_impl.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 "components/mus/ws/window_tree_host_impl.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/display_manager.h"
@@ skipping 12 matching lines @@
     mojo::ApplicationImpl* app_impl,
     const scoped_refptr<GpuState>& gpu_state,
     const scoped_refptr<SurfacesState>& surfaces_state,
     mojom::WindowManagerPtr window_manager)
     : delegate_(nullptr),
       connection_manager_(connection_manager),
       client_(client.Pass()),
       event_dispatcher_(this),
       display_manager_(
           DisplayManager::Create(app_impl, gpu_state, surfaces_state)),
-      focus_controller_(new FocusController(this)),
+      focus_controller_(new FocusController),
       window_manager_(window_manager.Pass()) {
+  focus_controller_->AddObserver(this);
   display_manager_->Init(this);
   if (client_) {
     client_.set_connection_error_handler(base::Bind(
         &WindowTreeHostImpl::OnClientClosed, base::Unretained(this)));
   }
 }
 
 WindowTreeHostImpl::~WindowTreeHostImpl() {
+  DestroyFocusController();
   for (ServerWindow* window : windows_needing_frame_destruction_)
     window->RemoveObserver(this);
 }
 
 void WindowTreeHostImpl::Init(WindowTreeHostDelegate* delegate) {
   delegate_ = delegate;
   if (delegate_ && root_)
     delegate_->OnDisplayInitialized();
 }
 
@@ skipping 29 matching lines @@
 const mojom::ViewportMetrics& WindowTreeHostImpl::GetViewportMetrics() const {
   return display_manager_->GetViewportMetrics();
 }
 
 void WindowTreeHostImpl::SetFocusedWindow(ServerWindow* new_focused_window) {
   ServerWindow* old_focused_window = focus_controller_->GetFocusedWindow();
   if (old_focused_window == new_focused_window)
     return;
   DCHECK(root_window()->Contains(new_focused_window));
   focus_controller_->SetFocusedWindow(new_focused_window);
-  // TODO(beng): have the FocusController notify us via FocusControllerDelegate.
-  OnFocusChanged(old_focused_window, new_focused_window);
 }
 
 ServerWindow* WindowTreeHostImpl::GetFocusedWindow() {
   return focus_controller_->GetFocusedWindow();
 }
 
 void WindowTreeHostImpl::DestroyFocusController() {
+  if (!focus_controller_)
+    return;
+
+  focus_controller_->RemoveObserver(this);
   focus_controller_.reset();
 }
 
 void WindowTreeHostImpl::UpdateTextInputState(ServerWindow* window,
                                               const ui::TextInputState& state) {
   // Do not need to update text input for unfocused windows.
   if (!display_manager_ || focus_controller_->GetFocusedWindow() != window)
     return;
   display_manager_->UpdateTextInputState(state);
 }
@@ skipping 67 matching lines @@
 
 void WindowTreeHostImpl::OnCompositorFrameDrawn() {
   std::set<ServerWindow*> windows;
   windows.swap(windows_needing_frame_destruction_);
   for (ServerWindow* window : windows) {
     window->RemoveObserver(this);
     window->DestroySurfacesScheduledForDestruction();
   }
 }
 
-void WindowTreeHostImpl::OnFocusChanged(ServerWindow* old_focused_window,
-                                        ServerWindow* new_focused_window) {
+void WindowTreeHostImpl::OnFocusChanged(
+    FocusControllerChangeSource change_source,
+    ServerWindow* old_focused_window,
+    ServerWindow* new_focused_window) {
   // There are up to four connections that need to be notified:
   // . the connection containing |old_focused_window|.
   // . the connection with |old_focused_window| as its root.
   // . the connection containing |new_focused_window|.
   // . the connection with |new_focused_window| as its root.
   // Some of these connections may be the same. The following takes care to
   // notify each only once.
   WindowTreeImpl* owning_connection_old = nullptr;
   WindowTreeImpl* embedded_connection_old = nullptr;
 
@@ skipping 80 matching lines @@
                                            base::Bind(&base::DoNothing));
 }
 
 void WindowTreeHostImpl::OnWindowDestroyed(ServerWindow* window) {
   windows_needing_frame_destruction_.erase(window);
   window->RemoveObserver(this);
 }
 
 }  // namespace ws
 }  // namespace mus