Moves mash/wm into ash/mus

ash/mus/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 "mash/wm/accelerator_registrar_impl.h"
+#include "ash/mus/accelerator_registrar_impl.h"
 
 #include <stdint.h>
 #include <utility>
 
+#include "ash/mus/root_window_controller.h"
+#include "ash/mus/window_manager.h"
+#include "ash/mus/window_manager_application.h"
 #include "base/bind.h"
 #include "components/mus/public/cpp/window_manager_delegate.h"
-#include "mash/wm/root_window_controller.h"
-#include "mash/wm/window_manager.h"
-#include "mash/wm/window_manager_application.h"
 
-namespace mash {
-namespace wm {
+namespace ash {
+namespace mus {
 
 namespace {
 const int kAcceleratorIdMask = 0xffff;
 
 void OnAcceleratorAdded(bool result) {}
 void CallAddAcceleratorCallback(
-    const mus::mojom::AcceleratorRegistrar::AddAcceleratorCallback& callback,
+    const ::mus::mojom::AcceleratorRegistrar::AddAcceleratorCallback& callback,
     bool result) {
   callback.Run(result);
 }
 
 }  // namespace
 
 struct AcceleratorRegistrarImpl::Accelerator {
-  mus::mojom::EventMatcherPtr event_matcher;
+  ::mus::mojom::EventMatcherPtr event_matcher;
   AddAcceleratorCallback callback;
   bool callback_used = false;
 };
 
 AcceleratorRegistrarImpl::AcceleratorRegistrarImpl(
     WindowManagerApplication* wm_app,
     uint32_t accelerator_namespace,
     mojo::InterfaceRequest<AcceleratorRegistrar> request,
     const DestroyCallback& destroy_callback)
     : wm_app_(wm_app),
       binding_(this, std::move(request)),
       accelerator_namespace_(accelerator_namespace & 0xffff),
       destroy_callback_(destroy_callback) {
   wm_app_->AddRootWindowsObserver(this);
   binding_.set_connection_error_handler(base::Bind(
       &AcceleratorRegistrarImpl::OnBindingGone, base::Unretained(this)));
 }
 
 void AcceleratorRegistrarImpl::Destroy() {
   delete this;
 }
 
 bool AcceleratorRegistrarImpl::OwnsAccelerator(uint32_t accelerator_id) const {
   return !!accelerators_.count(accelerator_id);
 }
 
-void AcceleratorRegistrarImpl::ProcessAccelerator(uint32_t accelerator_id,
-                                                  mus::mojom::EventPtr event) {
+void AcceleratorRegistrarImpl::ProcessAccelerator(
+    uint32_t accelerator_id,
+    ::mus::mojom::EventPtr event) {
   DCHECK(OwnsAccelerator(accelerator_id));
   accelerator_handler_->OnAccelerator(accelerator_id & kAcceleratorIdMask,
                                       std::move(event));
 }
 
 AcceleratorRegistrarImpl::~AcceleratorRegistrarImpl() {
   wm_app_->RemoveRootWindowsObserver(this);
   RemoveAllAccelerators();
   destroy_callback_.Run(this);
 }
@@ skipping 42 matching lines @@
   for (const auto& pair : accelerators_) {
     for (RootWindowController* root : wm_app_->GetRootControllers()) {
       root->window_manager()->window_manager_client()->RemoveAccelerator(
           pair.first);
     }
   }
   accelerators_.clear();
 }
 
 void AcceleratorRegistrarImpl::SetHandler(
-    mus::mojom::AcceleratorHandlerPtr handler) {
+    ::mus::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,
-    mus::mojom::EventMatcherPtr matcher,
+    ::mus::mojom::EventMatcherPtr matcher,
     const AddAcceleratorCallback& callback) {
   if (!accelerator_handler_ ||
       (accelerator_id & kAcceleratorIdMask) != accelerator_id) {
     // The |accelerator_id| is too large, and it can't be handled correctly.
     callback.Run(false);
     return;
   }
   uint32_t namespaced_accelerator_id = ComputeAcceleratorId(accelerator_id);
   accelerators_[namespaced_accelerator_id].event_matcher = matcher->Clone();
   accelerators_[namespaced_accelerator_id].callback = callback;
@@ skipping 18 matching lines @@
   if (accelerators_.empty() && !binding_.is_bound())
     delete this;
 }
 
 void AcceleratorRegistrarImpl::OnRootWindowControllerAdded(
     RootWindowController* controller) {
   for (const auto& pair : accelerators_)
     AddAcceleratorToRoot(controller, pair.first);
 }
 
-}  // namespace wm
-}  // namespace mash
+}  // namespace mus
+}  // namespace ash