Reland: Remove aura and make a pure mojo::View version of FocusController.
[Changes: Remove additional deps which Linux/Windows was fine with, but
which broke android because it implied an aura dependency. window_manager
should now be properly deauraed.]
This patch is only half done, however the main driver (removing aura) is
needed by other teams for them to make progress.
Input handling is regressed in this patch; while FocusController is
rebuilt to the point where it should theoretically work, all of the
details about ui::EventTargeter don't work correctly. There is an empty
subclass ViewTargeter which will need to be filled out before
Thankfully, this should only regress people who are using the wm_flow
demo, and this should unblock the android guys who don't have aura
support on their platform.
BUG=431047
TBR=eseidel@chromium.org, sky@chromium.org
Review URL: https://codereview.chromium.org/710203006
diff --git a/mojo/services/window_manager/window_manager_app.cc b/mojo/services/window_manager/window_manager_app.cc
index 2ba436a..9c055b4 100644
--- a/mojo/services/window_manager/window_manager_app.cc
+++ b/mojo/services/window_manager/window_manager_app.cc
@@ -6,7 +6,6 @@
#include "base/message_loop/message_loop.h"
#include "base/stl_util.h"
-#include "mojo/aura/aura_init.h"
#include "mojo/converters/geometry/geometry_type_converters.h"
#include "mojo/converters/input_events/input_events_type_converters.h"
#include "mojo/public/cpp/application/application_connection.h"
@@ -14,66 +13,20 @@
#include "mojo/public/interfaces/application/shell.mojom.h"
#include "mojo/services/public/cpp/view_manager/view.h"
#include "mojo/services/public/cpp/view_manager/view_manager.h"
+#include "mojo/services/window_manager/focus_controller.h"
+#include "mojo/services/window_manager/focus_rules.h"
+#include "mojo/services/window_manager/view_event_dispatcher.h"
+#include "mojo/services/window_manager/view_target.h"
+#include "mojo/services/window_manager/view_targeter.h"
#include "mojo/services/window_manager/window_manager_delegate.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_delegate.h"
-#include "ui/aura/window_property.h"
#include "ui/base/hit_test.h"
-#include "ui/wm/core/capture_controller.h"
-#include "ui/wm/core/focus_controller.h"
-#include "ui/wm/public/activation_client.h"
-
-DECLARE_WINDOW_PROPERTY_TYPE(mojo::View*);
namespace mojo {
-// The aura::Windows we use to track Views don't render, so we don't actually
-// need to supply a fully functional WindowDelegate. We do need to provide _a_
-// delegate however, otherwise the event dispatcher won't dispatch events to
-// these windows. (The aura WindowTargeter won't allow a delegate-less window
-// to be the target of an event, since the window delegate is considered the
-// "target handler").
-class DummyDelegate : public aura::WindowDelegate {
- public:
- DummyDelegate() {}
- ~DummyDelegate() override {}
-
- private:
- // WindowDelegate overrides:
- gfx::Size GetMinimumSize() const override { return gfx::Size(); }
- gfx::Size GetMaximumSize() const override { return gfx::Size(); }
- void OnBoundsChanged(const gfx::Rect& old_bounds,
- const gfx::Rect& new_bounds) override {}
- gfx::NativeCursor GetCursor(const gfx::Point& point) override {
- return gfx::kNullCursor;
- }
- int GetNonClientComponent(const gfx::Point& point) const override {
- return HTCAPTION;
- }
- bool ShouldDescendIntoChildForEventHandling(
- aura::Window* child,
- const gfx::Point& location) override {
- return true;
- }
- bool CanFocus() override { return true; }
- void OnCaptureLost() override {}
- void OnPaint(gfx::Canvas* canvas) override {}
- void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
- void OnWindowDestroying(aura::Window* window) override {}
- void OnWindowDestroyed(aura::Window* window) override {}
- void OnWindowTargetVisibilityChanged(bool visible) override {}
- bool HasHitTestMask() const override { return false; }
- void GetHitTestMask(gfx::Path* mask) const override {}
-
- DISALLOW_COPY_AND_ASSIGN(DummyDelegate);
-};
-
namespace {
-DEFINE_WINDOW_PROPERTY_KEY(View*, kViewKey, NULL);
-
-Id GetIdForWindow(aura::Window* window) {
- return window ? WindowManagerApp::GetViewForWindow(window)->id() : 0;
+Id GetIdForView(View* view) {
+ return view ? view->id() : 0;
}
} // namespace
@@ -123,9 +76,8 @@
native_viewport_event_dispatcher_factory_(this),
wrapped_view_manager_delegate_(view_manager_delegate),
window_manager_delegate_(window_manager_delegate),
- view_manager_(NULL),
- root_(NULL),
- dummy_delegate_(new DummyDelegate) {
+ view_manager_(nullptr),
+ root_(nullptr) {
}
WindowManagerApp::~WindowManagerApp() {
@@ -133,13 +85,14 @@
}
// static
-View* WindowManagerApp::GetViewForWindow(aura::Window* window) {
- return window->GetProperty(kViewKey);
+View* WindowManagerApp::GetViewForViewTarget(ViewTarget* target) {
+ return target->view();
}
-aura::Window* WindowManagerApp::GetWindowForViewId(Id view) {
- ViewIdToWindowMap::const_iterator it = view_id_to_window_map_.find(view);
- return it != view_id_to_window_map_.end() ? it->second : NULL;
+ViewTarget* WindowManagerApp::GetViewTargetForViewId(Id view) {
+ ViewIdToViewTargetMap::const_iterator it =
+ view_id_to_view_target_map_.find(view);
+ return it != view_id_to_view_target_map_.end() ? it->second : nullptr;
}
void WindowManagerApp::AddConnection(WindowManagerImpl* connection) {
@@ -153,37 +106,33 @@
}
void WindowManagerApp::SetCapture(Id view) {
- capture_client_->capture_client()->SetCapture(GetWindowForViewId(view));
+ // TODO(erg): Capture. Another pile of worms that is mixed in here.
+
+ // capture_client_->capture_client()->SetCapture(GetWindowForViewId(view));
+
// TODO(beng): notify connected clients that capture has changed, probably
// by implementing some capture-client observer.
}
-void WindowManagerApp::FocusWindow(Id view) {
- aura::Window* window = GetWindowForViewId(view);
- DCHECK(window);
- focus_client_->FocusWindow(window);
+void WindowManagerApp::FocusWindow(Id view_id) {
+ View* view = view_manager_->GetViewById(view_id);
+ DCHECK(view);
+ focus_controller_->FocusView(view);
}
-void WindowManagerApp::ActivateWindow(Id view) {
- aura::Window* window = GetWindowForViewId(view);
- DCHECK(window);
- activation_client_->ActivateWindow(window);
+void WindowManagerApp::ActivateWindow(Id view_id) {
+ View* view = view_manager_->GetViewById(view_id);
+ DCHECK(view);
+ focus_controller_->ActivateView(view);
}
bool WindowManagerApp::IsReady() const {
return view_manager_ && root_;
}
-void WindowManagerApp::InitFocus(wm::FocusRules* rules) {
- wm::FocusController* focus_controller = new wm::FocusController(rules);
- activation_client_ = focus_controller;
- focus_client_.reset(focus_controller);
- aura::client::SetFocusClient(window_tree_host_->window(), focus_controller);
- aura::client::SetActivationClient(window_tree_host_->window(),
- focus_controller);
-
- focus_client_->AddObserver(this);
- activation_client_->AddObserver(this);
+void WindowManagerApp::InitFocus(scoped_ptr<mojo::FocusRules> rules) {
+ focus_controller_.reset(new mojo::FocusController(rules.Pass()));
+ focus_controller_->AddObserver(this);
}
void WindowManagerApp::Embed(
@@ -204,7 +153,6 @@
void WindowManagerApp::Initialize(ApplicationImpl* impl) {
shell_ = impl->shell();
- aura_init_.reset(new AuraInit);
LaunchViewManager(impl);
}
@@ -225,14 +173,14 @@
view_manager_ = view_manager;
root_ = root;
- window_tree_host_.reset(new WindowTreeHostMojo(shell_, root_));
- window_tree_host_->window()->SetBounds(root->bounds().To<gfx::Rect>());
- window_tree_host_->window()->Show();
+ view_event_dispatcher_.reset(new ViewEventDispatcher());
- RegisterSubtree(root_, window_tree_host_->window());
+ RegisterSubtree(root_, nullptr);
- capture_client_.reset(
- new wm::ScopedCaptureClient(window_tree_host_->window()));
+ // TODO(erg): Also move the capture client over.
+ //
+ // capture_client_.reset(
+ // new wm::ScopedCaptureClient(window_tree_host_->window()));
if (wrapped_view_manager_delegate_) {
wrapped_view_manager_delegate_->OnEmbed(
@@ -249,7 +197,7 @@
DCHECK_EQ(view_manager_, view_manager);
if (wrapped_view_manager_delegate_)
wrapped_view_manager_delegate_->OnViewManagerDisconnected(view_manager);
- view_manager_ = NULL;
+ view_manager_ = nullptr;
base::MessageLoop::current()->Quit();
}
@@ -265,11 +213,11 @@
return;
if (params.new_parent) {
- if (view_id_to_window_map_.find(params.target->id()) ==
- view_id_to_window_map_.end()) {
- ViewIdToWindowMap::const_iterator it =
- view_id_to_window_map_.find(params.new_parent->id());
- DCHECK(it != view_id_to_window_map_.end());
+ if (view_id_to_view_target_map_.find(params.target->id()) ==
+ view_id_to_view_target_map_.end()) {
+ ViewIdToViewTargetMap::const_iterator it =
+ view_id_to_view_target_map_.find(params.new_parent->id());
+ DCHECK(it != view_id_to_view_target_map_.end());
RegisterSubtree(params.target, it->second);
}
} else if (params.old_parent) {
@@ -282,22 +230,16 @@
Unregister(view);
return;
}
- aura::Window* window = GetWindowForViewId(view->id());
- window->RemovePreTargetHandler(this);
- root_ = NULL;
- STLDeleteValues(&view_id_to_window_map_);
- if (focus_client_.get())
- focus_client_->RemoveObserver(this);
- if (activation_client_)
- activation_client_->RemoveObserver(this);
- window_tree_host_.reset();
+ root_ = nullptr;
+ if (focus_controller_)
+ focus_controller_->RemoveObserver(this);
}
void WindowManagerApp::OnViewBoundsChanged(View* view,
const Rect& old_bounds,
const Rect& new_bounds) {
- aura::Window* window = GetWindowForViewId(view->id());
- window->SetBounds(new_bounds.To<gfx::Rect>());
+ // aura::Window* window = GetWindowForViewId(view->id());
+ // window->SetBounds(new_bounds.To<gfx::Rect>());
}
////////////////////////////////////////////////////////////////////////////////
@@ -307,63 +249,61 @@
if (!window_manager_client_)
return;
- View* view = GetViewForWindow(static_cast<aura::Window*>(event->target()));
+ View* view = GetViewForViewTarget(static_cast<ViewTarget*>(event->target()));
if (!view)
return;
+ if (focus_controller_)
+ focus_controller_->OnEvent(event);
+
window_manager_client_->DispatchInputEventToView(view->id(),
Event::From(*event));
}
////////////////////////////////////////////////////////////////////////////////
-// WindowManagerApp, aura::client::FocusChangeObserver implementation:
+// WindowManagerApp, mojo::FocusControllerObserver implementation:
-void WindowManagerApp::OnWindowFocused(aura::Window* gained_focus,
- aura::Window* lost_focus) {
+void WindowManagerApp::OnViewFocused(View* gained_focus,
+ View* lost_focus) {
for (Connections::const_iterator it = connections_.begin();
it != connections_.end(); ++it) {
- (*it)->NotifyViewFocused(GetIdForWindow(gained_focus),
- GetIdForWindow(lost_focus));
+ (*it)->NotifyViewFocused(GetIdForView(gained_focus),
+ GetIdForView(lost_focus));
}
}
-////////////////////////////////////////////////////////////////////////////////
-// WindowManagerApp, aura::client::ActivationChangeObserver implementation:
-
-void WindowManagerApp::OnWindowActivated(aura::Window* gained_active,
- aura::Window* lost_active) {
+void WindowManagerApp::OnViewActivated(View* gained_active,
+ View* lost_active) {
for (Connections::const_iterator it = connections_.begin();
it != connections_.end(); ++it) {
- (*it)->NotifyWindowActivated(GetIdForWindow(gained_active),
- GetIdForWindow(lost_active));
+ (*it)->NotifyWindowActivated(GetIdForView(gained_active),
+ GetIdForView(lost_active));
}
- if (gained_active) {
- View* view = GetViewForWindow(gained_active);
- view->MoveToFront();
- }
+ if (gained_active)
+ gained_active->MoveToFront();
}
////////////////////////////////////////////////////////////////////////////////
// WindowManagerApp, private:
-void WindowManagerApp::RegisterSubtree(View* view, aura::Window* parent) {
+void WindowManagerApp::RegisterSubtree(View* view, ViewTarget* parent) {
view->AddObserver(this);
- DCHECK(view_id_to_window_map_.find(view->id()) ==
- view_id_to_window_map_.end());
- aura::Window* window = new aura::Window(dummy_delegate_.get());
- window->set_id(view->id());
- window->SetProperty(kViewKey, view);
+ DCHECK(view_id_to_view_target_map_.find(view->id()) ==
+ view_id_to_view_target_map_.end());
+ ViewTarget* target = new ViewTarget(this, view);
// All events pass through the root during dispatch, so we only need a handler
// installed there.
- if (view == root_)
- window->AddPreTargetHandler(this);
- parent->AddChild(window);
- window->SetBounds(view->bounds().To<gfx::Rect>());
- window->Show();
- view_id_to_window_map_[view->id()] = window;
+ if (view == root_) {
+ target->SetEventTargeter(scoped_ptr<ViewTargeter>(new ViewTargeter()));
+ target->AddPreTargetHandler(this);
+ view_event_dispatcher_->SetRootViewTarget(target);
+ }
+ // TODO(erg): Why is there no matching RemoveChild()? How does that work in
+ // the aura version?
+ view_id_to_view_target_map_[view->id()] = target;
View::Children::const_iterator it = view->children().begin();
for (; it != view->children().end(); ++it)
- RegisterSubtree(*it, window);
+ RegisterSubtree(*it, target);
}
void WindowManagerApp::UnregisterSubtree(View* view) {
@@ -373,18 +313,19 @@
}
void WindowManagerApp::Unregister(View* view) {
- ViewIdToWindowMap::iterator it = view_id_to_window_map_.find(view->id());
- if (it == view_id_to_window_map_.end()) {
+ ViewIdToViewTargetMap::iterator it =
+ view_id_to_view_target_map_.find(view->id());
+ if (it == view_id_to_view_target_map_.end()) {
// Because we unregister in OnViewDestroying() we can still get a subsequent
// OnTreeChanged for the same view. Ignore this one.
return;
}
view->RemoveObserver(this);
- DCHECK(it != view_id_to_window_map_.end());
+ DCHECK(it != view_id_to_view_target_map_.end());
// Delete before we remove from map as destruction may want to look up view
// for window.
delete it->second;
- view_id_to_window_map_.erase(it);
+ view_id_to_view_target_map_.erase(it);
}
void WindowManagerApp::SetViewportSize(const gfx::Size& size) {
