Clean up WindowEventDispatcher some more.

ui/aura/window_tree_host.cc

 // Copyright (c) 2013 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_tree_host.h"
 
 #include "base/debug/trace_event.h"
+#include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window_transformer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_targeter.h"
-#include "ui/aura/window_tree_host_delegate.h"
 #include "ui/aura/window_tree_host_observer.h"
 #include "ui/base/view_prop.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/screen.h"
@@ skipping 52 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SimpleRootWindowTransformer);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHost, public:
 
 WindowTreeHost::~WindowTreeHost() {
   DCHECK(!compositor_) << "compositor must be destroyed before root window";
 }
 
+#if defined(OS_ANDROID)
+// static
+WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
+  // This is only hit for tests and ash, right now these aren't an issue so
+  // adding the CHECK.
+  // TODO(sky): decide if we want a factory.
+  CHECK(false);
+  return NULL;
+}
+#endif
+
 // static
 WindowTreeHost* WindowTreeHost::GetForAcceleratedWidget(
     gfx::AcceleratedWidget widget) {
   return reinterpret_cast<WindowTreeHost*>(
       ui::ViewProp::GetValue(widget, kWindowTreeHostForAcceleratedWidget));
 }
 
 void WindowTreeHost::InitHost() {
   InitCompositor();
   UpdateRootWindowSize(GetBounds().size());
-  Env::GetInstance()->NotifyRootWindowInitialized(delegate_->AsDispatcher());
+  Env::GetInstance()->NotifyRootWindowInitialized(dispatcher());
   window()->Show();
 }
 
 void WindowTreeHost::InitCompositor() {
   compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(window()),
                                GetBounds().size());
   compositor_->SetRootLayer(window()->layer());
   transformer_.reset(
       new SimpleRootWindowTransformer(window(), gfx::Transform()));
 }
@@ skipping 72 matching lines @@
   // so just pass everything along to the host.
   SetCursorNative(cursor);
 }
 
 void WindowTreeHost::OnCursorVisibilityChanged(bool show) {
   // Clear any existing mouse hover effects when the cursor becomes invisible.
   // Note we do not need to dispatch a mouse enter when the cursor becomes
   // visible because that can only happen in response to a mouse event, which
   // will trigger its own mouse enter.
   if (!show) {
-    delegate_->AsDispatcher()->DispatchMouseExitAtPoint(
-        delegate_->AsDispatcher()->GetLastMouseLocationInRoot());
+    dispatcher()->DispatchMouseExitAtPoint(
+        dispatcher()->GetLastMouseLocationInRoot());
   }
 
   OnCursorVisibilityChangedNative(show);
 }
 
 void WindowTreeHost::MoveCursorTo(const gfx::Point& location_in_dip) {
   gfx::Point host_location(location_in_dip);
   ConvertPointToHost(&host_location);
   MoveCursorToInternal(location_in_dip, host_location);
 }
 
 void WindowTreeHost::MoveCursorToHostLocation(const gfx::Point& host_location) {
   gfx::Point root_location(host_location);
   ConvertPointFromHost(&root_location);
   MoveCursorToInternal(root_location, host_location);
 }
 
-WindowEventDispatcher* WindowTreeHost::GetDispatcher() {
-  return delegate_->AsDispatcher();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHost, protected:
 
 WindowTreeHost::WindowTreeHost()
-    : delegate_(NULL),
-      window_(new Window(NULL)),
+    : window_(new Window(NULL)),
       last_cursor_(ui::kCursorNull) {
 }
 
 void WindowTreeHost::DestroyCompositor() {
   DCHECK(GetAcceleratedWidget());
   compositor_.reset();
 }
 
 void WindowTreeHost::DestroyDispatcher() {
-  // An observer may have been added by an animation on the
-  // WindowEventDispatcher.
-  window()->layer()->GetAnimator()->RemoveObserver(dispatcher());
-
   delete window_;
   window_ = NULL;
   dispatcher_.reset();
 
   // TODO(beng): this comment is no longer quite valid since this function
   // isn't called from WED, and WED isn't a subclass of Window. So it seems
   // like we could just rely on ~Window now.
   // 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
@@ skipping 11 matching lines @@
     window()->Init(WINDOW_LAYER_NOT_DRAWN);
     window()->set_host(this);
     window()->SetName("RootWindow");
     window()->SetEventTargeter(
         scoped_ptr<ui::EventTargeter>(new WindowTargeter()));
     prop_.reset(new ui::ViewProp(GetAcceleratedWidget(),
                                  kWindowTreeHostForAcceleratedWidget,
                                  this));
     dispatcher_.reset(new WindowEventDispatcher(this));
   }
-  delegate_ = dispatcher();
 }
 
 void WindowTreeHost::OnHostMoved(const gfx::Point& new_location) {
   TRACE_EVENT1("ui", "WindowTreeHost::OnHostMoved",
                "origin", new_location.ToString());
 
   FOR_EACH_OBSERVER(WindowTreeHostObserver, observers_,
                     OnHostMoved(this, new_location));
 }
 
 void WindowTreeHost::OnHostResized(const gfx::Size& new_size) {
   // The compositor should have the same size as the native root window host.
   // Get the latest scale from display because it might have been changed.
   compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(window()),
                                new_size);
 
   gfx::Size layer_size = GetBounds().size();
   // The layer, and the observers should be notified of the
   // transformed size of the root window.
   UpdateRootWindowSize(layer_size);
   FOR_EACH_OBSERVER(WindowTreeHostObserver, observers_, OnHostResized(this));
-  delegate_->OnHostResized(layer_size);
+  dispatcher()->OnHostResized(layer_size);
 }
 
 void WindowTreeHost::OnHostCloseRequested() {
   FOR_EACH_OBSERVER(WindowTreeHostObserver, observers_,
                     OnHostCloseRequested(this));
 }
 
+void WindowTreeHost::OnHostActivated() {
+  Env::GetInstance()->RootWindowActivated(dispatcher());
+}
+
+void WindowTreeHost::OnHostLostWindowCapture() {
+  Window* capture_window = client::GetCaptureWindow(window());
+  if (capture_window && capture_window->GetRootWindow() == window())
+    capture_window->ReleaseCapture();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// WindowTreeHost, private:
+
 void WindowTreeHost::MoveCursorToInternal(const gfx::Point& root_location,
                                           const gfx::Point& host_location) {
   MoveCursorToNative(host_location);
   client::CursorClient* cursor_client = client::GetCursorClient(window());
   if (cursor_client) {
     const gfx::Display& display =
         gfx::Screen::GetScreenFor(window())->GetDisplayNearestWindow(window());
     cursor_client->SetDisplay(display);
   }
-  delegate_->OnCursorMovedToRootLocation(root_location);
+  dispatcher()->OnCursorMovedToRootLocation(root_location);
 }
 
-#if defined(OS_ANDROID)
-// static
-WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
-  // This is only hit for tests and ash, right now these aren't an issue so
-  // adding the CHECK.
-  // TODO(sky): decide if we want a factory.
-  CHECK(false);
-  return NULL;
-}
-#endif
-
 }  // namespace aura