Window ownership -> WindowTreeHost

ui/aura/window_event_dispatcher_unittest.cc

 // Copyright (c) 2012 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/run_loop.h"
@@ skipping 1115 matching lines @@
     }
     EventFilterRecorder::OnTouchEvent(event);
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
     EXPECT_EQ(done_cleanup_ ? repost_target_ : repost_source_, event->target());
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       if (!reposted_) {
         EXPECT_NE(repost_target_, event->target());
         reposted_ = true;
-        repost_target_->GetDispatcher()->RepostEvent(*event);
+        repost_target_->GetHost()->dispatcher()->RepostEvent(*event);
         // Ensure that the reposted gesture event above goes to the
         // repost_target_;
         repost_source_->GetRootWindow()->RemoveChild(repost_source_);
         return;
       }
     }
     EventFilterRecorder::OnGestureEvent(event);
   }
 
   // Ignore mouse events as they don't fire at all times. This causes
@@ skipping 197 matching lines @@
 
   int mouse_event_count() const { return mouse_event_count_; }
 
   // TestWindowDelegate:
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if ((event->flags() & ui::EF_SHIFT_DOWN) != 0 &&
         mouse_event_count_++ == 0) {
       ui::MouseEvent mouse_event(ui::ET_MOUSE_PRESSED,
                                  gfx::Point(10, 10), gfx::Point(10, 10),
                                  ui::EF_SHIFT_DOWN, 0);
-      root_->GetDispatcher()->RepostEvent(mouse_event);
+      root_->GetHost()->dispatcher()->RepostEvent(mouse_event);
     }
   }
 
  private:
   Window* root_;
   int mouse_event_count_;
 
   DISALLOW_COPY_AND_ASSIGN(DontResetHeldEventWindowDelegate);
 };
 
 }  // namespace
 
 // Verifies RootWindow doesn't reset |RootWindow::held_repostable_event_| after
 // dispatching. This is done by using DontResetHeldEventWindowDelegate, which
 // tracks the number of events with ui::EF_SHIFT_DOWN set (all reposted events
 // have EF_SHIFT_DOWN). When the first event is seen RepostEvent() is used to
 // schedule another reposted event.
 TEST_F(WindowEventDispatcherTest, DontResetHeldEvent) {
   DontResetHeldEventWindowDelegate delegate(root_window());
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), &delegate));
   w1->SetBounds(gfx::Rect(0, 0, 40, 40));
   ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED,
                          gfx::Point(10, 10), gfx::Point(10, 10),
                          ui::EF_SHIFT_DOWN, 0);
-  root_window()->GetDispatcher()->RepostEvent(pressed);
+  root_window()->GetHost()->dispatcher()->RepostEvent(pressed);
   ui::MouseEvent pressed2(ui::ET_MOUSE_PRESSED,
                           gfx::Point(10, 10), gfx::Point(10, 10), 0, 0);
   // Dispatch an event to flush event scheduled by way of RepostEvent().
   DispatchEventUsingWindowDispatcher(&pressed2);
   // Delegate should have seen reposted event (identified by way of
   // EF_SHIFT_DOWN). Dispatch another event to flush the second
   // RepostedEvent().
   EXPECT_EQ(1, delegate.mouse_event_count());
   DispatchEventUsingWindowDispatcher(&pressed2);
   EXPECT_EQ(2, delegate.mouse_event_count());
@@ skipping 456 matching lines @@
   virtual ~DispatchEventHandler() {}
 
   bool dispatched() const { return dispatched_; }
  private:
   // ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
     if (mouse->type() == ui::ET_MOUSE_MOVED) {
       ui::MouseEvent move(ui::ET_MOUSE_MOVED, target_->bounds().CenterPoint(),
           target_->bounds().CenterPoint(), ui::EF_NONE, ui::EF_NONE);
       ui::EventDispatchDetails details =
-          target_->GetDispatcher()->OnEventFromSource(&move);
+          target_->GetHost()->dispatcher()->OnEventFromSource(&move);
       ASSERT_FALSE(details.dispatcher_destroyed);
       EXPECT_FALSE(details.target_destroyed);
       EXPECT_EQ(target_, move.target());
       dispatched_ = true;
     }
     ui::EventHandler::OnMouseEvent(mouse);
   }
 
   Window* target_;
   bool dispatched_;
@@ skipping 69 matching lines @@
   EXPECT_TRUE(details.target_destroyed);
   EXPECT_EQ(first.get(), move.target());
   EXPECT_TRUE(dispatch_event.dispatched());
   EXPECT_EQ(second_root, first->GetRootWindow());
 
   first->RemovePreTargetHandler(&dispatch_event);
   second->RemovePreTargetHandler(&move_window);
 }
 
 }  // namespace aura