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

ash/mus/accelerators/accelerator_registrar_impl.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/accelerators/accelerator_registrar_impl.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/window_manager.h"
 #include "base/bind.h"
 #include "services/ui/public/cpp/window_manager_delegate.h"
 #include "ui/events/event.h"
 
 namespace ash {
 namespace mus {
 
 namespace {
 
 void CallAddAcceleratorCallback(
-    const ::ui::mojom::AcceleratorRegistrar::AddAcceleratorCallback& callback,
+    const ui::mojom::AcceleratorRegistrar::AddAcceleratorCallback& callback,
     bool result) {
   callback.Run(result);
 }
 
 // Returns true if |event_matcher| corresponds to matching an Accelerator.
 bool IsMatcherForKeyAccelerator(const ui::mojom::EventMatcher& event_matcher) {
   return (
       event_matcher.accelerator_phase ==
           ui::mojom::AcceleratorPhase::PRE_TARGET &&
       event_matcher.type_matcher &&
@@ skipping 86 matching lines @@
 
   WmShell::Get()->accelerator_controller()->UnregisterAll(this);
   keyboard_accelerator_to_id_.clear();
   id_to_keyboard_accelerator_.clear();
 
   accelerators_.clear();
 }
 
 bool AcceleratorRegistrarImpl::AddAcceleratorForKeyBinding(
     uint32_t accelerator_id,
-    const ::ui::mojom::EventMatcher& matcher,
+    const ui::mojom::EventMatcher& matcher,
     const AddAcceleratorCallback& callback) {
   if (!IsMatcherForKeyAccelerator(matcher))
     return false;
 
   const ui::Accelerator accelerator = EventMatcherToAccelerator(matcher);
   if (keyboard_accelerator_to_id_.count(accelerator)) {
     callback.Run(false);
     return true;
   }
 
@@ skipping 13 matching lines @@
 
   const uint16_t local_id = GetAcceleratorLocalId(accelerator_id);
   keyboard_accelerator_to_id_[accelerator] = local_id;
   id_to_keyboard_accelerator_[local_id] = accelerator;
   accelerator_controller->Register(accelerator, this);
   callback.Run(true);
   return true;
 }
 
 void AcceleratorRegistrarImpl::SetHandler(
-    ::ui::mojom::AcceleratorHandlerPtr handler) {
+    ui::mojom::AcceleratorHandlerPtr handler) {
   accelerator_handler_ = std::move(handler);
   accelerator_handler_.set_connection_error_handler(base::Bind(
       &AcceleratorRegistrarImpl::OnHandlerGone, base::Unretained(this)));
 }
 
 void AcceleratorRegistrarImpl::AddAccelerator(
     uint32_t accelerator_id,
-    ::ui::mojom::EventMatcherPtr matcher,
+    ui::mojom::EventMatcherPtr matcher,
     const AddAcceleratorCallback& callback) {
   if (!accelerator_handler_ || accelerator_id > 0xFFFF) {
     // The |accelerator_id| is too large, and it can't be handled correctly.
     callback.Run(false);
     DVLOG(1) << "AddAccelerator failed because of bogus id";
     return;
   }
 
   uint32_t namespaced_accelerator_id = ComputeAcceleratorId(
       accelerator_namespace_, static_cast<uint16_t>(accelerator_id));
@@ skipping 69 matching lines @@
                                       ui::Event::Clone(key_event));
   return true;
 }
 
 bool AcceleratorRegistrarImpl::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace mus
 }  // namespace ash