Revert of Improves focus/activation for aura-mus and DesktopNativeWidgetAura

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>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
+#include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/capture_synchronizer.h"
 #include "ui/aura/mus/drag_drop_controller_mus.h"
-#include "ui/aura/mus/focus_synchronizer.h"
 #include "ui/aura/mus/in_flight_change.h"
 #include "ui/aura/mus/input_method_mus.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
@@ skipping 94 matching lines @@
       next_change_id_(1),
       delegate_(delegate),
       window_manager_delegate_(window_manager_delegate),
       binding_(this),
       tree_(nullptr),
       in_destructor_(false),
       weak_factory_(this) {
   // Allow for a null request in tests.
   if (request.is_pending())
     binding_.Bind(std::move(request));
+  delegate_->GetFocusClient()->AddObserver(this);
   client::GetTransientWindowClient()->AddObserver(this);
   if (window_manager_delegate)
     window_manager_delegate->SetWindowManagerClient(this);
 }
 
 WindowTreeClient::~WindowTreeClient() {
   in_destructor_ = true;
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnWillDestroyClient(this);
@@ skipping 17 matching lines @@
   // other random windows that it doesn't own.
   while (!tracker.windows().empty())
     delete tracker.windows().front();
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnDidDestroyClient(this);
 
   capture_synchronizer_.reset();
 
   client::GetTransientWindowClient()->RemoveObserver(this);
+  delegate_->GetFocusClient()->RemoveObserver(this);
 }
 
 void WindowTreeClient::ConnectViaWindowTreeFactory(
     service_manager::Connector* connector) {
   // The client id doesn't really matter, we use 101 purely for debugging.
   client_id_ = 101;
 
   ui::mojom::WindowTreeFactoryPtr factory;
   connector->ConnectToInterface("service:ui", &factory);
   ui::mojom::WindowTreePtr window_tree;
@@ skipping 98 matching lines @@
   return it != windows_.end() ? it->second : nullptr;
 }
 
 bool WindowTreeClient::WasCreatedByThisClient(const WindowMus* window) const {
   // Windows created via CreateTopLevelWindow() are not owned by us, but have
   // our client id. const_cast is required by set.
   return HiWord(window->server_id()) == client_id_ &&
          roots_.count(const_cast<WindowMus*>(window)) == 0;
 }
 
+void WindowTreeClient::SetFocusFromServer(WindowMus* window) {
+  if (focused_window_ == window)
+    return;
+
+  if (window) {
+    client::FocusClient* focus_client =
+        client::GetFocusClient(window->GetWindow());
+    if (focus_client) {
+      SetFocusFromServerImpl(focus_client, window);
+    } else {
+      SetFocusFromServerImpl(
+          client::GetFocusClient(focused_window_->GetWindow()), nullptr);
+    }
+  } else {
+    SetFocusFromServerImpl(client::GetFocusClient(focused_window_->GetWindow()),
+                           nullptr);
+  }
+}
+
+void WindowTreeClient::SetFocusFromServerImpl(client::FocusClient* focus_client,
+                                              WindowMus* window) {
+  if (!focus_client)
+    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);
+  focus_client->FocusWindow(window ? window->GetWindow() : nullptr);
+}
+
 InFlightChange* WindowTreeClient::GetOldestInFlightChangeMatching(
     const InFlightChange& change) {
   for (const auto& pair : in_flight_map_) {
     if (pair.second->window() == change.window() &&
         pair.second->change_type() == change.change_type() &&
         pair.second->Matches(change)) {
       return pair.second.get();
     }
   }
   return nullptr;
@@ skipping 107 matching lines @@
   }
 }
 
 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_, delegate_->GetCaptureClient());
