Shell related switches -> aura shell switches.

ui/views/widget/native_widget_aura.cc

 // Copyright (c) 2011 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/native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
+#include "ui/aura/client/window_types.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
-#include "ui/aura/window_types.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/drop_helper.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/tooltip_manager_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/win_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #endif
 
 #if defined(HAVE_IBUS)
 #include "ui/views/ime/input_method_ibus.h"
 #else
 #include "ui/views/ime/mock_input_method.h"
 #endif
 
 namespace views {
 
 namespace {
 
-aura::WindowType GetAuraWindowTypeForWidgetType(Widget::InitParams::Type type) {
+aura::client::WindowType GetAuraWindowTypeForWidgetType(
+    Widget::InitParams::Type type) {
   switch (type) {
     case Widget::InitParams::TYPE_WINDOW:
-      return aura::WINDOW_TYPE_NORMAL;
+      return aura::client::WINDOW_TYPE_NORMAL;
     case Widget::InitParams::TYPE_WINDOW_FRAMELESS:
     case Widget::InitParams::TYPE_CONTROL:
     case Widget::InitParams::TYPE_POPUP:
     case Widget::InitParams::TYPE_BUBBLE:
-      return aura::WINDOW_TYPE_POPUP;
+      return aura::client::WINDOW_TYPE_POPUP;
     case Widget::InitParams::TYPE_MENU:
-      return aura::WINDOW_TYPE_MENU;
+      return aura::client::WINDOW_TYPE_MENU;
     case Widget::InitParams::TYPE_TOOLTIP:
-      return aura::WINDOW_TYPE_TOOLTIP;
+      return aura::client::WINDOW_TYPE_TOOLTIP;
     default:
       NOTREACHED() << "Unhandled widget type " << type;
-      return aura::WINDOW_TYPE_UNKNOWN;
+      return aura::client::WINDOW_TYPE_UNKNOWN;
   }
 }
 
 void NotifyLocaleChangedInternal(aura::Window* window) {
   Widget* widget = Widget::GetWidgetForNativeWindow(window);
   if (widget)
     widget->LocaleChanged();
 
   const aura::Window::Windows& children = window->children();
   for (aura::Window::Windows::const_iterator it = children.begin();
@@ skipping 12 matching lines @@
     aura::RootWindow::GetInstance()->AddObserver(this);
   }
   virtual ~ActiveWindowObserver() {
     aura::RootWindow::GetInstance()->RemoveObserver(this);
   }
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowPropertyChanged(aura::Window* window,
                                        const char* key,
                                        void* old) OVERRIDE {
-    if (key != aura::kRootWindowActiveWindow)
+    if (key != aura::client::kRootWindowActiveWindow)
       return;
     aura::Window* active =
         aura::client::GetActivationClient()->GetActiveWindow();
     if (!active || (active != host_->window_ &&
                     active->transient_parent() != host_->window_)) {
       host_->delegate_->EnableInactiveRendering();
     }
   }
 
  private:
@@ skipping 40 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, internal::NativeWidgetPrivate implementation:
 
 void NativeWidgetAura::InitNativeWidget(const Widget::InitParams& params) {
   ownership_ = params.ownership;
   window_->set_user_data(this);
   Widget::InitParams::Type window_type =
       params.child ? Widget::InitParams::TYPE_CONTROL : params.type;
   window_->SetType(GetAuraWindowTypeForWidgetType(window_type));
   // TODO(jamescook): Should this use params.show_state instead?
-  window_->SetIntProperty(aura::kShowStateKey, ui::SHOW_STATE_NORMAL);
+  window_->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   window_->Init(params.create_texture_for_layer ?
                     ui::Layer::LAYER_HAS_TEXTURE :
                     ui::Layer::LAYER_HAS_NO_TEXTURE);
   if (window_type == Widget::InitParams::TYPE_CONTROL)
     window_->Show();
 
   window_->layer()->SetFillsBoundsOpaquely(!params.transparent);
   delegate_->OnNativeWidgetCreated();
   window_->SetBounds(params.bounds);
   if (window_type == Widget::InitParams::TYPE_CONTROL) {
@@ skipping 146 matching lines @@
                                size.width(),
                                size.height()));
 }
 
 void NativeWidgetAura::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   // The interface specifies returning restored bounds, not current bounds.
   *bounds = GetRestoredBounds();
   *show_state = static_cast<ui::WindowShowState>(
-      window_->GetIntProperty(aura::kShowStateKey));
+      window_->GetIntProperty(aura::client::kShowStateKey));
 }
 
 void NativeWidgetAura::SetWindowTitle(const string16& title) {
   window_->set_title(title);
 }
 
 void NativeWidgetAura::SetWindowIcons(const SkBitmap& window_icon,
                                      const SkBitmap& app_icon) {
   // Aura doesn't have window icons.
 }
 
 void NativeWidgetAura::SetAccessibleName(const string16& name) {
   // http://crbug.com/102570
   //NOTIMPLEMENTED();
 }
 
 void NativeWidgetAura::SetAccessibleRole(ui::AccessibilityTypes::Role role) {
   // http://crbug.com/102570
   //NOTIMPLEMENTED();
 }
 
 void NativeWidgetAura::SetAccessibleState(ui::AccessibilityTypes::State state) {
   // http://crbug.com/102570
   //NOTIMPLEMENTED();
 }
 
 void NativeWidgetAura::BecomeModal() {
-  window_->SetIntProperty(aura::kModalKey, 1);
+  window_->SetIntProperty(aura::client::kModalKey, 1);
 }
 
 gfx::Rect NativeWidgetAura::GetWindowScreenBounds() const {
   return window_->GetScreenBounds();
 }
 
 gfx::Rect NativeWidgetAura::GetClientAreaScreenBounds() const {
   // In Aura, the entire window is the client area.
   return window_->GetScreenBounds();
 }
 
 gfx::Rect NativeWidgetAura::GetRestoredBounds() const {
   gfx::Rect* restore_bounds = reinterpret_cast<gfx::Rect*>(
-      window_->GetProperty(aura::kRestoreBoundsKey));
+      window_->GetProperty(aura::client::kRestoreBoundsKey));
   return restore_bounds ? *restore_bounds : window_->bounds();
 }
 
 void NativeWidgetAura::SetBounds(const gfx::Rect& bounds) {
   window_->SetBounds(bounds);
 }
 
 void NativeWidgetAura::SetSize(const gfx::Size& size) {
   window_->SetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
@@ skipping 12 matching lines @@
 }
 
 void NativeWidgetAura::Close() {
   // |window_| may already be deleted by parent window. This can happen
   // when this widget is child widget or has transient parent
   // and ownership is WIDGET_OWNS_NATIVE_WIDGET.
   DCHECK(window_ ||
          ownership_ == Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   if (window_) {
     Hide();
-    window_->SetIntProperty(aura::kModalKey, 0);
+    window_->SetIntProperty(aura::client::kModalKey, 0);
   }
 
   if (!close_widget_factory_.HasWeakPtrs()) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&NativeWidgetAura::CloseNow,
                    close_widget_factory_.GetWeakPtr()));
   }
 }
 
