Replaces ::ui:: with ui:: in ash

ash/mus/bridge/wm_window_mus.cc

 // Copyright 2016 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 "ash/mus/bridge/wm_window_mus.h"
 
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_layout_manager.h"
 #include "ash/common/wm_window_observer.h"
@@ skipping 39 matching lines @@
 // WindowState.
 class WindowStateMus : public wm::WindowState {
  public:
   explicit WindowStateMus(WmWindow* window) : wm::WindowState(window) {}
   ~WindowStateMus() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowStateMus);
 };
 
-ui::WindowShowState UIWindowShowStateFromMojom(::ui::mojom::ShowState state) {
+ui::WindowShowState UIWindowShowStateFromMojom(ui::mojom::ShowState state) {
   switch (state) {
-    case ::ui::mojom::ShowState::DEFAULT:
+    case ui::mojom::ShowState::DEFAULT:
       return ui::SHOW_STATE_DEFAULT;
-    case ::ui::mojom::ShowState::NORMAL:
+    case ui::mojom::ShowState::NORMAL:
       return ui::SHOW_STATE_NORMAL;
-    case ::ui::mojom::ShowState::MINIMIZED:
+    case ui::mojom::ShowState::MINIMIZED:
       return ui::SHOW_STATE_MINIMIZED;
-    case ::ui::mojom::ShowState::MAXIMIZED:
+    case ui::mojom::ShowState::MAXIMIZED:
       return ui::SHOW_STATE_MAXIMIZED;
-    case ::ui::mojom::ShowState::INACTIVE:
+    case ui::mojom::ShowState::INACTIVE:
       return ui::SHOW_STATE_INACTIVE;
-    case ::ui::mojom::ShowState::FULLSCREEN:
+    case ui::mojom::ShowState::FULLSCREEN:
       return ui::SHOW_STATE_FULLSCREEN;
-    case ::ui::mojom::ShowState::DOCKED:
+    case ui::mojom::ShowState::DOCKED:
       return ui::SHOW_STATE_DOCKED;
     default:
       break;
   }
   return ui::SHOW_STATE_DEFAULT;
 }
 
-::ui::mojom::ShowState MojomWindowShowStateFromUI(ui::WindowShowState state) {
+ui::mojom::ShowState MojomWindowShowStateFromUI(ui::WindowShowState state) {
   switch (state) {
     case ui::SHOW_STATE_DEFAULT:
-      return ::ui::mojom::ShowState::DEFAULT;
+      return ui::mojom::ShowState::DEFAULT;
     case ui::SHOW_STATE_NORMAL:
-      return ::ui::mojom::ShowState::NORMAL;
+      return ui::mojom::ShowState::NORMAL;
     case ui::SHOW_STATE_MINIMIZED:
-      return ::ui::mojom::ShowState::MINIMIZED;
+      return ui::mojom::ShowState::MINIMIZED;
     case ui::SHOW_STATE_MAXIMIZED:
-      return ::ui::mojom::ShowState::MAXIMIZED;
+      return ui::mojom::ShowState::MAXIMIZED;
     case ui::SHOW_STATE_INACTIVE:
-      return ::ui::mojom::ShowState::INACTIVE;
+      return ui::mojom::ShowState::INACTIVE;
     case ui::SHOW_STATE_FULLSCREEN:
-      return ::ui::mojom::ShowState::FULLSCREEN;
+      return ui::mojom::ShowState::FULLSCREEN;
     case ui::SHOW_STATE_DOCKED:
-      return ::ui::mojom::ShowState::DOCKED;
+      return ui::mojom::ShowState::DOCKED;
     default:
       break;
   }
-  return ::ui::mojom::ShowState::DEFAULT;
+  return ui::mojom::ShowState::DEFAULT;
 }
 
 }  // namespace
 
-WmWindowMus::WmWindowMus(::ui::Window* window)
+WmWindowMus::WmWindowMus(ui::Window* window)
     : window_(window),
       // Matches aura, see aura::Window for details.
       observers_(base::ObserverList<WmWindowObserver>::NOTIFY_EXISTING_ONLY) {
   window_->AddObserver(this);
   window_->SetLocalProperty(kWmWindowKey, this);
   window_state_.reset(new WindowStateMus(this));
 }
 
 WmWindowMus::~WmWindowMus() {
   window_->RemoveObserver(this);
 }
 
 // static
-WmWindowMus* WmWindowMus::Get(::ui::Window* window) {
+WmWindowMus* WmWindowMus::Get(ui::Window* window) {
   if (!window)
     return nullptr;
 
   WmWindowMus* wm_window = window->GetLocalProperty(kWmWindowKey);
   if (wm_window)
     return wm_window;
   // WmWindowMus is owned by the ui::Window.
   return new WmWindowMus(window);
 }
 
 // static
 WmWindowMus* WmWindowMus::Get(views::Widget* widget) {
   return WmWindowMus::Get(aura::GetMusWindow(widget->GetNativeView()));
 }
 
 // static
-const ::ui::Window* WmWindowMus::GetMusWindow(const WmWindow* wm_window) {
+const ui::Window* WmWindowMus::GetMusWindow(const WmWindow* wm_window) {
   return static_cast<const WmWindowMus*>(wm_window)->mus_window();
 }
 
 // static
 std::vector<WmWindow*> WmWindowMus::FromMusWindows(
-    const std::vector<::ui::Window*>& mus_windows) {
+    const std::vector<ui::Window*>& mus_windows) {
   std::vector<WmWindow*> result(mus_windows.size());
   for (size_t i = 0; i < mus_windows.size(); ++i)
     result[i] = Get(mus_windows[i]);
   return result;
 }
 
 const WmRootWindowControllerMus* WmWindowMus::GetRootWindowControllerMus()
     const {
   return WmRootWindowControllerMus::Get(window_->GetRoot());
 }
@@ skipping 15 matching lines @@
   return GetRootWindowControllerMus();
 }
 
 WmShell* WmWindowMus::GetShell() const {
   return WmShellMus::Get();
 }
 
 void WmWindowMus::SetName(const char* name) {
   if (name) {
     window_->SetSharedProperty<std::string>(
-        ::ui::mojom::WindowManager::kName_Property, std::string(name));
+        ui::mojom::WindowManager::kName_Property, std::string(name));
   } else {
-    window_->ClearSharedProperty(::ui::mojom::WindowManager::kName_Property);
+    window_->ClearSharedProperty(ui::mojom::WindowManager::kName_Property);
   }
 }
 
 std::string WmWindowMus::GetName() const {
-  return window_->HasSharedProperty(::ui::mojom::WindowManager::kName_Property)
+  return window_->HasSharedProperty(ui::mojom::WindowManager::kName_Property)
              ? window_->GetSharedProperty<std::string>(
-                   ::ui::mojom::WindowManager::kName_Property)
+                   ui::mojom::WindowManager::kName_Property)
              : std::string();
 }
 
 base::string16 WmWindowMus::GetTitle() const {
   return GetWindowTitle(window_);
 }
 
 void WmWindowMus::SetShellWindowId(int id) {
   shell_window_id_ = id;
 }
