Window ownership -> WindowTreeHost

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 "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/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"
 #include "ui/gfx/size_conversions.h"
 
 namespace aura {
 
+const char kWindowTreeHostForAcceleratedWidget[] =
+    "__AURA_WINDOW_TREE_HOST_ACCELERATED_WIDGET__";
+
 float GetDeviceScaleFactorFromDisplay(Window* window) {
   gfx::Display display = gfx::Screen::GetScreenFor(window)->
       GetDisplayNearestWindow(window);
   DCHECK(display.is_valid());
   return display.device_scale_factor();
 }
 
 class SimpleRootWindowTransformer : public RootWindowTransformer {
  public:
   SimpleRootWindowTransformer(const Window* root_window,
@@ skipping 35 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SimpleRootWindowTransformer);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHost, public:
 
 WindowTreeHost::~WindowTreeHost() {
   DCHECK(!compositor_) << "compositor must be destroyed before root window";
 }
 
+// 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());
   window()->Show();
 }
 
 void WindowTreeHost::InitCompositor() {
   compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(window()),
                                GetBounds().size());
   compositor_->SetRootLayer(window()->layer());
   transformer_.reset(
       new SimpleRootWindowTransformer(window(), gfx::Transform()));
 }
 
-aura::Window* WindowTreeHost::window() {
-  return const_cast<Window*>(const_cast<const WindowTreeHost*>(this)->window());
-}
-
-const aura::Window* WindowTreeHost::window() const {
-  return delegate_->AsDispatcher()->window();
-}
-
 void WindowTreeHost::SetRootWindowTransformer(
     scoped_ptr<RootWindowTransformer> transformer) {
   transformer_ = transformer.Pass();
   SetInsets(transformer_->GetHostInsets());
   window()->SetTransform(transformer_->GetTransform());
   // If the layer is not animating, then we need to update the root window
   // size immediately.
   if (!window()->layer()->GetAnimator()->is_animating())
     UpdateRootWindowSize(GetBounds().size());
 }
@@ skipping 81 matching lines @@
 
 WindowEventDispatcher* WindowTreeHost::GetDispatcher() {
   return delegate_->AsDispatcher();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHost, protected:
 
 WindowTreeHost::WindowTreeHost()
     : delegate_(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
+  // we ensure GetRootWindow() still returns this.
+  //window()->RemoveOrDestroyChildren();
 }
 
 void WindowTreeHost::CreateCompositor(
     gfx::AcceleratedWidget accelerated_widget) {
   compositor_.reset(new ui::Compositor(GetAcceleratedWidget()));
   DCHECK(compositor_.get());
   // TODO(beng): I think this setup should probably all move to a "accelerated
   // widget available" function.
-  if (!dispatcher())
+  if (!dispatcher()) {
+    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::NotifyHostResized(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();
@@ skipping 20 matching lines @@
 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