Move wm/core to wm namespace.

ui/views/widget/desktop_aura/desktop_native_widget_aura.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/views/widget/desktop_aura/desktop_native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 225 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowDestructionObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, public:
 
 int DesktopNativeWidgetAura::cursor_reference_count_ = 0;
 DesktopNativeCursorManager* DesktopNativeWidgetAura::native_cursor_manager_ =
     NULL;
-views::corewm::CursorManager* DesktopNativeWidgetAura::cursor_manager_ = NULL;
+wm::CursorManager* DesktopNativeWidgetAura::cursor_manager_ = NULL;
 
 DesktopNativeWidgetAura::DesktopNativeWidgetAura(
     internal::NativeWidgetDelegate* delegate)
     : desktop_window_tree_host_(NULL),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       close_widget_factory_(this),
       can_activate_(true),
       content_window_container_(NULL),
       content_window_(new aura::Window(this)),
       native_widget_delegate_(delegate),
@@ skipping 137 matching lines @@
   NativeWidgetAura::RegisterNativeWidgetForWindow(this, content_window_);
   // Animations on TYPE_WINDOW are handled by the OS. Additionally if we animate
   // these windows the size of the window gets augmented, effecting restore
   // bounds and maximized windows in bad ways.
   if (params.type == Widget::InitParams::TYPE_WINDOW &&
       !params.remove_standard_frame) {
     content_window_->SetProperty(aura::client::kAnimationsDisabledKey, true);
   }
   content_window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
   content_window_->Init(params.layer_type);
-  corewm::SetShadowType(content_window_, corewm::SHADOW_TYPE_NONE);
+  wm::SetShadowType(content_window_, wm::SHADOW_TYPE_NONE);
 
   content_window_container_ = new aura::Window(NULL);
   content_window_container_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   content_window_container_->Show();
   content_window_container_->AddChild(content_window_);
 
   desktop_window_tree_host_ = params.desktop_window_tree_host ?
       params.desktop_window_tree_host :
       DesktopWindowTreeHost::Create(native_widget_delegate_, this);
   host_.reset(desktop_window_tree_host_->AsWindowTreeHost());
   desktop_window_tree_host_->Init(content_window_, params);
 
   // Mark this window as Desktop root window.
   host_->window()->SetProperty(views::kDesktopRootWindow, true);
 
   host_->InitHost();
   host_->window()->AddChild(content_window_container_);
   host_->window()->SetProperty(kDesktopNativeWidgetAuraKey, this);
 
   host_->window()->AddObserver(new RootWindowDestructionObserver(this));
 
   // The WindowsModalityController event filter should be at the head of the
   // pre target handlers list. This ensures that it handles input events first
   // when modal windows are at the top of the Zorder.
   if (widget_type_ == Widget::InitParams::TYPE_WINDOW)
     window_modality_controller_.reset(
-        new views::corewm::WindowModalityController(host_->window()));
+        new wm::WindowModalityController(host_->window()));
 
   // |root_window_event_filter_| must be created before
   // OnWindowTreeHostCreated() is invoked.
 
   // CEF sets focus to the window the user clicks down on.
   // TODO(beng): see if we can't do this some other way. CEF seems a heavy-
   //             handed way of accomplishing focus.
   // No event filter for aura::Env. Create CompoundEvnetFilter per
   // WindowEventDispatcher.
-  root_window_event_filter_ = new corewm::CompoundEventFilter;
+  root_window_event_filter_ = new wm::CompoundEventFilter;
   // Pass ownership of the filter to the root_window.
   host_->window()->SetEventFilter(root_window_event_filter_);
 
   // The host's dispatcher must be added to |native_cursor_manager_| before
   // OnNativeWidgetCreated() is called.
   cursor_reference_count_++;
   if (!native_cursor_manager_) {
     native_cursor_manager_ = new DesktopNativeCursorManager(
         DesktopCursorLoaderUpdater::Create());
   }
   if (!cursor_manager_) {
-    cursor_manager_ = new views::corewm::CursorManager(
-        scoped_ptr<corewm::NativeCursorManager>(native_cursor_manager_));
+    cursor_manager_ = new wm::CursorManager(
+        scoped_ptr<wm::NativeCursorManager>(native_cursor_manager_));
   }
   native_cursor_manager_->AddHost(host());
   aura::client::SetCursorClient(host_->window(), cursor_manager_);
 
   desktop_window_tree_host_->OnNativeWidgetCreated(params);
 
   UpdateWindowTransparency();
 
   capture_client_.reset(new DesktopCaptureClient(host_->window()));
 
