Remove some pass-thrus on RootWindow API in favor of exposing the RootWindowHost again.

ui/aura/root_window.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/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 67 matching lines @@
     Env::GetInstance()->set_last_mouse_location(location_in_screen);
   } else {
     Env::GetInstance()->set_last_mouse_location(location_in_root);
   }
 }
 
 RootWindowHost* CreateHost(RootWindow* root_window,
                            const RootWindow::CreateParams& params) {
   RootWindowHost* host = params.host ?
       params.host : RootWindowHost::Create(params.initial_bounds);
-  host->SetDelegate(root_window);
+  host->set_delegate(root_window);
   return host;
 }
 
 class SimpleRootWindowTransformer : public RootWindowTransformer {
  public:
   SimpleRootWindowTransformer(const Window* root_window,
                               const gfx::Transform& transform)
       : root_window_(root_window),
         transform_(transform) {
   }
@@ skipping 97 matching lines @@
       ui::ViewProp::GetValue(widget, kRootWindowForAcceleratedWidget));
 }
 
 void RootWindow::Init() {
   compositor()->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(window()),
                                 host_->GetBounds().size());
   window()->Init(ui::LAYER_NOT_DRAWN);
   compositor()->SetRootLayer(window()->layer());
   transformer_.reset(
       new SimpleRootWindowTransformer(window(), gfx::Transform()));
-  UpdateRootWindowSize(GetHostSize());
+  UpdateRootWindowSize(host_->GetBounds().size());
   Env::GetInstance()->NotifyRootWindowInitialized(this);
   window()->Show();
 }
 
-void RootWindow::ShowRootWindow() {
-  host_->Show();
-}
-
-void RootWindow::HideRootWindow() {
-  host_->Hide();
-}
-
 void RootWindow::PrepareForShutdown() {
   host_->PrepareForShutdown();
   // discard synthesize event request as well.
   synthesize_mouse_move_ = false;
 }
 
 void RootWindow::RepostEvent(const ui::LocatedEvent& event) {
   DCHECK(event.type() == ui::ET_MOUSE_PRESSED ||
          event.type() == ui::ET_GESTURE_TAP_DOWN);
   // We allow for only one outstanding repostable event. This is used
@@ skipping 31 matching lines @@
   // Requery the location to constrain it within the new root window size.
   gfx::Point point;
   if (host_->QueryMouseLocation(&point)) {
     SetLastMouseLocation(window(),
                          ui::ConvertPointToDIP(window()->layer(), point));
   }
 
   synthesize_mouse_move_ = false;
 }
 
-gfx::Size RootWindow::GetHostSize() const {
-  return host_->GetBounds().size();
-}
-
 void RootWindow::SetHostBounds(const gfx::Rect& bounds_in_pixel) {
   DCHECK(!bounds_in_pixel.IsEmpty());
   DispatchDetails details = DispatchHeldEvents();
   if (details.dispatcher_destroyed)
     return;
   host_->SetBounds(bounds_in_pixel);
   synthesize_mouse_move_ = false;
 }
 
-gfx::Point RootWindow::GetHostOrigin() const {
-  return host_->GetBounds().origin();
-}
-
 void RootWindow::SetCursor(gfx::NativeCursor cursor) {
   last_cursor_ = cursor;
   // A lot of code seems to depend on NULL cursors actually showing an arrow,
   // so just pass everything along to the host.
   host_->SetCursor(cursor);
 }
 
 void RootWindow::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
@@ skipping 17 matching lines @@
   ConvertPointToHost(&host_location);
   MoveCursorToInternal(location_in_dip, host_location);
 }
 
 void RootWindow::MoveCursorToHostLocation(const gfx::Point& host_location) {
   gfx::Point root_location(host_location);
   ConvertPointFromHost(&root_location);
   MoveCursorToInternal(root_location, host_location);
 }
 
