Window ownership -> WindowTreeHost

ui/aura/window_event_dispatcher.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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/window_event_dispatcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
-#include "ui/base/view_prop.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/events/event.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/events/gestures/gesture_types.h"
 #include "ui/gfx/screen.h"
 
 using std::vector;
 
 typedef ui::EventDispatchDetails DispatchDetails;
 
 namespace aura {
 
 namespace {
 
-const char kRootWindowForAcceleratedWidget[] =
-    "__AURA_ROOT_WINDOW_ACCELERATED_WIDGET__";
-
 // Returns true if |target| has a non-client (frame) component at |location|,
 // in window coordinates.
 bool IsNonClientLocation(Window* target, const gfx::Point& location) {
   if (!target->delegate())
     return false;
   int hit_test_code = target->delegate()->GetNonClientComponent(location);
   return hit_test_code != HTCLIENT && hit_test_code != HTNOWHERE;
 }
 
 Window* ConsumerToWindow(ui::GestureConsumer* consumer) {
@@ skipping 22 matching lines @@
     return true;
   return false;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowEventDispatcher, public:
 
 WindowEventDispatcher::WindowEventDispatcher(WindowTreeHost* host)
-    : window_(new Window(NULL)),
-      host_(host),
+    : host_(host),
       touch_ids_down_(0),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       event_dispatch_target_(NULL),
       old_dispatch_target_(NULL),
       synthesize_mouse_move_(false),
       move_hold_count_(0),
       dispatching_held_event_(false),
       repost_event_factory_(this),
       held_event_factory_(this) {
-  window()->Init(WINDOW_LAYER_NOT_DRAWN);
-  window()->set_dispatcher(this);
-  window()->SetName("RootWindow");
-  window()->SetEventTargeter(
-      scoped_ptr<ui::EventTargeter>(new WindowTargeter()));
-
-  prop_.reset(new ui::ViewProp(host_->GetAcceleratedWidget(),
-                               kRootWindowForAcceleratedWidget,
-                               this));
   ui::GestureRecognizer::Get()->AddGestureEventHelper(this);
 }
 
 WindowEventDispatcher::~WindowEventDispatcher() {
   TRACE_EVENT0("shutdown", "WindowEventDispatcher::Destructor");
-
   ui::GestureRecognizer::Get()->RemoveGestureEventHelper(this);
-
-  // An observer may have been added by an animation on the
-  // WindowEventDispatcher.
-  window()->layer()->GetAnimator()->RemoveObserver(this);
-
-  // Destroy child windows while we're still valid. This is also done by
-  // ~Window, but by that time any calls to virtual methods overriden here (such
-  // as GetRootWindow()) result in Window's implementation. By destroying here
-  // we ensure GetRootWindow() still returns this.
-  window()->RemoveOrDestroyChildren();
-  window()->set_dispatcher(NULL);
-}
-
-// static
-WindowEventDispatcher* WindowEventDispatcher::GetForAcceleratedWidget(
-    gfx::AcceleratedWidget widget) {
-  return reinterpret_cast<WindowEventDispatcher*>(
-      ui::ViewProp::GetValue(widget, kRootWindowForAcceleratedWidget));
 }
 
 void WindowEventDispatcher::PrepareForShutdown() {
   host_->PrepareForShutdown();
   // discard synthesize event request as well.
   synthesize_mouse_move_ = false;
 }
 
 void WindowEventDispatcher::RepostEvent(const ui::LocatedEvent& event) {
   DCHECK(event.type() == ui::ET_MOUSE_PRESSED ||
@@ skipping 766 matching lines @@
       break;
 
     default:
       NOTREACHED();
       break;
   }
   PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura