chromeos: fix focus for mushrome

ui/aura/mus/focus_synchronizer.cc

 // Copyright 2016 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/aura/mus/focus_synchronizer.h"
 
 #include "base/auto_reset.h"
 #include "services/ui/public/interfaces/window_tree.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/focus_client.h"
@@ skipping 24 matching lines @@
     return;
 
   DCHECK(!setting_focus_);
   base::AutoReset<bool> focus_reset(&setting_focus_, true);
   base::AutoReset<WindowMus*> window_setting_focus_to_reset(
       &window_setting_focus_to_, window);
   if (window) {
     Window* root = window->GetWindow()->GetRootWindow();
     // The client should provide a focus client for all roots.
     DCHECK(client::GetFocusClient(root));
-    if (active_focus_client_root_ != root)
+    if (!is_singleton_focus_client_ && active_focus_client_root_ != root)

[msw, 2017/04/26 23:01:08]

If |is_singleton_focus_client_| is true, should this
[D]CHECK_EQ(active_focus_client_, client::GetFocusClient(root))?

[sky, 2017/04/26 23:30:28]

Done.

       SetActiveFocusClient(client::GetFocusClient(root), root);
     window->GetWindow()->Focus();
   } else if (active_focus_client_) {
     active_focus_client_->FocusWindow(nullptr);
   }
 }
 
 void FocusSynchronizer::OnFocusedWindowDestroyed() {
   focused_window_ = nullptr;
 }
 
+void FocusSynchronizer::SetSingletonFocusClient(
+    client::FocusClient* focus_client) {
+  SetActiveFocusClient(focus_client, nullptr);
+  if (focus_client)
+    is_singleton_focus_client_ = true;
+}
+
 void FocusSynchronizer::SetActiveFocusClient(client::FocusClient* focus_client,
                                              Window* focus_client_root) {
-  if (focus_client_root == active_focus_client_root_) {
-    DCHECK_EQ(focus_client, active_focus_client_);
+  if (focus_client == active_focus_client_ &&
+      focus_client_root == active_focus_client_root_) {
     return;
   }
 
+  is_singleton_focus_client_ = false;
+
   if (active_focus_client_root_)
     active_focus_client_root_->RemoveObserver(this);
   active_focus_client_root_ = focus_client_root;
   if (active_focus_client_root_)
     active_focus_client_root_->AddObserver(this);
 
+  if (focus_client == active_focus_client_)
+    return;
+
   OnActiveFocusClientChanged(focus_client, focus_client_root);
   for (FocusSynchronizerObserver& observer : observers_)
     observer.OnActiveFocusClientChanged(focus_client, focus_client_root);
 }
 
 void FocusSynchronizer::SetActiveFocusClientInternal(
     client::FocusClient* focus_client) {
   if (focus_client == active_focus_client_)
     return;
 
@@ skipping 31 matching lines @@
                                         Window* lost_focus) {
   WindowMus* gained_focus_mus = WindowMus::Get(gained_focus);
   if (setting_focus_ && gained_focus_mus == window_setting_focus_to_) {
     focused_window_ = gained_focus_mus;
     return;
   }
   SetFocusedWindow(gained_focus_mus);
 }
 
 void FocusSynchronizer::OnWindowDestroying(Window* window) {
+  DCHECK(!is_singleton_focus_client_);
   SetActiveFocusClient(nullptr, nullptr);
 }
 
 void FocusSynchronizer::OnWindowPropertyChanged(Window* window,
                                                 const void* key,
                                                 intptr_t old) {
+  DCHECK(!is_singleton_focus_client_);
   if (key != client::kFocusClientKey)
     return;
 
   // Assume if the focus client changes the window is being destroyed.
   SetActiveFocusClient(nullptr, nullptr);
 }
 
 }  // namespace aura