chromeos: fix focus for mushrome

ui/aura/mus/window_tree_client.cc

 // Copyright 2014 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/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 508 matching lines @@
   tree_ptr_->GetCursorLocationMemory(
       base::Bind(&WindowTreeClient::OnReceivedCursorLocationMemory,
                  weak_factory_.GetWeakPtr()));
 
   tree_ptr_.set_connection_error_handler(base::Bind(
       &WindowTreeClient::OnConnectionLost, weak_factory_.GetWeakPtr()));
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(
         MakeRequest(&window_manager_internal_client_));
+    window_manager_client_ = window_manager_internal_client_.get();
   }
 }
 
 void WindowTreeClient::WindowTreeConnectionEstablished(
     ui::mojom::WindowTree* window_tree) {
   tree_ = window_tree;
 
   drag_drop_controller_ = base::MakeUnique<DragDropControllerMus>(this, tree_);
   capture_synchronizer_ = base::MakeUnique<CaptureSynchronizer>(this, tree_);
   focus_synchronizer_ = base::MakeUnique<FocusSynchronizer>(this, tree_);
@@ skipping 188 matching lines @@
     // As |window| is a root, changes to its bounds are ignored (it's assumed
     // bounds changes are routed through OnWindowTreeHostBoundsWillChange()).
     // But the display is created with an initial bounds, and we need to push
     // that to the server.
     DCHECK(kRootWindowBoundsChangesAreIgnored);
     ScheduleInFlightBoundsChange(
         window, gfx::Rect(),
         gfx::Rect(
             display_init_params->viewport_metrics.bounds_in_pixels.size()));
 
-    // Tests may not config |window_manager_internal_client_|.
-    if (window_manager_internal_client_) {
-      window_manager_internal_client_->SetDisplayRoot(
+    if (window_manager_client_) {
+      window_manager_client_->SetDisplayRoot(
           display, display_init_params->viewport_metrics.Clone(),
           display_init_params->is_primary_display, window->server_id(),
           base::Bind(&WindowTreeClient::OnSetDisplayRootDone,
                      base::Unretained(this), window->server_id()));
     }
   }
 }
 
 void WindowTreeClient::OnWindowMusDestroyed(WindowMus* window, Origin origin) {
   if (focus_synchronizer_->focused_window() == window)
@@ skipping 135 matching lines @@
 
   const uint32_t change_id =
       ScheduleInFlightChange(base::MakeUnique<InFlightPropertyChange>(
           window, transport_name, std::move(data_mus->transport_value)));
   tree_->SetWindowProperty(change_id, window->server_id(), transport_name,
                            transport_value_mojo);
 }
 
 void WindowTreeClient::OnWmMoveLoopCompleted(uint32_t change_id,
                                              bool completed) {
-  if (window_manager_internal_client_)
-    window_manager_internal_client_->WmResponse(change_id, completed);
+  if (window_manager_client_)
+    window_manager_client_->WmResponse(change_id, completed);
 
   if (change_id == current_wm_move_loop_change_) {
     current_wm_move_loop_change_ = 0;
     current_wm_move_loop_window_id_ = 0;
   }
 }
 
 std::set<Window*> WindowTreeClient::GetRoots() {
   std::set<Window*> roots;
   for (WindowMus* window : roots_)
@@ skipping 72 matching lines @@
     const cc::FrameSinkId& frame_sink_id,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
   DCHECK(!tree_ptr_);
   tree_ptr_ = std::move(tree);
 
   is_from_embed_ = true;
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(
         MakeRequest(&window_manager_internal_client_));
+    window_manager_client_ = window_manager_internal_client_.get();
   }
 
   OnEmbedImpl(tree_ptr_.get(), client_id, std::move(root_data), display_id,
               focused_window_id, drawn, frame_sink_id, local_surface_id);
 }
 
 void WindowTreeClient::OnEmbeddedAppDisconnected(Id window_id) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (window)
     window->NotifyEmbeddedAppDisconnected();
@@ skipping 529 matching lines @@
   if (window) {
     float device_scale_factor = ScaleFactorForDisplay(window->GetWindow());
     DCHECK(window_manager_delegate_);
     gfx::Rect transit_bounds_in_dip =
         gfx::ConvertRectToDIP(device_scale_factor, transit_bounds_in_pixels);
     window_manager_delegate_->OnWmSetBounds(window->GetWindow(),
                                             transit_bounds_in_dip);
   } else {
     DVLOG(1) << "Unknown window passed to WmSetBounds().";
   }
