Makes SetFocus() notify callback correctly on failure

components/mus/ws/focus_controller.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/focus_controller.h"
 
 #include "base/macros.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "components/mus/ws/focus_controller_delegate.h"
 #include "components/mus/ws/focus_controller_observer.h"
@@ skipping 53 matching lines @@
       focused_window_(nullptr),
       active_window_(nullptr),
       activation_reason_(ActivationChangeReason::UNKNONW) {
   DCHECK(delegate_);
   DCHECK(root_);
 }
 
 FocusController::~FocusController() {
 }
 
-void FocusController::SetFocusedWindow(ServerWindow* window) {
+bool FocusController::SetFocusedWindow(ServerWindow* window) {
   if (GetFocusedWindow() == window)
-    return;
+    return true;
 
-  SetFocusedWindowImpl(FocusControllerChangeSource::EXPLICIT, window);
+  return SetFocusedWindowImpl(FocusControllerChangeSource::EXPLICIT, window);
 }
 
 ServerWindow* FocusController::GetFocusedWindow() {
   return focused_window_;
 }
 
 void FocusController::ActivateNextWindow() {
   WindowTreeIterator iter(root_);
   ServerWindow* activate = active_window_;
   while (true) {
@@ skipping 111 matching lines @@
 
 ServerWindow* FocusController::GetActivatableAncestorOf(
     ServerWindow* window) const {
   for (ServerWindow* w = window; w; w = w->parent()) {
     if (CanBeActivated(w))
       return w;
   }
   return nullptr;
 }
 
-void FocusController::SetFocusedWindowImpl(
+bool FocusController::SetFocusedWindowImpl(
     FocusControllerChangeSource change_source,
     ServerWindow* window) {
   if (window && !CanBeFocused(window))
-    return;
+    return false;
+
   ServerWindow* old_focused = GetFocusedWindow();
 
   DCHECK(!window || window->IsDrawn());
 
   // Activate the closest activatable ancestor window.
   // TODO(sad): The window to activate doesn't necessarily have to be a direct
   // ancestor (e.g. could be a transient parent).
   SetActiveWindow(GetActivatableAncestorOf(window),
                   ActivationChangeReason::FOCUS);
 
   FOR_EACH_OBSERVER(FocusControllerObserver, observers_,
                     OnFocusChanged(change_source, old_focused, window));
 
   focused_window_ = window;
   // We can currently use only a single ServerWindowDrawnTracker since focused
   // window is expected to be a direct descendant of the active window.
   if (focused_window_ && active_window_) {
     DCHECK(active_window_->Contains(focused_window_));
   }
   ServerWindow* track_window = focused_window_;
   if (!track_window)
     track_window = active_window_;
   if (track_window)
     drawn_tracker_.reset(new ServerWindowDrawnTracker(track_window, this));
   else
     drawn_tracker_.reset();
+  return true;
 }
 
 void FocusController::OnDrawnStateWillChange(ServerWindow* ancestor,
                                              ServerWindow* window,
                                              bool is_drawn) {
   DCHECK(!is_drawn);
   DCHECK_NE(ancestor, window);
   DCHECK(root_->Contains(window));
   drawn_tracker_.reset();
 
@@ skipping 49 matching lines @@
 }
 
 void FocusController::OnDrawnStateChanged(ServerWindow* ancestor,
                                           ServerWindow* window,
                                           bool is_drawn) {
   // DCHECK(false);  TODO(sadrul):
 }
 
 }  // namespace ws
 }  // namespace mus