@@ skipping 11 matching lines @@
 
 void NativeWidgetAura::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   window_->SetBounds(restored_bounds);
   ShowWithWindowState(ui::SHOW_STATE_MAXIMIZED);
 }
 
 void NativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
   if (state == ui::SHOW_STATE_MAXIMIZED ||
       state == ui::SHOW_STATE_FULLSCREEN) {
-    window_->SetIntProperty(aura::kShowStateKey, state);
+    window_->SetIntProperty(aura::client::kShowStateKey, state);
   }
   window_->Show();
   if (can_activate_ && (state != ui::SHOW_STATE_INACTIVE ||
                         !GetWidget()->SetInitialFocus())) {
     Activate();
   }
 }
 
 bool NativeWidgetAura::IsVisible() const {
   return window_->IsVisible();
 }
 
 void NativeWidgetAura::Activate() {
   aura::client::GetActivationClient()->ActivateWindow(window_);
 }
 
 void NativeWidgetAura::Deactivate() {
   aura::client::GetActivationClient()->DeactivateWindow(window_);
 }
 
 bool NativeWidgetAura::IsActive() const {
   return aura::client::GetActivationClient()->GetActiveWindow() == window_;
 }
 
 void NativeWidgetAura::SetAlwaysOnTop(bool on_top) {
-  window_->SetIntProperty(aura::kAlwaysOnTopKey, on_top);
+  window_->SetIntProperty(aura::client::kAlwaysOnTopKey, on_top);
 }
 
 void NativeWidgetAura::Maximize() {
-  window_->SetIntProperty(aura::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
+  window_->SetIntProperty(aura::client::kShowStateKey,
+                          ui::SHOW_STATE_MAXIMIZED);
 }
 
 void NativeWidgetAura::Minimize() {
   // No minimized window for aura. crbug.com/104571.
   NOTREACHED();
 }
 
 bool NativeWidgetAura::IsMaximized() const {
-  return window_->GetIntProperty(aura::kShowStateKey) ==
+  return window_->GetIntProperty(aura::client::kShowStateKey) ==
       ui::SHOW_STATE_MAXIMIZED;
 }
 
 bool NativeWidgetAura::IsMinimized() const {
-  return window_->GetIntProperty(aura::kShowStateKey) ==
+  return window_->GetIntProperty(aura::client::kShowStateKey) ==
       ui::SHOW_STATE_MINIMIZED;
 }
 
 void NativeWidgetAura::Restore() {
-  window_->SetIntProperty(aura::kShowStateKey, ui::SHOW_STATE_NORMAL);
+  window_->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 }
 
 void NativeWidgetAura::SetFullscreen(bool fullscreen) {
   window_->SetIntProperty(
-      aura::kShowStateKey,
+      aura::client::kShowStateKey,
       fullscreen ? ui::SHOW_STATE_FULLSCREEN : ui::SHOW_STATE_NORMAL);
 }
 
 bool NativeWidgetAura::IsFullscreen() const {
-  return window_->GetIntProperty(aura::kShowStateKey) ==
+  return window_->GetIntProperty(aura::client::kShowStateKey) ==
       ui::SHOW_STATE_FULLSCREEN;
 }
 
 void NativeWidgetAura::SetOpacity(unsigned char opacity) {
   window_->layer()->SetOpacity(opacity / 255.0);
 }
 
 void NativeWidgetAura::SetUseDragFrame(bool use_drag_frame) {
   NOTIMPLEMENTED();
 }
@@ skipping 350 matching lines @@
   }
 }
 
 // static
 bool NativeWidgetPrivate::IsMouseButtonDown() {
   return aura::RootWindow::GetInstance()->IsMouseButtonDown();
 }
 
 }  // namespace internal
 }  // namespace views