@@ skipping 20 matching lines @@
 bool WmWindowMus::HasNonClientArea() {
   return widget_ ? true : false;
 }
 
 int WmWindowMus::GetNonClientComponent(const gfx::Point& location) {
   return widget_ ? widget_->GetNonClientComponent(location) : HTNOWHERE;
 }
 
 gfx::Point WmWindowMus::ConvertPointToTarget(const WmWindow* target,
                                              const gfx::Point& point) const {
-  const ::ui::Window* target_window = GetMusWindow(target);
+  const ui::Window* target_window = GetMusWindow(target);
   if (target_window->Contains(window_)) {
     gfx::Point result(point);
-    const ::ui::Window* window = window_;
+    const ui::Window* window = window_;
     while (window != target_window) {
       result += window->bounds().origin().OffsetFromOrigin();
       window = window->parent();
     }
     return result;
   }
   if (window_->Contains(target_window)) {
     gfx::Point result(point);
     result -=
         target->ConvertPointToTarget(this, gfx::Point()).OffsetFromOrigin();
@@ skipping 327 matching lines @@
 void WmWindowMus::StackChildAtTop(WmWindow* child) {
   GetMusWindow(child)->MoveToFront();
 }
 
 void WmWindowMus::StackChildAtBottom(WmWindow* child) {
   GetMusWindow(child)->MoveToBack();
 }
 
 void WmWindowMus::StackChildAbove(WmWindow* child, WmWindow* target) {
   GetMusWindow(child)->Reorder(GetMusWindow(target),
-                               ::ui::mojom::OrderDirection::ABOVE);
+                               ui::mojom::OrderDirection::ABOVE);
 }
 
 void WmWindowMus::StackChildBelow(WmWindow* child, WmWindow* target) {
   GetMusWindow(child)->Reorder(GetMusWindow(target),
-                               ::ui::mojom::OrderDirection::BELOW);
+                               ui::mojom::OrderDirection::BELOW);
 }
 
 void WmWindowMus::SetAlwaysOnTop(bool value) {
   mus::SetAlwaysOnTop(window_, value);
 }
 
 bool WmWindowMus::IsAlwaysOnTop() const {
   return mus::IsAlwaysOnTop(window_);
 }
 
@@ skipping 20 matching lines @@
     window_->RequestClose();
   else
     widget_->Close();
 }
 
 bool WmWindowMus::IsFocused() const {
   return window_->HasFocus();
 }
 
 bool WmWindowMus::IsActive() const {
-  ::ui::Window* focused = window_->window_tree()->GetFocusedWindow();
+  ui::Window* focused = window_->window_tree()->GetFocusedWindow();
   return focused && window_->Contains(focused);
 }
 
 void WmWindowMus::Activate() {
   window_->SetFocus();
   WmWindow* top_level = GetToplevelWindow();
   if (!top_level)
     return;
 
   // TODO(sky): mus should do this too.
   GetMusWindow(top_level)->MoveToFront();
 }
 
 void WmWindowMus::Deactivate() {
   if (IsActive())
     window_->window_tree()->ClearFocus();
 }
 
 void WmWindowMus::SetFullscreen() {
-  SetWindowShowState(window_, ::ui::mojom::ShowState::FULLSCREEN);
+  SetWindowShowState(window_, ui::mojom::ShowState::FULLSCREEN);
 }
 
 void WmWindowMus::Maximize() {
-  SetWindowShowState(window_, ::ui::mojom::ShowState::MAXIMIZED);
+  SetWindowShowState(window_, ui::mojom::ShowState::MAXIMIZED);
 }
 
 void WmWindowMus::Minimize() {
-  SetWindowShowState(window_, ::ui::mojom::ShowState::MINIMIZED);
+  SetWindowShowState(window_, ui::mojom::ShowState::MINIMIZED);
 }
 
 void WmWindowMus::Unminimize() {
   SetWindowShowState(window_, MojomWindowShowStateFromUI(restore_show_state_));
   restore_show_state_ = ui::SHOW_STATE_DEFAULT;
 }
 
 void WmWindowMus::SetExcludedFromMru(bool excluded_from_mru) {
   NOTIMPLEMENTED();
 }
 
 std::vector<WmWindow*> WmWindowMus::GetChildren() {
   return FromMusWindows(window_->children());
 }
 
 WmWindow* WmWindowMus::GetChildByShellWindowId(int id) {
   if (id == shell_window_id_)
     return this;
-  for (::ui::Window* child : window_->children()) {
+  for (ui::Window* child : window_->children()) {
     WmWindow* result = Get(child)->GetChildByShellWindowId(id);
     if (result)
       return result;
   }
   return nullptr;
 }
 
 void WmWindowMus::ShowResizeShadow(int component) {
   NOTIMPLEMENTED();
 }
@@ skipping 76 matching lines @@
 
 void WmWindowMus::OnTreeChanged(const TreeChangeParams& params) {
   WmWindowObserver::TreeChangeParams wm_params;
   wm_params.target = Get(params.target);
   wm_params.new_parent = Get(params.new_parent);
   wm_params.old_parent = Get(params.old_parent);
   FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowTreeChanged(this, wm_params));
 }
 
-void WmWindowMus::OnWindowReordered(::ui::Window* window,
-                                    ::ui::Window* relative_window,
-                                    ::ui::mojom::OrderDirection direction) {
+void WmWindowMus::OnWindowReordered(ui::Window* window,
+                                    ui::Window* relative_window,
+                                    ui::mojom::OrderDirection direction) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowStackingChanged(this));
 }
 
 void WmWindowMus::OnWindowSharedPropertyChanged(
-    ::ui::Window* window,
+    ui::Window* window,
     const std::string& name,
     const std::vector<uint8_t>* old_data,
     const std::vector<uint8_t>* new_data) {
-  if (name == ::ui::mojom::WindowManager::kShowState_Property) {
+  if (name == ui::mojom::WindowManager::kShowState_Property) {
     GetWindowState()->OnWindowShowStateChanged();
     return;
   }
-  if (name == ::ui::mojom::WindowManager::kAlwaysOnTop_Property) {
+  if (name == ui::mojom::WindowManager::kAlwaysOnTop_Property) {
     FOR_EACH_OBSERVER(
         WmWindowObserver, observers_,
         OnWindowPropertyChanged(this, WmWindowProperty::ALWAYS_ON_TOP));
     return;
   }
 
   // Deal with snap to pixel.
   NOTIMPLEMENTED();
 }
 
-void WmWindowMus::OnWindowBoundsChanged(::ui::Window* window,
+void WmWindowMus::OnWindowBoundsChanged(ui::Window* window,
                                         const gfx::Rect& old_bounds,
                                         const gfx::Rect& new_bounds) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowBoundsChanged(this, old_bounds, new_bounds));
 }
 
-void WmWindowMus::OnWindowDestroying(::ui::Window* window) {
+void WmWindowMus::OnWindowDestroying(ui::Window* window) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_, OnWindowDestroying(this));
 }
 
-void WmWindowMus::OnWindowDestroyed(::ui::Window* window) {
+void WmWindowMus::OnWindowDestroyed(ui::Window* window) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_, OnWindowDestroyed(this));
 }
 
 }  // namespace mus
 }  // namespace ash