Revert "Delete the ViewManager and WindowManager services."

services/window_manager/view_targeter.cc

Index: services/window_manager/view_targeter.cc
diff --git a/services/window_manager/view_targeter.cc b/services/window_manager/view_targeter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2b69e6cb1bd19281eb12c4a3a4bb77504f63af06
--- /dev/null
+++ b/services/window_manager/view_targeter.cc
@@ -0,0 +1,148 @@
+// 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 "services/window_manager/view_targeter.h"
+
+#include "services/window_manager/capture_controller.h"
+#include "services/window_manager/focus_controller.h"
+#include "services/window_manager/view_target.h"
+#include "ui/events/event_target_iterator.h"
+
+namespace window_manager {
+
+ViewTargeter::ViewTargeter() {}
+
+ViewTargeter::~ViewTargeter() {}
+
+ui::EventTarget* ViewTargeter::FindTargetForEvent(ui::EventTarget* root,
+                                                  ui::Event* event) {
+  ViewTarget* view = static_cast<ViewTarget*>(root);
+  ViewTarget* target;
+  if (event->IsKeyEvent()) {
+    target = FindTargetForKeyEvent(view, *static_cast<ui::KeyEvent*>(event));
+  } else if (event->IsMouseEvent() ||
+      event->IsScrollEvent() ||
+      event->IsTouchEvent() ||
+      event->IsGestureEvent()) {
+    target = static_cast<ViewTarget*>(FindTargetForLocatedEvent(
+      root, static_cast<ui::LocatedEvent*>(event)));
+  } else {
+    target = static_cast<ViewTarget*>(root);
+  }
+
+  // TODO(erg): The aura version of this method does a lot of work to handle
+  // dispatching to a target that isn't a child of |view|. For now, punt on
+  // this.
+  DCHECK_EQ(view->GetRoot(), target->GetRoot());
+
+  return target;
+}
+
+ui::EventTarget* ViewTargeter::FindNextBestTarget(
+  ui::EventTarget* previous_target, ui::Event* event) {
+  return nullptr;
+}
+
+ui::EventTarget* ViewTargeter::FindTargetForLocatedEvent(
+    ui::EventTarget* root,
+    ui::LocatedEvent* event) {
+  ViewTarget* view = static_cast<ViewTarget*>(root);
+  if (!view->HasParent()) {
+    ViewTarget* target = FindTargetInRootView(view, *event);
+    if (target) {
+      view->ConvertEventToTarget(target, event);
+      return target;
+    }
+  }
+  scoped_ptr<ui::EventTargetIterator> iter = root->GetChildIterator();
+  if (iter) {
+    ui::EventTarget* target = root;
+    for (ui::EventTarget* child = iter->GetNextTarget(); child;
+         child = iter->GetNextTarget()) {
+      ViewTargeter* targeter = static_cast<ViewTargeter*>(
+        child->GetEventTargeter());
+      if (!targeter)
+        targeter = this;
+      if (!targeter->SubtreeShouldBeExploredForEvent(child, *event))
+        continue;
+      target->ConvertEventToTarget(child, event);
+      target = child;
+      ui::EventTarget* child_target =
+          targeter->FindTargetForLocatedEvent(child, event);
+      if (child_target)
+        return child_target;
+    }
+    target->ConvertEventToTarget(root, event);
+  }
+  return root->CanAcceptEvent(*event) ? root : NULL;
+}
+
+bool ViewTargeter::SubtreeShouldBeExploredForEvent(
+  ui::EventTarget* target, const ui::LocatedEvent& event) {
+  return SubtreeCanAcceptEvent(target, event) &&
+         EventLocationInsideBounds(target, event);
+}
+
+bool ViewTargeter::SubtreeCanAcceptEvent(ui::EventTarget* target,
+                                         const ui::LocatedEvent& event) const {
+  ViewTarget* view = static_cast<ViewTarget*>(target);
+
+  if (!view->IsVisible())
+    return false;
+
+  // TODO(erg): We may need to keep track of the parent on ViewTarget, because
+  // we have a check here about
+  // WindowDelegate::ShouldDescendIntoChildForEventHandling().
+
+  // TODO(sky): decide if we really want this. If we do, it should be a public
+  // constant and documented.
+  if (view->view()->shared_properties().count("deliver-events-to-parent"))
+    return false;
+
+  return true;
+}
+
+bool ViewTargeter::EventLocationInsideBounds(
+    ui::EventTarget* target,
+    const ui::LocatedEvent& event) const {
+  ViewTarget* view = static_cast<ViewTarget*>(target);
+  gfx::Point point = event.location();
+  const ViewTarget* parent = view->GetParent();
+  if (parent)
+    ViewTarget::ConvertPointToTarget(parent, view, &point);
+  return gfx::Rect(view->GetBounds().size()).Contains(point);
+}
+
+ViewTarget* ViewTargeter::FindTargetForKeyEvent(ViewTarget* view_target,
+                                                const ui::KeyEvent& key) {
+  FocusController* focus_controller = GetFocusController(view_target->view());
+  if (focus_controller) {
+    mojo::View* focused_view = focus_controller->GetFocusedView();
+    if (focused_view)
+      return ViewTarget::TargetFromView(focused_view);
+  }
+  return view_target;
+}
+
+ViewTarget* ViewTargeter::FindTargetInRootView(ViewTarget* root_view,
+                                               const ui::LocatedEvent& event) {
+  // TODO(erg): This here is important because it resolves
+  // mouse_pressed_handler() in the aura version. This is what makes sure
+  // that a view gets both the mouse down and up.
+
+  CaptureController* capture_controller =
+      GetCaptureController(root_view->view());
+  if (capture_controller) {
+    mojo::View* capture_view = capture_controller->GetCapture();
+    if (capture_view)
+      return ViewTarget::TargetFromView(capture_view);
+  }
+
+  // TODO(erg): There's a whole bunch of junk about handling touch events
+  // here. Handle later.
+
+  return nullptr;
+}
+
+}  // namespace window_manager