-  corewm::FocusController* focus_controller =
-      new corewm::FocusController(new DesktopFocusRules(content_window_));
+  wm::FocusController* focus_controller =
+      new wm::FocusController(new DesktopFocusRules(content_window_));
   focus_client_.reset(focus_controller);
   aura::client::SetFocusClient(host_->window(), focus_controller);
   aura::client::SetActivationClient(host_->window(), focus_controller);
   host_->window()->AddPreTargetHandler(focus_controller);
 
   dispatcher_client_.reset(new DesktopDispatcherClient);
   aura::client::SetDispatcherClient(host_->window(),
                                     dispatcher_client_.get());
 
   position_client_.reset(new DesktopScreenPositionClient(host_->window()));
@@ skipping 21 matching lines @@
   tooltip_manager_.reset(new TooltipManagerAura(GetWidget()));
 
   tooltip_controller_.reset(
       new corewm::TooltipController(
           desktop_window_tree_host_->CreateTooltip()));
   aura::client::SetTooltipClient(host_->window(),
                                  tooltip_controller_.get());
   host_->window()->AddPreTargetHandler(tooltip_controller_.get());
 
   if (params.opacity == Widget::InitParams::TRANSLUCENT_WINDOW) {
-    visibility_controller_.reset(new views::corewm::VisibilityController);
+    visibility_controller_.reset(new wm::VisibilityController);
     aura::client::SetVisibilityClient(host_->window(),
                                       visibility_controller_.get());
-    views::corewm::SetChildWindowVisibilityChangesAnimated(host_->window());
-    views::corewm::SetChildWindowVisibilityChangesAnimated(
+    wm::SetChildWindowVisibilityChangesAnimated(host_->window());
+    wm::SetChildWindowVisibilityChangesAnimated(
         content_window_container_);
   }
 
   if (params.type == Widget::InitParams::TYPE_WINDOW) {
     focus_manager_event_handler_.reset(new FocusManagerEventHandler(this));
     host_->window()->AddPreTargetHandler(focus_manager_event_handler_.get());
   }
 
   event_client_.reset(new DesktopEventClient);
   aura::client::SetEventClient(host_->window(), event_client_.get());
 
   aura::client::GetFocusClient(content_window_)->FocusWindow(content_window_);
 
   aura::client::SetActivationDelegate(content_window_, this);
 
-  shadow_controller_.reset(new corewm::ShadowController(
+  shadow_controller_.reset(new wm::ShadowController(
       aura::client::GetActivationClient(host_->window())));
 
   content_window_->SetProperty(aura::client::kCanMaximizeKey,
                                GetWidget()->widget_delegate()->CanMaximize());
   content_window_->SetProperty(aura::client::kCanResizeKey,
                                GetWidget()->widget_delegate()->CanResize());
 
   window_reorderer_.reset(new WindowReorderer(content_window_,
       GetWidget()->GetRootView()));
 }
@@ skipping 627 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, NativeWidget implementation:
 
 ui::EventHandler* DesktopNativeWidgetAura::GetEventHandler() {
   return this;
 }
 
 void DesktopNativeWidgetAura::InstallInputMethodEventFilter() {
   DCHECK(!input_method_event_filter_.get());
 
-  input_method_event_filter_.reset(new corewm::InputMethodEventFilter(
+  input_method_event_filter_.reset(new wm::InputMethodEventFilter(
       host_->GetAcceleratedWidget()));
   input_method_event_filter_->SetInputMethodPropertyInRootWindow(
       host_->window());
   root_window_event_filter_->AddHandler(input_method_event_filter_.get());
 }
 
 void DesktopNativeWidgetAura::UpdateWindowTransparency() {
   content_window_->SetTransparent(
       desktop_window_tree_host_->ShouldWindowContentsBeTransparent());
 }
 
 void DesktopNativeWidgetAura::RootWindowDestroyed() {
   cursor_reference_count_--;
   if (cursor_reference_count_ == 0) {
     // We are the last DesktopNativeWidgetAura instance, and we are responsible
     // for cleaning up |cursor_manager_|.
     delete cursor_manager_;
     native_cursor_manager_ = NULL;
     cursor_manager_ = NULL;
   }
 }
 
 }  // namespace views