-bool RootWindow::ConfineCursorToWindow() {
-  // We would like to be able to confine the cursor to that window. However,
-  // currently, we do not have such functionality in X. So we just confine
-  // to the root window. This is ok because this option is currently only
-  // being used in fullscreen mode, so root_window bounds = window bounds.
-  return host_->ConfineCursorToRootWindow();
-}
-
-void RootWindow::UnConfineCursor() {
-  host_->UnConfineCursor();
-}
-
 void RootWindow::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
   compositor_->ScheduleRedrawRect(damage_rect);
 }
 
 Window* RootWindow::GetGestureTarget(ui::GestureEvent* event) {
   Window* target = client::GetCaptureWindow(window());
   if (!target) {
     target = ConsumerToWindow(
         ui::GestureRecognizer::Get()->GetTargetForGestureEvent(event));
   }
@@ skipping 81 matching lines @@
 }
 
 void RootWindow::AddRootWindowObserver(RootWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RootWindow::RemoveRootWindowObserver(RootWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void RootWindow::PostNativeEvent(const base::NativeEvent& native_event) {
-  host_->PostNativeEvent(native_event);
-}
-
-void RootWindow::ConvertPointToNativeScreen(gfx::Point* point) const {
-  ConvertPointToHost(point);
-  gfx::Point location = host_->GetLocationOnNativeScreen();
-  point->Offset(location.x(), location.y());
-}
-
-void RootWindow::ConvertPointFromNativeScreen(gfx::Point* point) const {
-  gfx::Point location = host_->GetLocationOnNativeScreen();
-  point->Offset(-location.x(), -location.y());
-  ConvertPointFromHost(point);
-}
-
 void RootWindow::ConvertPointToHost(gfx::Point* point) const {
   gfx::Point3F point_3f(*point);
   GetRootTransform().TransformPoint(&point_3f);
   *point = gfx::ToFlooredPoint(point_3f.AsPointF());
 }
 
 void RootWindow::ConvertPointFromHost(gfx::Point* point) const {
   gfx::Point3F point_3f(*point);
   GetInverseRootTransform().TransformPoint(&point_3f);
   *point = gfx::ToFlooredPoint(point_3f.AsPointF());
 }
 
 void RootWindow::ProcessedTouchEvent(ui::TouchEvent* event,
                                      Window* window,
                                      ui::EventResult result) {
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
   gestures.reset(ui::GestureRecognizer::Get()->
       ProcessTouchEventForGesture(*event, result, window));
   DispatchDetails details = ProcessGestures(gestures.get());
   if (details.dispatcher_destroyed)
     return;
 }
 
-gfx::AcceleratedWidget RootWindow::GetAcceleratedWidget() {
-  return host_->GetAcceleratedWidget();
-}
-
-void RootWindow::ToggleFullScreen() {
-  host_->ToggleFullScreen();
-}
-
 void RootWindow::HoldPointerMoves() {
   if (!move_hold_count_)
     held_event_factory_.InvalidateWeakPtrs();
   ++move_hold_count_;
   TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::HoldPointerMoves", this);
 }
 
 void RootWindow::ReleasePointerMoves() {
   --move_hold_count_;
   DCHECK_GE(move_hold_count_, 0);
   if (!move_hold_count_ && held_move_event_) {
     // We don't want to call DispatchHeldEvents directly, because this might be
     // called from a deep stack while another event, in which case dispatching
     // another one may not be safe/expected.  Instead we post a task, that we
     // may cancel if HoldPointerMoves is called again before it executes.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&RootWindow::DispatchHeldEventsAsync,
                    held_event_factory_.GetWeakPtr()));
   }
   TRACE_EVENT_ASYNC_END0("ui", "RootWindow::HoldPointerMoves", this);
 }
 
-void RootWindow::SetFocusWhenShown(bool focused) {
-  host_->SetFocusWhenShown(focused);
-}
-
 gfx::Point RootWindow::GetLastMouseLocationInRoot() const {
   gfx::Point location = Env::GetInstance()->last_mouse_location();
   client::ScreenPositionClient* client =
       client::GetScreenPositionClient(window());
   if (client)
     client->ConvertPointFromScreen(window(), &location);
   return location;
 }
 
-bool RootWindow::QueryMouseLocationForTest(gfx::Point* point) const {
-  return host_->QueryMouseLocation(point);
-}
-
 void RootWindow::SetRootWindowTransformer(
     scoped_ptr<RootWindowTransformer> transformer) {
   transformer_ = transformer.Pass();
   host_->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(GetHostSize());
+    UpdateRootWindowSize(host_->GetBounds().size());
 }
 
 gfx::Transform RootWindow::GetRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(window()->layer());
   gfx::Transform transform;
   transform.Scale(scale, scale);
   transform *= transformer_->GetTransform();
   return transform;
 }
 
 void RootWindow::SetTransform(const gfx::Transform& transform) {
   scoped_ptr<RootWindowTransformer> transformer(
       new SimpleRootWindowTransformer(window(), transform));
   SetRootWindowTransformer(transformer.Pass());
 }
 
-void RootWindow::DeviceScaleFactorChanged(float device_scale_factor) {
-  host_->OnDeviceScaleFactorChanged(device_scale_factor);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
 void RootWindow::TransformEventForDeviceScaleFactor(ui::LocatedEvent* event) {
   event->UpdateForRootTransform(GetInverseRootTransform());
 }
 
 void RootWindow::MoveCursorToInternal(const gfx::Point& root_location,
                                       const gfx::Point& host_location) {
   host_->MoveCursorTo(host_location);
@@ skipping 184 matching lines @@
 
 void RootWindow::DispatchCancelTouchEvent(ui::TouchEvent* event) {
   OnHostTouchEvent(event);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::LayerAnimationObserver implementation:
 
 void RootWindow::OnLayerAnimationEnded(
     ui::LayerAnimationSequence* animation) {
-  UpdateRootWindowSize(GetHostSize());
+  UpdateRootWindowSize(host_->GetBounds().size());
 }
 
 void RootWindow::OnLayerAnimationScheduled(
     ui::LayerAnimationSequence* animation) {
 }
 
 void RootWindow::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* animation) {
 }
 
@@ skipping 131 matching lines @@
 }
 
 float RootWindow::GetDeviceScaleFactor() {
   return compositor()->device_scale_factor();
 }
 
 RootWindow* RootWindow::AsRootWindow() {
   return this;
 }
 
+const RootWindow* RootWindow::AsRootWindow() const {
+  return this;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
 ui::EventDispatchDetails RootWindow::OnHostMouseEventImpl(
     ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_DRAGGED ||
       (event->flags() & ui::EF_IS_SYNTHESIZED)) {
     if (move_hold_count_) {
       Window* null_window = static_cast<Window*>(NULL);
       held_move_event_.reset(
@@ skipping 266 matching lines @@
 }
 
 gfx::Transform RootWindow::GetInverseRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(window()->layer());
   gfx::Transform transform;
   transform.Scale(1.0f / scale, 1.0f / scale);
   return transformer_->GetInverseTransform() * transform;
 }
 
 }  // namespace aura