-  focus_synchronizer_ = base::MakeUnique<FocusSynchronizer>(this, tree_);
 }
 
 void WindowTreeClient::OnConnectionLost() {
   delegate_->OnLostConnection(this);
 }
 
 bool WindowTreeClient::HandleInternalPropertyChanged(WindowMus* window,
                                                      const void* key) {
   if (key != client::kModalKey)
     return false;
@@ skipping 21 matching lines @@
                                    bool drawn) {
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
   client_id_ = client_id;
   WindowTreeConnectionEstablished(window_tree);
 
   DCHECK(roots_.empty());
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       CreateWindowTreeHost(WindowMusType::EMBED, root_data, display_id);
 
-  focus_synchronizer_->SetFocusFromServer(
-      GetWindowByServerId(focused_window_id));
+  SetFocusFromServer(GetWindowByServerId(focused_window_id));
 
   delegate_->OnEmbed(std::move(window_tree_host));
 }
 
 WindowTreeHost* WindowTreeClient::WmNewDisplayAddedImpl(
     const display::Display& display,
     ui::mojom::WindowDataPtr root_data,
     bool parent_drawn) {
   DCHECK(window_manager_delegate_);
 
@@ skipping 90 matching lines @@
   if (create_top_level) {
     tree_->NewTopLevelWindow(change_id, window->server_id(),
                              std::move(transport_properties));
   } else {
     tree_->NewWindow(change_id, window->server_id(),
                      std::move(transport_properties));
   }
 }
 
 void WindowTreeClient::OnWindowMusDestroyed(WindowMus* window) {
-  if (focus_synchronizer_->focused_window() == window)
-    focus_synchronizer_->OnFocusedWindowDestroyed();
+  if (focused_window_ == window)
+    focused_window_ = nullptr;
 
   // TODO: decide how to deal with windows not owned by this client.
   if (WasCreatedByThisClient(window) || IsRoot(window)) {
     const uint32_t change_id =
         ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
             window, ChangeType::DELETE_WINDOW));
     tree_->DeleteWindow(change_id, window->server_id());
   }
 
   windows_.erase(window->server_id());
@@ skipping 149 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeClient, WindowTreeClient implementation:
 
 std::set<Window*> WindowTreeClient::GetRoots() {
   std::set<Window*> roots;
   for (WindowMus* window : roots_)
     roots.insert(window->GetWindow());
   return roots;
 }
 
+Window* WindowTreeClient::GetFocusedWindow() {
+  return focused_window_ ? focused_window_->GetWindow() : nullptr;
+}
+
 gfx::Point WindowTreeClient::GetCursorScreenPoint() {
   // We raced initialization. Return (0, 0).
   if (!cursor_location_memory())
     return gfx::Point();
 
   base::subtle::Atomic32 location =
       base::subtle::NoBarrier_Load(cursor_location_memory());
   return gfx::Point(static_cast<int16_t>(location >> 16),
                     static_cast<int16_t>(location & 0xFFFF));
 }
@@ skipping 386 matching lines @@
     return;
 
   WindowMus* target_window = GetWindowByServerId(window_id);
   delegate_->OnPointerEventObserved(
       *event->AsPointerEvent(),
       target_window ? target_window->GetWindow() : nullptr);
 }
 
 void WindowTreeClient::OnWindowFocused(Id focused_window_id) {
   WindowMus* focused_window = GetWindowByServerId(focused_window_id);
-  InFlightFocusChange new_change(this, focus_synchronizer_.get(),
-                                 focused_window);
+  InFlightFocusChange new_change(this, focused_window);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
-  focus_synchronizer_->SetFocusFromServer(focused_window);
+  SetFocusFromServer(focused_window);
 }
 
 void WindowTreeClient::OnWindowPredefinedCursorChanged(
     Id window_id,
     ui::mojom::Cursor cursor) {
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   InFlightPredefinedCursorChange new_change(window, cursor);
@@ skipping 302 matching lines @@
 void WindowTreeClient::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         WindowMus::Get(window)->server_id(), offset.x(), offset.y(), hit_area);
   }
 }
 
+void WindowTreeClient::OnWindowFocused(Window* gained_focus,
+                                       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;
+  }
+
+  const uint32_t change_id = ScheduleInFlightChange(
+      base::MakeUnique<InFlightFocusChange>(this, focused_window_));
+  focused_window_ = gained_focus_mus;
+  tree_->SetFocus(change_id, focused_window_ ? focused_window_->server_id()
+                                             : kInvalidServerId);
+}
+
 void WindowTreeClient::OnWindowTreeHostBoundsWillChange(
     WindowTreeHostMus* window_tree_host,
     const gfx::Rect& bounds) {
   ScheduleInFlightBoundsChange(WindowMus::Get(window_tree_host->window()),
                                window_tree_host->GetBounds(), bounds);
 }
 
 std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortForTopLevel() {
   std::unique_ptr<WindowPortMus> window_port =
       base::MakeUnique<WindowPortMus>(this, WindowMusType::TOP_LEVEL);
@@ skipping 43 matching lines @@
 uint32_t WindowTreeClient::CreateChangeIdForDrag(WindowMus* window) {
   return ScheduleInFlightChange(
       base::MakeUnique<InFlightDragChange>(window, ChangeType::DRAG_LOOP));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForCapture(WindowMus* window) {
   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