-  if (window_manager_internal_client_)
-    window_manager_internal_client_->WmSetBoundsResponse(change_id);
+  if (window_manager_client_)
+    window_manager_client_->WmSetBoundsResponse(change_id);
 }
 
 void WindowTreeClient::WmSetProperty(
     uint32_t change_id,
     Id window_id,
     const std::string& name,
     const base::Optional<std::vector<uint8_t>>& transit_data) {
   WindowMus* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
     std::unique_ptr<std::vector<uint8_t>> data;
     if (transit_data.has_value())
       data.reset(new std::vector<uint8_t>(transit_data.value()));
 
     result = window_manager_delegate_->OnWmSetProperty(window->GetWindow(),
                                                        name, &data);
     if (result) {
       delegate_->GetPropertyConverter()->SetPropertyFromTransportValue(
           window->GetWindow(), name, data.get());
     }
   }
-  if (window_manager_internal_client_)
-    window_manager_internal_client_->WmResponse(change_id, result);
+  if (window_manager_client_)
+    window_manager_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClient::WmSetModalType(Id window_id, ui::ModalType type) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (window)
     window_manager_delegate_->OnWmSetModalType(window->GetWindow(), type);
 }
 
 void WindowTreeClient::WmSetCanFocus(Id window_id, bool can_focus) {
   WindowMus* window = GetWindowByServerId(window_id);
@@ skipping 12 matching lines @@
   auto type_iter =
       properties.find(ui::mojom::WindowManager::kWindowType_InitProperty);
   if (type_iter != properties.end()) {
     // TODO: validation! http://crbug.com/654924.
     window_type = static_cast<ui::mojom::WindowType>(
         mojo::ConvertTo<int32_t>(type_iter->second));
   }
   Window* window = window_manager_delegate_->OnWmCreateTopLevelWindow(
       window_type, &properties);
   if (!window) {
-    window_manager_internal_client_->OnWmCreatedTopLevelWindow(
-        change_id, kInvalidServerId);
+    window_manager_client_->OnWmCreatedTopLevelWindow(change_id,
+                                                      kInvalidServerId);
     return;
   }
   embedded_windows_[requesting_client_id].insert(window);
-  if (window_manager_internal_client_) {
-    window_manager_internal_client_->OnWmCreatedTopLevelWindow(
+  if (window_manager_client_) {
+    window_manager_client_->OnWmCreatedTopLevelWindow(
         change_id, WindowMus::Get(window)->server_id());
   }
 }
 
 void WindowTreeClient::WmClientJankinessChanged(ClientSpecificId client_id,
                                                 bool janky) {
   if (window_manager_delegate_) {
     auto it = embedded_windows_.find(client_id);
     CHECK(it != embedded_windows_.end());
     window_manager_delegate_->OnWmClientJankinessChanged(
@@ skipping 81 matching lines @@
 }
 
 void WindowTreeClient::WmStackAbove(uint32_t wm_change_id, Id above_id,
                                     Id below_id) {
   if (!window_manager_delegate_)
     return;
 
   WindowMus* below_mus = GetWindowByServerId(below_id);
   if (!below_mus) {
     DVLOG(1) << "Attempt to stack at top invalid window " << below_id;
-    if (window_manager_internal_client_)
-      window_manager_internal_client_->WmResponse(wm_change_id, false);
+    if (window_manager_client_)
+      window_manager_client_->WmResponse(wm_change_id, false);
     return;
   }
 
   WindowMus* above_mus = GetWindowByServerId(above_id);
   if (!above_mus) {
     DVLOG(1) << "Attempt to stack at top invalid window " << above_id;
-    if (window_manager_internal_client_)
-      window_manager_internal_client_->WmResponse(wm_change_id, false);
+    if (window_manager_client_)
+      window_manager_client_->WmResponse(wm_change_id, false);
     return;
   }
 
   Window* above = above_mus->GetWindow();
   Window* below = below_mus->GetWindow();
 
   if (above->parent() != below->parent()) {
     DVLOG(1) << "Windows do not share the same parent";
-    if (window_manager_internal_client_)
-      window_manager_internal_client_->WmResponse(wm_change_id, false);
+    if (window_manager_client_)
+      window_manager_client_->WmResponse(wm_change_id, false);
     return;
   }
 
   above->parent()->StackChildAbove(above, below);
 
-  if (window_manager_internal_client_)
-    window_manager_internal_client_->WmResponse(wm_change_id, true);
+  if (window_manager_client_)
+    window_manager_client_->WmResponse(wm_change_id, true);
 }
 
 void WindowTreeClient::WmStackAtTop(uint32_t wm_change_id, uint32_t window_id) {
   if (!window_manager_delegate_)
     return;
 
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window) {
     DVLOG(1) << "Attempt to stack at top invalid window " << window_id;
-    if (window_manager_internal_client_)
-      window_manager_internal_client_->WmResponse(wm_change_id, false);
+    if (window_manager_client_)
+      window_manager_client_->WmResponse(wm_change_id, false);
     return;
   }
 
   Window* parent = window->GetWindow()->parent();
   parent->StackChildAtTop(window->GetWindow());
 
-  if (window_manager_internal_client_)
-    window_manager_internal_client_->WmResponse(wm_change_id, true);
+  if (window_manager_client_)
+    window_manager_client_->WmResponse(wm_change_id, true);
 }
 
 void WindowTreeClient::OnAccelerator(uint32_t ack_id,
                                      uint32_t accelerator_id,
                                      std::unique_ptr<ui::Event> event) {
   DCHECK(event);
   std::unordered_map<std::string, std::vector<uint8_t>> properties;
   const ui::mojom::EventResult result = window_manager_delegate_->OnAccelerator(
       accelerator_id, *event.get(), &properties);
-  if (ack_id && window_manager_internal_client_)
-    window_manager_internal_client_->OnAcceleratorAck(ack_id, result,
-                                                      properties);
+  if (ack_id && window_manager_client_)
+    window_manager_client_->OnAcceleratorAck(ack_id, result, properties);
 }
 
 void WindowTreeClient::SetFrameDecorationValues(
     ui::mojom::FrameDecorationValuesPtr values) {
-  if (window_manager_internal_client_) {
+  if (window_manager_client_) {
     normal_client_area_insets_ = values->normal_client_area_insets;
-    window_manager_internal_client_->WmSetFrameDecorationValues(
-        std::move(values));
+    window_manager_client_->WmSetFrameDecorationValues(std::move(values));
   }
 }
 
 void WindowTreeClient::SetNonClientCursor(Window* window,
                                           ui::mojom::CursorType cursor_id) {
-  if (window_manager_internal_client_) {
-    window_manager_internal_client_->WmSetNonClientCursor(
+  if (window_manager_client_) {
+    window_manager_client_->WmSetNonClientCursor(
         WindowMus::Get(window)->server_id(), cursor_id);
   }
 }
 
 void WindowTreeClient::AddAccelerators(
     std::vector<ui::mojom::WmAcceleratorPtr> accelerators,
     const base::Callback<void(bool)>& callback) {
-  if (window_manager_internal_client_) {
-    window_manager_internal_client_->AddAccelerators(std::move(accelerators),
-                                                     callback);
+  if (window_manager_client_) {
+    window_manager_client_->AddAccelerators(std::move(accelerators), callback);
   }
 }
 
 void WindowTreeClient::RemoveAccelerator(uint32_t id) {
-  if (window_manager_internal_client_) {
-    window_manager_internal_client_->RemoveAccelerator(id);
+  if (window_manager_client_) {
+    window_manager_client_->RemoveAccelerator(id);
   }
 }
 
 void WindowTreeClient::AddActivationParent(Window* window) {
-  if (window_manager_internal_client_) {
-    window_manager_internal_client_->AddActivationParent(
+  if (window_manager_client_) {
+    window_manager_client_->AddActivationParent(
         WindowMus::Get(window)->server_id());
   }
 }
 
 void WindowTreeClient::RemoveActivationParent(Window* window) {
-  if (window_manager_internal_client_) {
-    window_manager_internal_client_->RemoveActivationParent(
+  if (window_manager_client_) {
+    window_manager_client_->RemoveActivationParent(
         WindowMus::Get(window)->server_id());
   }
 }
 
 void WindowTreeClient::ActivateNextWindow() {
-  if (window_manager_internal_client_)
-    window_manager_internal_client_->ActivateNextWindow();
+  if (window_manager_client_)
+    window_manager_client_->ActivateNextWindow();
 }
 
 void WindowTreeClient::SetExtendedHitArea(Window* window,
                                           const gfx::Insets& hit_area) {
-  if (window_manager_internal_client_) {
+  if (window_manager_client_) {
     float device_scale_factor = ScaleFactorForDisplay(window);
-    window_manager_internal_client_->SetExtendedHitArea(
+    window_manager_client_->SetExtendedHitArea(
         WindowMus::Get(window)->server_id(),
         gfx::ConvertInsetsToPixel(device_scale_factor, hit_area));
   }
 }
 
 void WindowTreeClient::RequestClose(Window* window) {
   DCHECK(window);
-  if (window_manager_internal_client_)
-    window_manager_internal_client_->WmRequestClose(
-        WindowMus::Get(window)->server_id());
+  if (window_manager_client_)
+    window_manager_client_->WmRequestClose(WindowMus::Get(window)->server_id());
 }
 
 void WindowTreeClient::OnWindowTreeHostBoundsWillChange(
     WindowTreeHostMus* window_tree_host,
     const gfx::Rect& bounds) {
   ScheduleInFlightBoundsChange(WindowMus::Get(window_tree_host->window()),
                                window_tree_host->GetBoundsInPixels(), bounds);
 }
 
 void WindowTreeClient::OnWindowTreeHostClientAreaWillChange(
@@ skipping 191 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura