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

ash/mus/non_client_frame_controller.cc

 // Copyright 2015 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/non_client_frame_controller.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 94 matching lines @@
   void UpdateWindowTitle() override {}
   void SizeConstraintsChanged() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EmptyDraggableNonClientFrameView);
 };
 
 class WmNativeWidgetMus : public views::NativeWidgetMus {
  public:
   WmNativeWidgetMus(views::internal::NativeWidgetDelegate* delegate,
-                    ::ui::Window* window,
-                    ::ui::WindowManagerClient* window_manager_client)
-      : NativeWidgetMus(delegate,
-                        window,
-                        ::ui::mojom::SurfaceType::UNDERLAY),
+                    ui::Window* window,
+                    ui::WindowManagerClient* window_manager_client)
+      : NativeWidgetMus(delegate, window, ui::mojom::SurfaceType::UNDERLAY),
         window_manager_client_(window_manager_client) {}
   ~WmNativeWidgetMus() override {}
 
   // NativeWidgetMus:
   views::NonClientFrameView* CreateNonClientFrameView() override {
     move_event_handler_.reset(new MoveEventHandler(
         window(), window_manager_client_, GetNativeView()));
     if (ShouldRemoveStandardFrame(window()))
       return new EmptyDraggableNonClientFrameView();
     return new NonClientFrameViewMash(GetWidget(), window());
@@ skipping 29 matching lines @@
     // This pushes the client area to the WS. We don't want to do that as
     // the client area should come from the client, not us.
   }
 
  private:
   // The shadow, may be null.
   std::unique_ptr<Shadow> shadow_;
 
   std::unique_ptr<MoveEventHandler> move_event_handler_;
 
-  ::ui::WindowManagerClient* window_manager_client_;
+  ui::WindowManagerClient* window_manager_client_;
 
   DISALLOW_COPY_AND_ASSIGN(WmNativeWidgetMus);
 };
 
 class ClientViewMus : public views::ClientView {
  public:
   ClientViewMus(views::Widget* widget,
                 views::View* contents_view,
                 NonClientFrameController* frame_controller)
       : views::ClientView(widget, contents_view),
@@ skipping 13 matching lines @@
   NonClientFrameController* frame_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientViewMus);
 };
 
 }  // namespace
 
 // static
 void NonClientFrameController::Create(
     shell::Connector* connector,
-    ::ui::Window* parent,
-    ::ui::Window* window,
-    ::ui::WindowManagerClient* window_manager_client) {
+    ui::Window* parent,
+    ui::Window* window,
+    ui::WindowManagerClient* window_manager_client) {
   new NonClientFrameController(connector, parent, window,
                                window_manager_client);
 }
 
 // static
 gfx::Insets NonClientFrameController::GetPreferredClientAreaInsets() {
   return NonClientFrameViewMash::GetPreferredClientAreaInsets();
 }
 
 // static
 int NonClientFrameController::GetMaxTitleBarButtonWidth() {
   return NonClientFrameViewMash::GetMaxTitleBarButtonWidth();
 }
 
 NonClientFrameController::NonClientFrameController(
     shell::Connector* connector,
-    ::ui::Window* parent,
-    ::ui::Window* window,
-    ::ui::WindowManagerClient* window_manager_client)
+    ui::Window* parent,
+    ui::Window* window,
+    ui::WindowManagerClient* window_manager_client)
     : widget_(new views::Widget), window_(window) {
   WmWindowMus* wm_window = WmWindowMus::Get(window);
   wm_window->set_widget(widget_, WmWindowMus::WidgetCreationType::FOR_CLIENT);
   window_->AddObserver(this);
 
   // To simplify things this code creates a Widget. While a Widget is created
   // we need to ensure we don't inadvertently change random properties of the
   // underlying ui::Window. For example, showing the Widget shouldn't change
   // the bounds of the ui::Window in anyway.
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
@@ skipping 18 matching lines @@
       window, gfx::Vector2d(shadow_inset, shadow_inset), extended_hit_region);
 }
 
 NonClientFrameController::~NonClientFrameController() {
   if (window_)
     window_->RemoveObserver(this);
 }
 
 base::string16 NonClientFrameController::GetWindowTitle() const {
   if (!window_->HasSharedProperty(
-          ::ui::mojom::WindowManager::kWindowTitle_Property)) {
+          ui::mojom::WindowManager::kWindowTitle_Property)) {
     return base::string16();
   }
 
   base::string16 title = window_->GetSharedProperty<base::string16>(
-      ::ui::mojom::WindowManager::kWindowTitle_Property);
+      ui::mojom::WindowManager::kWindowTitle_Property);
 
   if (IsWindowJanky(window_))
     title += base::ASCIIToUTF16(" !! Not responding !!");
 
   return title;
 }
 
 views::View* NonClientFrameController::GetContentsView() {
   return this;
 }
 
 bool NonClientFrameController::CanResize() const {
   return window_ &&
-         (GetResizeBehavior(window_) & ::ui::mojom::kResizeBehaviorCanResize) !=
+         (GetResizeBehavior(window_) & ui::mojom::kResizeBehaviorCanResize) !=
              0;
 }
 
 bool NonClientFrameController::CanMaximize() const {
   return window_ &&
-         (GetResizeBehavior(window_) &
-          ::ui::mojom::kResizeBehaviorCanMaximize) != 0;
+         (GetResizeBehavior(window_) & ui::mojom::kResizeBehaviorCanMaximize) !=
+             0;
 }
 
 bool NonClientFrameController::CanMinimize() const {
   return window_ &&
-         (GetResizeBehavior(window_) &
-          ::ui::mojom::kResizeBehaviorCanMinimize) != 0;
+         (GetResizeBehavior(window_) & ui::mojom::kResizeBehaviorCanMinimize) !=
+             0;
 }
 
 bool NonClientFrameController::ShouldShowWindowTitle() const {
   // Only draw the title if the client hasn't declared any additional client
   // areas which might conflict with it.
   return window_ && window_->additional_client_areas().empty();
 }
 
 views::ClientView* NonClientFrameController::CreateClientView(
     views::Widget* widget) {
   return new ClientViewMus(widget, GetContentsView(), this);
 }
 
 void NonClientFrameController::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::kResizeBehavior_Property)
+  if (name == ui::mojom::WindowManager::kResizeBehavior_Property)
     widget_->OnSizeConstraintsChanged();
-  else if (name == ::ui::mojom::WindowManager::kWindowTitle_Property)
+  else if (name == ui::mojom::WindowManager::kWindowTitle_Property)
     widget_->UpdateWindowTitle();
 }
 
-void NonClientFrameController::OnWindowLocalPropertyChanged(
-    ::ui::Window* window,
-    const void* key,
-    intptr_t old) {
+void NonClientFrameController::OnWindowLocalPropertyChanged(ui::Window* window,
+                                                            const void* key,
+                                                            intptr_t old) {
   if (IsWindowJankyProperty(key)) {
     widget_->UpdateWindowTitle();
     widget_->non_client_view()->frame_view()->SchedulePaint();
   }
 }
 
-void NonClientFrameController::OnWindowDestroyed(::ui::Window* window) {
+void NonClientFrameController::OnWindowDestroyed(ui::Window* window) {
   window_->RemoveObserver(this);
   window_ = nullptr;
 }
 
 }  // namespace mus
 }  // namespace ash